diff --git a/assets/javascripts/bundle.c2b142ea.min.js b/assets/javascripts/bundle.c2b142ea.min.js
index 36c87fe94..3a9ab3cd4 100644
--- a/assets/javascripts/bundle.c2b142ea.min.js
+++ b/assets/javascripts/bundle.c2b142ea.min.js
@@ -1,4 +1,4 @@
 "use strict";(()=>{var xc=Object.create;var kn=Object.defineProperty,wc=Object.defineProperties,Ec=Object.getOwnPropertyDescriptor,Tc=Object.getOwnPropertyDescriptors,Sc=Object.getOwnPropertyNames,Dr=Object.getOwnPropertySymbols,Oc=Object.getPrototypeOf,An=Object.prototype.hasOwnProperty,Fo=Object.prototype.propertyIsEnumerable;var jo=(e,t,r)=>t in e?kn(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,H=(e,t)=>{for(var r in t||(t={}))An.call(t,r)&&jo(e,r,t[r]);if(Dr)for(var r of Dr(t))Fo.call(t,r)&&jo(e,r,t[r]);return e},He=(e,t)=>wc(e,Tc(t));var gr=(e,t)=>{var r={};for(var n in e)An.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&Dr)for(var n of Dr(e))t.indexOf(n)<0&&Fo.call(e,n)&&(r[n]=e[n]);return r};var Cn=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Lc=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Sc(t))!An.call(e,o)&&o!==r&&kn(e,o,{get:()=>t[o],enumerable:!(n=Ec(t,o))||n.enumerable});return e};var _r=(e,t,r)=>(r=e!=null?xc(Oc(e)):{},Lc(t||!e||!e.__esModule?kn(r,"default",{value:e,enumerable:!0}):r,e));var Uo=(e,t,r)=>new Promise((n,o)=>{var i=c=>{try{s(r.next(c))}catch(l){o(l)}},a=c=>{try{s(r.throw(c))}catch(l){o(l)}},s=c=>c.done?n(c.value):Promise.resolve(c.value).then(i,a);s((r=r.apply(e,t)).next())});var Do=Cn((Hn,No)=>{(function(e,t){typeof Hn=="object"&&typeof No!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(Hn,(function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(_){return!!(_&&_!==document&&_.nodeName!=="HTML"&&_.nodeName!=="BODY"&&"classList"in _&&"contains"in _.classList)}function c(_){var de=_.type,be=_.tagName;return!!(be==="INPUT"&&a[de]&&!_.readOnly||be==="TEXTAREA"&&!_.readOnly||_.isContentEditable)}function l(_){_.classList.contains("focus-visible")||(_.classList.add("focus-visible"),_.setAttribute("data-focus-visible-added",""))}function u(_){_.hasAttribute("data-focus-visible-added")&&(_.classList.remove("focus-visible"),_.removeAttribute("data-focus-visible-added"))}function p(_){_.metaKey||_.altKey||_.ctrlKey||(s(r.activeElement)&&l(r.activeElement),n=!0)}function d(_){n=!1}function m(_){s(_.target)&&(n||c(_.target))&&l(_.target)}function h(_){s(_.target)&&(_.target.classList.contains("focus-visible")||_.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(_.target))}function v(_){document.visibilityState==="hidden"&&(o&&(n=!0),x())}function x(){document.addEventListener("mousemove",E),document.addEventListener("mousedown",E),document.addEventListener("mouseup",E),document.addEventListener("pointermove",E),document.addEventListener("pointerdown",E),document.addEventListener("pointerup",E),document.addEventListener("touchmove",E),document.addEventListener("touchstart",E),document.addEventListener("touchend",E)}function w(){document.removeEventListener("mousemove",E),document.removeEventListener("mousedown",E),document.removeEventListener("mouseup",E),document.removeEventListener("pointermove",E),document.removeEventListener("pointerdown",E),document.removeEventListener("pointerup",E),document.removeEventListener("touchmove",E),document.removeEventListener("touchstart",E),document.removeEventListener("touchend",E)}function E(_){_.target.nodeName&&_.target.nodeName.toLowerCase()==="html"||(n=!1,w())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",d,!0),document.addEventListener("pointerdown",d,!0),document.addEventListener("touchstart",d,!0),document.addEventListener("visibilitychange",v,!0),x(),r.addEventListener("focus",m,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)}))});var So=Cn((M0,vs)=>{"use strict";var Gu=/["'&<>]/;vs.exports=Ju;function Ju(e){var t=""+e,r=Gu.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i<t.length;i++){switch(t.charCodeAt(i)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}a!==i&&(o+=t.substring(a,i)),a=i+1,o+=n}return a!==i?o+t.substring(a,i):o}});var Mo=Cn((jr,Lo)=>{(function(t,r){typeof jr=="object"&&typeof Lo=="object"?Lo.exports=r():typeof define=="function"&&define.amd?define([],r):typeof jr=="object"?jr.ClipboardJS=r():t.ClipboardJS=r()})(jr,function(){return(function(){var e={686:(function(n,o,i){"use strict";i.d(o,{default:function(){return vr}});var a=i(279),s=i.n(a),c=i(370),l=i.n(c),u=i(817),p=i.n(u);function d(B){try{return document.execCommand(B)}catch(C){return!1}}var m=function(C){var k=p()(C);return d("cut"),k},h=m;function v(B){var C=document.documentElement.getAttribute("dir")==="rtl",k=document.createElement("textarea");k.style.fontSize="12pt",k.style.border="0",k.style.padding="0",k.style.margin="0",k.style.position="absolute",k.style[C?"right":"left"]="-9999px";var D=window.pageYOffset||document.documentElement.scrollTop;return k.style.top="".concat(D,"px"),k.setAttribute("readonly",""),k.value=B,k}var x=function(C,k){var D=v(C);k.container.appendChild(D);var W=p()(D);return d("copy"),D.remove(),W},w=function(C){var k=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},D="";return typeof C=="string"?D=x(C,k):C instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(C==null?void 0:C.type)?D=x(C.value,k):(D=p()(C),d("copy")),D},E=w;function _(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?_=function(k){return typeof k}:_=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},_(B)}var de=function(){var C=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},k=C.action,D=k===void 0?"copy":k,W=C.container,Z=C.target,We=C.text;if(D!=="copy"&&D!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(Z!==void 0)if(Z&&_(Z)==="object"&&Z.nodeType===1){if(D==="copy"&&Z.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(D==="cut"&&(Z.hasAttribute("readonly")||Z.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(We)return E(We,{container:W});if(Z)return D==="cut"?h(Z):E(Z,{container:W})},be=de;function M(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?M=function(k){return typeof k}:M=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},M(B)}function O(B,C){if(!(B instanceof C))throw new TypeError("Cannot call a class as a function")}function N(B,C){for(var k=0;k<C.length;k++){var D=C[k];D.enumerable=D.enumerable||!1,D.configurable=!0,"value"in D&&(D.writable=!0),Object.defineProperty(B,D.key,D)}}function ee(B,C,k){return C&&N(B.prototype,C),k&&N(B,k),B}function le(B,C){if(typeof C!="function"&&C!==null)throw new TypeError("Super expression must either be null or a function");B.prototype=Object.create(C&&C.prototype,{constructor:{value:B,writable:!0,configurable:!0}}),C&&ce(B,C)}function ce(B,C){return ce=Object.setPrototypeOf||function(D,W){return D.__proto__=W,D},ce(B,C)}function Ne(B){var C=st();return function(){var D=tt(B),W;if(C){var Z=tt(this).constructor;W=Reflect.construct(D,arguments,Z)}else W=D.apply(this,arguments);return bt(this,W)}}function bt(B,C){return C&&(M(C)==="object"||typeof C=="function")?C:De(B)}function De(B){if(B===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return B}function st(){if(typeof Reflect=="undefined"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(B){return!1}}function tt(B){return tt=Object.setPrototypeOf?Object.getPrototypeOf:function(k){return k.__proto__||Object.getPrototypeOf(k)},tt(B)}function Yt(B,C){var k="data-clipboard-".concat(B);if(C.hasAttribute(k))return C.getAttribute(k)}var Mt=(function(B){le(k,B);var C=Ne(k);function k(D,W){var Z;return O(this,k),Z=C.call(this),Z.resolveOptions(W),Z.listenClick(D),Z}return ee(k,[{key:"resolveOptions",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof W.action=="function"?W.action:this.defaultAction,this.target=typeof W.target=="function"?W.target:this.defaultTarget,this.text=typeof W.text=="function"?W.text:this.defaultText,this.container=M(W.container)==="object"?W.container:document.body}},{key:"listenClick",value:function(W){var Z=this;this.listener=l()(W,"click",function(We){return Z.onClick(We)})}},{key:"onClick",value:function(W){var Z=W.delegateTarget||W.currentTarget,We=this.action(Z)||"copy",Gt=be({action:We,container:this.container,target:this.target(Z),text:this.text(Z)});this.emit(Gt?"success":"error",{action:We,text:Gt,trigger:Z,clearSelection:function(){Z&&Z.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(W){return Yt("action",W)}},{key:"defaultTarget",value:function(W){var Z=Yt("target",W);if(Z)return document.querySelector(Z)}},{key:"defaultText",value:function(W){return Yt("text",W)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(W){var Z=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return E(W,Z)}},{key:"cut",value:function(W){return h(W)}},{key:"isSupported",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],Z=typeof W=="string"?[W]:W,We=!!document.queryCommandSupported;return Z.forEach(function(Gt){We=We&&!!document.queryCommandSupported(Gt)}),We}}]),k})(s()),vr=Mt}),828:(function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,c){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(c))return s;s=s.parentNode}}n.exports=a}),438:(function(n,o,i){var a=i(828);function s(u,p,d,m,h){var v=l.apply(this,arguments);return u.addEventListener(d,v,h),{destroy:function(){u.removeEventListener(d,v,h)}}}function c(u,p,d,m,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof d=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,d,m,h)}))}function l(u,p,d,m){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&m.call(u,h)}}n.exports=c}),879:(function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}}),370:(function(n,o,i){var a=i(879),s=i(438);function c(d,m,h){if(!d&&!m&&!h)throw new Error("Missing required arguments");if(!a.string(m))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(d))return l(d,m,h);if(a.nodeList(d))return u(d,m,h);if(a.string(d))return p(d,m,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function l(d,m,h){return d.addEventListener(m,h),{destroy:function(){d.removeEventListener(m,h)}}}function u(d,m,h){return Array.prototype.forEach.call(d,function(v){v.addEventListener(m,h)}),{destroy:function(){Array.prototype.forEach.call(d,function(v){v.removeEventListener(m,h)})}}}function p(d,m,h){return s(document.body,d,m,h)}n.exports=c}),817:(function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var c=window.getSelection(),l=document.createRange();l.selectNodeContents(i),c.removeAllRanges(),c.addRange(l),a=c.toString()}return a}n.exports=o}),279:(function(n){function o(){}o.prototype={on:function(i,a,s){var c=this.e||(this.e={});return(c[i]||(c[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var c=this;function l(){c.off(i,l),a.apply(s,arguments)}return l._=a,this.on(i,l,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),c=0,l=s.length;for(c;c<l;c++)s[c].fn.apply(s[c].ctx,a);return this},off:function(i,a){var s=this.e||(this.e={}),c=s[i],l=[];if(c&&a)for(var u=0,p=c.length;u<p;u++)c[u].fn!==a&&c[u].fn._!==a&&l.push(c[u]);return l.length?s[i]=l:delete s[i],this}},n.exports=o,n.exports.TinyEmitter=o})},t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}return(function(){r.n=function(n){var o=n&&n.__esModule?function(){return n.default}:function(){return n};return r.d(o,{a:o}),o}})(),(function(){r.d=function(n,o){for(var i in o)r.o(o,i)&&!r.o(n,i)&&Object.defineProperty(n,i,{enumerable:!0,get:o[i]})}})(),(function(){r.o=function(n,o){return Object.prototype.hasOwnProperty.call(n,o)}})(),r(686)})().default})});var LM=_r(Do());var $n=function(e,t){return $n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,n){r.__proto__=n}||function(r,n){for(var o in n)Object.prototype.hasOwnProperty.call(n,o)&&(r[o]=n[o])},$n(e,t)};function ue(e,t){if(typeof t!="function"&&t!==null)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");$n(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function Wo(e,t,r,n){function o(i){return i instanceof r?i:new r(function(a){a(i)})}return new(r||(r=Promise))(function(i,a){function s(u){try{l(n.next(u))}catch(p){a(p)}}function c(u){try{l(n.throw(u))}catch(p){a(p)}}function l(u){u.done?i(u.value):o(u.value).then(s,c)}l((n=n.apply(e,t||[])).next())})}function Wr(e,t){var r={label:0,sent:function(){if(i[0]&1)throw i[1];return i[1]},trys:[],ops:[]},n,o,i,a=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return a.next=s(0),a.throw=s(1),a.return=s(2),typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(l){return function(u){return c([l,u])}}function c(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(r=0)),r;)try{if(n=1,o&&(i=l[0]&2?o.return:l[0]?o.throw||((i=o.return)&&i.call(o),0):o.next)&&!(i=i.call(o,l[1])).done)return i;switch(o=0,i&&(l=[l[0]&2,i.value]),l[0]){case 0:case 1:i=l;break;case 4:return r.label++,{value:l[1],done:!1};case 5:r.label++,o=l[1],l=[0];continue;case 7:l=r.ops.pop(),r.trys.pop();continue;default:if(i=r.trys,!(i=i.length>0&&i[i.length-1])&&(l[0]===6||l[0]===2)){r=0;continue}if(l[0]===3&&(!i||l[1]>i[0]&&l[1]<i[3])){r.label=l[1];break}if(l[0]===6&&r.label<i[1]){r.label=i[1],i=l;break}if(i&&r.label<i[2]){r.label=i[2],r.ops.push(l);break}i[2]&&r.ops.pop(),r.trys.pop();continue}l=t.call(e,r)}catch(u){l=[6,u],o=0}finally{n=i=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}function $e(e){var t=typeof Symbol=="function"&&Symbol.iterator,r=t&&e[t],n=0;if(r)return r.call(e);if(e&&typeof e.length=="number")return{next:function(){return e&&n>=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function te(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function ne(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n<o;n++)(i||!(n in t))&&(i||(i=Array.prototype.slice.call(t,0,n)),i[n]=t[n]);return e.concat(i||Array.prototype.slice.call(t))}function kt(e){return this instanceof kt?(this.v=e,this):new kt(e)}function Vo(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),o,i=[];return o=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",a),o[Symbol.asyncIterator]=function(){return this},o;function a(m){return function(h){return Promise.resolve(h).then(m,p)}}function s(m,h){n[m]&&(o[m]=function(v){return new Promise(function(x,w){i.push([m,v,x,w])>1||c(m,v)})},h&&(o[m]=h(o[m])))}function c(m,h){try{l(n[m](h))}catch(v){d(i[0][3],v)}}function l(m){m.value instanceof kt?Promise.resolve(m.value.v).then(u,p):d(i[0][2],m)}function u(m){c("next",m)}function p(m){c("throw",m)}function d(m,h){m(h),i.shift(),i.length&&c(i[0][0],i[0][1])}}function zo(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof $e=="function"?$e(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,c){a=e[i](a),o(s,c,a.done,a.value)})}}function o(i,a,s,c){Promise.resolve(c).then(function(l){i({value:l,done:s})},a)}}function F(e){return typeof e=="function"}function Jt(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var Vr=Jt(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription:
 `+r.map(function(n,o){return o+1+") "+n.toString()}).join(`
   `):"",this.name="UnsubscriptionError",this.errors=r}});function ct(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var rt=(function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=$e(a),c=s.next();!c.done;c=s.next()){var l=c.value;l.remove(this)}}catch(v){t={error:v}}finally{try{c&&!c.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(F(u))try{u()}catch(v){i=v instanceof Vr?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var d=$e(p),m=d.next();!m.done;m=d.next()){var h=m.value;try{qo(h)}catch(v){i=i!=null?i:[],v instanceof Vr?i=ne(ne([],te(i)),te(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{m&&!m.done&&(o=d.return)&&o.call(d)}finally{if(n)throw n.error}}}if(i)throw new Vr(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)qo(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&ct(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&ct(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=(function(){var t=new e;return t.closed=!0,t})(),e})();var Pn=rt.EMPTY;function zr(e){return e instanceof rt||e&&"closed"in e&&F(e.remove)&&F(e.add)&&F(e.unsubscribe)}function qo(e){F(e)?e():e.unsubscribe()}var Je={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var Xt={setTimeout:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Xt.delegate;return o!=null&&o.setTimeout?o.setTimeout.apply(o,ne([e,t],te(r))):setTimeout.apply(void 0,ne([e,t],te(r)))},clearTimeout:function(e){var t=Xt.delegate;return((t==null?void 0:t.clearTimeout)||clearTimeout)(e)},delegate:void 0};function qr(e){Xt.setTimeout(function(){var t=Je.onUnhandledError;if(t)t(e);else throw e})}function Pe(){}var Ko=(function(){return In("C",void 0,void 0)})();function Bo(e){return In("E",void 0,e)}function Yo(e){return In("N",e,void 0)}function In(e,t,r){return{kind:e,value:t,error:r}}var At=null;function Zt(e){if(Je.useDeprecatedSynchronousErrorHandling){var t=!At;if(t&&(At={errorThrown:!1,error:null}),e(),t){var r=At,n=r.errorThrown,o=r.error;if(At=null,n)throw o}}else e()}function Go(e){Je.useDeprecatedSynchronousErrorHandling&&At&&(At.errorThrown=!0,At.error=e)}var yr=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n.isStopped=!1,r?(n.destination=r,zr(r)&&r.add(n)):n.destination=Cc,n}return t.create=function(r,n,o){return new Ct(r,n,o)},t.prototype.next=function(r){this.isStopped?jn(Yo(r),this):this._next(r)},t.prototype.error=function(r){this.isStopped?jn(Bo(r),this):(this.isStopped=!0,this._error(r))},t.prototype.complete=function(){this.isStopped?jn(Ko,this):(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.closed||(this.isStopped=!0,e.prototype.unsubscribe.call(this),this.destination=null)},t.prototype._next=function(r){this.destination.next(r)},t.prototype._error=function(r){try{this.destination.error(r)}finally{this.unsubscribe()}},t.prototype._complete=function(){try{this.destination.complete()}finally{this.unsubscribe()}},t})(rt);var Mc=Function.prototype.bind;function Rn(e,t){return Mc.call(e,t)}var kc=(function(){function e(t){this.partialObserver=t}return e.prototype.next=function(t){var r=this.partialObserver;if(r.next)try{r.next(t)}catch(n){Kr(n)}},e.prototype.error=function(t){var r=this.partialObserver;if(r.error)try{r.error(t)}catch(n){Kr(n)}else Kr(t)},e.prototype.complete=function(){var t=this.partialObserver;if(t.complete)try{t.complete()}catch(r){Kr(r)}},e})(),Ct=(function(e){ue(t,e);function t(r,n,o){var i=e.call(this)||this,a;if(F(r)||!r)a={next:r!=null?r:void 0,error:n!=null?n:void 0,complete:o!=null?o:void 0};else{var s;i&&Je.useDeprecatedNextContext?(s=Object.create(r),s.unsubscribe=function(){return i.unsubscribe()},a={next:r.next&&Rn(r.next,s),error:r.error&&Rn(r.error,s),complete:r.complete&&Rn(r.complete,s)}):a=r}return i.destination=new kc(a),i}return t})(yr);function Kr(e){Je.useDeprecatedSynchronousErrorHandling?Go(e):qr(e)}function Ac(e){throw e}function jn(e,t){var r=Je.onStoppedNotification;r&&Xt.setTimeout(function(){return r(e,t)})}var Cc={closed:!0,next:Pe,error:Ac,complete:Pe};var Qt=(function(){return typeof Symbol=="function"&&Symbol.observable||"@@observable"})();function Oe(e){return e}function Jo(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Fn(e)}function Fn(e){return e.length===0?Oe:e.length===1?e[0]:function(r){return e.reduce(function(n,o){return o(n)},r)}}var U=(function(){function e(t){t&&(this._subscribe=t)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(t,r,n){var o=this,i=$c(t)?t:new Ct(t,r,n);return Zt(function(){var a=o,s=a.operator,c=a.source;i.add(s?s.call(i,c):c?o._subscribe(i):o._trySubscribe(i))}),i},e.prototype._trySubscribe=function(t){try{return this._subscribe(t)}catch(r){t.error(r)}},e.prototype.forEach=function(t,r){var n=this;return r=Xo(r),new r(function(o,i){var a=new Ct({next:function(s){try{t(s)}catch(c){i(c),a.unsubscribe()}},error:i,complete:o});n.subscribe(a)})},e.prototype._subscribe=function(t){var r;return(r=this.source)===null||r===void 0?void 0:r.subscribe(t)},e.prototype[Qt]=function(){return this},e.prototype.pipe=function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return Fn(t)(this)},e.prototype.toPromise=function(t){var r=this;return t=Xo(t),new t(function(n,o){var i;r.subscribe(function(a){return i=a},function(a){return o(a)},function(){return n(i)})})},e.create=function(t){return new e(t)},e})();function Xo(e){var t;return(t=e!=null?e:Je.Promise)!==null&&t!==void 0?t:Promise}function Hc(e){return e&&F(e.next)&&F(e.error)&&F(e.complete)}function $c(e){return e&&e instanceof yr||Hc(e)&&zr(e)}function Pc(e){return F(e==null?void 0:e.lift)}function S(e){return function(t){if(Pc(t))return t.lift(function(r){try{return e(r,this)}catch(n){this.error(n)}});throw new TypeError("Unable to lift unknown Observable type")}}function T(e,t,r,n,o){return new Ic(e,t,r,n,o)}var Ic=(function(e){ue(t,e);function t(r,n,o,i,a,s){var c=e.call(this,r)||this;return c.onFinalize=a,c.shouldUnsubscribe=s,c._next=n?function(l){try{n(l)}catch(u){r.error(u)}}:e.prototype._next,c._error=i?function(l){try{i(l)}catch(u){r.error(u)}finally{this.unsubscribe()}}:e.prototype._error,c._complete=o?function(){try{o()}catch(l){r.error(l)}finally{this.unsubscribe()}}:e.prototype._complete,c}return t.prototype.unsubscribe=function(){var r;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){var n=this.closed;e.prototype.unsubscribe.call(this),!n&&((r=this.onFinalize)===null||r===void 0||r.call(this))}},t})(yr);var er={schedule:function(e){var t=requestAnimationFrame,r=cancelAnimationFrame,n=er.delegate;n&&(t=n.requestAnimationFrame,r=n.cancelAnimationFrame);var o=t(function(i){r=void 0,e(i)});return new rt(function(){return r==null?void 0:r(o)})},requestAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.requestAnimationFrame)||requestAnimationFrame).apply(void 0,ne([],te(e)))},cancelAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.cancelAnimationFrame)||cancelAnimationFrame).apply(void 0,ne([],te(e)))},delegate:void 0};var Zo=Jt(function(e){return function(){e(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}});var I=(function(e){ue(t,e);function t(){var r=e.call(this)||this;return r.closed=!1,r.currentObservers=null,r.observers=[],r.isStopped=!1,r.hasError=!1,r.thrownError=null,r}return t.prototype.lift=function(r){var n=new Qo(this,this);return n.operator=r,n},t.prototype._throwIfClosed=function(){if(this.closed)throw new Zo},t.prototype.next=function(r){var n=this;Zt(function(){var o,i;if(n._throwIfClosed(),!n.isStopped){n.currentObservers||(n.currentObservers=Array.from(n.observers));try{for(var a=$e(n.currentObservers),s=a.next();!s.done;s=a.next()){var c=s.value;c.next(r)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}}})},t.prototype.error=function(r){var n=this;Zt(function(){if(n._throwIfClosed(),!n.isStopped){n.hasError=n.isStopped=!0,n.thrownError=r;for(var o=n.observers;o.length;)o.shift().error(r)}})},t.prototype.complete=function(){var r=this;Zt(function(){if(r._throwIfClosed(),!r.isStopped){r.isStopped=!0;for(var n=r.observers;n.length;)n.shift().complete()}})},t.prototype.unsubscribe=function(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null},Object.defineProperty(t.prototype,"observed",{get:function(){var r;return((r=this.observers)===null||r===void 0?void 0:r.length)>0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Pn:(this.currentObservers=null,s.push(r),new rt(function(){n.currentObservers=null,ct(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new Qo(r,n)},t})(U);var Qo=(function(e){ue(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Pn},t})(I);var Un=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n._value=r,n}return Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!1,configurable:!0}),t.prototype._subscribe=function(r){var n=e.prototype._subscribe.call(this,r);return!n.closed&&r.next(this._value),n},t.prototype.getValue=function(){var r=this,n=r.hasError,o=r.thrownError,i=r._value;if(n)throw o;return this._throwIfClosed(),i},t.prototype.next=function(r){e.prototype.next.call(this,this._value=r)},t})(I);var xr={now:function(){return(xr.delegate||Date).now()},delegate:void 0};var wr=(function(e){ue(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=xr);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,c=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+c)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),c=0;c<s.length&&!r.closed;c+=i?1:2)r.next(s[c]);return this._checkFinalizedStatuses(r),n},t.prototype._trimBuffer=function(){var r=this,n=r._bufferSize,o=r._timestampProvider,i=r._buffer,a=r._infiniteTimeWindow,s=(a?1:2)*n;if(n<1/0&&s<i.length&&i.splice(0,i.length-s),!a){for(var c=o.now(),l=0,u=1;u<i.length&&i[u]<=c;u+=2)l=u;l&&i.splice(0,l+1)}},t})(I);var ei=(function(e){ue(t,e);function t(r,n){return e.call(this)||this}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),this},t})(rt);var Er={setInterval:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Er.delegate;return o!=null&&o.setInterval?o.setInterval.apply(o,ne([e,t],te(r))):setInterval.apply(void 0,ne([e,t],te(r)))},clearInterval:function(e){var t=Er.delegate;return((t==null?void 0:t.clearInterval)||clearInterval)(e)},delegate:void 0};var tr=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o.pending=!1,o}return t.prototype.schedule=function(r,n){var o;if(n===void 0&&(n=0),this.closed)return this;this.state=r;var i=this.id,a=this.scheduler;return i!=null&&(this.id=this.recycleAsyncId(a,i,n)),this.pending=!0,this.delay=n,this.id=(o=this.id)!==null&&o!==void 0?o:this.requestAsyncId(a,this.id,n),this},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),Er.setInterval(r.flush.bind(r,this),o)},t.prototype.recycleAsyncId=function(r,n,o){if(o===void 0&&(o=0),o!=null&&this.delay===o&&this.pending===!1)return n;n!=null&&Er.clearInterval(n)},t.prototype.execute=function(r,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;var o=this._execute(r,n);if(o)return o;this.pending===!1&&this.id!=null&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))},t.prototype._execute=function(r,n){var o=!1,i;try{this.work(r)}catch(a){o=!0,i=a||new Error("Scheduled action threw falsy error")}if(o)return this.unsubscribe(),i},t.prototype.unsubscribe=function(){if(!this.closed){var r=this,n=r.id,o=r.scheduler,i=o.actions;this.work=this.state=this.scheduler=null,this.pending=!1,ct(i,this),n!=null&&(this.id=this.recycleAsyncId(o,n,null)),this.delay=null,e.prototype.unsubscribe.call(this)}},t})(ei);var Nn=(function(){function e(t,r){r===void 0&&(r=e.now),this.schedulerActionCtor=t,this.now=r}return e.prototype.schedule=function(t,r,n){return r===void 0&&(r=0),new this.schedulerActionCtor(this,t).schedule(n,r)},e.now=xr.now,e})();var rr=(function(e){ue(t,e);function t(r,n){n===void 0&&(n=Nn.now);var o=e.call(this,r,n)||this;return o.actions=[],o._active=!1,o}return t.prototype.flush=function(r){var n=this.actions;if(this._active){n.push(r);return}var o;this._active=!0;do if(o=r.execute(r.state,r.delay))break;while(r=n.shift());if(this._active=!1,o){for(;r=n.shift();)r.unsubscribe();throw o}},t})(Nn);var ge=new rr(tr),Dn=ge;var ti=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),n>0?e.prototype.schedule.call(this,r,n):(this.delay=n,this.state=r,this.scheduler.flush(this),this)},t.prototype.execute=function(r,n){return n>0||this.closed?e.prototype.execute.call(this,r,n):this._execute(r,n)},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!=null&&o>0||o==null&&this.delay>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.flush(this),0)},t})(tr);var ri=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t})(rr);var Wn=new ri(ti);var ni=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!==null&&o>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=er.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&n===r._scheduled&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(er.cancelAnimationFrame(n),r._scheduled=void 0)},t})(tr);var oi=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n;r?n=r.id:(n=this._scheduled,this._scheduled=void 0);var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t})(rr);var je=new oi(ni);var y=new U(function(e){return e.complete()});function Br(e){return e&&F(e.schedule)}function Vn(e){return e[e.length-1]}function _t(e){return F(Vn(e))?e.pop():void 0}function qe(e){return Br(Vn(e))?e.pop():void 0}function Yr(e,t){return typeof Vn(e)=="number"?e.pop():t}var nr=(function(e){return e&&typeof e.length=="number"&&typeof e!="function"});function Gr(e){return F(e==null?void 0:e.then)}function Jr(e){return F(e[Qt])}function Xr(e){return Symbol.asyncIterator&&F(e==null?void 0:e[Symbol.asyncIterator])}function Zr(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Rc(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qr=Rc();function en(e){return F(e==null?void 0:e[Qr])}function tn(e){return Vo(this,arguments,function(){var r,n,o,i;return Wr(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,kt(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,kt(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,kt(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function rn(e){return F(e==null?void 0:e.getReader)}function q(e){if(e instanceof U)return e;if(e!=null){if(Jr(e))return jc(e);if(nr(e))return Fc(e);if(Gr(e))return Uc(e);if(Xr(e))return ii(e);if(en(e))return Nc(e);if(rn(e))return Dc(e)}throw Zr(e)}function jc(e){return new U(function(t){var r=e[Qt]();if(F(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Fc(e){return new U(function(t){for(var r=0;r<e.length&&!t.closed;r++)t.next(e[r]);t.complete()})}function Uc(e){return new U(function(t){e.then(function(r){t.closed||(t.next(r),t.complete())},function(r){return t.error(r)}).then(null,qr)})}function Nc(e){return new U(function(t){var r,n;try{for(var o=$e(e),i=o.next();!i.done;i=o.next()){var a=i.value;if(t.next(a),t.closed)return}}catch(s){r={error:s}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}t.complete()})}function ii(e){return new U(function(t){Wc(e,t).catch(function(r){return t.error(r)})})}function Dc(e){return ii(tn(e))}function Wc(e,t){var r,n,o,i;return Wo(this,void 0,void 0,function(){var a,s;return Wr(this,function(c){switch(c.label){case 0:c.trys.push([0,5,6,11]),r=zo(e),c.label=1;case 1:return[4,r.next()];case 2:if(n=c.sent(),!!n.done)return[3,4];if(a=n.value,t.next(a),t.closed)return[2];c.label=3;case 3:return[3,1];case 4:return[3,11];case 5:return s=c.sent(),o={error:s},[3,11];case 6:return c.trys.push([6,,9,10]),n&&!n.done&&(i=r.return)?[4,i.call(r)]:[3,8];case 7:c.sent(),c.label=8;case 8:return[3,10];case 9:if(o)throw o.error;return[7];case 10:return[7];case 11:return t.complete(),[2]}})})}function Fe(e,t,r,n,o){n===void 0&&(n=0),o===void 0&&(o=!1);var i=t.schedule(function(){r(),o?e.add(this.schedule(null,n)):this.unsubscribe()},n);if(e.add(i),!o)return i}function Ie(e,t){return t===void 0&&(t=0),S(function(r,n){r.subscribe(T(n,function(o){return Fe(n,e,function(){return n.next(o)},t)},function(){return Fe(n,e,function(){return n.complete()},t)},function(o){return Fe(n,e,function(){return n.error(o)},t)}))})}function Ht(e,t){return t===void 0&&(t=0),S(function(r,n){n.add(e.schedule(function(){return r.subscribe(n)},t))})}function ai(e,t){return q(e).pipe(Ht(t),Ie(t))}function si(e,t){return q(e).pipe(Ht(t),Ie(t))}function ci(e,t){return new U(function(r){var n=0;return t.schedule(function(){n===e.length?r.complete():(r.next(e[n++]),r.closed||this.schedule())})})}function li(e,t){return new U(function(r){var n;return Fe(r,t,function(){n=e[Qr](),Fe(r,t,function(){var o,i,a;try{o=n.next(),i=o.value,a=o.done}catch(s){r.error(s);return}a?r.complete():r.next(i)},0,!0)}),function(){return F(n==null?void 0:n.return)&&n.return()}})}function nn(e,t){if(!e)throw new Error("Iterable cannot be null");return new U(function(r){Fe(r,t,function(){var n=e[Symbol.asyncIterator]();Fe(r,t,function(){n.next().then(function(o){o.done?r.complete():r.next(o.value)})},0,!0)})})}function ui(e,t){return nn(tn(e),t)}function pi(e,t){if(e!=null){if(Jr(e))return ai(e,t);if(nr(e))return ci(e,t);if(Gr(e))return si(e,t);if(Xr(e))return nn(e,t);if(en(e))return li(e,t);if(rn(e))return ui(e,t)}throw Zr(e)}function me(e,t){return t?pi(e,t):q(e)}function Y(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return me(e,r)}function zn(e,t){var r=F(e)?e:function(){return e},n=function(o){return o.error(r())};return new U(t?function(o){return t.schedule(n,0,o)}:n)}var on=Jt(function(e){return function(){e(this),this.name="EmptyError",this.message="no elements in sequence"}});function fi(e){return e instanceof Date&&!isNaN(e)}function f(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){n.next(e.call(t,i,o++))}))})}var Vc=Array.isArray;function zc(e,t){return Vc(t)?e.apply(void 0,ne([],te(t))):e(t)}function yt(e){return f(function(t){return zc(e,t)})}var qc=Array.isArray,Kc=Object.getPrototypeOf,Bc=Object.prototype,Yc=Object.keys;function mi(e){if(e.length===1){var t=e[0];if(qc(t))return{args:t,keys:null};if(Gc(t)){var r=Yc(t);return{args:r.map(function(n){return t[n]}),keys:r}}}return{args:e,keys:null}}function Gc(e){return e&&typeof e=="object"&&Kc(e)===Bc}function di(e,t){return e.reduce(function(r,n,o){return r[n]=t[o],r},{})}function re(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=_t(e),o=mi(e),i=o.args,a=o.keys;if(i.length===0)return me([],r);var s=new U(qn(i,r,a?function(c){return di(a,c)}:Oe));return n?s.pipe(yt(n)):s}function qn(e,t,r){return r===void 0&&(r=Oe),function(n){hi(t,function(){for(var o=e.length,i=new Array(o),a=o,s=o,c=function(u){hi(t,function(){var p=me(e[u],t),d=!1;p.subscribe(T(n,function(m){i[u]=m,d||(d=!0,s--),s||n.next(r(i.slice()))},function(){--a||n.complete()}))},n)},l=0;l<o;l++)c(l)},n)}}function hi(e,t,r){e?Fe(r,e,t):t()}function vi(e,t,r,n,o,i,a,s){var c=[],l=0,u=0,p=!1,d=function(){p&&!c.length&&!l&&t.complete()},m=function(v){return l<n?h(v):c.push(v)},h=function(v){i&&t.next(v),l++;var x=!1;q(r(v,u++)).subscribe(T(t,function(w){o==null||o(w),i?m(w):t.next(w)},function(){x=!0},void 0,function(){if(x)try{l--;for(var w=function(){var E=c.shift();a?Fe(t,a,function(){return h(E)}):h(E)};c.length&&l<n;)w();d()}catch(E){t.error(E)}}))};return e.subscribe(T(t,m,function(){p=!0,d()})),function(){s==null||s()}}function oe(e,t,r){return r===void 0&&(r=1/0),F(t)?oe(function(n,o){return f(function(i,a){return t(n,i,o,a)})(q(e(n,o)))},r):(typeof t=="number"&&(r=t),S(function(n,o){return vi(n,o,e,r)}))}function or(e){return e===void 0&&(e=1/0),oe(Oe,e)}function bi(){return or(1)}function nt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return bi()(me(e,qe(e)))}function j(e){return new U(function(t){q(e()).subscribe(t)})}var Jc=["addListener","removeListener"],Xc=["addEventListener","removeEventListener"],Zc=["on","off"];function b(e,t,r,n){if(F(r)&&(n=r,r=void 0),n)return b(e,t,r).pipe(yt(n));var o=te(tl(e)?Xc.map(function(s){return function(c){return e[s](t,c,r)}}):Qc(e)?Jc.map(gi(e,t)):el(e)?Zc.map(gi(e,t)):[],2),i=o[0],a=o[1];if(!i&&nr(e))return oe(function(s){return b(s,t,r)})(q(e));if(!i)throw new TypeError("Invalid event target");return new U(function(s){var c=function(){for(var l=[],u=0;u<arguments.length;u++)l[u]=arguments[u];return s.next(1<l.length?l:l[0])};return i(c),function(){return a(c)}})}function gi(e,t){return function(r){return function(n){return e[r](t,n)}}}function Qc(e){return F(e.addListener)&&F(e.removeListener)}function el(e){return F(e.on)&&F(e.off)}function tl(e){return F(e.addEventListener)&&F(e.removeEventListener)}function an(e,t,r){return r?an(e,t).pipe(yt(r)):new U(function(n){var o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];return n.next(a.length===1?a[0]:a)},i=e(o);return F(t)?function(){return t(o,i)}:void 0})}function Ve(e,t,r){e===void 0&&(e=0),r===void 0&&(r=Dn);var n=-1;return t!=null&&(Br(t)?r=t:n=t),new U(function(o){var i=fi(e)?+e-r.now():e;i<0&&(i=0);var a=0;return r.schedule(function(){o.closed||(o.next(a++),0<=n?this.schedule(void 0,n):o.complete())},i)})}function R(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0),o=e;return o.length?o.length===1?q(o[0]):or(n)(me(o,r)):y}var Ke=new U(Pe);var rl=Array.isArray;function sn(e){return e.length===1&&rl(e[0])?e[0]:e}function L(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){return e.call(t,i,o++)&&n.next(i)}))})}function $t(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e),n=sn(e);return n.length?new U(function(o){var i=n.map(function(){return[]}),a=n.map(function(){return!1});o.add(function(){i=a=null});for(var s=function(l){q(n[l]).subscribe(T(o,function(u){if(i[l].push(u),i.every(function(d){return d.length})){var p=i.map(function(d){return d.shift()});o.next(r?r.apply(void 0,ne([],te(p))):p),i.some(function(d,m){return!d.length&&a[m]})&&o.complete()}},function(){a[l]=!0,!i[l].length&&o.complete()}))},c=0;!o.closed&&c<n.length;c++)s(c);return function(){i=a=null}}):y}function _i(e){return S(function(t,r){var n=!1,o=null,i=null,a=!1,s=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var l=o;o=null,r.next(l)}a&&r.complete()},c=function(){i=null,a&&r.complete()};t.subscribe(T(r,function(l){n=!0,o=l,i||q(e(l)).subscribe(i=T(r,s,c))},function(){a=!0,(!n||!i||i.closed)&&r.complete()}))})}function Xe(e,t){return t===void 0&&(t=ge),_i(function(){return Ve(e,t)})}function Pt(e,t){return t===void 0&&(t=null),t=t!=null?t:e,S(function(r,n){var o=[],i=0;r.subscribe(T(n,function(a){var s,c,l,u,p=null;i++%t===0&&o.push([]);try{for(var d=$e(o),m=d.next();!m.done;m=d.next()){var h=m.value;h.push(a),e<=h.length&&(p=p!=null?p:[],p.push(h))}}catch(w){s={error:w}}finally{try{m&&!m.done&&(c=d.return)&&c.call(d)}finally{if(s)throw s.error}}if(p)try{for(var v=$e(p),x=v.next();!x.done;x=v.next()){var h=x.value;ct(o,h),n.next(h)}}catch(w){l={error:w}}finally{try{x&&!x.done&&(u=v.return)&&u.call(v)}finally{if(l)throw l.error}}},function(){var a,s;try{for(var c=$e(o),l=c.next();!l.done;l=c.next()){var u=l.value;n.next(u)}}catch(p){a={error:p}}finally{try{l&&!l.done&&(s=c.return)&&s.call(c)}finally{if(a)throw a.error}}n.complete()},void 0,function(){o=null}))})}function _e(e){return S(function(t,r){var n=null,o=!1,i;n=t.subscribe(T(r,void 0,void 0,function(a){i=q(e(a,_e(e)(t))),n?(n.unsubscribe(),n=null,i.subscribe(r)):o=!0})),o&&(n.unsubscribe(),n=null,i.subscribe(r))})}function yi(e,t,r,n,o){return function(i,a){var s=r,c=t,l=0;i.subscribe(T(a,function(u){var p=l++;c=s?e(c,u,p):(s=!0,u),n&&a.next(c)},o&&(function(){s&&a.next(c),a.complete()})))}}function Kn(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return r?Jo(Kn.apply(void 0,ne([],te(e))),yt(r)):S(function(n,o){qn(ne([n],te(sn(e))))(o)})}function Ze(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Kn.apply(void 0,ne([],te(e)))}function Tr(e){return S(function(t,r){var n=!1,o=null,i=null,a=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var s=o;o=null,r.next(s)}};t.subscribe(T(r,function(s){i==null||i.unsubscribe(),n=!0,o=s,i=T(r,a,Pe),q(e(s)).subscribe(i)},function(){a(),r.complete()},void 0,function(){o=i=null}))})}function Be(e,t){return t===void 0&&(t=ge),S(function(r,n){var o=null,i=null,a=null,s=function(){if(o){o.unsubscribe(),o=null;var l=i;i=null,n.next(l)}};function c(){var l=a+e,u=t.now();if(u<l){o=this.schedule(void 0,l-u),n.add(o);return}s()}r.subscribe(T(n,function(l){i=l,a=t.now(),o||(o=t.schedule(c,e),n.add(o))},function(){s(),n.complete()},void 0,function(){i=o=null}))})}function ot(e){return S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){n||r.next(e),r.complete()}))})}function Me(e){return e<=0?function(){return y}:S(function(t,r){var n=0;t.subscribe(T(r,function(o){++n<=e&&(r.next(o),e<=n&&r.complete())}))})}function he(){return S(function(e,t){e.subscribe(T(t,Pe))})}function xi(e){return f(function(){return e})}function Bn(e,t){return t?function(r){return nt(t.pipe(Me(1),he()),r.pipe(Bn(e)))}:oe(function(r,n){return q(e(r,n)).pipe(Me(1),xi(r))})}function It(e,t){t===void 0&&(t=ge);var r=Ve(e,t);return Bn(function(){return r})}function Yn(e,t){return S(function(r,n){var o=new Set;r.subscribe(T(n,function(i){var a=e?e(i):i;o.has(a)||(o.add(a),n.next(i))})),t&&q(t).subscribe(T(n,function(){return o.clear()},Pe))})}function ie(e,t){return t===void 0&&(t=Oe),e=e!=null?e:nl,S(function(r,n){var o,i=!0;r.subscribe(T(n,function(a){var s=t(a);(i||!e(o,s))&&(i=!1,o=s,n.next(a))}))})}function nl(e,t){return e===t}function fe(e,t){return ie(function(r,n){return t?t(r[e],n[e]):r[e]===n[e]})}function wi(e){return e===void 0&&(e=ol),S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){return n?r.complete():r.error(e())}))})}function ol(){return new on}function ye(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return function(r){return nt(r,Y.apply(void 0,ne([],te(e))))}}function cn(e,t){return t?function(r){return r.pipe(cn(function(n,o){return q(e(n,o)).pipe(f(function(i,a){return t(n,i,o,a)}))}))}:S(function(r,n){var o=0,i=null,a=!1;r.subscribe(T(n,function(s){i||(i=T(n,void 0,function(){i=null,a&&n.complete()}),q(e(s,o++)).subscribe(i))},function(){a=!0,!i&&n.complete()}))})}function V(e){return S(function(t,r){try{t.subscribe(r)}finally{r.add(e)}})}function Sr(e,t){var r=arguments.length>=2;return function(n){return n.pipe(e?L(function(o,i){return e(o,i,n)}):Oe,Me(1),r?ot(t):wi(function(){return new on}))}}function Gn(e){return e<=0?function(){return y}:S(function(t,r){var n=[];t.subscribe(T(r,function(o){n.push(o),e<n.length&&n.shift()},function(){var o,i;try{for(var a=$e(n),s=a.next();!s.done;s=a.next()){var c=s.value;r.next(c)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}r.complete()},void 0,function(){n=null}))})}function Ei(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0);return S(function(o,i){or(n)(me(ne([o],te(e)),r)).subscribe(i)})}function Rt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Ei.apply(void 0,ne([],te(e)))}function jt(e){var t,r=1/0,n;return e!=null&&(typeof e=="object"?(t=e.count,r=t===void 0?1/0:t,n=e.delay):r=e),r<=0?function(){return y}:S(function(o,i){var a=0,s,c=function(){if(s==null||s.unsubscribe(),s=null,n!=null){var u=typeof n=="number"?Ve(n):q(n(a)),p=T(i,function(){p.unsubscribe(),l()});u.subscribe(p)}else l()},l=function(){var u=!1;s=o.subscribe(T(i,void 0,function(){++a<r?s?c():u=!0:i.complete()})),u&&c()};l()})}function Or(e,t){return S(yi(e,t,arguments.length>=2,!0))}function xe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new I}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,c=s===void 0?!0:s;return function(l){var u,p,d,m=0,h=!1,v=!1,x=function(){p==null||p.unsubscribe(),p=void 0},w=function(){x(),u=d=void 0,h=v=!1},E=function(){var _=u;w(),_==null||_.unsubscribe()};return S(function(_,de){m++,!v&&!h&&x();var be=d=d!=null?d:r();de.add(function(){m--,m===0&&!v&&!h&&(p=Jn(E,c))}),be.subscribe(de),!u&&m>0&&(u=new Ct({next:function(M){return be.next(M)},error:function(M){v=!0,x(),p=Jn(w,o,M),be.error(M)},complete:function(){h=!0,x(),p=Jn(w,a),be.complete()}}),q(_).subscribe(u))})(l)}}function Jn(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];if(t===!0){e();return}if(t!==!1){var o=new Ct({next:function(){o.unsubscribe(),e()}});return q(t.apply(void 0,ne([],te(r)))).subscribe(o)}}function se(e,t,r){var n,o,i,a,s=!1;return e&&typeof e=="object"?(n=e.bufferSize,a=n===void 0?1/0:n,o=e.windowTime,t=o===void 0?1/0:o,i=e.refCount,s=i===void 0?!1:i,r=e.scheduler):a=e!=null?e:1/0,xe({connector:function(){return new wr(a,t,r)},resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:s})}function ke(e){return L(function(t,r){return e<=r})}function J(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return S(function(n,o){(r?nt(e,n,r):nt(e,n)).subscribe(o)})}function g(e,t){return S(function(r,n){var o=null,i=0,a=!1,s=function(){return a&&!o&&n.complete()};r.subscribe(T(n,function(c){o==null||o.unsubscribe();var l=0,u=i++;q(e(c,u)).subscribe(o=T(n,function(p){return n.next(t?t(c,p,u,l++):p)},function(){o=null,s()}))},function(){a=!0,s()}))})}function Q(e){return S(function(t,r){q(e).subscribe(T(r,function(){return r.complete()},Pe)),!r.closed&&t.subscribe(r)})}function Xn(e,t){return t===void 0&&(t=!1),S(function(r,n){var o=0;r.subscribe(T(n,function(i){var a=e(i,o++);(a||t)&&n.next(i),!a&&n.complete()}))})}function $(e,t,r){var n=F(e)||t||r?{next:e,error:t,complete:r}:e;return n?S(function(o,i){var a;(a=n.subscribe)===null||a===void 0||a.call(n);var s=!0;o.subscribe(T(i,function(c){var l;(l=n.next)===null||l===void 0||l.call(n,c),i.next(c)},function(){var c;s=!1,(c=n.complete)===null||c===void 0||c.call(n),i.complete()},function(c){var l;s=!1,(l=n.error)===null||l===void 0||l.call(n,c),i.error(c)},function(){var c,l;s&&((c=n.unsubscribe)===null||c===void 0||c.call(n)),(l=n.finalize)===null||l===void 0||l.call(n)}))}):Oe}function Ti(e,t){return S(function(r,n){var o=t!=null?t:{},i=o.leading,a=i===void 0?!0:i,s=o.trailing,c=s===void 0?!1:s,l=!1,u=null,p=null,d=!1,m=function(){p==null||p.unsubscribe(),p=null,c&&(x(),d&&n.complete())},h=function(){p=null,d&&n.complete()},v=function(w){return p=q(e(w)).subscribe(T(n,m,h))},x=function(){if(l){l=!1;var w=u;u=null,n.next(w),!d&&v(w)}};r.subscribe(T(n,function(w){l=!0,u=w,!(p&&!p.closed)&&(a?x():v(w))},function(){d=!0,!(c&&l&&p&&!p.closed)&&n.complete()}))})}function Lr(e,t,r){t===void 0&&(t=ge);var n=Ve(e,t);return Ti(function(){return n},r)}function pe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return S(function(n,o){for(var i=e.length,a=new Array(i),s=e.map(function(){return!1}),c=!1,l=function(p){q(e[p]).subscribe(T(o,function(d){a[p]=d,!c&&!s[p]&&(s[p]=!0,(c=s.every(Oe))&&(s=null))},Pe))},u=0;u<i;u++)l(u);n.subscribe(T(o,function(p){if(c){var d=ne([p],te(a));o.next(r?r.apply(void 0,ne([],te(d))):d)}}))})}function Si(){let e=new wr(1);return b(document,"DOMContentLoaded",{once:!0}).subscribe(()=>e.next(document)),e}function P(e,t=document){return Array.from(t.querySelectorAll(e))}function G(e,t=document){let r=Le(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function Le(e,t=document){return t.querySelector(e)||void 0}function xt(){var e,t,r,n;return(n=(r=(t=(e=document.activeElement)==null?void 0:e.shadowRoot)==null?void 0:t.activeElement)!=null?r:document.activeElement)!=null?n:void 0}var il=R(b(document.body,"focusin"),b(document.body,"focusout")).pipe(Be(1),J(void 0),f(()=>xt()||document.body),se(1));function ir(e){return il.pipe(f(t=>e.contains(t)),ie())}function Ft(e,t){let{matches:r}=matchMedia("(hover)");return j(()=>(r?R(b(e,"mouseenter").pipe(f(()=>!0)),b(e,"mouseleave").pipe(f(()=>!1))):R(b(e,"touchstart").pipe(f(()=>!0)),b(e,"touchend").pipe(f(()=>!1)),b(e,"touchcancel").pipe(f(()=>!1)))).pipe(t?Tr(o=>Ve(+!o*t)):Oe,J(!0,e.matches(":hover"))))}function Oi(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)Oi(e,r)}function A(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)Oi(n,o);return n}function Li(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function ar(e){let t=A("script",{src:e});return j(()=>(document.head.appendChild(t),R(b(t,"load"),b(t,"error").pipe(g(()=>zn(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(f(()=>{}),V(()=>document.head.removeChild(t)),Me(1))))}var Mi=new I,al=j(()=>typeof ResizeObserver=="undefined"?ar("https://unpkg.com/resize-observer-polyfill"):Y(void 0)).pipe(f(()=>new ResizeObserver(e=>e.forEach(t=>Mi.next(t)))),g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Ae(e){return{width:e.offsetWidth,height:e.offsetHeight}}function Re(e){let t=e;for(;t.clientWidth===0&&t.parentElement;)t=t.parentElement;return al.pipe($(r=>r.observe(t)),g(r=>Mi.pipe(L(n=>n.target===t),V(()=>r.unobserve(t)))),f(()=>Ae(e)),J(Ae(e)))}function Mr(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ki(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}function Ai(e){let t=[],r=e.parentElement;for(;r;)(e.clientWidth>r.clientWidth||e.clientHeight>r.clientHeight)&&t.push(r),r=(e=r).parentElement;return t.length===0&&t.push(document.documentElement),t}function wt(e){return{x:e.offsetLeft,y:e.offsetTop}}function Ci(e){let t=e.getBoundingClientRect();return{x:t.x+window.scrollX,y:t.y+window.scrollY}}function Hi(e){return R(b(window,"load"),b(window,"resize")).pipe(Xe(0,je),f(()=>wt(e)),J(wt(e)))}function ln(e){return{x:e.scrollLeft,y:e.scrollTop}}function Ut(e){return R(b(e,"scroll"),b(window,"scroll"),b(window,"resize")).pipe(Xe(0,je),f(()=>ln(e)),J(ln(e)))}var $i=new I,sl=j(()=>Y(new IntersectionObserver(e=>{for(let t of e)$i.next(t)},{threshold:0}))).pipe(g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Et(e){return sl.pipe($(t=>t.observe(e)),g(t=>$i.pipe(L(({target:r})=>r===e),V(()=>t.unobserve(e)),f(({isIntersecting:r})=>r))))}var cl=Object.create,la=Object.defineProperty,ll=Object.getOwnPropertyDescriptor,ul=Object.getOwnPropertyNames,pl=Object.getPrototypeOf,fl=Object.prototype.hasOwnProperty,ml=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),dl=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of ul(t))!fl.call(e,o)&&o!==r&&la(e,o,{get:()=>t[o],enumerable:!(n=ll(t,o))||n.enumerable});return e},hl=(e,t,r)=>(r=e!=null?cl(pl(e)):{},dl(t||!e||!e.__esModule?la(r,"default",{value:e,enumerable:!0}):r,e)),vl=ml((e,t)=>{var r="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,c=/^0o[0-7]+$/i,l=parseInt,u=typeof global=="object"&&global&&global.Object===Object&&global,p=typeof self=="object"&&self&&self.Object===Object&&self,d=u||p||Function("return this")(),m=Object.prototype,h=m.toString,v=Math.max,x=Math.min,w=function(){return d.Date.now()};function E(O,N,ee){var le,ce,Ne,bt,De,st,tt=0,Yt=!1,Mt=!1,vr=!0;if(typeof O!="function")throw new TypeError(r);N=M(N)||0,_(ee)&&(Yt=!!ee.leading,Mt="maxWait"in ee,Ne=Mt?v(M(ee.maxWait)||0,N):Ne,vr="trailing"in ee?!!ee.trailing:vr);function B(Te){var gt=le,br=ce;return le=ce=void 0,tt=Te,bt=O.apply(br,gt),bt}function C(Te){return tt=Te,De=setTimeout(W,N),Yt?B(Te):bt}function k(Te){var gt=Te-st,br=Te-tt,Ro=N-gt;return Mt?x(Ro,Ne-br):Ro}function D(Te){var gt=Te-st,br=Te-tt;return st===void 0||gt>=N||gt<0||Mt&&br>=Ne}function W(){var Te=w();if(D(Te))return Z(Te);De=setTimeout(W,k(Te))}function Z(Te){return De=void 0,vr&&le?B(Te):(le=ce=void 0,bt)}function We(){De!==void 0&&clearTimeout(De),tt=0,le=st=ce=De=void 0}function Gt(){return De===void 0?bt:Z(w())}function Nr(){var Te=w(),gt=D(Te);if(le=arguments,ce=this,st=Te,gt){if(De===void 0)return C(st);if(Mt)return De=setTimeout(W,N),B(st)}return De===void 0&&(De=setTimeout(W,N)),bt}return Nr.cancel=We,Nr.flush=Gt,Nr}function _(O){var N=typeof O;return!!O&&(N=="object"||N=="function")}function de(O){return!!O&&typeof O=="object"}function be(O){return typeof O=="symbol"||de(O)&&h.call(O)==o}function M(O){if(typeof O=="number")return O;if(be(O))return n;if(_(O)){var N=typeof O.valueOf=="function"?O.valueOf():O;O=_(N)?N+"":N}if(typeof O!="string")return O===0?O:+O;O=O.replace(i,"");var ee=s.test(O);return ee||c.test(O)?l(O.slice(2),ee?2:8):a.test(O)?n:+O}t.exports=E}),yn,K,ua,pa,Nt,Pi,fa,ma,da,lo,to,ro,bl,Ar={},ha=[],gl=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Pr=Array.isArray;function pt(e,t){for(var r in t)e[r]=t[r];return e}function uo(e){e&&e.parentNode&&e.parentNode.removeChild(e)}function Wt(e,t,r){var n,o,i,a={};for(i in t)i=="key"?n=t[i]:i=="ref"?o=t[i]:a[i]=t[i];if(arguments.length>2&&(a.children=arguments.length>3?yn.call(arguments,2):r),typeof e=="function"&&e.defaultProps!=null)for(i in e.defaultProps)a[i]===void 0&&(a[i]=e.defaultProps[i]);return fn(e,a,n,o,null)}function fn(e,t,r,n,o){var i={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:o!=null?o:++ua,__i:-1,__u:0};return o==null&&K.vnode!=null&&K.vnode(i),i}function ft(e){return e.children}function at(e,t){this.props=e,this.context=t}function cr(e,t){if(t==null)return e.__?cr(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null)return r.__e;return typeof e.type=="function"?cr(e):null}function va(e){var t,r;if((e=e.__)!=null&&e.__c!=null){for(e.__e=e.__c.base=null,t=0;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null){e.__e=e.__c.base=r.__e;break}return va(e)}}function Ii(e){(!e.__d&&(e.__d=!0)&&Nt.push(e)&&!vn.__r++||Pi!=K.debounceRendering)&&((Pi=K.debounceRendering)||fa)(vn)}function vn(){for(var e,t,r,n,o,i,a,s=1;Nt.length;)Nt.length>s&&Nt.sort(ma),e=Nt.shift(),s=Nt.length,e.__d&&(r=void 0,n=void 0,o=(n=(t=e).__v).__e,i=[],a=[],t.__P&&((r=pt({},n)).__v=n.__v+1,K.vnode&&K.vnode(r),po(t.__P,r,n,t.__n,t.__P.namespaceURI,32&n.__u?[o]:null,i,o!=null?o:cr(n),!!(32&n.__u),a),r.__v=n.__v,r.__.__k[r.__i]=r,_a(i,r,a),n.__e=n.__=null,r.__e!=o&&va(r)));vn.__r=0}function ba(e,t,r,n,o,i,a,s,c,l,u){var p,d,m,h,v,x,w,E=n&&n.__k||ha,_=t.length;for(c=_l(r,t,E,c,_),p=0;p<_;p++)(m=r.__k[p])!=null&&(d=m.__i==-1?Ar:E[m.__i]||Ar,m.__i=p,x=po(e,m,d,o,i,a,s,c,l,u),h=m.__e,m.ref&&d.ref!=m.ref&&(d.ref&&fo(d.ref,null,m),u.push(m.ref,m.__c||h,m)),v==null&&h!=null&&(v=h),(w=!!(4&m.__u))||d.__k===m.__k?c=ga(m,c,e,w):typeof m.type=="function"&&x!==void 0?c=x:h&&(c=h.nextSibling),m.__u&=-7);return r.__e=v,c}function _l(e,t,r,n,o){var i,a,s,c,l,u=r.length,p=u,d=0;for(e.__k=new Array(o),i=0;i<o;i++)(a=t[i])!=null&&typeof a!="boolean"&&typeof a!="function"?(c=i+d,(a=e.__k[i]=typeof a=="string"||typeof a=="number"||typeof a=="bigint"||a.constructor==String?fn(null,a,null,null,null):Pr(a)?fn(ft,{children:a},null,null,null):a.constructor==null&&a.__b>0?fn(a.type,a.props,a.key,a.ref?a.ref:null,a.__v):a).__=e,a.__b=e.__b+1,s=null,(l=a.__i=yl(a,r,c,p))!=-1&&(p--,(s=r[l])&&(s.__u|=2)),s==null||s.__v==null?(l==-1&&(o>u?d--:o<u&&d++),typeof a.type!="function"&&(a.__u|=4)):l!=c&&(l==c-1?d--:l==c+1?d++:(l>c?d--:d++,a.__u|=4))):e.__k[i]=null;if(p)for(i=0;i<u;i++)(s=r[i])!=null&&!(2&s.__u)&&(s.__e==n&&(n=cr(s)),xa(s,s));return n}function ga(e,t,r,n){var o,i;if(typeof e.type=="function"){for(o=e.__k,i=0;o&&i<o.length;i++)o[i]&&(o[i].__=e,t=ga(o[i],t,r,n));return t}e.__e!=t&&(n&&(t&&e.type&&!t.parentNode&&(t=cr(e)),r.insertBefore(e.__e,t||null)),t=e.__e);do t=t&&t.nextSibling;while(t!=null&&t.nodeType==8);return t}function Cr(e,t){return t=t||[],e==null||typeof e=="boolean"||(Pr(e)?e.some(function(r){Cr(r,t)}):t.push(e)),t}function yl(e,t,r,n){var o,i,a,s=e.key,c=e.type,l=t[r],u=l!=null&&(2&l.__u)==0;if(l===null&&e.key==null||u&&s==l.key&&c==l.type)return r;if(n>(u?1:0)){for(o=r-1,i=r+1;o>=0||i<t.length;)if((l=t[a=o>=0?o--:i++])!=null&&!(2&l.__u)&&s==l.key&&c==l.type)return a}return-1}function Ri(e,t,r){t[0]=="-"?e.setProperty(t,r!=null?r:""):e[t]=r==null?"":typeof r!="number"||gl.test(t)?r:r+"px"}function un(e,t,r,n,o){var i,a;e:if(t=="style")if(typeof r=="string")e.style.cssText=r;else{if(typeof n=="string"&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||Ri(e.style,t,"");if(r)for(t in r)n&&r[t]==n[t]||Ri(e.style,t,r[t])}else if(t[0]=="o"&&t[1]=="n")i=t!=(t=t.replace(da,"$1")),a=t.toLowerCase(),t=a in e||t=="onFocusOut"||t=="onFocusIn"?a.slice(2):t.slice(2),e.l||(e.l={}),e.l[t+i]=r,r?n?r.u=n.u:(r.u=lo,e.addEventListener(t,i?ro:to,i)):e.removeEventListener(t,i?ro:to,i);else{if(o=="http://www.w3.org/2000/svg")t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(t!="width"&&t!="height"&&t!="href"&&t!="list"&&t!="form"&&t!="tabIndex"&&t!="download"&&t!="rowSpan"&&t!="colSpan"&&t!="role"&&t!="popover"&&t in e)try{e[t]=r!=null?r:"";break e}catch(s){}typeof r=="function"||(r==null||r===!1&&t[4]!="-"?e.removeAttribute(t):e.setAttribute(t,t=="popover"&&r==1?"":r))}}function ji(e){return function(t){if(this.l){var r=this.l[t.type+e];if(t.t==null)t.t=lo++;else if(t.t<r.u)return;return r(K.event?K.event(t):t)}}}function po(e,t,r,n,o,i,a,s,c,l){var u,p,d,m,h,v,x,w,E,_,de,be,M,O,N,ee,le,ce=t.type;if(t.constructor!=null)return null;128&r.__u&&(c=!!(32&r.__u),i=[s=t.__e=r.__e]),(u=K.__b)&&u(t);e:if(typeof ce=="function")try{if(w=t.props,E="prototype"in ce&&ce.prototype.render,_=(u=ce.contextType)&&n[u.__c],de=u?_?_.props.value:u.__:n,r.__c?x=(p=t.__c=r.__c).__=p.__E:(E?t.__c=p=new ce(w,de):(t.__c=p=new at(w,de),p.constructor=ce,p.render=wl),_&&_.sub(p),p.props=w,p.state||(p.state={}),p.context=de,p.__n=n,d=p.__d=!0,p.__h=[],p._sb=[]),E&&p.__s==null&&(p.__s=p.state),E&&ce.getDerivedStateFromProps!=null&&(p.__s==p.state&&(p.__s=pt({},p.__s)),pt(p.__s,ce.getDerivedStateFromProps(w,p.__s))),m=p.props,h=p.state,p.__v=t,d)E&&ce.getDerivedStateFromProps==null&&p.componentWillMount!=null&&p.componentWillMount(),E&&p.componentDidMount!=null&&p.__h.push(p.componentDidMount);else{if(E&&ce.getDerivedStateFromProps==null&&w!==m&&p.componentWillReceiveProps!=null&&p.componentWillReceiveProps(w,de),!p.__e&&p.shouldComponentUpdate!=null&&p.shouldComponentUpdate(w,p.__s,de)===!1||t.__v==r.__v){for(t.__v!=r.__v&&(p.props=w,p.state=p.__s,p.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.some(function(Ne){Ne&&(Ne.__=t)}),be=0;be<p._sb.length;be++)p.__h.push(p._sb[be]);p._sb=[],p.__h.length&&a.push(p);break e}p.componentWillUpdate!=null&&p.componentWillUpdate(w,p.__s,de),E&&p.componentDidUpdate!=null&&p.__h.push(function(){p.componentDidUpdate(m,h,v)})}if(p.context=de,p.props=w,p.__P=e,p.__e=!1,M=K.__r,O=0,E){for(p.state=p.__s,p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),N=0;N<p._sb.length;N++)p.__h.push(p._sb[N]);p._sb=[]}else do p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),p.state=p.__s;while(p.__d&&++O<25);p.state=p.__s,p.getChildContext!=null&&(n=pt(pt({},n),p.getChildContext())),E&&!d&&p.getSnapshotBeforeUpdate!=null&&(v=p.getSnapshotBeforeUpdate(m,h)),ee=u,u!=null&&u.type===ft&&u.key==null&&(ee=ya(u.props.children)),s=ba(e,Pr(ee)?ee:[ee],t,r,n,o,i,a,s,c,l),p.base=t.__e,t.__u&=-161,p.__h.length&&a.push(p),x&&(p.__E=p.__=null)}catch(Ne){if(t.__v=null,c||i!=null)if(Ne.then){for(t.__u|=c?160:128;s&&s.nodeType==8&&s.nextSibling;)s=s.nextSibling;i[i.indexOf(s)]=null,t.__e=s}else{for(le=i.length;le--;)uo(i[le]);no(t)}else t.__e=r.__e,t.__k=r.__k,Ne.then||no(t);K.__e(Ne,t,r)}else i==null&&t.__v==r.__v?(t.__k=r.__k,t.__e=r.__e):s=t.__e=xl(r.__e,t,r,n,o,i,a,c,l);return(u=K.diffed)&&u(t),128&t.__u?void 0:s}function no(e){e&&e.__c&&(e.__c.__e=!0),e&&e.__k&&e.__k.forEach(no)}function _a(e,t,r){for(var n=0;n<r.length;n++)fo(r[n],r[++n],r[++n]);K.__c&&K.__c(t,e),e.some(function(o){try{e=o.__h,o.__h=[],e.some(function(i){i.call(o)})}catch(i){K.__e(i,o.__v)}})}function ya(e){return typeof e!="object"||e==null||e.__b&&e.__b>0?e:Pr(e)?e.map(ya):pt({},e)}function xl(e,t,r,n,o,i,a,s,c){var l,u,p,d,m,h,v,x=r.props,w=t.props,E=t.type;if(E=="svg"?o="http://www.w3.org/2000/svg":E=="math"?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),i!=null){for(l=0;l<i.length;l++)if((m=i[l])&&"setAttribute"in m==!!E&&(E?m.localName==E:m.nodeType==3)){e=m,i[l]=null;break}}if(e==null){if(E==null)return document.createTextNode(w);e=document.createElementNS(o,E,w.is&&w),s&&(K.__m&&K.__m(t,i),s=!1),i=null}if(E==null)x===w||s&&e.data==w||(e.data=w);else{if(i=i&&yn.call(e.childNodes),x=r.props||Ar,!s&&i!=null)for(x={},l=0;l<e.attributes.length;l++)x[(m=e.attributes[l]).name]=m.value;for(l in x)if(m=x[l],l!="children"){if(l=="dangerouslySetInnerHTML")p=m;else if(!(l in w)){if(l=="value"&&"defaultValue"in w||l=="checked"&&"defaultChecked"in w)continue;un(e,l,null,m,o)}}for(l in w)m=w[l],l=="children"?d=m:l=="dangerouslySetInnerHTML"?u=m:l=="value"?h=m:l=="checked"?v=m:s&&typeof m!="function"||x[l]===m||un(e,l,m,x[l],o);if(u)s||p&&(u.__html==p.__html||u.__html==e.innerHTML)||(e.innerHTML=u.__html),t.__k=[];else if(p&&(e.innerHTML=""),ba(t.type=="template"?e.content:e,Pr(d)?d:[d],t,r,n,E=="foreignObject"?"http://www.w3.org/1999/xhtml":o,i,a,i?i[0]:r.__k&&cr(r,0),s,c),i!=null)for(l=i.length;l--;)uo(i[l]);s||(l="value",E=="progress"&&h==null?e.removeAttribute("value"):h!=null&&(h!==e[l]||E=="progress"&&!h||E=="option"&&h!=x[l])&&un(e,l,h,x[l],o),l="checked",v!=null&&v!=e[l]&&un(e,l,v,x[l],o))}return e}function fo(e,t,r){try{if(typeof e=="function"){var n=typeof e.__u=="function";n&&e.__u(),n&&t==null||(e.__u=e(t))}else e.current=t}catch(o){K.__e(o,r)}}function xa(e,t,r){var n,o;if(K.unmount&&K.unmount(e),(n=e.ref)&&(n.current&&n.current!=e.__e||fo(n,null,t)),(n=e.__c)!=null){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(i){K.__e(i,t)}n.base=n.__P=null}if(n=e.__k)for(o=0;o<n.length;o++)n[o]&&xa(n[o],t,r||typeof e.type!="function");r||uo(e.__e),e.__c=e.__=e.__e=void 0}function wl(e,t,r){return this.constructor(e,r)}function El(e,t,r){var n,o,i,a;t==document&&(t=document.documentElement),K.__&&K.__(e,t),o=(n=typeof r=="function")?null:r&&r.__k||t.__k,i=[],a=[],po(t,e=(!n&&r||t).__k=Wt(ft,null,[e]),o||Ar,Ar,t.namespaceURI,!n&&r?[r]:o?null:t.firstChild?yn.call(t.childNodes):null,i,!n&&r?r:o?o.__e:t.firstChild,n,a),_a(i,e,a)}yn=ha.slice,K={__e:function(e,t,r,n){for(var o,i,a;t=t.__;)if((o=t.__c)&&!o.__)try{if((i=o.constructor)&&i.getDerivedStateFromError!=null&&(o.setState(i.getDerivedStateFromError(e)),a=o.__d),o.componentDidCatch!=null&&(o.componentDidCatch(e,n||{}),a=o.__d),a)return o.__E=o}catch(s){e=s}throw e}},ua=0,pa=function(e){return e!=null&&e.constructor==null},at.prototype.setState=function(e,t){var r;r=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=pt({},this.state),typeof e=="function"&&(e=e(pt({},r),this.props)),e&&pt(r,e),e!=null&&this.__v&&(t&&this._sb.push(t),Ii(this))},at.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),Ii(this))},at.prototype.render=ft,Nt=[],fa=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,ma=function(e,t){return e.__v.__b-t.__v.__b},vn.__r=0,da=/(PointerCapture)$|Capture$/i,lo=0,to=ji(!1),ro=ji(!0),bl=0;var Hr,ve,Zn,Fi,$r=0,wa=[],we=K,Ui=we.__b,Ni=we.__r,Di=we.diffed,Wi=we.__c,Vi=we.unmount,zi=we.__;function mo(e,t){we.__h&&we.__h(ve,e,$r||t),$r=0;var r=ve.__H||(ve.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({}),r.__[e]}function bn(e){return $r=1,Tl(Ta,e)}function Tl(e,t,r){var n=mo(Hr++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):Ta(void 0,t),function(s){var c=n.__N?n.__N[0]:n.__[0],l=n.t(c,s);c!==l&&(n.__N=[l,n.__[1]],n.__c.setState({}))}],n.__c=ve,!ve.__f)){var o=function(s,c,l){if(!n.__c.__H)return!0;var u=n.__c.__H.__.filter(function(d){return!!d.__c});if(u.every(function(d){return!d.__N}))return!i||i.call(this,s,c,l);var p=n.__c.props!==s;return u.forEach(function(d){if(d.__N){var m=d.__[0];d.__=d.__N,d.__N=void 0,m!==d.__[0]&&(p=!0)}}),i&&i.call(this,s,c,l)||p};ve.__f=!0;var i=ve.shouldComponentUpdate,a=ve.componentWillUpdate;ve.componentWillUpdate=function(s,c,l){if(this.__e){var u=i;i=void 0,o(s,c,l),i=u}a&&a.call(this,s,c,l)},ve.shouldComponentUpdate=o}return n.__N||n.__}function mt(e,t){var r=mo(Hr++,3);!we.__s&&Ea(r.__H,t)&&(r.__=e,r.u=t,ve.__H.__h.push(r))}function Vt(e){return $r=5,ur(function(){return{current:e}},[])}function ur(e,t){var r=mo(Hr++,7);return Ea(r.__H,t)&&(r.__=e(),r.__H=t,r.__h=e),r.__}function Sl(e,t){return $r=8,ur(function(){return e},t)}function Ol(){for(var e;e=wa.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(mn),e.__H.__h.forEach(oo),e.__H.__h=[]}catch(t){e.__H.__h=[],we.__e(t,e.__v)}}we.__b=function(e){ve=null,Ui&&Ui(e)},we.__=function(e,t){e&&t.__k&&t.__k.__m&&(e.__m=t.__k.__m),zi&&zi(e,t)},we.__r=function(e){Ni&&Ni(e),Hr=0;var t=(ve=e.__c).__H;t&&(Zn===ve?(t.__h=[],ve.__h=[],t.__.forEach(function(r){r.__N&&(r.__=r.__N),r.u=r.__N=void 0})):(t.__h.forEach(mn),t.__h.forEach(oo),t.__h=[],Hr=0)),Zn=ve},we.diffed=function(e){Di&&Di(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(wa.push(t)!==1&&Fi===we.requestAnimationFrame||((Fi=we.requestAnimationFrame)||Ll)(Ol)),t.__H.__.forEach(function(r){r.u&&(r.__H=r.u),r.u=void 0})),Zn=ve=null},we.__c=function(e,t){t.some(function(r){try{r.__h.forEach(mn),r.__h=r.__h.filter(function(n){return!n.__||oo(n)})}catch(n){t.some(function(o){o.__h&&(o.__h=[])}),t=[],we.__e(n,r.__v)}}),Wi&&Wi(e,t)},we.unmount=function(e){Vi&&Vi(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{mn(n)}catch(o){t=o}}),r.__H=void 0,t&&we.__e(t,r.__v))};var qi=typeof requestAnimationFrame=="function";function Ll(e){var t,r=function(){clearTimeout(n),qi&&cancelAnimationFrame(t),setTimeout(e)},n=setTimeout(r,35);qi&&(t=requestAnimationFrame(r))}function mn(e){var t=ve,r=e.__c;typeof r=="function"&&(e.__c=void 0,r()),ve=t}function oo(e){var t=ve;e.__c=e.__(),ve=t}function Ea(e,t){return!e||e.length!==t.length||t.some(function(r,n){return r!==e[n]})}function Ta(e,t){return typeof t=="function"?t(e):t}function Ml(e,t){for(var r in t)e[r]=t[r];return e}function Ki(e,t){for(var r in e)if(r!=="__source"&&!(r in t))return!0;for(var n in t)if(n!=="__source"&&e[n]!==t[n])return!0;return!1}function Bi(e,t){this.props=e,this.context=t}(Bi.prototype=new at).isPureReactComponent=!0,Bi.prototype.shouldComponentUpdate=function(e,t){return Ki(this.props,e)||Ki(this.state,t)};var Yi=K.__b;K.__b=function(e){e.type&&e.type.__f&&e.ref&&(e.props.ref=e.ref,e.ref=null),Yi&&Yi(e)};var Yx=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911,kl=K.__e;K.__e=function(e,t,r,n){if(e.then){for(var o,i=t;i=i.__;)if((o=i.__c)&&o.__c)return t.__e==null&&(t.__e=r.__e,t.__k=r.__k),o.__c(e,t)}kl(e,t,r,n)};var Gi=K.unmount;function Sa(e,t,r){return e&&(e.__c&&e.__c.__H&&(e.__c.__H.__.forEach(function(n){typeof n.__c=="function"&&n.__c()}),e.__c.__H=null),(e=Ml({},e)).__c!=null&&(e.__c.__P===r&&(e.__c.__P=t),e.__c.__e=!0,e.__c=null),e.__k=e.__k&&e.__k.map(function(n){return Sa(n,t,r)})),e}function Oa(e,t,r){return e&&r&&(e.__v=null,e.__k=e.__k&&e.__k.map(function(n){return Oa(n,t,r)}),e.__c&&e.__c.__P===t&&(e.__e&&r.appendChild(e.__e),e.__c.__e=!0,e.__c.__P=r)),e}function Qn(){this.__u=0,this.o=null,this.__b=null}function La(e){var t=e.__.__c;return t&&t.__a&&t.__a(e)}function pn(){this.i=null,this.l=null}K.unmount=function(e){var t=e.__c;t&&t.__R&&t.__R(),t&&32&e.__u&&(e.type=null),Gi&&Gi(e)},(Qn.prototype=new at).__c=function(e,t){var r=t.__c,n=this;n.o==null&&(n.o=[]),n.o.push(r);var o=La(n.__v),i=!1,a=function(){i||(i=!0,r.__R=null,o?o(s):s())};r.__R=a;var s=function(){if(!--n.__u){if(n.state.__a){var c=n.state.__a;n.__v.__k[0]=Oa(c,c.__c.__P,c.__c.__O)}var l;for(n.setState({__a:n.__b=null});l=n.o.pop();)l.forceUpdate()}};n.__u++||32&t.__u||n.setState({__a:n.__b=n.__v.__k[0]}),e.then(a,a)},Qn.prototype.componentWillUnmount=function(){this.o=[]},Qn.prototype.render=function(e,t){if(this.__b){if(this.__v.__k){var r=document.createElement("div"),n=this.__v.__k[0].__c;this.__v.__k[0]=Sa(this.__b,r,n.__O=n.__P)}this.__b=null}var o=t.__a&&Wt(ft,null,e.fallback);return o&&(o.__u&=-33),[Wt(ft,null,t.__a?null:e.children),o]};var Ji=function(e,t,r){if(++r[1]===r[0]&&e.l.delete(t),e.props.revealOrder&&(e.props.revealOrder[0]!=="t"||!e.l.size))for(r=e.i;r;){for(;r.length>3;)r.pop()();if(r[1]<r[0])break;e.i=r=r[2]}};(pn.prototype=new at).__a=function(e){var t=this,r=La(t.__v),n=t.l.get(e);return n[0]++,function(o){var i=function(){t.props.revealOrder?(n.push(o),Ji(t,e,n)):o()};r?r(i):i()}},pn.prototype.render=function(e){this.i=null,this.l=new Map;var t=Cr(e.children);e.revealOrder&&e.revealOrder[0]==="b"&&t.reverse();for(var r=t.length;r--;)this.l.set(t[r],this.i=[1,0,this.i]);return e.children},pn.prototype.componentDidUpdate=pn.prototype.componentDidMount=function(){var e=this;this.l.forEach(function(t,r){Ji(e,r,t)})};var Al=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,Cl=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,Hl=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,$l=/[A-Z0-9]/g,Pl=typeof document<"u",Il=function(e){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(e)};at.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(e){Object.defineProperty(at.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})});var Xi=K.event;function Rl(){}function jl(){return this.cancelBubble}function Fl(){return this.defaultPrevented}K.event=function(e){return Xi&&(e=Xi(e)),e.persist=Rl,e.isPropagationStopped=jl,e.isDefaultPrevented=Fl,e.nativeEvent=e};var Ma,Ul={enumerable:!1,configurable:!0,get:function(){return this.class}},Zi=K.vnode;K.vnode=function(e){typeof e.type=="string"&&(function(t){var r=t.props,n=t.type,o={},i=n.indexOf("-")===-1;for(var a in r){var s=r[a];if(!(a==="value"&&"defaultValue"in r&&s==null||Pl&&a==="children"&&n==="noscript"||a==="class"||a==="className")){var c=a.toLowerCase();a==="defaultValue"&&"value"in r&&r.value==null?a="value":a==="download"&&s===!0?s="":c==="translate"&&s==="no"?s=!1:c[0]==="o"&&c[1]==="n"?c==="ondoubleclick"?a="ondblclick":c!=="onchange"||n!=="input"&&n!=="textarea"||Il(r.type)?c==="onfocus"?a="onfocusin":c==="onblur"?a="onfocusout":Hl.test(a)&&(a=c):c=a="oninput":i&&Cl.test(a)?a=a.replace($l,"-$&").toLowerCase():s===null&&(s=void 0),c==="oninput"&&o[a=c]&&(a="oninputCapture"),o[a]=s}}n=="select"&&o.multiple&&Array.isArray(o.value)&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.value.indexOf(l.props.value)!=-1})),n=="select"&&o.defaultValue!=null&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.multiple?o.defaultValue.indexOf(l.props.value)!=-1:o.defaultValue==l.props.value})),r.class&&!r.className?(o.class=r.class,Object.defineProperty(o,"className",Ul)):(r.className&&!r.class||r.class&&r.className)&&(o.class=o.className=r.className),t.props=o})(e),e.$$typeof=Al,Zi&&Zi(e)};var Qi=K.__r;K.__r=function(e){Qi&&Qi(e),Ma=e.__c};var ea=K.diffed;K.diffed=function(e){ea&&ea(e);var t=e.props,r=e.__e;r!=null&&e.type==="textarea"&&"value"in t&&t.value!==r.value&&(r.value=t.value==null?"":t.value),Ma=null};function ka(e){let t=Vt(e);return t.current=e,ur(()=>Object.freeze({get current(){return t.current}}),[])}var Nl=typeof globalThis<"u"&&typeof navigator<"u"&&typeof document<"u";function Dl(e,...t){var r;(r=e==null?void 0:e.addEventListener)==null||r.call(e,...t)}function Wl(e,...t){var r;(r=e==null?void 0:e.removeEventListener)==null||r.call(e,...t)}var Vl=(e,t)=>Object.hasOwn(e,t),zl=()=>!0,ql=()=>!1;function Kl(e=!1){let t=Vt(e),r=Sl(()=>t.current,[]);return mt(()=>(t.current=!0,()=>{t.current=!1}),[]),r}function Bl(e,...t){let r=Kl(),n=ka(t[1]),o=ur(()=>function(...i){r()&&(typeof n.current=="function"?n.current.apply(this,i):typeof n.current.handleEvent=="function"&&n.current.handleEvent.apply(this,i))},[]);mt(()=>{let i=Yl(e)?e.current:e;if(!i)return;let a=t.slice(2);return Dl(i,t[0],o,...a),()=>{Wl(i,t[0],o,...a)}},[e,t[0]])}function Yl(e){return e!==null&&typeof e=="object"&&Vl(e,"current")}var Gl=e=>typeof e=="function"?e:typeof e=="string"?t=>t.key===e:e?zl:ql,Jl=Nl?globalThis:null;function Aa(e,t,r=[],n={}){let{event:o="keydown",target:i=Jl,eventOptions:a}=n,s=ka(t),c=ur(()=>{let l=Gl(e);return function(u){l(u)&&s.current.call(this,u)}},r);Bl(i,o,c,a)}function Ca(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(r=Ca(e[t]))&&(n&&(n+=" "),n+=r)}else for(r in e)e[r]&&(n&&(n+=" "),n+=r);return n}function Xl(){for(var e,t,r=0,n="",o=arguments.length;r<o;r++)(e=arguments[r])&&(t=Ca(e))&&(n&&(n+=" "),n+=t);return n}var zt=Xl,Zl=Symbol.for("preact-signals");function xn(){if(St>1)St--;else{for(var e,t=!1;kr!==void 0;){var r=kr;for(kr=void 0,io++;r!==void 0;){var n=r.o;if(r.o=void 0,r.f&=-3,!(8&r.f)&&Pa(r))try{r.c()}catch(o){t||(e=o,t=!0)}r=n}}if(io=0,St--,t)throw e}}function Ql(e){if(St>0)return e();St++;try{return e()}finally{xn()}}var ae=void 0;function Ha(e){var t=ae;ae=void 0;try{return e()}finally{ae=t}}var kr=void 0,St=0,io=0,gn=0;function $a(e){if(ae!==void 0){var t=e.n;if(t===void 0||t.t!==ae)return t={i:0,S:e,p:ae.s,n:void 0,t:ae,e:void 0,x:void 0,r:t},ae.s!==void 0&&(ae.s.n=t),ae.s=t,e.n=t,32&ae.f&&e.S(t),t;if(t.i===-1)return t.i=0,t.n!==void 0&&(t.n.p=t.p,t.p!==void 0&&(t.p.n=t.n),t.p=ae.s,t.n=void 0,ae.s.n=t,ae.s=t),t}}function Ce(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Ce.prototype.brand=Zl;Ce.prototype.h=function(){return!0};Ce.prototype.S=function(e){var t=this,r=this.t;r!==e&&e.e===void 0&&(e.x=r,this.t=e,r!==void 0?r.e=e:Ha(function(){var n;(n=t.W)==null||n.call(t)}))};Ce.prototype.U=function(e){var t=this;if(this.t!==void 0){var r=e.e,n=e.x;r!==void 0&&(r.x=n,e.e=void 0),n!==void 0&&(n.e=r,e.x=void 0),e===this.t&&(this.t=n,n===void 0&&Ha(function(){var o;(o=t.Z)==null||o.call(t)}))}};Ce.prototype.subscribe=function(e){var t=this;return qt(function(){var r=t.value,n=ae;ae=void 0;try{e(r)}finally{ae=n}},{name:"sub"})};Ce.prototype.valueOf=function(){return this.value};Ce.prototype.toString=function(){return this.value+""};Ce.prototype.toJSON=function(){return this.value};Ce.prototype.peek=function(){var e=ae;ae=void 0;try{return this.value}finally{ae=e}};Object.defineProperty(Ce.prototype,"value",{get:function(){var e=$a(this);return e!==void 0&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(io>100)throw new Error("Cycle detected");this.v=e,this.i++,gn++,St++;try{for(var t=this.t;t!==void 0;t=t.x)t.t.N()}finally{xn()}}}});function Ot(e,t){return new Ce(e,t)}function Pa(e){for(var t=e.s;t!==void 0;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function Ia(e){for(var t=e.s;t!==void 0;t=t.n){var r=t.S.n;if(r!==void 0&&(t.r=r),t.S.n=t,t.i=-1,t.n===void 0){e.s=t;break}}}function Ra(e){for(var t=e.s,r=void 0;t!==void 0;){var n=t.p;t.i===-1?(t.S.U(t),n!==void 0&&(n.n=t.n),t.n!==void 0&&(t.n.p=n)):r=t,t.S.n=t.r,t.r!==void 0&&(t.r=void 0),t=n}e.s=r}function Kt(e,t){Ce.call(this,void 0),this.x=e,this.s=void 0,this.g=gn-1,this.f=4,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Kt.prototype=new Ce;Kt.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if((36&this.f)==32||(this.f&=-5,this.g===gn))return!0;if(this.g=gn,this.f|=1,this.i>0&&!Pa(this))return this.f&=-2,!0;var e=ae;try{Ia(this),ae=this;var t=this.x();(16&this.f||this.v!==t||this.i===0)&&(this.v=t,this.f&=-17,this.i++)}catch(r){this.v=r,this.f|=16,this.i++}return ae=e,Ra(this),this.f&=-2,!0};Kt.prototype.S=function(e){if(this.t===void 0){this.f|=36;for(var t=this.s;t!==void 0;t=t.n)t.S.S(t)}Ce.prototype.S.call(this,e)};Kt.prototype.U=function(e){if(this.t!==void 0&&(Ce.prototype.U.call(this,e),this.t===void 0)){this.f&=-33;for(var t=this.s;t!==void 0;t=t.n)t.S.U(t)}};Kt.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;e!==void 0;e=e.x)e.t.N()}};Object.defineProperty(Kt.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var e=$a(this);if(this.h(),e!==void 0&&(e.i=this.i),16&this.f)throw this.v;return this.v}});function ta(e,t){return new Kt(e,t)}function ja(e){var t=e.u;if(e.u=void 0,typeof t=="function"){St++;var r=ae;ae=void 0;try{t()}catch(n){throw e.f&=-2,e.f|=8,ho(e),n}finally{ae=r,xn()}}}function ho(e){for(var t=e.s;t!==void 0;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,ja(e)}function eu(e){if(ae!==this)throw new Error("Out-of-order effect");Ra(this),ae=e,this.f&=-2,8&this.f&&ho(this),xn()}function pr(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=t==null?void 0:t.name}pr.prototype.c=function(){var e=this.S();try{if(8&this.f||this.x===void 0)return;var t=this.x();typeof t=="function"&&(this.u=t)}finally{e()}};pr.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1,this.f&=-9,ja(this),Ia(this),St++;var e=ae;return ae=this,eu.bind(this,e)};pr.prototype.N=function(){2&this.f||(this.f|=2,this.o=kr,kr=this)};pr.prototype.d=function(){this.f|=8,1&this.f||ho(this)};pr.prototype.dispose=function(){this.d()};function qt(e,t){var r=new pr(e,t);try{r.c()}catch(o){throw r.d(),o}var n=r.d.bind(r);return n[Symbol.dispose]=n,n}var Fa,vo,eo,Ua=[];qt(function(){Fa=this.N})();function fr(e,t){K[e]=t.bind(null,K[e]||function(){})}function _n(e){eo&&eo(),eo=e&&e.S()}function Na(e){var t=this,r=e.data,n=ru(r);n.value=r;var o=ur(function(){for(var s=t,c=t.__v;c=c.__;)if(c.__c){c.__c.__$f|=4;break}var l=ta(function(){var m=n.value.value;return m===0?0:m===!0?"":m||""}),u=ta(function(){return!Array.isArray(l.value)&&!pa(l.value)}),p=qt(function(){if(this.N=Da,u.value){var m=l.value;s.__v&&s.__v.__e&&s.__v.__e.nodeType===3&&(s.__v.__e.data=m)}}),d=t.__$u.d;return t.__$u.d=function(){p(),d.call(this)},[u,l]},[]),i=o[0],a=o[1];return i.value?a.peek():a.value}Na.displayName="ReactiveTextNode";Object.defineProperties(Ce.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:Na},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});fr("__b",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),typeof t.type=="string"){var r,n=t.props;for(var o in n)if(o!=="children"){var i=n[o];i instanceof Ce&&(r||(t.__np=r={}),r[o]=i,n[o]=i.peek())}}e(t)});fr("__r",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.enterComponent(t),t.type!==ft){_n();var r,n=t.__c;n&&(n.__$f&=-2,(r=n.__$u)===void 0&&(n.__$u=r=(function(o){var i;return qt(function(){i=this}),i.c=function(){n.__$f|=1,n.setState({})},i})())),vo=n,_n(r)}e(t)});fr("__e",function(e,t,r,n){typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0,e(t,r,n)});fr("diffed",function(e,t){typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0;var r;if(typeof t.type=="string"&&(r=t.__e)){var n=t.__np,o=t.props;if(n){var i=r.U;if(i)for(var a in i){var s=i[a];s!==void 0&&!(a in n)&&(s.d(),i[a]=void 0)}else i={},r.U=i;for(var c in n){var l=i[c],u=n[c];l===void 0?(l=tu(r,c,u,o),i[c]=l):l.o(u,o)}}}e(t)});function tu(e,t,r,n){var o=t in e&&e.ownerSVGElement===void 0,i=Ot(r);return{o:function(a,s){i.value=a,n=s},d:qt(function(){this.N=Da;var a=i.value.value;n[t]!==a&&(n[t]=a,o?e[t]=a:a?e.setAttribute(t,a):e.removeAttribute(t))})}}fr("unmount",function(e,t){if(typeof t.type=="string"){var r=t.__e;if(r){var n=r.U;if(n){r.U=void 0;for(var o in n){var i=n[o];i&&i.d()}}}}else{var a=t.__c;if(a){var s=a.__$u;s&&(a.__$u=void 0,s.d())}}e(t)});fr("__h",function(e,t,r,n){(n<3||n===9)&&(t.__$f|=2),e(t,r,n)});at.prototype.shouldComponentUpdate=function(e,t){var r=this.__$u,n=r&&r.s!==void 0;for(var o in t)return!0;if(this.__f||typeof this.u=="boolean"&&this.u===!0){var i=2&this.__$f;if(!(n||i||4&this.__$f)||1&this.__$f)return!0}else if(!(n||4&this.__$f)||3&this.__$f)return!0;for(var a in e)if(a!=="__source"&&e[a]!==this.props[a])return!0;for(var s in this.props)if(!(s in e))return!0;return!1};function ru(e,t){return bn(function(){return Ot(e,t)})[0]}var nu=function(e){queueMicrotask(function(){queueMicrotask(e)})};function ou(){Ql(function(){for(var e;e=Ua.shift();)Fa.call(e)})}function Da(){Ua.push(this)===1&&(K.requestAnimationFrame||nu)(ou)}var ao=[0];for(let e=0;e<32;e++)ao.push(ao[e]|1<<e);function iu(e){return new Uint32Array(e)}var ra=class{constructor(e,t=iu(Math.ceil(e/32))){this.size=e,this.data=t}get(e){return this.data[e>>>5]>>>e&1}set(e){this.data[e>>>5]|=1<<(e&31)}forEach(e){let t=this.size&31;for(let r=0;r<this.data.length;r++){if(this.data[r]===0)continue;let n=this.data[r];t&&r===this.data.length-1&&(n=n&ao[t]);for(let o=0,i=32-Math.clz32(n);o<i;o++)n&1<<o&&e((r<<5)+o)}}};function au(e){lr.value=e,e.items.find(t=>{var r;return(r=t.tags)==null?void 0:r.length})&&(matchMedia("(max-width: 768px)").matches||Wa())}function Dt(){Qe.value=He(H({},Qe.value),{hideSearch:!Qe.value.hideSearch})}function Wa(){Qe.value=He(H({},Qe.value),{hideFilters:!Qe.value.hideFilters})}function dn(){return Qe.value.selectedItem}function so(e){Qe.value=He(H({},Qe.value),{selectedItem:e})}function su(){var e,t;return(t=(e=lr.value)==null?void 0:e.items)!=null?t:[]}function wn(){return typeof Se.value.input=="string"?Se.value.input:""}function Va(e){let t=za();e.length&&!t.length?Se.value=He(H({},Se.value),{page:void 0,input:e}):!e.length&&t.length?Se.value=He(H({},Se.value),{page:void 0,input:{type:"operator",data:{operator:"not",operands:[]}}}):Se.value=He(H({},Se.value),{page:void 0,input:e})}function cu(){typeof it.value.pagination.next<"u"&&(Se.value=He(H({},Se.value),{page:it.value.pagination.next}))}function lu(e){let t=Se.value.filter.input;if("type"in t&&t.type==="operator"){for(let r of t.data.operands)if("type"in r&&r.type==="value"&&typeof r.data.value=="string"&&r.data.value===e)return!0}return!1}function za(){let e=Se.value.filter.input,t=[];if("type"in e&&e.type==="operator")for(let r of e.data.operands)"type"in r&&r.type==="value"&&typeof r.data.value=="string"&&t.push(r.data.value);return t}function uu(e){let t=Se.value.filter.input,r=[];if("type"in t&&t.type==="operator")for(let n of t.data.operands)"type"in n&&n.type==="value"&&typeof n.data.value=="string"&&r.push(n.data.value);if(r.includes(e)){let n=r.indexOf(e);n>-1&&r.splice(n,1)}else r.push(e);Se.value=He(H({},Se.value),{page:void 0,filter:He(H({},Se.value.filter),{input:{type:"operator",data:{operator:"and",operands:r.map(n=>({type:"value",data:{field:"tags",value:n}}))}}})}),Va(wn())}function pu(){return it.value.items}function fu(){return it.value.total}function mu(){var e;for(let t of(e=it.value.aggregations)!=null?e:[])if(t.type==="term")return t.data.value;return[]}function sr(){return Qe.value.hideSearch}function du(){return Qe.value.hideFilters}function qa(){var e;return(e=Ka.value.highlight)!=null?e:!1}var Qe=Ot({hideSearch:!0,hideFilters:!0,selectedItem:0}),Ka=Ot({}),lr=Ot(),na=Ot(),Se=Ot({input:"",filter:{input:{type:"operator",data:{operator:"and",operands:[]}},aggregation:{input:[{type:"term",data:{field:"tags"}}]}}}),it=Ot({items:[],query:{select:{documents:new ra(0),terms:new ra(0)},values:[]},pagination:{total:0}});function hu(e,t,r){for(let n=0;t<r;){switch(n=n<<8^32|e.charCodeAt(++t),n){case 97:case 98:case 99:case 101:case 104:case 105:case 108:case 109:case 112:case 115:case 116:case 119:case 24946:case 25185:case 25455:case 25965:case 26989:case 26990:case 27753:case 28005:case 28769:case 29551:case 29810:case 30562:case 6386277:case 6447475:case 6647138:case 6909552:case 7104878:case 7169396:case 7364978:case 7565173:case 7631457:case 1701667429:case 1768845429:case 1869967971:case 1885434465:case 1936684402:case 1953653091:continue;case 25202:case 26738:case 6516588:case 6909287:case 7823986:case 1634885997:case 1634887009:case 1650553701:case 1818848875:case 1835165028:case 1835365473:case 1852863860:case 1918985067:case 1970430821:switch(e.charCodeAt(++t)){case 9:case 10:case 32:case 47:case 62:return!0}}break}return!1}function vu(e,t,r=0,n=e.length){let o=0,i=r;for(let a=0;i<n;i++)switch(a=e.charCodeAt(i),a){case 60:i>r&&t(0,o,r,r=i);continue;case 62:e.charCodeAt(r+1)===47?t(2,--o,r,r=i+1):hu(e,r,n)?t(3,o,r,r=i+1):t(1,o++,r,r=i+1)}i>r&&t(0,o,r,i)}function bu(e,t=0,r=e.length){let n=++t;e:for(let l=0;n<r;n++)switch(l=e.charCodeAt(n),l){case 9:case 10:case 32:case 62:break e}let o=e.slice(t,t=n),i=[],a=0,s=0,c=0;for(let l=0;n<r;n++){let u=e.charCodeAt(n);switch(a){case 0:switch(u){case 9:case 10:case 32:t===n?t++:(s=1,a=1);break;case 61:s=1,a=2;break;case 47:t++;case 62:t<n&&(s=1);break}break;case 1:switch(u){case 9:case 10:case 32:continue;case 61:a=2,t=n+1;continue;default:a=0,t=n,l++}continue;case 2:switch(u){case 9:case 10:case 32:t===n?t++:c===0&&(s=2,a=0);break;case 34:case 39:switch(c){case 0:c=u,t=n+1;continue;case u:s=2,a=0,c=0}break;case 62:t<n&&(s=2);break}}switch(s){case 1:i[l]=[e.slice(t,n),""],s=0,t=n+1;break;case 2:i[l++][1]=e.slice(t,n),s=0,t=n+1;break}}return{tag:o,attrs:i.length?Object.fromEntries(i):null}}function gu(e,t,r){return e.slice(t,r)}function _u(e){return(t,r,n,o)=>{let i=[],a=[],{onElement:s,onText:c=gu}=typeof r=="function"?{onElement:r}:r,l=0,u=0;return e(t,(p,d,m,h)=>{if(p===0)i[l++]=c(t,m,h),a[u++]={value:null,depth:d};else if(p&1&&(a[u++]={value:bu(t,m,h),depth:d}),p&2)for(let v=0;u>=0;v++){let{value:x,depth:w}=a[--u];if(w>d)continue;let E=i.slice(l-=v,l+v);i[l++]=s(x,E),u++;break}},n,o),i.slice(0,l)}}function yu(e){return e.replace(/[&<>]/g,t=>{switch(t.charCodeAt(0)){case 38:return"&amp;";case 60:return"&lt;";case 62:return"&gt;"}})}function hn(e){return e.replace(/&(amp|[lg]t);/g,t=>{switch(t.charCodeAt(1)){case 97:return"&";case 108:return"<";case 103:return">"}})}function xu(e,t){return{start:e.start+t,end:e.end+t,value:e.value}}function wu(e,t,r){return e.slice(t,r)}function Eu(e){let{onHighlight:t,onText:r=wu}=typeof e=="function"?{onHighlight:e}:e;return(n,o,i=0,a=n.length)=>{var l;let s=[],c=(l=o==null?void 0:o.ranges)!=null?l:[];for(let u=0,p=i;u<c.length;u++){let d=c[u].start;if(d>a)break;let m=c[u].end;if(m<p)continue;d=Math.max(d,i),m=Math.min(m,a),d>i&&s.push(r(n,i,d));let{value:h}=c[u];s.push(t(n,{start:d,end:i=m,value:h}))}return i<a&&s.push(r(n,i,a)),s}}var Tu={fuzzy:"v"},Su=0;function z(e,t,r,n,o,i){t||(t={});var a,s,c=t;if("ref"in c)for(s in c={},t)s=="ref"?a=t[s]:c[s]=t[s];var l={type:e,props:c,key:r,ref:a,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--Su,__i:-1,__u:0,__source:o,__self:i};if(typeof e=="function"&&(a=e.defaultProps))for(s in a)c[s]===void 0&&(c[s]=a[s]);return K.vnode&&K.vnode(l),l}var Ou=_u(vu),Lu=Eu({onText(e,t,r){return hn(e.slice(t,r))},onHighlight(e,{start:t,end:r,value:n}){let o=Math.min(r,t+n);return t===r?null:(n===-1&&(o=r),z("mark",{className:zt({[Tu.fuzzy]:n===-1}),children:[z("u",{children:hn(e.slice(t,o))}),hn(e.slice(o,r))]}))}});function Ba(e,t){let r=Ou(e,{onElement(n,o){return Wt(n.tag,n.attrs,...o)},onText(n,o,i){return Lu(n,t==null?void 0:t.value.highlight,o,i)}});return z(ft,{children:r})}function Mu(e,t){var n;let r=[];for(let o=0,i=0;o<e.length;o++){let a=[];if((n=t==null?void 0:t.value.highlight)!=null&&n.ranges)for(let s of t.value.highlight.ranges)a.push(xu(s,-i));r.push(Ba(e[o],He(H({},t),{value:He(H({},t==null?void 0:t.value),{highlight:{ranges:a}})}))),i+=e[o].length}return r}function Ya(e,t={highlight:!0}){Ka.value=t;let r=new Worker(e);r.onmessage=n=>{let o=n.data;switch(o.type){case 1:na.value=!0;break;case 3:typeof o.data.pagination.prev<"u"?it.value=He(H({},it.value),{pagination:o.data.pagination,items:[...it.value.items,...o.data.items]}):(it.value=o.data,so(0));break}},qt(()=>{lr.value&&r.postMessage({type:0,data:lr.value})}),qt(()=>{na.value&&r.postMessage({type:2,data:Se.value})})}var oa={container:"p",hidden:"m"};function ku(e){return z("div",{class:zt(oa.container,{[oa.hidden]:e.hidden}),onClick:()=>Dt()})}var ia={container:"r",disabled:"c"};function co(e){return z("button",{class:zt(ia.container,{[ia.disabled]:!e.onClick}),onClick:e.onClick,children:e.children})}var aa=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),Au=e=>e.replace(/^([A-Z])|[\s-_]+(\w)/g,(t,r,n)=>n?n.toUpperCase():r.toLowerCase()),sa=e=>{let t=Au(e);return t.charAt(0).toUpperCase()+t.slice(1)},Cu=(...e)=>e.filter((t,r,n)=>!!t&&t.trim()!==""&&n.indexOf(t)===r).join(" ").trim(),Hu={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},$u=c=>{var l=c,{color:e="currentColor",size:t=24,strokeWidth:r=2,absoluteStrokeWidth:n,children:o,iconNode:i,class:a=""}=l,s=gr(l,["color","size","strokeWidth","absoluteStrokeWidth","children","iconNode","class"]);return Wt("svg",H(He(H({},Hu),{width:String(t),height:t,stroke:e,"stroke-width":n?Number(r)*24/Number(t):r,class:["lucide",a].join(" ")}),s),[...i.map(([u,p])=>Wt(u,p)),...Cr(o)])},bo=(e,t)=>{let r=a=>{var s=a,{class:n="",children:o}=s,i=gr(s,["class","children"]);return Wt($u,He(H({},i),{iconNode:t,class:Cu(`lucide-${aa(sa(e))}`,`lucide-${aa(e)}`,n)}),o)};return r.displayName=sa(e),r},Pu=bo("corner-down-left",[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4",key:"6o5b7l"}],["path",{d:"m9 10-5 5 5 5",key:"1kshq7"}]]),Iu=bo("list-filter",[["path",{d:"M2 5h20",key:"1fs1ex"}],["path",{d:"M6 12h12",key:"8npq4p"}],["path",{d:"M9 19h6",key:"456am0"}]]),Ru=bo("search",[["path",{d:"m21 21-4.34-4.34",key:"14j7rj"}],["circle",{cx:"11",cy:"11",r:"8",key:"4ej97u"}]]),Gx=hl(vl(),1);function ju({threshold:e=0,root:t=null,rootMargin:r="0%",freezeOnceVisible:n=!1,initialIsIntersecting:o=!1,onChange:i}={}){var a;let[s,c]=bn(null),[l,u]=bn(()=>({isIntersecting:o,entry:void 0})),p=Vt();p.current=i;let d=((a=l.entry)==null?void 0:a.isIntersecting)&&n;mt(()=>{if(!s||!("IntersectionObserver"in window)||d)return;let v,x=new IntersectionObserver(w=>{let E=Array.isArray(x.thresholds)?x.thresholds:[x.thresholds];w.forEach(_=>{let de=_.isIntersecting&&E.some(be=>_.intersectionRatio>=be);u({isIntersecting:de,entry:_}),p.current&&p.current(de,_),de&&n&&v&&(v(),v=void 0)})},{threshold:e,root:t,rootMargin:r});return x.observe(s),()=>{x.disconnect()}},[s,JSON.stringify(e),t,r,d,n]);let m=Vt(null);mt(()=>{var v;!s&&(v=l.entry)!=null&&v.target&&!n&&!d&&m.current!==l.entry.target&&(m.current=l.entry.target,u({isIntersecting:o,entry:void 0}))},[s,l.entry,n,d,o]);let h=[c,!!l.isIntersecting,l.entry];return h.ref=h[0],h.isIntersecting=h[1],h.entry=h[2],h}var lt={container:"n",hidden:"l",content:"u",pop:"d",badge:"y",sidebar:"i",controls:"w",results:"k",loadmore:"z"};function Fu(e){let{isIntersecting:t,ref:r}=ju({threshold:0});mt(()=>{t&&cu()},[t]);let n=Vt(null);mt(()=>{n.current&&typeof Se.value.page>"u"&&n.current.scrollTo({top:0,behavior:"smooth"})},[Se.value]);let o=za();return z("div",{class:zt(lt.container,{[lt.hidden]:e.hidden}),children:[z("div",{class:lt.content,children:[z("div",{class:lt.controls,children:[z(co,{onClick:Dt,children:z(Ru,{})}),z(Nu,{focus:!e.hidden}),z(co,{onClick:Wa,children:[z(Iu,{}),o.length>0&&z("span",{class:lt.badge,children:o.length})]})]}),z("div",{class:lt.results,ref:n,children:[z(Du,{keyboard:!e.hidden}),z("div",{class:lt.loadmore,ref:r})]})]}),z("div",{class:zt(lt.sidebar,{[lt.hidden]:du()}),children:z(Uu,{})})]})}var Tt={container:"X",list:"j",heading:"F",title:"I",item:"o",active:"g",value:"R",count:"q"};function Uu(e){let t=mu();return t.sort((r,n)=>n.node.count-r.node.count),z("div",{class:Tt.container,children:[z("h3",{class:Tt.heading,children:"Filters"}),z("h4",{class:Tt.title,children:"Tags"}),z("ol",{class:Tt.list,children:t.map(r=>z("li",{class:zt(Tt.item,{[Tt.active]:lu(r.node.value)}),onClick:()=>uu(r.node.value),children:[z("span",{class:Tt.value,children:r.node.value}),z("span",{class:Tt.count,children:r.node.count})]}))})]})}var ca={container:"f"};function Nu(e){let t=Vt(null);return mt(()=>{var r,n;e.focus?(r=t.current)==null||r.focus():(n=t.current)==null||n.blur()},[e.focus]),z("div",{class:ca.container,children:z("input",{ref:t,type:"text",class:ca.content,value:hn(wn()),onInput:r=>Va(yu(r.currentTarget.value)),autocapitalize:"off",autocomplete:"off",autocorrect:"off",placeholder:"Search",spellcheck:!1,role:"combobox"})})}var ut={container:"b",heading:"A",item:"a",active:"h",wrapper:"B",actions:"s",title:"x",path:"t"};function Ga(){let[e,t]=bn(!1);return mt(()=>{let r=()=>t(!0),n=()=>t(!1);return document.addEventListener("compositionstart",r),document.addEventListener("compositionend",n),()=>{document.removeEventListener("compositionstart",r),document.removeEventListener("compositionend",n)}},[]),e}function Du(e){var s;let t=su(),r=pu(),n=dn(),o=Vt([]),i=Ga();mt(()=>{let c=o.current[n];c&&c.scrollIntoView({block:"center",behavior:"smooth"})},[n]),Aa(e.keyboard,c=>{if(i)return;let l=dn();c.key==="ArrowDown"?(c.preventDefault(),so(Math.min(l+1,r.length-1))):c.key==="ArrowUp"&&(c.preventDefault(),so(Math.max(l-1,0)))},[e.keyboard,i]);let a=(s=fu())!=null?s:0;return z(ft,{children:[r.length>0&&z("h3",{class:ut.heading,children:[z("span",{class:ut.bubble,children:new Intl.NumberFormat("en-US").format(a)})," ","results"]}),z("ol",{class:ut.container,children:r.map((c,l)=>{var m;let u=Ba(t[c.id].title,c.matches.find(({field:h})=>h==="title")),p=Mu((m=t[c.id].path)!=null?m:[],c.matches.find(({field:h})=>h==="path")),d=t[c.id].location;if(qa()){let h=encodeURIComponent(wn()),[v,x]=d.split("#",2);d=`${v}?h=${h.replace(/%20/g,"+")}`,typeof x<"u"&&(d+=`#${x}`)}return z("li",{children:z("a",{ref:h=>{o.current[l]=h},href:d,onClick:()=>Dt(),class:zt(ut.item,{[ut.active]:l===dn()}),children:[z("div",{class:ut.wrapper,children:[z("h2",{class:ut.title,children:u}),z("menu",{class:ut.path,children:p.map(h=>z("li",{children:h}))})]}),z("nav",{class:ut.actions,children:z(co,{children:z(Pu,{})})})]})})})})]})}var Wu={container:"e"};function Vu(e){let t=Ga();return Aa(!0,r=>{var n,o,i,a,s;if(!t)if((r.metaKey||r.ctrlKey)&&r.key==="k")r.preventDefault(),Dt();else if((r.metaKey||r.ctrlKey)&&r.key==="j")document.body.classList.toggle("dark");else if(r.key==="Enter"&&!sr()){r.preventDefault();let c=dn(),l=(o=(n=it.value)==null?void 0:n.items[c])==null?void 0:o.id;if((a=(i=lr.value)==null?void 0:i.items[l])!=null&&a.location){Dt();let u=(s=lr.value)==null?void 0:s.items[l].location;if(qa()){let p=encodeURIComponent(wn()),[d,m]=u.split("#",2);u=`${d}?h=${p.replace(/%20/g,"+")}`,typeof m<"u"&&(u+=`#${m}`)}window.location.href=u}}else r.key==="Escape"&&!sr()&&(r.preventDefault(),Dt())},[t]),z("div",{class:Wu.container,children:[z(ku,{hidden:sr()}),z(Fu,{hidden:sr()})]})}function Ja(e,t){au(e),El(z(Vu,{}),t)}function go(){Dt()}function zu(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function qu(){return R(b(window,"compositionstart").pipe(f(()=>!0)),b(window,"compositionend").pipe(f(()=>!1))).pipe(J(!1))}function Xa(){let e=b(window,"keydown").pipe(f(t=>({mode:sr()?"global":"search",type:t.key,meta:t.ctrlKey||t.metaKey,claim(){t.preventDefault(),t.stopPropagation()}})),L(({mode:t,type:r})=>{if(t==="global"){let n=xt();if(typeof n!="undefined")return!zu(n,r)}return!0}),xe());return qu().pipe(g(t=>t?y:e))}function Ye(){return new URL(location.href)}function dt(e,t=!1){if(X("navigation.instant")&&!t){let r=A("a",{href:e.href});document.body.appendChild(r),r.click(),r.remove()}else location.href=e.href}function Za(){return new I}function Qa(){return location.hash.slice(1)}function es(e){let t=A("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function _o(e){return R(b(window,"hashchange"),e).pipe(f(Qa),J(Qa()),L(t=>t.length>0),se(1))}function ts(e){return _o(e).pipe(f(t=>Le(`[id="${t}"]`)),L(t=>typeof t!="undefined"))}function Ir(e){let t=matchMedia(e);return an(r=>t.addListener(()=>r(t.matches))).pipe(J(t.matches))}function rs(){let e=matchMedia("print");return R(b(window,"beforeprint").pipe(f(()=>!0)),b(window,"afterprint").pipe(f(()=>!1))).pipe(J(e.matches))}function yo(e,t){return e.pipe(g(r=>r?t():y))}function xo(e,t){return new U(r=>{let n=new XMLHttpRequest;return n.open("GET",`${e}`),n.responseType="blob",n.addEventListener("load",()=>{n.status>=200&&n.status<300?(r.next(n.response),r.complete()):r.error(new Error(n.statusText))}),n.addEventListener("error",()=>{r.error(new Error("Network error"))}),n.addEventListener("abort",()=>{r.complete()}),typeof(t==null?void 0:t.progress$)!="undefined"&&(n.addEventListener("progress",o=>{var i;if(o.lengthComputable)t.progress$.next(o.loaded/o.total*100);else{let a=(i=n.getResponseHeader("Content-Length"))!=null?i:0;t.progress$.next(o.loaded/+a*100)}}),t.progress$.next(5)),n.send(),()=>n.abort()})}function et(e,t){return xo(e,t).pipe(g(r=>r.text()),f(r=>JSON.parse(r)),se(1))}function En(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/html")),se(1))}function ns(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/xml")),se(1))}var wo={drawer:G("[data-md-toggle=drawer]"),search:G("[data-md-toggle=search]")};function Eo(e,t){wo[e].checked!==t&&wo[e].click()}function Tn(e){let t=wo[e];return b(t,"change").pipe(f(()=>t.checked),J(t.checked))}function os(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function is(){return R(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(f(os),J(os()))}function as(){return{width:innerWidth,height:innerHeight}}function ss(){return b(window,"resize",{passive:!0}).pipe(f(as),J(as()))}function cs(){return re([is(),ss()]).pipe(f(([e,t])=>({offset:e,size:t})),se(1))}function Sn(e,{viewport$:t,header$:r}){let n=t.pipe(fe("size")),o=re([n,r]).pipe(f(()=>wt(e)));return re([r,t,o]).pipe(f(([{height:i},{offset:a,size:s},{x:c,y:l}])=>({offset:{x:a.x-c,y:a.y-l+i},size:s})))}var Ku=G("#__config"),mr=JSON.parse(Ku.textContent);mr.base=`${new URL(mr.base,Ye())}`;function Ue(){return mr}function X(e){return mr.features.includes(e)}function Bt(e,t){return typeof t!="undefined"?mr.translations[e].replace("#",t.toString()):mr.translations[e]}function ht(e,t=document){return G(`[data-md-component=${e}]`,t)}function Ee(e,t=document){return P(`[data-md-component=${e}]`,t)}function Bu(e){let t=G(".md-typeset > :first-child",e);return b(t,"click",{once:!0}).pipe(f(()=>G(".md-typeset",e)),f(r=>({hash:__md_hash(r.innerHTML)})))}function ls(e){if(!X("announce.dismiss")||!e.childElementCount)return y;if(!e.hidden){let t=G(".md-typeset",e);__md_hash(t.innerHTML)===__md_get("__announce")&&(e.hidden=!0)}return j(()=>{let t=new I;return t.subscribe(({hash:r})=>{e.hidden=!0,__md_set("__announce",r)}),Bu(e).pipe($(r=>t.next(r)),V(()=>t.complete()),f(r=>H({ref:e},r)))})}function Yu(e,{target$:t}){return t.pipe(f(r=>({hidden:r!==e})))}function us(e,t){let r=new I;return r.subscribe(({hidden:n})=>{e.hidden=n}),Yu(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))}function To(e,t){return t==="inline"?A("div",{class:"md-tooltip md-tooltip--inline",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"})):A("div",{class:"md-tooltip",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"}))}function On(...e){return A("div",{class:"md-tooltip2",role:"dialog"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function ps(...e){return A("div",{class:"md-tooltip2",role:"tooltip"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function fs(e,t){if(t=t?`${t}_annotation_${e}`:void 0,t){let r=t?`#${t}`:void 0;return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("a",{href:r,class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}else return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("span",{class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}function ms(e){return A("button",{class:"md-code__button",title:Bt("clipboard.copy"),"data-clipboard-target":`#${e} > code`,"data-md-type":"copy"})}function ds(){return A("button",{class:"md-code__button",title:"Toggle line selection","data-md-type":"select"})}function hs(){return A("nav",{class:"md-code__nav"})}var Xu=_r(So());function bs(e){return A("ul",{class:"md-source__facts"},Object.entries(e).map(([t,r])=>A("li",{class:`md-source__fact md-source__fact--${t}`},typeof r=="number"?Li(r):r)))}function Oo(e){let t=`tabbed-control tabbed-control--${e}`;return A("div",{class:t,hidden:!0},A("button",{class:"tabbed-button",tabIndex:-1,"aria-hidden":"true"}))}function gs(e){return A("div",{class:"md-typeset__scrollwrap"},A("div",{class:"md-typeset__table"},e))}function Zu(e){var n;let t=Ue(),r=new URL(`../${e.version}/`,t.base);return A("li",{class:"md-version__item"},A("a",{href:`${r}`,class:"md-version__link"},e.title,((n=t.version)==null?void 0:n.alias)&&e.aliases.length>0&&A("span",{class:"md-version__alias"},e.aliases[0])))}function _s(e,t){var n;let r=Ue();return e=e.filter(o=>{var i;return!((i=o.properties)!=null&&i.hidden)}),A("div",{class:"md-version"},A("button",{class:"md-version__current","aria-label":Bt("select.version")},t.title,((n=r.version)==null?void 0:n.alias)&&t.aliases.length>0&&A("span",{class:"md-version__alias"},t.aliases[0])),A("ul",{class:"md-version__list"},e.map(Zu)))}var Qu=0;function ep(e,t=250){let r=re([ir(e),Ft(e,t)]).pipe(f(([o,i])=>o||i),ie()),n=j(()=>Ai(e)).pipe(oe(Ut),Lr(1),Ze(r),f(()=>Ci(e)));return r.pipe(Sr(o=>o),g(()=>re([r,n])),f(([o,i])=>({active:o,offset:i})),xe())}function Rr(e,t,r=250){let{content$:n,viewport$:o}=t,i=`__tooltip2_${Qu++}`;return j(()=>{let a=new I,s=new Un(!1);a.pipe(he(),ye(!1)).subscribe(s);let c=s.pipe(Tr(u=>Ve(+!u*250,Wn)),ie(),g(u=>u?n:y),$(u=>u.id=i),xe());re([a.pipe(f(({active:u})=>u)),c.pipe(g(u=>Ft(u,250)),J(!1))]).pipe(f(u=>u.some(p=>p))).subscribe(s);let l=s.pipe(L(u=>u),pe(c,o),f(([u,p,{size:d}])=>{let m=e.getBoundingClientRect(),h=m.width/2;if(p.role==="tooltip")return{x:h,y:8+m.height};if(m.y>=d.height/2){let{height:v}=Ae(p);return{x:h,y:-16-v}}else return{x:h,y:16+m.height}}));return re([c,a,l]).subscribe(([u,{offset:p},d])=>{u.style.setProperty("--md-tooltip-host-x",`${p.x}px`),u.style.setProperty("--md-tooltip-host-y",`${p.y}px`),u.style.setProperty("--md-tooltip-x",`${d.x}px`),u.style.setProperty("--md-tooltip-y",`${d.y}px`),u.classList.toggle("md-tooltip2--top",d.y<0),u.classList.toggle("md-tooltip2--bottom",d.y>=0)}),s.pipe(L(u=>u),pe(c,(u,p)=>p),L(u=>u.role==="tooltip")).subscribe(u=>{let p=Ae(G(":scope > *",u));u.style.setProperty("--md-tooltip-width",`${p.width}px`),u.style.setProperty("--md-tooltip-tail","0px")}),s.pipe(ie(),Ie(je),pe(c)).subscribe(([u,p])=>{p.classList.toggle("md-tooltip2--active",u)}),re([s.pipe(L(u=>u)),c]).subscribe(([u,p])=>{p.role==="dialog"?(e.setAttribute("aria-controls",i),e.setAttribute("aria-haspopup","dialog")):e.setAttribute("aria-describedby",i)}),s.pipe(L(u=>!u)).subscribe(()=>{e.removeAttribute("aria-controls"),e.removeAttribute("aria-describedby"),e.removeAttribute("aria-haspopup")}),ep(e,r).pipe($(u=>a.next(u)),V(()=>a.complete()),f(u=>H({ref:e},u)))})}function Ge(e,{viewport$:t},r=document.body){return Rr(e,{content$:new U(n=>{let o=e.title,i=ps(o);return n.next(i),e.removeAttribute("title"),r.append(i),()=>{i.remove(),e.setAttribute("title",o)}}),viewport$:t},0)}function tp(e,t){let r=j(()=>re([Hi(e),Ut(t)])).pipe(f(([{x:n,y:o},i])=>{let{width:a,height:s}=Ae(e);return{x:n-i.x+a/2,y:o-i.y+s/2}}));return ir(e).pipe(g(n=>r.pipe(f(o=>({active:n,offset:o})),Me(+!n||1/0))))}function ys(e,t,{target$:r}){let[n,o]=Array.from(e.children);return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({offset:s}){e.style.setProperty("--md-tooltip-x",`${s.x}px`),e.style.setProperty("--md-tooltip-y",`${s.y}px`)},complete(){e.style.removeProperty("--md-tooltip-x"),e.style.removeProperty("--md-tooltip-y")}}),Et(e).pipe(Q(a)).subscribe(s=>{e.toggleAttribute("data-md-visible",s)}),R(i.pipe(L(({active:s})=>s)),i.pipe(Be(250),L(({active:s})=>!s))).subscribe({next({active:s}){s?e.prepend(n):n.remove()},complete(){e.prepend(n)}}),i.pipe(Xe(16,je)).subscribe(({active:s})=>{n.classList.toggle("md-tooltip--active",s)}),i.pipe(Lr(125,je),L(()=>!!e.offsetParent),f(()=>e.offsetParent.getBoundingClientRect()),f(({x:s})=>s)).subscribe({next(s){s?e.style.setProperty("--md-tooltip-0",`${-s}px`):e.style.removeProperty("--md-tooltip-0")},complete(){e.style.removeProperty("--md-tooltip-0")}}),b(o,"click").pipe(Q(a),L(s=>!(s.metaKey||s.ctrlKey))).subscribe(s=>{s.stopPropagation(),s.preventDefault()}),b(o,"mousedown").pipe(Q(a),pe(i)).subscribe(([s,{active:c}])=>{var l;if(s.button!==0||s.metaKey||s.ctrlKey)s.preventDefault();else if(c){s.preventDefault();let u=e.parentElement.closest(".md-annotation");u instanceof HTMLElement?u.focus():(l=xt())==null||l.blur()}}),r.pipe(Q(a),L(s=>s===n),It(125)).subscribe(()=>e.focus()),tp(e,t).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function rp(e){let t=Ue();if(e.tagName!=="CODE")return[e];let r=[".c",".c1",".cm"];if(t.annotate){let n=e.closest("[class|=language]");if(n)for(let o of Array.from(n.classList)){if(!o.startsWith("language-"))continue;let[,i]=o.split("-");i in t.annotate&&r.push(...t.annotate[i])}}return P(r.join(", "),e)}function np(e){let t=[];for(let r of rp(e)){let n=[],o=document.createNodeIterator(r,NodeFilter.SHOW_TEXT);for(let i=o.nextNode();i;i=o.nextNode())n.push(i);for(let i of n){let a;for(;a=/(\(\d+\))(!)?/.exec(i.textContent);){let[,s,c]=a;if(typeof c=="undefined"){let l=i.splitText(a.index);i=l.splitText(s.length),t.push(l)}else{i.textContent=s,t.push(i);break}}}}return t}function xs(e,t){t.append(...Array.from(e.childNodes))}function Ln(e,t,{target$:r,print$:n}){let o=t.closest("[id]"),i=o==null?void 0:o.id,a=new Map;for(let s of np(t)){let[,c]=s.textContent.match(/\((\d+)\)/);Le(`:scope > li:nth-child(${c})`,e)&&(a.set(c,fs(c,i)),s.replaceWith(a.get(c)))}return a.size===0?y:j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=[];for(let[u,p]of a)l.push([G(".md-typeset",p),G(`:scope > li:nth-child(${u})`,e)]);return n.pipe(Q(c)).subscribe(u=>{e.hidden=!u,e.classList.toggle("md-annotation-list",u);for(let[p,d]of l)u?xs(p,d):xs(d,p)}),R(...[...a].map(([,u])=>ys(u,t,{target$:r}))).pipe(V(()=>s.complete()),xe())})}function ws(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return ws(t)}}function Es(e,t){return j(()=>{let r=ws(e);return typeof r!="undefined"?Ln(r,e,t):y})}var Ss=_r(Mo());var op=0,Ts=R(b(window,"keydown").pipe(f(()=>!0)),R(b(window,"keyup"),b(window,"contextmenu")).pipe(f(()=>!1))).pipe(J(!1),se(1));function Os(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return Os(t)}}function ip(e){return Re(e).pipe(f(({width:t})=>({scrollable:Mr(e).width>t})),fe("scrollable"))}function Ls(e,t){let{matches:r}=matchMedia("(hover)"),n=j(()=>{let o=new I,i=o.pipe(Gn(1));o.subscribe(({scrollable:m})=>{m&&r?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")});let a=[],s=e.closest("pre"),c=s.closest("[id]"),l=c?c.id:op++;s.id=`__code_${l}`;let u=[],p=e.closest(".highlight");if(p instanceof HTMLElement){let m=Os(p);if(typeof m!="undefined"&&(p.classList.contains("annotate")||X("content.code.annotate"))){let h=Ln(m,e,t);u.push(Re(p).pipe(Q(i),f(({width:v,height:x})=>v&&x),ie(),g(v=>v?h:y)))}}let d=P(":scope > span[id]",e);if(d.length&&(e.classList.add("md-code__content"),e.closest(".select")||X("content.code.select")&&!e.closest(".no-select"))){let m=+d[0].id.split("-").pop(),h=ds();a.push(h),X("content.tooltips")&&u.push(Ge(h,{viewport$}));let v=b(h,"click").pipe(Or(M=>!M,!1),$(()=>h.blur()),xe());v.subscribe(M=>{h.classList.toggle("md-code__button--active",M)});let x=me(d).pipe(oe(M=>Ft(M).pipe(f(O=>[M,O]))));v.pipe(g(M=>M?x:y)).subscribe(([M,O])=>{let N=Le(".hll.select",M);if(N&&!O)N.replaceWith(...Array.from(N.childNodes));else if(!N&&O){let ee=document.createElement("span");ee.className="hll select",ee.append(...Array.from(M.childNodes).slice(1)),M.append(ee)}});let w=me(d).pipe(oe(M=>b(M,"mousedown").pipe($(O=>O.preventDefault()),f(()=>M)))),E=v.pipe(g(M=>M?w:y),pe(Ts),f(([M,O])=>{var ee;let N=d.indexOf(M)+m;if(O===!1)return[N,N];{let le=P(".hll",e).map(ce=>d.indexOf(ce.parentElement)+m);return(ee=window.getSelection())==null||ee.removeAllRanges(),[Math.min(N,...le),Math.max(N,...le)]}})),_=_o(y).pipe(L(M=>M.startsWith(`__codelineno-${l}-`)));_.subscribe(M=>{let[,,O]=M.split("-"),N=O.split(":").map(le=>+le-m+1);N.length===1&&N.push(N[0]);for(let le of P(".hll:not(.select)",e))le.replaceWith(...Array.from(le.childNodes));let ee=d.slice(N[0]-1,N[1]);for(let le of ee){let ce=document.createElement("span");ce.className="hll",ce.append(...Array.from(le.childNodes).slice(1)),le.append(ce)}}),_.pipe(Me(1),Ie(ge)).subscribe(M=>{if(M.includes(":")){let O=document.getElementById(M.split(":")[0]);O&&setTimeout(()=>{let N=O,ee=-64;for(;N!==document.body;)ee+=N.offsetTop,N=N.offsetParent;window.scrollTo({top:ee})},1)}});let be=me(P('a[href^="#__codelineno"]',p)).pipe(oe(M=>b(M,"click").pipe($(O=>O.preventDefault()),f(()=>M)))).pipe(Q(i),pe(Ts),f(([M,O])=>{let ee=+G(`[id="${M.hash.slice(1)}"]`).parentElement.id.split("-").pop();if(O===!1)return[ee,ee];{let le=P(".hll",e).map(ce=>+ce.parentElement.id.split("-").pop());return[Math.min(ee,...le),Math.max(ee,...le)]}}));R(E,be).subscribe(M=>{let O=`#__codelineno-${l}-`;M[0]===M[1]?O+=M[0]:O+=`${M[0]}:${M[1]}`,history.replaceState({},"",O),window.dispatchEvent(new HashChangeEvent("hashchange",{newURL:window.location.origin+window.location.pathname+O,oldURL:window.location.href}))})}if(Ss.default.isSupported()&&(e.closest(".copy")||X("content.code.copy")&&!e.closest(".no-copy"))){let m=ms(s.id);a.push(m),X("content.tooltips")&&u.push(Ge(m,{viewport$}))}if(a.length){let m=hs();m.append(...a),s.insertBefore(m,e)}return ip(e).pipe($(m=>o.next(m)),V(()=>o.complete()),f(m=>H({ref:e},m)),Rt(R(...u).pipe(Q(i))))});return X("content.lazy")?Et(e).pipe(L(o=>o),Me(1),g(()=>n)):n}function ap(e,{target$:t,print$:r}){let n=!0;return R(t.pipe(f(o=>o.closest("details:not([open])")),L(o=>e===o),f(()=>({action:"open",reveal:!0}))),r.pipe(L(o=>o||!n),$(()=>n=e.open),f(o=>({action:o?"open":"close"}))))}function Ms(e,t){return j(()=>{let r=new I;return r.subscribe(({action:n,reveal:o})=>{e.toggleAttribute("open",n==="open"),o&&e.scrollIntoView()}),ap(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}var ks=0,As=new Map;function sp(e){let t=document.createElement("h3");t.innerHTML=e.innerHTML;let r=[t],n=e.nextElementSibling;for(;n&&!(n instanceof HTMLHeadingElement);)r.push(n.cloneNode(!0)),n=n.nextElementSibling;return r}function cp(e,t){for(let r of P("[href], [src]",e))for(let n of["href","src"]){let o=r.getAttribute(n);if(o&&!/^(?:[a-z]+:)?\/\//i.test(o)){r[n]=new URL(r.getAttribute(n),t).toString();break}}for(let r of P("[name^=__], [for]",e))for(let n of["id","for","name"]){let o=r.getAttribute(n);o&&r.setAttribute(n,`${o}$preview_${ks}`)}return ks++,Y(e)}function lp(e){let t=As.get(e.toString());return t?Y(t):En(e).pipe(g(r=>cp(r,e)),f(r=>(As.set(e.toString(),r),r)))}function Cs(e,t){let{sitemap$:r}=t;if(!(e instanceof HTMLAnchorElement))return y;if(!(X("navigation.instant.preview")||e.hasAttribute("data-preview")))return y;e.removeAttribute("title");let n=re([ir(e),Ft(e).pipe(ke(1))]).pipe(f(([i,a])=>i||a),ie(),L(i=>i));return $t([r,n]).pipe(g(([i])=>{let a=new URL(e.href);return a.search=a.hash="",i.has(`${a}`)?Y(a):y}),g(i=>lp(i)),g(i=>{let a=e.hash?`article [id="${decodeURIComponent(e.hash.slice(1))}"]`:"article h1",s=Le(a,i);return typeof s=="undefined"?y:Y(sp(s))})).pipe(g(i=>{let a=new U(s=>{let c=On(...i);return s.next(c),document.body.append(c),()=>c.remove()});return Rr(e,H({content$:a},t))}))}var Hs=".node circle,.node ellipse,.node path,.node polygon,.node rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}marker{fill:var(--md-mermaid-edge-color)!important}.edgeLabel .label rect{fill:#0000}.flowchartTitleText{fill:var(--md-mermaid-label-fg-color)}.label{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.label foreignObject{line-height:normal;overflow:visible}.label div .edgeLabel{color:var(--md-mermaid-label-fg-color)}.edgeLabel,.edgeLabel p,.label div .edgeLabel{background-color:var(--md-mermaid-label-bg-color)}.edgeLabel,.edgeLabel p{fill:var(--md-mermaid-label-bg-color);color:var(--md-mermaid-edge-color)}.edgePath .path,.flowchart-link{stroke:var(--md-mermaid-edge-color)}.edgePath .arrowheadPath{fill:var(--md-mermaid-edge-color);stroke:none}.cluster rect{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}.cluster span{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}g #flowchart-circleEnd,g #flowchart-circleStart,g #flowchart-crossEnd,g #flowchart-crossStart,g #flowchart-pointEnd,g #flowchart-pointStart{stroke:none}.classDiagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.classGroup line,g.classGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.classGroup text{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.classLabel .box{fill:var(--md-mermaid-label-bg-color);background-color:var(--md-mermaid-label-bg-color);opacity:1}.classLabel .label{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.node .divider{stroke:var(--md-mermaid-node-fg-color)}.relation{stroke:var(--md-mermaid-edge-color)}.cardinality{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.cardinality text{fill:inherit!important}defs marker.marker.composition.class path,defs marker.marker.dependency.class path,defs marker.marker.extension.class path{fill:var(--md-mermaid-edge-color)!important;stroke:var(--md-mermaid-edge-color)!important}defs marker.marker.aggregation.class path{fill:var(--md-mermaid-label-bg-color)!important;stroke:var(--md-mermaid-edge-color)!important}.statediagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.stateGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.stateGroup .state-title{fill:var(--md-mermaid-label-fg-color)!important;font-family:var(--md-mermaid-font-family)}g.stateGroup .composit{fill:var(--md-mermaid-label-bg-color)}.nodeLabel,.nodeLabel p{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}a .nodeLabel{text-decoration:underline}.node circle.state-end,.node circle.state-start,.start-state{fill:var(--md-mermaid-edge-color);stroke:none}.end-state-inner,.end-state-outer{fill:var(--md-mermaid-edge-color)}.end-state-inner,.node circle.state-end{stroke:var(--md-mermaid-label-bg-color)}.transition{stroke:var(--md-mermaid-edge-color)}[id^=state-fork] rect,[id^=state-join] rect{fill:var(--md-mermaid-edge-color)!important;stroke:none!important}.statediagram-cluster.statediagram-cluster .inner{fill:var(--md-default-bg-color)}.statediagram-cluster rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}.statediagram-state rect.divider{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}defs #statediagram-barbEnd{stroke:var(--md-mermaid-edge-color)}[id^=entity] path,[id^=entity] rect{fill:var(--md-default-bg-color)}.relationshipLine{stroke:var(--md-mermaid-edge-color)}defs .marker.oneOrMore.er *,defs .marker.onlyOne.er *,defs .marker.zeroOrMore.er *,defs .marker.zeroOrOne.er *{stroke:var(--md-mermaid-edge-color)!important}text:not([class]):last-child{fill:var(--md-mermaid-label-fg-color)}.actor{fill:var(--md-mermaid-sequence-actor-bg-color);stroke:var(--md-mermaid-sequence-actor-border-color)}text.actor>tspan{fill:var(--md-mermaid-sequence-actor-fg-color);font-family:var(--md-mermaid-font-family)}line{stroke:var(--md-mermaid-sequence-actor-line-color)}.actor-man circle,.actor-man line{fill:var(--md-mermaid-sequence-actorman-bg-color);stroke:var(--md-mermaid-sequence-actorman-line-color)}.messageLine0,.messageLine1{stroke:var(--md-mermaid-sequence-message-line-color)}.note{fill:var(--md-mermaid-sequence-note-bg-color);stroke:var(--md-mermaid-sequence-note-border-color)}.loopText,.loopText>tspan,.messageText,.noteText>tspan{stroke:none;font-family:var(--md-mermaid-font-family)!important}.messageText{fill:var(--md-mermaid-sequence-message-fg-color)}.loopText,.loopText>tspan{fill:var(--md-mermaid-sequence-loop-fg-color)}.noteText>tspan{fill:var(--md-mermaid-sequence-note-fg-color)}#arrowhead path{fill:var(--md-mermaid-sequence-message-line-color);stroke:none}.loopLine{fill:var(--md-mermaid-sequence-loop-bg-color);stroke:var(--md-mermaid-sequence-loop-border-color)}.labelBox{fill:var(--md-mermaid-sequence-label-bg-color);stroke:none}.labelText,.labelText>span{fill:var(--md-mermaid-sequence-label-fg-color);font-family:var(--md-mermaid-font-family)}.sequenceNumber{fill:var(--md-mermaid-sequence-number-fg-color)}rect.rect{fill:var(--md-mermaid-sequence-box-bg-color);stroke:none}rect.rect+text.text{fill:var(--md-mermaid-sequence-box-fg-color)}defs #sequencenumber{fill:var(--md-mermaid-sequence-number-bg-color)!important}";var ko,pp=0;function fp(){return typeof mermaid=="undefined"||mermaid instanceof Element?ar("https://unpkg.com/mermaid@11/dist/mermaid.min.js"):Y(void 0)}function $s(e){return e.classList.remove("mermaid"),ko||(ko=fp().pipe($(()=>mermaid.initialize({startOnLoad:!1,themeCSS:Hs,sequence:{actorFontSize:"16px",messageFontSize:"16px",noteFontSize:"16px"}})),f(()=>{}),se(1))),ko.subscribe(()=>Uo(null,null,function*(){e.classList.add("mermaid");let t=`__mermaid_${pp++}`,r=A("div",{class:"mermaid"}),n=e.textContent,{svg:o,fn:i}=yield mermaid.render(t,n),a=r.attachShadow({mode:"closed"});a.innerHTML=o,e.replaceWith(r),i==null||i(a)})),ko.pipe(f(()=>({ref:e})))}var Ps=A("table");function Is(e){return e.replaceWith(Ps),Ps.replaceWith(gs(e)),Y({ref:e})}function mp(e){let t=e.find(r=>r.checked)||e[0];return R(...e.map(r=>b(r,"change").pipe(f(()=>G(`label[for="${r.id}"]`))))).pipe(J(G(`label[for="${t.id}"]`)),f(r=>({active:r})))}function Rs(e,{viewport$:t,target$:r}){let n=G(".tabbed-labels",e),o=P(":scope > input",e),i=Oo("prev");e.append(i);let a=Oo("next");return e.append(a),j(()=>{let s=new I,c=s.pipe(he(),ye(!0));re([s,Re(e),Et(e)]).pipe(Q(c),Xe(1,je)).subscribe({next([{active:l},u]){let p=wt(l),{width:d}=Ae(l);e.style.setProperty("--md-indicator-x",`${p.x}px`),e.style.setProperty("--md-indicator-width",`${d}px`);let m=ln(n);(p.x<m.x||p.x+d>m.x+u.width)&&n.scrollTo({left:Math.max(0,p.x-16),behavior:"smooth"})},complete(){e.style.removeProperty("--md-indicator-x"),e.style.removeProperty("--md-indicator-width")}}),re([Ut(n),Re(n)]).pipe(Q(c)).subscribe(([l,u])=>{let p=Mr(n);i.hidden=l.x<16,a.hidden=l.x>p.width-u.width-16}),R(b(i,"click").pipe(f(()=>-1)),b(a,"click").pipe(f(()=>1))).pipe(Q(c)).subscribe(l=>{let{width:u}=Ae(n);n.scrollBy({left:u*l,behavior:"smooth"})}),r.pipe(Q(c),L(l=>o.includes(l))).subscribe(l=>l.click()),n.classList.add("tabbed-labels--linked");for(let l of o){let u=G(`label[for="${l.id}"]`);u.replaceChildren(A("a",{href:`#${u.htmlFor}`,tabIndex:-1},...Array.from(u.childNodes))),b(u.firstElementChild,"click").pipe(Q(c),L(p=>!(p.metaKey||p.ctrlKey)),$(p=>{p.preventDefault(),p.stopPropagation()})).subscribe(()=>{history.replaceState({},"",`#${u.htmlFor}`),u.click()})}return X("content.tabs.link")&&s.pipe(ke(1),pe(t)).subscribe(([{active:l},{offset:u}])=>{let p=l.innerText.trim();if(l.hasAttribute("data-md-switching"))l.removeAttribute("data-md-switching");else{let d=e.offsetTop-u.y;for(let h of P("[data-tabs]"))for(let v of P(":scope > input",h)){let x=G(`label[for="${v.id}"]`);if(x!==l&&x.innerText.trim()===p){x.setAttribute("data-md-switching",""),v.click();break}}window.scrollTo({top:e.offsetTop-d});let m=__md_get("__tabs")||[];__md_set("__tabs",[...new Set([p,...m])])}}),s.pipe(Q(c)).subscribe(()=>{for(let l of P("audio, video",e))l.offsetWidth&&l.autoplay?l.play().catch(()=>{}):l.pause()}),mp(o).pipe($(l=>s.next(l)),V(()=>s.complete()),f(l=>H({ref:e},l)))}).pipe(Ht(ge))}function js(e,t){let{viewport$:r,target$:n,print$:o}=t;return R(...P(".annotate:not(.highlight)",e).map(i=>Es(i,{target$:n,print$:o})),...P("pre:not(.mermaid) > code",e).map(i=>Ls(i,{target$:n,print$:o})),...P("a",e).map(i=>Cs(i,t)),...P("pre.mermaid",e).map(i=>$s(i)),...P("table:not([class])",e).map(i=>Is(i)),...P("details",e).map(i=>Ms(i,{target$:n,print$:o})),...P("[data-tabs]",e).map(i=>Rs(i,{viewport$:r,target$:n})),...P("[title]:not([data-preview])",e).filter(()=>X("content.tooltips")).map(i=>Ge(i,{viewport$:r})),...P(".footnote-ref",e).filter(()=>X("content.footnote.tooltips")).map(i=>Rr(i,{content$:new U(a=>{let s=new URL(i.href).hash.slice(1),c=Array.from(document.getElementById(s).cloneNode(!0).children),l=On(...c);return a.next(l),document.body.append(l),()=>l.remove()}),viewport$:r})))}function dp(e,{alert$:t}){return t.pipe(g(r=>R(Y(!0),Y(!1).pipe(It(2e3))).pipe(f(n=>({message:r,active:n})))))}function Fs(e,t){let r=G(".md-typeset",e);return j(()=>{let n=new I;return n.subscribe(({message:o,active:i})=>{e.classList.toggle("md-dialog--active",i),r.textContent=o}),dp(e,t).pipe($(o=>n.next(o)),V(()=>n.complete()),f(o=>H({ref:e},o)))})}function hp({viewport$:e}){if(!X("header.autohide"))return Y(!1);let t=e.pipe(f(({offset:{y:o}})=>o),Pt(2,1),f(([o,i])=>[o<i,i]),fe(0)),r=re([e,t]).pipe(L(([{offset:o},[,i]])=>Math.abs(i-o.y)>100),f(([,[o]])=>o),ie()),n=Tn("search");return re([e,n]).pipe(f(([{offset:o},i])=>o.y>400&&!i),ie(),g(o=>o?r:Y(!1)),J(!1))}function Us(e,t){return j(()=>re([Re(e),hp(t)])).pipe(f(([{height:r},n])=>({height:r,hidden:n})),ie((r,n)=>r.height===n.height&&r.hidden===n.hidden),se(1))}function Ns(e,{viewport$:t,header$:r,main$:n}){return j(()=>{let o=new I,i=o.pipe(he(),ye(!0));o.pipe(fe("active"),Ze(r)).subscribe(([{active:s},{hidden:c}])=>{e.classList.toggle("md-header--shadow",s&&!c),e.hidden=c});let a=me(P("[title]",e)).pipe(L(()=>X("content.tooltips")),oe(s=>Ge(s,{viewport$:t})));return n.subscribe(o),r.pipe(Q(i),f(s=>H({ref:e},s)),Rt(a.pipe(Q(i))))})}function vp(e,{viewport$:t,header$:r}){return Sn(e,{viewport$:t,header$:r}).pipe(f(({offset:{y:n}})=>{let{height:o}=Ae(e);return{active:o>0&&n>=o}}),fe("active"))}function Ds(e,t){return j(()=>{let r=new I;r.subscribe({next({active:o}){e.classList.toggle("md-header__title--active",o)},complete(){e.classList.remove("md-header__title--active")}});let n=Le(".md-content h1");return typeof n=="undefined"?y:vp(n,t).pipe($(o=>r.next(o)),V(()=>r.complete()),f(o=>H({ref:e},o)))})}function Ws(e,{viewport$:t,header$:r}){let n=r.pipe(f(({height:i})=>i),ie()),o=n.pipe(g(()=>Re(e).pipe(f(({height:i})=>({top:e.offsetTop,bottom:e.offsetTop+i})),fe("bottom"))));return re([n,o,t]).pipe(f(([i,{top:a,bottom:s},{offset:{y:c},size:{height:l}}])=>(l=Math.max(0,l-Math.max(0,a-c,i)-Math.max(0,l+c-s)),{offset:a-i,height:l,active:a-i<=c})),ie((i,a)=>i.offset===a.offset&&i.height===a.height&&i.active===a.active))}function bp(e){let t=__md_get("__palette")||{index:e.findIndex(n=>matchMedia(n.getAttribute("data-md-color-media")).matches)},r=Math.max(0,Math.min(t.index,e.length-1));return Y(...e).pipe(oe(n=>b(n,"change").pipe(f(()=>n))),J(e[r]),f(n=>({index:e.indexOf(n),color:{media:n.getAttribute("data-md-color-media"),scheme:n.getAttribute("data-md-color-scheme"),primary:n.getAttribute("data-md-color-primary"),accent:n.getAttribute("data-md-color-accent")}})),se(1))}function Vs(e){let t=P("input",e),r=A("meta",{name:"theme-color"});document.head.appendChild(r);let n=A("meta",{name:"color-scheme"});document.head.appendChild(n);let o=Ir("(prefers-color-scheme: light)");return j(()=>{let i=new I;return i.subscribe(a=>{if(document.body.setAttribute("data-md-color-switching",""),a.color.media==="(prefers-color-scheme)"){let s=matchMedia("(prefers-color-scheme: light)"),c=document.querySelector(s.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");a.color.scheme=c.getAttribute("data-md-color-scheme"),a.color.primary=c.getAttribute("data-md-color-primary"),a.color.accent=c.getAttribute("data-md-color-accent")}for(let[s,c]of Object.entries(a.color))document.body.setAttribute(`data-md-color-${s}`,c);for(let s=0;s<t.length;s++){let c=t[s].nextElementSibling;c instanceof HTMLElement&&(c.hidden=a.index!==s)}__md_set("__palette",a)}),b(e,"keydown").pipe(L(a=>a.key==="Enter"),pe(i,(a,s)=>s)).subscribe(({index:a})=>{a=(a+1)%t.length,t[a].click(),t[a].focus()}),i.pipe(f(()=>{let a=ht("header"),s=window.getComputedStyle(a);return n.content=s.colorScheme,s.backgroundColor.match(/\d+/g).map(c=>(+c).toString(16).padStart(2,"0")).join("")})).subscribe(a=>r.content=`#${a}`),i.pipe(Ie(ge)).subscribe(()=>{document.body.removeAttribute("data-md-color-switching")}),bp(t).pipe(Q(o.pipe(ke(1))),jt(),$(a=>i.next(a)),V(()=>i.complete()),f(a=>H({ref:e},a)))})}function zs(e,{progress$:t}){return j(()=>{let r=new I;return r.subscribe(({value:n})=>{e.style.setProperty("--md-progress-value",`${n}`)}),t.pipe($(n=>r.next({value:n})),V(()=>r.complete()),f(n=>({ref:e,value:n})))})}var qs='.v u{text-decoration:underline!important;text-decoration-style:wavy!important;text-decoration-thickness:1px!important}.p{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-backdrop)/var(--alpha-lighter));cursor:pointer;height:100%;pointer-events:auto;position:absolute;transition:opacity .25s;width:100%}.p.m{opacity:0;pointer-events:none;transition:opacity .35s}.r{align-items:center;background-color:initial;border:none;border-radius:var(--space-2);cursor:pointer;display:flex;flex-shrink:0;font-family:var(--font-family);height:36px;justify-content:center;outline:none;padding:0;position:relative;transition:background-color .25s,color .25s;width:36px;z-index:1}.r svg{stroke:rgb(var(--color-foreground));height:18px;opacity:.5;width:18px}.r:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.r:hover:before{opacity:1;transform:scale(1)}.r.c{cursor:auto}.r.c:before{display:none}.n{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background)/var(--alpha-light));border-radius:var(--space-3);box-shadow:0 0 60px #0000000d;display:flex;height:480px;overflow:hidden;pointer-events:auto;position:absolute;transition:transform .25s cubic-bezier(.16,1,.3,1),opacity .25s;width:640px}.n.l{opacity:0;pointer-events:none;transform:scale(1.1);transition:transform .25s .15s,opacity .15s}@media (max-width:680px){.n{border-radius:0;height:100%;width:100%}}.u{display:flex;flex-basis:min-content;flex-direction:column;flex-grow:1;flex-shrink:0}@keyframes d{0%{transform:scale(0)}50%{transform:scale(1.2)}to{transform:scale(1)}}.y{animation:d .25s ease-in-out;background:var(--color-highlight);border-radius:100%;color:#fff;font-size:8px;font-weight:700;height:12px;padding-top:1px;position:absolute;right:4px;top:4px;width:12px}.i{background-color:rgb(var(--color-background-subtle)/var(--alpha-lighter));flex-shrink:0;overflow:scroll;position:relative;transition:width .35s cubic-bezier(.16,1,.3,1),opacity .25s;width:200px}.i>*{transform:translate(0);transition:transform .25s cubic-bezier(.16,1,.3,1)}.i.l{opacity:0;width:0}.i.l>*{transform:translate(-48px)}@media (max-width:680px){.i{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background-subtle)/var(--alpha-light));box-shadow:0 0 60px #00000026;height:100%;position:absolute;right:0;top:0}}.w{border-bottom:1px solid rgb(var(--color-foreground)/var(--alpha-lightest));display:flex;gap:var(--space-1);padding:var(--space-2)}.k{-webkit-overflow-scrolling:touch;overflow:auto;overscroll-behavior:contain}.z{padding:8px 10px}.X{color:rgb(var(--color-foreground)/var(--alpha-light));padding:var(--space-2);position:absolute;width:200px}.X,.j{display:flex;flex-direction:column}.j{gap:2px;list-style:none;padding:0}.F,.j{margin:0}.F{font-size:16px;font-weight:400}.F,.I{padding:8px}.I{font-size:14px;margin:4px 0 0;opacity:.5}.I,.o{font-size:12px}.o{cursor:pointer;display:flex;padding:4px 8px;position:relative}.o:before{background-color:var(--color-highlight-transparent);border-radius:var(--space-1);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.o.g:before,.o:hover:before{opacity:1;transform:scale(1)}.o.g,.o:hover{color:var(--color-highlight)}.R{flex-grow:1}.R,.q{position:relative}.q{font-weight:700}.f{flex-grow:1}.f input{background:#0000;border:none;color:rgb(var(--color-foreground));font-family:var(--font-family);font-size:16px;height:100%;letter-spacing:-.25px;outline:none;width:100%}.b{color:rgb(var(--color-foreground)/var(--alpha-light));display:flex;flex-direction:column;gap:2px;line-height:1.3;list-style:none;margin:var(--space-2);margin-top:0;padding:0}.A,.b li{margin:0}.A{color:rgb(var(--color-foreground)/var(--alpha-lighter));font-size:12px;margin-top:var(--space-2);padding:0 18px}.a{border-radius:var(--space-2);color:inherit;cursor:pointer;display:flex;flex-direction:row;flex-grow:1;padding:8px 10px;position:relative;text-decoration:none}.a:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";display:block;inset:0;opacity:0;position:absolute;transform:scale(.9);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.a.h:before,.a:hover:before{opacity:1;transform:scale(1)}}.a mark{background:#0000;color:var(--color-highlight)}.a u{background-color:var(--color-highlight-transparent);border-radius:2px;box-shadow:0 0 0 1px var(--color-highlight-transparent);text-decoration:none}.B{flex-grow:1}.s{margin-right:-8px;opacity:0;position:relative;transform:translate(-2px);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.h>.s,:hover>.s{opacity:1;transform:none}}.x{font-size:14px;margin:0;position:relative}.x code{background:rgb(var(--color-background-subtle));border-radius:var(--space-1);font-size:13px;padding:2px 4px}.t{color:rgb(var(--color-foreground)/var(--alpha-lighter));display:inline-flex;flex-wrap:wrap;font-size:12px;gap:var(--space-1);list-style:none;margin:0;padding:0;position:relative}.t li{white-space:nowrap}.t li:after{content:"/";display:inline;margin-left:var(--space-1)}.t li:last-child:after{content:"";display:none}.e{--space-1:4px;--space-2:calc(var(--space-1)*2);--space-3:calc(var(--space-2)*2);--space-4:calc(var(--space-3)*2);--space-5:calc(var(--space-4)*2);--alpha-light:.7;--alpha-lighter:.54;--alpha-lightest:.1;--color-highlight:var(--md-accent-fg-color,#526cfe);--color-highlight-transparent:var(--md-accent-fg-color--transparent,#526cfe1a);--border-radius-1:var(--space-1);--border-radius-2:var(--space-2);--border-radius-3:calc(var(--space-1) + var(--space-2));--font-family:var(--md-text-font-family,Inter,Roboto Flex,system-ui,sans-serif);--font-size:16px;--line-height:1.5;--letter-spacing:-.5px;-webkit-font-smoothing:antialiased;align-items:center;display:flex;font-family:var(--font-family);font-size:var(--font-size);height:100vh;justify-content:center;letter-spacing:var(--letter-spacing);line-height:var(--line-height);pointer-events:none;position:absolute;width:100vw}@media (pointer:coarse){.e{height:-webkit-fill-available}}.e *,.e :after,.e :before{box-sizing:border-box}';function Ks(e,{index$:t}){let r=Ue(),n=document.createElement("div");document.body.appendChild(n),n.style.position="fixed",n.style.height="100%",n.style.top="0",n.style.zIndex="4";let o=n.attachShadow({mode:"open"});o.appendChild(A("style",{},qs.toString()));try{Ya(r.search,{highlight:r.features.includes("search.highlight")}),me(t).subscribe(i=>{for(let a of i.items)a.location=new URL(a.location,r.base).toString();Ja(i,o)}),b(e,"click").subscribe(()=>{go()}),Tn("search").pipe(ke(1)).subscribe(()=>go())}catch(i){e.hidden=!0;let a=G("label[for=__search]");a.hidden=!0}return Ke}var Bs=_r(So());function Ys(e,{index$:t,location$:r}){return re([t,r.pipe(J(Ye()),L(n=>!!n.searchParams.get("h")))]).pipe(f(([n,o])=>_p(n.config)(o.searchParams.get("h"))),f(n=>{var a;let o=new Map,i=document.createNodeIterator(e,NodeFilter.SHOW_TEXT);for(let s=i.nextNode();s;s=i.nextNode())if((a=s.parentElement)!=null&&a.offsetHeight){let c=s.textContent,l=n(c);l.length>c.length&&o.set(s,l)}for(let[s,c]of o){let{childNodes:l}=A("span",null,c);s.replaceWith(...Array.from(l))}return{ref:e,nodes:o}}))}function _p(e){let t=e.separator.split("|").map(o=>o.replace(/(\(\?[!=<][^)]+\))/g,"").length===0?"\uFFFD":o).join("|"),r=new RegExp(t,"img"),n=(o,i,a)=>`${i}<mark data-md-highlight>${a}</mark>`;return o=>{o=o.replace(/\s+/g," ").replace(/&/g,"&amp;").trim();let i=new RegExp(`(^|${e.separator}|)(${o.split(r).map(a=>a.replace(/[|\\{}()[\]^$+*?.-]/g,"\\$&")).filter(a=>a.length>0).join("|")})`,"img");return a=>(0,Bs.default)(a).replace(i,n).replace(/<\/mark>(\s+)<mark[^>]*>/img,"$1")}}function yp(e,{viewport$:t,main$:r}){let n=e.closest(".md-grid"),o=n.offsetTop-n.parentElement.offsetTop;return re([r,t]).pipe(f(([{offset:i,height:a},{offset:{y:s}}])=>(a=a+Math.min(o,Math.max(0,s-i))-o,{height:a,locked:s>=i+o})),ie((i,a)=>i.height===a.height&&i.locked===a.locked))}function Ao(e,n){var o=n,{header$:t}=o,r=gr(o,["header$"]);let i=G(".md-sidebar__scrollwrap",e),{y:a}=wt(i);return j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=s.pipe(Xe(0,je));return l.pipe(pe(t)).subscribe({next([{height:u},{height:p}]){i.style.height=`${u-2*a}px`,e.style.top=`${p}px`},complete(){i.style.height="",e.style.top=""}}),l.pipe(Sr()).subscribe(()=>{for(let u of P(".md-nav__link--active[href]",e)){if(!u.clientHeight)continue;let p=u.closest(".md-sidebar__scrollwrap");if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2})}}}),me(P("label[tabindex]",e)).pipe(oe(u=>b(u,"click").pipe(Ie(ge),f(()=>u),Q(c)))).subscribe(u=>{let p=G(`[id="${u.htmlFor}"]`);G(`[aria-labelledby="${u.id}"]`).setAttribute("aria-expanded",`${p.checked}`)}),X("content.tooltips")&&me(P("abbr[title]",e)).pipe(oe(u=>Ge(u,{viewport$})),Q(c)).subscribe(),yp(e,r).pipe($(u=>s.next(u)),V(()=>s.complete()),f(u=>H({ref:e},u)))})}function Gs(e,t){if(typeof t!="undefined"){let r=`https://api.github.com/repos/${e}/${t}`;return $t(et(`${r}/releases/latest`).pipe(_e(()=>y),f(n=>({version:n.tag_name})),ot({})),et(r).pipe(_e(()=>y),f(n=>({stars:n.stargazers_count,forks:n.forks_count})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}else{let r=`https://api.github.com/users/${e}`;return et(r).pipe(f(n=>({repositories:n.public_repos})),ot({}))}}function Js(e,t){let r=`https://${e}/api/v4/projects/${encodeURIComponent(t)}`;return $t(et(`${r}/releases/permalink/latest`).pipe(_e(()=>y),f(({tag_name:n})=>({version:n})),ot({})),et(r).pipe(_e(()=>y),f(({star_count:n,forks_count:o})=>({stars:n,forks:o})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}function Xs(e){let t=e.match(/^.+github\.com\/([^/]+)\/?([^/]+)?/i);if(t){let[,r,n]=t;return Gs(r,n)}if(t=e.match(/^.+?([^/]*gitlab[^/]+)\/(.+?)\/?$/i),t){let[,r,n]=t;return Js(r,n)}return y}var xp;function wp(e){return xp||(xp=j(()=>{let t=__md_get("__source",sessionStorage);if(t)return Y(t);if(Ee("consent").length){let n=__md_get("__consent");if(!(n&&n.github))return y}return Xs(e.href).pipe($(n=>__md_set("__source",n,sessionStorage)))}).pipe(_e(()=>y),L(t=>Object.keys(t).length>0),f(t=>({facts:t})),se(1)))}function Zs(e){let t=G(":scope > :last-child",e);return j(()=>{let r=new I;return r.subscribe(({facts:n})=>{t.appendChild(bs(n)),t.classList.add("md-source__repository--active")}),wp(e).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Ep(e,{viewport$:t,header$:r}){return Re(document.body).pipe(g(()=>Sn(e,{header$:r,viewport$:t})),f(({offset:{y:n}})=>({hidden:n>=10})),fe("hidden"))}function Qs(e,t){return j(()=>{let r=new I;return r.subscribe({next({hidden:n}){e.hidden=n},complete(){e.hidden=!1}}),(X("navigation.tabs.sticky")?Y({hidden:!1}):Ep(e,t)).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Tp(e,{viewport$:t,header$:r}){let n=new Map,o=P(".md-nav__link",e);for(let s of o){let c=decodeURIComponent(s.hash.substring(1)),l=Le(`[id="${c}"]`);typeof l!="undefined"&&n.set(s,l)}let i=r.pipe(fe("height"),f(({height:s})=>{let c=ht("main"),l=G(":scope > :first-child",c);return s+.9*(l.offsetTop-c.offsetTop)}),xe());return Re(document.body).pipe(fe("height"),g(s=>j(()=>{let c=[];return Y([...n].reduce((l,[u,p])=>{for(;c.length&&n.get(c[c.length-1]).tagName>=p.tagName;)c.pop();let d=p.offsetTop;for(;!d&&p.parentElement;)p=p.parentElement,d=p.offsetTop;let m=p.offsetParent;for(;m;m=m.offsetParent)d+=m.offsetTop;return l.set([...c=[...c,u]].reverse(),d)},new Map))}).pipe(f(c=>new Map([...c].sort(([,l],[,u])=>l-u))),Ze(i),g(([c,l])=>t.pipe(Or(([u,p],{offset:{y:d},size:m})=>{let h=d+m.height>=Math.floor(s.height);for(;p.length;){let[,v]=p[0];if(v-l<d||h)u=[...u,p.shift()];else break}for(;u.length;){let[,v]=u[u.length-1];if(v-l>=d&&!h)p=[u.pop(),...p];else break}return[u,p]},[[],[...c]]),ie((u,p)=>u[0]===p[0]&&u[1]===p[1])))))).pipe(f(([s,c])=>({prev:s.map(([l])=>l),next:c.map(([l])=>l)})),J({prev:[],next:[]}),Pt(2,1),f(([s,c])=>s.prev.length<c.prev.length?{prev:c.prev.slice(Math.max(0,s.prev.length-1),c.prev.length),next:[]}:{prev:c.prev.slice(-1),next:c.next.slice(0,c.next.length-s.next.length)}))}function ec(e,{viewport$:t,header$:r,main$:n,target$:o}){return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));if(i.subscribe(({prev:s,next:c})=>{for(let[l]of c)l.classList.remove("md-nav__link--passed"),l.classList.remove("md-nav__link--active");for(let[l,[u]]of s.entries())u.classList.add("md-nav__link--passed"),u.classList.toggle("md-nav__link--active",l===s.length-1)}),X("toc.follow")){let s=R(t.pipe(Be(1),f(()=>{})),t.pipe(Be(250),f(()=>"smooth")));i.pipe(L(({prev:c})=>c.length>0),Ze(n.pipe(Ie(ge))),pe(s)).subscribe(([[{prev:c}],l])=>{let[u]=c[c.length-1];if(u.offsetHeight){let p=ki(u);if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2,behavior:l})}}})}return X("navigation.tracking")&&t.pipe(Q(a),fe("offset"),Be(250),ke(1),Q(o.pipe(ke(1))),jt({delay:250}),pe(i)).subscribe(([,{prev:s}])=>{let c=Ye(),l=s[s.length-1];if(l&&l.length){let[u]=l,{hash:p}=new URL(u.href);c.hash!==p&&(c.hash=p,history.replaceState({},"",`${c}`))}else c.hash="",history.replaceState({},"",`${c}`)}),Tp(e,{viewport$:t,header$:r}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function Sp(e,{viewport$:t,main$:r,target$:n}){let o=t.pipe(f(({offset:{y:a}})=>a),Pt(2,1),f(([a,s])=>a>s&&s>0),ie()),i=r.pipe(f(({active:a})=>a));return re([i,o]).pipe(f(([a,s])=>!(a&&s)),ie(),Q(n.pipe(ke(1))),ye(!0),jt({delay:250}),f(a=>({hidden:a})))}function tc(e,{viewport$:t,header$:r,main$:n,target$:o}){let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({hidden:s}){e.hidden=s,s?(e.setAttribute("tabindex","-1"),e.blur()):e.removeAttribute("tabindex")},complete(){e.style.top="",e.hidden=!0,e.removeAttribute("tabindex")}}),r.pipe(Q(a),fe("height")).subscribe(({height:s})=>{e.style.top=`${s+16}px`}),b(e,"click").subscribe(s=>{s.preventDefault(),window.scrollTo({top:0})}),Sp(e,{viewport$:t,main$:n,target$:o}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))}function rc(e,t){return e.protocol=t.protocol,e.hostname=t.hostname,t.port&&(e.port=t.port),e}function Op(e,t){let r=new Map;for(let n of P("url",e)){let o=G("loc",n),i=[rc(new URL(o.textContent),t)];r.set(`${i[0]}`,i);for(let a of P("[rel=alternate]",n)){let s=a.getAttribute("href");s!=null&&i.push(rc(new URL(s),t))}}return r}function dr(e){return ns(new URL("sitemap.xml",e)).pipe(f(t=>Op(t,new URL(e))),_e(()=>Y(new Map)),xe())}function nc({document$:e}){let t=new Map;e.pipe(g(()=>P("link[rel=alternate]")),f(r=>new URL(r.href)),L(r=>!t.has(r.toString())),oe(r=>dr(r).pipe(f(n=>[r,n]),_e(()=>y)))).subscribe(([r,n])=>{t.set(r.toString().replace(/\/$/,""),n)}),b(document.body,"click").pipe(L(r=>!r.metaKey&&!r.ctrlKey),g(r=>{if(r.target instanceof Element){let n=r.target.closest("a");if(n&&!n.target){let o=[...t].find(([p])=>n.href.startsWith(`${p}/`));if(typeof o=="undefined")return y;let[i,a]=o,s=Ye();if(s.href.startsWith(i))return y;let c=Ue(),l=s.href.replace(c.base,"");l=`${i}/${l}`;let u=a.has(l.split("#")[0])?new URL(l,c.base):new URL(i);return r.preventDefault(),Y(u)}}return y})).subscribe(r=>dt(r,!0))}var Co=_r(Mo());function Lp(e){e.setAttribute("data-md-copying","");let t=e.closest("[data-copy]"),r=t?t.getAttribute("data-copy"):e.innerText;return e.removeAttribute("data-md-copying"),r.trimEnd()}function oc({alert$:e}){Co.default.isSupported()&&new U(t=>{new Co.default("[data-clipboard-target], [data-clipboard-text]",{text:r=>r.getAttribute("data-clipboard-text")||Lp(G(r.getAttribute("data-clipboard-target")))}).on("success",r=>t.next(r))}).pipe($(t=>{t.trigger.focus()}),f(()=>Bt("clipboard.copied"))).subscribe(e)}function ic(e,t){if(!(e.target instanceof Element))return y;let r=e.target.closest("a");if(r===null)return y;if(r.target||e.metaKey||e.ctrlKey)return y;let n=new URL(r.href);return n.search=n.hash="",t.has(`${n}`)?(e.preventDefault(),Y(r)):y}function ac(e){let t=new Map;for(let r of P(":scope > *",e.head))t.set(r.outerHTML,r);return t}function sc(e){for(let t of P("[href], [src]",e))for(let r of["href","src"]){let n=t.getAttribute(r);if(n&&!/^(?:[a-z]+:)?\/\//i.test(n)){t[r]=t[r];break}}return Y(e)}function Mp(e){for(let n of["[data-md-component=announce]","[data-md-component=container]","[data-md-component=header-topic]","[data-md-component=outdated]","[data-md-component=logo]","[data-md-component=skip]",...X("navigation.tabs.sticky")?["[data-md-component=tabs]"]:[]]){let o=Le(n),i=Le(n,e);typeof o!="undefined"&&typeof i!="undefined"&&o.replaceWith(i)}let t=ac(document);for(let[n,o]of ac(e))t.has(n)?t.delete(n):document.head.appendChild(o);for(let n of t.values()){let o=n.getAttribute("name");o!=="theme-color"&&o!=="color-scheme"&&n.remove()}let r=ht("container");return nt(P("script",r)).pipe(g(n=>{let o=e.createElement("script");if(n.src){for(let i of n.getAttributeNames())o.setAttribute(i,n.getAttribute(i));return n.replaceWith(o),new U(i=>{o.onload=()=>i.complete()})}else return o.textContent=n.textContent,n.replaceWith(o),y}),he(),ye(document))}function cc({sitemap$:e,location$:t,viewport$:r,progress$:n}){if(location.protocol==="file:")return Ke;Y(document).subscribe(sc);let o=b(document.body,"click").pipe(Ze(e),g(([s,c])=>ic(s,c)),f(({href:s})=>new URL(s)),xe()),i=b(window,"popstate").pipe(f(Ye),xe());o.pipe(pe(r)).subscribe(([s,{offset:c}])=>{history.replaceState(c,""),history.pushState(null,"",s)}),R(o,i).subscribe(t);let a=t.pipe(fe("pathname"),g(s=>En(s,{progress$:n}).pipe(_e(()=>(dt(s,!0),y)))),g(sc),g(Mp),xe());return R(a.pipe(pe(t,(s,c)=>c)),a.pipe(g(()=>t),fe("hash")),t.pipe(ie((s,c)=>s.pathname===c.pathname&&s.hash===c.hash),g(()=>o),$(()=>history.back()))).subscribe(s=>{var c,l;history.state!==null||!s.hash?window.scrollTo(0,(l=(c=history.state)==null?void 0:c.y)!=null?l:0):(history.scrollRestoration="auto",es(s.hash),history.scrollRestoration="manual")}),t.subscribe(()=>{history.scrollRestoration="manual"}),b(window,"beforeunload").subscribe(()=>{history.scrollRestoration="auto"}),r.pipe(fe("offset"),Be(100)).subscribe(({offset:s})=>{history.replaceState(s,"")}),X("navigation.instant.prefetch")&&R(b(document.body,"mousemove"),b(document.body,"focusin")).pipe(Ze(e),g(([s,c])=>ic(s,c)),Be(25),Yn(({href:s})=>s),cn(s=>{let c=document.createElement("link");return c.rel="prefetch",c.href=s.toString(),document.head.appendChild(c),b(c,"load").pipe(f(()=>c),Me(1))})).subscribe(s=>s.remove()),a}function lc(e){var u;let{selectedVersionSitemap:t,selectedVersionBaseURL:r,currentLocation:n,currentBaseURL:o}=e,i=(u=Ho(o))==null?void 0:u.pathname;if(i===void 0)return;let a=kp(n.pathname,i);if(a===void 0)return;let s=Cp(t.keys());if(!t.has(s))return;let c=Ho(a,s);if(!c||!t.has(c.href))return;let l=Ho(a,r);if(l)return l.hash=n.hash,l.search=n.search,l}function Ho(e,t){try{return new URL(e,t)}catch(r){return}}function kp(e,t){if(e.startsWith(t))return e.slice(t.length)}function Ap(e,t){let r=Math.min(e.length,t.length),n;for(n=0;n<r&&e[n]===t[n];++n);return n}function Cp(e){let t;for(let r of e)t===void 0?t=r:t=t.slice(0,Ap(t,r));return t!=null?t:""}function uc({document$:e}){let t=Ue(),r=et(new URL("../versions.json",t.base)).pipe(_e(()=>y)),n=r.pipe(f(o=>{let[,i]=t.base.match(/([^/]+)\/?$/);return o.find(({version:a,aliases:s})=>a===i||s.includes(i))||o[0]}));r.pipe(f(o=>new Map(o.map(i=>[`${new URL(`../${i.version}/`,t.base)}`,i]))),g(o=>b(document.body,"click").pipe(L(i=>!i.metaKey&&!i.ctrlKey),pe(n),g(([i,a])=>{if(i.target instanceof Element){let s=i.target.closest("a");if(s&&!s.target&&o.has(s.href)){let c=s.href;return!i.target.closest(".md-version")&&o.get(c)===a?y:(i.preventDefault(),Y(new URL(c)))}}return y}),g(i=>dr(i).pipe(f(a=>{var s;return(s=lc({selectedVersionSitemap:a,selectedVersionBaseURL:i,currentLocation:Ye(),currentBaseURL:t.base}))!=null?s:i})))))).subscribe(o=>dt(o,!0)),re([r,n]).subscribe(([o,i])=>{G(".md-header__topic").appendChild(_s(o,i))}),e.pipe(g(()=>n)).subscribe(o=>{var s;let i=new URL(t.base),a=__md_get("__outdated",sessionStorage,i);if(a===null){a=!0;let c=((s=t.version)==null?void 0:s.default)||"latest";Array.isArray(c)||(c=[c]);e:for(let l of c)for(let u of o.aliases.concat(o.version))if(new RegExp(l,"i").test(u)){a=!1;break e}__md_set("__outdated",a,sessionStorage,i)}if(a)for(let c of Ee("outdated"))c.hidden=!1})}function pc({document$:e,viewport$:t}){e.pipe(g(()=>P(".md-ellipsis")),oe(r=>Et(r).pipe(Q(e.pipe(ke(1))),L(n=>n),f(()=>r),Me(1))),L(r=>r.offsetWidth<r.scrollWidth),oe(r=>{let n=r.innerText,o=r.closest("a")||r;return o.title=n,X("content.tooltips")?Ge(o,{viewport$:t}).pipe(Q(e.pipe(ke(1))),V(()=>o.removeAttribute("title"))):y})).subscribe(),X("content.tooltips")&&e.pipe(g(()=>P(".md-status")),oe(r=>Ge(r,{viewport$:t}))).subscribe()}function fc({document$:e,tablet$:t}){e.pipe(g(()=>P(".md-toggle--indeterminate")),$(r=>{r.indeterminate=!0,r.checked=!1}),oe(r=>b(r,"change").pipe(Xn(()=>r.classList.contains("md-toggle--indeterminate")),f(()=>r))),pe(t)).subscribe(([r,n])=>{r.classList.remove("md-toggle--indeterminate"),n&&(r.checked=!1)})}function Hp(){return/(iPad|iPhone|iPod)/.test(navigator.userAgent)}function mc({document$:e}){e.pipe(g(()=>P("[data-md-scrollfix]")),$(t=>t.removeAttribute("data-md-scrollfix")),L(Hp),oe(t=>b(t,"touchstart").pipe(f(()=>t)))).subscribe(t=>{let r=t.scrollTop;r===0?t.scrollTop=1:r+t.offsetHeight===t.scrollHeight&&(t.scrollTop=r-1)})}Object.entries||(Object.entries=function(e){let t=[];for(let r of Object.keys(e))t.push([r,e[r]]);return t});Object.values||(Object.values=function(e){let t=[];for(let r of Object.keys(e))t.push(e[r]);return t});typeof Element!="undefined"&&(Element.prototype.scrollTo||(Element.prototype.scrollTo=function(e,t){typeof e=="object"?(this.scrollLeft=e.left,this.scrollTop=e.top):(this.scrollLeft=e,this.scrollTop=t)}),Element.prototype.replaceWith||(Element.prototype.replaceWith=function(...e){let t=this.parentNode;if(t){e.length===0&&t.removeChild(this);for(let r=e.length-1;r>=0;r--){let n=e[r];typeof n=="string"?n=document.createTextNode(n):n.parentNode&&n.parentNode.removeChild(n),r?t.insertBefore(this.previousSibling,n):t.replaceChild(n,this)}}}));function $p(){return location.protocol==="file:"?ar(`${new URL("search.js",Mn.base)}`).pipe(f(()=>__index),_e(()=>Ke),se(1)):et(new URL("search.json",Mn.base))}document.documentElement.classList.remove("no-js");document.documentElement.classList.add("js");var vt=Si(),Ur=Za(),hr=ts(Ur),hc=Xa(),ze=cs(),$o=Ir("(min-width: 60em)"),vc=Ir("(min-width: 76.25em)"),bc=rs(),Mn=Ue(),gc=Le(".md-search")?$p():Ke,Po=new I;oc({alert$:Po});nc({document$:vt});var Io=new I,_c=dr(Mn.base);X("navigation.instant")&&cc({sitemap$:_c,location$:Ur,viewport$:ze,progress$:Io}).subscribe(vt);var dc;((dc=Mn.version)==null?void 0:dc.provider)==="mike"&&uc({document$:vt});R(Ur,hr).pipe(It(125)).subscribe(()=>{Eo("drawer",!1),Eo("search",!1)});hc.pipe(L(({mode:e,meta:t})=>e==="global"&&!t)).subscribe(e=>{switch(e.type){case",":case"p":let t=document.querySelector("link[rel=prev]");t instanceof HTMLLinkElement&&dt(t);break;case".":case"n":let r=document.querySelector("link[rel=next]");r instanceof HTMLLinkElement&&dt(r);break;case"/":let n=document.querySelector("[data-md-component=search] button");n instanceof HTMLButtonElement&&n.click();break;case"Enter":let o=xt();o instanceof HTMLLabelElement&&o.click()}});pc({viewport$:ze,document$:vt});fc({document$:vt,tablet$:$o});mc({document$:vt});var Lt=Us(ht("header"),{viewport$:ze}),Fr=vt.pipe(f(()=>ht("main")),g(e=>Ws(e,{viewport$:ze,header$:Lt})),se(1)),Pp=R(...Ee("consent").map(e=>us(e,{target$:hr})),...Ee("dialog").map(e=>Fs(e,{alert$:Po})),...Ee("palette").map(e=>Vs(e)),...Ee("progress").map(e=>zs(e,{progress$:Io})),...Ee("search").map(e=>Ks(e,{index$:gc})),...Ee("source").map(e=>Zs(e))),Ip=j(()=>R(...Ee("announce").map(e=>ls(e)),...Ee("content").map(e=>js(e,{sitemap$:_c,viewport$:ze,target$:hr,print$:bc})),...Ee("content").map(e=>X("search.highlight")?Ys(e,{index$:gc,location$:Ur}):y),...Ee("header").map(e=>Ns(e,{viewport$:ze,header$:Lt,main$:Fr})),...Ee("header-title").map(e=>Ds(e,{viewport$:ze,header$:Lt})),...Ee("sidebar").map(e=>e.getAttribute("data-md-type")==="navigation"?yo(vc,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr})):yo($o,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr}))),...Ee("tabs").map(e=>Qs(e,{viewport$:ze,header$:Lt})),...Ee("toc").map(e=>ec(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})),...Ee("top").map(e=>tc(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})))),yc=vt.pipe(g(()=>Ip),Rt(Pp),se(1));yc.subscribe();window.document$=vt;window.location$=Ur;window.target$=hr;window.keyboard$=hc;window.viewport$=ze;window.tablet$=$o;window.screen$=vc;window.print$=bc;window.alert$=Po;window.progress$=Io;window.component$=yc;})();
-/*! update cache: 20260331044451 */
+/*! update cache: 20260331053143 */
diff --git a/en/assets/javascripts/bundle.c2b142ea.min.js b/en/assets/javascripts/bundle.c2b142ea.min.js
index c88793c85..7f19f1463 100644
--- a/en/assets/javascripts/bundle.c2b142ea.min.js
+++ b/en/assets/javascripts/bundle.c2b142ea.min.js
@@ -1,4 +1,4 @@
 "use strict";(()=>{var xc=Object.create;var kn=Object.defineProperty,wc=Object.defineProperties,Ec=Object.getOwnPropertyDescriptor,Tc=Object.getOwnPropertyDescriptors,Sc=Object.getOwnPropertyNames,Dr=Object.getOwnPropertySymbols,Oc=Object.getPrototypeOf,An=Object.prototype.hasOwnProperty,Fo=Object.prototype.propertyIsEnumerable;var jo=(e,t,r)=>t in e?kn(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,H=(e,t)=>{for(var r in t||(t={}))An.call(t,r)&&jo(e,r,t[r]);if(Dr)for(var r of Dr(t))Fo.call(t,r)&&jo(e,r,t[r]);return e},He=(e,t)=>wc(e,Tc(t));var gr=(e,t)=>{var r={};for(var n in e)An.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&Dr)for(var n of Dr(e))t.indexOf(n)<0&&Fo.call(e,n)&&(r[n]=e[n]);return r};var Cn=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Lc=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Sc(t))!An.call(e,o)&&o!==r&&kn(e,o,{get:()=>t[o],enumerable:!(n=Ec(t,o))||n.enumerable});return e};var _r=(e,t,r)=>(r=e!=null?xc(Oc(e)):{},Lc(t||!e||!e.__esModule?kn(r,"default",{value:e,enumerable:!0}):r,e));var Uo=(e,t,r)=>new Promise((n,o)=>{var i=c=>{try{s(r.next(c))}catch(l){o(l)}},a=c=>{try{s(r.throw(c))}catch(l){o(l)}},s=c=>c.done?n(c.value):Promise.resolve(c.value).then(i,a);s((r=r.apply(e,t)).next())});var Do=Cn((Hn,No)=>{(function(e,t){typeof Hn=="object"&&typeof No!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(Hn,(function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(_){return!!(_&&_!==document&&_.nodeName!=="HTML"&&_.nodeName!=="BODY"&&"classList"in _&&"contains"in _.classList)}function c(_){var de=_.type,be=_.tagName;return!!(be==="INPUT"&&a[de]&&!_.readOnly||be==="TEXTAREA"&&!_.readOnly||_.isContentEditable)}function l(_){_.classList.contains("focus-visible")||(_.classList.add("focus-visible"),_.setAttribute("data-focus-visible-added",""))}function u(_){_.hasAttribute("data-focus-visible-added")&&(_.classList.remove("focus-visible"),_.removeAttribute("data-focus-visible-added"))}function p(_){_.metaKey||_.altKey||_.ctrlKey||(s(r.activeElement)&&l(r.activeElement),n=!0)}function d(_){n=!1}function m(_){s(_.target)&&(n||c(_.target))&&l(_.target)}function h(_){s(_.target)&&(_.target.classList.contains("focus-visible")||_.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(_.target))}function v(_){document.visibilityState==="hidden"&&(o&&(n=!0),x())}function x(){document.addEventListener("mousemove",E),document.addEventListener("mousedown",E),document.addEventListener("mouseup",E),document.addEventListener("pointermove",E),document.addEventListener("pointerdown",E),document.addEventListener("pointerup",E),document.addEventListener("touchmove",E),document.addEventListener("touchstart",E),document.addEventListener("touchend",E)}function w(){document.removeEventListener("mousemove",E),document.removeEventListener("mousedown",E),document.removeEventListener("mouseup",E),document.removeEventListener("pointermove",E),document.removeEventListener("pointerdown",E),document.removeEventListener("pointerup",E),document.removeEventListener("touchmove",E),document.removeEventListener("touchstart",E),document.removeEventListener("touchend",E)}function E(_){_.target.nodeName&&_.target.nodeName.toLowerCase()==="html"||(n=!1,w())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",d,!0),document.addEventListener("pointerdown",d,!0),document.addEventListener("touchstart",d,!0),document.addEventListener("visibilitychange",v,!0),x(),r.addEventListener("focus",m,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)}))});var So=Cn((M0,vs)=>{"use strict";var Gu=/["'&<>]/;vs.exports=Ju;function Ju(e){var t=""+e,r=Gu.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i<t.length;i++){switch(t.charCodeAt(i)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}a!==i&&(o+=t.substring(a,i)),a=i+1,o+=n}return a!==i?o+t.substring(a,i):o}});var Mo=Cn((jr,Lo)=>{(function(t,r){typeof jr=="object"&&typeof Lo=="object"?Lo.exports=r():typeof define=="function"&&define.amd?define([],r):typeof jr=="object"?jr.ClipboardJS=r():t.ClipboardJS=r()})(jr,function(){return(function(){var e={686:(function(n,o,i){"use strict";i.d(o,{default:function(){return vr}});var a=i(279),s=i.n(a),c=i(370),l=i.n(c),u=i(817),p=i.n(u);function d(B){try{return document.execCommand(B)}catch(C){return!1}}var m=function(C){var k=p()(C);return d("cut"),k},h=m;function v(B){var C=document.documentElement.getAttribute("dir")==="rtl",k=document.createElement("textarea");k.style.fontSize="12pt",k.style.border="0",k.style.padding="0",k.style.margin="0",k.style.position="absolute",k.style[C?"right":"left"]="-9999px";var D=window.pageYOffset||document.documentElement.scrollTop;return k.style.top="".concat(D,"px"),k.setAttribute("readonly",""),k.value=B,k}var x=function(C,k){var D=v(C);k.container.appendChild(D);var W=p()(D);return d("copy"),D.remove(),W},w=function(C){var k=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},D="";return typeof C=="string"?D=x(C,k):C instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(C==null?void 0:C.type)?D=x(C.value,k):(D=p()(C),d("copy")),D},E=w;function _(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?_=function(k){return typeof k}:_=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},_(B)}var de=function(){var C=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},k=C.action,D=k===void 0?"copy":k,W=C.container,Z=C.target,We=C.text;if(D!=="copy"&&D!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(Z!==void 0)if(Z&&_(Z)==="object"&&Z.nodeType===1){if(D==="copy"&&Z.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(D==="cut"&&(Z.hasAttribute("readonly")||Z.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(We)return E(We,{container:W});if(Z)return D==="cut"?h(Z):E(Z,{container:W})},be=de;function M(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?M=function(k){return typeof k}:M=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},M(B)}function O(B,C){if(!(B instanceof C))throw new TypeError("Cannot call a class as a function")}function N(B,C){for(var k=0;k<C.length;k++){var D=C[k];D.enumerable=D.enumerable||!1,D.configurable=!0,"value"in D&&(D.writable=!0),Object.defineProperty(B,D.key,D)}}function ee(B,C,k){return C&&N(B.prototype,C),k&&N(B,k),B}function le(B,C){if(typeof C!="function"&&C!==null)throw new TypeError("Super expression must either be null or a function");B.prototype=Object.create(C&&C.prototype,{constructor:{value:B,writable:!0,configurable:!0}}),C&&ce(B,C)}function ce(B,C){return ce=Object.setPrototypeOf||function(D,W){return D.__proto__=W,D},ce(B,C)}function Ne(B){var C=st();return function(){var D=tt(B),W;if(C){var Z=tt(this).constructor;W=Reflect.construct(D,arguments,Z)}else W=D.apply(this,arguments);return bt(this,W)}}function bt(B,C){return C&&(M(C)==="object"||typeof C=="function")?C:De(B)}function De(B){if(B===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return B}function st(){if(typeof Reflect=="undefined"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(B){return!1}}function tt(B){return tt=Object.setPrototypeOf?Object.getPrototypeOf:function(k){return k.__proto__||Object.getPrototypeOf(k)},tt(B)}function Yt(B,C){var k="data-clipboard-".concat(B);if(C.hasAttribute(k))return C.getAttribute(k)}var Mt=(function(B){le(k,B);var C=Ne(k);function k(D,W){var Z;return O(this,k),Z=C.call(this),Z.resolveOptions(W),Z.listenClick(D),Z}return ee(k,[{key:"resolveOptions",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof W.action=="function"?W.action:this.defaultAction,this.target=typeof W.target=="function"?W.target:this.defaultTarget,this.text=typeof W.text=="function"?W.text:this.defaultText,this.container=M(W.container)==="object"?W.container:document.body}},{key:"listenClick",value:function(W){var Z=this;this.listener=l()(W,"click",function(We){return Z.onClick(We)})}},{key:"onClick",value:function(W){var Z=W.delegateTarget||W.currentTarget,We=this.action(Z)||"copy",Gt=be({action:We,container:this.container,target:this.target(Z),text:this.text(Z)});this.emit(Gt?"success":"error",{action:We,text:Gt,trigger:Z,clearSelection:function(){Z&&Z.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(W){return Yt("action",W)}},{key:"defaultTarget",value:function(W){var Z=Yt("target",W);if(Z)return document.querySelector(Z)}},{key:"defaultText",value:function(W){return Yt("text",W)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(W){var Z=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return E(W,Z)}},{key:"cut",value:function(W){return h(W)}},{key:"isSupported",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],Z=typeof W=="string"?[W]:W,We=!!document.queryCommandSupported;return Z.forEach(function(Gt){We=We&&!!document.queryCommandSupported(Gt)}),We}}]),k})(s()),vr=Mt}),828:(function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,c){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(c))return s;s=s.parentNode}}n.exports=a}),438:(function(n,o,i){var a=i(828);function s(u,p,d,m,h){var v=l.apply(this,arguments);return u.addEventListener(d,v,h),{destroy:function(){u.removeEventListener(d,v,h)}}}function c(u,p,d,m,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof d=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,d,m,h)}))}function l(u,p,d,m){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&m.call(u,h)}}n.exports=c}),879:(function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}}),370:(function(n,o,i){var a=i(879),s=i(438);function c(d,m,h){if(!d&&!m&&!h)throw new Error("Missing required arguments");if(!a.string(m))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(d))return l(d,m,h);if(a.nodeList(d))return u(d,m,h);if(a.string(d))return p(d,m,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function l(d,m,h){return d.addEventListener(m,h),{destroy:function(){d.removeEventListener(m,h)}}}function u(d,m,h){return Array.prototype.forEach.call(d,function(v){v.addEventListener(m,h)}),{destroy:function(){Array.prototype.forEach.call(d,function(v){v.removeEventListener(m,h)})}}}function p(d,m,h){return s(document.body,d,m,h)}n.exports=c}),817:(function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var c=window.getSelection(),l=document.createRange();l.selectNodeContents(i),c.removeAllRanges(),c.addRange(l),a=c.toString()}return a}n.exports=o}),279:(function(n){function o(){}o.prototype={on:function(i,a,s){var c=this.e||(this.e={});return(c[i]||(c[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var c=this;function l(){c.off(i,l),a.apply(s,arguments)}return l._=a,this.on(i,l,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),c=0,l=s.length;for(c;c<l;c++)s[c].fn.apply(s[c].ctx,a);return this},off:function(i,a){var s=this.e||(this.e={}),c=s[i],l=[];if(c&&a)for(var u=0,p=c.length;u<p;u++)c[u].fn!==a&&c[u].fn._!==a&&l.push(c[u]);return l.length?s[i]=l:delete s[i],this}},n.exports=o,n.exports.TinyEmitter=o})},t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}return(function(){r.n=function(n){var o=n&&n.__esModule?function(){return n.default}:function(){return n};return r.d(o,{a:o}),o}})(),(function(){r.d=function(n,o){for(var i in o)r.o(o,i)&&!r.o(n,i)&&Object.defineProperty(n,i,{enumerable:!0,get:o[i]})}})(),(function(){r.o=function(n,o){return Object.prototype.hasOwnProperty.call(n,o)}})(),r(686)})().default})});var LM=_r(Do());var $n=function(e,t){return $n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,n){r.__proto__=n}||function(r,n){for(var o in n)Object.prototype.hasOwnProperty.call(n,o)&&(r[o]=n[o])},$n(e,t)};function ue(e,t){if(typeof t!="function"&&t!==null)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");$n(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function Wo(e,t,r,n){function o(i){return i instanceof r?i:new r(function(a){a(i)})}return new(r||(r=Promise))(function(i,a){function s(u){try{l(n.next(u))}catch(p){a(p)}}function c(u){try{l(n.throw(u))}catch(p){a(p)}}function l(u){u.done?i(u.value):o(u.value).then(s,c)}l((n=n.apply(e,t||[])).next())})}function Wr(e,t){var r={label:0,sent:function(){if(i[0]&1)throw i[1];return i[1]},trys:[],ops:[]},n,o,i,a=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return a.next=s(0),a.throw=s(1),a.return=s(2),typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(l){return function(u){return c([l,u])}}function c(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(r=0)),r;)try{if(n=1,o&&(i=l[0]&2?o.return:l[0]?o.throw||((i=o.return)&&i.call(o),0):o.next)&&!(i=i.call(o,l[1])).done)return i;switch(o=0,i&&(l=[l[0]&2,i.value]),l[0]){case 0:case 1:i=l;break;case 4:return r.label++,{value:l[1],done:!1};case 5:r.label++,o=l[1],l=[0];continue;case 7:l=r.ops.pop(),r.trys.pop();continue;default:if(i=r.trys,!(i=i.length>0&&i[i.length-1])&&(l[0]===6||l[0]===2)){r=0;continue}if(l[0]===3&&(!i||l[1]>i[0]&&l[1]<i[3])){r.label=l[1];break}if(l[0]===6&&r.label<i[1]){r.label=i[1],i=l;break}if(i&&r.label<i[2]){r.label=i[2],r.ops.push(l);break}i[2]&&r.ops.pop(),r.trys.pop();continue}l=t.call(e,r)}catch(u){l=[6,u],o=0}finally{n=i=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}function $e(e){var t=typeof Symbol=="function"&&Symbol.iterator,r=t&&e[t],n=0;if(r)return r.call(e);if(e&&typeof e.length=="number")return{next:function(){return e&&n>=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function te(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function ne(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n<o;n++)(i||!(n in t))&&(i||(i=Array.prototype.slice.call(t,0,n)),i[n]=t[n]);return e.concat(i||Array.prototype.slice.call(t))}function kt(e){return this instanceof kt?(this.v=e,this):new kt(e)}function Vo(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),o,i=[];return o=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",a),o[Symbol.asyncIterator]=function(){return this},o;function a(m){return function(h){return Promise.resolve(h).then(m,p)}}function s(m,h){n[m]&&(o[m]=function(v){return new Promise(function(x,w){i.push([m,v,x,w])>1||c(m,v)})},h&&(o[m]=h(o[m])))}function c(m,h){try{l(n[m](h))}catch(v){d(i[0][3],v)}}function l(m){m.value instanceof kt?Promise.resolve(m.value.v).then(u,p):d(i[0][2],m)}function u(m){c("next",m)}function p(m){c("throw",m)}function d(m,h){m(h),i.shift(),i.length&&c(i[0][0],i[0][1])}}function zo(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof $e=="function"?$e(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,c){a=e[i](a),o(s,c,a.done,a.value)})}}function o(i,a,s,c){Promise.resolve(c).then(function(l){i({value:l,done:s})},a)}}function F(e){return typeof e=="function"}function Jt(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var Vr=Jt(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription:
 `+r.map(function(n,o){return o+1+") "+n.toString()}).join(`
   `):"",this.name="UnsubscriptionError",this.errors=r}});function ct(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var rt=(function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=$e(a),c=s.next();!c.done;c=s.next()){var l=c.value;l.remove(this)}}catch(v){t={error:v}}finally{try{c&&!c.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(F(u))try{u()}catch(v){i=v instanceof Vr?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var d=$e(p),m=d.next();!m.done;m=d.next()){var h=m.value;try{qo(h)}catch(v){i=i!=null?i:[],v instanceof Vr?i=ne(ne([],te(i)),te(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{m&&!m.done&&(o=d.return)&&o.call(d)}finally{if(n)throw n.error}}}if(i)throw new Vr(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)qo(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&ct(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&ct(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=(function(){var t=new e;return t.closed=!0,t})(),e})();var Pn=rt.EMPTY;function zr(e){return e instanceof rt||e&&"closed"in e&&F(e.remove)&&F(e.add)&&F(e.unsubscribe)}function qo(e){F(e)?e():e.unsubscribe()}var Je={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var Xt={setTimeout:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Xt.delegate;return o!=null&&o.setTimeout?o.setTimeout.apply(o,ne([e,t],te(r))):setTimeout.apply(void 0,ne([e,t],te(r)))},clearTimeout:function(e){var t=Xt.delegate;return((t==null?void 0:t.clearTimeout)||clearTimeout)(e)},delegate:void 0};function qr(e){Xt.setTimeout(function(){var t=Je.onUnhandledError;if(t)t(e);else throw e})}function Pe(){}var Ko=(function(){return In("C",void 0,void 0)})();function Bo(e){return In("E",void 0,e)}function Yo(e){return In("N",e,void 0)}function In(e,t,r){return{kind:e,value:t,error:r}}var At=null;function Zt(e){if(Je.useDeprecatedSynchronousErrorHandling){var t=!At;if(t&&(At={errorThrown:!1,error:null}),e(),t){var r=At,n=r.errorThrown,o=r.error;if(At=null,n)throw o}}else e()}function Go(e){Je.useDeprecatedSynchronousErrorHandling&&At&&(At.errorThrown=!0,At.error=e)}var yr=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n.isStopped=!1,r?(n.destination=r,zr(r)&&r.add(n)):n.destination=Cc,n}return t.create=function(r,n,o){return new Ct(r,n,o)},t.prototype.next=function(r){this.isStopped?jn(Yo(r),this):this._next(r)},t.prototype.error=function(r){this.isStopped?jn(Bo(r),this):(this.isStopped=!0,this._error(r))},t.prototype.complete=function(){this.isStopped?jn(Ko,this):(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.closed||(this.isStopped=!0,e.prototype.unsubscribe.call(this),this.destination=null)},t.prototype._next=function(r){this.destination.next(r)},t.prototype._error=function(r){try{this.destination.error(r)}finally{this.unsubscribe()}},t.prototype._complete=function(){try{this.destination.complete()}finally{this.unsubscribe()}},t})(rt);var Mc=Function.prototype.bind;function Rn(e,t){return Mc.call(e,t)}var kc=(function(){function e(t){this.partialObserver=t}return e.prototype.next=function(t){var r=this.partialObserver;if(r.next)try{r.next(t)}catch(n){Kr(n)}},e.prototype.error=function(t){var r=this.partialObserver;if(r.error)try{r.error(t)}catch(n){Kr(n)}else Kr(t)},e.prototype.complete=function(){var t=this.partialObserver;if(t.complete)try{t.complete()}catch(r){Kr(r)}},e})(),Ct=(function(e){ue(t,e);function t(r,n,o){var i=e.call(this)||this,a;if(F(r)||!r)a={next:r!=null?r:void 0,error:n!=null?n:void 0,complete:o!=null?o:void 0};else{var s;i&&Je.useDeprecatedNextContext?(s=Object.create(r),s.unsubscribe=function(){return i.unsubscribe()},a={next:r.next&&Rn(r.next,s),error:r.error&&Rn(r.error,s),complete:r.complete&&Rn(r.complete,s)}):a=r}return i.destination=new kc(a),i}return t})(yr);function Kr(e){Je.useDeprecatedSynchronousErrorHandling?Go(e):qr(e)}function Ac(e){throw e}function jn(e,t){var r=Je.onStoppedNotification;r&&Xt.setTimeout(function(){return r(e,t)})}var Cc={closed:!0,next:Pe,error:Ac,complete:Pe};var Qt=(function(){return typeof Symbol=="function"&&Symbol.observable||"@@observable"})();function Oe(e){return e}function Jo(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Fn(e)}function Fn(e){return e.length===0?Oe:e.length===1?e[0]:function(r){return e.reduce(function(n,o){return o(n)},r)}}var U=(function(){function e(t){t&&(this._subscribe=t)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(t,r,n){var o=this,i=$c(t)?t:new Ct(t,r,n);return Zt(function(){var a=o,s=a.operator,c=a.source;i.add(s?s.call(i,c):c?o._subscribe(i):o._trySubscribe(i))}),i},e.prototype._trySubscribe=function(t){try{return this._subscribe(t)}catch(r){t.error(r)}},e.prototype.forEach=function(t,r){var n=this;return r=Xo(r),new r(function(o,i){var a=new Ct({next:function(s){try{t(s)}catch(c){i(c),a.unsubscribe()}},error:i,complete:o});n.subscribe(a)})},e.prototype._subscribe=function(t){var r;return(r=this.source)===null||r===void 0?void 0:r.subscribe(t)},e.prototype[Qt]=function(){return this},e.prototype.pipe=function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return Fn(t)(this)},e.prototype.toPromise=function(t){var r=this;return t=Xo(t),new t(function(n,o){var i;r.subscribe(function(a){return i=a},function(a){return o(a)},function(){return n(i)})})},e.create=function(t){return new e(t)},e})();function Xo(e){var t;return(t=e!=null?e:Je.Promise)!==null&&t!==void 0?t:Promise}function Hc(e){return e&&F(e.next)&&F(e.error)&&F(e.complete)}function $c(e){return e&&e instanceof yr||Hc(e)&&zr(e)}function Pc(e){return F(e==null?void 0:e.lift)}function S(e){return function(t){if(Pc(t))return t.lift(function(r){try{return e(r,this)}catch(n){this.error(n)}});throw new TypeError("Unable to lift unknown Observable type")}}function T(e,t,r,n,o){return new Ic(e,t,r,n,o)}var Ic=(function(e){ue(t,e);function t(r,n,o,i,a,s){var c=e.call(this,r)||this;return c.onFinalize=a,c.shouldUnsubscribe=s,c._next=n?function(l){try{n(l)}catch(u){r.error(u)}}:e.prototype._next,c._error=i?function(l){try{i(l)}catch(u){r.error(u)}finally{this.unsubscribe()}}:e.prototype._error,c._complete=o?function(){try{o()}catch(l){r.error(l)}finally{this.unsubscribe()}}:e.prototype._complete,c}return t.prototype.unsubscribe=function(){var r;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){var n=this.closed;e.prototype.unsubscribe.call(this),!n&&((r=this.onFinalize)===null||r===void 0||r.call(this))}},t})(yr);var er={schedule:function(e){var t=requestAnimationFrame,r=cancelAnimationFrame,n=er.delegate;n&&(t=n.requestAnimationFrame,r=n.cancelAnimationFrame);var o=t(function(i){r=void 0,e(i)});return new rt(function(){return r==null?void 0:r(o)})},requestAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.requestAnimationFrame)||requestAnimationFrame).apply(void 0,ne([],te(e)))},cancelAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.cancelAnimationFrame)||cancelAnimationFrame).apply(void 0,ne([],te(e)))},delegate:void 0};var Zo=Jt(function(e){return function(){e(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}});var I=(function(e){ue(t,e);function t(){var r=e.call(this)||this;return r.closed=!1,r.currentObservers=null,r.observers=[],r.isStopped=!1,r.hasError=!1,r.thrownError=null,r}return t.prototype.lift=function(r){var n=new Qo(this,this);return n.operator=r,n},t.prototype._throwIfClosed=function(){if(this.closed)throw new Zo},t.prototype.next=function(r){var n=this;Zt(function(){var o,i;if(n._throwIfClosed(),!n.isStopped){n.currentObservers||(n.currentObservers=Array.from(n.observers));try{for(var a=$e(n.currentObservers),s=a.next();!s.done;s=a.next()){var c=s.value;c.next(r)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}}})},t.prototype.error=function(r){var n=this;Zt(function(){if(n._throwIfClosed(),!n.isStopped){n.hasError=n.isStopped=!0,n.thrownError=r;for(var o=n.observers;o.length;)o.shift().error(r)}})},t.prototype.complete=function(){var r=this;Zt(function(){if(r._throwIfClosed(),!r.isStopped){r.isStopped=!0;for(var n=r.observers;n.length;)n.shift().complete()}})},t.prototype.unsubscribe=function(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null},Object.defineProperty(t.prototype,"observed",{get:function(){var r;return((r=this.observers)===null||r===void 0?void 0:r.length)>0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Pn:(this.currentObservers=null,s.push(r),new rt(function(){n.currentObservers=null,ct(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new Qo(r,n)},t})(U);var Qo=(function(e){ue(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Pn},t})(I);var Un=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n._value=r,n}return Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!1,configurable:!0}),t.prototype._subscribe=function(r){var n=e.prototype._subscribe.call(this,r);return!n.closed&&r.next(this._value),n},t.prototype.getValue=function(){var r=this,n=r.hasError,o=r.thrownError,i=r._value;if(n)throw o;return this._throwIfClosed(),i},t.prototype.next=function(r){e.prototype.next.call(this,this._value=r)},t})(I);var xr={now:function(){return(xr.delegate||Date).now()},delegate:void 0};var wr=(function(e){ue(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=xr);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,c=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+c)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),c=0;c<s.length&&!r.closed;c+=i?1:2)r.next(s[c]);return this._checkFinalizedStatuses(r),n},t.prototype._trimBuffer=function(){var r=this,n=r._bufferSize,o=r._timestampProvider,i=r._buffer,a=r._infiniteTimeWindow,s=(a?1:2)*n;if(n<1/0&&s<i.length&&i.splice(0,i.length-s),!a){for(var c=o.now(),l=0,u=1;u<i.length&&i[u]<=c;u+=2)l=u;l&&i.splice(0,l+1)}},t})(I);var ei=(function(e){ue(t,e);function t(r,n){return e.call(this)||this}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),this},t})(rt);var Er={setInterval:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Er.delegate;return o!=null&&o.setInterval?o.setInterval.apply(o,ne([e,t],te(r))):setInterval.apply(void 0,ne([e,t],te(r)))},clearInterval:function(e){var t=Er.delegate;return((t==null?void 0:t.clearInterval)||clearInterval)(e)},delegate:void 0};var tr=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o.pending=!1,o}return t.prototype.schedule=function(r,n){var o;if(n===void 0&&(n=0),this.closed)return this;this.state=r;var i=this.id,a=this.scheduler;return i!=null&&(this.id=this.recycleAsyncId(a,i,n)),this.pending=!0,this.delay=n,this.id=(o=this.id)!==null&&o!==void 0?o:this.requestAsyncId(a,this.id,n),this},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),Er.setInterval(r.flush.bind(r,this),o)},t.prototype.recycleAsyncId=function(r,n,o){if(o===void 0&&(o=0),o!=null&&this.delay===o&&this.pending===!1)return n;n!=null&&Er.clearInterval(n)},t.prototype.execute=function(r,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;var o=this._execute(r,n);if(o)return o;this.pending===!1&&this.id!=null&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))},t.prototype._execute=function(r,n){var o=!1,i;try{this.work(r)}catch(a){o=!0,i=a||new Error("Scheduled action threw falsy error")}if(o)return this.unsubscribe(),i},t.prototype.unsubscribe=function(){if(!this.closed){var r=this,n=r.id,o=r.scheduler,i=o.actions;this.work=this.state=this.scheduler=null,this.pending=!1,ct(i,this),n!=null&&(this.id=this.recycleAsyncId(o,n,null)),this.delay=null,e.prototype.unsubscribe.call(this)}},t})(ei);var Nn=(function(){function e(t,r){r===void 0&&(r=e.now),this.schedulerActionCtor=t,this.now=r}return e.prototype.schedule=function(t,r,n){return r===void 0&&(r=0),new this.schedulerActionCtor(this,t).schedule(n,r)},e.now=xr.now,e})();var rr=(function(e){ue(t,e);function t(r,n){n===void 0&&(n=Nn.now);var o=e.call(this,r,n)||this;return o.actions=[],o._active=!1,o}return t.prototype.flush=function(r){var n=this.actions;if(this._active){n.push(r);return}var o;this._active=!0;do if(o=r.execute(r.state,r.delay))break;while(r=n.shift());if(this._active=!1,o){for(;r=n.shift();)r.unsubscribe();throw o}},t})(Nn);var ge=new rr(tr),Dn=ge;var ti=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),n>0?e.prototype.schedule.call(this,r,n):(this.delay=n,this.state=r,this.scheduler.flush(this),this)},t.prototype.execute=function(r,n){return n>0||this.closed?e.prototype.execute.call(this,r,n):this._execute(r,n)},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!=null&&o>0||o==null&&this.delay>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.flush(this),0)},t})(tr);var ri=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t})(rr);var Wn=new ri(ti);var ni=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!==null&&o>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=er.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&n===r._scheduled&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(er.cancelAnimationFrame(n),r._scheduled=void 0)},t})(tr);var oi=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n;r?n=r.id:(n=this._scheduled,this._scheduled=void 0);var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t})(rr);var je=new oi(ni);var y=new U(function(e){return e.complete()});function Br(e){return e&&F(e.schedule)}function Vn(e){return e[e.length-1]}function _t(e){return F(Vn(e))?e.pop():void 0}function qe(e){return Br(Vn(e))?e.pop():void 0}function Yr(e,t){return typeof Vn(e)=="number"?e.pop():t}var nr=(function(e){return e&&typeof e.length=="number"&&typeof e!="function"});function Gr(e){return F(e==null?void 0:e.then)}function Jr(e){return F(e[Qt])}function Xr(e){return Symbol.asyncIterator&&F(e==null?void 0:e[Symbol.asyncIterator])}function Zr(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Rc(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qr=Rc();function en(e){return F(e==null?void 0:e[Qr])}function tn(e){return Vo(this,arguments,function(){var r,n,o,i;return Wr(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,kt(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,kt(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,kt(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function rn(e){return F(e==null?void 0:e.getReader)}function q(e){if(e instanceof U)return e;if(e!=null){if(Jr(e))return jc(e);if(nr(e))return Fc(e);if(Gr(e))return Uc(e);if(Xr(e))return ii(e);if(en(e))return Nc(e);if(rn(e))return Dc(e)}throw Zr(e)}function jc(e){return new U(function(t){var r=e[Qt]();if(F(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Fc(e){return new U(function(t){for(var r=0;r<e.length&&!t.closed;r++)t.next(e[r]);t.complete()})}function Uc(e){return new U(function(t){e.then(function(r){t.closed||(t.next(r),t.complete())},function(r){return t.error(r)}).then(null,qr)})}function Nc(e){return new U(function(t){var r,n;try{for(var o=$e(e),i=o.next();!i.done;i=o.next()){var a=i.value;if(t.next(a),t.closed)return}}catch(s){r={error:s}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}t.complete()})}function ii(e){return new U(function(t){Wc(e,t).catch(function(r){return t.error(r)})})}function Dc(e){return ii(tn(e))}function Wc(e,t){var r,n,o,i;return Wo(this,void 0,void 0,function(){var a,s;return Wr(this,function(c){switch(c.label){case 0:c.trys.push([0,5,6,11]),r=zo(e),c.label=1;case 1:return[4,r.next()];case 2:if(n=c.sent(),!!n.done)return[3,4];if(a=n.value,t.next(a),t.closed)return[2];c.label=3;case 3:return[3,1];case 4:return[3,11];case 5:return s=c.sent(),o={error:s},[3,11];case 6:return c.trys.push([6,,9,10]),n&&!n.done&&(i=r.return)?[4,i.call(r)]:[3,8];case 7:c.sent(),c.label=8;case 8:return[3,10];case 9:if(o)throw o.error;return[7];case 10:return[7];case 11:return t.complete(),[2]}})})}function Fe(e,t,r,n,o){n===void 0&&(n=0),o===void 0&&(o=!1);var i=t.schedule(function(){r(),o?e.add(this.schedule(null,n)):this.unsubscribe()},n);if(e.add(i),!o)return i}function Ie(e,t){return t===void 0&&(t=0),S(function(r,n){r.subscribe(T(n,function(o){return Fe(n,e,function(){return n.next(o)},t)},function(){return Fe(n,e,function(){return n.complete()},t)},function(o){return Fe(n,e,function(){return n.error(o)},t)}))})}function Ht(e,t){return t===void 0&&(t=0),S(function(r,n){n.add(e.schedule(function(){return r.subscribe(n)},t))})}function ai(e,t){return q(e).pipe(Ht(t),Ie(t))}function si(e,t){return q(e).pipe(Ht(t),Ie(t))}function ci(e,t){return new U(function(r){var n=0;return t.schedule(function(){n===e.length?r.complete():(r.next(e[n++]),r.closed||this.schedule())})})}function li(e,t){return new U(function(r){var n;return Fe(r,t,function(){n=e[Qr](),Fe(r,t,function(){var o,i,a;try{o=n.next(),i=o.value,a=o.done}catch(s){r.error(s);return}a?r.complete():r.next(i)},0,!0)}),function(){return F(n==null?void 0:n.return)&&n.return()}})}function nn(e,t){if(!e)throw new Error("Iterable cannot be null");return new U(function(r){Fe(r,t,function(){var n=e[Symbol.asyncIterator]();Fe(r,t,function(){n.next().then(function(o){o.done?r.complete():r.next(o.value)})},0,!0)})})}function ui(e,t){return nn(tn(e),t)}function pi(e,t){if(e!=null){if(Jr(e))return ai(e,t);if(nr(e))return ci(e,t);if(Gr(e))return si(e,t);if(Xr(e))return nn(e,t);if(en(e))return li(e,t);if(rn(e))return ui(e,t)}throw Zr(e)}function me(e,t){return t?pi(e,t):q(e)}function Y(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return me(e,r)}function zn(e,t){var r=F(e)?e:function(){return e},n=function(o){return o.error(r())};return new U(t?function(o){return t.schedule(n,0,o)}:n)}var on=Jt(function(e){return function(){e(this),this.name="EmptyError",this.message="no elements in sequence"}});function fi(e){return e instanceof Date&&!isNaN(e)}function f(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){n.next(e.call(t,i,o++))}))})}var Vc=Array.isArray;function zc(e,t){return Vc(t)?e.apply(void 0,ne([],te(t))):e(t)}function yt(e){return f(function(t){return zc(e,t)})}var qc=Array.isArray,Kc=Object.getPrototypeOf,Bc=Object.prototype,Yc=Object.keys;function mi(e){if(e.length===1){var t=e[0];if(qc(t))return{args:t,keys:null};if(Gc(t)){var r=Yc(t);return{args:r.map(function(n){return t[n]}),keys:r}}}return{args:e,keys:null}}function Gc(e){return e&&typeof e=="object"&&Kc(e)===Bc}function di(e,t){return e.reduce(function(r,n,o){return r[n]=t[o],r},{})}function re(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=_t(e),o=mi(e),i=o.args,a=o.keys;if(i.length===0)return me([],r);var s=new U(qn(i,r,a?function(c){return di(a,c)}:Oe));return n?s.pipe(yt(n)):s}function qn(e,t,r){return r===void 0&&(r=Oe),function(n){hi(t,function(){for(var o=e.length,i=new Array(o),a=o,s=o,c=function(u){hi(t,function(){var p=me(e[u],t),d=!1;p.subscribe(T(n,function(m){i[u]=m,d||(d=!0,s--),s||n.next(r(i.slice()))},function(){--a||n.complete()}))},n)},l=0;l<o;l++)c(l)},n)}}function hi(e,t,r){e?Fe(r,e,t):t()}function vi(e,t,r,n,o,i,a,s){var c=[],l=0,u=0,p=!1,d=function(){p&&!c.length&&!l&&t.complete()},m=function(v){return l<n?h(v):c.push(v)},h=function(v){i&&t.next(v),l++;var x=!1;q(r(v,u++)).subscribe(T(t,function(w){o==null||o(w),i?m(w):t.next(w)},function(){x=!0},void 0,function(){if(x)try{l--;for(var w=function(){var E=c.shift();a?Fe(t,a,function(){return h(E)}):h(E)};c.length&&l<n;)w();d()}catch(E){t.error(E)}}))};return e.subscribe(T(t,m,function(){p=!0,d()})),function(){s==null||s()}}function oe(e,t,r){return r===void 0&&(r=1/0),F(t)?oe(function(n,o){return f(function(i,a){return t(n,i,o,a)})(q(e(n,o)))},r):(typeof t=="number"&&(r=t),S(function(n,o){return vi(n,o,e,r)}))}function or(e){return e===void 0&&(e=1/0),oe(Oe,e)}function bi(){return or(1)}function nt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return bi()(me(e,qe(e)))}function j(e){return new U(function(t){q(e()).subscribe(t)})}var Jc=["addListener","removeListener"],Xc=["addEventListener","removeEventListener"],Zc=["on","off"];function b(e,t,r,n){if(F(r)&&(n=r,r=void 0),n)return b(e,t,r).pipe(yt(n));var o=te(tl(e)?Xc.map(function(s){return function(c){return e[s](t,c,r)}}):Qc(e)?Jc.map(gi(e,t)):el(e)?Zc.map(gi(e,t)):[],2),i=o[0],a=o[1];if(!i&&nr(e))return oe(function(s){return b(s,t,r)})(q(e));if(!i)throw new TypeError("Invalid event target");return new U(function(s){var c=function(){for(var l=[],u=0;u<arguments.length;u++)l[u]=arguments[u];return s.next(1<l.length?l:l[0])};return i(c),function(){return a(c)}})}function gi(e,t){return function(r){return function(n){return e[r](t,n)}}}function Qc(e){return F(e.addListener)&&F(e.removeListener)}function el(e){return F(e.on)&&F(e.off)}function tl(e){return F(e.addEventListener)&&F(e.removeEventListener)}function an(e,t,r){return r?an(e,t).pipe(yt(r)):new U(function(n){var o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];return n.next(a.length===1?a[0]:a)},i=e(o);return F(t)?function(){return t(o,i)}:void 0})}function Ve(e,t,r){e===void 0&&(e=0),r===void 0&&(r=Dn);var n=-1;return t!=null&&(Br(t)?r=t:n=t),new U(function(o){var i=fi(e)?+e-r.now():e;i<0&&(i=0);var a=0;return r.schedule(function(){o.closed||(o.next(a++),0<=n?this.schedule(void 0,n):o.complete())},i)})}function R(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0),o=e;return o.length?o.length===1?q(o[0]):or(n)(me(o,r)):y}var Ke=new U(Pe);var rl=Array.isArray;function sn(e){return e.length===1&&rl(e[0])?e[0]:e}function L(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){return e.call(t,i,o++)&&n.next(i)}))})}function $t(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e),n=sn(e);return n.length?new U(function(o){var i=n.map(function(){return[]}),a=n.map(function(){return!1});o.add(function(){i=a=null});for(var s=function(l){q(n[l]).subscribe(T(o,function(u){if(i[l].push(u),i.every(function(d){return d.length})){var p=i.map(function(d){return d.shift()});o.next(r?r.apply(void 0,ne([],te(p))):p),i.some(function(d,m){return!d.length&&a[m]})&&o.complete()}},function(){a[l]=!0,!i[l].length&&o.complete()}))},c=0;!o.closed&&c<n.length;c++)s(c);return function(){i=a=null}}):y}function _i(e){return S(function(t,r){var n=!1,o=null,i=null,a=!1,s=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var l=o;o=null,r.next(l)}a&&r.complete()},c=function(){i=null,a&&r.complete()};t.subscribe(T(r,function(l){n=!0,o=l,i||q(e(l)).subscribe(i=T(r,s,c))},function(){a=!0,(!n||!i||i.closed)&&r.complete()}))})}function Xe(e,t){return t===void 0&&(t=ge),_i(function(){return Ve(e,t)})}function Pt(e,t){return t===void 0&&(t=null),t=t!=null?t:e,S(function(r,n){var o=[],i=0;r.subscribe(T(n,function(a){var s,c,l,u,p=null;i++%t===0&&o.push([]);try{for(var d=$e(o),m=d.next();!m.done;m=d.next()){var h=m.value;h.push(a),e<=h.length&&(p=p!=null?p:[],p.push(h))}}catch(w){s={error:w}}finally{try{m&&!m.done&&(c=d.return)&&c.call(d)}finally{if(s)throw s.error}}if(p)try{for(var v=$e(p),x=v.next();!x.done;x=v.next()){var h=x.value;ct(o,h),n.next(h)}}catch(w){l={error:w}}finally{try{x&&!x.done&&(u=v.return)&&u.call(v)}finally{if(l)throw l.error}}},function(){var a,s;try{for(var c=$e(o),l=c.next();!l.done;l=c.next()){var u=l.value;n.next(u)}}catch(p){a={error:p}}finally{try{l&&!l.done&&(s=c.return)&&s.call(c)}finally{if(a)throw a.error}}n.complete()},void 0,function(){o=null}))})}function _e(e){return S(function(t,r){var n=null,o=!1,i;n=t.subscribe(T(r,void 0,void 0,function(a){i=q(e(a,_e(e)(t))),n?(n.unsubscribe(),n=null,i.subscribe(r)):o=!0})),o&&(n.unsubscribe(),n=null,i.subscribe(r))})}function yi(e,t,r,n,o){return function(i,a){var s=r,c=t,l=0;i.subscribe(T(a,function(u){var p=l++;c=s?e(c,u,p):(s=!0,u),n&&a.next(c)},o&&(function(){s&&a.next(c),a.complete()})))}}function Kn(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return r?Jo(Kn.apply(void 0,ne([],te(e))),yt(r)):S(function(n,o){qn(ne([n],te(sn(e))))(o)})}function Ze(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Kn.apply(void 0,ne([],te(e)))}function Tr(e){return S(function(t,r){var n=!1,o=null,i=null,a=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var s=o;o=null,r.next(s)}};t.subscribe(T(r,function(s){i==null||i.unsubscribe(),n=!0,o=s,i=T(r,a,Pe),q(e(s)).subscribe(i)},function(){a(),r.complete()},void 0,function(){o=i=null}))})}function Be(e,t){return t===void 0&&(t=ge),S(function(r,n){var o=null,i=null,a=null,s=function(){if(o){o.unsubscribe(),o=null;var l=i;i=null,n.next(l)}};function c(){var l=a+e,u=t.now();if(u<l){o=this.schedule(void 0,l-u),n.add(o);return}s()}r.subscribe(T(n,function(l){i=l,a=t.now(),o||(o=t.schedule(c,e),n.add(o))},function(){s(),n.complete()},void 0,function(){i=o=null}))})}function ot(e){return S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){n||r.next(e),r.complete()}))})}function Me(e){return e<=0?function(){return y}:S(function(t,r){var n=0;t.subscribe(T(r,function(o){++n<=e&&(r.next(o),e<=n&&r.complete())}))})}function he(){return S(function(e,t){e.subscribe(T(t,Pe))})}function xi(e){return f(function(){return e})}function Bn(e,t){return t?function(r){return nt(t.pipe(Me(1),he()),r.pipe(Bn(e)))}:oe(function(r,n){return q(e(r,n)).pipe(Me(1),xi(r))})}function It(e,t){t===void 0&&(t=ge);var r=Ve(e,t);return Bn(function(){return r})}function Yn(e,t){return S(function(r,n){var o=new Set;r.subscribe(T(n,function(i){var a=e?e(i):i;o.has(a)||(o.add(a),n.next(i))})),t&&q(t).subscribe(T(n,function(){return o.clear()},Pe))})}function ie(e,t){return t===void 0&&(t=Oe),e=e!=null?e:nl,S(function(r,n){var o,i=!0;r.subscribe(T(n,function(a){var s=t(a);(i||!e(o,s))&&(i=!1,o=s,n.next(a))}))})}function nl(e,t){return e===t}function fe(e,t){return ie(function(r,n){return t?t(r[e],n[e]):r[e]===n[e]})}function wi(e){return e===void 0&&(e=ol),S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){return n?r.complete():r.error(e())}))})}function ol(){return new on}function ye(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return function(r){return nt(r,Y.apply(void 0,ne([],te(e))))}}function cn(e,t){return t?function(r){return r.pipe(cn(function(n,o){return q(e(n,o)).pipe(f(function(i,a){return t(n,i,o,a)}))}))}:S(function(r,n){var o=0,i=null,a=!1;r.subscribe(T(n,function(s){i||(i=T(n,void 0,function(){i=null,a&&n.complete()}),q(e(s,o++)).subscribe(i))},function(){a=!0,!i&&n.complete()}))})}function V(e){return S(function(t,r){try{t.subscribe(r)}finally{r.add(e)}})}function Sr(e,t){var r=arguments.length>=2;return function(n){return n.pipe(e?L(function(o,i){return e(o,i,n)}):Oe,Me(1),r?ot(t):wi(function(){return new on}))}}function Gn(e){return e<=0?function(){return y}:S(function(t,r){var n=[];t.subscribe(T(r,function(o){n.push(o),e<n.length&&n.shift()},function(){var o,i;try{for(var a=$e(n),s=a.next();!s.done;s=a.next()){var c=s.value;r.next(c)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}r.complete()},void 0,function(){n=null}))})}function Ei(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0);return S(function(o,i){or(n)(me(ne([o],te(e)),r)).subscribe(i)})}function Rt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Ei.apply(void 0,ne([],te(e)))}function jt(e){var t,r=1/0,n;return e!=null&&(typeof e=="object"?(t=e.count,r=t===void 0?1/0:t,n=e.delay):r=e),r<=0?function(){return y}:S(function(o,i){var a=0,s,c=function(){if(s==null||s.unsubscribe(),s=null,n!=null){var u=typeof n=="number"?Ve(n):q(n(a)),p=T(i,function(){p.unsubscribe(),l()});u.subscribe(p)}else l()},l=function(){var u=!1;s=o.subscribe(T(i,void 0,function(){++a<r?s?c():u=!0:i.complete()})),u&&c()};l()})}function Or(e,t){return S(yi(e,t,arguments.length>=2,!0))}function xe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new I}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,c=s===void 0?!0:s;return function(l){var u,p,d,m=0,h=!1,v=!1,x=function(){p==null||p.unsubscribe(),p=void 0},w=function(){x(),u=d=void 0,h=v=!1},E=function(){var _=u;w(),_==null||_.unsubscribe()};return S(function(_,de){m++,!v&&!h&&x();var be=d=d!=null?d:r();de.add(function(){m--,m===0&&!v&&!h&&(p=Jn(E,c))}),be.subscribe(de),!u&&m>0&&(u=new Ct({next:function(M){return be.next(M)},error:function(M){v=!0,x(),p=Jn(w,o,M),be.error(M)},complete:function(){h=!0,x(),p=Jn(w,a),be.complete()}}),q(_).subscribe(u))})(l)}}function Jn(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];if(t===!0){e();return}if(t!==!1){var o=new Ct({next:function(){o.unsubscribe(),e()}});return q(t.apply(void 0,ne([],te(r)))).subscribe(o)}}function se(e,t,r){var n,o,i,a,s=!1;return e&&typeof e=="object"?(n=e.bufferSize,a=n===void 0?1/0:n,o=e.windowTime,t=o===void 0?1/0:o,i=e.refCount,s=i===void 0?!1:i,r=e.scheduler):a=e!=null?e:1/0,xe({connector:function(){return new wr(a,t,r)},resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:s})}function ke(e){return L(function(t,r){return e<=r})}function J(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return S(function(n,o){(r?nt(e,n,r):nt(e,n)).subscribe(o)})}function g(e,t){return S(function(r,n){var o=null,i=0,a=!1,s=function(){return a&&!o&&n.complete()};r.subscribe(T(n,function(c){o==null||o.unsubscribe();var l=0,u=i++;q(e(c,u)).subscribe(o=T(n,function(p){return n.next(t?t(c,p,u,l++):p)},function(){o=null,s()}))},function(){a=!0,s()}))})}function Q(e){return S(function(t,r){q(e).subscribe(T(r,function(){return r.complete()},Pe)),!r.closed&&t.subscribe(r)})}function Xn(e,t){return t===void 0&&(t=!1),S(function(r,n){var o=0;r.subscribe(T(n,function(i){var a=e(i,o++);(a||t)&&n.next(i),!a&&n.complete()}))})}function $(e,t,r){var n=F(e)||t||r?{next:e,error:t,complete:r}:e;return n?S(function(o,i){var a;(a=n.subscribe)===null||a===void 0||a.call(n);var s=!0;o.subscribe(T(i,function(c){var l;(l=n.next)===null||l===void 0||l.call(n,c),i.next(c)},function(){var c;s=!1,(c=n.complete)===null||c===void 0||c.call(n),i.complete()},function(c){var l;s=!1,(l=n.error)===null||l===void 0||l.call(n,c),i.error(c)},function(){var c,l;s&&((c=n.unsubscribe)===null||c===void 0||c.call(n)),(l=n.finalize)===null||l===void 0||l.call(n)}))}):Oe}function Ti(e,t){return S(function(r,n){var o=t!=null?t:{},i=o.leading,a=i===void 0?!0:i,s=o.trailing,c=s===void 0?!1:s,l=!1,u=null,p=null,d=!1,m=function(){p==null||p.unsubscribe(),p=null,c&&(x(),d&&n.complete())},h=function(){p=null,d&&n.complete()},v=function(w){return p=q(e(w)).subscribe(T(n,m,h))},x=function(){if(l){l=!1;var w=u;u=null,n.next(w),!d&&v(w)}};r.subscribe(T(n,function(w){l=!0,u=w,!(p&&!p.closed)&&(a?x():v(w))},function(){d=!0,!(c&&l&&p&&!p.closed)&&n.complete()}))})}function Lr(e,t,r){t===void 0&&(t=ge);var n=Ve(e,t);return Ti(function(){return n},r)}function pe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return S(function(n,o){for(var i=e.length,a=new Array(i),s=e.map(function(){return!1}),c=!1,l=function(p){q(e[p]).subscribe(T(o,function(d){a[p]=d,!c&&!s[p]&&(s[p]=!0,(c=s.every(Oe))&&(s=null))},Pe))},u=0;u<i;u++)l(u);n.subscribe(T(o,function(p){if(c){var d=ne([p],te(a));o.next(r?r.apply(void 0,ne([],te(d))):d)}}))})}function Si(){let e=new wr(1);return b(document,"DOMContentLoaded",{once:!0}).subscribe(()=>e.next(document)),e}function P(e,t=document){return Array.from(t.querySelectorAll(e))}function G(e,t=document){let r=Le(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function Le(e,t=document){return t.querySelector(e)||void 0}function xt(){var e,t,r,n;return(n=(r=(t=(e=document.activeElement)==null?void 0:e.shadowRoot)==null?void 0:t.activeElement)!=null?r:document.activeElement)!=null?n:void 0}var il=R(b(document.body,"focusin"),b(document.body,"focusout")).pipe(Be(1),J(void 0),f(()=>xt()||document.body),se(1));function ir(e){return il.pipe(f(t=>e.contains(t)),ie())}function Ft(e,t){let{matches:r}=matchMedia("(hover)");return j(()=>(r?R(b(e,"mouseenter").pipe(f(()=>!0)),b(e,"mouseleave").pipe(f(()=>!1))):R(b(e,"touchstart").pipe(f(()=>!0)),b(e,"touchend").pipe(f(()=>!1)),b(e,"touchcancel").pipe(f(()=>!1)))).pipe(t?Tr(o=>Ve(+!o*t)):Oe,J(!0,e.matches(":hover"))))}function Oi(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)Oi(e,r)}function A(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)Oi(n,o);return n}function Li(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function ar(e){let t=A("script",{src:e});return j(()=>(document.head.appendChild(t),R(b(t,"load"),b(t,"error").pipe(g(()=>zn(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(f(()=>{}),V(()=>document.head.removeChild(t)),Me(1))))}var Mi=new I,al=j(()=>typeof ResizeObserver=="undefined"?ar("https://unpkg.com/resize-observer-polyfill"):Y(void 0)).pipe(f(()=>new ResizeObserver(e=>e.forEach(t=>Mi.next(t)))),g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Ae(e){return{width:e.offsetWidth,height:e.offsetHeight}}function Re(e){let t=e;for(;t.clientWidth===0&&t.parentElement;)t=t.parentElement;return al.pipe($(r=>r.observe(t)),g(r=>Mi.pipe(L(n=>n.target===t),V(()=>r.unobserve(t)))),f(()=>Ae(e)),J(Ae(e)))}function Mr(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ki(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}function Ai(e){let t=[],r=e.parentElement;for(;r;)(e.clientWidth>r.clientWidth||e.clientHeight>r.clientHeight)&&t.push(r),r=(e=r).parentElement;return t.length===0&&t.push(document.documentElement),t}function wt(e){return{x:e.offsetLeft,y:e.offsetTop}}function Ci(e){let t=e.getBoundingClientRect();return{x:t.x+window.scrollX,y:t.y+window.scrollY}}function Hi(e){return R(b(window,"load"),b(window,"resize")).pipe(Xe(0,je),f(()=>wt(e)),J(wt(e)))}function ln(e){return{x:e.scrollLeft,y:e.scrollTop}}function Ut(e){return R(b(e,"scroll"),b(window,"scroll"),b(window,"resize")).pipe(Xe(0,je),f(()=>ln(e)),J(ln(e)))}var $i=new I,sl=j(()=>Y(new IntersectionObserver(e=>{for(let t of e)$i.next(t)},{threshold:0}))).pipe(g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Et(e){return sl.pipe($(t=>t.observe(e)),g(t=>$i.pipe(L(({target:r})=>r===e),V(()=>t.unobserve(e)),f(({isIntersecting:r})=>r))))}var cl=Object.create,la=Object.defineProperty,ll=Object.getOwnPropertyDescriptor,ul=Object.getOwnPropertyNames,pl=Object.getPrototypeOf,fl=Object.prototype.hasOwnProperty,ml=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),dl=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of ul(t))!fl.call(e,o)&&o!==r&&la(e,o,{get:()=>t[o],enumerable:!(n=ll(t,o))||n.enumerable});return e},hl=(e,t,r)=>(r=e!=null?cl(pl(e)):{},dl(t||!e||!e.__esModule?la(r,"default",{value:e,enumerable:!0}):r,e)),vl=ml((e,t)=>{var r="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,c=/^0o[0-7]+$/i,l=parseInt,u=typeof global=="object"&&global&&global.Object===Object&&global,p=typeof self=="object"&&self&&self.Object===Object&&self,d=u||p||Function("return this")(),m=Object.prototype,h=m.toString,v=Math.max,x=Math.min,w=function(){return d.Date.now()};function E(O,N,ee){var le,ce,Ne,bt,De,st,tt=0,Yt=!1,Mt=!1,vr=!0;if(typeof O!="function")throw new TypeError(r);N=M(N)||0,_(ee)&&(Yt=!!ee.leading,Mt="maxWait"in ee,Ne=Mt?v(M(ee.maxWait)||0,N):Ne,vr="trailing"in ee?!!ee.trailing:vr);function B(Te){var gt=le,br=ce;return le=ce=void 0,tt=Te,bt=O.apply(br,gt),bt}function C(Te){return tt=Te,De=setTimeout(W,N),Yt?B(Te):bt}function k(Te){var gt=Te-st,br=Te-tt,Ro=N-gt;return Mt?x(Ro,Ne-br):Ro}function D(Te){var gt=Te-st,br=Te-tt;return st===void 0||gt>=N||gt<0||Mt&&br>=Ne}function W(){var Te=w();if(D(Te))return Z(Te);De=setTimeout(W,k(Te))}function Z(Te){return De=void 0,vr&&le?B(Te):(le=ce=void 0,bt)}function We(){De!==void 0&&clearTimeout(De),tt=0,le=st=ce=De=void 0}function Gt(){return De===void 0?bt:Z(w())}function Nr(){var Te=w(),gt=D(Te);if(le=arguments,ce=this,st=Te,gt){if(De===void 0)return C(st);if(Mt)return De=setTimeout(W,N),B(st)}return De===void 0&&(De=setTimeout(W,N)),bt}return Nr.cancel=We,Nr.flush=Gt,Nr}function _(O){var N=typeof O;return!!O&&(N=="object"||N=="function")}function de(O){return!!O&&typeof O=="object"}function be(O){return typeof O=="symbol"||de(O)&&h.call(O)==o}function M(O){if(typeof O=="number")return O;if(be(O))return n;if(_(O)){var N=typeof O.valueOf=="function"?O.valueOf():O;O=_(N)?N+"":N}if(typeof O!="string")return O===0?O:+O;O=O.replace(i,"");var ee=s.test(O);return ee||c.test(O)?l(O.slice(2),ee?2:8):a.test(O)?n:+O}t.exports=E}),yn,K,ua,pa,Nt,Pi,fa,ma,da,lo,to,ro,bl,Ar={},ha=[],gl=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Pr=Array.isArray;function pt(e,t){for(var r in t)e[r]=t[r];return e}function uo(e){e&&e.parentNode&&e.parentNode.removeChild(e)}function Wt(e,t,r){var n,o,i,a={};for(i in t)i=="key"?n=t[i]:i=="ref"?o=t[i]:a[i]=t[i];if(arguments.length>2&&(a.children=arguments.length>3?yn.call(arguments,2):r),typeof e=="function"&&e.defaultProps!=null)for(i in e.defaultProps)a[i]===void 0&&(a[i]=e.defaultProps[i]);return fn(e,a,n,o,null)}function fn(e,t,r,n,o){var i={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:o!=null?o:++ua,__i:-1,__u:0};return o==null&&K.vnode!=null&&K.vnode(i),i}function ft(e){return e.children}function at(e,t){this.props=e,this.context=t}function cr(e,t){if(t==null)return e.__?cr(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null)return r.__e;return typeof e.type=="function"?cr(e):null}function va(e){var t,r;if((e=e.__)!=null&&e.__c!=null){for(e.__e=e.__c.base=null,t=0;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null){e.__e=e.__c.base=r.__e;break}return va(e)}}function Ii(e){(!e.__d&&(e.__d=!0)&&Nt.push(e)&&!vn.__r++||Pi!=K.debounceRendering)&&((Pi=K.debounceRendering)||fa)(vn)}function vn(){for(var e,t,r,n,o,i,a,s=1;Nt.length;)Nt.length>s&&Nt.sort(ma),e=Nt.shift(),s=Nt.length,e.__d&&(r=void 0,n=void 0,o=(n=(t=e).__v).__e,i=[],a=[],t.__P&&((r=pt({},n)).__v=n.__v+1,K.vnode&&K.vnode(r),po(t.__P,r,n,t.__n,t.__P.namespaceURI,32&n.__u?[o]:null,i,o!=null?o:cr(n),!!(32&n.__u),a),r.__v=n.__v,r.__.__k[r.__i]=r,_a(i,r,a),n.__e=n.__=null,r.__e!=o&&va(r)));vn.__r=0}function ba(e,t,r,n,o,i,a,s,c,l,u){var p,d,m,h,v,x,w,E=n&&n.__k||ha,_=t.length;for(c=_l(r,t,E,c,_),p=0;p<_;p++)(m=r.__k[p])!=null&&(d=m.__i==-1?Ar:E[m.__i]||Ar,m.__i=p,x=po(e,m,d,o,i,a,s,c,l,u),h=m.__e,m.ref&&d.ref!=m.ref&&(d.ref&&fo(d.ref,null,m),u.push(m.ref,m.__c||h,m)),v==null&&h!=null&&(v=h),(w=!!(4&m.__u))||d.__k===m.__k?c=ga(m,c,e,w):typeof m.type=="function"&&x!==void 0?c=x:h&&(c=h.nextSibling),m.__u&=-7);return r.__e=v,c}function _l(e,t,r,n,o){var i,a,s,c,l,u=r.length,p=u,d=0;for(e.__k=new Array(o),i=0;i<o;i++)(a=t[i])!=null&&typeof a!="boolean"&&typeof a!="function"?(c=i+d,(a=e.__k[i]=typeof a=="string"||typeof a=="number"||typeof a=="bigint"||a.constructor==String?fn(null,a,null,null,null):Pr(a)?fn(ft,{children:a},null,null,null):a.constructor==null&&a.__b>0?fn(a.type,a.props,a.key,a.ref?a.ref:null,a.__v):a).__=e,a.__b=e.__b+1,s=null,(l=a.__i=yl(a,r,c,p))!=-1&&(p--,(s=r[l])&&(s.__u|=2)),s==null||s.__v==null?(l==-1&&(o>u?d--:o<u&&d++),typeof a.type!="function"&&(a.__u|=4)):l!=c&&(l==c-1?d--:l==c+1?d++:(l>c?d--:d++,a.__u|=4))):e.__k[i]=null;if(p)for(i=0;i<u;i++)(s=r[i])!=null&&!(2&s.__u)&&(s.__e==n&&(n=cr(s)),xa(s,s));return n}function ga(e,t,r,n){var o,i;if(typeof e.type=="function"){for(o=e.__k,i=0;o&&i<o.length;i++)o[i]&&(o[i].__=e,t=ga(o[i],t,r,n));return t}e.__e!=t&&(n&&(t&&e.type&&!t.parentNode&&(t=cr(e)),r.insertBefore(e.__e,t||null)),t=e.__e);do t=t&&t.nextSibling;while(t!=null&&t.nodeType==8);return t}function Cr(e,t){return t=t||[],e==null||typeof e=="boolean"||(Pr(e)?e.some(function(r){Cr(r,t)}):t.push(e)),t}function yl(e,t,r,n){var o,i,a,s=e.key,c=e.type,l=t[r],u=l!=null&&(2&l.__u)==0;if(l===null&&e.key==null||u&&s==l.key&&c==l.type)return r;if(n>(u?1:0)){for(o=r-1,i=r+1;o>=0||i<t.length;)if((l=t[a=o>=0?o--:i++])!=null&&!(2&l.__u)&&s==l.key&&c==l.type)return a}return-1}function Ri(e,t,r){t[0]=="-"?e.setProperty(t,r!=null?r:""):e[t]=r==null?"":typeof r!="number"||gl.test(t)?r:r+"px"}function un(e,t,r,n,o){var i,a;e:if(t=="style")if(typeof r=="string")e.style.cssText=r;else{if(typeof n=="string"&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||Ri(e.style,t,"");if(r)for(t in r)n&&r[t]==n[t]||Ri(e.style,t,r[t])}else if(t[0]=="o"&&t[1]=="n")i=t!=(t=t.replace(da,"$1")),a=t.toLowerCase(),t=a in e||t=="onFocusOut"||t=="onFocusIn"?a.slice(2):t.slice(2),e.l||(e.l={}),e.l[t+i]=r,r?n?r.u=n.u:(r.u=lo,e.addEventListener(t,i?ro:to,i)):e.removeEventListener(t,i?ro:to,i);else{if(o=="http://www.w3.org/2000/svg")t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(t!="width"&&t!="height"&&t!="href"&&t!="list"&&t!="form"&&t!="tabIndex"&&t!="download"&&t!="rowSpan"&&t!="colSpan"&&t!="role"&&t!="popover"&&t in e)try{e[t]=r!=null?r:"";break e}catch(s){}typeof r=="function"||(r==null||r===!1&&t[4]!="-"?e.removeAttribute(t):e.setAttribute(t,t=="popover"&&r==1?"":r))}}function ji(e){return function(t){if(this.l){var r=this.l[t.type+e];if(t.t==null)t.t=lo++;else if(t.t<r.u)return;return r(K.event?K.event(t):t)}}}function po(e,t,r,n,o,i,a,s,c,l){var u,p,d,m,h,v,x,w,E,_,de,be,M,O,N,ee,le,ce=t.type;if(t.constructor!=null)return null;128&r.__u&&(c=!!(32&r.__u),i=[s=t.__e=r.__e]),(u=K.__b)&&u(t);e:if(typeof ce=="function")try{if(w=t.props,E="prototype"in ce&&ce.prototype.render,_=(u=ce.contextType)&&n[u.__c],de=u?_?_.props.value:u.__:n,r.__c?x=(p=t.__c=r.__c).__=p.__E:(E?t.__c=p=new ce(w,de):(t.__c=p=new at(w,de),p.constructor=ce,p.render=wl),_&&_.sub(p),p.props=w,p.state||(p.state={}),p.context=de,p.__n=n,d=p.__d=!0,p.__h=[],p._sb=[]),E&&p.__s==null&&(p.__s=p.state),E&&ce.getDerivedStateFromProps!=null&&(p.__s==p.state&&(p.__s=pt({},p.__s)),pt(p.__s,ce.getDerivedStateFromProps(w,p.__s))),m=p.props,h=p.state,p.__v=t,d)E&&ce.getDerivedStateFromProps==null&&p.componentWillMount!=null&&p.componentWillMount(),E&&p.componentDidMount!=null&&p.__h.push(p.componentDidMount);else{if(E&&ce.getDerivedStateFromProps==null&&w!==m&&p.componentWillReceiveProps!=null&&p.componentWillReceiveProps(w,de),!p.__e&&p.shouldComponentUpdate!=null&&p.shouldComponentUpdate(w,p.__s,de)===!1||t.__v==r.__v){for(t.__v!=r.__v&&(p.props=w,p.state=p.__s,p.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.some(function(Ne){Ne&&(Ne.__=t)}),be=0;be<p._sb.length;be++)p.__h.push(p._sb[be]);p._sb=[],p.__h.length&&a.push(p);break e}p.componentWillUpdate!=null&&p.componentWillUpdate(w,p.__s,de),E&&p.componentDidUpdate!=null&&p.__h.push(function(){p.componentDidUpdate(m,h,v)})}if(p.context=de,p.props=w,p.__P=e,p.__e=!1,M=K.__r,O=0,E){for(p.state=p.__s,p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),N=0;N<p._sb.length;N++)p.__h.push(p._sb[N]);p._sb=[]}else do p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),p.state=p.__s;while(p.__d&&++O<25);p.state=p.__s,p.getChildContext!=null&&(n=pt(pt({},n),p.getChildContext())),E&&!d&&p.getSnapshotBeforeUpdate!=null&&(v=p.getSnapshotBeforeUpdate(m,h)),ee=u,u!=null&&u.type===ft&&u.key==null&&(ee=ya(u.props.children)),s=ba(e,Pr(ee)?ee:[ee],t,r,n,o,i,a,s,c,l),p.base=t.__e,t.__u&=-161,p.__h.length&&a.push(p),x&&(p.__E=p.__=null)}catch(Ne){if(t.__v=null,c||i!=null)if(Ne.then){for(t.__u|=c?160:128;s&&s.nodeType==8&&s.nextSibling;)s=s.nextSibling;i[i.indexOf(s)]=null,t.__e=s}else{for(le=i.length;le--;)uo(i[le]);no(t)}else t.__e=r.__e,t.__k=r.__k,Ne.then||no(t);K.__e(Ne,t,r)}else i==null&&t.__v==r.__v?(t.__k=r.__k,t.__e=r.__e):s=t.__e=xl(r.__e,t,r,n,o,i,a,c,l);return(u=K.diffed)&&u(t),128&t.__u?void 0:s}function no(e){e&&e.__c&&(e.__c.__e=!0),e&&e.__k&&e.__k.forEach(no)}function _a(e,t,r){for(var n=0;n<r.length;n++)fo(r[n],r[++n],r[++n]);K.__c&&K.__c(t,e),e.some(function(o){try{e=o.__h,o.__h=[],e.some(function(i){i.call(o)})}catch(i){K.__e(i,o.__v)}})}function ya(e){return typeof e!="object"||e==null||e.__b&&e.__b>0?e:Pr(e)?e.map(ya):pt({},e)}function xl(e,t,r,n,o,i,a,s,c){var l,u,p,d,m,h,v,x=r.props,w=t.props,E=t.type;if(E=="svg"?o="http://www.w3.org/2000/svg":E=="math"?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),i!=null){for(l=0;l<i.length;l++)if((m=i[l])&&"setAttribute"in m==!!E&&(E?m.localName==E:m.nodeType==3)){e=m,i[l]=null;break}}if(e==null){if(E==null)return document.createTextNode(w);e=document.createElementNS(o,E,w.is&&w),s&&(K.__m&&K.__m(t,i),s=!1),i=null}if(E==null)x===w||s&&e.data==w||(e.data=w);else{if(i=i&&yn.call(e.childNodes),x=r.props||Ar,!s&&i!=null)for(x={},l=0;l<e.attributes.length;l++)x[(m=e.attributes[l]).name]=m.value;for(l in x)if(m=x[l],l!="children"){if(l=="dangerouslySetInnerHTML")p=m;else if(!(l in w)){if(l=="value"&&"defaultValue"in w||l=="checked"&&"defaultChecked"in w)continue;un(e,l,null,m,o)}}for(l in w)m=w[l],l=="children"?d=m:l=="dangerouslySetInnerHTML"?u=m:l=="value"?h=m:l=="checked"?v=m:s&&typeof m!="function"||x[l]===m||un(e,l,m,x[l],o);if(u)s||p&&(u.__html==p.__html||u.__html==e.innerHTML)||(e.innerHTML=u.__html),t.__k=[];else if(p&&(e.innerHTML=""),ba(t.type=="template"?e.content:e,Pr(d)?d:[d],t,r,n,E=="foreignObject"?"http://www.w3.org/1999/xhtml":o,i,a,i?i[0]:r.__k&&cr(r,0),s,c),i!=null)for(l=i.length;l--;)uo(i[l]);s||(l="value",E=="progress"&&h==null?e.removeAttribute("value"):h!=null&&(h!==e[l]||E=="progress"&&!h||E=="option"&&h!=x[l])&&un(e,l,h,x[l],o),l="checked",v!=null&&v!=e[l]&&un(e,l,v,x[l],o))}return e}function fo(e,t,r){try{if(typeof e=="function"){var n=typeof e.__u=="function";n&&e.__u(),n&&t==null||(e.__u=e(t))}else e.current=t}catch(o){K.__e(o,r)}}function xa(e,t,r){var n,o;if(K.unmount&&K.unmount(e),(n=e.ref)&&(n.current&&n.current!=e.__e||fo(n,null,t)),(n=e.__c)!=null){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(i){K.__e(i,t)}n.base=n.__P=null}if(n=e.__k)for(o=0;o<n.length;o++)n[o]&&xa(n[o],t,r||typeof e.type!="function");r||uo(e.__e),e.__c=e.__=e.__e=void 0}function wl(e,t,r){return this.constructor(e,r)}function El(e,t,r){var n,o,i,a;t==document&&(t=document.documentElement),K.__&&K.__(e,t),o=(n=typeof r=="function")?null:r&&r.__k||t.__k,i=[],a=[],po(t,e=(!n&&r||t).__k=Wt(ft,null,[e]),o||Ar,Ar,t.namespaceURI,!n&&r?[r]:o?null:t.firstChild?yn.call(t.childNodes):null,i,!n&&r?r:o?o.__e:t.firstChild,n,a),_a(i,e,a)}yn=ha.slice,K={__e:function(e,t,r,n){for(var o,i,a;t=t.__;)if((o=t.__c)&&!o.__)try{if((i=o.constructor)&&i.getDerivedStateFromError!=null&&(o.setState(i.getDerivedStateFromError(e)),a=o.__d),o.componentDidCatch!=null&&(o.componentDidCatch(e,n||{}),a=o.__d),a)return o.__E=o}catch(s){e=s}throw e}},ua=0,pa=function(e){return e!=null&&e.constructor==null},at.prototype.setState=function(e,t){var r;r=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=pt({},this.state),typeof e=="function"&&(e=e(pt({},r),this.props)),e&&pt(r,e),e!=null&&this.__v&&(t&&this._sb.push(t),Ii(this))},at.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),Ii(this))},at.prototype.render=ft,Nt=[],fa=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,ma=function(e,t){return e.__v.__b-t.__v.__b},vn.__r=0,da=/(PointerCapture)$|Capture$/i,lo=0,to=ji(!1),ro=ji(!0),bl=0;var Hr,ve,Zn,Fi,$r=0,wa=[],we=K,Ui=we.__b,Ni=we.__r,Di=we.diffed,Wi=we.__c,Vi=we.unmount,zi=we.__;function mo(e,t){we.__h&&we.__h(ve,e,$r||t),$r=0;var r=ve.__H||(ve.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({}),r.__[e]}function bn(e){return $r=1,Tl(Ta,e)}function Tl(e,t,r){var n=mo(Hr++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):Ta(void 0,t),function(s){var c=n.__N?n.__N[0]:n.__[0],l=n.t(c,s);c!==l&&(n.__N=[l,n.__[1]],n.__c.setState({}))}],n.__c=ve,!ve.__f)){var o=function(s,c,l){if(!n.__c.__H)return!0;var u=n.__c.__H.__.filter(function(d){return!!d.__c});if(u.every(function(d){return!d.__N}))return!i||i.call(this,s,c,l);var p=n.__c.props!==s;return u.forEach(function(d){if(d.__N){var m=d.__[0];d.__=d.__N,d.__N=void 0,m!==d.__[0]&&(p=!0)}}),i&&i.call(this,s,c,l)||p};ve.__f=!0;var i=ve.shouldComponentUpdate,a=ve.componentWillUpdate;ve.componentWillUpdate=function(s,c,l){if(this.__e){var u=i;i=void 0,o(s,c,l),i=u}a&&a.call(this,s,c,l)},ve.shouldComponentUpdate=o}return n.__N||n.__}function mt(e,t){var r=mo(Hr++,3);!we.__s&&Ea(r.__H,t)&&(r.__=e,r.u=t,ve.__H.__h.push(r))}function Vt(e){return $r=5,ur(function(){return{current:e}},[])}function ur(e,t){var r=mo(Hr++,7);return Ea(r.__H,t)&&(r.__=e(),r.__H=t,r.__h=e),r.__}function Sl(e,t){return $r=8,ur(function(){return e},t)}function Ol(){for(var e;e=wa.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(mn),e.__H.__h.forEach(oo),e.__H.__h=[]}catch(t){e.__H.__h=[],we.__e(t,e.__v)}}we.__b=function(e){ve=null,Ui&&Ui(e)},we.__=function(e,t){e&&t.__k&&t.__k.__m&&(e.__m=t.__k.__m),zi&&zi(e,t)},we.__r=function(e){Ni&&Ni(e),Hr=0;var t=(ve=e.__c).__H;t&&(Zn===ve?(t.__h=[],ve.__h=[],t.__.forEach(function(r){r.__N&&(r.__=r.__N),r.u=r.__N=void 0})):(t.__h.forEach(mn),t.__h.forEach(oo),t.__h=[],Hr=0)),Zn=ve},we.diffed=function(e){Di&&Di(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(wa.push(t)!==1&&Fi===we.requestAnimationFrame||((Fi=we.requestAnimationFrame)||Ll)(Ol)),t.__H.__.forEach(function(r){r.u&&(r.__H=r.u),r.u=void 0})),Zn=ve=null},we.__c=function(e,t){t.some(function(r){try{r.__h.forEach(mn),r.__h=r.__h.filter(function(n){return!n.__||oo(n)})}catch(n){t.some(function(o){o.__h&&(o.__h=[])}),t=[],we.__e(n,r.__v)}}),Wi&&Wi(e,t)},we.unmount=function(e){Vi&&Vi(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{mn(n)}catch(o){t=o}}),r.__H=void 0,t&&we.__e(t,r.__v))};var qi=typeof requestAnimationFrame=="function";function Ll(e){var t,r=function(){clearTimeout(n),qi&&cancelAnimationFrame(t),setTimeout(e)},n=setTimeout(r,35);qi&&(t=requestAnimationFrame(r))}function mn(e){var t=ve,r=e.__c;typeof r=="function"&&(e.__c=void 0,r()),ve=t}function oo(e){var t=ve;e.__c=e.__(),ve=t}function Ea(e,t){return!e||e.length!==t.length||t.some(function(r,n){return r!==e[n]})}function Ta(e,t){return typeof t=="function"?t(e):t}function Ml(e,t){for(var r in t)e[r]=t[r];return e}function Ki(e,t){for(var r in e)if(r!=="__source"&&!(r in t))return!0;for(var n in t)if(n!=="__source"&&e[n]!==t[n])return!0;return!1}function Bi(e,t){this.props=e,this.context=t}(Bi.prototype=new at).isPureReactComponent=!0,Bi.prototype.shouldComponentUpdate=function(e,t){return Ki(this.props,e)||Ki(this.state,t)};var Yi=K.__b;K.__b=function(e){e.type&&e.type.__f&&e.ref&&(e.props.ref=e.ref,e.ref=null),Yi&&Yi(e)};var Yx=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911,kl=K.__e;K.__e=function(e,t,r,n){if(e.then){for(var o,i=t;i=i.__;)if((o=i.__c)&&o.__c)return t.__e==null&&(t.__e=r.__e,t.__k=r.__k),o.__c(e,t)}kl(e,t,r,n)};var Gi=K.unmount;function Sa(e,t,r){return e&&(e.__c&&e.__c.__H&&(e.__c.__H.__.forEach(function(n){typeof n.__c=="function"&&n.__c()}),e.__c.__H=null),(e=Ml({},e)).__c!=null&&(e.__c.__P===r&&(e.__c.__P=t),e.__c.__e=!0,e.__c=null),e.__k=e.__k&&e.__k.map(function(n){return Sa(n,t,r)})),e}function Oa(e,t,r){return e&&r&&(e.__v=null,e.__k=e.__k&&e.__k.map(function(n){return Oa(n,t,r)}),e.__c&&e.__c.__P===t&&(e.__e&&r.appendChild(e.__e),e.__c.__e=!0,e.__c.__P=r)),e}function Qn(){this.__u=0,this.o=null,this.__b=null}function La(e){var t=e.__.__c;return t&&t.__a&&t.__a(e)}function pn(){this.i=null,this.l=null}K.unmount=function(e){var t=e.__c;t&&t.__R&&t.__R(),t&&32&e.__u&&(e.type=null),Gi&&Gi(e)},(Qn.prototype=new at).__c=function(e,t){var r=t.__c,n=this;n.o==null&&(n.o=[]),n.o.push(r);var o=La(n.__v),i=!1,a=function(){i||(i=!0,r.__R=null,o?o(s):s())};r.__R=a;var s=function(){if(!--n.__u){if(n.state.__a){var c=n.state.__a;n.__v.__k[0]=Oa(c,c.__c.__P,c.__c.__O)}var l;for(n.setState({__a:n.__b=null});l=n.o.pop();)l.forceUpdate()}};n.__u++||32&t.__u||n.setState({__a:n.__b=n.__v.__k[0]}),e.then(a,a)},Qn.prototype.componentWillUnmount=function(){this.o=[]},Qn.prototype.render=function(e,t){if(this.__b){if(this.__v.__k){var r=document.createElement("div"),n=this.__v.__k[0].__c;this.__v.__k[0]=Sa(this.__b,r,n.__O=n.__P)}this.__b=null}var o=t.__a&&Wt(ft,null,e.fallback);return o&&(o.__u&=-33),[Wt(ft,null,t.__a?null:e.children),o]};var Ji=function(e,t,r){if(++r[1]===r[0]&&e.l.delete(t),e.props.revealOrder&&(e.props.revealOrder[0]!=="t"||!e.l.size))for(r=e.i;r;){for(;r.length>3;)r.pop()();if(r[1]<r[0])break;e.i=r=r[2]}};(pn.prototype=new at).__a=function(e){var t=this,r=La(t.__v),n=t.l.get(e);return n[0]++,function(o){var i=function(){t.props.revealOrder?(n.push(o),Ji(t,e,n)):o()};r?r(i):i()}},pn.prototype.render=function(e){this.i=null,this.l=new Map;var t=Cr(e.children);e.revealOrder&&e.revealOrder[0]==="b"&&t.reverse();for(var r=t.length;r--;)this.l.set(t[r],this.i=[1,0,this.i]);return e.children},pn.prototype.componentDidUpdate=pn.prototype.componentDidMount=function(){var e=this;this.l.forEach(function(t,r){Ji(e,r,t)})};var Al=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,Cl=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,Hl=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,$l=/[A-Z0-9]/g,Pl=typeof document<"u",Il=function(e){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(e)};at.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(e){Object.defineProperty(at.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})});var Xi=K.event;function Rl(){}function jl(){return this.cancelBubble}function Fl(){return this.defaultPrevented}K.event=function(e){return Xi&&(e=Xi(e)),e.persist=Rl,e.isPropagationStopped=jl,e.isDefaultPrevented=Fl,e.nativeEvent=e};var Ma,Ul={enumerable:!1,configurable:!0,get:function(){return this.class}},Zi=K.vnode;K.vnode=function(e){typeof e.type=="string"&&(function(t){var r=t.props,n=t.type,o={},i=n.indexOf("-")===-1;for(var a in r){var s=r[a];if(!(a==="value"&&"defaultValue"in r&&s==null||Pl&&a==="children"&&n==="noscript"||a==="class"||a==="className")){var c=a.toLowerCase();a==="defaultValue"&&"value"in r&&r.value==null?a="value":a==="download"&&s===!0?s="":c==="translate"&&s==="no"?s=!1:c[0]==="o"&&c[1]==="n"?c==="ondoubleclick"?a="ondblclick":c!=="onchange"||n!=="input"&&n!=="textarea"||Il(r.type)?c==="onfocus"?a="onfocusin":c==="onblur"?a="onfocusout":Hl.test(a)&&(a=c):c=a="oninput":i&&Cl.test(a)?a=a.replace($l,"-$&").toLowerCase():s===null&&(s=void 0),c==="oninput"&&o[a=c]&&(a="oninputCapture"),o[a]=s}}n=="select"&&o.multiple&&Array.isArray(o.value)&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.value.indexOf(l.props.value)!=-1})),n=="select"&&o.defaultValue!=null&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.multiple?o.defaultValue.indexOf(l.props.value)!=-1:o.defaultValue==l.props.value})),r.class&&!r.className?(o.class=r.class,Object.defineProperty(o,"className",Ul)):(r.className&&!r.class||r.class&&r.className)&&(o.class=o.className=r.className),t.props=o})(e),e.$$typeof=Al,Zi&&Zi(e)};var Qi=K.__r;K.__r=function(e){Qi&&Qi(e),Ma=e.__c};var ea=K.diffed;K.diffed=function(e){ea&&ea(e);var t=e.props,r=e.__e;r!=null&&e.type==="textarea"&&"value"in t&&t.value!==r.value&&(r.value=t.value==null?"":t.value),Ma=null};function ka(e){let t=Vt(e);return t.current=e,ur(()=>Object.freeze({get current(){return t.current}}),[])}var Nl=typeof globalThis<"u"&&typeof navigator<"u"&&typeof document<"u";function Dl(e,...t){var r;(r=e==null?void 0:e.addEventListener)==null||r.call(e,...t)}function Wl(e,...t){var r;(r=e==null?void 0:e.removeEventListener)==null||r.call(e,...t)}var Vl=(e,t)=>Object.hasOwn(e,t),zl=()=>!0,ql=()=>!1;function Kl(e=!1){let t=Vt(e),r=Sl(()=>t.current,[]);return mt(()=>(t.current=!0,()=>{t.current=!1}),[]),r}function Bl(e,...t){let r=Kl(),n=ka(t[1]),o=ur(()=>function(...i){r()&&(typeof n.current=="function"?n.current.apply(this,i):typeof n.current.handleEvent=="function"&&n.current.handleEvent.apply(this,i))},[]);mt(()=>{let i=Yl(e)?e.current:e;if(!i)return;let a=t.slice(2);return Dl(i,t[0],o,...a),()=>{Wl(i,t[0],o,...a)}},[e,t[0]])}function Yl(e){return e!==null&&typeof e=="object"&&Vl(e,"current")}var Gl=e=>typeof e=="function"?e:typeof e=="string"?t=>t.key===e:e?zl:ql,Jl=Nl?globalThis:null;function Aa(e,t,r=[],n={}){let{event:o="keydown",target:i=Jl,eventOptions:a}=n,s=ka(t),c=ur(()=>{let l=Gl(e);return function(u){l(u)&&s.current.call(this,u)}},r);Bl(i,o,c,a)}function Ca(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(r=Ca(e[t]))&&(n&&(n+=" "),n+=r)}else for(r in e)e[r]&&(n&&(n+=" "),n+=r);return n}function Xl(){for(var e,t,r=0,n="",o=arguments.length;r<o;r++)(e=arguments[r])&&(t=Ca(e))&&(n&&(n+=" "),n+=t);return n}var zt=Xl,Zl=Symbol.for("preact-signals");function xn(){if(St>1)St--;else{for(var e,t=!1;kr!==void 0;){var r=kr;for(kr=void 0,io++;r!==void 0;){var n=r.o;if(r.o=void 0,r.f&=-3,!(8&r.f)&&Pa(r))try{r.c()}catch(o){t||(e=o,t=!0)}r=n}}if(io=0,St--,t)throw e}}function Ql(e){if(St>0)return e();St++;try{return e()}finally{xn()}}var ae=void 0;function Ha(e){var t=ae;ae=void 0;try{return e()}finally{ae=t}}var kr=void 0,St=0,io=0,gn=0;function $a(e){if(ae!==void 0){var t=e.n;if(t===void 0||t.t!==ae)return t={i:0,S:e,p:ae.s,n:void 0,t:ae,e:void 0,x:void 0,r:t},ae.s!==void 0&&(ae.s.n=t),ae.s=t,e.n=t,32&ae.f&&e.S(t),t;if(t.i===-1)return t.i=0,t.n!==void 0&&(t.n.p=t.p,t.p!==void 0&&(t.p.n=t.n),t.p=ae.s,t.n=void 0,ae.s.n=t,ae.s=t),t}}function Ce(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Ce.prototype.brand=Zl;Ce.prototype.h=function(){return!0};Ce.prototype.S=function(e){var t=this,r=this.t;r!==e&&e.e===void 0&&(e.x=r,this.t=e,r!==void 0?r.e=e:Ha(function(){var n;(n=t.W)==null||n.call(t)}))};Ce.prototype.U=function(e){var t=this;if(this.t!==void 0){var r=e.e,n=e.x;r!==void 0&&(r.x=n,e.e=void 0),n!==void 0&&(n.e=r,e.x=void 0),e===this.t&&(this.t=n,n===void 0&&Ha(function(){var o;(o=t.Z)==null||o.call(t)}))}};Ce.prototype.subscribe=function(e){var t=this;return qt(function(){var r=t.value,n=ae;ae=void 0;try{e(r)}finally{ae=n}},{name:"sub"})};Ce.prototype.valueOf=function(){return this.value};Ce.prototype.toString=function(){return this.value+""};Ce.prototype.toJSON=function(){return this.value};Ce.prototype.peek=function(){var e=ae;ae=void 0;try{return this.value}finally{ae=e}};Object.defineProperty(Ce.prototype,"value",{get:function(){var e=$a(this);return e!==void 0&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(io>100)throw new Error("Cycle detected");this.v=e,this.i++,gn++,St++;try{for(var t=this.t;t!==void 0;t=t.x)t.t.N()}finally{xn()}}}});function Ot(e,t){return new Ce(e,t)}function Pa(e){for(var t=e.s;t!==void 0;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function Ia(e){for(var t=e.s;t!==void 0;t=t.n){var r=t.S.n;if(r!==void 0&&(t.r=r),t.S.n=t,t.i=-1,t.n===void 0){e.s=t;break}}}function Ra(e){for(var t=e.s,r=void 0;t!==void 0;){var n=t.p;t.i===-1?(t.S.U(t),n!==void 0&&(n.n=t.n),t.n!==void 0&&(t.n.p=n)):r=t,t.S.n=t.r,t.r!==void 0&&(t.r=void 0),t=n}e.s=r}function Kt(e,t){Ce.call(this,void 0),this.x=e,this.s=void 0,this.g=gn-1,this.f=4,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Kt.prototype=new Ce;Kt.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if((36&this.f)==32||(this.f&=-5,this.g===gn))return!0;if(this.g=gn,this.f|=1,this.i>0&&!Pa(this))return this.f&=-2,!0;var e=ae;try{Ia(this),ae=this;var t=this.x();(16&this.f||this.v!==t||this.i===0)&&(this.v=t,this.f&=-17,this.i++)}catch(r){this.v=r,this.f|=16,this.i++}return ae=e,Ra(this),this.f&=-2,!0};Kt.prototype.S=function(e){if(this.t===void 0){this.f|=36;for(var t=this.s;t!==void 0;t=t.n)t.S.S(t)}Ce.prototype.S.call(this,e)};Kt.prototype.U=function(e){if(this.t!==void 0&&(Ce.prototype.U.call(this,e),this.t===void 0)){this.f&=-33;for(var t=this.s;t!==void 0;t=t.n)t.S.U(t)}};Kt.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;e!==void 0;e=e.x)e.t.N()}};Object.defineProperty(Kt.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var e=$a(this);if(this.h(),e!==void 0&&(e.i=this.i),16&this.f)throw this.v;return this.v}});function ta(e,t){return new Kt(e,t)}function ja(e){var t=e.u;if(e.u=void 0,typeof t=="function"){St++;var r=ae;ae=void 0;try{t()}catch(n){throw e.f&=-2,e.f|=8,ho(e),n}finally{ae=r,xn()}}}function ho(e){for(var t=e.s;t!==void 0;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,ja(e)}function eu(e){if(ae!==this)throw new Error("Out-of-order effect");Ra(this),ae=e,this.f&=-2,8&this.f&&ho(this),xn()}function pr(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=t==null?void 0:t.name}pr.prototype.c=function(){var e=this.S();try{if(8&this.f||this.x===void 0)return;var t=this.x();typeof t=="function"&&(this.u=t)}finally{e()}};pr.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1,this.f&=-9,ja(this),Ia(this),St++;var e=ae;return ae=this,eu.bind(this,e)};pr.prototype.N=function(){2&this.f||(this.f|=2,this.o=kr,kr=this)};pr.prototype.d=function(){this.f|=8,1&this.f||ho(this)};pr.prototype.dispose=function(){this.d()};function qt(e,t){var r=new pr(e,t);try{r.c()}catch(o){throw r.d(),o}var n=r.d.bind(r);return n[Symbol.dispose]=n,n}var Fa,vo,eo,Ua=[];qt(function(){Fa=this.N})();function fr(e,t){K[e]=t.bind(null,K[e]||function(){})}function _n(e){eo&&eo(),eo=e&&e.S()}function Na(e){var t=this,r=e.data,n=ru(r);n.value=r;var o=ur(function(){for(var s=t,c=t.__v;c=c.__;)if(c.__c){c.__c.__$f|=4;break}var l=ta(function(){var m=n.value.value;return m===0?0:m===!0?"":m||""}),u=ta(function(){return!Array.isArray(l.value)&&!pa(l.value)}),p=qt(function(){if(this.N=Da,u.value){var m=l.value;s.__v&&s.__v.__e&&s.__v.__e.nodeType===3&&(s.__v.__e.data=m)}}),d=t.__$u.d;return t.__$u.d=function(){p(),d.call(this)},[u,l]},[]),i=o[0],a=o[1];return i.value?a.peek():a.value}Na.displayName="ReactiveTextNode";Object.defineProperties(Ce.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:Na},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});fr("__b",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),typeof t.type=="string"){var r,n=t.props;for(var o in n)if(o!=="children"){var i=n[o];i instanceof Ce&&(r||(t.__np=r={}),r[o]=i,n[o]=i.peek())}}e(t)});fr("__r",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.enterComponent(t),t.type!==ft){_n();var r,n=t.__c;n&&(n.__$f&=-2,(r=n.__$u)===void 0&&(n.__$u=r=(function(o){var i;return qt(function(){i=this}),i.c=function(){n.__$f|=1,n.setState({})},i})())),vo=n,_n(r)}e(t)});fr("__e",function(e,t,r,n){typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0,e(t,r,n)});fr("diffed",function(e,t){typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0;var r;if(typeof t.type=="string"&&(r=t.__e)){var n=t.__np,o=t.props;if(n){var i=r.U;if(i)for(var a in i){var s=i[a];s!==void 0&&!(a in n)&&(s.d(),i[a]=void 0)}else i={},r.U=i;for(var c in n){var l=i[c],u=n[c];l===void 0?(l=tu(r,c,u,o),i[c]=l):l.o(u,o)}}}e(t)});function tu(e,t,r,n){var o=t in e&&e.ownerSVGElement===void 0,i=Ot(r);return{o:function(a,s){i.value=a,n=s},d:qt(function(){this.N=Da;var a=i.value.value;n[t]!==a&&(n[t]=a,o?e[t]=a:a?e.setAttribute(t,a):e.removeAttribute(t))})}}fr("unmount",function(e,t){if(typeof t.type=="string"){var r=t.__e;if(r){var n=r.U;if(n){r.U=void 0;for(var o in n){var i=n[o];i&&i.d()}}}}else{var a=t.__c;if(a){var s=a.__$u;s&&(a.__$u=void 0,s.d())}}e(t)});fr("__h",function(e,t,r,n){(n<3||n===9)&&(t.__$f|=2),e(t,r,n)});at.prototype.shouldComponentUpdate=function(e,t){var r=this.__$u,n=r&&r.s!==void 0;for(var o in t)return!0;if(this.__f||typeof this.u=="boolean"&&this.u===!0){var i=2&this.__$f;if(!(n||i||4&this.__$f)||1&this.__$f)return!0}else if(!(n||4&this.__$f)||3&this.__$f)return!0;for(var a in e)if(a!=="__source"&&e[a]!==this.props[a])return!0;for(var s in this.props)if(!(s in e))return!0;return!1};function ru(e,t){return bn(function(){return Ot(e,t)})[0]}var nu=function(e){queueMicrotask(function(){queueMicrotask(e)})};function ou(){Ql(function(){for(var e;e=Ua.shift();)Fa.call(e)})}function Da(){Ua.push(this)===1&&(K.requestAnimationFrame||nu)(ou)}var ao=[0];for(let e=0;e<32;e++)ao.push(ao[e]|1<<e);function iu(e){return new Uint32Array(e)}var ra=class{constructor(e,t=iu(Math.ceil(e/32))){this.size=e,this.data=t}get(e){return this.data[e>>>5]>>>e&1}set(e){this.data[e>>>5]|=1<<(e&31)}forEach(e){let t=this.size&31;for(let r=0;r<this.data.length;r++){if(this.data[r]===0)continue;let n=this.data[r];t&&r===this.data.length-1&&(n=n&ao[t]);for(let o=0,i=32-Math.clz32(n);o<i;o++)n&1<<o&&e((r<<5)+o)}}};function au(e){lr.value=e,e.items.find(t=>{var r;return(r=t.tags)==null?void 0:r.length})&&(matchMedia("(max-width: 768px)").matches||Wa())}function Dt(){Qe.value=He(H({},Qe.value),{hideSearch:!Qe.value.hideSearch})}function Wa(){Qe.value=He(H({},Qe.value),{hideFilters:!Qe.value.hideFilters})}function dn(){return Qe.value.selectedItem}function so(e){Qe.value=He(H({},Qe.value),{selectedItem:e})}function su(){var e,t;return(t=(e=lr.value)==null?void 0:e.items)!=null?t:[]}function wn(){return typeof Se.value.input=="string"?Se.value.input:""}function Va(e){let t=za();e.length&&!t.length?Se.value=He(H({},Se.value),{page:void 0,input:e}):!e.length&&t.length?Se.value=He(H({},Se.value),{page:void 0,input:{type:"operator",data:{operator:"not",operands:[]}}}):Se.value=He(H({},Se.value),{page:void 0,input:e})}function cu(){typeof it.value.pagination.next<"u"&&(Se.value=He(H({},Se.value),{page:it.value.pagination.next}))}function lu(e){let t=Se.value.filter.input;if("type"in t&&t.type==="operator"){for(let r of t.data.operands)if("type"in r&&r.type==="value"&&typeof r.data.value=="string"&&r.data.value===e)return!0}return!1}function za(){let e=Se.value.filter.input,t=[];if("type"in e&&e.type==="operator")for(let r of e.data.operands)"type"in r&&r.type==="value"&&typeof r.data.value=="string"&&t.push(r.data.value);return t}function uu(e){let t=Se.value.filter.input,r=[];if("type"in t&&t.type==="operator")for(let n of t.data.operands)"type"in n&&n.type==="value"&&typeof n.data.value=="string"&&r.push(n.data.value);if(r.includes(e)){let n=r.indexOf(e);n>-1&&r.splice(n,1)}else r.push(e);Se.value=He(H({},Se.value),{page:void 0,filter:He(H({},Se.value.filter),{input:{type:"operator",data:{operator:"and",operands:r.map(n=>({type:"value",data:{field:"tags",value:n}}))}}})}),Va(wn())}function pu(){return it.value.items}function fu(){return it.value.total}function mu(){var e;for(let t of(e=it.value.aggregations)!=null?e:[])if(t.type==="term")return t.data.value;return[]}function sr(){return Qe.value.hideSearch}function du(){return Qe.value.hideFilters}function qa(){var e;return(e=Ka.value.highlight)!=null?e:!1}var Qe=Ot({hideSearch:!0,hideFilters:!0,selectedItem:0}),Ka=Ot({}),lr=Ot(),na=Ot(),Se=Ot({input:"",filter:{input:{type:"operator",data:{operator:"and",operands:[]}},aggregation:{input:[{type:"term",data:{field:"tags"}}]}}}),it=Ot({items:[],query:{select:{documents:new ra(0),terms:new ra(0)},values:[]},pagination:{total:0}});function hu(e,t,r){for(let n=0;t<r;){switch(n=n<<8^32|e.charCodeAt(++t),n){case 97:case 98:case 99:case 101:case 104:case 105:case 108:case 109:case 112:case 115:case 116:case 119:case 24946:case 25185:case 25455:case 25965:case 26989:case 26990:case 27753:case 28005:case 28769:case 29551:case 29810:case 30562:case 6386277:case 6447475:case 6647138:case 6909552:case 7104878:case 7169396:case 7364978:case 7565173:case 7631457:case 1701667429:case 1768845429:case 1869967971:case 1885434465:case 1936684402:case 1953653091:continue;case 25202:case 26738:case 6516588:case 6909287:case 7823986:case 1634885997:case 1634887009:case 1650553701:case 1818848875:case 1835165028:case 1835365473:case 1852863860:case 1918985067:case 1970430821:switch(e.charCodeAt(++t)){case 9:case 10:case 32:case 47:case 62:return!0}}break}return!1}function vu(e,t,r=0,n=e.length){let o=0,i=r;for(let a=0;i<n;i++)switch(a=e.charCodeAt(i),a){case 60:i>r&&t(0,o,r,r=i);continue;case 62:e.charCodeAt(r+1)===47?t(2,--o,r,r=i+1):hu(e,r,n)?t(3,o,r,r=i+1):t(1,o++,r,r=i+1)}i>r&&t(0,o,r,i)}function bu(e,t=0,r=e.length){let n=++t;e:for(let l=0;n<r;n++)switch(l=e.charCodeAt(n),l){case 9:case 10:case 32:case 62:break e}let o=e.slice(t,t=n),i=[],a=0,s=0,c=0;for(let l=0;n<r;n++){let u=e.charCodeAt(n);switch(a){case 0:switch(u){case 9:case 10:case 32:t===n?t++:(s=1,a=1);break;case 61:s=1,a=2;break;case 47:t++;case 62:t<n&&(s=1);break}break;case 1:switch(u){case 9:case 10:case 32:continue;case 61:a=2,t=n+1;continue;default:a=0,t=n,l++}continue;case 2:switch(u){case 9:case 10:case 32:t===n?t++:c===0&&(s=2,a=0);break;case 34:case 39:switch(c){case 0:c=u,t=n+1;continue;case u:s=2,a=0,c=0}break;case 62:t<n&&(s=2);break}}switch(s){case 1:i[l]=[e.slice(t,n),""],s=0,t=n+1;break;case 2:i[l++][1]=e.slice(t,n),s=0,t=n+1;break}}return{tag:o,attrs:i.length?Object.fromEntries(i):null}}function gu(e,t,r){return e.slice(t,r)}function _u(e){return(t,r,n,o)=>{let i=[],a=[],{onElement:s,onText:c=gu}=typeof r=="function"?{onElement:r}:r,l=0,u=0;return e(t,(p,d,m,h)=>{if(p===0)i[l++]=c(t,m,h),a[u++]={value:null,depth:d};else if(p&1&&(a[u++]={value:bu(t,m,h),depth:d}),p&2)for(let v=0;u>=0;v++){let{value:x,depth:w}=a[--u];if(w>d)continue;let E=i.slice(l-=v,l+v);i[l++]=s(x,E),u++;break}},n,o),i.slice(0,l)}}function yu(e){return e.replace(/[&<>]/g,t=>{switch(t.charCodeAt(0)){case 38:return"&amp;";case 60:return"&lt;";case 62:return"&gt;"}})}function hn(e){return e.replace(/&(amp|[lg]t);/g,t=>{switch(t.charCodeAt(1)){case 97:return"&";case 108:return"<";case 103:return">"}})}function xu(e,t){return{start:e.start+t,end:e.end+t,value:e.value}}function wu(e,t,r){return e.slice(t,r)}function Eu(e){let{onHighlight:t,onText:r=wu}=typeof e=="function"?{onHighlight:e}:e;return(n,o,i=0,a=n.length)=>{var l;let s=[],c=(l=o==null?void 0:o.ranges)!=null?l:[];for(let u=0,p=i;u<c.length;u++){let d=c[u].start;if(d>a)break;let m=c[u].end;if(m<p)continue;d=Math.max(d,i),m=Math.min(m,a),d>i&&s.push(r(n,i,d));let{value:h}=c[u];s.push(t(n,{start:d,end:i=m,value:h}))}return i<a&&s.push(r(n,i,a)),s}}var Tu={fuzzy:"v"},Su=0;function z(e,t,r,n,o,i){t||(t={});var a,s,c=t;if("ref"in c)for(s in c={},t)s=="ref"?a=t[s]:c[s]=t[s];var l={type:e,props:c,key:r,ref:a,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--Su,__i:-1,__u:0,__source:o,__self:i};if(typeof e=="function"&&(a=e.defaultProps))for(s in a)c[s]===void 0&&(c[s]=a[s]);return K.vnode&&K.vnode(l),l}var Ou=_u(vu),Lu=Eu({onText(e,t,r){return hn(e.slice(t,r))},onHighlight(e,{start:t,end:r,value:n}){let o=Math.min(r,t+n);return t===r?null:(n===-1&&(o=r),z("mark",{className:zt({[Tu.fuzzy]:n===-1}),children:[z("u",{children:hn(e.slice(t,o))}),hn(e.slice(o,r))]}))}});function Ba(e,t){let r=Ou(e,{onElement(n,o){return Wt(n.tag,n.attrs,...o)},onText(n,o,i){return Lu(n,t==null?void 0:t.value.highlight,o,i)}});return z(ft,{children:r})}function Mu(e,t){var n;let r=[];for(let o=0,i=0;o<e.length;o++){let a=[];if((n=t==null?void 0:t.value.highlight)!=null&&n.ranges)for(let s of t.value.highlight.ranges)a.push(xu(s,-i));r.push(Ba(e[o],He(H({},t),{value:He(H({},t==null?void 0:t.value),{highlight:{ranges:a}})}))),i+=e[o].length}return r}function Ya(e,t={highlight:!0}){Ka.value=t;let r=new Worker(e);r.onmessage=n=>{let o=n.data;switch(o.type){case 1:na.value=!0;break;case 3:typeof o.data.pagination.prev<"u"?it.value=He(H({},it.value),{pagination:o.data.pagination,items:[...it.value.items,...o.data.items]}):(it.value=o.data,so(0));break}},qt(()=>{lr.value&&r.postMessage({type:0,data:lr.value})}),qt(()=>{na.value&&r.postMessage({type:2,data:Se.value})})}var oa={container:"p",hidden:"m"};function ku(e){return z("div",{class:zt(oa.container,{[oa.hidden]:e.hidden}),onClick:()=>Dt()})}var ia={container:"r",disabled:"c"};function co(e){return z("button",{class:zt(ia.container,{[ia.disabled]:!e.onClick}),onClick:e.onClick,children:e.children})}var aa=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),Au=e=>e.replace(/^([A-Z])|[\s-_]+(\w)/g,(t,r,n)=>n?n.toUpperCase():r.toLowerCase()),sa=e=>{let t=Au(e);return t.charAt(0).toUpperCase()+t.slice(1)},Cu=(...e)=>e.filter((t,r,n)=>!!t&&t.trim()!==""&&n.indexOf(t)===r).join(" ").trim(),Hu={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},$u=c=>{var l=c,{color:e="currentColor",size:t=24,strokeWidth:r=2,absoluteStrokeWidth:n,children:o,iconNode:i,class:a=""}=l,s=gr(l,["color","size","strokeWidth","absoluteStrokeWidth","children","iconNode","class"]);return Wt("svg",H(He(H({},Hu),{width:String(t),height:t,stroke:e,"stroke-width":n?Number(r)*24/Number(t):r,class:["lucide",a].join(" ")}),s),[...i.map(([u,p])=>Wt(u,p)),...Cr(o)])},bo=(e,t)=>{let r=a=>{var s=a,{class:n="",children:o}=s,i=gr(s,["class","children"]);return Wt($u,He(H({},i),{iconNode:t,class:Cu(`lucide-${aa(sa(e))}`,`lucide-${aa(e)}`,n)}),o)};return r.displayName=sa(e),r},Pu=bo("corner-down-left",[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4",key:"6o5b7l"}],["path",{d:"m9 10-5 5 5 5",key:"1kshq7"}]]),Iu=bo("list-filter",[["path",{d:"M2 5h20",key:"1fs1ex"}],["path",{d:"M6 12h12",key:"8npq4p"}],["path",{d:"M9 19h6",key:"456am0"}]]),Ru=bo("search",[["path",{d:"m21 21-4.34-4.34",key:"14j7rj"}],["circle",{cx:"11",cy:"11",r:"8",key:"4ej97u"}]]),Gx=hl(vl(),1);function ju({threshold:e=0,root:t=null,rootMargin:r="0%",freezeOnceVisible:n=!1,initialIsIntersecting:o=!1,onChange:i}={}){var a;let[s,c]=bn(null),[l,u]=bn(()=>({isIntersecting:o,entry:void 0})),p=Vt();p.current=i;let d=((a=l.entry)==null?void 0:a.isIntersecting)&&n;mt(()=>{if(!s||!("IntersectionObserver"in window)||d)return;let v,x=new IntersectionObserver(w=>{let E=Array.isArray(x.thresholds)?x.thresholds:[x.thresholds];w.forEach(_=>{let de=_.isIntersecting&&E.some(be=>_.intersectionRatio>=be);u({isIntersecting:de,entry:_}),p.current&&p.current(de,_),de&&n&&v&&(v(),v=void 0)})},{threshold:e,root:t,rootMargin:r});return x.observe(s),()=>{x.disconnect()}},[s,JSON.stringify(e),t,r,d,n]);let m=Vt(null);mt(()=>{var v;!s&&(v=l.entry)!=null&&v.target&&!n&&!d&&m.current!==l.entry.target&&(m.current=l.entry.target,u({isIntersecting:o,entry:void 0}))},[s,l.entry,n,d,o]);let h=[c,!!l.isIntersecting,l.entry];return h.ref=h[0],h.isIntersecting=h[1],h.entry=h[2],h}var lt={container:"n",hidden:"l",content:"u",pop:"d",badge:"y",sidebar:"i",controls:"w",results:"k",loadmore:"z"};function Fu(e){let{isIntersecting:t,ref:r}=ju({threshold:0});mt(()=>{t&&cu()},[t]);let n=Vt(null);mt(()=>{n.current&&typeof Se.value.page>"u"&&n.current.scrollTo({top:0,behavior:"smooth"})},[Se.value]);let o=za();return z("div",{class:zt(lt.container,{[lt.hidden]:e.hidden}),children:[z("div",{class:lt.content,children:[z("div",{class:lt.controls,children:[z(co,{onClick:Dt,children:z(Ru,{})}),z(Nu,{focus:!e.hidden}),z(co,{onClick:Wa,children:[z(Iu,{}),o.length>0&&z("span",{class:lt.badge,children:o.length})]})]}),z("div",{class:lt.results,ref:n,children:[z(Du,{keyboard:!e.hidden}),z("div",{class:lt.loadmore,ref:r})]})]}),z("div",{class:zt(lt.sidebar,{[lt.hidden]:du()}),children:z(Uu,{})})]})}var Tt={container:"X",list:"j",heading:"F",title:"I",item:"o",active:"g",value:"R",count:"q"};function Uu(e){let t=mu();return t.sort((r,n)=>n.node.count-r.node.count),z("div",{class:Tt.container,children:[z("h3",{class:Tt.heading,children:"Filters"}),z("h4",{class:Tt.title,children:"Tags"}),z("ol",{class:Tt.list,children:t.map(r=>z("li",{class:zt(Tt.item,{[Tt.active]:lu(r.node.value)}),onClick:()=>uu(r.node.value),children:[z("span",{class:Tt.value,children:r.node.value}),z("span",{class:Tt.count,children:r.node.count})]}))})]})}var ca={container:"f"};function Nu(e){let t=Vt(null);return mt(()=>{var r,n;e.focus?(r=t.current)==null||r.focus():(n=t.current)==null||n.blur()},[e.focus]),z("div",{class:ca.container,children:z("input",{ref:t,type:"text",class:ca.content,value:hn(wn()),onInput:r=>Va(yu(r.currentTarget.value)),autocapitalize:"off",autocomplete:"off",autocorrect:"off",placeholder:"Search",spellcheck:!1,role:"combobox"})})}var ut={container:"b",heading:"A",item:"a",active:"h",wrapper:"B",actions:"s",title:"x",path:"t"};function Ga(){let[e,t]=bn(!1);return mt(()=>{let r=()=>t(!0),n=()=>t(!1);return document.addEventListener("compositionstart",r),document.addEventListener("compositionend",n),()=>{document.removeEventListener("compositionstart",r),document.removeEventListener("compositionend",n)}},[]),e}function Du(e){var s;let t=su(),r=pu(),n=dn(),o=Vt([]),i=Ga();mt(()=>{let c=o.current[n];c&&c.scrollIntoView({block:"center",behavior:"smooth"})},[n]),Aa(e.keyboard,c=>{if(i)return;let l=dn();c.key==="ArrowDown"?(c.preventDefault(),so(Math.min(l+1,r.length-1))):c.key==="ArrowUp"&&(c.preventDefault(),so(Math.max(l-1,0)))},[e.keyboard,i]);let a=(s=fu())!=null?s:0;return z(ft,{children:[r.length>0&&z("h3",{class:ut.heading,children:[z("span",{class:ut.bubble,children:new Intl.NumberFormat("en-US").format(a)})," ","results"]}),z("ol",{class:ut.container,children:r.map((c,l)=>{var m;let u=Ba(t[c.id].title,c.matches.find(({field:h})=>h==="title")),p=Mu((m=t[c.id].path)!=null?m:[],c.matches.find(({field:h})=>h==="path")),d=t[c.id].location;if(qa()){let h=encodeURIComponent(wn()),[v,x]=d.split("#",2);d=`${v}?h=${h.replace(/%20/g,"+")}`,typeof x<"u"&&(d+=`#${x}`)}return z("li",{children:z("a",{ref:h=>{o.current[l]=h},href:d,onClick:()=>Dt(),class:zt(ut.item,{[ut.active]:l===dn()}),children:[z("div",{class:ut.wrapper,children:[z("h2",{class:ut.title,children:u}),z("menu",{class:ut.path,children:p.map(h=>z("li",{children:h}))})]}),z("nav",{class:ut.actions,children:z(co,{children:z(Pu,{})})})]})})})})]})}var Wu={container:"e"};function Vu(e){let t=Ga();return Aa(!0,r=>{var n,o,i,a,s;if(!t)if((r.metaKey||r.ctrlKey)&&r.key==="k")r.preventDefault(),Dt();else if((r.metaKey||r.ctrlKey)&&r.key==="j")document.body.classList.toggle("dark");else if(r.key==="Enter"&&!sr()){r.preventDefault();let c=dn(),l=(o=(n=it.value)==null?void 0:n.items[c])==null?void 0:o.id;if((a=(i=lr.value)==null?void 0:i.items[l])!=null&&a.location){Dt();let u=(s=lr.value)==null?void 0:s.items[l].location;if(qa()){let p=encodeURIComponent(wn()),[d,m]=u.split("#",2);u=`${d}?h=${p.replace(/%20/g,"+")}`,typeof m<"u"&&(u+=`#${m}`)}window.location.href=u}}else r.key==="Escape"&&!sr()&&(r.preventDefault(),Dt())},[t]),z("div",{class:Wu.container,children:[z(ku,{hidden:sr()}),z(Fu,{hidden:sr()})]})}function Ja(e,t){au(e),El(z(Vu,{}),t)}function go(){Dt()}function zu(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function qu(){return R(b(window,"compositionstart").pipe(f(()=>!0)),b(window,"compositionend").pipe(f(()=>!1))).pipe(J(!1))}function Xa(){let e=b(window,"keydown").pipe(f(t=>({mode:sr()?"global":"search",type:t.key,meta:t.ctrlKey||t.metaKey,claim(){t.preventDefault(),t.stopPropagation()}})),L(({mode:t,type:r})=>{if(t==="global"){let n=xt();if(typeof n!="undefined")return!zu(n,r)}return!0}),xe());return qu().pipe(g(t=>t?y:e))}function Ye(){return new URL(location.href)}function dt(e,t=!1){if(X("navigation.instant")&&!t){let r=A("a",{href:e.href});document.body.appendChild(r),r.click(),r.remove()}else location.href=e.href}function Za(){return new I}function Qa(){return location.hash.slice(1)}function es(e){let t=A("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function _o(e){return R(b(window,"hashchange"),e).pipe(f(Qa),J(Qa()),L(t=>t.length>0),se(1))}function ts(e){return _o(e).pipe(f(t=>Le(`[id="${t}"]`)),L(t=>typeof t!="undefined"))}function Ir(e){let t=matchMedia(e);return an(r=>t.addListener(()=>r(t.matches))).pipe(J(t.matches))}function rs(){let e=matchMedia("print");return R(b(window,"beforeprint").pipe(f(()=>!0)),b(window,"afterprint").pipe(f(()=>!1))).pipe(J(e.matches))}function yo(e,t){return e.pipe(g(r=>r?t():y))}function xo(e,t){return new U(r=>{let n=new XMLHttpRequest;return n.open("GET",`${e}`),n.responseType="blob",n.addEventListener("load",()=>{n.status>=200&&n.status<300?(r.next(n.response),r.complete()):r.error(new Error(n.statusText))}),n.addEventListener("error",()=>{r.error(new Error("Network error"))}),n.addEventListener("abort",()=>{r.complete()}),typeof(t==null?void 0:t.progress$)!="undefined"&&(n.addEventListener("progress",o=>{var i;if(o.lengthComputable)t.progress$.next(o.loaded/o.total*100);else{let a=(i=n.getResponseHeader("Content-Length"))!=null?i:0;t.progress$.next(o.loaded/+a*100)}}),t.progress$.next(5)),n.send(),()=>n.abort()})}function et(e,t){return xo(e,t).pipe(g(r=>r.text()),f(r=>JSON.parse(r)),se(1))}function En(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/html")),se(1))}function ns(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/xml")),se(1))}var wo={drawer:G("[data-md-toggle=drawer]"),search:G("[data-md-toggle=search]")};function Eo(e,t){wo[e].checked!==t&&wo[e].click()}function Tn(e){let t=wo[e];return b(t,"change").pipe(f(()=>t.checked),J(t.checked))}function os(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function is(){return R(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(f(os),J(os()))}function as(){return{width:innerWidth,height:innerHeight}}function ss(){return b(window,"resize",{passive:!0}).pipe(f(as),J(as()))}function cs(){return re([is(),ss()]).pipe(f(([e,t])=>({offset:e,size:t})),se(1))}function Sn(e,{viewport$:t,header$:r}){let n=t.pipe(fe("size")),o=re([n,r]).pipe(f(()=>wt(e)));return re([r,t,o]).pipe(f(([{height:i},{offset:a,size:s},{x:c,y:l}])=>({offset:{x:a.x-c,y:a.y-l+i},size:s})))}var Ku=G("#__config"),mr=JSON.parse(Ku.textContent);mr.base=`${new URL(mr.base,Ye())}`;function Ue(){return mr}function X(e){return mr.features.includes(e)}function Bt(e,t){return typeof t!="undefined"?mr.translations[e].replace("#",t.toString()):mr.translations[e]}function ht(e,t=document){return G(`[data-md-component=${e}]`,t)}function Ee(e,t=document){return P(`[data-md-component=${e}]`,t)}function Bu(e){let t=G(".md-typeset > :first-child",e);return b(t,"click",{once:!0}).pipe(f(()=>G(".md-typeset",e)),f(r=>({hash:__md_hash(r.innerHTML)})))}function ls(e){if(!X("announce.dismiss")||!e.childElementCount)return y;if(!e.hidden){let t=G(".md-typeset",e);__md_hash(t.innerHTML)===__md_get("__announce")&&(e.hidden=!0)}return j(()=>{let t=new I;return t.subscribe(({hash:r})=>{e.hidden=!0,__md_set("__announce",r)}),Bu(e).pipe($(r=>t.next(r)),V(()=>t.complete()),f(r=>H({ref:e},r)))})}function Yu(e,{target$:t}){return t.pipe(f(r=>({hidden:r!==e})))}function us(e,t){let r=new I;return r.subscribe(({hidden:n})=>{e.hidden=n}),Yu(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))}function To(e,t){return t==="inline"?A("div",{class:"md-tooltip md-tooltip--inline",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"})):A("div",{class:"md-tooltip",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"}))}function On(...e){return A("div",{class:"md-tooltip2",role:"dialog"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function ps(...e){return A("div",{class:"md-tooltip2",role:"tooltip"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function fs(e,t){if(t=t?`${t}_annotation_${e}`:void 0,t){let r=t?`#${t}`:void 0;return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("a",{href:r,class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}else return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("span",{class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}function ms(e){return A("button",{class:"md-code__button",title:Bt("clipboard.copy"),"data-clipboard-target":`#${e} > code`,"data-md-type":"copy"})}function ds(){return A("button",{class:"md-code__button",title:"Toggle line selection","data-md-type":"select"})}function hs(){return A("nav",{class:"md-code__nav"})}var Xu=_r(So());function bs(e){return A("ul",{class:"md-source__facts"},Object.entries(e).map(([t,r])=>A("li",{class:`md-source__fact md-source__fact--${t}`},typeof r=="number"?Li(r):r)))}function Oo(e){let t=`tabbed-control tabbed-control--${e}`;return A("div",{class:t,hidden:!0},A("button",{class:"tabbed-button",tabIndex:-1,"aria-hidden":"true"}))}function gs(e){return A("div",{class:"md-typeset__scrollwrap"},A("div",{class:"md-typeset__table"},e))}function Zu(e){var n;let t=Ue(),r=new URL(`../${e.version}/`,t.base);return A("li",{class:"md-version__item"},A("a",{href:`${r}`,class:"md-version__link"},e.title,((n=t.version)==null?void 0:n.alias)&&e.aliases.length>0&&A("span",{class:"md-version__alias"},e.aliases[0])))}function _s(e,t){var n;let r=Ue();return e=e.filter(o=>{var i;return!((i=o.properties)!=null&&i.hidden)}),A("div",{class:"md-version"},A("button",{class:"md-version__current","aria-label":Bt("select.version")},t.title,((n=r.version)==null?void 0:n.alias)&&t.aliases.length>0&&A("span",{class:"md-version__alias"},t.aliases[0])),A("ul",{class:"md-version__list"},e.map(Zu)))}var Qu=0;function ep(e,t=250){let r=re([ir(e),Ft(e,t)]).pipe(f(([o,i])=>o||i),ie()),n=j(()=>Ai(e)).pipe(oe(Ut),Lr(1),Ze(r),f(()=>Ci(e)));return r.pipe(Sr(o=>o),g(()=>re([r,n])),f(([o,i])=>({active:o,offset:i})),xe())}function Rr(e,t,r=250){let{content$:n,viewport$:o}=t,i=`__tooltip2_${Qu++}`;return j(()=>{let a=new I,s=new Un(!1);a.pipe(he(),ye(!1)).subscribe(s);let c=s.pipe(Tr(u=>Ve(+!u*250,Wn)),ie(),g(u=>u?n:y),$(u=>u.id=i),xe());re([a.pipe(f(({active:u})=>u)),c.pipe(g(u=>Ft(u,250)),J(!1))]).pipe(f(u=>u.some(p=>p))).subscribe(s);let l=s.pipe(L(u=>u),pe(c,o),f(([u,p,{size:d}])=>{let m=e.getBoundingClientRect(),h=m.width/2;if(p.role==="tooltip")return{x:h,y:8+m.height};if(m.y>=d.height/2){let{height:v}=Ae(p);return{x:h,y:-16-v}}else return{x:h,y:16+m.height}}));return re([c,a,l]).subscribe(([u,{offset:p},d])=>{u.style.setProperty("--md-tooltip-host-x",`${p.x}px`),u.style.setProperty("--md-tooltip-host-y",`${p.y}px`),u.style.setProperty("--md-tooltip-x",`${d.x}px`),u.style.setProperty("--md-tooltip-y",`${d.y}px`),u.classList.toggle("md-tooltip2--top",d.y<0),u.classList.toggle("md-tooltip2--bottom",d.y>=0)}),s.pipe(L(u=>u),pe(c,(u,p)=>p),L(u=>u.role==="tooltip")).subscribe(u=>{let p=Ae(G(":scope > *",u));u.style.setProperty("--md-tooltip-width",`${p.width}px`),u.style.setProperty("--md-tooltip-tail","0px")}),s.pipe(ie(),Ie(je),pe(c)).subscribe(([u,p])=>{p.classList.toggle("md-tooltip2--active",u)}),re([s.pipe(L(u=>u)),c]).subscribe(([u,p])=>{p.role==="dialog"?(e.setAttribute("aria-controls",i),e.setAttribute("aria-haspopup","dialog")):e.setAttribute("aria-describedby",i)}),s.pipe(L(u=>!u)).subscribe(()=>{e.removeAttribute("aria-controls"),e.removeAttribute("aria-describedby"),e.removeAttribute("aria-haspopup")}),ep(e,r).pipe($(u=>a.next(u)),V(()=>a.complete()),f(u=>H({ref:e},u)))})}function Ge(e,{viewport$:t},r=document.body){return Rr(e,{content$:new U(n=>{let o=e.title,i=ps(o);return n.next(i),e.removeAttribute("title"),r.append(i),()=>{i.remove(),e.setAttribute("title",o)}}),viewport$:t},0)}function tp(e,t){let r=j(()=>re([Hi(e),Ut(t)])).pipe(f(([{x:n,y:o},i])=>{let{width:a,height:s}=Ae(e);return{x:n-i.x+a/2,y:o-i.y+s/2}}));return ir(e).pipe(g(n=>r.pipe(f(o=>({active:n,offset:o})),Me(+!n||1/0))))}function ys(e,t,{target$:r}){let[n,o]=Array.from(e.children);return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({offset:s}){e.style.setProperty("--md-tooltip-x",`${s.x}px`),e.style.setProperty("--md-tooltip-y",`${s.y}px`)},complete(){e.style.removeProperty("--md-tooltip-x"),e.style.removeProperty("--md-tooltip-y")}}),Et(e).pipe(Q(a)).subscribe(s=>{e.toggleAttribute("data-md-visible",s)}),R(i.pipe(L(({active:s})=>s)),i.pipe(Be(250),L(({active:s})=>!s))).subscribe({next({active:s}){s?e.prepend(n):n.remove()},complete(){e.prepend(n)}}),i.pipe(Xe(16,je)).subscribe(({active:s})=>{n.classList.toggle("md-tooltip--active",s)}),i.pipe(Lr(125,je),L(()=>!!e.offsetParent),f(()=>e.offsetParent.getBoundingClientRect()),f(({x:s})=>s)).subscribe({next(s){s?e.style.setProperty("--md-tooltip-0",`${-s}px`):e.style.removeProperty("--md-tooltip-0")},complete(){e.style.removeProperty("--md-tooltip-0")}}),b(o,"click").pipe(Q(a),L(s=>!(s.metaKey||s.ctrlKey))).subscribe(s=>{s.stopPropagation(),s.preventDefault()}),b(o,"mousedown").pipe(Q(a),pe(i)).subscribe(([s,{active:c}])=>{var l;if(s.button!==0||s.metaKey||s.ctrlKey)s.preventDefault();else if(c){s.preventDefault();let u=e.parentElement.closest(".md-annotation");u instanceof HTMLElement?u.focus():(l=xt())==null||l.blur()}}),r.pipe(Q(a),L(s=>s===n),It(125)).subscribe(()=>e.focus()),tp(e,t).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function rp(e){let t=Ue();if(e.tagName!=="CODE")return[e];let r=[".c",".c1",".cm"];if(t.annotate){let n=e.closest("[class|=language]");if(n)for(let o of Array.from(n.classList)){if(!o.startsWith("language-"))continue;let[,i]=o.split("-");i in t.annotate&&r.push(...t.annotate[i])}}return P(r.join(", "),e)}function np(e){let t=[];for(let r of rp(e)){let n=[],o=document.createNodeIterator(r,NodeFilter.SHOW_TEXT);for(let i=o.nextNode();i;i=o.nextNode())n.push(i);for(let i of n){let a;for(;a=/(\(\d+\))(!)?/.exec(i.textContent);){let[,s,c]=a;if(typeof c=="undefined"){let l=i.splitText(a.index);i=l.splitText(s.length),t.push(l)}else{i.textContent=s,t.push(i);break}}}}return t}function xs(e,t){t.append(...Array.from(e.childNodes))}function Ln(e,t,{target$:r,print$:n}){let o=t.closest("[id]"),i=o==null?void 0:o.id,a=new Map;for(let s of np(t)){let[,c]=s.textContent.match(/\((\d+)\)/);Le(`:scope > li:nth-child(${c})`,e)&&(a.set(c,fs(c,i)),s.replaceWith(a.get(c)))}return a.size===0?y:j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=[];for(let[u,p]of a)l.push([G(".md-typeset",p),G(`:scope > li:nth-child(${u})`,e)]);return n.pipe(Q(c)).subscribe(u=>{e.hidden=!u,e.classList.toggle("md-annotation-list",u);for(let[p,d]of l)u?xs(p,d):xs(d,p)}),R(...[...a].map(([,u])=>ys(u,t,{target$:r}))).pipe(V(()=>s.complete()),xe())})}function ws(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return ws(t)}}function Es(e,t){return j(()=>{let r=ws(e);return typeof r!="undefined"?Ln(r,e,t):y})}var Ss=_r(Mo());var op=0,Ts=R(b(window,"keydown").pipe(f(()=>!0)),R(b(window,"keyup"),b(window,"contextmenu")).pipe(f(()=>!1))).pipe(J(!1),se(1));function Os(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return Os(t)}}function ip(e){return Re(e).pipe(f(({width:t})=>({scrollable:Mr(e).width>t})),fe("scrollable"))}function Ls(e,t){let{matches:r}=matchMedia("(hover)"),n=j(()=>{let o=new I,i=o.pipe(Gn(1));o.subscribe(({scrollable:m})=>{m&&r?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")});let a=[],s=e.closest("pre"),c=s.closest("[id]"),l=c?c.id:op++;s.id=`__code_${l}`;let u=[],p=e.closest(".highlight");if(p instanceof HTMLElement){let m=Os(p);if(typeof m!="undefined"&&(p.classList.contains("annotate")||X("content.code.annotate"))){let h=Ln(m,e,t);u.push(Re(p).pipe(Q(i),f(({width:v,height:x})=>v&&x),ie(),g(v=>v?h:y)))}}let d=P(":scope > span[id]",e);if(d.length&&(e.classList.add("md-code__content"),e.closest(".select")||X("content.code.select")&&!e.closest(".no-select"))){let m=+d[0].id.split("-").pop(),h=ds();a.push(h),X("content.tooltips")&&u.push(Ge(h,{viewport$}));let v=b(h,"click").pipe(Or(M=>!M,!1),$(()=>h.blur()),xe());v.subscribe(M=>{h.classList.toggle("md-code__button--active",M)});let x=me(d).pipe(oe(M=>Ft(M).pipe(f(O=>[M,O]))));v.pipe(g(M=>M?x:y)).subscribe(([M,O])=>{let N=Le(".hll.select",M);if(N&&!O)N.replaceWith(...Array.from(N.childNodes));else if(!N&&O){let ee=document.createElement("span");ee.className="hll select",ee.append(...Array.from(M.childNodes).slice(1)),M.append(ee)}});let w=me(d).pipe(oe(M=>b(M,"mousedown").pipe($(O=>O.preventDefault()),f(()=>M)))),E=v.pipe(g(M=>M?w:y),pe(Ts),f(([M,O])=>{var ee;let N=d.indexOf(M)+m;if(O===!1)return[N,N];{let le=P(".hll",e).map(ce=>d.indexOf(ce.parentElement)+m);return(ee=window.getSelection())==null||ee.removeAllRanges(),[Math.min(N,...le),Math.max(N,...le)]}})),_=_o(y).pipe(L(M=>M.startsWith(`__codelineno-${l}-`)));_.subscribe(M=>{let[,,O]=M.split("-"),N=O.split(":").map(le=>+le-m+1);N.length===1&&N.push(N[0]);for(let le of P(".hll:not(.select)",e))le.replaceWith(...Array.from(le.childNodes));let ee=d.slice(N[0]-1,N[1]);for(let le of ee){let ce=document.createElement("span");ce.className="hll",ce.append(...Array.from(le.childNodes).slice(1)),le.append(ce)}}),_.pipe(Me(1),Ie(ge)).subscribe(M=>{if(M.includes(":")){let O=document.getElementById(M.split(":")[0]);O&&setTimeout(()=>{let N=O,ee=-64;for(;N!==document.body;)ee+=N.offsetTop,N=N.offsetParent;window.scrollTo({top:ee})},1)}});let be=me(P('a[href^="#__codelineno"]',p)).pipe(oe(M=>b(M,"click").pipe($(O=>O.preventDefault()),f(()=>M)))).pipe(Q(i),pe(Ts),f(([M,O])=>{let ee=+G(`[id="${M.hash.slice(1)}"]`).parentElement.id.split("-").pop();if(O===!1)return[ee,ee];{let le=P(".hll",e).map(ce=>+ce.parentElement.id.split("-").pop());return[Math.min(ee,...le),Math.max(ee,...le)]}}));R(E,be).subscribe(M=>{let O=`#__codelineno-${l}-`;M[0]===M[1]?O+=M[0]:O+=`${M[0]}:${M[1]}`,history.replaceState({},"",O),window.dispatchEvent(new HashChangeEvent("hashchange",{newURL:window.location.origin+window.location.pathname+O,oldURL:window.location.href}))})}if(Ss.default.isSupported()&&(e.closest(".copy")||X("content.code.copy")&&!e.closest(".no-copy"))){let m=ms(s.id);a.push(m),X("content.tooltips")&&u.push(Ge(m,{viewport$}))}if(a.length){let m=hs();m.append(...a),s.insertBefore(m,e)}return ip(e).pipe($(m=>o.next(m)),V(()=>o.complete()),f(m=>H({ref:e},m)),Rt(R(...u).pipe(Q(i))))});return X("content.lazy")?Et(e).pipe(L(o=>o),Me(1),g(()=>n)):n}function ap(e,{target$:t,print$:r}){let n=!0;return R(t.pipe(f(o=>o.closest("details:not([open])")),L(o=>e===o),f(()=>({action:"open",reveal:!0}))),r.pipe(L(o=>o||!n),$(()=>n=e.open),f(o=>({action:o?"open":"close"}))))}function Ms(e,t){return j(()=>{let r=new I;return r.subscribe(({action:n,reveal:o})=>{e.toggleAttribute("open",n==="open"),o&&e.scrollIntoView()}),ap(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}var ks=0,As=new Map;function sp(e){let t=document.createElement("h3");t.innerHTML=e.innerHTML;let r=[t],n=e.nextElementSibling;for(;n&&!(n instanceof HTMLHeadingElement);)r.push(n.cloneNode(!0)),n=n.nextElementSibling;return r}function cp(e,t){for(let r of P("[href], [src]",e))for(let n of["href","src"]){let o=r.getAttribute(n);if(o&&!/^(?:[a-z]+:)?\/\//i.test(o)){r[n]=new URL(r.getAttribute(n),t).toString();break}}for(let r of P("[name^=__], [for]",e))for(let n of["id","for","name"]){let o=r.getAttribute(n);o&&r.setAttribute(n,`${o}$preview_${ks}`)}return ks++,Y(e)}function lp(e){let t=As.get(e.toString());return t?Y(t):En(e).pipe(g(r=>cp(r,e)),f(r=>(As.set(e.toString(),r),r)))}function Cs(e,t){let{sitemap$:r}=t;if(!(e instanceof HTMLAnchorElement))return y;if(!(X("navigation.instant.preview")||e.hasAttribute("data-preview")))return y;e.removeAttribute("title");let n=re([ir(e),Ft(e).pipe(ke(1))]).pipe(f(([i,a])=>i||a),ie(),L(i=>i));return $t([r,n]).pipe(g(([i])=>{let a=new URL(e.href);return a.search=a.hash="",i.has(`${a}`)?Y(a):y}),g(i=>lp(i)),g(i=>{let a=e.hash?`article [id="${decodeURIComponent(e.hash.slice(1))}"]`:"article h1",s=Le(a,i);return typeof s=="undefined"?y:Y(sp(s))})).pipe(g(i=>{let a=new U(s=>{let c=On(...i);return s.next(c),document.body.append(c),()=>c.remove()});return Rr(e,H({content$:a},t))}))}var Hs=".node circle,.node ellipse,.node path,.node polygon,.node rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}marker{fill:var(--md-mermaid-edge-color)!important}.edgeLabel .label rect{fill:#0000}.flowchartTitleText{fill:var(--md-mermaid-label-fg-color)}.label{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.label foreignObject{line-height:normal;overflow:visible}.label div .edgeLabel{color:var(--md-mermaid-label-fg-color)}.edgeLabel,.edgeLabel p,.label div .edgeLabel{background-color:var(--md-mermaid-label-bg-color)}.edgeLabel,.edgeLabel p{fill:var(--md-mermaid-label-bg-color);color:var(--md-mermaid-edge-color)}.edgePath .path,.flowchart-link{stroke:var(--md-mermaid-edge-color)}.edgePath .arrowheadPath{fill:var(--md-mermaid-edge-color);stroke:none}.cluster rect{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}.cluster span{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}g #flowchart-circleEnd,g #flowchart-circleStart,g #flowchart-crossEnd,g #flowchart-crossStart,g #flowchart-pointEnd,g #flowchart-pointStart{stroke:none}.classDiagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.classGroup line,g.classGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.classGroup text{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.classLabel .box{fill:var(--md-mermaid-label-bg-color);background-color:var(--md-mermaid-label-bg-color);opacity:1}.classLabel .label{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.node .divider{stroke:var(--md-mermaid-node-fg-color)}.relation{stroke:var(--md-mermaid-edge-color)}.cardinality{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.cardinality text{fill:inherit!important}defs marker.marker.composition.class path,defs marker.marker.dependency.class path,defs marker.marker.extension.class path{fill:var(--md-mermaid-edge-color)!important;stroke:var(--md-mermaid-edge-color)!important}defs marker.marker.aggregation.class path{fill:var(--md-mermaid-label-bg-color)!important;stroke:var(--md-mermaid-edge-color)!important}.statediagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.stateGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.stateGroup .state-title{fill:var(--md-mermaid-label-fg-color)!important;font-family:var(--md-mermaid-font-family)}g.stateGroup .composit{fill:var(--md-mermaid-label-bg-color)}.nodeLabel,.nodeLabel p{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}a .nodeLabel{text-decoration:underline}.node circle.state-end,.node circle.state-start,.start-state{fill:var(--md-mermaid-edge-color);stroke:none}.end-state-inner,.end-state-outer{fill:var(--md-mermaid-edge-color)}.end-state-inner,.node circle.state-end{stroke:var(--md-mermaid-label-bg-color)}.transition{stroke:var(--md-mermaid-edge-color)}[id^=state-fork] rect,[id^=state-join] rect{fill:var(--md-mermaid-edge-color)!important;stroke:none!important}.statediagram-cluster.statediagram-cluster .inner{fill:var(--md-default-bg-color)}.statediagram-cluster rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}.statediagram-state rect.divider{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}defs #statediagram-barbEnd{stroke:var(--md-mermaid-edge-color)}[id^=entity] path,[id^=entity] rect{fill:var(--md-default-bg-color)}.relationshipLine{stroke:var(--md-mermaid-edge-color)}defs .marker.oneOrMore.er *,defs .marker.onlyOne.er *,defs .marker.zeroOrMore.er *,defs .marker.zeroOrOne.er *{stroke:var(--md-mermaid-edge-color)!important}text:not([class]):last-child{fill:var(--md-mermaid-label-fg-color)}.actor{fill:var(--md-mermaid-sequence-actor-bg-color);stroke:var(--md-mermaid-sequence-actor-border-color)}text.actor>tspan{fill:var(--md-mermaid-sequence-actor-fg-color);font-family:var(--md-mermaid-font-family)}line{stroke:var(--md-mermaid-sequence-actor-line-color)}.actor-man circle,.actor-man line{fill:var(--md-mermaid-sequence-actorman-bg-color);stroke:var(--md-mermaid-sequence-actorman-line-color)}.messageLine0,.messageLine1{stroke:var(--md-mermaid-sequence-message-line-color)}.note{fill:var(--md-mermaid-sequence-note-bg-color);stroke:var(--md-mermaid-sequence-note-border-color)}.loopText,.loopText>tspan,.messageText,.noteText>tspan{stroke:none;font-family:var(--md-mermaid-font-family)!important}.messageText{fill:var(--md-mermaid-sequence-message-fg-color)}.loopText,.loopText>tspan{fill:var(--md-mermaid-sequence-loop-fg-color)}.noteText>tspan{fill:var(--md-mermaid-sequence-note-fg-color)}#arrowhead path{fill:var(--md-mermaid-sequence-message-line-color);stroke:none}.loopLine{fill:var(--md-mermaid-sequence-loop-bg-color);stroke:var(--md-mermaid-sequence-loop-border-color)}.labelBox{fill:var(--md-mermaid-sequence-label-bg-color);stroke:none}.labelText,.labelText>span{fill:var(--md-mermaid-sequence-label-fg-color);font-family:var(--md-mermaid-font-family)}.sequenceNumber{fill:var(--md-mermaid-sequence-number-fg-color)}rect.rect{fill:var(--md-mermaid-sequence-box-bg-color);stroke:none}rect.rect+text.text{fill:var(--md-mermaid-sequence-box-fg-color)}defs #sequencenumber{fill:var(--md-mermaid-sequence-number-bg-color)!important}";var ko,pp=0;function fp(){return typeof mermaid=="undefined"||mermaid instanceof Element?ar("https://unpkg.com/mermaid@11/dist/mermaid.min.js"):Y(void 0)}function $s(e){return e.classList.remove("mermaid"),ko||(ko=fp().pipe($(()=>mermaid.initialize({startOnLoad:!1,themeCSS:Hs,sequence:{actorFontSize:"16px",messageFontSize:"16px",noteFontSize:"16px"}})),f(()=>{}),se(1))),ko.subscribe(()=>Uo(null,null,function*(){e.classList.add("mermaid");let t=`__mermaid_${pp++}`,r=A("div",{class:"mermaid"}),n=e.textContent,{svg:o,fn:i}=yield mermaid.render(t,n),a=r.attachShadow({mode:"closed"});a.innerHTML=o,e.replaceWith(r),i==null||i(a)})),ko.pipe(f(()=>({ref:e})))}var Ps=A("table");function Is(e){return e.replaceWith(Ps),Ps.replaceWith(gs(e)),Y({ref:e})}function mp(e){let t=e.find(r=>r.checked)||e[0];return R(...e.map(r=>b(r,"change").pipe(f(()=>G(`label[for="${r.id}"]`))))).pipe(J(G(`label[for="${t.id}"]`)),f(r=>({active:r})))}function Rs(e,{viewport$:t,target$:r}){let n=G(".tabbed-labels",e),o=P(":scope > input",e),i=Oo("prev");e.append(i);let a=Oo("next");return e.append(a),j(()=>{let s=new I,c=s.pipe(he(),ye(!0));re([s,Re(e),Et(e)]).pipe(Q(c),Xe(1,je)).subscribe({next([{active:l},u]){let p=wt(l),{width:d}=Ae(l);e.style.setProperty("--md-indicator-x",`${p.x}px`),e.style.setProperty("--md-indicator-width",`${d}px`);let m=ln(n);(p.x<m.x||p.x+d>m.x+u.width)&&n.scrollTo({left:Math.max(0,p.x-16),behavior:"smooth"})},complete(){e.style.removeProperty("--md-indicator-x"),e.style.removeProperty("--md-indicator-width")}}),re([Ut(n),Re(n)]).pipe(Q(c)).subscribe(([l,u])=>{let p=Mr(n);i.hidden=l.x<16,a.hidden=l.x>p.width-u.width-16}),R(b(i,"click").pipe(f(()=>-1)),b(a,"click").pipe(f(()=>1))).pipe(Q(c)).subscribe(l=>{let{width:u}=Ae(n);n.scrollBy({left:u*l,behavior:"smooth"})}),r.pipe(Q(c),L(l=>o.includes(l))).subscribe(l=>l.click()),n.classList.add("tabbed-labels--linked");for(let l of o){let u=G(`label[for="${l.id}"]`);u.replaceChildren(A("a",{href:`#${u.htmlFor}`,tabIndex:-1},...Array.from(u.childNodes))),b(u.firstElementChild,"click").pipe(Q(c),L(p=>!(p.metaKey||p.ctrlKey)),$(p=>{p.preventDefault(),p.stopPropagation()})).subscribe(()=>{history.replaceState({},"",`#${u.htmlFor}`),u.click()})}return X("content.tabs.link")&&s.pipe(ke(1),pe(t)).subscribe(([{active:l},{offset:u}])=>{let p=l.innerText.trim();if(l.hasAttribute("data-md-switching"))l.removeAttribute("data-md-switching");else{let d=e.offsetTop-u.y;for(let h of P("[data-tabs]"))for(let v of P(":scope > input",h)){let x=G(`label[for="${v.id}"]`);if(x!==l&&x.innerText.trim()===p){x.setAttribute("data-md-switching",""),v.click();break}}window.scrollTo({top:e.offsetTop-d});let m=__md_get("__tabs")||[];__md_set("__tabs",[...new Set([p,...m])])}}),s.pipe(Q(c)).subscribe(()=>{for(let l of P("audio, video",e))l.offsetWidth&&l.autoplay?l.play().catch(()=>{}):l.pause()}),mp(o).pipe($(l=>s.next(l)),V(()=>s.complete()),f(l=>H({ref:e},l)))}).pipe(Ht(ge))}function js(e,t){let{viewport$:r,target$:n,print$:o}=t;return R(...P(".annotate:not(.highlight)",e).map(i=>Es(i,{target$:n,print$:o})),...P("pre:not(.mermaid) > code",e).map(i=>Ls(i,{target$:n,print$:o})),...P("a",e).map(i=>Cs(i,t)),...P("pre.mermaid",e).map(i=>$s(i)),...P("table:not([class])",e).map(i=>Is(i)),...P("details",e).map(i=>Ms(i,{target$:n,print$:o})),...P("[data-tabs]",e).map(i=>Rs(i,{viewport$:r,target$:n})),...P("[title]:not([data-preview])",e).filter(()=>X("content.tooltips")).map(i=>Ge(i,{viewport$:r})),...P(".footnote-ref",e).filter(()=>X("content.footnote.tooltips")).map(i=>Rr(i,{content$:new U(a=>{let s=new URL(i.href).hash.slice(1),c=Array.from(document.getElementById(s).cloneNode(!0).children),l=On(...c);return a.next(l),document.body.append(l),()=>l.remove()}),viewport$:r})))}function dp(e,{alert$:t}){return t.pipe(g(r=>R(Y(!0),Y(!1).pipe(It(2e3))).pipe(f(n=>({message:r,active:n})))))}function Fs(e,t){let r=G(".md-typeset",e);return j(()=>{let n=new I;return n.subscribe(({message:o,active:i})=>{e.classList.toggle("md-dialog--active",i),r.textContent=o}),dp(e,t).pipe($(o=>n.next(o)),V(()=>n.complete()),f(o=>H({ref:e},o)))})}function hp({viewport$:e}){if(!X("header.autohide"))return Y(!1);let t=e.pipe(f(({offset:{y:o}})=>o),Pt(2,1),f(([o,i])=>[o<i,i]),fe(0)),r=re([e,t]).pipe(L(([{offset:o},[,i]])=>Math.abs(i-o.y)>100),f(([,[o]])=>o),ie()),n=Tn("search");return re([e,n]).pipe(f(([{offset:o},i])=>o.y>400&&!i),ie(),g(o=>o?r:Y(!1)),J(!1))}function Us(e,t){return j(()=>re([Re(e),hp(t)])).pipe(f(([{height:r},n])=>({height:r,hidden:n})),ie((r,n)=>r.height===n.height&&r.hidden===n.hidden),se(1))}function Ns(e,{viewport$:t,header$:r,main$:n}){return j(()=>{let o=new I,i=o.pipe(he(),ye(!0));o.pipe(fe("active"),Ze(r)).subscribe(([{active:s},{hidden:c}])=>{e.classList.toggle("md-header--shadow",s&&!c),e.hidden=c});let a=me(P("[title]",e)).pipe(L(()=>X("content.tooltips")),oe(s=>Ge(s,{viewport$:t})));return n.subscribe(o),r.pipe(Q(i),f(s=>H({ref:e},s)),Rt(a.pipe(Q(i))))})}function vp(e,{viewport$:t,header$:r}){return Sn(e,{viewport$:t,header$:r}).pipe(f(({offset:{y:n}})=>{let{height:o}=Ae(e);return{active:o>0&&n>=o}}),fe("active"))}function Ds(e,t){return j(()=>{let r=new I;r.subscribe({next({active:o}){e.classList.toggle("md-header__title--active",o)},complete(){e.classList.remove("md-header__title--active")}});let n=Le(".md-content h1");return typeof n=="undefined"?y:vp(n,t).pipe($(o=>r.next(o)),V(()=>r.complete()),f(o=>H({ref:e},o)))})}function Ws(e,{viewport$:t,header$:r}){let n=r.pipe(f(({height:i})=>i),ie()),o=n.pipe(g(()=>Re(e).pipe(f(({height:i})=>({top:e.offsetTop,bottom:e.offsetTop+i})),fe("bottom"))));return re([n,o,t]).pipe(f(([i,{top:a,bottom:s},{offset:{y:c},size:{height:l}}])=>(l=Math.max(0,l-Math.max(0,a-c,i)-Math.max(0,l+c-s)),{offset:a-i,height:l,active:a-i<=c})),ie((i,a)=>i.offset===a.offset&&i.height===a.height&&i.active===a.active))}function bp(e){let t=__md_get("__palette")||{index:e.findIndex(n=>matchMedia(n.getAttribute("data-md-color-media")).matches)},r=Math.max(0,Math.min(t.index,e.length-1));return Y(...e).pipe(oe(n=>b(n,"change").pipe(f(()=>n))),J(e[r]),f(n=>({index:e.indexOf(n),color:{media:n.getAttribute("data-md-color-media"),scheme:n.getAttribute("data-md-color-scheme"),primary:n.getAttribute("data-md-color-primary"),accent:n.getAttribute("data-md-color-accent")}})),se(1))}function Vs(e){let t=P("input",e),r=A("meta",{name:"theme-color"});document.head.appendChild(r);let n=A("meta",{name:"color-scheme"});document.head.appendChild(n);let o=Ir("(prefers-color-scheme: light)");return j(()=>{let i=new I;return i.subscribe(a=>{if(document.body.setAttribute("data-md-color-switching",""),a.color.media==="(prefers-color-scheme)"){let s=matchMedia("(prefers-color-scheme: light)"),c=document.querySelector(s.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");a.color.scheme=c.getAttribute("data-md-color-scheme"),a.color.primary=c.getAttribute("data-md-color-primary"),a.color.accent=c.getAttribute("data-md-color-accent")}for(let[s,c]of Object.entries(a.color))document.body.setAttribute(`data-md-color-${s}`,c);for(let s=0;s<t.length;s++){let c=t[s].nextElementSibling;c instanceof HTMLElement&&(c.hidden=a.index!==s)}__md_set("__palette",a)}),b(e,"keydown").pipe(L(a=>a.key==="Enter"),pe(i,(a,s)=>s)).subscribe(({index:a})=>{a=(a+1)%t.length,t[a].click(),t[a].focus()}),i.pipe(f(()=>{let a=ht("header"),s=window.getComputedStyle(a);return n.content=s.colorScheme,s.backgroundColor.match(/\d+/g).map(c=>(+c).toString(16).padStart(2,"0")).join("")})).subscribe(a=>r.content=`#${a}`),i.pipe(Ie(ge)).subscribe(()=>{document.body.removeAttribute("data-md-color-switching")}),bp(t).pipe(Q(o.pipe(ke(1))),jt(),$(a=>i.next(a)),V(()=>i.complete()),f(a=>H({ref:e},a)))})}function zs(e,{progress$:t}){return j(()=>{let r=new I;return r.subscribe(({value:n})=>{e.style.setProperty("--md-progress-value",`${n}`)}),t.pipe($(n=>r.next({value:n})),V(()=>r.complete()),f(n=>({ref:e,value:n})))})}var qs='.v u{text-decoration:underline!important;text-decoration-style:wavy!important;text-decoration-thickness:1px!important}.p{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-backdrop)/var(--alpha-lighter));cursor:pointer;height:100%;pointer-events:auto;position:absolute;transition:opacity .25s;width:100%}.p.m{opacity:0;pointer-events:none;transition:opacity .35s}.r{align-items:center;background-color:initial;border:none;border-radius:var(--space-2);cursor:pointer;display:flex;flex-shrink:0;font-family:var(--font-family);height:36px;justify-content:center;outline:none;padding:0;position:relative;transition:background-color .25s,color .25s;width:36px;z-index:1}.r svg{stroke:rgb(var(--color-foreground));height:18px;opacity:.5;width:18px}.r:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.r:hover:before{opacity:1;transform:scale(1)}.r.c{cursor:auto}.r.c:before{display:none}.n{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background)/var(--alpha-light));border-radius:var(--space-3);box-shadow:0 0 60px #0000000d;display:flex;height:480px;overflow:hidden;pointer-events:auto;position:absolute;transition:transform .25s cubic-bezier(.16,1,.3,1),opacity .25s;width:640px}.n.l{opacity:0;pointer-events:none;transform:scale(1.1);transition:transform .25s .15s,opacity .15s}@media (max-width:680px){.n{border-radius:0;height:100%;width:100%}}.u{display:flex;flex-basis:min-content;flex-direction:column;flex-grow:1;flex-shrink:0}@keyframes d{0%{transform:scale(0)}50%{transform:scale(1.2)}to{transform:scale(1)}}.y{animation:d .25s ease-in-out;background:var(--color-highlight);border-radius:100%;color:#fff;font-size:8px;font-weight:700;height:12px;padding-top:1px;position:absolute;right:4px;top:4px;width:12px}.i{background-color:rgb(var(--color-background-subtle)/var(--alpha-lighter));flex-shrink:0;overflow:scroll;position:relative;transition:width .35s cubic-bezier(.16,1,.3,1),opacity .25s;width:200px}.i>*{transform:translate(0);transition:transform .25s cubic-bezier(.16,1,.3,1)}.i.l{opacity:0;width:0}.i.l>*{transform:translate(-48px)}@media (max-width:680px){.i{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background-subtle)/var(--alpha-light));box-shadow:0 0 60px #00000026;height:100%;position:absolute;right:0;top:0}}.w{border-bottom:1px solid rgb(var(--color-foreground)/var(--alpha-lightest));display:flex;gap:var(--space-1);padding:var(--space-2)}.k{-webkit-overflow-scrolling:touch;overflow:auto;overscroll-behavior:contain}.z{padding:8px 10px}.X{color:rgb(var(--color-foreground)/var(--alpha-light));padding:var(--space-2);position:absolute;width:200px}.X,.j{display:flex;flex-direction:column}.j{gap:2px;list-style:none;padding:0}.F,.j{margin:0}.F{font-size:16px;font-weight:400}.F,.I{padding:8px}.I{font-size:14px;margin:4px 0 0;opacity:.5}.I,.o{font-size:12px}.o{cursor:pointer;display:flex;padding:4px 8px;position:relative}.o:before{background-color:var(--color-highlight-transparent);border-radius:var(--space-1);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.o.g:before,.o:hover:before{opacity:1;transform:scale(1)}.o.g,.o:hover{color:var(--color-highlight)}.R{flex-grow:1}.R,.q{position:relative}.q{font-weight:700}.f{flex-grow:1}.f input{background:#0000;border:none;color:rgb(var(--color-foreground));font-family:var(--font-family);font-size:16px;height:100%;letter-spacing:-.25px;outline:none;width:100%}.b{color:rgb(var(--color-foreground)/var(--alpha-light));display:flex;flex-direction:column;gap:2px;line-height:1.3;list-style:none;margin:var(--space-2);margin-top:0;padding:0}.A,.b li{margin:0}.A{color:rgb(var(--color-foreground)/var(--alpha-lighter));font-size:12px;margin-top:var(--space-2);padding:0 18px}.a{border-radius:var(--space-2);color:inherit;cursor:pointer;display:flex;flex-direction:row;flex-grow:1;padding:8px 10px;position:relative;text-decoration:none}.a:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";display:block;inset:0;opacity:0;position:absolute;transform:scale(.9);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.a.h:before,.a:hover:before{opacity:1;transform:scale(1)}}.a mark{background:#0000;color:var(--color-highlight)}.a u{background-color:var(--color-highlight-transparent);border-radius:2px;box-shadow:0 0 0 1px var(--color-highlight-transparent);text-decoration:none}.B{flex-grow:1}.s{margin-right:-8px;opacity:0;position:relative;transform:translate(-2px);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.h>.s,:hover>.s{opacity:1;transform:none}}.x{font-size:14px;margin:0;position:relative}.x code{background:rgb(var(--color-background-subtle));border-radius:var(--space-1);font-size:13px;padding:2px 4px}.t{color:rgb(var(--color-foreground)/var(--alpha-lighter));display:inline-flex;flex-wrap:wrap;font-size:12px;gap:var(--space-1);list-style:none;margin:0;padding:0;position:relative}.t li{white-space:nowrap}.t li:after{content:"/";display:inline;margin-left:var(--space-1)}.t li:last-child:after{content:"";display:none}.e{--space-1:4px;--space-2:calc(var(--space-1)*2);--space-3:calc(var(--space-2)*2);--space-4:calc(var(--space-3)*2);--space-5:calc(var(--space-4)*2);--alpha-light:.7;--alpha-lighter:.54;--alpha-lightest:.1;--color-highlight:var(--md-accent-fg-color,#526cfe);--color-highlight-transparent:var(--md-accent-fg-color--transparent,#526cfe1a);--border-radius-1:var(--space-1);--border-radius-2:var(--space-2);--border-radius-3:calc(var(--space-1) + var(--space-2));--font-family:var(--md-text-font-family,Inter,Roboto Flex,system-ui,sans-serif);--font-size:16px;--line-height:1.5;--letter-spacing:-.5px;-webkit-font-smoothing:antialiased;align-items:center;display:flex;font-family:var(--font-family);font-size:var(--font-size);height:100vh;justify-content:center;letter-spacing:var(--letter-spacing);line-height:var(--line-height);pointer-events:none;position:absolute;width:100vw}@media (pointer:coarse){.e{height:-webkit-fill-available}}.e *,.e :after,.e :before{box-sizing:border-box}';function Ks(e,{index$:t}){let r=Ue(),n=document.createElement("div");document.body.appendChild(n),n.style.position="fixed",n.style.height="100%",n.style.top="0",n.style.zIndex="4";let o=n.attachShadow({mode:"open"});o.appendChild(A("style",{},qs.toString()));try{Ya(r.search,{highlight:r.features.includes("search.highlight")}),me(t).subscribe(i=>{for(let a of i.items)a.location=new URL(a.location,r.base).toString();Ja(i,o)}),b(e,"click").subscribe(()=>{go()}),Tn("search").pipe(ke(1)).subscribe(()=>go())}catch(i){e.hidden=!0;let a=G("label[for=__search]");a.hidden=!0}return Ke}var Bs=_r(So());function Ys(e,{index$:t,location$:r}){return re([t,r.pipe(J(Ye()),L(n=>!!n.searchParams.get("h")))]).pipe(f(([n,o])=>_p(n.config)(o.searchParams.get("h"))),f(n=>{var a;let o=new Map,i=document.createNodeIterator(e,NodeFilter.SHOW_TEXT);for(let s=i.nextNode();s;s=i.nextNode())if((a=s.parentElement)!=null&&a.offsetHeight){let c=s.textContent,l=n(c);l.length>c.length&&o.set(s,l)}for(let[s,c]of o){let{childNodes:l}=A("span",null,c);s.replaceWith(...Array.from(l))}return{ref:e,nodes:o}}))}function _p(e){let t=e.separator.split("|").map(o=>o.replace(/(\(\?[!=<][^)]+\))/g,"").length===0?"\uFFFD":o).join("|"),r=new RegExp(t,"img"),n=(o,i,a)=>`${i}<mark data-md-highlight>${a}</mark>`;return o=>{o=o.replace(/\s+/g," ").replace(/&/g,"&amp;").trim();let i=new RegExp(`(^|${e.separator}|)(${o.split(r).map(a=>a.replace(/[|\\{}()[\]^$+*?.-]/g,"\\$&")).filter(a=>a.length>0).join("|")})`,"img");return a=>(0,Bs.default)(a).replace(i,n).replace(/<\/mark>(\s+)<mark[^>]*>/img,"$1")}}function yp(e,{viewport$:t,main$:r}){let n=e.closest(".md-grid"),o=n.offsetTop-n.parentElement.offsetTop;return re([r,t]).pipe(f(([{offset:i,height:a},{offset:{y:s}}])=>(a=a+Math.min(o,Math.max(0,s-i))-o,{height:a,locked:s>=i+o})),ie((i,a)=>i.height===a.height&&i.locked===a.locked))}function Ao(e,n){var o=n,{header$:t}=o,r=gr(o,["header$"]);let i=G(".md-sidebar__scrollwrap",e),{y:a}=wt(i);return j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=s.pipe(Xe(0,je));return l.pipe(pe(t)).subscribe({next([{height:u},{height:p}]){i.style.height=`${u-2*a}px`,e.style.top=`${p}px`},complete(){i.style.height="",e.style.top=""}}),l.pipe(Sr()).subscribe(()=>{for(let u of P(".md-nav__link--active[href]",e)){if(!u.clientHeight)continue;let p=u.closest(".md-sidebar__scrollwrap");if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2})}}}),me(P("label[tabindex]",e)).pipe(oe(u=>b(u,"click").pipe(Ie(ge),f(()=>u),Q(c)))).subscribe(u=>{let p=G(`[id="${u.htmlFor}"]`);G(`[aria-labelledby="${u.id}"]`).setAttribute("aria-expanded",`${p.checked}`)}),X("content.tooltips")&&me(P("abbr[title]",e)).pipe(oe(u=>Ge(u,{viewport$})),Q(c)).subscribe(),yp(e,r).pipe($(u=>s.next(u)),V(()=>s.complete()),f(u=>H({ref:e},u)))})}function Gs(e,t){if(typeof t!="undefined"){let r=`https://api.github.com/repos/${e}/${t}`;return $t(et(`${r}/releases/latest`).pipe(_e(()=>y),f(n=>({version:n.tag_name})),ot({})),et(r).pipe(_e(()=>y),f(n=>({stars:n.stargazers_count,forks:n.forks_count})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}else{let r=`https://api.github.com/users/${e}`;return et(r).pipe(f(n=>({repositories:n.public_repos})),ot({}))}}function Js(e,t){let r=`https://${e}/api/v4/projects/${encodeURIComponent(t)}`;return $t(et(`${r}/releases/permalink/latest`).pipe(_e(()=>y),f(({tag_name:n})=>({version:n})),ot({})),et(r).pipe(_e(()=>y),f(({star_count:n,forks_count:o})=>({stars:n,forks:o})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}function Xs(e){let t=e.match(/^.+github\.com\/([^/]+)\/?([^/]+)?/i);if(t){let[,r,n]=t;return Gs(r,n)}if(t=e.match(/^.+?([^/]*gitlab[^/]+)\/(.+?)\/?$/i),t){let[,r,n]=t;return Js(r,n)}return y}var xp;function wp(e){return xp||(xp=j(()=>{let t=__md_get("__source",sessionStorage);if(t)return Y(t);if(Ee("consent").length){let n=__md_get("__consent");if(!(n&&n.github))return y}return Xs(e.href).pipe($(n=>__md_set("__source",n,sessionStorage)))}).pipe(_e(()=>y),L(t=>Object.keys(t).length>0),f(t=>({facts:t})),se(1)))}function Zs(e){let t=G(":scope > :last-child",e);return j(()=>{let r=new I;return r.subscribe(({facts:n})=>{t.appendChild(bs(n)),t.classList.add("md-source__repository--active")}),wp(e).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Ep(e,{viewport$:t,header$:r}){return Re(document.body).pipe(g(()=>Sn(e,{header$:r,viewport$:t})),f(({offset:{y:n}})=>({hidden:n>=10})),fe("hidden"))}function Qs(e,t){return j(()=>{let r=new I;return r.subscribe({next({hidden:n}){e.hidden=n},complete(){e.hidden=!1}}),(X("navigation.tabs.sticky")?Y({hidden:!1}):Ep(e,t)).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Tp(e,{viewport$:t,header$:r}){let n=new Map,o=P(".md-nav__link",e);for(let s of o){let c=decodeURIComponent(s.hash.substring(1)),l=Le(`[id="${c}"]`);typeof l!="undefined"&&n.set(s,l)}let i=r.pipe(fe("height"),f(({height:s})=>{let c=ht("main"),l=G(":scope > :first-child",c);return s+.9*(l.offsetTop-c.offsetTop)}),xe());return Re(document.body).pipe(fe("height"),g(s=>j(()=>{let c=[];return Y([...n].reduce((l,[u,p])=>{for(;c.length&&n.get(c[c.length-1]).tagName>=p.tagName;)c.pop();let d=p.offsetTop;for(;!d&&p.parentElement;)p=p.parentElement,d=p.offsetTop;let m=p.offsetParent;for(;m;m=m.offsetParent)d+=m.offsetTop;return l.set([...c=[...c,u]].reverse(),d)},new Map))}).pipe(f(c=>new Map([...c].sort(([,l],[,u])=>l-u))),Ze(i),g(([c,l])=>t.pipe(Or(([u,p],{offset:{y:d},size:m})=>{let h=d+m.height>=Math.floor(s.height);for(;p.length;){let[,v]=p[0];if(v-l<d||h)u=[...u,p.shift()];else break}for(;u.length;){let[,v]=u[u.length-1];if(v-l>=d&&!h)p=[u.pop(),...p];else break}return[u,p]},[[],[...c]]),ie((u,p)=>u[0]===p[0]&&u[1]===p[1])))))).pipe(f(([s,c])=>({prev:s.map(([l])=>l),next:c.map(([l])=>l)})),J({prev:[],next:[]}),Pt(2,1),f(([s,c])=>s.prev.length<c.prev.length?{prev:c.prev.slice(Math.max(0,s.prev.length-1),c.prev.length),next:[]}:{prev:c.prev.slice(-1),next:c.next.slice(0,c.next.length-s.next.length)}))}function ec(e,{viewport$:t,header$:r,main$:n,target$:o}){return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));if(i.subscribe(({prev:s,next:c})=>{for(let[l]of c)l.classList.remove("md-nav__link--passed"),l.classList.remove("md-nav__link--active");for(let[l,[u]]of s.entries())u.classList.add("md-nav__link--passed"),u.classList.toggle("md-nav__link--active",l===s.length-1)}),X("toc.follow")){let s=R(t.pipe(Be(1),f(()=>{})),t.pipe(Be(250),f(()=>"smooth")));i.pipe(L(({prev:c})=>c.length>0),Ze(n.pipe(Ie(ge))),pe(s)).subscribe(([[{prev:c}],l])=>{let[u]=c[c.length-1];if(u.offsetHeight){let p=ki(u);if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2,behavior:l})}}})}return X("navigation.tracking")&&t.pipe(Q(a),fe("offset"),Be(250),ke(1),Q(o.pipe(ke(1))),jt({delay:250}),pe(i)).subscribe(([,{prev:s}])=>{let c=Ye(),l=s[s.length-1];if(l&&l.length){let[u]=l,{hash:p}=new URL(u.href);c.hash!==p&&(c.hash=p,history.replaceState({},"",`${c}`))}else c.hash="",history.replaceState({},"",`${c}`)}),Tp(e,{viewport$:t,header$:r}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function Sp(e,{viewport$:t,main$:r,target$:n}){let o=t.pipe(f(({offset:{y:a}})=>a),Pt(2,1),f(([a,s])=>a>s&&s>0),ie()),i=r.pipe(f(({active:a})=>a));return re([i,o]).pipe(f(([a,s])=>!(a&&s)),ie(),Q(n.pipe(ke(1))),ye(!0),jt({delay:250}),f(a=>({hidden:a})))}function tc(e,{viewport$:t,header$:r,main$:n,target$:o}){let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({hidden:s}){e.hidden=s,s?(e.setAttribute("tabindex","-1"),e.blur()):e.removeAttribute("tabindex")},complete(){e.style.top="",e.hidden=!0,e.removeAttribute("tabindex")}}),r.pipe(Q(a),fe("height")).subscribe(({height:s})=>{e.style.top=`${s+16}px`}),b(e,"click").subscribe(s=>{s.preventDefault(),window.scrollTo({top:0})}),Sp(e,{viewport$:t,main$:n,target$:o}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))}function rc(e,t){return e.protocol=t.protocol,e.hostname=t.hostname,t.port&&(e.port=t.port),e}function Op(e,t){let r=new Map;for(let n of P("url",e)){let o=G("loc",n),i=[rc(new URL(o.textContent),t)];r.set(`${i[0]}`,i);for(let a of P("[rel=alternate]",n)){let s=a.getAttribute("href");s!=null&&i.push(rc(new URL(s),t))}}return r}function dr(e){return ns(new URL("sitemap.xml",e)).pipe(f(t=>Op(t,new URL(e))),_e(()=>Y(new Map)),xe())}function nc({document$:e}){let t=new Map;e.pipe(g(()=>P("link[rel=alternate]")),f(r=>new URL(r.href)),L(r=>!t.has(r.toString())),oe(r=>dr(r).pipe(f(n=>[r,n]),_e(()=>y)))).subscribe(([r,n])=>{t.set(r.toString().replace(/\/$/,""),n)}),b(document.body,"click").pipe(L(r=>!r.metaKey&&!r.ctrlKey),g(r=>{if(r.target instanceof Element){let n=r.target.closest("a");if(n&&!n.target){let o=[...t].find(([p])=>n.href.startsWith(`${p}/`));if(typeof o=="undefined")return y;let[i,a]=o,s=Ye();if(s.href.startsWith(i))return y;let c=Ue(),l=s.href.replace(c.base,"");l=`${i}/${l}`;let u=a.has(l.split("#")[0])?new URL(l,c.base):new URL(i);return r.preventDefault(),Y(u)}}return y})).subscribe(r=>dt(r,!0))}var Co=_r(Mo());function Lp(e){e.setAttribute("data-md-copying","");let t=e.closest("[data-copy]"),r=t?t.getAttribute("data-copy"):e.innerText;return e.removeAttribute("data-md-copying"),r.trimEnd()}function oc({alert$:e}){Co.default.isSupported()&&new U(t=>{new Co.default("[data-clipboard-target], [data-clipboard-text]",{text:r=>r.getAttribute("data-clipboard-text")||Lp(G(r.getAttribute("data-clipboard-target")))}).on("success",r=>t.next(r))}).pipe($(t=>{t.trigger.focus()}),f(()=>Bt("clipboard.copied"))).subscribe(e)}function ic(e,t){if(!(e.target instanceof Element))return y;let r=e.target.closest("a");if(r===null)return y;if(r.target||e.metaKey||e.ctrlKey)return y;let n=new URL(r.href);return n.search=n.hash="",t.has(`${n}`)?(e.preventDefault(),Y(r)):y}function ac(e){let t=new Map;for(let r of P(":scope > *",e.head))t.set(r.outerHTML,r);return t}function sc(e){for(let t of P("[href], [src]",e))for(let r of["href","src"]){let n=t.getAttribute(r);if(n&&!/^(?:[a-z]+:)?\/\//i.test(n)){t[r]=t[r];break}}return Y(e)}function Mp(e){for(let n of["[data-md-component=announce]","[data-md-component=container]","[data-md-component=header-topic]","[data-md-component=outdated]","[data-md-component=logo]","[data-md-component=skip]",...X("navigation.tabs.sticky")?["[data-md-component=tabs]"]:[]]){let o=Le(n),i=Le(n,e);typeof o!="undefined"&&typeof i!="undefined"&&o.replaceWith(i)}let t=ac(document);for(let[n,o]of ac(e))t.has(n)?t.delete(n):document.head.appendChild(o);for(let n of t.values()){let o=n.getAttribute("name");o!=="theme-color"&&o!=="color-scheme"&&n.remove()}let r=ht("container");return nt(P("script",r)).pipe(g(n=>{let o=e.createElement("script");if(n.src){for(let i of n.getAttributeNames())o.setAttribute(i,n.getAttribute(i));return n.replaceWith(o),new U(i=>{o.onload=()=>i.complete()})}else return o.textContent=n.textContent,n.replaceWith(o),y}),he(),ye(document))}function cc({sitemap$:e,location$:t,viewport$:r,progress$:n}){if(location.protocol==="file:")return Ke;Y(document).subscribe(sc);let o=b(document.body,"click").pipe(Ze(e),g(([s,c])=>ic(s,c)),f(({href:s})=>new URL(s)),xe()),i=b(window,"popstate").pipe(f(Ye),xe());o.pipe(pe(r)).subscribe(([s,{offset:c}])=>{history.replaceState(c,""),history.pushState(null,"",s)}),R(o,i).subscribe(t);let a=t.pipe(fe("pathname"),g(s=>En(s,{progress$:n}).pipe(_e(()=>(dt(s,!0),y)))),g(sc),g(Mp),xe());return R(a.pipe(pe(t,(s,c)=>c)),a.pipe(g(()=>t),fe("hash")),t.pipe(ie((s,c)=>s.pathname===c.pathname&&s.hash===c.hash),g(()=>o),$(()=>history.back()))).subscribe(s=>{var c,l;history.state!==null||!s.hash?window.scrollTo(0,(l=(c=history.state)==null?void 0:c.y)!=null?l:0):(history.scrollRestoration="auto",es(s.hash),history.scrollRestoration="manual")}),t.subscribe(()=>{history.scrollRestoration="manual"}),b(window,"beforeunload").subscribe(()=>{history.scrollRestoration="auto"}),r.pipe(fe("offset"),Be(100)).subscribe(({offset:s})=>{history.replaceState(s,"")}),X("navigation.instant.prefetch")&&R(b(document.body,"mousemove"),b(document.body,"focusin")).pipe(Ze(e),g(([s,c])=>ic(s,c)),Be(25),Yn(({href:s})=>s),cn(s=>{let c=document.createElement("link");return c.rel="prefetch",c.href=s.toString(),document.head.appendChild(c),b(c,"load").pipe(f(()=>c),Me(1))})).subscribe(s=>s.remove()),a}function lc(e){var u;let{selectedVersionSitemap:t,selectedVersionBaseURL:r,currentLocation:n,currentBaseURL:o}=e,i=(u=Ho(o))==null?void 0:u.pathname;if(i===void 0)return;let a=kp(n.pathname,i);if(a===void 0)return;let s=Cp(t.keys());if(!t.has(s))return;let c=Ho(a,s);if(!c||!t.has(c.href))return;let l=Ho(a,r);if(l)return l.hash=n.hash,l.search=n.search,l}function Ho(e,t){try{return new URL(e,t)}catch(r){return}}function kp(e,t){if(e.startsWith(t))return e.slice(t.length)}function Ap(e,t){let r=Math.min(e.length,t.length),n;for(n=0;n<r&&e[n]===t[n];++n);return n}function Cp(e){let t;for(let r of e)t===void 0?t=r:t=t.slice(0,Ap(t,r));return t!=null?t:""}function uc({document$:e}){let t=Ue(),r=et(new URL("../versions.json",t.base)).pipe(_e(()=>y)),n=r.pipe(f(o=>{let[,i]=t.base.match(/([^/]+)\/?$/);return o.find(({version:a,aliases:s})=>a===i||s.includes(i))||o[0]}));r.pipe(f(o=>new Map(o.map(i=>[`${new URL(`../${i.version}/`,t.base)}`,i]))),g(o=>b(document.body,"click").pipe(L(i=>!i.metaKey&&!i.ctrlKey),pe(n),g(([i,a])=>{if(i.target instanceof Element){let s=i.target.closest("a");if(s&&!s.target&&o.has(s.href)){let c=s.href;return!i.target.closest(".md-version")&&o.get(c)===a?y:(i.preventDefault(),Y(new URL(c)))}}return y}),g(i=>dr(i).pipe(f(a=>{var s;return(s=lc({selectedVersionSitemap:a,selectedVersionBaseURL:i,currentLocation:Ye(),currentBaseURL:t.base}))!=null?s:i})))))).subscribe(o=>dt(o,!0)),re([r,n]).subscribe(([o,i])=>{G(".md-header__topic").appendChild(_s(o,i))}),e.pipe(g(()=>n)).subscribe(o=>{var s;let i=new URL(t.base),a=__md_get("__outdated",sessionStorage,i);if(a===null){a=!0;let c=((s=t.version)==null?void 0:s.default)||"latest";Array.isArray(c)||(c=[c]);e:for(let l of c)for(let u of o.aliases.concat(o.version))if(new RegExp(l,"i").test(u)){a=!1;break e}__md_set("__outdated",a,sessionStorage,i)}if(a)for(let c of Ee("outdated"))c.hidden=!1})}function pc({document$:e,viewport$:t}){e.pipe(g(()=>P(".md-ellipsis")),oe(r=>Et(r).pipe(Q(e.pipe(ke(1))),L(n=>n),f(()=>r),Me(1))),L(r=>r.offsetWidth<r.scrollWidth),oe(r=>{let n=r.innerText,o=r.closest("a")||r;return o.title=n,X("content.tooltips")?Ge(o,{viewport$:t}).pipe(Q(e.pipe(ke(1))),V(()=>o.removeAttribute("title"))):y})).subscribe(),X("content.tooltips")&&e.pipe(g(()=>P(".md-status")),oe(r=>Ge(r,{viewport$:t}))).subscribe()}function fc({document$:e,tablet$:t}){e.pipe(g(()=>P(".md-toggle--indeterminate")),$(r=>{r.indeterminate=!0,r.checked=!1}),oe(r=>b(r,"change").pipe(Xn(()=>r.classList.contains("md-toggle--indeterminate")),f(()=>r))),pe(t)).subscribe(([r,n])=>{r.classList.remove("md-toggle--indeterminate"),n&&(r.checked=!1)})}function Hp(){return/(iPad|iPhone|iPod)/.test(navigator.userAgent)}function mc({document$:e}){e.pipe(g(()=>P("[data-md-scrollfix]")),$(t=>t.removeAttribute("data-md-scrollfix")),L(Hp),oe(t=>b(t,"touchstart").pipe(f(()=>t)))).subscribe(t=>{let r=t.scrollTop;r===0?t.scrollTop=1:r+t.offsetHeight===t.scrollHeight&&(t.scrollTop=r-1)})}Object.entries||(Object.entries=function(e){let t=[];for(let r of Object.keys(e))t.push([r,e[r]]);return t});Object.values||(Object.values=function(e){let t=[];for(let r of Object.keys(e))t.push(e[r]);return t});typeof Element!="undefined"&&(Element.prototype.scrollTo||(Element.prototype.scrollTo=function(e,t){typeof e=="object"?(this.scrollLeft=e.left,this.scrollTop=e.top):(this.scrollLeft=e,this.scrollTop=t)}),Element.prototype.replaceWith||(Element.prototype.replaceWith=function(...e){let t=this.parentNode;if(t){e.length===0&&t.removeChild(this);for(let r=e.length-1;r>=0;r--){let n=e[r];typeof n=="string"?n=document.createTextNode(n):n.parentNode&&n.parentNode.removeChild(n),r?t.insertBefore(this.previousSibling,n):t.replaceChild(n,this)}}}));function $p(){return location.protocol==="file:"?ar(`${new URL("search.js",Mn.base)}`).pipe(f(()=>__index),_e(()=>Ke),se(1)):et(new URL("search.json",Mn.base))}document.documentElement.classList.remove("no-js");document.documentElement.classList.add("js");var vt=Si(),Ur=Za(),hr=ts(Ur),hc=Xa(),ze=cs(),$o=Ir("(min-width: 60em)"),vc=Ir("(min-width: 76.25em)"),bc=rs(),Mn=Ue(),gc=Le(".md-search")?$p():Ke,Po=new I;oc({alert$:Po});nc({document$:vt});var Io=new I,_c=dr(Mn.base);X("navigation.instant")&&cc({sitemap$:_c,location$:Ur,viewport$:ze,progress$:Io}).subscribe(vt);var dc;((dc=Mn.version)==null?void 0:dc.provider)==="mike"&&uc({document$:vt});R(Ur,hr).pipe(It(125)).subscribe(()=>{Eo("drawer",!1),Eo("search",!1)});hc.pipe(L(({mode:e,meta:t})=>e==="global"&&!t)).subscribe(e=>{switch(e.type){case",":case"p":let t=document.querySelector("link[rel=prev]");t instanceof HTMLLinkElement&&dt(t);break;case".":case"n":let r=document.querySelector("link[rel=next]");r instanceof HTMLLinkElement&&dt(r);break;case"/":let n=document.querySelector("[data-md-component=search] button");n instanceof HTMLButtonElement&&n.click();break;case"Enter":let o=xt();o instanceof HTMLLabelElement&&o.click()}});pc({viewport$:ze,document$:vt});fc({document$:vt,tablet$:$o});mc({document$:vt});var Lt=Us(ht("header"),{viewport$:ze}),Fr=vt.pipe(f(()=>ht("main")),g(e=>Ws(e,{viewport$:ze,header$:Lt})),se(1)),Pp=R(...Ee("consent").map(e=>us(e,{target$:hr})),...Ee("dialog").map(e=>Fs(e,{alert$:Po})),...Ee("palette").map(e=>Vs(e)),...Ee("progress").map(e=>zs(e,{progress$:Io})),...Ee("search").map(e=>Ks(e,{index$:gc})),...Ee("source").map(e=>Zs(e))),Ip=j(()=>R(...Ee("announce").map(e=>ls(e)),...Ee("content").map(e=>js(e,{sitemap$:_c,viewport$:ze,target$:hr,print$:bc})),...Ee("content").map(e=>X("search.highlight")?Ys(e,{index$:gc,location$:Ur}):y),...Ee("header").map(e=>Ns(e,{viewport$:ze,header$:Lt,main$:Fr})),...Ee("header-title").map(e=>Ds(e,{viewport$:ze,header$:Lt})),...Ee("sidebar").map(e=>e.getAttribute("data-md-type")==="navigation"?yo(vc,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr})):yo($o,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr}))),...Ee("tabs").map(e=>Qs(e,{viewport$:ze,header$:Lt})),...Ee("toc").map(e=>ec(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})),...Ee("top").map(e=>tc(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})))),yc=vt.pipe(g(()=>Ip),Rt(Pp),se(1));yc.subscribe();window.document$=vt;window.location$=Ur;window.target$=hr;window.keyboard$=hc;window.viewport$=ze;window.tablet$=$o;window.screen$=vc;window.print$=bc;window.alert$=Po;window.progress$=Io;window.component$=yc;})();
-/*! update cache: 20260331044513 */
+/*! update cache: 20260331053206 */
diff --git a/en/chapter_stack_and_queue/queue/index.html b/en/chapter_stack_and_queue/queue/index.html
index 104248652..52648b100 100644
--- a/en/chapter_stack_and_queue/queue/index.html
+++ b/en/chapter_stack_and_queue/queue/index.html
@@ -6441,7 +6441,7 @@
 <a id="__codelineno-36-2" name="__codelineno-36-2" href="#__codelineno-36-2"></a><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-36-3" name="__codelineno-36-3" href="#__codelineno-36-3"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">nums</span><span class="p">;</span><span class="w">       </span><span class="c1">// Array for storing queue elements</span>
 <a id="__codelineno-36-4" name="__codelineno-36-4" href="#__codelineno-36-4"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">front</span><span class="p">;</span><span class="w">       </span><span class="c1">// Front pointer, points to the front of the queue element</span>
-<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// Rear pointer, points to rear + 1</span>
+<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// Current number of elements in the queue</span>
 <a id="__codelineno-36-6" name="__codelineno-36-6" href="#__codelineno-36-6"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queCapacity</span><span class="p">;</span><span class="w"> </span><span class="c1">// Queue capacity</span>
 <a id="__codelineno-36-7" name="__codelineno-36-7" href="#__codelineno-36-7"></a><span class="p">}</span><span class="w"> </span><span class="n">ArrayQueue</span><span class="p">;</span>
 <a id="__codelineno-36-8" name="__codelineno-36-8" href="#__codelineno-36-8"></a>
diff --git a/en/javascripts/katex.js b/en/javascripts/katex.js
index eff15a0d4..3a9f13b68 100644
--- a/en/javascripts/katex.js
+++ b/en/javascripts/katex.js
@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260331044513 */
+/*! update cache: 20260331053206 */
diff --git a/en/javascripts/mathjax.js b/en/javascripts/mathjax.js
index 312339a55..1b73758e5 100644
--- a/en/javascripts/mathjax.js
+++ b/en/javascripts/mathjax.js
@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260331044513 */
+/*! update cache: 20260331053206 */
diff --git a/en/javascripts/starfield.js b/en/javascripts/starfield.js
index 3df115a59..b2ae3c56e 100644
--- a/en/javascripts/starfield.js
+++ b/en/javascripts/starfield.js
@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260331044513 */
+/*! update cache: 20260331053206 */
diff --git a/en/search.json b/en/search.json
index 45aca1f8b..1ec805970 100644
--- a/en/search.json
+++ b/en/search.json
@@ -1 +1 @@
-{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"Chapter 16.   Appendix","text":"","path":["Chapter 16. Appendix","Chapter 16. &nbsp; Appendix"],"tags":[]},{"location":"chapter_appendix/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>16.1   Programming Environment Installation</li> <li>16.2   Contributing Together</li> <li>16.3   Terminology Table</li> </ul>","path":["Chapter 16. Appendix","Chapter 16. &nbsp; Appendix"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   Contributing Together","text":"<p>Due to limited capacity, there may be inevitable omissions and errors in this book. We appreciate your understanding and are grateful for your help in correcting them. If you discover typos, broken links, missing content, ambiguous wording, unclear explanations, or structural issues, please help us make corrections to provide readers with higher-quality learning resources.</p> <p>The GitHub IDs of all contributors will be displayed on the homepage of the book repository, the web version, and the PDF version to acknowledge their selfless contributions to the open source community.</p> <p>The Charm of Open Source</p> <p>The interval between two printings of a physical book is often quite long, making content updates very inconvenient.</p> <p>In this open source book, the time for content updates has been shortened to just days or even hours.</p>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#1-minor-content-adjustments","level":3,"title":"1.   Minor Content Adjustments","text":"<p>As shown in Figure 16-3, there is an \"edit icon\" in the top-right corner of each page. You can modify text or code by following these steps.</p> <ol> <li>Click the \"edit icon\". If you encounter a prompt asking you to \"Fork this repository\", please approve the operation.</li> <li>Modify the content of the Markdown source file, verify the correctness of the content, and maintain consistent formatting as much as possible.</li> <li>Fill in a description of your changes at the bottom of the page, then click the \"Propose file change\" button. After the page transitions, click the \"Create pull request\" button to submit your pull request.</li> </ol> <p></p> <p> Figure 16-3   Page edit button </p> <p>Images cannot be directly modified. Please describe the issue by creating a new Issue or leaving a comment. We will promptly redraw and replace the images.</p>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#2-content-creation","level":3,"title":"2.   Content Creation","text":"<p>If you are interested in contributing to this open source project, including translating code into other programming languages or expanding article content, you will need to follow the Pull Request workflow below.</p> <ol> <li>Log in to GitHub and Fork the book's code repository to your personal account.</li> <li>Enter your forked repository webpage and use the <code>git clone</code> command to clone the repository to your local machine.</li> <li>Create content locally and conduct comprehensive tests to verify code correctness.</li> <li>Commit your local changes and push them to the remote repository.</li> <li>Refresh the repository webpage and click the \"Create pull request\" button to submit your pull request.</li> </ol>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker-deployment","level":3,"title":"3.   Docker Deployment","text":"<p>From the root directory of <code>hello-algo</code>, run the following Docker script to access the project at <code>http://localhost:8000</code>:</p> <pre><code>docker-compose up -d\n</code></pre> <p>Use the following command to remove the deployment:</p> <pre><code>docker-compose down\n</code></pre>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   Programming Environment Installation","text":"","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1611-installing-ide","level":2,"title":"16.1.1   Installing Ide","text":"<p>We recommend using the open-source and lightweight VS Code as the local integrated development environment (IDE). Visit the VS Code official website, and download and install the appropriate version of VS Code according to your operating system.</p> <p></p> <p> Figure 16-1   Download VS Code from the Official Website </p> <p>VS Code has a powerful ecosystem of extensions that supports running and debugging most programming languages. For example, after installing the \"Python Extension Pack\" extension, you can debug Python code. The installation steps are shown in the following figure.</p> <p></p> <p> Figure 16-2   Install VS Code Extensions </p>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1612-installing-language-environments","level":2,"title":"16.1.2   Installing Language Environments","text":"","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1-python-environment","level":3,"title":"1.   Python Environment","text":"<ol> <li>Download and install Miniconda3, which requires Python 3.10 or newer.</li> <li>Search for <code>python</code> in the VS Code extension marketplace and install the Python Extension Pack.</li> <li>(Optional) Enter <code>pip install black</code> on the command line to install the code formatter.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc-environment","level":3,"title":"2.   C/c++ Environment","text":"<ol> <li>Windows systems need to install MinGW (configuration tutorial); macOS comes with Clang built-in and does not require installation.</li> <li>Search for <code>c++</code> in the VS Code extension marketplace and install the C/C++ Extension Pack.</li> <li>(Optional) Open the Settings page, search for the <code>Clang_format_fallback Style</code> code formatting option, and set it to <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code>.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#3-java-environment","level":3,"title":"3.   Java Environment","text":"<ol> <li>Download and install OpenJDK (version must be &gt; JDK 9).</li> <li>Search for <code>java</code> in the VS Code extension marketplace and install the Extension Pack for Java.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#4-c-environment","level":3,"title":"4.   C# Environment","text":"<ol> <li>Download and install .Net 8.0.</li> <li>Search for <code>C# Dev Kit</code> in the VS Code extension marketplace and install C# Dev Kit (configuration tutorial).</li> <li>You can also use Visual Studio (installation tutorial).</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#5-go-environment","level":3,"title":"5.   Go Environment","text":"<ol> <li>Download and install Go.</li> <li>Search for <code>go</code> in the VS Code extension marketplace and install Go.</li> <li>Press <code>Ctrl + Shift + P</code> to open the command palette, type <code>go</code>, select <code>Go: Install/Update Tools</code>, check all options and install.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift-environment","level":3,"title":"6.   Swift Environment","text":"<ol> <li>Download and install Swift.</li> <li>Search for <code>swift</code> in the VS Code extension marketplace and install Swift for Visual Studio Code.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript-environment","level":3,"title":"7.   Javascript Environment","text":"<ol> <li>Download and install Node.js.</li> <li>(Optional) Search for <code>Prettier</code> in the VS Code extension marketplace and install the code formatter.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript-environment","level":3,"title":"8.   Typescript Environment","text":"<ol> <li>Follow the same installation steps as the JavaScript environment.</li> <li>Install TypeScript Execute (tsx).</li> <li>Search for <code>typescript</code> in the VS Code extension marketplace and install Pretty TypeScript Errors.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart-environment","level":3,"title":"9.   Dart Environment","text":"<ol> <li>Download and install Dart.</li> <li>Search for <code>dart</code> in the VS Code extension marketplace and install Dart.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust-environment","level":3,"title":"10.   Rust Environment","text":"<ol> <li>Download and install Rust.</li> <li>Search for <code>rust</code> in the VS Code extension marketplace and install rust-analyzer.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   Terminology Table","text":"<p>The following table lists important terms that appear in this book. It is worth noting the following points:</p> <ul> <li>We recommend remembering the English names of terms to help with reading English literature.</li> <li>Some terms have different names in Simplified Chinese and Traditional Chinese.</li> </ul> <p> Table 16-1   Important Terms in Data Structures and Algorithms </p> English Simplified Chinese Traditional Chinese algorithm 算法 演算法 data structure 数据结构 資料結構 code 代码 程式碼 file 文件 檔案 function 函数 函式 method 方法 方法 variable 变量 變數 asymptotic complexity analysis 渐近复杂度分析 漸近複雜度分析 time complexity 时间复杂度 時間複雜度 space complexity 空间复杂度 空間複雜度 loop 循环 迴圈 iteration 迭代 迭代 recursion 递归 遞迴 tail recursion 尾递归 尾遞迴 recursion tree 递归树 遞迴樹 big-\\(O\\) notation 大 \\(O\\) 记号 大 \\(O\\) 記號 asymptotic upper bound 渐近上界 漸近上界 sign-magnitude 原码 原碼 1’s complement 反码 一補數 2’s complement 补码 二補數 array 数组 陣列 index 索引 索引 linked list 链表 鏈結串列 linked list node, list node 链表节点 鏈結串列節點 head node 头节点 頭節點 tail node 尾节点 尾節點 list 列表 串列 dynamic array 动态数组 動態陣列 hard disk 硬盘 硬碟 random-access memory (RAM) 内存 記憶體 cache memory 缓存 快取 cache miss 缓存未命中 快取未命中 cache hit rate 缓存命中率 快取命中率 stack 栈 堆疊 top of the stack 栈顶 堆疊頂 bottom of the stack 栈底 堆疊底 queue 队列 佇列 double-ended queue 双向队列 雙向佇列 front of the queue 队首 佇列首 rear of the queue 队尾 佇列尾 hash table 哈希表 雜湊表 hash set 哈希集合 雜湊集合 bucket 桶 桶 hash function 哈希函数 雜湊函式 hash collision 哈希冲突 雜湊衝突 load factor 负载因子 負載因子 separate chaining 链式地址 鏈結位址 open addressing 开放寻址 開放定址 linear probing 线性探测 線性探查 lazy deletion 懒删除 懶刪除 binary tree 二叉树 二元樹 tree node 树节点 樹節點 left-child node 左子节点 左子節點 right-child node 右子节点 右子節點 parent node 父节点 父節點 left subtree 左子树 左子樹 right subtree 右子树 右子樹 root node 根节点 根節點 leaf node 叶节点 葉節點 edge 边 邊 level 层 層 degree 度 度 height 高度 高度 depth 深度 深度 perfect binary tree 完美二叉树 完美二元樹 complete binary tree 完全二叉树 完全二元樹 full binary tree 完满二叉树 完滿二元樹 balanced binary tree 平衡二叉树 平衡二元樹 binary search tree 二叉搜索树 二元搜尋樹 AVL tree AVL 树 AVL 樹 red-black tree 红黑树 紅黑樹 level-order traversal 层序遍历 層序走訪 breadth-first traversal 广度优先遍历 廣度優先走訪 depth-first traversal 深度优先遍历 深度優先走訪 binary search tree 二叉搜索树 二元搜尋樹 balanced binary search tree 平衡二叉搜索树 平衡二元搜尋樹 balance factor 平衡因子 平衡因子 heap 堆 堆積 max heap 大顶堆 大頂堆積 min heap 小顶堆 小頂堆積 priority queue 优先队列 優先佇列 heapify 堆化 堆積化 top-\\(k\\) problem Top-\\(k\\) 问题 Top-\\(k\\) 問題 graph 图 圖 vertex 顶点 頂點 undirected graph 无向图 無向圖 directed graph 有向图 有向圖 connected graph 连通图 連通圖 disconnected graph 非连通图 非連通圖 weighted graph 有权图 有權圖 adjacency 邻接 鄰接 path 路径 路徑 in-degree 入度 入度 out-degree 出度 出度 adjacency matrix 邻接矩阵 鄰接矩陣 adjacency list 邻接表 鄰接表 breadth-first search 广度优先搜索 廣度優先搜尋 depth-first search 深度优先搜索 深度優先搜尋 binary search 二分查找 二分搜尋 searching algorithm 搜索算法 搜尋演算法 sorting algorithm 排序算法 排序演算法 selection sort 选择排序 選擇排序 bubble sort 冒泡排序 泡沫排序 insertion sort 插入排序 插入排序 quick sort 快速排序 快速排序 merge sort 归并排序 合併排序 heap sort 堆排序 堆積排序 bucket sort 桶排序 桶排序 counting sort 计数排序 計數排序 radix sort 基数排序 基數排序 divide and conquer 分治 分治 hanota problem 汉诺塔问题 河內塔問題 backtracking algorithm 回溯算法 回溯演算法 constraint 约束 約束 solution 解 解 state 状态 狀態 pruning 剪枝 剪枝 permutations problem 全排列问题 全排列問題 subset-sum problem 子集和问题 子集合問題 \\(n\\)-queens problem \\(n\\) 皇后问题 \\(n\\) 皇后問題 dynamic programming 动态规划 動態規劃 initial state 初始状态 初始狀態 state-transition equation 状态转移方程 狀態轉移方程 knapsack problem 背包问题 背包問題 edit distance problem 编辑距离问题 編輯距離問題 greedy algorithm 贪心算法 貪婪演算法","path":["Chapter 16. Appendix","16.3 &nbsp; Terminology Table"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"Chapter 4.   Array and Linked List","text":"<p>Abstract</p> <p>The world of data structures is like a solid brick wall.</p> <p>Array bricks are neatly arranged, tightly packed one by one. Linked list bricks are scattered everywhere, with connecting vines freely weaving through the gaps between bricks.</p>","path":["Chapter 4. Array and Linked List","Chapter 4. &nbsp; Array and Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>4.1   Array</li> <li>4.2   Linked List</li> <li>4.3   List</li> <li>4.4   Memory and Cache *</li> <li>4.5   Summary</li> </ul>","path":["Chapter 4. Array and Linked List","Chapter 4. &nbsp; Array and Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   Array","text":"<p>An array is a linear data structure that stores elements of the same type in contiguous memory space. The position of an element in the array is called the element's index. Figure 4-1 illustrates the main concepts and storage method of arrays.</p> <p></p> <p> Figure 4-1   Array definition and storage method </p>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411-common-array-operations","level":2,"title":"4.1.1   Common Array Operations","text":"","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1-initializing-arrays","level":3,"title":"1.   Initializing Arrays","text":"<p>We can choose between two array initialization methods based on our needs: without initial values or with given initial values. When no initial values are specified, most programming languages will initialize array elements to \\(0\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># Initialize array\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* Initialize array */\n// Stored on stack\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Stored on heap (requires manual memory release)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* Initialize array */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* Initialize array */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* Initialize array */\nvar arr [5]int\n// In Go, specifying length ([5]int) creates an array; not specifying length ([]int) creates a slice\n// Since Go's arrays are designed to have their length determined at compile time, only constants can be used to specify the length\n// For convenience in implementing the extend() method, slices are treated as arrays below\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* Initialize array */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* Initialize array */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* Initialize array */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* Initialize array */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* Initialize array */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// In Rust, specifying length ([i32; 5]) creates an array; not specifying length (&amp;[i32]) creates a slice\n// Since Rust's arrays are designed to have their length determined at compile time, only constants can be used to specify the length\n// Vector is the type generally used as a dynamic array in Rust\n// For convenience in implementing the extend() method, vectors are treated as arrays below\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* Initialize array */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* Initialize array */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># Initialize array\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2-accessing-elements","level":3,"title":"2.   Accessing Elements","text":"<p>Array elements are stored in contiguous memory space, which means calculating the memory address of array elements is very easy. Given the array's memory address (the memory address of the first element) and an element's index, we can use the formula shown in Figure 4-2 to calculate the element's memory address and directly access that element.</p> <p></p> <p> Figure 4-2   Memory address calculation for array elements </p> <p>Observing Figure 4-2, we find that the first element of an array has an index of \\(0\\), which may seem counterintuitive since counting from \\(1\\) would be more natural. However, from the perspective of the address calculation formula, an index is essentially an offset from the memory address. The address offset of the first element is \\(0\\), so it is reasonable for its index to be \\(0\\).</p> <p>Accessing elements in an array is highly efficient; we can randomly access any element in the array in \\(O(1)\\) time.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"Random access to element\"\"\"\n    # Randomly select a number from the interval [0, len(nums)-1]\n    random_index = random.randint(0, len(nums) - 1)\n    # Retrieve and return the random element\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* Random access to element */\nint randomAccess(int *nums, int size) {\n    // Randomly select a number from interval [0, size)\n    int randomIndex = rand() % size;\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* Random access to element */\nint randomAccess(int[] nums) {\n    // Randomly select a number in the interval [0, nums.length)\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* Random access to element */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // Randomly select a number in interval [0, nums.Length)\n    int randomIndex = random.Next(nums.Length);\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* Random access to element */\nfunc randomAccess(nums []int) (randomNum int) {\n    // Randomly select a number in the interval [0, nums.length)\n    randomIndex := rand.Intn(len(nums))\n    // Retrieve and return the random element\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* Random access to element */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // Randomly select a number in interval [0, nums.count)\n    let randomIndex = nums.indices.randomElement()!\n    // Retrieve and return the random element\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* Random access to element */\nfunction randomAccess(nums) {\n    // Randomly select a number in the interval [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Retrieve and return the random element\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* Random access to element */\nfunction randomAccess(nums: number[]): number {\n    // Randomly select a number in the interval [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Retrieve and return the random element\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* Random access to element */\nint randomAccess(List&lt;int&gt; nums) {\n  // Randomly select a number in the interval [0, nums.length)\n  int randomIndex = Random().nextInt(nums.length);\n  // Retrieve and return the random element\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* Random access to element */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // Randomly select a number in interval [0, nums.len())\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // Retrieve and return the random element\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* Random access to element */\nint randomAccess(int *nums, int size) {\n    // Randomly select a number from interval [0, size)\n    int randomIndex = rand() % size;\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* Random access to element */\nfun randomAccess(nums: IntArray): Int {\n    // Randomly select a number in interval [0, nums.size)\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // Retrieve and return the random element\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### Random access element ###\ndef random_access(nums)\n  # Randomly select a number in the interval [0, nums.length)\n  random_index = Random.rand(0...nums.length)\n\n  # Retrieve and return the random element\n  nums[random_index]\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3-inserting-elements","level":3,"title":"3.   Inserting Elements","text":"<p>Array elements are stored \"tightly adjacent\" in memory, with no space between them to store any additional data. As shown in Figure 4-3, if we want to insert an element in the middle of an array, we need to shift all elements after that position backward by one position, and then assign the value to that index.</p> <p></p> <p> Figure 4-3   Example of inserting an element into an array </p> <p>It is worth noting that since the length of an array is fixed, inserting an element will inevitably cause the element at the end of the array to be \"lost\". We will leave the solution to this problem for discussion in the \"List\" chapter.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"Insert element num at index index in the array\"\"\"\n    # Move all elements at and after index index backward by one position\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # Assign num to the element at index index\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* Insert element num at index index in the array */\nvoid insert(int *nums, int size, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* Insert element num at index index in the array */\nvoid insert(int[] nums, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* Insert element num at index index in the array */\nvoid Insert(int[] nums, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* Insert element num at index index in the array */\nfunc insert(nums []int, num int, index int) {\n    // Move all elements at and after index index backward by one position\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* Insert element num at index index in the array */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // Move all elements at and after index index backward by one position\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* Insert element num at index index in the array */\nfunction insert(nums, num, index) {\n    // Move all elements at and after index index backward by one position\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* Insert element num at index index in the array */\nfunction insert(nums: number[], num: number, index: number): void {\n    // Move all elements at and after index index backward by one position\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* Insert element _num at array index index */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // Move all elements at and after index index backward by one position\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // Assign _num to element at index\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* Insert element num at index index in the array */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // Move all elements at and after index index backward by one position\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* Insert element num at index index in the array */\nvoid insert(int *nums, int size, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* Insert element num at index index in the array */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // Move all elements at and after index index backward by one position\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### Insert element num at index in array ###\ndef insert(nums, num, index)\n  # Move all elements at and after index index backward by one position\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # Assign num to the element at index index\n  nums[index] = num\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4-removing-elements","level":3,"title":"4.   Removing Elements","text":"<p>Similarly, as shown in Figure 4-4, to delete the element at index \\(i\\), we need to shift all elements after index \\(i\\) forward by one position.</p> <p></p> <p> Figure 4-4   Example of removing an element from an array </p> <p>Note that after the deletion is complete, the original last element becomes \"meaningless\", so we do not need to specifically modify it.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"Remove the element at index index\"\"\"\n    # Move all elements after index index forward by one position\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* Remove the element at index index */\nvoid remove(int *nums, int size, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* Remove the element at index index */\nvoid remove(int[] nums, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* Remove the element at index index */\nvoid Remove(int[] nums, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* Remove the element at index index */\nfunc remove(nums []int, index int) {\n    // Move all elements after index index forward by one position\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* Remove the element at index index */\nfunc remove(nums: inout [Int], index: Int) {\n    // Move all elements after index index forward by one position\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* Remove the element at index index */\nfunction remove(nums, index) {\n    // Move all elements after index index forward by one position\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* Remove the element at index index */\nfunction remove(nums: number[], index: number): void {\n    // Move all elements after index index forward by one position\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* Remove the element at index index */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // Move all elements after index index forward by one position\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* Remove the element at index index */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // Move all elements after index index forward by one position\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* Remove the element at index index */\n// Note: stdio.h occupies the remove keyword\nvoid removeItem(int *nums, int size, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* Remove the element at index index */\nfun remove(nums: IntArray, index: Int) {\n    // Move all elements after index index forward by one position\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### Delete element at index ###\ndef remove(nums, index)\n  # Move all elements after index index forward by one position\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> <p>Overall, array insertion and deletion operations have the following drawbacks:</p> <ul> <li>High time complexity: The average time complexity for both insertion and deletion in arrays is \\(O(n)\\), where \\(n\\) is the length of the array.</li> <li>Loss of elements: Since the length of an array is immutable, after inserting an element, elements that exceed the array's length will be lost.</li> <li>Memory waste: We can initialize a relatively long array and only use the front portion, so that when inserting data, the lost elements at the end are \"meaningless\", but this causes some memory space to be wasted.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5-traversing-arrays","level":3,"title":"5.   Traversing Arrays","text":"<p>In most programming languages, we can traverse an array either by index or by directly iterating through each element in the array:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"Traverse array\"\"\"\n    count = 0\n    # Traverse array by index\n    for i in range(len(nums)):\n        count += nums[i]\n    # Direct traversal of array elements\n    for num in nums:\n        count += num\n    # Traverse simultaneously data index and elements\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* Traverse array */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* Traverse array */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* Traverse array */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* Traverse array */\nfunc traverse(nums []int) {\n    count := 0\n    // Traverse array by index\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // Direct traversal of array elements\n    for _, num := range nums {\n        count += num\n    }\n    // Traverse simultaneously data index and elements\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* Traverse array */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // Traverse array by index\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // Direct traversal of array elements\n    for num in nums {\n        count += num\n    }\n    // Traverse simultaneously data index and elements\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* Traverse array */\nfunction traverse(nums) {\n    let count = 0;\n    // Traverse array by index\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* Traverse array */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // Traverse array by index\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* Traverse array elements */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // Traverse array by index\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // Direct traversal of array elements\n  for (int _num in nums) {\n    count += _num;\n  }\n  // Traverse array using forEach method\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* Traverse array */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // Traverse array by index\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // Direct traversal of array elements\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* Traverse array */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* Traverse array */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // Traverse array by index\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // Direct traversal of array elements\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### Traverse array ###\ndef traverse(nums)\n  count = 0\n\n  # Traverse array by index\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # Direct traversal of array elements\n  for num in nums\n    count += num\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6-finding-elements","level":3,"title":"6.   Finding Elements","text":"<p>Finding a specified element in an array requires traversing the array and checking whether the element value matches in each iteration; if it matches, output the corresponding index.</p> <p>Since an array is a linear data structure, the above search operation is called a \"linear search\".</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"Find the specified element in the array\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* Find the specified element in the array */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* Find the specified element in the array */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* Find the specified element in the array */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* Find the specified element in the array */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* Find the specified element in the array */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* Find the specified element in the array */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* Find the specified element in the array */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* Find the specified element in the array */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* Find the specified element in the array */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* Find the specified element in the array */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* Find the specified element in the array */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### Find specified element in array ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7-expanding-arrays","level":3,"title":"7.   Expanding Arrays","text":"<p>In complex system environments, programs cannot guarantee that the memory space after an array is available, making it unsafe to expand the array's capacity. Therefore, in most programming languages, the length of an array is immutable.</p> <p>If we want to expand an array, we need to create a new, larger array and then copy the original array elements to the new array one by one. This is an \\(O(n)\\) operation, which is very time-consuming when the array is large. The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"Extend array length\"\"\"\n    # Initialize an array with extended length\n    res = [0] * (len(nums) + enlarge)\n    # Copy all elements from the original array to the new array\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # Return the extended new array\n    return res\n</code></pre> array.cpp<pre><code>/* Extend array length */\nint *extend(int *nums, int size, int enlarge) {\n    // Initialize an array with extended length\n    int *res = new int[size + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Free memory\n    delete[] nums;\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.java<pre><code>/* Extend array length */\nint[] extend(int[] nums, int enlarge) {\n    // Initialize an array with extended length\n    int[] res = new int[nums.length + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.cs<pre><code>/* Extend array length */\nint[] Extend(int[] nums, int enlarge) {\n    // Initialize an array with extended length\n    int[] res = new int[nums.Length + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.go<pre><code>/* Extend array length */\nfunc extend(nums []int, enlarge int) []int {\n    // Initialize an array with extended length\n    res := make([]int, len(nums)+enlarge)\n    // Copy all elements from the original array to the new array\n    for i, num := range nums {\n        res[i] = num\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.swift<pre><code>/* Extend array length */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // Initialize an array with extended length\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // Copy all elements from the original array to the new array\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.js<pre><code>/* Extend array length */\n// Note: JavaScript's Array is dynamic array, can be directly expanded\n// For learning purposes, this function treats Array as fixed-length array\nfunction extend(nums, enlarge) {\n    // Initialize an array with extended length\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Copy all elements from the original array to the new array\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.ts<pre><code>/* Extend array length */\n// Note: TypeScript's Array is dynamic array, can be directly expanded\n// For learning purposes, this function treats Array as fixed-length array\nfunction extend(nums: number[], enlarge: number): number[] {\n    // Initialize an array with extended length\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Copy all elements from the original array to the new array\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.dart<pre><code>/* Extend array length */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // Initialize an array with extended length\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // Copy all elements from the original array to the new array\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // Return the extended new array\n  return res;\n}\n</code></pre> array.rs<pre><code>/* Extend array length */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // Initialize an array with extended length\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // Copy all elements from original array to new\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // Return the extended new array\n    res\n}\n</code></pre> array.c<pre><code>/* Extend array length */\nint *extend(int *nums, int size, int enlarge) {\n    // Initialize an array with extended length\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Initialize expanded space\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.kt<pre><code>/* Extend array length */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // Initialize an array with extended length\n    val res = IntArray(nums.size + enlarge)\n    // Copy all elements from the original array to the new array\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.rb<pre><code>### Extend array length ###\n# Note: Ruby's Array is dynamic array, can be directly expanded\n# For learning purposes, this function treats Array as fixed-length array\ndef extend(nums, enlarge)\n  # Initialize an array with extended length\n  res = Array.new(nums.length + enlarge, 0)\n\n  # Copy all elements from the original array to the new array\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # Return the extended new array\n  res\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412-advantages-and-limitations-of-arrays","level":2,"title":"4.1.2   Advantages and Limitations of Arrays","text":"<p>Arrays are stored in contiguous memory space with elements of the same type. This approach contains rich prior information that the system can use to optimize the efficiency of data structure operations.</p> <ul> <li>High space efficiency: Arrays allocate contiguous memory blocks for data without additional structural overhead.</li> <li>Support for random access: Arrays allow accessing any element in \\(O(1)\\) time.</li> <li>Cache locality: When accessing array elements, the computer not only loads the element but also caches the surrounding data, thereby leveraging the cache to improve the execution speed of subsequent operations.</li> </ul> <p>Contiguous space storage is a double-edged sword with the following limitations:</p> <ul> <li>Low insertion and deletion efficiency: When an array has many elements, insertion and deletion operations require shifting a large number of elements.</li> <li>Immutable length: After an array is initialized, its length is fixed. Expanding the array requires copying all data to a new array, which is very costly.</li> <li>Space waste: If the allocated size of an array exceeds what is actually needed, the extra space is wasted.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413-typical-applications-of-arrays","level":2,"title":"4.1.3   Typical Applications of Arrays","text":"<p>Arrays are a fundamental and common data structure, frequently used in various algorithms and for implementing various complex data structures.</p> <ul> <li>Random access: If we want to randomly sample some items, we can use an array to store them and generate a random sequence to implement random sampling based on indices.</li> <li>Sorting and searching: Arrays are the most commonly used data structure for sorting and searching algorithms. Quick sort, merge sort, binary search, and others are primarily performed on arrays.</li> <li>Lookup tables: When we need to quickly find an element or its corresponding relationship, we can use an array as a lookup table. For example, if we want to implement a mapping from characters to ASCII codes, we can use the ASCII code value of a character as an index, with the corresponding element stored at that position in the array.</li> <li>Machine learning: Neural networks make extensive use of linear algebra operations between vectors, matrices, and tensors, all of which are constructed in the form of arrays. Arrays are the most commonly used data structure in neural network programming.</li> <li>Data structure implementation: Arrays can be used to implement stacks, queues, hash tables, heaps, graphs, and other data structures. For example, the adjacency matrix representation of a graph is essentially a two-dimensional array.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   Linked List","text":"<p>Memory space is a shared resource for all programs. In a complex system runtime environment, available memory space may be scattered throughout the memory. We know that the memory space for storing an array must be contiguous, and when the array is very large, the memory may not be able to provide such a large contiguous space. This is where the flexibility advantage of linked lists becomes apparent.</p> <p>A linked list is a linear data structure in which each element is a node object, and the nodes are connected through \"references\". A reference records the memory address of the next node, through which the next node can be accessed from the current node.</p> <p>The design of linked lists allows nodes to be stored scattered throughout the memory, and their memory addresses do not need to be contiguous.</p> <p></p> <p> Figure 4-5   Linked list definition and storage method </p> <p>Observing Figure 4-5, the basic unit of a linked list is a node object. Each node contains two pieces of data: the node's \"value\" and a \"reference\" to the next node.</p> <ul> <li>The first node of a linked list is called the \"head node\", and the last node is called the \"tail node\".</li> <li>The tail node points to \"null\", which is denoted as <code>null</code>, <code>nullptr</code>, and <code>None</code> in Java, C++, and Python, respectively.</li> <li>In languages that support pointers, such as C, C++, Go, and Rust, the aforementioned \"reference\" should be replaced with \"pointer\".</li> </ul> <p>As shown in the following code, a linked list node <code>ListNode</code> contains not only a value but also an additional reference (pointer). Therefore, linked lists occupy more memory space than arrays when storing the same amount of data.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Linked list node class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Node value\n        self.next: ListNode | None = None # Reference to the next node\n</code></pre> <pre><code>/* Linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the next node\n    ListNode(int x) : val(x), next(nullptr) {}  // Constructor\n};\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode(int x) { val = x; }  // Constructor\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;         // Node value\n    ListNode? next;      // Reference to the next node\n}\n</code></pre> <pre><code>/* Linked list node structure */\ntype ListNode struct {\n    Val  int       // Node value\n    Next *ListNode // Pointer to the next node\n}\n\n// NewListNode Constructor, creates a new linked list\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Node value\n        this.next = (next === undefined ? null : next); // Reference to the next node\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Node value\n        this.next = next === undefined ? null : next;  // Reference to the next node\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Reference to the next node\n  ListNode(this.val, [this.next]); // Constructor\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* Linked list node class */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the next node\n}\n</code></pre> <pre><code>/* Linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the next node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Linked list node class */\n// Constructor\nclass ListNode(x: Int) {\n    val _val: Int = x          // Node value\n    val next: ListNode? = null // Reference to the next node\n}\n</code></pre> <pre><code># Linked list node class\nclass ListNode\n  attr_accessor :val  # Node value\n  attr_accessor :next # Reference to the next node\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421-common-linked-list-operations","level":2,"title":"4.2.1   Common Linked List Operations","text":"","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1-initializing-a-linked-list","level":3,"title":"1.   Initializing a Linked List","text":"<p>Building a linked list involves two steps: first, initializing each node object; second, constructing the reference relationships between nodes. Once initialization is complete, we can traverse all nodes starting from the head node of the linked list through the reference <code>next</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Initialize each node\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// Build references between nodes\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Build references between nodes\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// Initialize each node\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Build references between nodes\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Build references between nodes\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Initialize each node\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> Code Visualization <p> Full Screen &gt;</p> <p>An array is a single variable; for example, an array <code>nums</code> contains elements <code>nums[0]</code>, <code>nums[1]</code>, etc. A linked list, however, is composed of multiple independent node objects. We typically use the head node as the reference to the linked list; for example, the linked list in the above code can be referred to as linked list <code>n0</code>.</p>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2-inserting-a-node","level":3,"title":"2.   Inserting a Node","text":"<p>Inserting a node in a linked list is very easy. As shown in Figure 4-6, suppose we want to insert a new node <code>P</code> between two adjacent nodes <code>n0</code> and <code>n1</code>. We only need to change two node references (pointers), with a time complexity of \\(O(1)\\).</p> <p>In contrast, the time complexity of inserting an element in an array is \\(O(n)\\), which is inefficient when dealing with large amounts of data.</p> <p></p> <p> Figure 4-6   Example of inserting a node into a linked list </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"Insert node P after node n0 in the linked list\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* Insert node P after node n0 in the linked list */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* Insert node P after node n0 in the linked list */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* Insert node P after node n0 in the linked list */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* Insert node P after node n0 in the linked list */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* Insert node P after node n0 in the linked list */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* Insert node P after node n0 in the linked list */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* Insert node P after node n0 in the linked list */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### Insert node _p after node n0 in linked list ###\n# Ruby's `p` is a built-in function, `P` is a constant, so use `_p` instead\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3-removing-a-node","level":3,"title":"3.   Removing a Node","text":"<p>As shown in Figure 4-7, removing a node in a linked list is also very convenient. We only need to change one node's reference (pointer).</p> <p>Note that although node <code>P</code> still points to <code>n1</code> after the deletion operation is complete, the linked list can no longer access <code>P</code> when traversing, which means <code>P</code> no longer belongs to this linked list.</p> <p></p> <p> Figure 4-7   Removing a node from a linked list </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"Remove the first node after node n0 in the linked list\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Free memory\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* Remove the first node after node n0 in the linked list */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* Remove the first node after node n0 in the linked list */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* Remove the first node after node n0 in the linked list */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* Remove the first node after node n0 in the linked list */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* Remove the first node after node n0 in the linked list */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* Remove the first node after node n0 in the linked list */\n// Note: stdio.h occupies the remove keyword\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Free memory\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* Remove the first node after node n0 in the linked list */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### Delete first node after node n0 in linked list ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4-accessing-a-node","level":3,"title":"4.   Accessing a Node","text":"<p>Accessing nodes in a linked list is less efficient. As mentioned in the previous section, we can access any element in an array in \\(O(1)\\) time. This is not the case with linked lists. The program needs to start from the head node and traverse backward one by one until the target node is found. That is, accessing the \\(i\\)-th node in a linked list requires \\(i - 1\\) iterations, with a time complexity of \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"Access the node at index index in the linked list\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* Access the node at index index in the linked list */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* Access the node at index index in the linked list */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* Access the node at index index in the linked list */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* Access the node at index index in the linked list */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* Access the node at index index in the linked list */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* Access the node at index index in the linked list */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* Access the node at index index in the linked list */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* Access the node at index index in the linked list */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* Access the node at index index in the linked list */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* Access the node at index index in the linked list */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* Access the node at index index in the linked list */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### Access node at index in linked list ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5-finding-a-node","level":3,"title":"5.   Finding a Node","text":"<p>Traverse the linked list to find a node with value <code>target</code>, and output the index of that node in the linked list. This process is also a linear search. The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"Find the first node with value target in the linked list\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* Find the first node with value target in the linked list */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* Find the first node with value target in the linked list */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* Find the first node with value target in the linked list */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* Find the first node with value target in the linked list */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* Find the first node with value target in the linked list */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* Find the first node with value target in the linked list */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* Find the first node with value target in the linked list */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### Find first node with value target in linked list ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-arrays-vs-linked-lists","level":2,"title":"4.2.2   Arrays vs. Linked Lists","text":"<p>Table 4-1 summarizes the characteristics of arrays and linked lists and compares their operational efficiencies. Since they employ two opposite storage strategies, their various properties and operational efficiencies also exhibit contrasting characteristics.</p> <p> Table 4-1   Comparison of array and linked list efficiencies </p> Array Linked List Storage method Contiguous memory space Scattered memory space Capacity expansion Immutable length Flexible expansion Memory efficiency Elements occupy less memory, but space may be wasted Elements occupy more memory Accessing an element \\(O(1)\\) \\(O(n)\\) Adding an element \\(O(n)\\) \\(O(1)\\) Removing an element \\(O(n)\\) \\(O(1)\\)","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423-common-types-of-linked-lists","level":2,"title":"4.2.3   Common Types of Linked Lists","text":"<p>As shown in Figure 4-8, there are three common types of linked lists:</p> <ul> <li>Singly linked list: This is the ordinary linked list introduced earlier. The nodes of a singly linked list contain a value and a reference to the next node. We call the first node the head node and the last node the tail node, which points to null <code>None</code>.</li> <li>Circular linked list: If we make the tail node of a singly linked list point to the head node (connecting the tail to the head), we get a circular linked list. In a circular linked list, any node can be viewed as the head node.</li> <li>Doubly linked list: Compared to a singly linked list, a doubly linked list records references in both directions. The node definition of a doubly linked list includes references to both the successor node (next node) and the predecessor node (previous node). Compared to a singly linked list, a doubly linked list is more flexible and can traverse the linked list in both directions, but it also requires more memory space.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Doubly linked list node class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.next: ListNode | None = None  # Reference to the successor node\n        self.prev: ListNode | None = None  # Reference to the predecessor node\n</code></pre> <pre><code>/* Doubly linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the successor node\n    ListNode *prev;  // Pointer to the predecessor node\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Constructor\n};\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the successor node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(int x) { val = x; }  // Constructor\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;    // Node value\n    ListNode next;  // Reference to the successor node\n    ListNode prev;  // Reference to the predecessor node\n}\n</code></pre> <pre><code>/* Doubly linked list node structure */\ntype DoublyListNode struct {\n    Val  int             // Node value\n    Next *DoublyListNode // Pointer to the successor node\n    Prev *DoublyListNode // Pointer to the predecessor node\n}\n\n// NewDoublyListNode Initialization\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the successor node\n    var prev: ListNode? // Reference to the predecessor node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode? next;  // Reference to the successor node\n    ListNode? prev;  // Reference to the predecessor node\n    ListNode(this.val, [this.next, this.prev]);  // Constructor\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Doubly linked list node type */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the successor node\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the predecessor node\n}\n\n/* Constructor */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the successor node\n    struct ListNode *prev; // Pointer to the predecessor node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\n// Constructor\nclass ListNode(x: Int) {\n    val _val: Int = x           // Node value\n    val next: ListNode? = null  // Reference to the successor node\n    val prev: ListNode? = null  // Reference to the predecessor node\n}\n</code></pre> <pre><code># Doubly linked list node class\nclass ListNode\n  attr_accessor :val    # Node value\n  attr_accessor :next   # Reference to the successor node\n  attr_accessor :prev   # Reference to the predecessor node\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> Figure 4-8   Common types of linked lists </p>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424-typical-applications-of-linked-lists","level":2,"title":"4.2.4   Typical Applications of Linked Lists","text":"<p>Singly linked lists are commonly used to implement stacks, queues, hash tables, and graphs.</p> <ul> <li>Stacks and queues: When insertion and deletion operations both occur at one end of the linked list, it exhibits last-in-first-out characteristics, corresponding to a stack. When insertion operations occur at one end of the linked list and deletion operations occur at the other end, it exhibits first-in-first-out characteristics, corresponding to a queue.</li> <li>Hash tables: Separate chaining is one of the mainstream solutions for resolving hash collisions. In this approach, all colliding elements are placed in a linked list.</li> <li>Graphs: An adjacency list is a common way to represent a graph, where each vertex in the graph is associated with a linked list, and each element in the linked list represents another vertex connected to that vertex.</li> </ul> <p>Doubly linked lists are commonly used in scenarios where quick access to the previous and next elements is needed.</p> <ul> <li>Advanced data structures: For example, in red-black trees and B-trees, we need to access the parent node of a node, which can be achieved by saving a reference to the parent node in the node, similar to a doubly linked list.</li> <li>Browser history: In web browsers, when a user clicks the forward or backward button, the browser needs to know the previous and next web pages the user visited. The characteristics of doubly linked lists make this operation simple.</li> <li>LRU algorithm: In cache eviction (LRU) algorithms, we need to quickly find the least recently used data and support quick addition and deletion of nodes. Using a doubly linked list is very suitable for this.</li> </ul> <p>Circular linked lists are commonly used in scenarios that require periodic operations, such as operating system resource scheduling.</p> <ul> <li>Round-robin scheduling algorithm: In operating systems, round-robin scheduling is a common CPU scheduling algorithm that needs to cycle through a set of processes. Each process is assigned a time slice, and when the time slice expires, the CPU switches to the next process. This cyclic operation can be implemented using a circular linked list.</li> <li>Data buffers: In some data buffer implementations, circular linked lists may also be used. For example, in audio and video players, the data stream may be divided into multiple buffer blocks and placed in a circular linked list to achieve seamless playback.</li> </ul>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   List","text":"<p>A list is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, insertion, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays.</p> <ul> <li>A linked list can naturally be viewed as a list, supporting element insertion, deletion, search, and modification operations, and can flexibly expand dynamically.</li> <li>An array also supports element insertion, deletion, search, and modification, but since its length is immutable, it can only be viewed as a list with length limitations.</li> </ul> <p>When implementing lists using arrays, the immutable length property reduces the practicality of the list. This is because we usually cannot determine in advance how much data we need to store, making it difficult to choose an appropriate list length. If the length is too small, it may fail to meet usage requirements; if the length is too large, it will waste memory space.</p> <p>To solve this problem, we can use a dynamic array to implement a list. It inherits all the advantages of arrays and can dynamically expand during program execution.</p> <p>In fact, the lists provided in the standard libraries of many programming languages are implemented based on dynamic arrays, such as <code>list</code> in Python, <code>ArrayList</code> in Java, <code>vector</code> in C++, and <code>List</code> in C#. In the following discussion, we will treat \"list\" and \"dynamic array\" as equivalent concepts.</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431-common-list-operations","level":2,"title":"4.3.1   Common List Operations","text":"","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1-initialize-a-list","level":3,"title":"1.   Initialize a List","text":"<p>We typically use two initialization methods: \"without initial values\" and \"with initial values\":</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Initialize a list\n# Without initial values\nnums1: list[int] = []\n# With initial values\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* Initialize a list */\n// Note that vector in C++ is equivalent to nums as described in this article\n// Without initial values\nvector&lt;int&gt; nums1;\n// With initial values\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// With initial values (note that array elements should use the wrapper class Integer[] instead of int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;int&gt; nums1 = [];\n// With initial values\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* Initialize a list */\n// Without initial values\nnums1 := []int{}\n// With initial values\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* Initialize a list */\n// Without initial values\nlet nums1: [Int] = []\n// With initial values\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* Initialize a list */\n// Without initial values\nconst nums1 = [];\n// With initial values\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* Initialize a list */\n// Without initial values\nconst nums1: number[] = [];\n// With initial values\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;int&gt; nums1 = [];\n// With initial values\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* Initialize a list */\n// Without initial values\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// With initial values\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Initialize a list */\n// Without initial values\nvar nums1 = listOf&lt;Int&gt;()\n// With initial values\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># Initialize a list\n# Without initial values\nnums1 = []\n# With initial values\nnums = [1, 3, 2, 5, 4]\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2-access-elements","level":3,"title":"2.   Access Elements","text":"<p>Since a list is essentially an array, we can access and update elements in \\(O(1)\\) time complexity, which is very efficient.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Access an element\nnum: int = nums[1]  # Access element at index 1\n\n# Update an element\nnums[1] = 0    # Update element at index 1 to 0\n</code></pre> list.cpp<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.java<pre><code>/* Access an element */\nint num = nums.get(1);  // Access element at index 1\n\n/* Update an element */\nnums.set(1, 0);  // Update element at index 1 to 0\n</code></pre> list.cs<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list_test.go<pre><code>/* Access an element */\nnum := nums[1]  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0     // Update element at index 1 to 0\n</code></pre> list.swift<pre><code>/* Access an element */\nlet num = nums[1] // Access element at index 1\n\n/* Update an element */\nnums[1] = 0 // Update element at index 1 to 0\n</code></pre> list.js<pre><code>/* Access an element */\nconst num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.ts<pre><code>/* Access an element */\nconst num: number = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.dart<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.rs<pre><code>/* Access an element */\nlet num: i32 = nums[1];  // Access element at index 1\n/* Update an element */\nnums[1] = 0;             // Update element at index 1 to 0\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Access an element */\nval num = nums[1]       // Access element at index 1\n/* Update an element */\nnums[1] = 0             // Update element at index 1 to 0\n</code></pre> list.rb<pre><code># Access an element\nnum = nums[1] # Access element at index 1\n# Update an element\nnums[1] = 0 # Update element at index 1 to 0\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3-insert-and-delete-elements","level":3,"title":"3.   Insert and Delete Elements","text":"<p>Compared to arrays, lists can freely add and delete elements. Adding an element at the end of a list has a time complexity of \\(O(1)\\), but inserting and deleting elements still have the same efficiency as arrays, with a time complexity of \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Clear the list\nnums.clear()\n\n# Add elements at the end\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Insert an element in the middle\nnums.insert(3, 6)  # Insert number 6 at index 3\n\n# Delete an element\nnums.pop(3)        # Delete element at index 3\n</code></pre> list.cpp<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Insert an element in the middle */\nnums.insert(nums.begin() + 3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.erase(nums.begin() + 3);      // Delete element at index 3\n</code></pre> list.java<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);  // Delete element at index 3\n</code></pre> list.cs<pre><code>/* Clear the list */\nnums.Clear();\n\n/* Add elements at the end */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Insert an element in the middle */\nnums.Insert(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.RemoveAt(3);  // Delete element at index 3\n</code></pre> list_test.go<pre><code>/* Clear the list */\nnums = nil\n\n/* Add elements at the end */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Insert an element in the middle */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Insert number 6 at index 3\n\n/* Delete an element */\nnums = append(nums[:3], nums[4:]...) // Delete element at index 3\n</code></pre> list.swift<pre><code>/* Clear the list */\nnums.removeAll()\n\n/* Add elements at the end */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Insert an element in the middle */\nnums.insert(6, at: 3) // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(at: 3) // Delete element at index 3\n</code></pre> list.js<pre><code>/* Clear the list */\nnums.length = 0;\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.splice(3, 0, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.splice(3, 1);  // Delete element at index 3\n</code></pre> list.ts<pre><code>/* Clear the list */\nnums.length = 0;\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.splice(3, 0, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.splice(3, 1);  // Delete element at index 3\n</code></pre> list.dart<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.insert(3, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.removeAt(3); // Delete element at index 3\n</code></pre> list.rs<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.insert(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);    // Delete element at index 3\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);  // Delete element at index 3\n</code></pre> list.rb<pre><code># Clear the list\nnums.clear\n\n# Add elements at the end\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# Insert an element in the middle\nnums.insert(3, 6) # Insert number 6 at index 3\n\n# Delete an element\nnums.delete_at(3) # Delete element at index 3\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4-traverse-a-list","level":3,"title":"4.   Traverse a List","text":"<p>Like arrays, lists can be traversed by index or by directly iterating through elements.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Traverse the list by index\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Traverse list elements directly\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Traverse list elements directly */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* Traverse the list by index */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* Traverse the list by index */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* Traverse the list by index */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* Traverse the list by index */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// Traverse the list by index\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Traverse list elements directly\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Traverse the list by index */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># Traverse the list by index\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# Traverse list elements directly\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5-concatenate-lists","level":3,"title":"5.   Concatenate Lists","text":"<p>Given a new list <code>nums1</code>, we can concatenate it to the end of the original list.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Concatenate two lists\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Concatenate list nums1 to the end of nums\n</code></pre> list.cpp<pre><code>/* Concatenate two lists */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// Concatenate list nums1 to the end of nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* Concatenate two lists */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.cs<pre><code>/* Concatenate two lists */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list_test.go<pre><code>/* Concatenate two lists */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Concatenate list nums1 to the end of nums\n</code></pre> list.swift<pre><code>/* Concatenate two lists */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Concatenate list nums1 to the end of nums\n</code></pre> list.js<pre><code>/* Concatenate two lists */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.ts<pre><code>/* Concatenate two lists */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.dart<pre><code>/* Concatenate two lists */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.rs<pre><code>/* Concatenate two lists */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Concatenate two lists */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // Concatenate list nums1 to the end of nums\n</code></pre> list.rb<pre><code># Concatenate two lists\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6-sort-a-list","level":3,"title":"6.   Sort a List","text":"<p>After sorting a list, we can use \"binary search\" and \"two-pointer\" algorithms, which are frequently tested in array algorithm problems.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Sort a list\nnums.sort()  # After sorting, list elements are arranged from smallest to largest\n</code></pre> list.cpp<pre><code>/* Sort a list */\nsort(nums.begin(), nums.end());  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.java<pre><code>/* Sort a list */\nCollections.sort(nums);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.cs<pre><code>/* Sort a list */\nnums.Sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list_test.go<pre><code>/* Sort a list */\nsort.Ints(nums)  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.swift<pre><code>/* Sort a list */\nnums.sort() // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.js<pre><code>/* Sort a list */\nnums.sort((a, b) =&gt; a - b);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.ts<pre><code>/* Sort a list */\nnums.sort((a, b) =&gt; a - b);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.dart<pre><code>/* Sort a list */\nnums.sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.rs<pre><code>/* Sort a list */\nnums.sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Sort a list */\nnums.sort() // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.rb<pre><code># Sort a list\nnums = nums.sort { |a, b| a &lt;=&gt; b } # After sorting, list elements are arranged from smallest to largest\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432-list-implementation","level":2,"title":"4.3.2   List Implementation","text":"<p>Many programming languages have built-in lists, such as Java, C++, and Python. Their implementations are quite complex, and the parameters are carefully considered, such as initial capacity, expansion multiples, and so on. Interested readers can consult the source code to learn more.</p> <p>To deepen our understanding of how lists work, we attempt to implement a simple list with three key design considerations:</p> <ul> <li>Initial capacity: Select a reasonable initial capacity for the underlying array. In this example, we choose 10 as the initial capacity.</li> <li>Size tracking: Declare a variable <code>size</code> to record the current number of elements in the list and update it in real-time as elements are inserted and deleted. Based on this variable, we can locate the end of the list and determine whether expansion is needed.</li> <li>Expansion mechanism: When the list capacity is full upon inserting an element, we need to expand. We create a larger array based on the expansion multiple and then move all elements from the current array to the new array in order. In this example, we specify that the array should be expanded to 2 times its previous size each time.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"List class\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._capacity: int = 10  # List capacity\n        self._arr: list[int] = [0] * self._capacity  # Array (stores list elements)\n        self._size: int = 0  # List length (current number of elements)\n        self._extend_ratio: int = 2  # Multiple by which the list capacity is extended each time\n\n    def size(self) -&gt; int:\n        \"\"\"Get list length (current number of elements)\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get list capacity\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"Access element\"\"\"\n        # If the index is out of bounds, throw an exception, as below\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"Update element\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"Add element at the end\"\"\"\n        # When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"Insert element in the middle\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        # When the number of elements exceeds capacity, trigger the extension mechanism\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # Move all elements at and after index index backward by one position\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # Update the number of elements\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"Remove element\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        num = self._arr[index]\n        # Move all elements after index index forward by one position\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # Update the number of elements\n        self._size -= 1\n        # Return the removed element\n        return num\n\n    def extend_capacity(self):\n        \"\"\"Extend list capacity\"\"\"\n        # Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # Update list capacity\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return list with valid length\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* List class */\nclass MyList {\n  private:\n    int *arr;             // Array (stores list elements)\n    int arrCapacity = 10; // List capacity\n    int arrSize = 0;      // List length (current number of elements)\n    int extendRatio = 2;   // Multiple by which the list capacity is extended each time\n\n  public:\n    /* Constructor */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Destructor */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* Get list length (current number of elements)*/\n    int size() {\n        return arrSize;\n    }\n\n    /* Get list capacity */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* Update element */\n    int get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    void add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Sort list */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size() == capacity())\n            extendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Remove element */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        int num = arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        arrSize--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    void extendCapacity() {\n        // Create a new array with length extendRatio times the original array\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // Copy all elements from the original array to the new array\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // Free memory\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* Convert list to Vector for printing */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* List class */\nclass MyList {\n    private int[] arr; // Array (stores list elements)\n    private int capacity = 10; // List capacity\n    private int size = 0; // List length (current number of elements)\n    private int extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* Get list length (current number of elements) */\n    public int size() {\n        return size;\n    }\n\n    /* Get list capacity */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* Update element */\n    public int get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public void add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // Update the number of elements\n        size++;\n    }\n\n    /* Sort list */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        size++;\n    }\n\n    /* Remove element */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        int num = arr[index];\n        // Move all elements after index forward by one position\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public void extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // Add elements at the end\n        capacity = arr.length;\n    }\n\n    /* Convert list to array */\n    public int[] toArray() {\n        int size = size();\n        // Elements enqueue\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* List class */\nclass MyList {\n    private int[] arr;           // Array (stores list elements)\n    private int arrCapacity = 10;    // List capacity\n    private int arrSize = 0;         // List length (current number of elements)\n    private readonly int extendRatio = 2;  // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Get list length (current number of elements) */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* Get list capacity */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* Update element */\n    public int Get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public void Add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Sort list */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Remove element */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        int num = arr[index];\n        // Move all elements after index forward by one position\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        arrSize--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public void ExtendCapacity() {\n        // Create new array of length arrCapacity * extendRatio and copy original array to new array\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // Add elements at the end\n        arrCapacity = arr.Length;\n    }\n\n    /* Convert list to array */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* List class */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* Constructor */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // List capacity\n        arr:         make([]int, 10), // Array (stores list elements)\n        arrSize:     0,               // List length (current number of elements)\n        extendRatio: 2,               // Multiple by which the list capacity is extended each time\n    }\n}\n\n/* Get list length (current number of elements) */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* Get list capacity */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* Update element */\nfunc (l *myList) get(index int) int {\n    // If the index is out of bounds, throw an exception, as below\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    return l.arr[index]\n}\n\n/* Add elements at the end */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    l.arr[index] = num\n}\n\n/* Direct traversal of list elements */\nfunc (l *myList) add(num int) {\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // Update the number of elements\n    l.arrSize++\n}\n\n/* Sort list */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // Move all elements after index index forward by one position\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // Update the number of elements\n    l.arrSize++\n}\n\n/* Remove element */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    num := l.arr[index]\n    // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // Update the number of elements\n    l.arrSize--\n    // Return the removed element\n    return num\n}\n\n/* Driver Code */\nfunc (l *myList) extendCapacity() {\n    // Create a new array with length extendRatio times the original array and copy the original array to the new array\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // Add elements at the end\n    l.arrCapacity = len(l.arr)\n}\n\n/* Return list with valid length */\nfunc (l *myList) toArray() []int {\n    // Elements enqueue\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* List class */\nclass MyList {\n    private var arr: [Int] // Array (stores list elements)\n    private var _capacity: Int // List capacity\n    private var _size: Int // List length (current number of elements)\n    private let extendRatio: Int // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* Get list length (current number of elements) */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Get list capacity */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* Update element */\n    func get(index: Int) -&gt; Int {\n        // Throw error if index out of bounds, same below\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        return arr[index]\n    }\n\n    /* Add elements at the end */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        arr[index] = num\n    }\n\n    /* Direct traversal of list elements */\n    func add(num: Int) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // Update the number of elements\n        _size += 1\n    }\n\n    /* Sort list */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // Move all elements after index index forward by one position\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // Update the number of elements\n        _size += 1\n    }\n\n    /* Remove element */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        let num = arr[index]\n        // Move all elements after index forward by one position\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // Update the number of elements\n        _size -= 1\n        // Return the removed element\n        return num\n    }\n\n    /* Driver Code */\n    func extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // Add elements at the end\n        _capacity = arr.count\n    }\n\n    /* Convert list to array */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* List class */\nclass MyList {\n    #arr = new Array(); // Array (stores list elements)\n    #capacity = 10; // List capacity\n    #size = 0; // List length (current number of elements)\n    #extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* Get list length (current number of elements) */\n    size() {\n        return this.#size;\n    }\n\n    /* Get list capacity */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* Update element */\n    get(index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        return this.#arr[index];\n    }\n\n    /* Add elements at the end */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        this.#arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    add(num) {\n        // If length equals capacity, need to expand\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Add new element to end of list\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* Sort list */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Move all elements after index index forward by one position\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // Update the number of elements\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* Remove element */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        let num = this.#arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // Update the number of elements\n        this.#size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // Add elements at the end\n        this.#capacity = this.#arr.length;\n    }\n\n    /* Convert list to array */\n    toArray() {\n        let size = this.size();\n        // Elements enqueue\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* List class */\nclass MyList {\n    private arr: Array&lt;number&gt;; // Array (stores list elements)\n    private _capacity: number = 10; // List capacity\n    private _size: number = 0; // List length (current number of elements)\n    private extendRatio: number = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* Get list length (current number of elements) */\n    public size(): number {\n        return this._size;\n    }\n\n    /* Get list capacity */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* Update element */\n    public get(index: number): number {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        return this.arr[index];\n    }\n\n    /* Add elements at the end */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        this.arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public add(num: number): void {\n        // If length equals capacity, need to expand\n        if (this._size === this._capacity) this.extendCapacity();\n        // Add new element to end of list\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* Sort list */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // Move all elements after index index forward by one position\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // Update the number of elements\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* Remove element */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        let num = this.arr[index];\n        // Move all elements after index forward by one position\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // Update the number of elements\n        this._size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public extendCapacity(): void {\n        // Create new array of length size and copy original array to new array\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // Add elements at the end\n        this._capacity = this.arr.length;\n    }\n\n    /* Convert list to array */\n    public toArray(): number[] {\n        let size = this.size();\n        // Elements enqueue\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* List class */\nclass MyList {\n  late List&lt;int&gt; _arr; // Array (stores list elements)\n  int _capacity = 10; // List capacity\n  int _size = 0; // List length (current number of elements)\n  int _extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n  /* Constructor */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* Get list length (current number of elements) */\n  int size() =&gt; _size;\n\n  /* Get list capacity */\n  int capacity() =&gt; _capacity;\n\n  /* Update element */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    return _arr[index];\n  }\n\n  /* Add elements at the end */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    _arr[index] = _num;\n  }\n\n  /* Direct traversal of list elements */\n  void add(int _num) {\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // Update the number of elements\n    _size++;\n  }\n\n  /* Sort list */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (_size == _capacity) extendCapacity();\n    // Move all elements after index index forward by one position\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // Update the number of elements\n    _size++;\n  }\n\n  /* Remove element */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    int _num = _arr[index];\n    // Move all elements after index forward by one position\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // Update the number of elements\n    _size--;\n    // Return the removed element\n    return _num;\n  }\n\n  /* Driver Code */\n  void extendCapacity() {\n    // Create new array with length _extendRatio times original array\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // Copy original array to new array\n    List.copyRange(_newNums, 0, _arr);\n    // Update _arr reference\n    _arr = _newNums;\n    // Add elements at the end\n    _capacity = _arr.length;\n  }\n\n  /* Convert list to array */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* List class */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // Array (stores list elements)\n    capacity: usize,     // List capacity\n    size: usize,         // List length (current number of elements)\n    extend_ratio: usize, // Multiple by which the list capacity is extended each time\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* Constructor */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* Get list length (current number of elements) */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* Get list capacity */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* Update element */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // If the index is out of bounds, throw an exception, as below\n        if index &gt;= self.size {\n            panic!(\"Index out of bounds\")\n        };\n        return self.arr[index];\n    }\n\n    /* Add elements at the end */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"Index out of bounds\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    pub fn add(&amp;mut self, num: i32) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // Update the number of elements\n        self.size += 1;\n    }\n\n    /* Sort list */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"Index out of bounds\")\n        };\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // Move all elements after index index forward by one position\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // Update the number of elements\n        self.size += 1;\n    }\n\n    /* Remove element */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"Index out of bounds\")\n        };\n        let num = self.arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // Update the number of elements\n        self.size -= 1;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    pub fn extend_capacity(&amp;mut self) {\n        // Create new array with length extend_ratio times original, copy original array to new array\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // Add elements at the end\n        self.capacity = new_capacity;\n    }\n\n    /* Convert list to array */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // Elements enqueue\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* List class */\ntypedef struct {\n    int *arr;        // Array (stores list elements)\n    int capacity;    // List capacity\n    int size;        // List size\n    int extendRatio; // List expansion multiplier\n} MyList;\n\n/* Constructor */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* Destructor */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* Get list length */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* Get list capacity */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* Update element */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* Add elements at the end */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* Direct traversal of list elements */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Expand capacity\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* Sort list */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Expand capacity\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* Remove element */\n// Note: stdio.h occupies the remove keyword\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* Driver Code */\nvoid extendCapacity(MyList *nums) {\n    // Allocate space first\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // Copy old data to new data\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // Free old data\n    free(temp);\n\n    // Update new data\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* Convert list to Array for printing */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* List class */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // Array (stores list elements)\n    private var capacity: Int = 10 // List capacity\n    private var size: Int = 0 // List length (current number of elements)\n    private var extendRatio: Int = 2 // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* Get list length (current number of elements) */\n    fun size(): Int {\n        return size\n    }\n\n    /* Get list capacity */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* Update element */\n    fun get(index: Int): Int {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        return arr[index]\n    }\n\n    /* Add elements at the end */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        arr[index] = num\n    }\n\n    /* Direct traversal of list elements */\n    fun add(num: Int) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // Update the number of elements\n        size++\n    }\n\n    /* Sort list */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity()\n        // Move all elements after index index forward by one position\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // Update the number of elements\n        size++\n    }\n\n    /* Remove element */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        val num = arr[index]\n        // Move all elements after index forward by one position\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // Update the number of elements\n        size--\n        // Return the removed element\n        return num\n    }\n\n    /* Driver Code */\n    fun extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = arr.copyOf(capacity() * extendRatio)\n        // Add elements at the end\n        capacity = arr.size\n    }\n\n    /* Convert list to array */\n    fun toArray(): IntArray {\n        val size = size()\n        // Elements enqueue\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### List class ###\nclass MyList\n  attr_reader :size       # Get list length (current number of elements)\n  attr_reader :capacity   # Get list capacity\n\n  ### Constructor ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### Access element ###\n  def get(index)\n    # If the index is out of bounds, throw an exception, as below\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### Access element ###\n  def set(index, num)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### Add element at end ###\n  def add(num)\n    # When the number of elements exceeds capacity, trigger the extension mechanism\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # Update the number of elements\n    @size += 1\n  end\n\n  ### Insert element in middle ###\n  def insert(index, num)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n\n    # When the number of elements exceeds capacity, trigger the extension mechanism\n    extend_capacity if size == capacity\n\n    # Move all elements after index index forward by one position\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # Update the number of elements\n    @size += 1\n  end\n\n  ### Delete element ###\n  def remove(index)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # Move all elements after index forward by one position\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # Update the number of elements\n    @size -= 1\n\n    # Return the removed element\n    num\n  end\n\n  ### Expand list capacity ###\n  def extend_capacity\n    # Create new array with length extend_ratio times original, copy original array to new array\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # Add elements at the end\n    @capacity = arr.length\n  end\n\n  ### Convert list to array ###\n  def to_array\n    sz = size\n    # Elements enqueue\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   Random-Access Memory and Cache *","text":"<p>In the first two sections of this chapter, we explored arrays and linked lists, two fundamental and important data structures that represent \"contiguous storage\" and \"distributed storage\" as two physical structures, respectively.</p> <p>In fact, physical structure largely determines the efficiency with which programs utilize memory and cache, which in turn affects the overall performance of algorithmic programs.</p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441-computer-storage-devices","level":2,"title":"4.4.1   Computer Storage Devices","text":"<p>Computers include three types of storage devices: hard disk, random-access memory (RAM), and cache memory. The following table shows their different roles and performance characteristics in a computer system.</p> <p> Table 4-2   Computer Storage Devices </p> Hard Disk RAM Cache Purpose Long-term storage of data, including operating systems, programs, and files Temporary storage of currently running programs and data being processed Storage of frequently accessed data and instructions to reduce CPU's accesses to memory Volatility Data is not lost after power-off Data is lost after power-off Data is lost after power-off Capacity Large, on the order of terabytes (TB) Small, on the order of gigabytes (GB) Very small, on the order of megabytes (MB) Speed Slow, hundreds to thousands of MB/s Fast, tens of GB/s Very fast, tens to hundreds of GB/s Cost (USD/GB) Inexpensive, fractions of a dollar to a few dollars per GB Expensive, tens to hundreds of dollars per GB Very expensive, priced as part of the CPU package <p>We can imagine the computer storage system as a pyramid structure as shown in the diagram below. Storage devices closer to the top of the pyramid are faster, have smaller capacity, and are more expensive. This multi-layered design is not by accident, but rather the result of careful consideration by computer scientists and engineers.</p> <ul> <li>Hard disk cannot be easily replaced by RAM. First, data in memory is lost after power-off, making it unsuitable for long-term data storage. Second, memory is tens of times more expensive than hard disk, which makes it difficult to popularize in the consumer market.</li> <li>Cache cannot simultaneously achieve large capacity and high speed. As the capacity of L1, L2, and L3 caches increases, their physical size becomes larger, and the physical distance between them and the CPU core increases, resulting in longer data transmission time and higher element access latency. With current technology, the multi-layered cache structure represents the best balance point between capacity, speed, and cost.</li> </ul> <p></p> <p> Figure 4-9   Computer Storage System </p> <p>Tip</p> <p>The storage hierarchy of computers embodies a delicate balance among speed, capacity, and cost. In fact, such trade-offs are common across all industrial fields, requiring us to find the optimal balance point between different advantages and constraints.</p> <p>In summary, hard disk is used for long-term storage of large amounts of data, RAM is used for temporary storage of data being processed during program execution, and cache is used for storage of frequently accessed data and instructions, to improve program execution efficiency. The three work together to ensure efficient operation of the computer system.</p> <p>As shown in the diagram below, during program execution, data is read from the hard disk into RAM for CPU computation. Cache can be viewed as part of the CPU, it intelligently loads data from RAM, providing the CPU with high-speed data reading, thereby significantly improving program execution efficiency and reducing reliance on slower RAM.</p> <p></p> <p> Figure 4-10   Data Flow Among Hard Disk, RAM, and Cache </p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442-memory-efficiency-of-data-structures","level":2,"title":"4.4.2   Memory Efficiency of Data Structures","text":"<p>In terms of memory space utilization, arrays and linked lists each have advantages and limitations.</p> <p>On one hand, memory is limited, and the same memory cannot be shared by multiple programs, so we hope data structures can utilize space as efficiently as possible. Array elements are tightly packed and do not require additional space to store references (pointers) between linked list nodes, thus having higher space efficiency. However, arrays need to allocate sufficient contiguous memory space at once, which may lead to memory waste, and array expansion requires additional time and space costs. In comparison, linked lists perform dynamic memory allocation and deallocation on a \"node\" basis, providing greater flexibility.</p> <p>On the other hand, during program execution, as memory is repeatedly allocated and freed, the degree of fragmentation of free memory becomes increasingly severe, leading to reduced memory utilization efficiency. Arrays, due to their contiguous storage approach, are relatively less prone to memory fragmentation. Conversely, linked list elements are distributed in storage, and frequent insertion and deletion operations are more likely to cause memory fragmentation.</p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443-cache-efficiency-of-data-structures","level":2,"title":"4.4.3   Cache Efficiency of Data Structures","text":"<p>Although cache has much smaller space capacity than memory, it is much faster than memory and plays a crucial role in program execution speed. Since cache capacity is limited and can only store a small portion of frequently accessed data, when the CPU attempts to access data that is not in the cache, a cache miss occurs, and the CPU must load the required data from the slower memory.</p> <p>Clearly, the fewer \"cache misses,\" the higher the efficiency of CPU data reads and writes, and the better the program performance. We call the proportion of data that the CPU successfully obtains from the cache the cache hit rate, a metric typically used to measure cache efficiency.</p> <p>To achieve the highest efficiency possible, cache employs the following data loading mechanisms.</p> <ul> <li>Cache lines: The cache does not store and load data on a byte-by-byte basis, but rather as cache lines. Compared to byte-by-byte transmission, cache line transmission is more efficient.</li> <li>Prefetching mechanism: The processor attempts to predict data access patterns (e.g., sequential access, fixed-stride jumping access, etc.) and loads data into the cache according to specific patterns, thereby improving hit rate.</li> <li>Spatial locality: If a piece of data is accessed, nearby data may also be accessed in the near future. Therefore, when the cache loads a particular piece of data, it also loads nearby data to improve hit rate.</li> <li>Temporal locality: If a piece of data is accessed, it is likely to be accessed again in the near future. Cache leverages this principle by retaining recently accessed data to improve hit rate.</li> </ul> <p>In fact, arrays and linked lists have different efficiencies in utilizing cache, manifested in the following aspects.</p> <ul> <li>Space occupied: Linked list elements occupy more space than array elements, resulting in fewer effective data in the cache.</li> <li>Cache lines: Linked list data are scattered throughout memory, while cache loads \"by lines,\" so the proportion of invalid data loaded is higher.</li> <li>Prefetching mechanism: Arrays have more \"predictable\" data access patterns than linked lists, making it easier for the system to guess which data will be loaded next.</li> <li>Spatial locality: Arrays are stored in centralized memory space, so data near loaded data is more likely to be accessed soon.</li> </ul> <p>Overall, arrays have higher cache hit rates, thus they usually outperform linked lists in operation efficiency. This makes data structures implemented based on arrays more popular when solving algorithmic problems.</p> <p>It is important to note that high cache efficiency does not mean arrays are superior to linked lists in all cases. In practical applications, which data structure to choose should be determined based on specific requirements. For example, both arrays and linked lists can implement the \"stack\" data structure (which will be discussed in detail in the next chapter), but they are suitable for different scenarios.</p> <ul> <li>When solving algorithm problems, we tend to prefer stack implementations based on arrays, because they provide higher operation efficiency and the ability of random access, at the cost of needing to pre-allocate a certain amount of memory space for the array.</li> <li>If the data volume is very large, the dynamic nature is high, and the expected size of the stack is difficult to estimate, then a stack implementation based on linked lists is more suitable. Linked lists can distribute large amounts of data across different parts of memory and avoid the additional overhead produced by array expansion.</li> </ul>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   Summary","text":"","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Arrays and linked lists are two fundamental data structures, representing two different ways data can be stored in computer memory: contiguous memory storage and scattered memory storage. The characteristics of the two complement each other.</li> <li>Arrays support random access and use less memory; however, inserting and deleting elements is inefficient, and the length is immutable after initialization.</li> <li>Linked lists achieve efficient insertion and deletion of nodes by modifying references (pointers), and can flexibly adjust length; however, node access is inefficient and memory consumption is higher. Common linked list types include singly linked lists, circular linked lists, and doubly linked lists.</li> <li>A list is an ordered collection of elements that supports insertion, deletion, search, and modification, typically implemented based on dynamic arrays. It retains the advantages of arrays while allowing flexible adjustment of length.</li> <li>The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space.</li> <li>During program execution, data is primarily stored in memory. Arrays provide higher memory space efficiency, while linked lists offer greater flexibility in memory usage.</li> <li>Caches provide fast data access to the CPU through mechanisms such as cache lines, prefetching, and spatial and temporal locality, significantly improving program execution efficiency.</li> <li>Because arrays have higher cache hit rates, they are generally more efficient than linked lists. When choosing a data structure, appropriate selection should be made based on specific requirements and scenarios.</li> </ul>","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Does storing an array on the stack versus on the heap affect time efficiency and space efficiency?</p> <p>Arrays stored on the stack and on the heap are both stored in contiguous memory space, so data operation efficiency is basically the same. However, the stack and heap have their own characteristics, leading to the following differences.</p> <ol> <li>Allocation and deallocation efficiency: The stack is a relatively small piece of memory, with allocation automatically handled by the compiler; the heap is relatively larger and can be dynamically allocated in code, more prone to fragmentation. Therefore, allocation and deallocation operations on the heap are usually slower than on the stack.</li> <li>Size limitations: Stack memory is relatively small, and the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays.</li> <li>Flexibility: The size of an array on the stack must be determined at compile time, while the size of an array on the heap can be determined dynamically at runtime.</li> </ol> <p>Q: Why do arrays require elements of the same type, while linked lists do not emphasize this requirement?</p> <p>Linked lists are composed of nodes, with nodes connected through references (pointers), and each node can store different types of data, such as <code>int</code>, <code>double</code>, <code>string</code>, <code>object</code>, etc.</p> <p>In contrast, array elements must be of the same type, so that the corresponding element position can be obtained by calculating the offset. For example, if an array contains both <code>int</code> and <code>long</code> types, with individual elements occupying 4 bytes and 8 bytes respectively, then the following formula cannot be used to calculate the offset, because the array contains two different \"element lengths\".</p> <pre><code># Element Memory Address = Array Memory Address (first Element Memory address) + Element Length * Element Index\n</code></pre> <p>Q: After deleting node <code>P</code>, do we need to set <code>P.next</code> to <code>None</code>?</p> <p>It is not necessary to modify <code>P.next</code>. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter <code>P</code>. This means that node <code>P</code> has been removed from the linked list, and it doesn't matter where node <code>P</code> points to at this time—it won't affect the linked list.</p> <p>From a data structures and algorithms perspective (problem-solving), not disconnecting the pointer doesn't matter as long as the program logic is correct. From the perspective of standard libraries, disconnecting is safer and the logic is clearer. If not disconnected, assuming the deleted node is not properly reclaimed, it may affect the memory reclamation of its successor nodes.</p> <p>Q: In a linked list, the time complexity of insertion and deletion operations is \\(O(1)\\). However, both insertion and deletion require \\(O(n)\\) time to find the element; why isn't the time complexity \\(O(n)\\)?</p> <p>If the element is first found and then deleted, the time complexity is indeed \\(O(n)\\). However, the advantage of \\(O(1)\\) insertion and deletion in linked lists can be demonstrated in other applications. For example, a deque is well-suited for linked list implementation, where we maintain pointer variables always pointing to the head and tail nodes, with each insertion and deletion operation being \\(O(1)\\).</p> <p>Q: In the diagram \"Linked List Definition and Storage Methods\", does the light blue pointer node occupy a single memory address, or does it share equally with the node value?</p> <p>This diagram is a qualitative representation; a quantitative representation requires analysis based on the specific situation.</p> <ul> <li>Different types of node values occupy different amounts of space, such as <code>int</code>, <code>long</code>, <code>double</code>, and instance objects, etc.</li> <li>The amount of memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes.</li> </ul> <p>Q: Is appending an element at the end of a list always \\(O(1)\\)?</p> <p>If appending an element exceeds the list length, the list must first be expanded before adding. The system allocates a new block of memory and moves all elements from the original list to it, in which case the time complexity becomes \\(O(n)\\).</p> <p>Q: \"The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space\"—does this space waste refer to the memory occupied by additional variables such as capacity, length, and expansion factor?</p> <p>This space waste mainly has two aspects: on one hand, lists typically set an initial length, which we may not need to fully utilize; on the other hand, to prevent frequent expansion, expansion generally multiplies by a coefficient, such as \\(\\times 1.5\\). As a result, there will be many empty positions that we typically cannot completely fill.</p> <p>Q: In Python, after initializing <code>n = [1, 2, 3]</code>, the addresses of these 3 elements are contiguous, but initializing <code>m = [2, 1, 3]</code> reveals that each element's id is not continuous; rather, they are the same as those in <code>n</code>. Since the addresses of these elements are not contiguous, is <code>m</code> still an array?</p> <p>If we replace list elements with linked list nodes <code>n = [n1, n2, n3, n4, n5]</code>, usually these 5 node objects are also scattered throughout memory. However, given a list index, we can still obtain the node memory address in \\(O(1)\\) time, thereby accessing the corresponding node. This is because the array stores references to nodes, not the nodes themselves.</p> <p>Unlike many languages, numbers in Python are wrapped as objects, and lists store not the numbers themselves, but references to the numbers. Therefore, we find that the same numbers in two arrays have the same id, and the memory addresses of these numbers need not be contiguous.</p> <p>Q: C++ STL has <code>std::list</code> which has already implemented a doubly linked list, but it seems that some algorithm books don't use it directly. Is there a limitation?</p> <p>On one hand, we often prefer to use arrays for implementing algorithms and only use linked lists when necessary, mainly for two reasons.</p> <ul> <li>Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next element), <code>std::list</code> typically consumes more space than <code>std::vector</code>.</li> <li>Cache unfriendliness: Since data is not stored contiguously, <code>std::list</code> has lower cache utilization. In general, <code>std::vector</code> has better performance.</li> </ul> <p>On the other hand, cases where linked lists are necessary mainly involve binary trees and graphs. Stacks and queues usually use the <code>stack</code> and <code>queue</code> provided by the programming language, rather than linked lists.</p> <p>Q: Does the operation <code>res = [[0]] * n</code> create a 2D list where each <code>[0]</code> is independent?</p> <p>No, they are not independent. In this 2D list, all the <code>[0]</code> are actually references to the same object. If we modify one element, we will find that all corresponding elements change accordingly.</p> <p>If we want each <code>[0]</code> in the 2D list to be independent, we can use <code>res = [[0] for _ in range(n)]</code> to achieve this. The principle of this approach is to initialize \\(n\\) independent <code>[0]</code> list objects.</p> <p>Q: Does the operation <code>res = [0] * n</code> create a list where each integer 0 is independent?</p> <p>In this list, all integer 0s are references to the same object. This is because Python uses a caching mechanism for small integers (typically -5 to 256) to maximize object reuse and improve performance.</p> <p>Although they point to the same object, we can still independently modify each element in the list. This is because Python integers are \"immutable objects\". When we modify an element, we are actually switching to a reference of another object, rather than changing the original object itself.</p> <p>However, when list elements are \"mutable objects\" (such as lists, dictionaries, or class instances), modifying an element directly changes the object itself, and all elements referencing that object will have the same change.</p>","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"Chapter 13.   Backtracking","text":"<p>Abstract</p> <p>We are like explorers in a maze, and may encounter difficulties on the path forward.</p> <p>The power of backtracking allows us to start over, keep trying, and eventually find the exit leading to light.</p>","path":["Chapter 13. Backtracking","Chapter 13. &nbsp; Backtracking"],"tags":[]},{"location":"chapter_backtracking/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>13.1   Backtracking Algorithm</li> <li>13.2   Permutations Problem</li> <li>13.3   Subset-Sum Problem</li> <li>13.4   N-Queens Problem</li> <li>13.5   Summary</li> </ul>","path":["Chapter 13. Backtracking","Chapter 13. &nbsp; Backtracking"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   Backtracking Algorithm","text":"<p>The backtracking algorithm is a method for solving problems through exhaustive search. Its core idea is to start from an initial state and exhaustively search all possible solutions. When a correct solution is found, it is recorded. This process continues until a solution is found or all possible choices have been tried without finding a solution.</p> <p>The backtracking algorithm typically employs \"depth-first search\" to traverse the solution space. In the \"Binary Tree\" chapter, we mentioned that preorder, inorder, and postorder traversals all belong to depth-first search. Next, we will construct a backtracking problem using preorder traversal to progressively understand how the backtracking algorithm works.</p> <p>Example 1</p> <p>Given a binary tree, search and record all nodes with value \\(7\\), and return a list of these nodes.</p> <p>For this problem, we perform a preorder traversal of the tree and check whether the current node's value is \\(7\\). If it is, we add the node to the result list <code>res</code>. The relevant implementation is shown in the following figure and code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # Record solution\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Record solution\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* Preorder traversal: Example 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Record solution\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* Preorder traversal: Example 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // Record solution\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* Preorder traversal: Example 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // Record solution\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* Preorder traversal: Example 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Record solution\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* Preorder traversal: Example 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Record solution\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // Record solution\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* Preorder traversal: Example 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Record solution\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* Preorder traversal: Example 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### Pre-order traversal: example 1 ###\ndef pre_order(root)\n  return unless root\n\n  # Record solution\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> <p></p> <p> Figure 13-1   Search for nodes in preorder traversal </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311-attempt-and-backtrack","level":2,"title":"13.1.1   Attempt and Backtrack","text":"<p>The reason it is called a backtracking algorithm is that it employs \"attempt\" and \"backtrack\" strategies when searching the solution space. When the algorithm encounters a state where it cannot continue forward or cannot find a solution that satisfies the constraints, it will undo the previous choice, return to a previous state, and try other possible choices.</p> <p>For Example 1, visiting each node represents an \"attempt\", while skipping over a leaf node or a function <code>return</code> from the parent node represents a \"backtrack\".</p> <p>It is worth noting that backtracking is not limited to function returns alone. To illustrate this, let's extend Example 1 slightly.</p> <p>Example 2</p> <p>In a binary tree, search all nodes with value \\(7\\), and return the paths from the root node to these nodes.</p> <p>Based on the code from Example 1, we need to use a list <code>path</code> to record the visited node path. When we reach a node with value \\(7\\), we copy <code>path</code> and add it to the result list <code>res</code>. After traversal is complete, <code>res</code> contains all the solutions. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 2\"\"\"\n    if root is None:\n        return\n    # Attempt\n    path.append(root)\n    if root.val == 7:\n        # Record solution\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Backtrack\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // Attempt\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // Attempt\n    path.add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Backtrack\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* Preorder traversal: Example 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // Attempt\n    path.Add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Backtrack\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* Preorder traversal: Example 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // Attempt\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Record solution\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // Backtrack\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* Preorder traversal: Example 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Attempt\n    path.append(root)\n    if root.val == 7 {\n        // Record solution\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Backtrack\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* Preorder traversal: Example 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* Preorder traversal: Example 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // Attempt\n  path.add(root);\n  if (root.val == 7) {\n    // Record solution\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Backtrack\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* Preorder traversal: Example 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // Attempt\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Backtrack\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // Attempt\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Record solution\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* Preorder traversal: Example 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // Attempt\n    path!!.add(root)\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Backtrack\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### Pre-order traversal: example 2 ###\ndef pre_order(root)\n  return unless root\n\n  # Attempt\n  $path &lt;&lt; root\n\n  # Record solution\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Backtrack\n  $path.pop\nend\n</code></pre> <p>In each \"attempt\", we record the path by adding the current node to <code>path</code>; before \"backtracking\", we need to remove the node from <code>path</code>, to restore the state before this attempt.</p> <p>Observing the process shown in the following figure, we can understand attempt and backtrack as \"advance\" and \"undo\", two operations that are the reverse of each other.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 13-2   Attempt and backtrack </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312-pruning","level":2,"title":"13.1.2   Pruning","text":"<p>Complex backtracking problems usually contain one or more constraints. Constraints can typically be used for \"pruning\".</p> <p>Example 3</p> <p>In a binary tree, search all nodes with value \\(7\\) and return the paths from the root node to these nodes, but require that the paths do not contain nodes with value \\(3\\).</p> <p>To satisfy the above constraints, we need to add pruning operations: during the search process, if we encounter a node with value \\(3\\), we return early and do not continue searching. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 3\"\"\"\n    # Pruning\n    if root is None or root.val == 3:\n        return\n    # Attempt\n    path.append(root)\n    if root.val == 7:\n        # Record solution\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Backtrack\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode *root) {\n    // Pruning\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // Attempt\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode root) {\n    // Pruning\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Attempt\n    path.add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Backtrack\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* Preorder traversal: Example 3 */\nvoid PreOrder(TreeNode? root) {\n    // Pruning\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Attempt\n    path.Add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Backtrack\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* Preorder traversal: Example 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // Pruning\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // Attempt\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Record solution\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // Backtrack\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* Preorder traversal: Example 3 */\nfunc preOrder(root: TreeNode?) {\n    // Pruning\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // Attempt\n    path.append(root)\n    if root.val == 7 {\n        // Record solution\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Backtrack\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* Preorder traversal: Example 3 */\nfunction preOrder(root, path, res) {\n    // Pruning\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* Preorder traversal: Example 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Pruning\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // Attempt\n  path.add(root);\n  if (root.val == 7) {\n    // Record solution\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Backtrack\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* Preorder traversal: Example 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // Pruning\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // Attempt\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Backtrack\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode *root) {\n    // Pruning\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // Attempt\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Record solution\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* Preorder traversal: Example 3 */\nfun preOrder(root: TreeNode?) {\n    // Pruning\n    if (root == null || root._val == 3) {\n        return\n    }\n    // Attempt\n    path!!.add(root)\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Backtrack\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### Pre-order traversal: example 3 ###\ndef pre_order(root)\n  # Pruning\n  return if !root || root.val == 3\n\n  # Attempt\n  $path.append(root)\n\n  # Record solution\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Backtrack\n  $path.pop\nend\n</code></pre> <p>\"Pruning\" is a vivid term. As shown in the following figure, during the search process, we \"prune\" search branches that do not satisfy the constraints, avoiding many meaningless attempts and thus improving search efficiency.</p> <p></p> <p> Figure 13-3   Pruning according to constraints </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313-framework-code","level":2,"title":"13.1.3   Framework Code","text":"<p>Next, we attempt to extract the main framework of backtracking's \"attempt, backtrack, and pruning\", to improve code generality.</p> <p>In the following framework code, <code>state</code> represents the current state of the problem, and <code>choices</code> represents the choices available in the current state:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"Backtracking algorithm framework\"\"\"\n    # Check if it is a solution\n    if is_solution(state):\n        # Record the solution\n        record_solution(state, res)\n        # Stop searching\n        return\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: check if the choice is valid\n        if is_valid(state, choice):\n            # Attempt: make a choice and update the state\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (Choice choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (Choice choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Check if it is a solution\n    if (IsSolution(state)) {\n        // Record the solution\n        RecordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    foreach (Choice choice in choices) {\n        // Pruning: check if the choice is valid\n        if (IsValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // Check if it is a solution\n    if isSolution(state) {\n        // Record the solution\n        recordSolution(state, res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for _, choice := range choices {\n        // Pruning: check if the choice is valid\n        if isValid(state, choice) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // Check if it is a solution\n    if isSolution(state: state) {\n        // Record the solution\n        recordSolution(state: state, res: &amp;res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if isValid(state: state, choice: choice) {\n            // Attempt: make a choice and update the state\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunction backtrack(state, choices, res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (let choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (let choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // Check if it is a solution\n  if (isSolution(state)) {\n    // Record the solution\n    recordSolution(state, res);\n    // Stop searching\n    return;\n  }\n  // Traverse all choices\n  for (Choice choice in choices) {\n    // Pruning: check if the choice is valid\n    if (isValid(state, choice)) {\n      // Attempt: make a choice and update the state\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // Backtrack: undo the choice and restore to the previous state\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // Check if it is a solution\n    if is_solution(state) {\n        // Record the solution\n        record_solution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if is_valid(state, choice) {\n            // Attempt: make a choice and update the state\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res, numRes);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; numChoices; i++) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, &amp;choices[i])) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### Backtracking algorithm framework ###\ndef backtrack(state, choices, res)\n    # Check if it is a solution\n    if is_solution?(state)\n        # Record the solution\n        record_solution(state, res)\n        return\n    end\n\n    # Traverse all choices\n    for choice in choices\n        # Pruning: check if the choice is valid\n        if is_valid?(state, choice)\n            # Attempt: make a choice and update the state\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>Next, we solve Example 3 based on the framework code. The state <code>state</code> is the node traversal path, the choices <code>choices</code> are the left and right child nodes of the current node, and the result <code>res</code> is a list of paths:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"Check if the current state is a solution\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"Record solution\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"Check if the choice is valid under the current state\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Update state\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Restore state\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"Backtracking algorithm: Example 3\"\"\"\n    # Check if it is a solution\n    if is_solution(state):\n        # Record solution\n        record_solution(state, res)\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: check if the choice is valid\n        if is_valid(state, choice):\n            # Attempt: make choice, update state\n            make_choice(state, choice)\n            # Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res)\n            # Backtrack: undo choice, restore to previous state\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* Check if the current state is a solution */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Update state */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* Restore state */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (TreeNode *choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* Check if the current state is a solution */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* Check if the choice is valid under the current state */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* Restore state */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (TreeNode choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* Check if the current state is a solution */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* Record solution */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* Check if the choice is valid under the current state */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* Restore state */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Check if it is a solution\n    if (IsSolution(state)) {\n        // Record solution\n        RecordSolution(state, res);\n    }\n    // Traverse all choices\n    foreach (TreeNode choice in choices) {\n        // Pruning: check if the choice is valid\n        if (IsValid(state, choice)) {\n            // Attempt: make choice, update state\n            MakeChoice(state, choice);\n            // Proceed to the next round of selection\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // Backtrack: undo choice, restore to previous state\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* Check if the current state is a solution */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* Record solution */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* Check if the choice is valid under the current state */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* Update state */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* Restore state */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* Backtracking algorithm: Example 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // Check if it is a solution\n    if isSolution(state) {\n        // Record solution\n        recordSolution(state, res)\n    }\n    // Traverse all choices\n    for _, choice := range *choices {\n        // Pruning: check if the choice is valid\n        if isValid(state, choice) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice)\n            // Proceed to the next round of selection\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* Check if the current state is a solution */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* Record solution */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* Check if the choice is valid under the current state */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* Update state */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* Restore state */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* Backtracking algorithm: Example 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // Check if it is a solution\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if isValid(state: state, choice: choice) {\n            // Attempt: make choice, update state\n            makeChoice(state: &amp;state, choice: choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* Check if the current state is a solution */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Record solution */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* Check if the choice is valid under the current state */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Update state */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* Restore state */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfunction backtrack(state, choices, res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* Check if the current state is a solution */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Record solution */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* Check if the choice is valid under the current state */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Update state */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* Restore state */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* Check if the current state is a solution */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* Restore state */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // Check if it is a solution\n  if (isSolution(state)) {\n    // Record solution\n    recordSolution(state, res);\n  }\n  // Traverse all choices\n  for (TreeNode? choice in choices) {\n    // Pruning: check if the choice is valid\n    if (isValid(state, choice)) {\n      // Attempt: make choice, update state\n      makeChoice(state, choice);\n      // Proceed to the next round of selection\n      backtrack(state, [choice!.left, choice.right], res);\n      // Backtrack: undo choice, restore to previous state\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* Check if the current state is a solution */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* Record solution */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* Check if the choice is valid under the current state */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* Update state */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* Restore state */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // Check if it is a solution\n    if is_solution(state) {\n        // Record solution\n        record_solution(state, res);\n    }\n    // Traverse all choices\n    for &amp;choice in choices.iter() {\n        // Pruning: check if the choice is valid\n        if is_valid(state, choice) {\n            // Attempt: make choice, update state\n            make_choice(state, choice.unwrap().clone());\n            // Proceed to the next round of selection\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // Backtrack: undo choice, restore to previous state\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* Check if the current state is a solution */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Update state */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* Restore state */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // Check if it is a solution\n    if (isSolution()) {\n        // Record solution\n        recordSolution();\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // Pruning: check if the choice is valid\n        if (isValid(choice)) {\n            // Attempt: make choice, update state\n            makeChoice(choice);\n            // Proceed to the next round of selection\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* Check if the current state is a solution */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* Record solution */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* Check if the choice is valid under the current state */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* Update state */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* Restore state */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* Backtracking algorithm: Example 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res)\n    }\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice)\n            // Proceed to the next round of selection\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### Check if current state is solution ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### Record solution ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### Check if choice is valid in current state ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### Update state ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### Restore state ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### Backtracking: example 3 ###\ndef backtrack(state, choices, res)\n  # Check if it is a solution\n  record_solution(state, res) if is_solution?(state)\n\n  # Traverse all choices\n  for choice in choices\n    # Pruning: check if the choice is valid\n    if is_valid?(state, choice)\n      # Attempt: make choice, update state\n      make_choice(state, choice)\n      # Proceed to the next round of selection\n      backtrack(state, [choice.left, choice.right], res)\n      # Backtrack: undo choice, restore to previous state\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> <p>As per the problem statement, we should continue searching after finding a node with value \\(7\\). Therefore, we need to remove the <code>return</code> statement after recording the solution. The following figure compares the search process with and without the <code>return</code> statement.</p> <p></p> <p> Figure 13-4   Comparison of search process with and without return statement </p> <p>Compared to code based on preorder traversal, code based on the backtracking algorithm framework appears more verbose, but has better generality. In fact, many backtracking problems can be solved within this framework. We only need to define <code>state</code> and <code>choices</code> for the specific problem and implement each method in the framework.</p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314-common-terminology","level":2,"title":"13.1.4   Common Terminology","text":"<p>To analyze algorithmic problems more clearly, we summarize the meanings of common terminology used in backtracking algorithms and provide corresponding examples from Example 3, as shown in the following table.</p> <p> Table 13-1   Common Backtracking Algorithm Terminology </p> Term Definition Example 3 Solution (solution) A solution is an answer that satisfies the specific conditions of a problem; there may be one or more solutions All paths from root to nodes with value \\(7\\) that satisfy the constraint Constraint (constraint) A constraint is a condition in the problem that limits the feasibility of solutions, typically used for pruning Paths do not contain nodes with value \\(3\\) State (state) State represents the situation of a problem at a certain moment, including the choices already made The currently visited node path, i.e., the <code>path</code> list of nodes Attempt (attempt) An attempt is the process of exploring the solution space according to available choices, including making choices, updating state, and checking if it is a solution Recursively visit left (right) child nodes, add nodes to <code>path</code>, check if node value is \\(7\\) Backtrack (backtracking) Backtracking refers to undoing previous choices and returning to a previous state when encountering a state that does not satisfy constraints Stop searching when passing over leaf nodes, ending node visits, or encountering nodes with value \\(3\\); function returns Pruning (pruning) Pruning is a method of avoiding meaningless search paths according to problem characteristics and constraints, which can improve search efficiency When encountering a node with value \\(3\\), do not continue searching <p>Tip</p> <p>The concepts of problem, solution, state, etc. are universal and are involved in divide-and-conquer, backtracking, dynamic programming, greedy and other algorithms.</p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315-advantages-and-limitations","level":2,"title":"13.1.5   Advantages and Limitations","text":"<p>The backtracking algorithm is essentially a depth-first search algorithm that tries all possible solutions until it finds one that satisfies the conditions. The advantage of this approach is that it can find all possible solutions, and with reasonable pruning operations, it achieves high efficiency.</p> <p>However, when dealing with large-scale or complex problems, the running efficiency of the backtracking algorithm may be unacceptable.</p> <ul> <li>Time: The backtracking algorithm usually needs to traverse all possibilities in the solution space, and the time complexity can reach exponential or factorial order.</li> <li>Space: During recursive calls, the current state needs to be saved (such as paths, auxiliary variables used for pruning, etc.), and when the depth is large, the space requirement can become very large.</li> </ul> <p>Nevertheless, the backtracking algorithm is still the best solution for certain search problems and constraint satisfaction problems. For these problems, since we cannot predict which choices will generate valid solutions, we must traverse all possible choices. In this case, the key is how to optimize efficiency. There are two common efficiency optimization methods.</p> <ul> <li>Pruning: Avoid searching paths that are guaranteed not to produce solutions, thereby saving time and space.</li> <li>Heuristic search: Introduce certain strategies or estimation values during the search process to prioritize searching paths that are most likely to produce valid solutions.</li> </ul>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316-typical-backtracking-examples","level":2,"title":"13.1.6   Typical Backtracking Examples","text":"<p>The backtracking algorithm can be used to solve many search problems, constraint satisfaction problems, and combinatorial optimization problems.</p> <p>Search problems: The goal of these problems is to find solutions that satisfy specific conditions.</p> <ul> <li>Permutation problem: Given a set, find all possible permutations and combinations.</li> <li>Subset sum problem: Given a set and a target sum, find all subsets in the set whose elements sum to the target.</li> <li>Tower of Hanoi: Given three pegs and a series of disks of different sizes, move all disks from one peg to another, moving only one disk at a time, and never placing a larger disk on a smaller disk.</li> </ul> <p>Constraint satisfaction problems: The goal of these problems is to find solutions that satisfy all constraints.</p> <ul> <li>N-Queens: Place \\(n\\) queens on an \\(n \\times n\\) chessboard such that they do not attack each other.</li> <li>Sudoku: Fill numbers \\(1\\) to \\(9\\) in a \\(9 \\times 9\\) grid such that each row, column, and \\(3 \\times 3\\) subgrid contains no repeated digits.</li> <li>Graph coloring: Given an undirected graph, color each vertex with the minimum number of colors such that adjacent vertices have different colors.</li> </ul> <p>Combinatorial optimization problems: The goal of these problems is to find an optimal solution that satisfies certain conditions in a combinatorial space.</p> <ul> <li>0-1 Knapsack: Given a set of items and a knapsack, each item has a value and weight. Under the knapsack capacity constraint, select items to maximize total value.</li> <li>Traveling Salesman Problem: Starting from a point in a graph, visit all other points exactly once and return to the starting point, finding the shortest path.</li> <li>Maximum Clique: Given an undirected graph, find the largest complete subgraph, i.e., a subgraph where any two vertices are connected by an edge.</li> </ul> <p>Note that for many combinatorial optimization problems, backtracking is not the optimal solution.</p> <ul> <li>The 0-1 Knapsack problem is usually solved using dynamic programming to achieve higher time efficiency.</li> <li>The Traveling Salesman Problem is a famous NP-Hard problem; common solutions include genetic algorithms and ant colony algorithms.</li> <li>The Maximum Clique problem is a classical problem in graph theory and can be solved using heuristic algorithms such as greedy algorithms.</li> </ul>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   N-Queens Problem","text":"<p>Question</p> <p>According to the rules of chess, a queen can attack pieces that share the same row, column, or diagonal line. Given \\(n\\) queens and an \\(n \\times n\\) chessboard, find a placement scheme such that no two queens can attack each other.</p> <p>As shown in Figure 13-15, when \\(n = 4\\), there are two solutions that can be found. From the perspective of the backtracking algorithm, an \\(n \\times n\\) chessboard has \\(n^2\\) squares, which provide all the choices <code>choices</code>. During the process of placing queens one by one, the chessboard state changes continuously, and the chessboard at each moment represents the state <code>state</code>.</p> <p></p> <p> Figure 13-15   Solution to the 4-queens problem </p> <p>Figure 13-16 illustrates the three constraints of this problem: multiple queens cannot be in the same row, the same column, or on the same diagonal. It is worth noting that diagonals are divided into two types: the main diagonal <code>\\</code> and the anti-diagonal <code>/</code>.</p> <p></p> <p> Figure 13-16   Constraints of the n-queens problem </p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1-row-by-row-placement-strategy","level":3,"title":"1.   Row-By-Row Placement Strategy","text":"<p>Since both the number of queens and the number of rows on the chessboard are \\(n\\), we can easily derive a conclusion: each row of the chessboard allows and only allows exactly one queen to be placed.</p> <p>This means we can adopt a row-by-row placement strategy: starting from the first row, place one queen in each row until the last row is completed.</p> <p>Figure 13-17 shows the row-by-row placement process for the 4-queens problem. Due to space limitations, the figure only expands one search branch of the first row, and all schemes that do not satisfy the column constraint and diagonal constraints are pruned.</p> <p></p> <p> Figure 13-17   Row-by-row placement strategy </p> <p>Essentially, the row-by-row placement strategy serves a pruning function, as it avoids all search branches where multiple queens appear in the same row.</p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2-column-and-diagonal-pruning","level":3,"title":"2.   Column and Diagonal Pruning","text":"<p>To satisfy the column constraint, we can use a boolean array <code>cols</code> of length \\(n\\) to record whether each column has a queen. Before each placement decision, we use <code>cols</code> to prune columns that already have queens, and dynamically update the state of <code>cols</code> during backtracking.</p> <p>Tip</p> <p>Please note that the origin of the matrix is located in the upper-left corner, where the row index increases from top to bottom, and the column index increases from left to right.</p> <p>So how do we handle diagonal constraints? Consider a square on the chessboard with row and column indices \\((row, col)\\). If we select a specific main diagonal in the matrix, we find that all squares on that diagonal have the same difference between their row and column indices, meaning that \\(row - col\\) is a constant value for all squares on the main diagonal.</p> <p>In other words, if two squares satisfy \\(row_1 - col_1 = row_2 - col_2\\), they must be on the same main diagonal. Using this pattern, we can use the array <code>diags1</code> shown in Figure 13-18 to record whether there is a queen on each main diagonal.</p> <p>Similarly, for all squares on an anti-diagonal, the sum \\(row + col\\) is a constant value. We can likewise use the array <code>diags2</code> to handle anti-diagonal constraints.</p> <p></p> <p> Figure 13-18   Handling column and diagonal constraints </p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>Please note that in an \\(n\\)-dimensional square matrix, the range of \\(row - col\\) is \\([-n + 1, n - 1]\\), and the range of \\(row + col\\) is \\([0, 2n - 2]\\). Therefore, the number of both main diagonals and anti-diagonals is \\(2n - 1\\), meaning the length of both arrays <code>diags1</code> and <code>diags2</code> is \\(2n - 1\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"Backtracking algorithm: N queens\"\"\"\n    # When all rows are placed, record the solution\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # Traverse all columns\n    for col in range(n):\n        # Calculate the main diagonal and anti-diagonal corresponding to this cell\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"Solve N queens\"\"\"\n    # Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # Record whether there is a queen in the column\n    diags1 = [False] * (2 * n - 1)  # Record whether there is a queen on the main diagonal\n    diags2 = [False] * (2 * n - 1)  # Record whether there is a queen on the anti-diagonal\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // Record whether there is a queen in the column\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // Record whether there is a queen on the main diagonal\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // Record whether there is a queen on the anti-diagonal\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // Record whether there is a queen in the column\n    boolean[] diags1 = new boolean[2 * n - 1]; // Record whether there is a queen on the main diagonal\n    boolean[] diags2 = new boolean[2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* Backtracking algorithm: N queens */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // Record whether there is a queen in the column\n    bool[] diags1 = new bool[2 * n - 1]; // Record whether there is a queen on the main diagonal\n    bool[] diags2 = new bool[2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* Backtracking algorithm: N queens */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // When all rows are placed, record the solution\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all columns\n    for col := 0; col &lt; n; col++ {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // Attempt: place the queen in this cell\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // Place the next row\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // Backtrack: restore this cell to an empty cell\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* Solve N queens */\nfunc nQueens(n int) [][][]string {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // Record whether there is a queen in the column\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* Backtracking algorithm: N queens */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // When all rows are placed, record the solution\n    if row == n {\n        res.append(state)\n        return\n    }\n    // Traverse all columns\n    for col in 0 ..&lt; n {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // Place the next row\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* Solve N queens */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // Record whether there is a queen in the column\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // Record whether there is a queen on the main diagonal\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // Record whether there is a queen on the anti-diagonal\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* Backtracking algorithm: N queens */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // When all rows are placed, record the solution\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Traverse all columns\n    for (let col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nfunction nQueens(n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Record whether there is a queen in the column\n    const diags1 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the main diagonal\n    const diags2 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the anti-diagonal\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* Backtracking algorithm: N queens */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // When all rows are placed, record the solution\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Traverse all columns\n    for (let col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nfunction nQueens(n: number): string[][][] {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Record whether there is a queen in the column\n    const diags1 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the main diagonal\n    const diags2 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the anti-diagonal\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // When all rows are placed, record the solution\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // Traverse all columns\n  for (int col = 0; col &lt; n; col++) {\n    // Calculate the main diagonal and anti-diagonal corresponding to this cell\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // Attempt: place the queen in this cell\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // Place the next row\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // Backtrack: restore this cell to an empty cell\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // Record whether there is a queen in the column\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // Record whether there is a queen on the main diagonal\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // Record whether there is a queen on the anti-diagonal\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* Backtracking algorithm: N queens */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // When all rows are placed, record the solution\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all columns\n    for col in 0..n {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* Solve N queens */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // Record whether there is a queen in the column\n    let mut diags1 = vec![false; 2 * n - 1]; // Record whether there is a queen on the main diagonal\n    let mut diags2 = vec![false; 2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // Record whether there is a queen in the column\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // Record whether there is a queen on the main diagonal\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // Record whether there is a queen on the anti-diagonal\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* Backtracking algorithm: N queens */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // Traverse all columns\n    for (col in 0..&lt;n) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* Solve N queens */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // Record whether there is a queen in the column\n    val diags1 = BooleanArray(2 * n - 1) // Record whether there is a queen on the main diagonal\n    val diags2 = BooleanArray(2 * n - 1) // Record whether there is a queen on the anti-diagonal\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### Backtracking: n queens ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # When all rows are placed, record the solution\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # Traverse all columns\n  for col in 0...n\n    # Calculate the main diagonal and anti-diagonal corresponding to this cell\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # Attempt: place the queen in this cell\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # Place the next row\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # Backtrack: restore this cell to an empty cell\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Solve n queens ###\ndef n_queens(n)\n  # Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # Record whether there is a queen in the column\n  diags1 = Array.new(2 * n - 1, false) # Record whether there is a queen on the main diagonal\n  diags2 = Array.new(2 * n - 1, false) # Record whether there is a queen on the anti-diagonal\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> <p>Placing \\(n\\) queens row by row, considering the column constraint, from the first row to the last row there are \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\) choices, using \\(O(n!)\\) time. When recording a solution, it is necessary to copy the matrix <code>state</code> and add it to <code>res</code>, and the copy operation uses \\(O(n^2)\\) time. Therefore, the overall time complexity is \\(O(n! \\cdot n^2)\\). In practice, pruning based on diagonal constraints can also significantly reduce the search space, so the search efficiency is often better than the time complexity mentioned above.</p> <p>The array <code>state</code> uses \\(O(n^2)\\) space, and the arrays <code>cols</code>, <code>diags1</code>, and <code>diags2</code> each use \\(O(n)\\) space. The maximum recursion depth is \\(n\\), using \\(O(n)\\) stack frame space. Therefore, the space complexity is \\(O(n^2)\\).</p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   Permutations Problem","text":"<p>The permutations problem is a classic application of backtracking algorithms. It is defined as finding all possible arrangements of elements in a given collection (such as an array or string).</p> <p>Table 13-2 shows several example datasets, including input arrays and their corresponding permutations.</p> <p> Table 13-2   Permutations Examples </p> Input Array All Permutations \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321-case-with-distinct-elements","level":2,"title":"13.2.1   Case with Distinct Elements","text":"<p>Question</p> <p>Given an integer array with no duplicate elements, return all possible permutations.</p> <p>From the perspective of backtracking algorithms, we can imagine the process of generating permutations as the result of a series of choices. Suppose the input array is \\([1, 2, 3]\\). If we first choose \\(1\\), then choose \\(3\\), and finally choose \\(2\\), we obtain the permutation \\([1, 3, 2]\\). Backtracking means undoing a choice and then trying other choices.</p> <p>From the perspective of backtracking code, the candidate set <code>choices</code> consists of all elements in the input array, and the state <code>state</code> is the elements that have been chosen so far. Note that each element can only be chosen once, therefore all elements in <code>state</code> should be unique.</p> <p>As shown in Figure 13-5, we can unfold the search process into a recursion tree, where each node in the tree represents the current state <code>state</code>. Starting from the root node, after three rounds of choices, we reach a leaf node, and each leaf node corresponds to a permutation.</p> <p></p> <p> Figure 13-5   Recursion tree of permutations </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1-pruning-duplicate-choices","level":3,"title":"1.   Pruning Duplicate Choices","text":"<p>To ensure that each element is chosen only once, we consider introducing a boolean array <code>selected</code>, where <code>selected[i]</code> indicates whether <code>choices[i]</code> has been chosen. We implement the following pruning operation based on it.</p> <ul> <li>After making a choice <code>choice[i]</code>, we set <code>selected[i]</code> to \\(\\text{True}\\), indicating that it has been chosen.</li> <li>When traversing the candidate list <code>choices</code>, we skip all nodes that have been chosen, which is pruning.</li> </ul> <p>As shown in Figure 13-6, suppose we choose \\(1\\) in the first round, \\(3\\) in the second round, and \\(2\\) in the third round. Then we need to prune the branch of element \\(1\\) in the second round and prune the branches of elements \\(1\\) and \\(3\\) in the third round.</p> <p></p> <p> Figure 13-6   Pruning example of permutations </p> <p>Observing the above figure, we find that this pruning operation reduces the search space size from \\(O(n^n)\\) to \\(O(n!)\\).</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>After understanding the above information, we can fill in the blanks in the template code. To shorten the overall code, we do not implement each function in the template separately, but instead unfold them in the <code>backtrack()</code> function:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Permutations I\"\"\"\n    # When the state length equals the number of elements, record the solution\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Traverse all choices\n    for i, choice in enumerate(choices):\n        # Pruning: do not allow repeated selection of elements\n        if not selected[i]:\n            # Attempt: make choice, update state\n            selected[i] = True\n            state.append(choice)\n            # Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            # Backtrack: undo choice, restore to previous state\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Permutations I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push_back(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Permutations I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.add(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Permutations I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* Backtracking algorithm: Permutations I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.Add(choice);\n            // Proceed to the next round of selection\n            Backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Permutations I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* Backtracking algorithm: Permutations I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // When the state length equals the number of elements, record the solution\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Traverse all choices\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Pruning: do not allow repeated selection of elements\n        if !(*selected)[i] {\n            // Attempt: make choice, update state\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Proceed to the next round of selection\n            backtrackI(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Permutations I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* Backtracking algorithm: Permutations I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // When the state length equals the number of elements, record the solution\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    for (i, choice) in choices.enumerated() {\n        // Pruning: do not allow repeated selection of elements\n        if !selected[i] {\n            // Attempt: make choice, update state\n            selected[i] = true\n            state.append(choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Permutations I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* Backtracking algorithm: Permutations I */\nfunction backtrack(state, choices, selected, res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* Backtracking algorithm: Permutations I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the state length equals the number of elements, record the solution\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Pruning: do not allow repeated selection of elements\n    if (!selected[i]) {\n      // Attempt: make choice, update state\n      selected[i] = true;\n      state.add(choice);\n      // Proceed to the next round of selection\n      backtrack(state, choices, selected, res);\n      // Backtrack: undo choice, restore to previous state\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Permutations I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* Backtracking algorithm: Permutations I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // When the state length equals the number of elements, record the solution\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Traverse all choices\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if !selected[i] {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state.clone(), choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Permutations I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // State (subset)\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // When the state length equals the number of elements, record the solution\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Proceed to the next round of selection\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n        }\n    }\n}\n\n/* Permutations I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* Backtracking algorithm: Permutations I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true\n            state.add(choice)\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Permutations I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### Backtracking: permutations I ###\ndef backtrack(state, choices, selected, res)\n  # When the state length equals the number of elements, record the solution\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  choices.each_with_index do |choice, i|\n    # Pruning: do not allow repeated selection of elements\n    unless selected[i]\n      # Attempt: make choice, update state\n      selected[i] = true\n      state &lt;&lt; choice\n      # Proceed to the next round of selection\n      backtrack(state, choices, selected, res)\n      # Backtrack: undo choice, restore to previous state\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Permutations I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322-case-with-duplicate-elements","level":2,"title":"13.2.2   Case with Duplicate Elements","text":"<p>Question</p> <p>Given an integer array that may contain duplicate elements, return all unique permutations.</p> <p>Suppose the input array is \\([1, 1, 2]\\). To distinguish the two duplicate elements \\(1\\), we denote the second \\(1\\) as \\(\\hat{1}\\).</p> <p>As shown in Figure 13-7, the method described above generates permutations where half are duplicates.</p> <p></p> <p> Figure 13-7   Duplicate permutations </p> <p>So how do we remove duplicate permutations? The most direct approach is to use a hash set to directly deduplicate the permutation results. However, this is not elegant because the search branches that generate duplicate permutations are unnecessary and should be identified and pruned early, which can further improve algorithm efficiency.</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1-pruning-duplicate-elements","level":3,"title":"1.   Pruning Duplicate Elements","text":"<p>Observe Figure 13-8. In the first round, choosing \\(1\\) or choosing \\(\\hat{1}\\) is equivalent. All permutations generated under these two choices are duplicates. Therefore, we should prune \\(\\hat{1}\\).</p> <p>Similarly, after choosing \\(2\\) in the first round, the \\(1\\) and \\(\\hat{1}\\) in the second round also produce duplicate branches, so the second round's \\(\\hat{1}\\) should also be pruned.</p> <p>Essentially, our goal is to ensure that multiple equal elements are chosen only once in a certain round of choices.</p> <p></p> <p> Figure 13-8   Pruning duplicate permutations </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2-code-implementation_1","level":3,"title":"2.   Code Implementation","text":"<p>Building on the code from the previous problem, we consider opening a hash set <code>duplicated</code> in each round of choices to record which elements have been tried in this round, and prune duplicate elements:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Permutations II\"\"\"\n    # When the state length equals the number of elements, record the solution\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Traverse all choices\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if not selected[i] and choice not in duplicated:\n            # Attempt: make choice, update state\n            duplicated.add(choice)  # Record the selected element value\n            selected[i] = True\n            state.append(choice)\n            # Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            # Backtrack: undo choice, restore to previous state\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Permutations II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // Attempt: make choice, update state\n            duplicated.emplace(choice); // Record the selected element value\n            selected[i] = true;\n            state.push_back(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Permutations II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.add(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Permutations II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* Backtracking algorithm: Permutations II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.Add(choice); // Record the selected element value\n            selected[i] = true;\n            state.Add(choice);\n            // Proceed to the next round of selection\n            Backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Permutations II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* Backtracking algorithm: Permutations II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // When the state length equals the number of elements, record the solution\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Traverse all choices\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // Attempt: make choice, update state\n            // Record the selected element value\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Proceed to the next round of selection\n            backtrackII(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Permutations II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* Backtracking algorithm: Permutations II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // When the state length equals the number of elements, record the solution\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if !selected[i], !duplicated.contains(choice) {\n            // Attempt: make choice, update state\n            duplicated.insert(choice) // Record the selected element value\n            selected[i] = true\n            state.append(choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Permutations II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* Backtracking algorithm: Permutations II */\nfunction backtrack(state, choices, selected, res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* Backtracking algorithm: Permutations II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the state length equals the number of elements, record the solution\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // Attempt: make choice, update state\n      duplicated.add(choice); // Record the selected element value\n      selected[i] = true;\n      state.add(choice);\n      // Proceed to the next round of selection\n      backtrack(state, choices, selected, res);\n      // Backtrack: undo choice, restore to previous state\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Permutations II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* Backtracking algorithm: Permutations II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // When the state length equals the number of elements, record the solution\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Traverse all choices\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // Attempt: make choice, update state\n            duplicated.insert(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state.clone(), choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Permutations II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // When the state length equals the number of elements, record the solution\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all choices\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // Attempt: make choice, update state\n            duplicated[choice] = true; // Record the selected element value\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Proceed to the next round of selection\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n        }\n    }\n}\n\n/* Permutations II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* Backtracking algorithm: Permutations II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice) // Record the selected element value\n            selected[i] = true\n            state.add(choice)\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Permutations II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### Backtracking: permutations II ###\ndef backtrack(state, choices, selected, res)\n  # When the state length equals the number of elements, record the solution\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # Attempt: make choice, update state\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # Proceed to the next round of selection\n      backtrack(state, choices, selected, res)\n      # Backtrack: undo choice, restore to previous state\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Permutations II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> <p>Assuming elements are pairwise distinct, there are \\(n!\\) (factorial) permutations of \\(n\\) elements. When recording results, we need to copy a list of length \\(n\\), using \\(O(n)\\) time. Therefore, the time complexity is \\(O(n! \\cdot n)\\).</p> <p>The maximum recursion depth is \\(n\\), using \\(O(n)\\) stack frame space. <code>selected</code> uses \\(O(n)\\) space. At most \\(n\\) <code>duplicated</code> sets exist simultaneously, using \\(O(n^2)\\) space. Therefore, the space complexity is \\(O(n^2)\\).</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3-comparison-of-two-pruning-methods","level":3,"title":"3.   Comparison of Two Pruning Methods","text":"<p>Note that although both <code>selected</code> and <code>duplicated</code> are used for pruning, they have different objectives.</p> <ul> <li>Pruning duplicate choices: There is only one <code>selected</code> throughout the entire search process. It records which elements are included in the current state, and its purpose is to prevent an element from appearing repeatedly in <code>state</code>.</li> <li>Pruning duplicate elements: Each round of choices (each <code>backtrack</code> function call) contains a <code>duplicated</code> set. It records which elements have been chosen in this round's iteration (the <code>for</code> loop), and its purpose is to ensure that equal elements are chosen only once.</li> </ul> <p>Figure 13-9 shows the effective scope of the two pruning conditions. Note that each node in the tree represents a choice, and the nodes on the path from the root to a leaf node form a permutation.</p> <p></p> <p> Figure 13-9   Effective scope of two pruning conditions </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   Subset-Sum Problem","text":"","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331-without-duplicate-elements","level":2,"title":"13.3.1   Without Duplicate Elements","text":"<p>Question</p> <p>Given a positive integer array <code>nums</code> and a target positive integer <code>target</code>, find all possible combinations where the sum of elements in the combination equals <code>target</code>. The given array has no duplicate elements, and each element can be selected multiple times. Return these combinations in list form, where the list should not contain duplicate combinations.</p> <p>For example, given the set \\(\\{3, 4, 5\\}\\) and target integer \\(9\\), the solutions are \\(\\{3, 3, 3\\}, \\{4, 5\\}\\). Note the following two points:</p> <ul> <li>Elements in the input set can be selected repeatedly without limit.</li> <li>Subsets do not distinguish element order; for example, \\(\\{4, 5\\}\\) and \\(\\{5, 4\\}\\) are the same subset.</li> </ul>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1-reference-to-full-permutation-solution","level":3,"title":"1.   Reference to Full Permutation Solution","text":"<p>Similar to the full permutation problem, we can imagine the process of generating subsets as a series of choices, and update the \"sum of elements\" in real-time during the selection process. When the sum equals <code>target</code>, we record the subset to the result list.</p> <p>Unlike the full permutation problem, elements in this problem's set can be selected unlimited times, so we do not need to use a <code>selected</code> boolean list to track whether an element has been selected. We can make minor modifications to the full permutation code and initially obtain the solution:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"Backtracking algorithm: Subset sum I\"\"\"\n    # When the subset sum equals target, record the solution\n    if total == target:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    for i in range(len(choices)):\n        # Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target:\n            continue\n        # Attempt: make choice, update element sum total\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum I (including duplicate subsets)\"\"\"\n    state = []  # State (subset)\n    total = 0  # Subset sum\n    res = []  # Result list (subset list)\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // State (subset)\n    int total = 0;           // Subset sum\n    vector&lt;vector&lt;int&gt;&gt; res; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    int total = 0; // Subset sum\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    int total = 0; // Subset sum\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    for i := 0; i &lt; len(*choices); i++ {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    total := 0              // Subset sum\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if total == target {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    for i in choices.indices {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let total = 0 // Subset sum\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(state, target, total, choices, res) {\n    // When the subset sum equals target, record the solution\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // State (subset)\n    const total = 0; // Subset sum\n    const res = []; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    const total = 0; // Subset sum\n    const res = []; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  for (int i = 0; i &lt; choices.length; i++) {\n    // Pruning: if the subset sum exceeds target, skip this choice\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // Attempt: make choice, update element sum total\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target, total + choices[i], choices, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  int total = 0; // Sum of elements\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* Backtracking algorithm: Subset sum I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    for i in 0..choices.len() {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    let total = 0; // Subset sum\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state[stateSize++] = choices[i];\n        // Proceed to the next round of selection\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // Initialize solution count to 0\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* Backtracking algorithm: Subset sum I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    for (i in choices.indices) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    val total = 0 // Subset sum\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### Backtracking: subset sum I ###\ndef backtrack(state, target, total, choices, res)\n  # When the subset sum equals target, record the solution\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  for i in 0...choices.length\n    # Pruning: if the subset sum exceeds target, skip this choice\n    next if total + choices[i] &gt; target\n    # Attempt: make choice, update element sum total\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target, total + choices[i], choices, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum I (with duplicate subsets) ###\ndef subset_sum_i_naive(nums, target)\n  state = [] # State (subset)\n  total = 0 # Subset sum\n  res = [] # Result list (subset list)\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> <p>When we input array \\([3, 4, 5]\\) and target element \\(9\\) to the above code, the output is \\([3, 3, 3], [4, 5], [5, 4]\\). Although we successfully find all subsets that sum to \\(9\\), there are duplicate subsets \\([4, 5]\\) and \\([5, 4]\\).</p> <p>This is because the search process distinguishes the order of selections, but subsets do not distinguish selection order. As shown in Figure 13-10, selecting 4 first and then 5 versus selecting 5 first and then 4 are different branches, but they correspond to the same subset.</p> <p></p> <p> Figure 13-10   Subset search and boundary pruning </p> <p>To eliminate duplicate subsets, one straightforward idea is to deduplicate the result list. However, this approach is very inefficient for two reasons:</p> <ul> <li>When there are many array elements, especially when <code>target</code> is large, the search process generates many duplicate subsets.</li> <li>Comparing subsets (arrays) is very time-consuming, requiring sorting the arrays first, then comparing each element in them.</li> </ul>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2-pruning-duplicate-subsets","level":3,"title":"2.   Pruning Duplicate Subsets","text":"<p>We consider deduplication through pruning during the search process. Observing Figure 13-11, duplicate subsets occur when array elements are selected in different orders, as in the following cases:</p> <ol> <li>When the first and second rounds select \\(3\\) and \\(4\\) respectively, all subsets containing these two elements are generated, denoted as \\([3, 4, \\dots]\\).</li> <li>Afterward, when the first round selects \\(4\\), the second round should skip \\(3\\), because the subset \\([4, 3, \\dots]\\) generated by this choice is completely duplicate with the subset generated in step <code>1.</code></li> </ol> <p>In the search process, each level's choices are tried from left to right, so the rightmost branches are pruned more.</p> <ol> <li>The first two rounds select \\(3\\) and \\(5\\), generating subset \\([3, 5, \\dots]\\).</li> <li>The first two rounds select \\(4\\) and \\(5\\), generating subset \\([4, 5, \\dots]\\).</li> <li>If the first round selects \\(5\\), the second round should skip \\(3\\) and \\(4\\), because subsets \\([5, 3, \\dots]\\) and \\([5, 4, \\dots]\\) are completely duplicate with the subsets described in steps <code>1.</code> and <code>2.</code></li> </ol> <p></p> <p> Figure 13-11   Different selection orders leading to duplicate subsets </p> <p>In summary, given an input array \\([x_1, x_2, \\dots, x_n]\\), let the selection sequence in the search process be \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\). This selection sequence must satisfy \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\); any selection sequence that does not satisfy this condition will cause duplicates and should be pruned.</p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>To implement this pruning, we initialize a variable <code>start</code> to indicate the starting point of traversal. After making choice \\(x_{i}\\), set the next round to start traversal from index \\(i\\). This ensures that the selection sequence satisfies \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\), guaranteeing subset uniqueness.</p> <p>In addition, we have made the following two optimizations to the code:</p> <ul> <li>Before starting the search, first sort the array <code>nums</code>. When traversing all choices, end the loop immediately when the subset sum exceeds <code>target</code>, because subsequent elements are larger, and their subset sums must exceed <code>target</code>.</li> <li>Omit the element sum variable <code>total</code> and use subtraction on <code>target</code> to track the sum of elements. Record the solution when <code>target</code> equals \\(0\\).</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Subset sum I\"\"\"\n    # When the subset sum equals target, record the solution\n    if target == 0:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    # Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in range(start, len(choices)):\n        # Pruning 1: if the subset sum exceeds target, end the loop directly\n        # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0:\n            break\n        # Attempt: make choice, update target, start\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum I\"\"\"\n    state = []  # State (subset)\n    nums.sort()  # Sort nums\n    start = 0  # Start point for traversal\n    res = []  # Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // State (subset)\n    sort(nums.begin(), nums.end()); // Sort nums\n    int start = 0;                  // Start point for traversal\n    vector&lt;vector&lt;int&gt;&gt; res;        // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    Arrays.sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    Array.Sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i := start; i &lt; len(*choices); i++ {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Attempt: make choice, update target, start\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    sort.Ints(nums)         // Sort nums\n    start := 0              // Start point for traversal\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in choices.indices.dropFirst(start) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Attempt: make choice, update target, start\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let nums = nums.sorted() // Sort nums\n    let start = 0 // Start point for traversal\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(state, target, choices, start, res) {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfunction subsetSumI(nums, target) {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  // Pruning 2: start traversing from start to avoid generating duplicate subsets\n  for (int i = start; i &lt; choices.length; i++) {\n    // Pruning 1: if the subset sum exceeds target, end the loop directly\n    // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Attempt: make choice, update target, start\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  nums.sort(); // Sort nums\n  int start = 0; // Start point for traversal\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* Backtracking algorithm: Subset sum I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in start..choices.len() {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    nums.sort(); // Sort nums\n    let start = 0; // Start point for traversal\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Proceed to the next round of selection\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // Sort nums\n    int start = 0;                           // Start point for traversal\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* Backtracking algorithm: Subset sum I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (i in start..&lt;choices.size) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    nums.sort() // Sort nums\n    val start = 0 // Start point for traversal\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### Backtracking: subset sum I ###\ndef backtrack(state, target, choices, start, res)\n  # When the subset sum equals target, record the solution\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # Traverse all choices\n  # Pruning 2: start traversing from start to avoid generating duplicate subsets\n  for i in start...choices.length\n    # Pruning 1: if the subset sum exceeds target, end the loop directly\n    # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    break if target - choices[i] &lt; 0\n    # Attempt: make choice, update target, start\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum I ###\ndef subset_sum_i(nums, target)\n  state = [] # State (subset)\n  nums.sort! # Sort nums\n  start = 0 # Start point for traversal\n  res = [] # Result list (subset list)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> <p>Figure 13-12 shows the complete backtracking process when array \\([3, 4, 5]\\) and target element \\(9\\) are input to the above code.</p> <p></p> <p> Figure 13-12   Subset-sum I backtracking process </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332-with-duplicate-elements-in-array","level":2,"title":"13.3.2   With Duplicate Elements in Array","text":"<p>Question</p> <p>Given a positive integer array <code>nums</code> and a target positive integer <code>target</code>, find all possible combinations where the sum of elements in the combination equals <code>target</code>. The given array may contain duplicate elements, and each element can be selected at most once. Return these combinations in list form, where the list should not contain duplicate combinations.</p> <p>Compared to the previous problem, the input array in this problem may contain duplicate elements, which introduces new challenges. For example, given array \\([4, \\hat{4}, 5]\\) and target element \\(9\\), the output of the existing code is \\([4, 5], [\\hat{4}, 5]\\), which contains duplicate subsets.</p> <p>The reason for this duplication is that equal elements are selected multiple times in a certain round. In Figure 13-13, the first round has three choices, two of which are \\(4\\), creating two duplicate search branches that output duplicate subsets. Similarly, the two \\(4\\)'s in the second round also produce duplicate subsets.</p> <p></p> <p> Figure 13-13   Duplicate subsets caused by equal elements </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1-pruning-equal-elements","level":3,"title":"1.   Pruning Equal Elements","text":"<p>To solve this problem, we need to limit equal elements to be selected only once in each round. The implementation is quite clever: since the array is already sorted, equal elements are adjacent. This means that in a certain round of selection, if the current element equals the element to its left, it means this element has already been selected, so we skip the current element directly.</p> <p>At the same time, this problem specifies that each array element can only be selected once. Fortunately, we can also use the variable <code>start</code> to satisfy this constraint: after making choice \\(x_{i}\\), set the next round to start traversal from index \\(i + 1\\) onwards. This both eliminates duplicate subsets and avoids selecting elements multiple times.</p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Subset sum II\"\"\"\n    # When the subset sum equals target, record the solution\n    if target == 0:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    # Pruning 2: start traversing from start to avoid generating duplicate subsets\n    # Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in range(start, len(choices)):\n        # Pruning 1: if the subset sum exceeds target, end the loop directly\n        # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0:\n            break\n        # Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # Attempt: make choice, update target, start\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum II\"\"\"\n    state = []  # State (subset)\n    nums.sort()  # Sort nums\n    start = 0  # Start point for traversal\n    res = []  # Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // State (subset)\n    sort(nums.begin(), nums.end()); // Sort nums\n    int start = 0;                  // Start point for traversal\n    vector&lt;vector&lt;int&gt;&gt; res;        // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    Arrays.sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    Array.Sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* Backtracking algorithm: Subset sum II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i := start; i &lt; len(*choices); i++ {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    sort.Ints(nums)         // Sort nums\n    start := 0              // Start point for traversal\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* Backtracking algorithm: Subset sum II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in choices.indices.dropFirst(start) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let nums = nums.sorted() // Sort nums\n    let start = 0 // Start point for traversal\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* Backtracking algorithm: Subset sum II */\nfunction backtrack(state, target, choices, start, res) {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfunction subsetSumII(nums, target) {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* Backtracking algorithm: Subset sum II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  // Pruning 2: start traversing from start to avoid generating duplicate subsets\n  // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n  for (int i = start; i &lt; choices.length; i++) {\n    // Pruning 1: if the subset sum exceeds target, end the loop directly\n    // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // Attempt: make choice, update target, start\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  nums.sort(); // Sort nums\n  int start = 0; // Start point for traversal\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* Backtracking algorithm: Subset sum II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in start..choices.len() {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    nums.sort(); // Sort nums\n    let start = 0; // Start point for traversal\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Pruning 1: Skip if subset sum exceeds target\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Proceed to the next round of selection\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // Sort nums\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // Start backtracking\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* Backtracking algorithm: Subset sum II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (i in start..&lt;choices.size) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    nums.sort() // Sort nums\n    val start = 0 // Start point for traversal\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### Backtracking: subset sum II ###\ndef backtrack(state, target, choices, start, res)\n  # When the subset sum equals target, record the solution\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  # Pruning 2: start traversing from start to avoid generating duplicate subsets\n  # Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n  for i in start...choices.length\n    # Pruning 1: if the subset sum exceeds target, end the loop directly\n    # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    break if target - choices[i] &lt; 0\n    # Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # Attempt: make choice, update target, start\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum II ###\ndef subset_sum_ii(nums, target)\n  state = [] # State (subset)\n  nums.sort! # Sort nums\n  start = 0 # Start point for traversal\n  res = [] # Result list (subset list)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> <p>Figure 13-14 shows the backtracking process for array \\([4, 4, 5]\\) and target element \\(9\\), which includes four types of pruning operations. Combine the illustration with the code comments to understand the entire search process and how each pruning operation works.</p> <p></p> <p> Figure 13-14   Subset-sum II backtracking process </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   Summary","text":"","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>The backtracking algorithm is fundamentally an exhaustive search method. It finds solutions that meet specified conditions by performing a depth-first traversal of the solution space. During the search process, when a solution satisfying the conditions is found, it is recorded. The search ends either after finding all solutions or when the traversal is complete.</li> <li>The backtracking algorithm search process consists of two parts: attempting and backtracking. It tries various choices through depth-first search. When encountering situations that violate constraints, it reverts the previous choice, returns to the previous state, and continues exploring other options. Attempting and backtracking are operations in opposite directions.</li> <li>Backtracking problems typically contain multiple constraints, which can be utilized to implement pruning operations. Pruning can terminate unnecessary search branches early, significantly improving search efficiency.</li> <li>The backtracking algorithm is primarily used to solve search problems and constraint satisfaction problems. While combinatorial optimization problems can be solved with backtracking, there are often more efficient or better-performing solutions available.</li> <li>The permutation problem aims to find all possible permutations of elements in a given set. We use an array to record whether each element has been selected, thereby pruning search branches that attempt to select the same element repeatedly, ensuring each element is selected exactly once.</li> <li>In the permutation problem, if the set contains duplicate elements, the final result will contain duplicate permutations. We need to impose a constraint so that equal elements can only be selected once per round, which is typically achieved using a hash set.</li> <li>The subset-sum problem aims to find all subsets of a given set that sum to a target value. Since the set is unordered but the search process outputs results in all orders, duplicate subsets are generated. We sort the data before backtracking and use a variable to indicate the starting point of each round's traversal, thereby pruning search branches that generate duplicate subsets.</li> <li>For the subset-sum problem, equal elements in the array produce duplicate sets. We leverage the precondition that the array is sorted by checking whether adjacent elements are equal to implement pruning, ensuring that equal elements can only be selected once per round.</li> <li>The \\(n\\) queens problem aims to find placements of \\(n\\) queens on an \\(n \\times n\\) chessboard such that no two queens can attack each other. The constraints of this problem include row constraints, column constraints, and main and anti-diagonal constraints. To satisfy row constraints, we adopt a row-by-row placement strategy, ensuring exactly one queen is placed in each row.</li> <li>The handling of column constraints and diagonal constraints is similar. For column constraints, we use an array to record whether each column has a queen, thereby indicating whether a selected cell is valid. For diagonal constraints, we use two arrays to separately record whether queens exist on each main or anti-diagonal. The challenge lies in finding the row-column index pattern that characterizes cells on the same main (anti-)diagonal.</li> </ul>","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: How should we understand the relationship between backtracking and recursion?</p> <p>Overall, backtracking is an \"algorithm strategy\", while recursion is more like a \"tool\".</p> <ul> <li>The backtracking algorithm is typically implemented based on recursion. However, backtracking is one application scenario of recursion and represents the application of recursion in search problems.</li> <li>The structure of recursion embodies the \"subproblem decomposition\" problem-solving paradigm, commonly used to solve problems involving divide-and-conquer, backtracking, and dynamic programming (memoized recursion).</li> </ul>","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"Chapter 2.   Complexity Analysis","text":"<p>Abstract</p> <p>Complexity analysis is like a space-time guide in the vast universe of algorithms.</p> <p>It leads us to explore deeply within the two dimensions of time and space, seeking more elegant solutions.</p>","path":["Chapter 2. Complexity Analysis","Chapter 2. &nbsp; Complexity Analysis"],"tags":[]},{"location":"chapter_computational_complexity/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>2.1   Algorithm Efficiency Evaluation</li> <li>2.2   Iteration and Recursion</li> <li>2.3   Time Complexity</li> <li>2.4   Space Complexity</li> <li>2.5   Summary</li> </ul>","path":["Chapter 2. Complexity Analysis","Chapter 2. &nbsp; Complexity Analysis"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   Iteration and Recursion","text":"<p>In algorithms, repeatedly executing a task is very common and closely related to complexity analysis. Therefore, before introducing time complexity and space complexity, let's first understand how to implement repeated task execution in programs, namely the two basic program control structures: iteration and recursion.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221-iteration","level":2,"title":"2.2.1   Iteration","text":"<p>Iteration is a control structure for repeatedly executing a task. In iteration, a program repeatedly executes a segment of code under certain conditions until those conditions are no longer satisfied.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for-loop","level":3,"title":"1.   For Loop","text":"<p>The <code>for</code> loop is one of the most common forms of iteration, suitable for use when the number of iterations is known in advance.</p> <p>The following function implements the summation \\(1 + 2 + \\dots + n\\) based on a <code>for</code> loop, with the sum result recorded using the variable <code>res</code>. Note that in Python, <code>range(a, b)</code> corresponds to a \"left-closed, right-open\" interval, with the traversal range being \\(a, a + 1, \\dots, b-1\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for loop\"\"\"\n    res = 0\n    # Sum 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for loop */\nint ForLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for loop */\nfunc forLoop(n int) int {\n    res := 0\n    // Sum 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for loop */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // Sum 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for loop */\nfunction forLoop(n) {\n    let res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for loop */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for loop */\nint forLoop(int n) {\n  int res = 0;\n  // Sum 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for loop */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for loop */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // Sum 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for loop ###\ndef for_loop(n)\n  res = 0\n\n  # Sum 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> <p>Figure 2-1 shows the flowchart of this summation function.</p> <p></p> <p> Figure 2-1   Flowchart of the summation function </p> <p>The number of operations in this summation function is proportional to the input data size \\(n\\), or has a \"linear relationship\". In fact, time complexity describes precisely this \"linear relationship\". Related content will be introduced in detail in the next section.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while-loop","level":3,"title":"2.   While Loop","text":"<p>Similar to the <code>for</code> loop, the <code>while</code> loop is also a method for implementing iteration. In a <code>while</code> loop, the program first checks the condition in each round; if the condition is true, it continues execution, otherwise it ends the loop.</p> <p>Below we use a <code>while</code> loop to implement the summation \\(1 + 2 + \\dots + n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while loop\"\"\"\n    res = 0\n    i = 1  # Initialize condition variable\n    # Sum 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # Update condition variable\n    return res\n</code></pre> iteration.cpp<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while loop */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while loop */\nfunc whileLoop(n int) int {\n    res := 0\n    // Initialize condition variable\n    i := 1\n    // Sum 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // Update condition variable\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while loop */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // Update condition variable\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while loop */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while loop */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while loop */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // Initialize condition variable\n  // Sum 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // Update condition variable\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while loop */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Initialize condition variable\n\n    // Sum 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // Update condition variable\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while loop */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // Update condition variable\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while loop ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Initialize condition variable\n\n  # Sum 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Update condition variable\n  end\n\n  res\nend\n</code></pre> <p>The <code>while</code> loop has greater flexibility than the <code>for</code> loop. In a <code>while</code> loop, we can freely design the initialization and update steps of the condition variable.</p> <p>For example, in the following code, the condition variable \\(i\\) is updated twice per round, which is not convenient to implement using a <code>for</code> loop:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while loop (two updates)\"\"\"\n    res = 0\n    i = 1  # Initialize condition variable\n    # Sum 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # Update condition variable\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while loop (two updates) */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while loop (two updates) */\nfunc whileLoopII(n int) int {\n    res := 0\n    // Initialize condition variable\n    i := 1\n    // Sum 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // Update condition variable\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while loop (two updates) */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // Update condition variable\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while loop (two updates) */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while loop (two updates) */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // Initialize condition variable\n  // Sum 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // Update condition variable\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while loop (two updates) */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Initialize condition variable\n\n    // Sum 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // Update condition variable\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while loop (two updates) */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // Update condition variable\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while loop (two updates) ###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # Initialize condition variable\n\n  # Sum 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # Update condition variable\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> <p>Overall, <code>for</code> loops have more compact code, while <code>while</code> loops are more flexible; both can implement iterative structures. The choice of which to use should be determined based on the requirements of the specific problem.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-nested-loops","level":3,"title":"3.   Nested Loops","text":"<p>We can nest one loop structure inside another. Below is an example using <code>for</code> loops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"Nested for loop\"\"\"\n    res = \"\"\n    # Loop i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # Loop j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* Nested for loop */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* Nested for loop */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* Nested for loop */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* Nested for loop */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // Loop i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // Loop j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Nested for loop */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // Loop i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // Loop j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Nested for loop */\nfunction nestedForLoop(n) {\n    let res = '';\n    // Loop i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Nested for loop */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // Loop i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Nested for loop */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // Loop i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // Loop j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Nested for loop */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // Loop i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // Loop j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* Nested for loop */\nchar *nestedForLoop(int n) {\n    // n * n is the number of points, \"(i, j), \" string max length is 6+10*2, plus extra space for null character \\0\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Nested for loop */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // Loop i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### Nested for loop ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # Loop i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # Loop j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> <p>Figure 2-2 shows the flowchart of this nested loop.</p> <p></p> <p> Figure 2-2   Flowchart of nested loops </p> <p>In this case, the number of operations of the function is proportional to \\(n^2\\), or the algorithm's running time has a \"quadratic relationship\" with the input data size \\(n\\).</p> <p>We can continue adding nested loops, where each nesting is a \"dimension increase\", raising the time complexity to \"cubic relationship\", \"quartic relationship\", and so on.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222-recursion","level":2,"title":"2.2.2   Recursion","text":"<p>Recursion is an algorithmic strategy that solves problems by having a function call itself. It mainly consists of two phases.</p> <ol> <li>Descend: The program continuously calls itself deeper, usually passing in smaller or more simplified parameters, until reaching a \"termination condition\".</li> <li>Ascend: After triggering the \"termination condition\", the program returns layer by layer from the deepest recursive function, aggregating the result of each layer.</li> </ol> <p>From an implementation perspective, recursive code mainly consists of three elements.</p> <ol> <li>Termination condition: Used to determine when to switch from \"descending\" to \"ascending\".</li> <li>Recursive call: Corresponds to \"descending\", where the function calls itself, usually with smaller or more simplified parameters.</li> <li>Return result: Corresponds to \"ascending\", returning the result of the current recursion level to the previous layer.</li> </ol> <p>Observe the following code. We only need to call the function <code>recur(n)</code> to complete the calculation of \\(1 + 2 + \\dots + n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"Recursion\"\"\"\n    # Termination condition\n    if n == 1:\n        return 1\n    # Recurse: recursive call\n    res = recur(n - 1)\n    # Return: return result\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* Recursion */\nint Recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = Recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* Recursion */\nfunc recur(n int) int {\n    // Termination condition\n    if n == 1 {\n        return 1\n    }\n    // Recurse: recursive call\n    res := recur(n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* Recursion */\nfunc recur(n: Int) -&gt; Int {\n    // Termination condition\n    if n == 1 {\n        return 1\n    }\n    // Recurse: recursive call\n    let res = recur(n: n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* Recursion */\nfunction recur(n) {\n    // Termination condition\n    if (n === 1) return 1;\n    // Recurse: recursive call\n    const res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* Recursion */\nfunction recur(n: number): number {\n    // Termination condition\n    if (n === 1) return 1;\n    // Recurse: recursive call\n    const res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* Recursion */\nint recur(int n) {\n  // Termination condition\n  if (n == 1) return 1;\n  // Recurse: recursive call\n  int res = recur(n - 1);\n  // Return: return result\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* Recursion */\nfn recur(n: i32) -&gt; i32 {\n    // Termination condition\n    if n == 1 {\n        return 1;\n    }\n    // Recurse: recursive call\n    let res = recur(n - 1);\n    // Return: return result\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* Recursion */\nfun recur(n: Int): Int {\n    // Termination condition\n    if (n == 1)\n        return 1\n    // Descend: recursive call\n    val res = recur(n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### Recursion ###\ndef recur(n)\n  # Termination condition\n  return 1 if n == 1\n  # Recurse: recursive call\n  res = recur(n - 1)\n  # Return: return result\n  n + res\nend\n</code></pre> <p>Figure 2-3 shows the recursive process of this function.</p> <p></p> <p> Figure 2-3   Recursive process of the summation function </p> <p>Although from a computational perspective, iteration and recursion can achieve the same results, they represent two completely different paradigms for thinking about and solving problems.</p> <ul> <li>Iteration: Solves problems \"bottom-up\". Starting from the most basic steps, these steps are then repeatedly executed or accumulated until the task is complete.</li> <li>Recursion: Solves problems \"top-down\". The original problem is decomposed into smaller subproblems that have the same form as the original problem. These subproblems continue to be decomposed into even smaller subproblems until reaching the base case (where the solution is known).</li> </ul> <p>Taking the above summation function as an example, let the problem be \\(f(n) = 1 + 2 + \\dots + n\\).</p> <ul> <li>Iteration: Simulates the summation process in a loop, traversing from \\(1\\) to \\(n\\), performing the summation operation in each round to obtain \\(f(n)\\).</li> <li>Recursion: Decomposes the problem into the subproblem \\(f(n) = n + f(n-1)\\), continuously decomposing (recursively) until terminating at the base case \\(f(1) = 1\\).</li> </ul>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-call-stack","level":3,"title":"1.   Call Stack","text":"<p>Each time a recursive function calls itself, the system allocates memory for the newly opened function to store local variables, call addresses, and other information. This leads to two consequences.</p> <ul> <li>The function's context data is stored in a memory area called \"stack frame space\", which is not released until the function returns. Therefore, recursion usually consumes more memory space than iteration.</li> <li>Recursive function calls incur additional overhead. Therefore, recursion is usually less time-efficient than loops.</li> </ul> <p>As shown in Figure 2-4, before the termination condition is triggered, there are \\(n\\) unreturned recursive functions existing simultaneously, with a recursion depth of \\(n\\).</p> <p></p> <p> Figure 2-4   Recursion call depth </p> <p>In practice, the recursion depth allowed by programming languages is usually limited, and excessively deep recursion may lead to stack overflow errors.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-tail-recursion","level":3,"title":"2.   Tail Recursion","text":"<p>Interestingly, if a function makes the recursive call as the very last step before returning, the function can be optimized by the compiler or interpreter to have space efficiency comparable to iteration. This case is called tail recursion.</p> <ul> <li>Regular recursion: When a function returns to the previous level, it needs to continue executing code, so the system needs to save the context of the previous layer's call.</li> <li>Tail recursion: The recursive call is the last operation before the function returns, meaning that after returning to the previous level, there is no need to continue executing other operations, so the system does not need to save the context of the previous layer's function.</li> </ul> <p>Taking the calculation of \\(1 + 2 + \\dots + n\\) as an example, we can set the result variable <code>res</code> as a function parameter to implement tail recursion:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"Tail recursion\"\"\"\n    # Termination condition\n    if n == 0:\n        return res\n    # Tail recursive call\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* Tail recursion */\nint TailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* Tail recursion */\nfunc tailRecur(n int, res int) int {\n    // Termination condition\n    if n == 0 {\n        return res\n    }\n    // Tail recursive call\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* Tail recursion */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // Termination condition\n    if n == 0 {\n        return res\n    }\n    // Tail recursive call\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* Tail recursion */\nfunction tailRecur(n, res) {\n    // Termination condition\n    if (n === 0) return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* Tail recursion */\nfunction tailRecur(n: number, res: number): number {\n    // Termination condition\n    if (n === 0) return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n  // Termination condition\n  if (n == 0) return res;\n  // Tail recursive call\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* Tail recursion */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // Termination condition\n    if n == 0 {\n        return res;\n    }\n    // Tail recursive call\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* Tail recursion */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // Add tailrec keyword to enable tail recursion optimization\n    // Termination condition\n    if (n == 0)\n        return res\n    // Tail recursive call\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### Tail recursion ###\ndef tail_recur(n, res)\n  # Termination condition\n  return res if n == 0\n  # Tail recursive call\n  tail_recur(n - 1, res + n)\nend\n</code></pre> <p>The execution process of tail recursion is shown in Figure 2-5. Comparing regular recursion and tail recursion, the execution point of the summation operation is different.</p> <ul> <li>Regular recursion: The summation operation is performed during the \"ascending\" process, requiring an additional summation operation after each layer returns.</li> <li>Tail recursion: The summation operation is performed during the \"descending\" process; the \"ascending\" process only needs to return layer by layer.</li> </ul> <p></p> <p> Figure 2-5   Tail recursion process </p> <p>Tip</p> <p>Please note that many compilers or interpreters do not support tail recursion optimization. For example, Python does not support tail recursion optimization by default, so even if a function is in tail recursive form, it may still encounter stack overflow issues.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-recursion-tree","level":3,"title":"3.   Recursion Tree","text":"<p>When dealing with algorithmic problems related to \"divide and conquer\", recursion often provides a more intuitive approach and more readable code than iteration. Taking the \"Fibonacci sequence\" as an example.</p> <p>Question</p> <p>Given a Fibonacci sequence \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\), find the \\(n\\)-th number in the sequence.</p> <p>Let the \\(n\\)-th number of the Fibonacci sequence be \\(f(n)\\). Two conclusions can be easily obtained.</p> <ul> <li>The first two numbers of the sequence are \\(f(1) = 0\\) and \\(f(2) = 1\\).</li> <li>Each number in the sequence is the sum of the previous two numbers, i.e., \\(f(n) = f(n - 1) + f(n - 2)\\).</li> </ul> <p>Following the recurrence relation to make recursive calls, with the first two numbers as termination conditions, we can write the recursive code. Calling <code>fib(n)</code> will give us the \\(n\\)-th number of the Fibonacci sequence:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"Fibonacci sequence: recursion\"\"\"\n    # Termination condition f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # Recursive call f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # Return result f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Fibonacci sequence: recursion */\nint Fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Fibonacci sequence: recursion */\nfunc fib(n int) int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Fibonacci sequence: recursion */\nfunc fib(n: Int) -&gt; Int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Fibonacci sequence: recursion */\nfunction fib(n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Fibonacci sequence: recursion */\nfunction fib(n: number): number {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n  // Termination condition f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // Recursive call f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // Return result f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Fibonacci sequence: recursion */\nfn fib(n: i32) -&gt; i32 {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // Return result\n    res\n}\n</code></pre> recursion.c<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Fibonacci sequence: recursion */\nfun fib(n: Int): Int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Fibonacci sequence: recursion ###\ndef fib(n)\n  # Termination condition f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # Recursive call f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # Return result f(n)\n  res\nend\n</code></pre> <p>Observing the above code, we recursively call two functions within the function, meaning that one call produces two call branches. As shown in Figure 2-6, such continuous recursive calling will eventually produce a recursion tree with \\(n\\) levels.</p> <p></p> <p> Figure 2-6   Recursion tree of the Fibonacci sequence </p> <p>Fundamentally, recursion embodies the paradigm of \"decomposing a problem into smaller subproblems\", and this divide-and-conquer strategy is crucial.</p> <ul> <li>From an algorithmic perspective, many important algorithmic strategies such as searching, sorting, backtracking, divide and conquer, and dynamic programming directly or indirectly apply this way of thinking.</li> <li>From a data structure perspective, recursion is naturally suited for handling problems related to linked lists, trees, and graphs, because they are well-suited for analysis using divide-and-conquer thinking.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223-comparison-of-the-two","level":2,"title":"2.2.3   Comparison of the Two","text":"<p>Summarizing the above content, as shown in Table 2-1, iteration and recursion differ in implementation, performance, and applicability.</p> <p> Table 2-1   Comparison of iteration and recursion characteristics </p> Iteration Recursion Implementation Loop structure Function calls itself Time efficiency Generally more efficient, no function call overhead Each function call incurs overhead Memory usage Usually uses a fixed amount of memory space Accumulated function calls may use a large amount of stack frame space Suitable problems Suitable for simple loop tasks, with intuitive and readable code Suitable for subproblem decomposition, such as trees, graphs, divide and conquer, backtracking, etc., with concise and clear code structure <p>Tip</p> <p>If you find the following content difficult to understand, you can review it after reading the \"Stack\" chapter.</p> <p>What is the intrinsic relationship between iteration and recursion? Taking the above recursive function as an example, the summation operation is performed during the \"ascending\" phase of recursion. This means that the function called first actually completes its summation operation last, and this working mechanism is similar to the \"last-in, first-out\" principle of stacks.</p> <p>In fact, recursive terminology such as \"call stack\" and \"stack frame space\" already hints at the close relationship between recursion and stacks.</p> <ol> <li>Descend: When a function is called, the system allocates a new stack frame on the \"call stack\" for that function to store the function's local variables, parameters, return address, and other data.</li> <li>Ascend: When the function completes execution and returns, the corresponding stack frame is removed from the \"call stack\", restoring the execution environment of the previous function.</li> </ol> <p>Therefore, we can use an explicit stack to simulate the behavior of the call stack, thus transforming recursion into iterative form:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"Simulate recursion using iteration\"\"\"\n    # Use an explicit stack to simulate the system call stack\n    stack = []\n    res = 0\n    # Recurse: recursive call\n    for i in range(n, 0, -1):\n        # Simulate \"recurse\" with \"push\"\n        stack.append(i)\n    # Return: return result\n    while stack:\n        # Simulate \"return\" with \"pop\"\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (!stack.empty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (!stack.isEmpty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Simulate recursion using iteration */\nint ForLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.Push(i);\n    }\n    // Return: return result\n    while (stack.Count &gt; 0) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Simulate recursion using iteration */\nfunc forLoopRecur(n int) int {\n    // Use an explicit stack to simulate the system call stack\n    stack := list.New()\n    res := 0\n    // Recurse: recursive call\n    for i := n; i &gt; 0; i-- {\n        // Simulate \"recurse\" with \"push\"\n        stack.PushBack(i)\n    }\n    // Return: return result\n    for stack.Len() != 0 {\n        // Simulate \"return\" with \"pop\"\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Simulate recursion using iteration */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // Use an explicit stack to simulate the system call stack\n    var stack: [Int] = []\n    var res = 0\n    // Recurse: recursive call\n    for i in (1 ... n).reversed() {\n        // Simulate \"recurse\" with \"push\"\n        stack.append(i)\n    }\n    // Return: return result\n    while !stack.isEmpty {\n        // Simulate \"return\" with \"pop\"\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Simulate recursion using iteration */\nfunction forLoopRecur(n) {\n    // Use an explicit stack to simulate the system call stack\n    const stack = [];\n    let res = 0;\n    // Recurse: recursive call\n    for (let i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (stack.length) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Simulate recursion using iteration */\nfunction forLoopRecur(n: number): number {\n    // Use an explicit stack to simulate the system call stack\n    const stack: number[] = [];\n    let res: number = 0;\n    // Recurse: recursive call\n    for (let i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (stack.length) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n  // Use an explicit stack to simulate the system call stack\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // Recurse: recursive call\n  for (int i = n; i &gt; 0; i--) {\n    // Simulate \"recurse\" with \"push\"\n    stack.add(i);\n  }\n  // Return: return result\n  while (!stack.isEmpty) {\n    // Simulate \"return\" with \"pop\"\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Simulate recursion using iteration */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // Use an explicit stack to simulate the system call stack\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // Recurse: recursive call\n    for i in (1..=n).rev() {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while !stack.is_empty() {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    int stack[1000]; // Use a large array to simulate stack\n    int top = -1;    // Stack top index\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack[1 + top++] = i;\n    }\n    // Return: return result\n    while (top &gt;= 0) {\n        // Simulate \"return\" with \"pop\"\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Simulate recursion using iteration */\nfun forLoopRecur(n: Int): Int {\n    // Use an explicit stack to simulate the system call stack\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // Descend: recursive call\n    for (i in n downTo 0) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i)\n    }\n    // Return: return result\n    while (stack.isNotEmpty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Use iteration to simulate recursion ###\ndef for_loop_recur(n)\n  # Use an explicit stack to simulate the system call stack\n  stack = []\n  res = 0\n\n  # Recurse: recursive call\n  for i in n.downto(0)\n    # Simulate \"recurse\" with \"push\"\n    stack &lt;&lt; i\n  end\n  # Return: return result\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> <p>Observing the above code, when recursion is transformed into iteration, the code becomes more complex. Although iteration and recursion can be converted into each other in many cases, it may not be worthwhile to do so for the following two reasons.</p> <ul> <li>The transformed code may be more difficult to understand and less readable.</li> <li>For some complex problems, simulating the behavior of the system call stack can be very difficult.</li> </ul> <p>In summary, choosing between iteration and recursion depends on the nature of the specific problem. In programming practice, it is crucial to weigh the pros and cons of both and choose the appropriate method based on the context.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   Algorithm Efficiency Evaluation","text":"<p>In algorithm design, we pursue the following two levels of objectives sequentially.</p> <ol> <li>Finding a solution to the problem: The algorithm must reliably obtain the correct solution within the specified input range.</li> <li>Seeking the optimal solution: Multiple solutions may exist for the same problem, and we hope to find an algorithm that is as efficient as possible.</li> </ol> <p>In other words, under the premise of being able to solve the problem, algorithm efficiency has become the primary evaluation criterion for measuring the quality of algorithms. It includes the following two dimensions.</p> <ul> <li>Time efficiency: The length of time the algorithm runs.</li> <li>Space efficiency: The size of memory space the algorithm occupies.</li> </ul> <p>In short, our goal is to design data structures and algorithms that are \"both fast and memory-efficient\". Effectively evaluating algorithm efficiency is crucial, because only in this way can we compare various algorithms and guide the algorithm design and optimization process.</p> <p>Efficiency evaluation methods are mainly divided into two types: actual testing and theoretical estimation.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211-actual-testing","level":2,"title":"2.1.1   Actual Testing","text":"<p>Suppose we now have algorithm <code>A</code> and algorithm <code>B</code>, both of which can solve the same problem, and we need to compare the efficiency of these two algorithms. The most direct method is to find a computer, run these two algorithms, and monitor and record their running time and memory usage. This evaluation approach can reflect the real situation, but it also has considerable limitations.</p> <p>On one hand, it is difficult to eliminate interference factors from the testing environment. Hardware configuration affects the performance of algorithms. For example, if an algorithm has a high degree of parallelism, it is more suitable for running on multi-core CPUs; if an algorithm has intensive memory operations, it will perform better on high-performance memory. In other words, the test results of an algorithm on different machines may be inconsistent. This means we need to test on various machines and calculate average efficiency, which is impractical.</p> <p>On the other hand, conducting complete testing is very resource-intensive. As the input data volume changes, the algorithm will exhibit different efficiencies. For example, when the input data volume is small, the running time of algorithm <code>A</code> is shorter than algorithm <code>B</code>; but when the input data volume is large, the test results may be exactly the opposite. Therefore, to obtain convincing conclusions, we need to test input data of various scales, which requires a large amount of computational resources.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212-theoretical-estimation","level":2,"title":"2.1.2   Theoretical Estimation","text":"<p>Since actual testing has considerable limitations, we can consider evaluating algorithm efficiency through calculations alone. This estimation method is called asymptotic complexity analysis, or complexity analysis for short.</p> <p>Complexity analysis can reflect the relationship between the time and space resources required for algorithm execution and the input data scale. It describes the growth trend of the time and space required for algorithm execution as the input data scale increases. This definition is somewhat convoluted, so we can break it down into three key points to understand.</p> <ul> <li>\"Time and space resources\" correspond to time complexity and space complexity, respectively.</li> <li>\"As the input data scale increases\" means that complexity reflects the relationship between algorithm running efficiency and input data scale.</li> <li>\"Growth trend of time and space\" indicates that complexity analysis focuses not on the specific values of running time or occupied space, but on how \"fast\" time or space grows.</li> </ul> <p>Complexity analysis overcomes the drawbacks of the actual testing method, reflected in the following aspects.</p> <ul> <li>It does not need to actually run the code, making it more environmentally friendly and energy-efficient.</li> <li>It is independent of the testing environment, and the analysis results are applicable to all running platforms.</li> <li>It can reflect algorithm efficiency at different data volumes, especially algorithm performance at large data volumes.</li> </ul> <p>Tip</p> <p>If you are still confused about the concept of complexity, don't worry—we will introduce it in detail in subsequent chapters.</p> <p>Complexity analysis provides us with a \"ruler\" for evaluating algorithm efficiency, allowing us to measure the time and space resources required to execute a certain algorithm and compare the efficiency between different algorithms.</p> <p>Complexity is a mathematical concept that may be relatively abstract for beginners, with a relatively high learning difficulty. From this perspective, complexity analysis may not be very suitable as the first content to be introduced. However, when we discuss the characteristics of a certain data structure or algorithm, it is difficult to avoid analyzing its running speed and space usage.</p> <p>In summary, it is recommended that before diving deep into data structures and algorithms, you first establish a preliminary understanding of complexity analysis so that you can complete complexity analysis of simple algorithms.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   Space Complexity","text":"<p>Space complexity measures the growth trend of memory space occupied by an algorithm as the data size increases. This concept is very similar to time complexity, except that \"running time\" is replaced with \"occupied memory space\".</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241-algorithm-related-space","level":2,"title":"2.4.1   Algorithm-Related Space","text":"<p>The memory space used by an algorithm during execution mainly includes the following types.</p> <ul> <li>Input space: Used to store the input data of the algorithm.</li> <li>Temporary space: Used to store variables, objects, function contexts, and other data during the algorithm's execution.</li> <li>Output space: Used to store the output data of the algorithm.</li> </ul> <p>In general, the scope of space complexity statistics is \"temporary space\" plus \"output space\".</p> <p>Temporary space can be further divided into three parts.</p> <ul> <li>Temporary data: Used to save various constants, variables, objects, etc., during the algorithm's execution.</li> <li>Stack frame space: Used to save the context data of called functions. The system creates a stack frame at the top of the stack each time a function is called, and the stack frame space is released after the function returns.</li> <li>Instruction space: Used to save compiled program instructions, which are usually ignored in actual statistics.</li> </ul> <p>When analyzing the space complexity of a program, we usually count three parts: temporary data, stack frame space, and output data, as shown in the following figure.</p> <p></p> <p> Figure 2-15   Algorithm-related space </p> <p>The related code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"Class\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # Node value\n        self.next: Node | None = None  # Reference to the next node\n\ndef function() -&gt; int:\n    \"\"\"Function\"\"\"\n    # Perform some operations...\n    return 0\n\ndef algorithm(n) -&gt; int:  # Input data\n    A = 0                 # Temporary data (constant, usually represented by uppercase letters)\n    b = 0                 # Temporary data (variable)\n    node = Node(0)        # Temporary data (object)\n    c = function()        # Stack frame space (function call)\n    return A + b + c      # Output data\n</code></pre> <pre><code>/* Structure */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Function */\nint func() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) {        // Input data\n    const int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node* node = new Node(0); // Temporary data (object)\n    int c = func();           // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Function */\nint function() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) {        // Input data\n    final int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node node = new Node(0);  // Temporary data (object)\n    int c = function();       // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* Function */\nint Function() {\n    // Perform some operations...\n    return 0;\n}\n\nint Algorithm(int n) {        // Input data\n    const int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node node = new(0);       // Temporary data (object)\n    int c = Function();       // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Structure */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Create node structure */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* Function */\nfunc function() int {\n    // Perform some operations...\n    return 0\n}\n\nfunc algorithm(n int) int { // Input data\n    const a = 0             // Temporary data (constant)\n    b := 0                  // Temporary data (variable)\n    newNode(0)              // Temporary data (object)\n    c := function()         // Stack frame space (function call)\n    return a + b + c        // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Function */\nfunc function() -&gt; Int {\n    // Perform some operations...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // Input data\n    let a = 0             // Temporary data (constant)\n    var b = 0             // Temporary data (variable)\n    let node = Node(x: 0) // Temporary data (object)\n    let c = function()    // Stack frame space (function call)\n    return a + b + c      // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.next = null;                       // Reference to the next node\n    }\n}\n\n/* Function */\nfunction constFunc() {\n    // Perform some operations\n    return 0;\n}\n\nfunction algorithm(n) {       // Input data\n    const a = 0;              // Temporary data (constant)\n    let b = 0;                // Temporary data (variable)\n    const node = new Node(0); // Temporary data (object)\n    const c = constFunc();    // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.next = null;                       // Reference to the next node\n    }\n}\n\n/* Function */\nfunction constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n\nfunction algorithm(n: number): number { // Input data\n    const a = 0;                        // Temporary data (constant)\n    let b = 0;                          // Temporary data (variable)\n    const node = new Node(0);           // Temporary data (object)\n    const c = constFunc();              // Stack frame space (function call)\n    return a + b + c;                   // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Function */\nint function() {\n  // Perform some operations...\n  return 0;\n}\n\nint algorithm(int n) {  // Input data\n  const int a = 0;      // Temporary data (constant)\n  int b = 0;            // Temporary data (variable)\n  Node node = Node(0);  // Temporary data (object)\n  int c = function();   // Stack frame space (function call)\n  return a + b + c;     // Output data\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Structure */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Create Node structure */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Function */\nfn function() -&gt; i32 {\n    // Perform some operations...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // Input data\n    const a: i32 = 0;               // Temporary data (constant)\n    let mut b = 0;                  // Temporary data (variable)\n    let node = Node::new(0);        // Temporary data (object)\n    let c = function();             // Stack frame space (function call)\n    return a + b + c;               // Output data\n}\n</code></pre> <pre><code>/* Function */\nint func() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) { // Input data\n    const int a = 0;   // Temporary data (constant)\n    int b = 0;         // Temporary data (variable)\n    int c = func();    // Stack frame space (function call)\n    return a + b + c;  // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* Function */\nfun function(): Int {\n    // Perform some operations...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // Input data\n    val a = 0                // Temporary data (constant)\n    var b = 0                // Temporary data (variable)\n    val node = Node(0)       // Temporary data (object)\n    val c = function()       // Stack frame space (function call)\n    return a + b + c         // Output data\n}\n</code></pre> <pre><code>### Class ###\nclass Node\n    attr_accessor :val      # Node value\n    attr_accessor :next     # Reference to the next node\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### Function ###\ndef function\n    # Perform some operations...\n    0\nend\n\n### Algorithm ###\ndef algorithm(n)        # Input data\n    a = 0               # Temporary data (constant)\n    b = 0               # Temporary data (variable)\n    node = Node.new(0)  # Temporary data (object)\n    c = function        # Stack frame space (function call)\n    a + b + c           # Output data\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242-calculation-method","level":2,"title":"2.4.2   Calculation Method","text":"<p>The calculation method for space complexity is roughly the same as for time complexity, except that the statistical object is changed from \"number of operations\" to \"size of space used\".</p> <p>Unlike time complexity, we usually only focus on the worst-case space complexity. This is because memory space is a hard requirement, and we must ensure that sufficient memory space is reserved for all input data.</p> <p>Observe the following code. The \"worst case\" in worst-case space complexity has two meanings.</p> <ol> <li>Based on the worst input data: When \\(n &lt; 10\\), the space complexity is \\(O(1)\\); but when \\(n &gt; 10\\), the initialized array <code>nums</code> occupies \\(O(n)\\) space, so the worst-case space complexity is \\(O(n)\\).</li> <li>Based on the peak memory during algorithm execution: For example, before executing the last line, the program occupies \\(O(1)\\) space; when initializing the array <code>nums</code>, the program occupies \\(O(n)\\) space, so the worst-case space complexity is \\(O(n)\\).</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>In recursive functions, it is necessary to count the stack frame space. Observe the following code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # Perform some operations\n    return 0\n\ndef loop(n: int):\n    \"\"\"Loop has space complexity of O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Recursion has space complexity of O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // Perform some operations\n    return 0\n}\n\n/* Loop has space complexity of O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* Recursion has space complexity of O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // Perform some operations\n    return 0\n}\n\n/* Loop has space complexity of O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* Recursion has space complexity of O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // Perform some operations\n  return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // Perform some operations\n    return 0\n}\n/* Loop has space complexity of O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* Recursion has space complexity of O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # Perform some operations\n    0\nend\n\n### Loop has space complexity of O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### Recursion has space complexity of O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>The time complexity of both functions <code>loop()</code> and <code>recur()</code> is \\(O(n)\\), but their space complexities are different.</p> <ul> <li>The function <code>loop()</code> calls <code>function()</code> \\(n\\) times in a loop. In each iteration, <code>function()</code> returns and releases its stack frame space, so the space complexity remains \\(O(1)\\).</li> <li>The recursive function <code>recur()</code> has \\(n\\) unreturned <code>recur()</code> instances existing simultaneously during execution, thus occupying \\(O(n)\\) stack frame space.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243-common-types","level":2,"title":"2.4.3   Common Types","text":"<p>Let the input data size be \\(n\\). The following figure shows common types of space complexity (arranged from low to high).</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{Constant} &lt; \\text{Logarithmic} &lt; \\text{Linear} &lt; \\text{Quadratic} &lt; \\text{Exponential} \\end{aligned} \\] <p></p> <p> Figure 2-16   Common types of space complexity </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-constant-order-o1","level":3,"title":"1.   Constant Order \\(O(1)\\)","text":"<p>Constant order is common in constants, variables, and objects whose quantity is independent of the input data size \\(n\\).</p> <p>It should be noted that memory occupied by initializing variables or calling functions in a loop is released when entering the next iteration, so it does not accumulate space, and the space complexity remains \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"Function\"\"\"\n    # Perform some operations\n    return 0\n\ndef constant(n: int):\n    \"\"\"Constant order\"\"\"\n    # Constants, variables, objects occupy O(1) space\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # Variables in the loop occupy O(1) space\n    for _ in range(n):\n        c = 0\n    # Functions in the loop occupy O(1) space\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* Function */\nint func() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Function */\nint function() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Function */\nint Function() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid Constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Function */\nfunc function() int {\n    // Perform some operations...\n    return 0\n}\n\n/* Constant order */\nfunc spaceConstant(n int) {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // Variables in the loop occupy O(1) space\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* Function */\n@discardableResult\nfunc function() -&gt; Int {\n    // Perform some operations\n    return 0\n}\n\n/* Constant order */\nfunc constant(n: Int) {\n    // Constants, variables, objects occupy O(1) space\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // Variables in the loop occupy O(1) space\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* Function */\nfunction constFunc() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nfunction constant(n) {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Function */\nfunction constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nfunction constant(n: number): void {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Function */\nint function() {\n  // Perform some operations\n  return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n  // Constants, variables, objects occupy O(1) space\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // Variables in the loop occupy O(1) space\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // Functions in the loop occupy O(1) space\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Function */\nfn function() -&gt; i32 {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\n#[allow(unused)]\nfn constant(n: i32) {\n    // Constants, variables, objects occupy O(1) space\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // Variables in the loop occupy O(1) space\n    for i in 0..n {\n        let c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Function */\nint func() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Function */\nfun function(): Int {\n    // Perform some operations\n    return 0\n}\n\n/* Constant order */\nfun constant(n: Int) {\n    // Constants, variables, objects occupy O(1) space\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // Variables in the loop occupy O(1) space\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Function ###\ndef function\n  # Perform some operations\n  0\nend\n\n### Constant time ###\ndef constant(n)\n  # Constants, variables, objects occupy O(1) space\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # Variables in the loop occupy O(1) space\n  (0...n).each { c = 0 }\n  # Functions in the loop occupy O(1) space\n  (0...n).each { function }\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-linear-order-on","level":3,"title":"2.   Linear Order \\(O(n)\\)","text":"<p>Linear order is common in arrays, linked lists, stacks, queues, etc., where the number of elements is proportional to \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"Linear order\"\"\"\n    # A list of length n occupies O(n) space\n    nums = [0] * n\n    # A hash table of length n occupies O(n) space\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    vector&lt;int&gt; nums(n);\n    // A list of length n occupies O(n) space\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    int[] nums = new int[n];\n    // A list of length n occupies O(n) space\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Linear order */\nvoid Linear(int n) {\n    // Array of length n uses O(n) space\n    int[] nums = new int[n];\n    // A list of length n occupies O(n) space\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Linear order */\nfunc spaceLinear(n int) {\n    // Array of length n uses O(n) space\n    _ = make([]int, n)\n    // A list of length n occupies O(n) space\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // A hash table of length n occupies O(n) space\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Linear order */\nfunc linear(n: Int) {\n    // Array of length n uses O(n) space\n    let nums = Array(repeating: 0, count: n)\n    // A list of length n occupies O(n) space\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // A hash table of length n occupies O(n) space\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* Linear order */\nfunction linear(n) {\n    // Array of length n uses O(n) space\n    const nums = new Array(n);\n    // A list of length n occupies O(n) space\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Linear order */\nfunction linear(n: number): void {\n    // Array of length n uses O(n) space\n    const nums = new Array(n);\n    // A list of length n occupies O(n) space\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Linear order */\nvoid linear(int n) {\n  // Array of length n uses O(n) space\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // A list of length n occupies O(n) space\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // A hash table of length n occupies O(n) space\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Linear order */\n#[allow(unused)]\nfn linear(n: i32) {\n    // Array of length n uses O(n) space\n    let mut nums = vec![0; n as usize];\n    // A list of length n occupies O(n) space\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // A hash table of length n occupies O(n) space\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Hash table */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Implemented using uthash.h\n} HashTable;\n\n/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // A list of length n occupies O(n) space\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // Memory release\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // A hash table of length n occupies O(n) space\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // Memory release\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Linear order */\nfun linear(n: Int) {\n    // Array of length n uses O(n) space\n    val nums = Array(n) { 0 }\n    // A list of length n occupies O(n) space\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // A hash table of length n occupies O(n) space\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Linear time ###\ndef linear(n)\n  # A list of length n occupies O(n) space\n  nums = Array.new(n, 0)\n\n  # A hash table of length n occupies O(n) space\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> <p>As shown in the following figure, the recursion depth of this function is \\(n\\), meaning that there are \\(n\\) unreturned <code>linear_recur()</code> functions existing simultaneously, using \\(O(n)\\) stack frame space:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"Linear order (recursive implementation)\"\"\"\n    print(\"Recursion n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"Recursion n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    System.out.println(\"Recursion n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Linear order (recursive implementation) */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"Recursion n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Linear order (recursive implementation) */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"Recursion n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Linear order (recursive implementation) */\nfunc linearRecur(n: Int) {\n    print(\"Recursion n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Linear order (recursive implementation) */\nfunction linearRecur(n) {\n    console.log(`Recursion n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Linear order (recursive implementation) */\nfunction linearRecur(n: number): void {\n    console.log(`Recursion n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n  print('Recursion n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Linear order (recursive implementation) */\nfn linear_recur(n: i32) {\n    println!(\"Recursion n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    printf(\"Recursion n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* Linear order (recursive implementation) */\nfun linearRecur(n: Int) {\n    println(\"Recursion n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Linear space (recursive) ###\ndef linear_recur(n)\n  puts \"Recursion n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> <p></p> <p> Figure 2-17   Linear order space complexity generated by recursive function </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-quadratic-order-on2","level":3,"title":"3.   Quadratic Order \\(O(n^2)\\)","text":"<p>Quadratic order is common in matrices and graphs, where the number of elements is quadratically related to \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"Quadratic order\"\"\"\n    # A 2D list occupies O(n^2) space\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // 2D list uses O(n^2) space\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // Matrix uses O(n^2) space\n    int[][] numMatrix = new int[n][n];\n    // 2D list uses O(n^2) space\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Exponential order */\nvoid Quadratic(int n) {\n    // Matrix uses O(n^2) space\n    int[,] numMatrix = new int[n, n];\n    // 2D list uses O(n^2) space\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Exponential order */\nfunc spaceQuadratic(n int) {\n    // Matrix uses O(n^2) space\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Exponential order */\nfunc quadratic(n: Int) {\n    // 2D list uses O(n^2) space\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* Exponential order */\nfunction quadratic(n) {\n    // Matrix uses O(n^2) space\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 2D list uses O(n^2) space\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Exponential order */\nfunction quadratic(n: number): void {\n    // Matrix uses O(n^2) space\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 2D list uses O(n^2) space\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n  // Matrix uses O(n^2) space\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 2D list uses O(n^2) space\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Exponential order */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // Matrix uses O(n^2) space\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 2D list uses O(n^2) space\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // 2D list uses O(n^2) space\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // Memory release\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* Exponential order */\nfun quadratic(n: Int) {\n    // Matrix uses O(n^2) space\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 2D list uses O(n^2) space\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Quadratic time ###\ndef quadratic(n)\n  # 2D list uses O(n^2) space\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> <p>As shown in the following figure, the recursion depth of this function is \\(n\\), and an array is initialized in each recursive function with lengths of \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\), with an average length of \\(n / 2\\), thus occupying \\(O(n^2)\\) space overall:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"Quadratic order (recursive implementation)\"\"\"\n    if n &lt;= 0:\n        return 0\n    # Array nums length is n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"In recursion n = \" &lt;&lt; n &lt;&lt; \", nums length = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // Array nums has length n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"In recursion n = \" + n + \", nums length = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Quadratic order (recursive implementation) */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"Recursion n = \" + n + \", nums length = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Quadratic order (recursive implementation) */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"In recursion n = %d, nums length = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Quadratic order (recursive implementation) */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // Array nums has length n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"In recursion n = \\(n), nums length = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Quadratic order (recursive implementation) */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`In recursion n = ${n}, nums length = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Quadratic order (recursive implementation) */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`In recursion n = ${n}, nums length = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('In recursion n = $n, nums length = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Quadratic order (recursive implementation) */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // Array nums has length n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"In recursion n = {}, nums length = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"In recursion n = %d, nums length = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* Quadratic order (recursive implementation) */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // Array nums has length n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"In recursion n = $n, nums length = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Quadratic space (recursive) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Array nums has length n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> <p></p> <p> Figure 2-18   Quadratic order space complexity generated by recursive function </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-exponential-order-o2n","level":3,"title":"4.   Exponential Order \\(O(2^n)\\)","text":"<p>Exponential order is common in binary trees. Observe the following figure: a \"full binary tree\" with \\(n\\) levels has \\(2^n - 1\\) nodes, occupying \\(O(2^n)\\) space:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"Exponential order (build full binary tree)\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* Driver Code */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* Driver Code */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* Driver Code */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* Driver Code */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* Driver Code */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* Driver Code */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* Driver Code */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* Driver Code */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* Driver Code */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* Driver Code */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* Driver Code */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### Exponential space (build full binary tree) ###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> <p></p> <p> Figure 2-19   Exponential order space complexity generated by full binary tree </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-logarithmic-order-olog-n","level":3,"title":"5.   Logarithmic Order \\(O(\\log n)\\)","text":"<p>Logarithmic order is common in divide-and-conquer algorithms. For example, merge sort: given an input array of length \\(n\\), each recursion divides the array in half from the midpoint, forming a recursion tree of height \\(\\log n\\), using \\(O(\\log n)\\) stack frame space.</p> <p>Another example is converting a number to a string. Given a positive integer \\(n\\), it has \\(\\lfloor \\log_{10} n \\rfloor + 1\\) digits, i.e., the corresponding string length is \\(\\lfloor \\log_{10} n \\rfloor + 1\\), so the space complexity is \\(O(\\log_{10} n + 1) = O(\\log n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244-trading-time-for-space","level":2,"title":"2.4.4   Trading Time for Space","text":"<p>Ideally, we hope that both the time complexity and space complexity of an algorithm can reach optimal. However, in practice, optimizing both time complexity and space complexity simultaneously is usually very difficult.</p> <p>Reducing time complexity usually comes at the cost of increasing space complexity, and vice versa. The approach of sacrificing memory space to improve algorithm execution speed is called \"trading space for time\"; conversely, it is called \"trading time for space\".</p> <p>The choice of which approach depends on which aspect we value more. In most cases, time is more precious than space, so \"trading space for time\" is usually the more common strategy. Of course, when the data volume is very large, controlling space complexity is also very important.</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   Summary","text":"","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<p>Algorithm Efficiency Assessment</p> <ul> <li>Time efficiency and space efficiency are the two primary evaluation metrics for measuring algorithm performance.</li> <li>We can evaluate algorithm efficiency through actual testing, but it is difficult to eliminate the influence of the testing environment, and it consumes substantial computational resources.</li> <li>Complexity analysis can eliminate the drawbacks of actual testing, with results applicable to all running platforms, and it can reveal algorithm efficiency under different data scales.</li> </ul> <p>Time Complexity</p> <ul> <li>Time complexity is used to measure the trend of algorithm runtime as data volume increases. It can effectively evaluate algorithm efficiency, but may fail in certain situations, such as when the input data volume is small or when time complexities are identical, making it impossible to precisely compare algorithm efficiency.</li> <li>Worst-case time complexity is represented using Big \\(O\\) notation, corresponding to the asymptotic upper bound of a function, reflecting the growth level of the number of operations \\(T(n)\\) as \\(n\\) approaches positive infinity.</li> <li>Deriving time complexity involves two steps: first, counting the number of operations, then determining the asymptotic upper bound.</li> <li>Common time complexities arranged from low to high include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\), and \\(O(n!)\\).</li> <li>The time complexity of some algorithms is not fixed, but rather depends on the distribution of input data. Time complexity is divided into worst-case, best-case, and average-case time complexity. Best-case time complexity is rarely used because input data generally needs to satisfy strict conditions to achieve the best case.</li> <li>Average time complexity reflects the algorithm's runtime efficiency under random data input, and is closest to the algorithm's performance in practical applications. Calculating average time complexity requires statistical analysis of input data distribution and the combined mathematical expectation.</li> </ul> <p>Space Complexity</p> <ul> <li>Space complexity serves a similar purpose to time complexity, used to measure the trend of algorithm memory usage as data volume increases.</li> <li>The memory space related to algorithm execution can be divided into input space, temporary space, and output space. Typically, input space is not included in space complexity calculations. Temporary space can be divided into temporary data, stack frame space, and instruction space, where stack frame space usually affects space complexity only in recursive functions.</li> <li>We typically only focus on worst-case space complexity, which is the space complexity of an algorithm under worst-case input data and worst-case runtime.</li> <li>Common space complexities arranged from low to high include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\), and \\(O(2^n)\\).</li> </ul>","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is the space complexity of tail recursion \\(O(1)\\)?</p> <p>Theoretically, the space complexity of tail recursive functions can be optimized to \\(O(1)\\). However, most programming languages (such as Java, Python, C++, Go, C#, etc.) do not support automatic tail recursion optimization, so the space complexity is generally considered to be \\(O(n)\\).</p> <p>Q: What is the difference between the terms function and method?</p> <p>A function can be executed independently, with all parameters passed explicitly. A method is associated with an object, is implicitly passed to the object that invokes it, and can operate on data contained in class instances.</p> <p>The following examples use several common programming languages for illustration.</p> <ul> <li>C is a procedural programming language without object-oriented concepts, so it only has functions. However, we can simulate object-oriented programming by creating structures (struct), and functions associated with structures are equivalent to methods in other programming languages.</li> <li>Java and C# are object-oriented programming languages where code blocks (methods) are typically part of a class. Static methods behave like functions because they are bound to the class and cannot access specific instance variables.</li> <li>C++ and Python support both procedural programming (functions) and object-oriented programming (methods).</li> </ul> <p>Q: Does the diagram for \"common space complexity types\" reflect the absolute size of occupied space?</p> <p>No, the diagram shows space complexity, which reflects growth trends rather than the absolute size of occupied space.</p> <p>Assuming \\(n = 8\\), you might find that the values of each curve do not correspond to the functions. This is because each curve contains a constant term used to compress the value range into a visually comfortable range.</p> <p>In practice, because we generally do not know what the \"constant term\" complexity of each method is, we usually cannot select the optimal solution for \\(n = 8\\) based on complexity alone. But for \\(n = 8^5\\), the choice is straightforward, as the growth trend already dominates.</p> <p>Q: Are there situations where algorithms are designed to sacrifice time (or space) based on actual use cases?</p> <p>In practical applications, most situations choose to sacrifice space for time. For example, with database indexes, we typically choose to build B+ trees or hash indexes, occupying substantial memory space in exchange for efficient queries of \\(O(\\log n)\\) or even \\(O(1)\\).</p> <p>In scenarios where space resources are precious, time may be sacrificed for space. For example, in embedded development, device memory is precious, and engineers may forgo using hash tables and choose to use array sequential search to save memory usage, at the cost of slower searches.</p>","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   Time Complexity","text":"<p>Runtime can intuitively and accurately reflect the efficiency of an algorithm. If we want to accurately estimate the runtime of a piece of code, how should we proceed?</p> <ol> <li>Determine the running platform, including hardware configuration, programming language, system environment, etc., as these factors all affect code execution efficiency.</li> <li>Evaluate the runtime required for various computational operations, for example, an addition operation <code>+</code> requires 1 ns, a multiplication operation <code>*</code> requires 10 ns, a print operation <code>print()</code> requires 5 ns, etc.</li> <li>Count all computational operations in the code, and sum the execution times of all operations to obtain the runtime.</li> </ol> <p>For example, in the following code, the input data size is \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># On a certain running platform\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # Loop n times\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // Loop n times\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // Loop n times\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// On a certain running platform\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // Loop n times\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># On a certain running platform\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # Loop n times\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>According to the above method, the algorithm's runtime can be obtained as \\((6n + 12)\\) ns:</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>In reality, however, counting an algorithm's runtime is neither reasonable nor realistic. First, we do not want to tie the estimated time to the running platform, because algorithms need to run on various different platforms. Second, it is difficult to know the runtime of each type of operation, which brings great difficulty to the estimation process.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231-counting-time-growth-trends","level":2,"title":"2.3.1   Counting Time Growth Trends","text":"<p>Time complexity analysis does not count the algorithm's runtime, but rather counts the growth trend of the algorithm's runtime as the data volume increases.</p> <p>The concept of \"time growth trend\" is rather abstract; let us understand it through an example. Suppose the input data size is \\(n\\), and given three algorithms <code>A</code>, <code>B</code>, and <code>C</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Time complexity of algorithm A: constant order\ndef algorithm_A(n: int):\n    print(0)\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Time complexity of algorithm B: linear order\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Time complexity of algorithm B: linear order\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Time complexity of algorithm B: linear order\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// Time complexity of algorithm C: constant order\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithmA(int n) {\n  print(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// Time complexity of algorithm B: linear order\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># Time complexity of algorithm A: constant order\ndef algorithm_A(n)\n    puts 0\nend\n\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>Figure 2-7 shows the time complexity of the above three algorithm functions.</p> <ul> <li>Algorithm <code>A</code> has only \\(1\\) print operation, and the algorithm's runtime does not grow as \\(n\\) increases. We call the time complexity of this algorithm \"constant order\".</li> <li>In algorithm <code>B</code>, the print operation needs to loop \\(n\\) times, and the algorithm's runtime grows linearly as \\(n\\) increases. The time complexity of this algorithm is called \"linear order\".</li> <li>In algorithm <code>C</code>, the print operation needs to loop \\(1000000\\) times. Although the runtime is very long, it is independent of the input data size \\(n\\). Therefore, the time complexity of <code>C</code> is the same as <code>A</code>, still \"constant order\".</li> </ul> <p></p> <p> Figure 2-7   Time growth trends of algorithms A, B, and C </p> <p>Compared to directly counting the algorithm's runtime, what are the characteristics of time complexity analysis?</p> <ul> <li>Time complexity can effectively evaluate algorithm efficiency. For example, the runtime of algorithm <code>B</code> grows linearly; when \\(n &gt; 1\\) it is slower than algorithm <code>A</code>, and when \\(n &gt; 1000000\\) it is slower than algorithm <code>C</code>. In fact, as long as the input data size \\(n\\) is sufficiently large, an algorithm with \"constant order\" complexity will always be superior to one with \"linear order\" complexity, which is precisely the meaning of time growth trend.</li> <li>The derivation method for time complexity is simpler. Obviously, the running platform and the types of computational operations are both unrelated to the growth trend of the algorithm's runtime. Therefore, in time complexity analysis, we can simply treat the execution time of all computational operations as the same \"unit time\", thus simplifying \"counting computational operation runtime\" to \"counting the number of computational operations\", which greatly reduces the difficulty of estimation.</li> <li>Time complexity also has certain limitations. For example, although algorithms <code>A</code> and <code>C</code> have the same time complexity, their actual runtimes differ significantly. Similarly, although algorithm <code>B</code> has a higher time complexity than <code>C</code>, when the input data size \\(n\\) is small, algorithm <code>B</code> is clearly superior to algorithm <code>C</code>. In such cases, it is often difficult to judge the efficiency of algorithms based solely on time complexity. Of course, despite the above issues, complexity analysis remains the most effective and commonly used method for evaluating algorithm efficiency.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232-asymptotic-upper-bound-of-functions","level":2,"title":"2.3.2   Asymptotic Upper Bound of Functions","text":"<p>Given a function with input size \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Loop n times\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // +1 (i++ is executed each round)\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Loop n times\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i &lt; n; i++){ // +1 (i++ is executed each round)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i &lt; n; i++){ // +1 (i++ is executed each round)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Loop n times\n  for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Loop n times\n    for _ in 0..n { // +1 (i++ is executed each round)\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // +1 (i++ is executed each round)\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for (i in 0..&lt;n) { // +1 (i++ is executed each round)\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # Loop n times\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>Let the number of operations of the algorithm be a function of the input data size \\(n\\), denoted as \\(T(n)\\). Then the number of operations of the above function is:</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) is a linear function, indicating that its runtime growth trend is linear, and therefore its time complexity is linear order.</p> <p>We denote the time complexity of linear order as \\(O(n)\\). This mathematical symbol is called big-\\(O\\) notation, representing the asymptotic upper bound of the function \\(T(n)\\).</p> <p>Time complexity analysis essentially calculates the asymptotic upper bound of \"the number of operations \\(T(n)\\)\", which has a clear mathematical definition.</p> <p>Asymptotic upper bound of functions</p> <p>If there exist positive real numbers \\(c\\) and \\(n_0\\) such that for all \\(n &gt; n_0\\), we have \\(T(n) \\leq c \\cdot f(n)\\), then \\(f(n)\\) can be considered as an asymptotic upper bound of \\(T(n)\\), denoted as \\(T(n) = O(f(n))\\).</p> <p>As shown in Figure 2-8, calculating the asymptotic upper bound is to find a function \\(f(n)\\) such that when \\(n\\) tends to infinity, \\(T(n)\\) and \\(f(n)\\) are at the same growth level, differing only by a constant coefficient \\(c\\).</p> <p></p> <p> Figure 2-8   Asymptotic upper bound of a function </p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233-derivation-method","level":2,"title":"2.3.3   Derivation Method","text":"<p>The asymptotic upper bound has a bit of mathematical flavor. If you feel you haven't fully understood it, don't worry. We can first master the derivation method, and gradually grasp its mathematical meaning through continuous practice.</p> <p>According to the definition, after determining \\(f(n)\\), we can obtain the time complexity \\(O(f(n))\\). So how do we determine the asymptotic upper bound \\(f(n)\\)? Overall, it is divided into two steps: first count the number of operations, then determine the asymptotic upper bound.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-step-1-count-the-number-of-operations","level":3,"title":"1.   Step 1: Count the Number of Operations","text":"<p>For code, count from top to bottom line by line. However, since the constant coefficient \\(c\\) in \\(c \\cdot f(n)\\) above can be of any size, coefficients and constant terms in the number of operations \\(T(n)\\) can all be ignored. According to this principle, the following counting simplification techniques can be summarized.</p> <ol> <li>Ignore constants in \\(T(n)\\). Because they are all independent of \\(n\\), they do not affect time complexity.</li> <li>Omit all coefficients. For example, looping \\(2n\\) times, \\(5n + 1\\) times, etc., can all be simplified as \\(n\\) times, because the coefficient before \\(n\\) does not affect time complexity.</li> <li>Use multiplication for nested loops. The total number of operations equals the product of the number of operations in the outer and inner loops, with each layer of loop still able to apply techniques <code>1.</code> and <code>2.</code> separately.</li> </ol> <p>Given a function, we can use the above techniques to count the number of operations:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0 (Technique 1)\n    a = a + n  # +0 (Technique 1)\n    # +n (Technique 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (Technique 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0 (Technique 1)\n    a = a + n  // +0 (Technique 1)\n    // +n (Technique 2)\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (Technique 3)\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0 (Technique 1)\n    a = a + n // +0 (Technique 1)\n    // +n (Technique 2)\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (Technique 3)\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (Technique 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (Technique 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0 (Technique 1)\n  a = a + n; // +0 (Technique 1)\n  // +n (Technique 2)\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (Technique 3)\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (Technique 1)\n    a = a + n;        // +0 (Technique 1)\n\n    // +n (Technique 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (Technique 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0 (Technique 1)\n    a = a + n   // +0 (Technique 1)\n    // +n (Technique 2)\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n (Technique 3)\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0 (Technique 1)\n    a = a + n   # +0 (Technique 1)\n    # +n (Technique 2)\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n (Technique 3)\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>The following formula shows the counting results before and after using the above techniques; both derive a time complexity of \\(O(n^2)\\).</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{Complete count (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{Simplified count (o.O)} \\end{aligned} \\]","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-step-2-determine-the-asymptotic-upper-bound","level":3,"title":"2.   Step 2: Determine the Asymptotic Upper Bound","text":"<p>Time complexity is determined by the highest-order term in \\(T(n)\\). This is because as \\(n\\) tends to infinity, the highest-order term will play a dominant role, and the influence of other terms can be ignored.</p> <p>Table 2-2 shows some examples, where some exaggerated values are used to emphasize the conclusion that \"coefficients cannot shake the order\". When \\(n\\) tends to infinity, these constants become insignificant.</p> <p> Table 2-2   Time complexities corresponding to different numbers of operations </p> Number of Operations \\(T(n)\\) Time Complexity \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234-common-types","level":2,"title":"2.3.4   Common Types","text":"<p>Let the input data size be \\(n\\). Common time complexity types are shown in Figure 2-9 (arranged in order from low to high).</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{Constant order} &lt; \\text{Logarithmic order} &lt; \\text{Linear order} &lt; \\text{Linearithmic order} &lt; \\text{Quadratic order} &lt; \\text{Exponential order} &lt; \\text{Factorial order} \\end{aligned} \\] <p></p> <p> Figure 2-9   Common time complexity types </p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-constant-order-o1","level":3,"title":"1.   Constant Order \\(O(1)\\)","text":"<p>The number of operations in constant order is independent of the input data size \\(n\\), meaning it does not change as \\(n\\) changes.</p> <p>In the following function, although the number of operations <code>size</code> may be large, since it is independent of the input data size \\(n\\), the time complexity remains \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"Constant order\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Constant order */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Constant order */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Constant order */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Constant order */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Constant order */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Constant order */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Constant order */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Constant order */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Constant time ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-linear-order-on","level":3,"title":"2.   Linear Order \\(O(n)\\)","text":"<p>The number of operations in linear order grows linearly relative to the input data size \\(n\\). Linear order typically appears in single-layer loops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"Linear order\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linear order */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linear order */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linear order */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linear order */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linear order */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linear order */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linear order */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linear order */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linear time ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> <p>Operations such as traversing arrays and traversing linked lists have a time complexity of \\(O(n)\\), where \\(n\\) is the length of the array or linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"Linear order (traversing array)\"\"\"\n    count = 0\n    # Number of iterations is proportional to the array length\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linear order (traversing array) */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linear order (traversing array) */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // Number of iterations is proportional to the array length\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linear order (traversing array) */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // Number of iterations is proportional to the array length\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linear order (traversing array) */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // Number of iterations is proportional to the array length\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linear order (traversing array) */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // Number of iterations is proportional to the array length\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // Number of iterations is proportional to the array length\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linear order (traversing array) */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // Number of iterations is proportional to the array length\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linear order (traversing array) */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // Number of iterations is proportional to the array length\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linear time (array traversal) ###\ndef array_traversal(nums)\n  count = 0\n\n  # Number of iterations is proportional to the array length\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> <p>It is worth noting that the input data size \\(n\\) should be determined according to the type of input data. For example, in the first example, the variable \\(n\\) is the input data size; in the second example, the array length \\(n\\) is the data size.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-quadratic-order-on2","level":3,"title":"3.   Quadratic Order \\(O(n^2)\\)","text":"<p>The number of operations in quadratic order grows quadratically relative to the input data size \\(n\\). Quadratic order typically appears in nested loops, where both the outer and inner loops have a time complexity of \\(O(n)\\), resulting in an overall time complexity of \\(O(n^2)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"Quadratic order\"\"\"\n    count = 0\n    # Number of iterations is quadratically related to the data size n\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order */\nint Quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order */\nfunc quadratic(n int) int {\n    count := 0\n    // Number of iterations is quadratically related to the data size n\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // Number of iterations is quadratically related to the data size n\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order */\nfunction quadratic(n) {\n    let count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order */\nint quadratic(int n) {\n  int count = 0;\n  // Number of iterations is quadratically related to the data size n\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // Number of iterations is quadratically related to the data size n\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Quadratic time ###\ndef quadratic(n)\n  count = 0\n\n  # Number of iterations is quadratically related to the data size n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> <p>Figure 2-10 compares constant order, linear order, and quadratic order time complexities.</p> <p></p> <p> Figure 2-10   Time complexities of constant, linear, and quadratic orders </p> <p>Taking bubble sort as an example, the outer loop executes \\(n - 1\\) times, and the inner loop executes \\(n-1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\) times, averaging \\(n / 2\\) times, resulting in a time complexity of \\(O((n - 1) n / 2) = O(n^2)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"Quadratic order (bubble sort)\"\"\"\n    count = 0  # Counter\n    # Outer loop: unsorted range is [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # Element swap includes 3 unit operations\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(int[] nums) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Quadratic order (bubble sort) */\nint BubbleSort(int[] nums) {\n    int count = 0;  // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Quadratic order (bubble sort) */\nfunc bubbleSort(nums []int) int {\n    count := 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Quadratic order (bubble sort) */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Quadratic order (bubble sort) */\nfunction bubbleSort(nums) {\n    let count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Quadratic order (bubble sort) */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // Counter\n  // Outer loop: unsorted range is [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // Element swap includes 3 unit operations\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Quadratic order (bubble sort) */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // Counter\n\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Quadratic order (bubble sort) */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Quadratic time (bubble sort) ###\ndef bubble_sort(nums)\n  count = 0  # Counter\n\n  # Outer loop: unsorted range is [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Element swap includes 3 unit operations\n      end\n    end\n  end\n\n  count\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-exponential-order-o2n","level":3,"title":"4.   Exponential Order \\(O(2^n)\\)","text":"<p>Biological \"cell division\" is a typical example of exponential order growth: the initial state is \\(1\\) cell, after one round of division it becomes \\(2\\), after two rounds it becomes \\(4\\), and so on; after \\(n\\) rounds of division there are \\(2^n\\) cells.</p> <p>Figure 2-11 and the following code simulate the cell division process, with a time complexity of \\(O(2^n)\\). Note that the input \\(n\\) represents the number of division rounds, and the return value <code>count</code> represents the total number of divisions.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"Exponential order (loop implementation)\"\"\"\n    count = 0\n    base = 1\n    # Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order (loop implementation) */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order (loop implementation) */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order (loop implementation) */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order (loop implementation) */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order (loop implementation) */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order (loop implementation) */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order (loop implementation) */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Exponential time (iterative) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> <p></p> <p> Figure 2-11   Time complexity of exponential order </p> <p>In actual algorithms, exponential order often appears in recursive functions. For example, in the following code, it recursively splits in two, stopping after \\(n\\) splits:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"Exponential order (recursive implementation)\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order (recursive implementation) */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order (recursive implementation) */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order (recursive implementation) */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order (recursive implementation) */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order (recursive implementation) */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order (recursive implementation) */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order (recursive implementation) */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Exponential time (recursive) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> <p>Exponential order growth is very rapid and is common in exhaustive methods (brute force search, backtracking, etc.). For problems with large data scales, exponential order is unacceptable and typically requires dynamic programming or greedy algorithms to solve.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-logarithmic-order-olog-n","level":3,"title":"5.   Logarithmic Order \\(O(\\log n)\\)","text":"<p>In contrast to exponential order, logarithmic order reflects the situation of \"reducing to half each round\". Let the input data size be \\(n\\). Since it is reduced to half each round, the number of loops is \\(\\log_2 n\\), which is the inverse function of \\(2^n\\).</p> <p>Figure 2-12 and the following code simulate the process of \"reducing to half each round\", with a time complexity of \\(O(\\log_2 n)\\), abbreviated as \\(O(\\log n)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"Logarithmic order (loop implementation)\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Logarithmic order (loop implementation) */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Logarithmic order (loop implementation) */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Logarithmic order (loop implementation) */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Logarithmic order (loop implementation) */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Logarithmic order (loop implementation) */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Logarithmic order (loop implementation) */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Logarithmic order (loop implementation) */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Logarithmic time (iterative) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> <p></p> <p> Figure 2-12   Time complexity of logarithmic order </p> <p>Like exponential order, logarithmic order also commonly appears in recursive functions. The following code forms a recursion tree of height \\(\\log_2 n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"Logarithmic order (recursive implementation)\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Logarithmic order (recursive implementation) */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Logarithmic order (recursive implementation) */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Logarithmic order (recursive implementation) */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Logarithmic order (recursive implementation) */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Logarithmic order (recursive implementation) */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Logarithmic order (recursive implementation) */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Logarithmic order (recursive implementation) */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Logarithmic time (recursive) ###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> <p>Logarithmic order commonly appears in algorithms based on the divide-and-conquer strategy, embodying the algorithmic thinking of \"dividing into many\" and \"simplifying complexity\". It grows slowly and is the ideal time complexity second only to constant order.</p> <p>What is the base of \\(O(\\log n)\\)?</p> <p>To be precise, \"dividing into \\(m\\)\" corresponds to a time complexity of \\(O(\\log_m n)\\). And through the logarithmic base change formula, we can obtain time complexities with different bases that are equal:</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>That is to say, the base \\(m\\) can be converted without affecting the complexity. Therefore, we usually omit the base \\(m\\) and denote logarithmic order simply as \\(O(\\log n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-linearithmic-order-on-log-n","level":3,"title":"6.   Linearithmic Order \\(O(n \\log n)\\)","text":"<p>Linearithmic order commonly appears in nested loops, where the time complexities of the two layers of loops are \\(O(\\log n)\\) and \\(O(n)\\) respectively. The relevant code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"Linearithmic order\"\"\"\n    if n &lt;= 1:\n        return 1\n    # Divide into two, the scale of subproblems is reduced by half\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # Current subproblem contains n operations\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linearithmic order */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linearithmic order */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linearithmic order */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linearithmic order */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linearithmic order */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linearithmic order */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linearithmic order */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linearithmic time ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> <p>Figure 2-13 shows how linearithmic order is generated. Each level of the binary tree has a total of \\(n\\) operations, and the tree has \\(\\log_2 n + 1\\) levels, resulting in a time complexity of \\(O(n \\log n)\\).</p> <p></p> <p> Figure 2-13   Time complexity of linearithmic order </p> <p>Mainstream sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), such as quicksort, merge sort, and heap sort.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-factorial-order-on","level":3,"title":"7.   Factorial Order \\(O(n!)\\)","text":"<p>Factorial order corresponds to the mathematical \"permutation\" problem. Given \\(n\\) distinct elements, find all possible permutation schemes; the number of schemes is:</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>Factorials are typically implemented using recursion. As shown in Figure 2-14 and the following code, the first level splits into \\(n\\) branches, the second level splits into \\(n - 1\\) branches, and so on, until the \\(n\\)-th level when splitting stops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"Factorial order (recursive implementation)\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # Split from 1 into n\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Factorial order (recursive implementation) */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Factorial order (recursive implementation) */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // Split from 1 into n\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Factorial order (recursive implementation) */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // Split from 1 into n\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Factorial order (recursive implementation) */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // Split from 1 into n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Factorial order (recursive implementation) */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // Split from 1 into n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // Split from 1 into n\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Factorial order (recursive implementation) */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // Split from 1 into n\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Factorial order (recursive implementation) */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // Split from 1 into n\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Factorial time (recursive) ###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # Split from 1 into n\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> <p></p> <p> Figure 2-14   Time complexity of factorial order </p> <p>Note that because when \\(n \\geq 4\\) we always have \\(n! &gt; 2^n\\), factorial order grows faster than exponential order, and is also unacceptable for large \\(n\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235-worst-best-and-average-time-complexities","level":2,"title":"2.3.5   Worst, Best, and Average Time Complexities","text":"<p>The time efficiency of an algorithm is often not fixed, but is related to the distribution of the input data. Suppose we input an array <code>nums</code> of length \\(n\\), where <code>nums</code> consists of numbers from \\(1\\) to \\(n\\), with each number appearing only once, but the element order is randomly shuffled. The task is to return the index of element \\(1\\). We can draw the following conclusions.</p> <ul> <li>When <code>nums = [?, ?, ..., 1]</code>, i.e., when the last element is \\(1\\), it requires a complete traversal of the array, reaching worst-case time complexity \\(O(n)\\).</li> <li>When <code>nums = [1, ?, ?, ...]</code>, i.e., when the first element is \\(1\\), no matter how long the array is, there is no need to continue traversing, reaching best-case time complexity \\(\\Omega(1)\\).</li> </ul> <p>The \"worst-case time complexity\" corresponds to the function's asymptotic upper bound, denoted using big-\\(O\\) notation. Correspondingly, the \"best-case time complexity\" corresponds to the function's asymptotic lower bound, denoted using \\(\\Omega\\) notation:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"Generate an array with elements: 1, 2, ..., n, shuffled in order\"\"\"\n    # Generate array nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # Randomly shuffle array elements\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"Find the index of number 1 in array nums\"\"\"\n    for i in range(len(nums)):\n        # When element 1 is at the head of the array, best time complexity O(1) is achieved\n        # When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Use system time to generate random seed\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // Randomly shuffle array elements\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // Randomly shuffle array elements\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // Randomly shuffle array elements\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* Find the index of number 1 in array nums */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // Generate array nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // Randomly shuffle array elements\n    nums.shuffle()\n    return nums\n}\n\n/* Find the index of number 1 in array nums */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // Generate array nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // Randomly shuffle array elements\n  nums.shuffle();\n\n  return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // When element 1 is at the head of the array, best time complexity O(1) is achieved\n    // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // Generate array nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // Randomly shuffle array elements\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* Find the index of number 1 in array nums */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint *randomNumbers(int n) {\n    // Allocate heap memory (create 1D variable-length array: n elements of type int)\n    int *nums = (int *)malloc(n * sizeof(int));\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // Randomly shuffle array elements\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* Find the index of number 1 in array nums */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### Generate array with elements: 1, 2, ..., n, shuffled ###\ndef random_numbers(n)\n  # Generate array nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # Randomly shuffle array elements\n  nums.shuffle!\nend\n\n### Find index of number 1 in array nums ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # When element 1 is at the head of the array, best time complexity O(1) is achieved\n    # When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> <p>It is worth noting that we rarely use best-case time complexity in practice, because it can usually only be achieved with a very small probability and may be somewhat misleading. The worst-case time complexity is more practical because it gives a safety value for efficiency, allowing us to use the algorithm with confidence.</p> <p>From the above example, we can see that both worst-case and best-case time complexities only occur under \"special data distributions\", which may have a very small probability of occurrence and may not truly reflect the algorithm's running efficiency. In contrast, average time complexity can reflect the algorithm's running efficiency under random input data, denoted using the \\(\\Theta\\) notation.</p> <p>For some algorithms, we can simply derive the average case under random data distribution. For example, in the above example, since the input array is shuffled, the probability of element \\(1\\) appearing at any index is equal, so the algorithm's average number of loops is half the array length \\(n / 2\\), giving an average time complexity of \\(\\Theta(n / 2) = \\Theta(n)\\).</p> <p>But for more complex algorithms, calculating average time complexity is often quite difficult, because it is hard to analyze the overall mathematical expectation under data distribution. In this case, we usually use worst-case time complexity as the criterion for judging algorithm efficiency.</p> <p>Why is the \\(\\Theta\\) symbol rarely seen?</p> <p>This may be because the \\(O\\) symbol is too catchy, so we often use it to represent average time complexity. But strictly speaking, this practice is not standard. In this book and other materials, if you encounter expressions like \"average time complexity \\(O(n)\\)\", please understand it directly as \\(\\Theta(n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"Chapter 3.   Data Structures","text":"<p>Abstract</p> <p>Data structure is like a sturdy and diverse framework.</p> <p>It provides a blueprint for the orderly organization of data, upon which algorithms come to life.</p>","path":["Chapter 3. Data Structures","Chapter 3. &nbsp; Data Structures"],"tags":[]},{"location":"chapter_data_structure/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>3.1   Classification of Data Structures</li> <li>3.2   Basic Data Types</li> <li>3.3   Number Encoding *</li> <li>3.4   Character Encoding *</li> <li>3.5   Summary</li> </ul>","path":["Chapter 3. Data Structures","Chapter 3. &nbsp; Data Structures"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   Basic Data Types","text":"<p>When we talk about data in computers, we think of various forms such as text, images, videos, audio, 3D models, and more. Although these data are organized in different ways, they are all composed of various basic data types.</p> <p>Basic data types are types that the CPU can directly operate on, and they are directly used in algorithms, mainly including the following.</p> <ul> <li>Integer types <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>.</li> <li>Floating-point types <code>float</code>, <code>double</code>, used to represent decimal numbers.</li> <li>Character type <code>char</code>, used to represent letters, punctuation marks, and even emojis in various languages.</li> <li>Boolean type <code>bool</code>, used to represent \"yes\" and \"no\" judgments.</li> </ul> <p>Basic data types are stored in binary form in computers. One binary bit is \\(1\\) bit. In most modern operating systems, \\(1\\) byte consists of \\(8\\) bits.</p> <p>The range of values for basic data types depends on the size of the space they occupy. Below is an example using Java.</p> <ul> <li>Integer type <code>byte</code> occupies \\(1\\) byte = \\(8\\) bits, and can represent \\(2^{8}\\) numbers.</li> <li>Integer type <code>int</code> occupies \\(4\\) bytes = \\(32\\) bits, and can represent \\(2^{32}\\) numbers.</li> </ul> <p>The following table lists the space occupied, value ranges, and default values of various basic data types in Java. You don't need to memorize this table; a general understanding is sufficient, and you can refer to it when needed.</p> <p> Table 3-1   Space occupied and value ranges of basic data types </p> Type Symbol Space Occupied Minimum Value Maximum Value Default Value Integer <code>byte</code> 1 byte \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 bytes \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 bytes \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 bytes \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) Float <code>float</code> 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) Character <code>char</code> 2 bytes \\(0\\) \\(2^{16} - 1\\) \\(0\\) Boolean <code>bool</code> 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>Please note that the above table is specific to Java's basic data types. Each programming language has its own data type definitions, and their space occupied, value ranges, and default values may vary.</p> <ul> <li>In Python, the integer type <code>int</code> can be of any size, limited only by available memory; the floating-point type <code>float</code> is double-precision 64-bit; there is no <code>char</code> type, a single character is actually a string <code>str</code> of length 1.</li> <li>C and C++ do not explicitly specify the size of basic data types, which varies by implementation and platform. The above table follows the LP64 data model, which is used in Unix 64-bit operating systems including Linux and macOS.</li> <li>The size of character <code>char</code> is 1 byte in C and C++, and in most programming languages it depends on the specific character encoding method, as detailed in the \"Character Encoding\" section.</li> <li>Even though representing a boolean value requires only 1 bit (\\(0\\) or \\(1\\)), it is usually stored as 1 byte in memory. This is because modern computer CPUs typically use 1 byte as the minimum addressable memory unit.</li> </ul> <p>So, what is the relationship between basic data types and data structures? We know that data structures are ways of organizing and storing data in computers. The subject of this statement is \"structure\", not \"data\".</p> <p>If we want to represent \"a row of numbers\", we naturally think of using an array. This is because the linear structure of an array can represent the adjacency and order relationships of numbers, but the content stored—whether integer <code>int</code>, floating-point <code>float</code>, or character <code>char</code>—is unrelated to the \"data structure\".</p> <p>In other words, basic data types provide the \"content type\" of data, while data structures provide the \"organization method\" of data. For example, in the following code, we use the same data structure (array) to store and represent different basic data types, including <code>int</code>, <code>float</code>, <code>char</code>, <code>bool</code>, etc.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Initialize arrays using various basic data types\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# In Python, characters are actually strings of length 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript arrays can freely store various basic data types and objects\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E4%BD%BF%E7%94%A8%E5%A4%9A%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20*%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%AD%97%E7%AC%A6%E5%AE%9E%E9%99%85%E4%B8%8A%E6%98%AF%E9%95%BF%E5%BA%A6%E4%B8%BA%201%20%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%0A%20%20%20%20characters%20%3D%20%5B'0'%5D%20*%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%88%97%E8%A1%A8%E5%8F%AF%E4%BB%A5%E8%87%AA%E7%94%B1%E5%AD%98%E5%82%A8%E5%90%84%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%AF%B9%E8%B1%A1%E5%BC%95%E7%94%A8%0A%20%20%20%20data%20%3D%20%5B0,%200.0,%20'a',%20False,%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Chapter 3. Data Structures","3.2 &nbsp; Basic Data Types"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   Character Encoding *","text":"<p>In computers, all data is stored in binary form, and character <code>char</code> is no exception. To represent characters, we need to establish a \"character set\" that defines a one-to-one correspondence between each character and binary numbers. With a character set, computers can convert binary numbers to characters by looking up the table.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii-character-set","level":2,"title":"3.4.1   Ascii Character Set","text":"<p>ASCII code is the earliest character set, with the full name American Standard Code for Information Interchange. It uses 7 binary bits (the lower 7 bits of one byte) to represent a character, and can represent a maximum of 128 different characters. As shown in Figure 3-6, ASCII code includes uppercase and lowercase English letters, numbers 0 ~ 9, some punctuation marks, and some control characters (such as newline and tab).</p> <p></p> <p> Figure 3-6   ASCII code </p> <p>However, ASCII code can only represent English. With the globalization of computers, a character set called EASCII that can represent more languages emerged. It expands from the 7-bit basis of ASCII to 8 bits, and can represent 256 different characters.</p> <p>Worldwide, a batch of EASCII character sets suitable for different regions have appeared successively. The first 128 characters of these character sets are unified as ASCII code, and the last 128 characters are defined differently to adapt to the needs of different languages.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk-character-set","level":2,"title":"3.4.2   Gbk Character Set","text":"<p>Later, people found that EASCII code still cannot meet the character quantity requirements of many languages. For example, there are nearly one hundred thousand Chinese characters, and several thousand are used daily. In 1980, the China National Standardization Administration released the GB2312 character set, which included 6,763 Chinese characters, basically meeting the needs for computer processing of Chinese characters.</p> <p>However, GB2312 cannot handle some rare characters and traditional Chinese characters. The GBK character set is an extension based on GB2312, which includes a total of 21,886 Chinese characters. In the GBK encoding scheme, ASCII characters are represented using one byte, and Chinese characters are represented using two bytes.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode-character-set","level":2,"title":"3.4.3   Unicode Character Set","text":"<p>With the vigorous development of computer technology, character sets and encoding standards flourished, which brought many problems. On the one hand, these character sets generally only define characters for specific languages and cannot work normally in multilingual environments. On the other hand, multiple character set standards exist for the same language, and if two computers use different encoding standards, garbled characters will appear during information transmission.</p> <p>Researchers of that era thought: If a sufficiently complete character set is released that includes all languages and symbols in the world, wouldn't it be possible to solve cross-language environment and garbled character problems? Driven by this idea, a large and comprehensive character set, Unicode, was born.</p> <p>Unicode is called \"统一码\" (Unified Code) in Chinese and can theoretically accommodate over one million characters. It is committed to including characters from around the world into a unified character set, providing a universal character set to handle and display various language texts, reducing garbled character problems caused by different encoding standards.</p> <p>Since its release in 1991, Unicode has continuously expanded to include new languages and characters. As of September 2022, Unicode has included 149,186 characters, including characters, symbols, and even emojis from various languages. In the vast Unicode character set, commonly used characters occupy 2 bytes, and some rare characters occupy 3 bytes or even 4 bytes.</p> <p>Unicode is a universal character set that essentially assigns a number (called a \"code point\") to each character, but it does not specify how to store these character code points in computers. We can't help but ask: when Unicode code points of multiple lengths appear simultaneously in a text, how does the system parse the characters? For example, given an encoding with a length of 2 bytes, how does the system determine whether it is one 2-byte character or two 1-byte characters?</p> <p>For the above problem, a straightforward solution is to store all characters as equal-length encodings. As shown in Figure 3-7, each character in \"Hello\" occupies 1 byte, and each character in \"算法\" (algorithm) occupies 2 bytes. We can encode all characters in \"Hello 算法\" as 2 bytes in length by padding the high bits with 0. In this way, the system can parse one character every 2 bytes and restore the content of this phrase.</p> <p></p> <p> Figure 3-7   Unicode encoding example </p> <p>However, ASCII code has already proven to us that encoding English only requires 1 byte. If the above scheme is adopted, the size of English text will be twice that under ASCII encoding, which is very wasteful of memory space. Therefore, we need a more efficient Unicode encoding method.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8-encoding","level":2,"title":"3.4.4   Utf-8 Encoding","text":"<p>Currently, UTF-8 has become the most widely used Unicode encoding method internationally. It is a variable-length encoding that uses 1 to 4 bytes to represent a character, depending on the complexity of the character. ASCII characters only require 1 byte, Latin and Greek letters require 2 bytes, commonly used Chinese characters require 3 bytes, and some other rare characters require 4 bytes.</p> <p>The encoding rules of UTF-8 are not complicated and can be divided into the following two cases.</p> <ul> <li>For 1-byte characters, set the highest bit to \\(0\\), and set the remaining 7 bits to the Unicode code point. It is worth noting that ASCII characters occupy the first 128 code points in the Unicode character set. That is to say, UTF-8 encoding is backward compatible with ASCII code. This means we can use UTF-8 to parse very old ASCII code text.</li> <li>For characters with a length of \\(n\\) bytes (where \\(n &gt; 1\\)), set the highest \\(n\\) bits of the first byte to \\(1\\), and set the \\((n + 1)\\)-th bit to \\(0\\); starting from the second byte, set the highest 2 bits of each byte to \\(10\\); use all remaining bits to fill in the Unicode code point of the character.</li> </ul> <p>Figure 3-8 shows the UTF-8 encoding corresponding to \"Hello算法\". It can be observed that since the highest \\(n\\) bits are all set to \\(1\\), the system can parse the length of the character as \\(n\\) by reading the number of highest bits that are \\(1\\).</p> <p>But why set the highest 2 bits of all other bytes to \\(10\\)? In fact, this \\(10\\) can serve as a check symbol. Assuming the system starts parsing text from an incorrect byte, the \\(10\\) at the beginning of the byte can help the system quickly determine an anomaly.</p> <p>The reason for using \\(10\\) as a check symbol is that under UTF-8 encoding rules, it is impossible for a character's highest two bits to be \\(10\\). This conclusion can be proven by contradiction: assuming the highest two bits of a character are \\(10\\), it means the length of the character is \\(1\\), corresponding to ASCII code. However, the highest bit of ASCII code should be \\(0\\), which contradicts the assumption.</p> <p></p> <p> Figure 3-8   UTF-8 encoding example </p> <p>In addition to UTF-8, common encoding methods also include the following two.</p> <ul> <li>UTF-16 encoding: Uses 2 or 4 bytes to represent a character. All ASCII characters and commonly used non-English characters are represented with 2 bytes; a few characters need to use 4 bytes. For 2-byte characters, UTF-16 encoding is equal to the Unicode code point.</li> <li>UTF-32 encoding: Every character uses 4 bytes. This means that UTF-32 takes up more space than UTF-8 and UTF-16, especially for text with a high proportion of ASCII characters.</li> </ul> <p>From the perspective of storage space occupation, using UTF-8 to represent English characters is very efficient because it only requires 1 byte; using UTF-16 encoding for some non-English characters (such as Chinese) will be more efficient because it only requires 2 bytes, while UTF-8 may require 3 bytes.</p> <p>From a compatibility perspective, UTF-8 has the best universality, and many tools and libraries support UTF-8 first.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345-character-encoding-in-programming-languages","level":2,"title":"3.4.5   Character Encoding in Programming Languages","text":"<p>For most past programming languages, strings during program execution use fixed-length encodings such as UTF-16 or UTF-32. Under fixed-length encoding, we can treat strings as arrays for processing, and this approach has the following advantages.</p> <ul> <li>Random access: UTF-16 encoded strings can be easily accessed randomly. UTF-8 is a variable-length encoding. To find the \\(i\\)-th character, we need to traverse from the beginning of the string to the \\(i\\)-th character, which requires \\(O(n)\\) time.</li> <li>Character counting: Similar to random access, calculating the length of a UTF-16 encoded string is also an \\(O(1)\\) operation. However, calculating the length of a UTF-8 encoded string requires traversing the entire string.</li> <li>String operations: Many string operations (such as splitting, joining, inserting, deleting, etc.) on UTF-16 encoded strings are easier to perform. Performing these operations on UTF-8 encoded strings usually requires additional calculations to ensure that invalid UTF-8 encoding is not generated.</li> </ul> <p>In fact, the design of character encoding schemes for programming languages is a very interesting topic involving many factors.</p> <ul> <li>Java's <code>String</code> type uses UTF-16 encoding, with each character occupying 2 bytes. This is because at the beginning of Java language design, people believed that 16 bits were sufficient to represent all possible characters. However, this was an incorrect judgment. Later, the Unicode specification expanded beyond 16 bits, so characters in Java may now be represented by a pair of 16-bit values (called \"surrogate pairs\").</li> <li>The strings of JavaScript and TypeScript use UTF-16 encoding for reasons similar to Java. When Netscape first introduced the JavaScript language in 1995, Unicode was still in its early stages of development, and at that time, using 16-bit encoding was sufficient to represent all Unicode characters.</li> <li>C# uses UTF-16 encoding mainly because the .NET platform was designed by Microsoft, and many of Microsoft's technologies (including the Windows operating system) extensively use UTF-16 encoding.</li> </ul> <p>Due to the underestimation of character quantities by the above programming languages, they had to adopt the \"surrogate pair\" method to represent Unicode characters with lengths exceeding 16 bits. This is a reluctant compromise. On the one hand, in strings containing surrogate pairs, one character may occupy 2 bytes or 4 bytes, thus losing the advantage of fixed-length encoding. On the other hand, handling surrogate pairs requires additional code, which increases the complexity and difficulty of debugging in programming.</p> <p>For the above reasons, some programming languages have proposed different encoding schemes.</p> <ul> <li>Python's <code>str</code> uses Unicode encoding and adopts a flexible string representation where the stored character length depends on the largest Unicode code point in the string. If all characters in the string are ASCII characters, each character occupies 1 byte; if there are characters exceeding the ASCII range but all within the Basic Multilingual Plane (BMP), each character occupies 2 bytes; if there are characters exceeding the BMP, each character occupies 4 bytes.</li> <li>Go language's <code>string</code> type uses UTF-8 encoding internally. Go language also provides the <code>rune</code> type, which is used to represent a single Unicode code point.</li> <li>Rust language's <code>str</code> and <code>String</code> types use UTF-8 encoding internally. Rust also provides the <code>char</code> type for representing a single Unicode code point.</li> </ul> <p>It should be noted that the above discussion is about how strings are stored in programming languages, which is different from how strings are stored in files or transmitted over networks. In file storage or network transmission, we usually encode strings into UTF-8 format to achieve optimal compatibility and space efficiency.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   Classification of Data Structures","text":"<p>Common data structures include arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs. They can be classified from two dimensions: \"logical structure\" and \"physical structure\".</p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311-logical-structure-linear-and-non-linear","level":2,"title":"3.1.1   Logical Structure: Linear and Non-Linear","text":"<p>Logical structure reveals the logical relationships between data elements. In arrays and linked lists, data is arranged in a certain order, embodying the linear relationship between data; while in trees, data is arranged hierarchically from top to bottom, showing the derived relationship between \"ancestors\" and \"descendants\"; graphs are composed of nodes and edges, reflecting complex network relationships.</p> <p>As shown in Figure 3-1, logical structures can be divided into two major categories: \"linear\" and \"non-linear\". Linear structures are more intuitive, indicating that data is linearly arranged in logical relationships; non-linear structures are the opposite, arranged non-linearly.</p> <ul> <li>Linear data structures: Arrays, linked lists, stacks, queues, hash tables, where elements have a one-to-one sequential relationship.</li> <li>Non-linear data structures: Trees, heaps, graphs, hash tables.</li> </ul> <p>Non-linear data structures can be further divided into tree structures and network structures.</p> <ul> <li>Tree structures: Trees, heaps, hash tables, where elements have a one-to-many relationship.</li> <li>Network structures: Graphs, where elements have a many-to-many relationship.</li> </ul> <p></p> <p> Figure 3-1   Linear and non-linear data structures </p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312-physical-structure-contiguous-and-dispersed","level":2,"title":"3.1.2   Physical Structure: Contiguous and Dispersed","text":"<p>When an algorithm program runs, the data being processed is mainly stored in memory. Figure 3-2 shows a computer memory stick, where each black square contains a memory space. We can imagine memory as a huge Excel spreadsheet, where each cell can store a certain amount of data.</p> <p>The system accesses data at the target location through memory addresses. As shown in Figure 3-2, the computer assigns a number to each cell in the spreadsheet according to specific rules, ensuring that each memory space has a unique memory address. With these addresses, the program can access data in memory.</p> <p></p> <p> Figure 3-2   Memory stick, memory space, memory address </p> <p>Tip</p> <p>It is worth noting that comparing memory to an Excel spreadsheet is a simplified analogy. The actual working mechanism of memory is quite complex, involving concepts such as address space, memory management, cache mechanisms, virtual memory, and physical memory.</p> <p>Memory is a shared resource for all programs. When a block of memory is occupied by a program, it usually cannot be used by other programs at the same time. Therefore, in the design of data structures and algorithms, memory resources are an important consideration. For example, the peak memory occupied by an algorithm should not exceed the remaining free memory of the system; if there is a lack of contiguous large memory blocks, then the data structure chosen must be able to be stored in dispersed memory spaces.</p> <p>As shown in Figure 3-3, physical structure reflects the way data is stored in computer memory, and can be divided into contiguous space storage (arrays) and dispersed space storage (linked lists). The two physical structures exhibit complementary characteristics in terms of time efficiency and space efficiency.</p> <p></p> <p> Figure 3-3   Contiguous space storage and dispersed space storage </p> <p>It is worth noting that all data structures are implemented based on arrays, linked lists, or a combination of both. For example, stacks and queues can be implemented using either arrays or linked lists; while the implementation of hash tables may include both arrays and linked lists.</p> <ul> <li>Can be implemented based on arrays: Stacks, queues, hash tables, trees, heaps, graphs, matrices, tensors (arrays with dimensions \\(\\geq 3\\)), etc.</li> <li>Can be implemented based on linked lists: Stacks, queues, hash tables, trees, heaps, graphs, etc.</li> </ul> <p>After initialization, linked lists can still adjust their length during program execution, so they are also called \"dynamic data structures\". After initialization, the length of arrays cannot be changed, so they are also called \"static data structures\". It is worth noting that arrays can achieve length changes by reallocating memory, thus possessing a certain degree of \"dynamism\".</p> <p>Tip</p> <p>If you find it difficult to understand physical structure, it is recommended to read the next chapter first, and then review this section.</p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   Number Encoding *","text":"<p>Tip</p> <p>In this book, chapters marked with an asterisk * are optional readings. If you are short on time or find them challenging, you may skip these initially and return to them after completing the essential chapters.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331-sign-magnitude-1s-complement-and-2s-complement","level":2,"title":"3.3.1   Sign-Magnitude, 1's Complement, and 2's Complement","text":"<p>In the table from the previous section, we found that all integer types can represent one more negative number than positive numbers. For example, the <code>byte</code> range is \\([-128, 127]\\). This phenomenon is counterintuitive, and its underlying reason involves knowledge of sign-magnitude, 1's complement, and 2's complement.</p> <p>First, it should be noted that numbers are stored in computers in the form of \"2's complement\". Before analyzing the reasons for this, let's first define these three concepts.</p> <ul> <li>Sign-magnitude: We treat the highest bit of the binary representation of a number as the sign bit, where \\(0\\) represents a positive number and \\(1\\) represents a negative number, and the remaining bits represent the value of the number.</li> <li>1's complement: The 1's complement of a positive number is the same as its sign-magnitude. For a negative number, the 1's complement is obtained by inverting all bits except the sign bit of its sign-magnitude.</li> <li>2's complement: The 2's complement of a positive number is the same as its sign-magnitude. For a negative number, the 2's complement is obtained by adding \\(1\\) to its 1's complement.</li> </ul> <p>Figure 3-4 shows the conversion methods among sign-magnitude, 1's complement, and 2's complement.</p> <p></p> <p> Figure 3-4   Conversions among sign-magnitude, 1's complement, and 2's complement </p> <p>Sign-magnitude, although the most intuitive, has some limitations. On one hand, the sign-magnitude of negative numbers cannot be directly used in operations. For example, calculating \\(1 + (-2)\\) in sign-magnitude yields \\(-3\\), which is clearly incorrect.</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>To solve this problem, computers introduced 1's complement. If we first convert sign-magnitude to 1's complement and calculate \\(1 + (-2)\\) in 1's complement, then convert the result back to sign-magnitude, we can obtain the correct result of \\(-1\\).</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(Sign-magnitude)} + 1000 \\; 0010 \\; \\text{(Sign-magnitude)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(1's complement)} + 1111  \\; 1101 \\; \\text{(1's complement)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(1's complement)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>On the other hand, the sign-magnitude of the number zero has two representations, \\(+0\\) and \\(-0\\). This means that the number zero corresponds to two different binary encodings, which may cause ambiguity. For example, in conditional judgments, if we don't distinguish between positive zero and negative zero, it may lead to incorrect judgment results. If we want to handle the ambiguity of positive and negative zero, we need to introduce additional judgment operations, which may reduce the computational efficiency of the computer.</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>Like sign-magnitude, 1's complement also has the problem of positive and negative zero ambiguity. Therefore, computers further introduced 2's complement. Let's first observe the conversion process of negative zero from sign-magnitude to 1's complement to 2's complement:</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(Sign-magnitude)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(1's complement)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(2's complement)} \\newline \\end{aligned} \\] <p>Adding \\(1\\) to the 1's complement of negative zero produces a carry, but since the <code>byte</code> type has a length of only 8 bits, the \\(1\\) that overflows to the 9<sup>th</sup> bit is discarded. That is to say, the 2's complement of negative zero is \\(0000 \\; 0000\\), which is the same as the 2's complement of positive zero. This means that in 2's complement representation, there is only one zero, and the positive and negative zero ambiguity is thus resolved.</p> <p>One last question remains: the range of the <code>byte</code> type is \\([-128, 127]\\), and how is the extra negative number \\(-128\\) obtained? We notice that all integers in the interval \\([-127, +127]\\) have corresponding sign-magnitude, 1's complement, and 2's complement, and sign-magnitude and 2's complement can be converted to each other.</p> <p>However, the 2's complement \\(1000 \\; 0000\\) is an exception, and it does not have a corresponding sign-magnitude. According to the conversion method, we get that the sign-magnitude of this 2's complement is \\(0000 \\; 0000\\). This is clearly contradictory because this sign-magnitude represents the number \\(0\\), and its 2's complement should be itself. The computer specifies that this special 2's complement \\(1000 \\; 0000\\) represents \\(-128\\). In fact, the result of calculating \\((-1) + (-127)\\) in 2's complement is \\(-128\\).</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(Sign-magnitude)} + 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(1's complement)} + 1111  \\; 1110 \\; \\text{(1's complement)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(2's complement)} + 1111  \\; 1111 \\; \\text{(2's complement)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(2's complement)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>You may have noticed that all the above calculations are addition operations. This hints at an important fact: the hardware circuits inside computers are mainly designed based on addition operations. This is because addition operations are simpler to implement in hardware compared to other operations (such as multiplication, division, and subtraction), easier to parallelize, and have faster operation speeds.</p> <p>Please note that this does not mean that computers can only perform addition. By combining addition with some basic logical operations, computers can implement various other mathematical operations. For example, calculating the subtraction \\(a - b\\) can be converted to calculating the addition \\(a + (-b)\\); calculating multiplication and division can be converted to calculating multiple additions or subtractions.</p> <p>Now we can summarize the reasons why computers use 2's complement: based on 2's complement representation, computers can use the same circuits and operations to handle the addition of positive and negative numbers, without the need to design special hardware circuits to handle subtraction, and without the need to specially handle the ambiguity problem of positive and negative zero. This greatly simplifies hardware design and improves operational efficiency.</p> <p>The design of 2's complement is very ingenious. Due to space limitations, we will stop here. Interested readers are encouraged to explore further.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332-floating-point-number-encoding","level":2,"title":"3.3.2   Floating-Point Number Encoding","text":"<p>Careful readers may have noticed: <code>int</code> and <code>float</code> have the same length, both are 4 bytes, but why does <code>float</code> have a much larger range than <code>int</code>? This is very counterintuitive because it stands to reason that <code>float</code> needs to represent decimals, so the range should be smaller.</p> <p>In fact, this is because floating-point number <code>float</code> uses a different representation method. Let's denote a 32-bit binary number as:</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>According to the IEEE 754 standard, a 32-bit <code>float</code> consists of the following three parts.</p> <ul> <li>Sign bit \\(\\mathrm{S}\\): occupies 1 bit, corresponding to \\(b_{31}\\).</li> <li>Exponent bit \\(\\mathrm{E}\\): occupies 8 bits, corresponding to \\(b_{30} b_{29} \\ldots b_{23}\\).</li> <li>Fraction bit \\(\\mathrm{N}\\): occupies 23 bits, corresponding to \\(b_{22} b_{21} \\ldots b_0\\).</li> </ul> <p>The calculation method for the value corresponding to the binary <code>float</code> is:</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>Converted to decimal, the calculation formula is:</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>The range of each component is:</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> Figure 3-5   Calculation example of float under IEEE 754 standard </p> <p>Observing Figure 3-5, given example data \\(\\mathrm{S} = 0\\), \\(\\mathrm{E} = 124\\), \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\), we have:</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>Now we can answer the initial question: the representation of <code>float</code> includes an exponent bit, resulting in a range far greater than <code>int</code>. According to the above calculation, the maximum positive number that <code>float</code> can represent is \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\), and the minimum negative number can be obtained by switching the sign bit.</p> <p>Although floating-point number <code>float</code> expands the range, its side effect is sacrificing precision. The integer type <code>int</code> uses all 32 bits to represent numbers, and the numbers are evenly distributed; however, due to the existence of the exponent bit, the larger the value of floating-point number <code>float</code>, the larger the difference between two adjacent numbers tends to be.</p> <p>As shown in Table 3-2, exponent bits \\(\\mathrm{E} = 0\\) and \\(\\mathrm{E} = 255\\) have special meanings, used to represent zero, infinity, \\(\\mathrm{NaN}\\), etc.</p> <p> Table 3-2   Meaning of exponent bits </p> Exponent Bit E Fraction Bit \\(\\mathrm{N} = 0\\) Fraction Bit \\(\\mathrm{N} \\ne 0\\) Calculation Formula \\(0\\) \\(\\pm 0\\) Subnormal Number \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Normal Number Normal Number \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>It is worth noting that subnormal numbers significantly improve the precision of floating-point numbers. The smallest positive normal number is \\(2^{-126}\\), and the smallest positive subnormal number is \\(2^{-126} \\times 2^{-23}\\).</p> <p>Double-precision <code>double</code> also uses a representation method similar to <code>float</code>, which will not be elaborated here.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   Summary","text":"","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_data_structure/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Data structures can be classified from two perspectives: logical structure and physical structure. Logical structure describes the logical relationships between data elements, while physical structure describes how data is stored in computer memory.</li> <li>Common logical structures include linear, tree, and network structures. We typically classify data structures as linear (arrays, linked lists, stacks, queues) and non-linear (trees, graphs, heaps) based on their logical structure. The implementation of hash tables may involve both linear and non-linear data structures.</li> <li>When a program runs, data is stored in computer memory. Each memory space has a corresponding memory address, and the program accesses data through these memory addresses.</li> <li>Physical structures are primarily divided into contiguous space storage (arrays) and dispersed space storage (linked lists). All data structures are implemented using arrays, linked lists, or a combination of both.</li> <li>Basic data types in computers include integers <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, floating-point numbers <code>float</code>, <code>double</code>, characters <code>char</code>, and booleans <code>bool</code>. Their value ranges depend on the size of space they occupy and their representation method.</li> <li>Sign-magnitude, 1's complement, and 2's complement are three methods for encoding numbers in computers, and they can be converted into each other. The most significant bit of sign-magnitude is the sign bit, and the remaining bits represent the value of the number.</li> <li>Integers are stored in computers in 2's complement form. Under 2's complement representation, computers can treat the addition of positive and negative numbers uniformly, without needing to design special hardware circuits for subtraction, and there is no ambiguity of positive and negative zero.</li> <li>The encoding of floating-point numbers consists of 1 sign bit, 8 exponent bits, and 23 fraction bits. Due to the exponent bits, the range of floating-point numbers is much larger than that of integers, at the cost of sacrificing precision.</li> <li>ASCII is the earliest English character set, with a length of 1 byte, containing a total of 127 characters. GBK is a commonly used Chinese character set, containing over 20,000 Chinese characters. Unicode is committed to providing a complete character set standard, collecting characters from various languages around the world, thereby solving the garbled text problem caused by inconsistent character encoding methods.</li> <li>UTF-8 is the most popular Unicode encoding method, with excellent universality. It is a variable-length encoding method with good scalability, effectively improving storage space efficiency. UTF-16 and UTF-32 are fixed-length encoding methods. When encoding Chinese characters, UTF-16 occupies less space than UTF-8. Programming languages such as Java and C# use UTF-16 encoding by default.</li> </ul>","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Why do hash tables contain both linear and non-linear data structures?</p> <p>The underlying structure of a hash table is an array. To resolve hash collisions, we may use \"chaining\" (discussed in the subsequent \"Hash Collision\" section): each bucket in the array points to a linked list, which may be converted to a tree (usually a red-black tree) when the list length exceeds a certain threshold.</p> <p>From a storage perspective, the underlying structure of a hash table is an array, where each bucket slot may contain a value, a linked list, or a tree. Therefore, hash tables may contain both linear data structures (arrays, linked lists) and non-linear data structures (trees).</p> <p>Q: Is the length of the <code>char</code> type 1 byte?</p> <p>The length of the <code>char</code> type is determined by the encoding method used by the programming language. For example, Java, JavaScript, TypeScript, and C# all use UTF-16 encoding (to store Unicode code points), so the <code>char</code> type has a length of 2 bytes.</p> <p>Q: Is there ambiguity in referring to array-based data structures as \"static data structures\"? Stacks can also perform \"dynamic\" operations such as push and pop.</p> <p>Stacks can indeed implement dynamic data operations, but the data structure is still \"static\" (fixed length). Although array-based data structures can dynamically add or remove elements, their capacity is fixed. If the data volume exceeds the pre-allocated size, a new larger array needs to be created, and the contents of the old array must be copied to the new array.</p> <p>Q: When constructing a stack (queue), its size is not specified. Why are they \"static data structures\"?</p> <p>In high-level programming languages, we do not need to manually specify the initial capacity of a stack (queue); this work is automatically completed within the class. For example, the initial capacity of Java's <code>ArrayList</code> is typically 10. Additionally, the expansion operation is also automatically implemented. See the subsequent \"List\" section for details.</p> <p>Q: The method of converting sign-magnitude to 2's complement is \"first negate then add 1\". So converting 2's complement to sign-magnitude should be the inverse operation \"first subtract 1 then negate\". However, 2's complement can also be converted to sign-magnitude through \"first negate then add 1\". Why is this?</p> <p>This is because the mutual conversion between sign-magnitude and 2's complement is actually the process of computing the \"complement\". Let us first define the complement: assuming \\(a + b = c\\), then we say that \\(a\\) is the complement of \\(b\\) to \\(c\\), and conversely, \\(b\\) is the complement of \\(a\\) to \\(c\\).</p> <p>Given an \\(n = 4\\) bit binary number \\(0010\\), if we treat this number as sign-magnitude (ignoring the sign bit), then its 2's complement can be obtained through \"first negate then add 1\":</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>We find that the sum of sign-magnitude and 2's complement is \\(0010 + 1110 = 10000\\), which means the 2's complement \\(1110\\) is the \"complement\" of sign-magnitude \\(0010\\) to \\(10000\\). This means the above \"first negate then add 1\" is actually the process of computing the complement to \\(10000\\).</p> <p>So, what is the \"complement\" of 2's complement \\(1110\\) to \\(10000\\)? We can still use \"first negate then add 1\" to obtain it:</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>In other words, sign-magnitude and 2's complement are each other's \"complement\" to \\(10000\\), so \"sign-magnitude to 2's complement\" and \"2's complement to sign-magnitude\" can be implemented using the same operation (first negate then add 1).</p> <p>Of course, we can also use the inverse operation to find the sign-magnitude of 2's complement \\(1110\\), that is, \"first subtract 1 then negate\":</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>In summary, both \"first negate then add 1\" and \"first subtract 1 then negate\" are computing the complement to \\(10000\\), and they are equivalent.</p> <p>Essentially, the \"negate\" operation is actually finding the complement to \\(1111\\) (because <code>sign-magnitude + 1's complement = 1111</code> always holds); and adding 1 to the 1's complement yields the 2's complement, which is the complement to \\(10000\\).</p> <p>The above uses \\(n = 4\\) as an example, and it can be generalized to binary numbers of any number of bits.</p>","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"Chapter 12.   Divide and Conquer","text":"<p>Abstract</p> <p>Difficult problems are decomposed layer by layer, with each decomposition making them simpler.</p> <p>Divide and conquer reveals an important truth: start with simplicity, and nothing remains complex.</p>","path":["Chapter 12. Divide and Conquer","Chapter 12. &nbsp; Divide and Conquer"],"tags":[]},{"location":"chapter_divide_and_conquer/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>12.1   Divide and Conquer Algorithms</li> <li>12.2   Divide and Conquer Search Strategy</li> <li>12.3   Building a Binary Tree Problem</li> <li>12.4   Hanoi Tower Problem</li> <li>12.5   Summary</li> </ul>","path":["Chapter 12. Divide and Conquer","Chapter 12. &nbsp; Divide and Conquer"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   Divide and Conquer Search Strategy","text":"<p>We have already learned that search algorithms are divided into two major categories.</p> <ul> <li>Brute-force search: Implemented by traversing the data structure, with a time complexity of \\(O(n)\\).</li> <li>Adaptive search: Utilizes unique data organization forms or prior information, with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\).</li> </ul> <p>In fact, search algorithms with time complexity of \\(O(\\log n)\\) are typically implemented based on the divide and conquer strategy, such as binary search and trees.</p> <ul> <li>Each step of binary search divides the problem (searching for a target element in an array) into a smaller problem (searching for the target element in half of the array), continuing until the array is empty or the target element is found.</li> <li>Trees are representative of the divide and conquer idea. In data structures such as binary search trees, AVL trees, and heaps, the time complexity of various operations is \\(O(\\log n)\\).</li> </ul> <p>The divide and conquer strategy of binary search is as follows.</p> <ul> <li>The problem can be decomposed: Binary search recursively decomposes the original problem (searching in an array) into subproblems (searching in half of the array), achieved by comparing the middle element with the target element.</li> <li>Subproblems are independent: In binary search, each round only processes one subproblem, which is not affected by other subproblems.</li> <li>Solutions of subproblems do not need to be merged: Binary search aims to find a specific element, so there is no need to merge the solutions of subproblems. When a subproblem is solved, the original problem is also solved.</li> </ul> <p>Divide and conquer can improve search efficiency because brute-force search can only eliminate one option per round, while divide and conquer search can eliminate half of the options per round.</p>","path":["Chapter 12. Divide and Conquer","12.2 &nbsp; Divide and Conquer Search Strategy"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1-implementing-binary-search-based-on-divide-and-conquer","level":3,"title":"1.   Implementing Binary Search Based on Divide and Conquer","text":"<p>In previous sections, binary search was implemented based on iteration. Now we implement it based on divide and conquer (recursion).</p> <p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\), where all elements are unique, find the element <code>target</code>.</p> <p>From a divide and conquer perspective, we denote the subproblem corresponding to the search interval \\([i, j]\\) as \\(f(i, j)\\).</p> <p>Starting from the original problem \\(f(0, n-1)\\), perform binary search through the following steps.</p> <ol> <li>Calculate the midpoint \\(m\\) of the search interval \\([i, j]\\), and use it to eliminate half of the search interval.</li> <li>Recursively solve the subproblem reduced by half in size, which could be \\(f(i, m-1)\\) or \\(f(m+1, j)\\).</li> <li>Repeat steps <code>1.</code> and <code>2.</code> until <code>target</code> is found or the interval is empty and return.</li> </ol> <p>Figure 12-4 shows the divide and conquer process of binary search for element \\(6\\) in an array.</p> <p></p> <p> Figure 12-4   Divide and conquer process of binary search </p> <p>In the implementation code, we declare a recursive function <code>dfs()</code> to solve the problem \\(f(i, j)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"Binary search: problem f(i, j)\"\"\"\n    # If the interval is empty, it means there is no target element, return -1\n    if i &gt; j:\n        return -1\n    # Calculate the midpoint index m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # Found the target element, return its index\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search\"\"\"\n    n = len(nums)\n    # Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* Binary search: problem f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* Binary search: problem f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* Binary search: problem f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // Solve the problem f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* Binary search: problem f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // If interval is empty, indicating no target element, return -1\n    if i &gt; j {\n        return -1\n    }\n    // Calculate midpoint index\n    m := i + ((j - i) &gt;&gt; 1)\n    // Compare midpoint with target element\n    if nums[m] &lt; target {\n        // If smaller, recurse on right half of array\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // If larger, recurse on left half of array\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // Found the target element, return its index\n        return m\n    }\n}\n\n/* Binary search */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* Binary search: problem f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // If the interval is empty, it means there is no target element, return -1\n    if i &gt; j {\n        return -1\n    }\n    // Calculate the midpoint index m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // Found the target element, return its index\n        return m\n    }\n}\n\n/* Binary search */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Solve the problem f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* Binary search: problem f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* Binary search: problem f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* Binary search: problem f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // If the interval is empty, it means there is no target element, return -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // Calculate the midpoint index m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // Recursion subproblem f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // Recursion subproblem f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // Found the target element, return its index\n    return m;\n  }\n}\n\n/* Binary search */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // Solve the problem f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* Binary search: problem f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // If the interval is empty, it means there is no target element, return -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // Solve the problem f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* Binary search: problem f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* Binary search: problem f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1\n    }\n    // Calculate the midpoint index m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // Found the target element, return its index\n        m\n    }\n}\n\n/* Binary search */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### Binary search: problem f(i, j) ###\ndef dfs(nums, target, i, j)\n  # If the interval is empty, it means there is no target element, return -1\n  return -1 if i &gt; j\n\n  # Calculate the midpoint index m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # Recursion subproblem f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # Recursion subproblem f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # Found the target element, return its index\n    return m\n  end\nend\n\n### Binary search ###\ndef binary_search(nums, target)\n  n = nums.length\n  # Solve the problem f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre>","path":["Chapter 12. Divide and Conquer","12.2 &nbsp; Divide and Conquer Search Strategy"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   Building a Binary Tree Problem","text":"<p>Question</p> <p>Given the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code> of a binary tree, construct the binary tree and return the root node of the binary tree. Assume there are no duplicate node values in the binary tree (as shown in Figure 12-5).</p> <p></p> <p> Figure 12-5   Example data for building a binary tree </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1-determining-if-it-is-a-divide-and-conquer-problem","level":3,"title":"1.   Determining If It Is a Divide and Conquer Problem","text":"<p>The original problem is defined as constructing a binary tree from <code>preorder</code> and <code>inorder</code>, which is a typical divide and conquer problem.</p> <ul> <li>The problem can be decomposed: From a divide and conquer perspective, we can divide the original problem into two subproblems: constructing the left subtree and constructing the right subtree, plus one operation: initializing the root node. For each subtree (subproblem), we can still reuse the above division method, dividing it into smaller subtrees (subproblems) until the smallest subproblem (empty subtree) is reached.</li> <li>Subproblems are independent: The left and right subtrees are independent of each other; there is no overlap between them. When constructing the left subtree, we only need to focus on the parts of the inorder and preorder traversals corresponding to the left subtree. The same applies to the right subtree.</li> <li>Solutions of subproblems can be merged: Once we have the left and right subtrees (solutions of subproblems), we can link them to the root node to obtain the solution to the original problem.</li> </ul>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2-how-to-divide-subtrees","level":3,"title":"2.   How to Divide Subtrees","text":"<p>Based on the above analysis, this problem can be solved using divide and conquer, but how do we divide the left and right subtrees through the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code>?</p> <p>According to the definition, both <code>preorder</code> and <code>inorder</code> can be divided into three parts.</p> <ul> <li>Preorder traversal: <code>[ Root Node | Left Subtree | Right Subtree ]</code>, for example, the tree in Figure 12-5 corresponds to <code>[ 3 | 9 | 2 1 7 ]</code>.</li> <li>Inorder traversal: <code>[ Left Subtree | Root Node ｜ Right Subtree ]</code>, for example, the tree in Figure 12-5 corresponds to <code>[ 9 | 3 | 1 2 7 ]</code>.</li> </ul> <p>Using the data from the figure above as an example, we can obtain the division results through the steps shown in Figure 12-6.</p> <ol> <li>The first element 3 in the preorder traversal is the value of the root node.</li> <li>Find the index of root node 3 in <code>inorder</code>, and use this index to divide <code>inorder</code> into <code>[ 9 | 3 ｜ 1 2 7 ]</code>.</li> <li>Based on the division result of <code>inorder</code>, it is easy to determine that the left and right subtrees have 1 and 3 nodes respectively, allowing us to divide <code>preorder</code> into <code>[ 3 | 9 | 2 1 7 ]</code>.</li> </ol> <p></p> <p> Figure 12-6   Dividing subtrees in preorder and inorder traversals </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3-describing-subtree-intervals-based-on-variables","level":3,"title":"3.   Describing Subtree Intervals Based on Variables","text":"<p>Based on the above division method, we have obtained the index intervals of the root node, left subtree, and right subtree in <code>preorder</code> and <code>inorder</code>. To describe these index intervals, we need to use several pointer variables.</p> <ul> <li>Denote the index of the current tree's root node in <code>preorder</code> as \\(i\\).</li> <li>Denote the index of the current tree's root node in <code>inorder</code> as \\(m\\).</li> <li>Denote the index interval of the current tree in <code>inorder</code> as \\([l, r]\\).</li> </ul> <p>As shown in Table 12-1, through these variables we can represent the index of the root node in <code>preorder</code> and the index intervals of the subtrees in <code>inorder</code>.</p> <p> Table 12-1   Indices of root node and subtrees in preorder and inorder traversals </p> Root node index in <code>preorder</code> Subtree index interval in <code>inorder</code> Current tree \\(i\\) \\([l, r]\\) Left subtree \\(i + 1\\) \\([l, m-1]\\) Right subtree \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>Please note that \\((m-l)\\) in the right subtree root node index means \"the number of nodes in the left subtree\". It is recommended to understand this in conjunction with Figure 12-7.</p> <p></p> <p> Figure 12-7   Index interval representation of root node and left and right subtrees </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4-code-implementation","level":3,"title":"4.   Code Implementation","text":"<p>To improve the efficiency of querying \\(m\\), we use a hash table <code>hmap</code> to store the mapping from elements in the <code>inorder</code> array to their indices:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"Build binary tree: divide and conquer\"\"\"\n    # Terminate when the subtree interval is empty\n    if r - l &lt; 0:\n        return None\n    # Initialize the root node\n    root = TreeNode(preorder[i])\n    # Query m to divide the left and right subtrees\n    m = inorder_map[preorder[i]]\n    # Subproblem: build the left subtree\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # Subproblem: build the right subtree\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # Return the root node\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"Build binary tree\"\"\"\n    # Initialize hash map, storing the mapping from inorder elements to indices\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* Build binary tree: divide and conquer */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return NULL;\n    // Initialize the root node\n    TreeNode *root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* Build binary tree: divide and conquer */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return null;\n    // Initialize the root node\n    TreeNode root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* Build binary tree: divide and conquer */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return null;\n    // Initialize the root node\n    TreeNode root = new(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* Build binary tree: divide and conquer */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // Terminate when the subtree interval is empty\n    if r-l &lt; 0 {\n        return nil\n    }\n    // Initialize the root node\n    root := NewTreeNode(preorder[i])\n    // Query m to divide the left and right subtrees\n    m := inorderMap[preorder[i]]\n    // Subproblem: build the left subtree\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // Subproblem: build the right subtree\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* Build binary tree: divide and conquer */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // Terminate when the subtree interval is empty\n    if r - l &lt; 0 {\n        return nil\n    }\n    // Initialize the root node\n    let root = TreeNode(x: preorder[i])\n    // Query m to divide the left and right subtrees\n    let m = inorderMap[preorder[i]]!\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* Build binary tree: divide and conquer */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null;\n    // Initialize the root node\n    const root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    const m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nfunction buildTree(preorder, inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* Build binary tree: divide and conquer */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null;\n    // Initialize the root node\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    const m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* Build binary tree: divide and conquer */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // Terminate when the subtree interval is empty\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // Initialize the root node\n  TreeNode? root = TreeNode(preorder[i]);\n  // Query m to divide the left and right subtrees\n  int m = inorderMap[preorder[i]]!;\n  // Subproblem: build the left subtree\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // Subproblem: build the right subtree\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // Return the root node\n  return root;\n}\n\n/* Build binary tree */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // Initialize hash map, storing the mapping from inorder elements to indices\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* Build binary tree: divide and conquer */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Terminate when the subtree interval is empty\n    if r - l &lt; 0 {\n        return None;\n    }\n    // Initialize the root node\n    let root = TreeNode::new(preorder[i as usize]);\n    // Query m to divide the left and right subtrees\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // Subproblem: build the left subtree\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    Some(root)\n}\n\n/* Build binary tree */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* Build binary tree: divide and conquer */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return NULL;\n    // Initialize the root node\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // Subproblem: build the right subtree\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* Build binary tree: divide and conquer */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null\n    // Initialize the root node\n    val root = TreeNode(preorder[i])\n    // Query m to divide the left and right subtrees\n    val m = inorderMap[preorder[i]]!!\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### Build binary tree: divide and conquer ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # Terminate when the subtree interval is empty\n  return if r - l &lt; 0\n\n  # Initialize the root node\n  root = TreeNode.new(preorder[i])\n  # Query m to divide the left and right subtrees\n  m = inorder_map[preorder[i]]\n  # Subproblem: build the left subtree\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # Subproblem: build the right subtree\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # Return the root node\n  root\nend\n\n### Build binary tree ###\ndef build_tree(preorder, inorder)\n  # Initialize hash map, storing the mapping from inorder elements to indices\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> <p>Figure 12-8 shows the recursive process of building the binary tree. Each node is established during the downward \"recursion\" process, while each edge (reference) is established during the upward \"return\" process.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 12-8   Recursive process of building a binary tree </p> <p>The division results of the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code> within each recursive function are shown in Figure 12-9.</p> <p></p> <p> Figure 12-9   Division results in each recursive function </p> <p>Let the number of nodes in the tree be \\(n\\). Initializing each node (executing one recursive function <code>dfs()</code>) takes \\(O(1)\\) time. Therefore, the overall time complexity is \\(O(n)\\).</p> <p>The hash table stores the mapping from <code>inorder</code> elements to their indices, with a space complexity of \\(O(n)\\). In the worst case, when the binary tree degenerates into a linked list, the recursion depth reaches \\(n\\), using \\(O(n)\\) stack frame space. Therefore, the overall space complexity is \\(O(n)\\).</p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   Divide and Conquer Algorithms","text":"<p>Divide and conquer is a very important and common algorithm strategy. Divide and conquer is typically implemented based on recursion, consisting of two steps: \"divide\" and \"conquer\".</p> <ol> <li>Divide (partition phase): Recursively divide the original problem into two or more subproblems until the smallest subproblem is reached.</li> <li>Conquer (merge phase): Starting from the smallest subproblems with known solutions, merge the solutions of subproblems from bottom to top to construct the solution to the original problem.</li> </ol> <p>As shown in Figure 12-1, \"merge sort\" is one of the typical applications of the divide and conquer strategy.</p> <ol> <li>Divide: Recursively divide the original array (original problem) into two subarrays (subproblems) until the subarray has only one element (smallest subproblem).</li> <li>Conquer: Merge the sorted subarrays (solutions to subproblems) from bottom to top to obtain a sorted original array (solution to the original problem).</li> </ol> <p></p> <p> Figure 12-1   Divide and conquer strategy of merge sort </p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211-how-to-determine-divide-and-conquer-problems","level":2,"title":"12.1.1   How to Determine Divide and Conquer Problems","text":"<p>Whether a problem is suitable for solving with divide and conquer can usually be determined based on the following criteria.</p> <ol> <li>The problem can be decomposed: The original problem can be divided into smaller, similar subproblems, and can be recursively divided in the same way.</li> <li>Subproblems are independent: There is no overlap between subproblems, they are independent of each other and can be solved independently.</li> <li>Solutions of subproblems can be merged: The solution to the original problem is obtained by merging the solutions of subproblems.</li> </ol> <p>Clearly, merge sort satisfies these three criteria.</p> <ol> <li>The problem can be decomposed: Recursively divide the array (original problem) into two subarrays (subproblems).</li> <li>Subproblems are independent: Each subarray can be sorted independently (subproblems can be solved independently).</li> <li>Solutions of subproblems can be merged: Two sorted subarrays (solutions of subproblems) can be merged into one sorted array (solution of the original problem).</li> </ol>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212-improving-efficiency-through-divide-and-conquer","level":2,"title":"12.1.2   Improving Efficiency Through Divide and Conquer","text":"<p>Divide and conquer can not only effectively solve algorithmic problems but often also improve algorithm efficiency. In sorting algorithms, quick sort, merge sort, and heap sort are faster than selection, bubble, and insertion sort because they apply the divide and conquer strategy.</p> <p>This raises the question: Why can divide and conquer improve algorithm efficiency, and what is the underlying logic? In other words, why is dividing a large problem into multiple subproblems, solving the subproblems, and merging their solutions more efficient than directly solving the original problem? This question can be discussed from two aspects: operation count and parallel computation.</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1-operation-count-optimization","level":3,"title":"1.   Operation Count Optimization","text":"<p>Taking \"bubble sort\" as an example, processing an array of length \\(n\\) requires \\(O(n^2)\\) time. Suppose we divide the array into two subarrays from the midpoint as shown in Figure 12-2, the division requires \\(O(n)\\) time, sorting each subarray requires \\(O((n / 2)^2)\\) time, and merging the two subarrays requires \\(O(n)\\) time, resulting in an overall time complexity of:</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> Figure 12-2   Bubble sort before and after array division </p> <p>Next, we compute the following inequality, where the left and right sides represent the total number of operations before and after division, respectively:</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>This means that when \\(n &gt; 4\\), the number of operations after division is smaller, and sorting efficiency should be higher. Note that the time complexity after division is still quadratic \\(O(n^2)\\), but the constant term in the complexity has become smaller.</p> <p>Going further, what if we continuously divide the subarrays from their midpoints into two subarrays until the subarrays have only one element? This approach is actually \"merge sort\", with a time complexity of \\(O(n \\log n)\\).</p> <p>Thinking further, what if we set multiple division points and evenly divide the original array into \\(k\\) subarrays? This situation is very similar to \"bucket sort\", which is well-suited for sorting massive amounts of data, with a theoretical time complexity of \\(O(n + k)\\).</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2-parallel-computation-optimization","level":3,"title":"2.   Parallel Computation Optimization","text":"<p>We know that the subproblems generated by divide and conquer are independent of each other, so they can typically be solved in parallel. This means divide and conquer can not only reduce the time complexity of algorithms, but also benefits from parallel optimization by operating systems.</p> <p>Parallel optimization is particularly effective in multi-core or multi-processor environments, as the system can simultaneously handle multiple subproblems, making fuller use of computing resources and significantly reducing overall runtime.</p> <p>For example, in the \"bucket sort\" shown in Figure 12-3, we evenly distribute massive data into various buckets, and the sorting tasks for all buckets can be distributed to various computing units. After completion, the results are merged.</p> <p></p> <p> Figure 12-3   Parallel computation in bucket sort </p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213-common-applications-of-divide-and-conquer","level":2,"title":"12.1.3   Common Applications of Divide and Conquer","text":"<p>On one hand, divide and conquer can be used to solve many classic algorithmic problems.</p> <ul> <li>Finding the closest pair of points: This algorithm first divides the point set into two parts, then finds the closest pair of points in each part separately, and finally finds the closest pair of points that spans both parts.</li> <li>Large integer multiplication: For example, the Karatsuba algorithm, which decomposes large integer multiplication into several smaller integer multiplications and additions.</li> <li>Matrix multiplication: For example, the Strassen algorithm, which decomposes large matrix multiplication into multiple small matrix multiplications and additions.</li> <li>Hanota problem: The hanota problem can be solved through recursion, which is a typical application of the divide and conquer strategy.</li> <li>Solving inversion pairs: In a sequence, if a preceding number is greater than a following number, these two numbers form an inversion pair. Solving the inversion pair problem can utilize the divide and conquer approach with the help of merge sort.</li> </ul> <p>On the other hand, divide and conquer is widely applied in the design of algorithms and data structures.</p> <ul> <li>Binary search: Binary search divides a sorted array into two parts from the midpoint index, then decides which half to eliminate based on the comparison result between the target value and the middle element value, and performs the same binary operation on the remaining interval.</li> <li>Merge sort: Already introduced at the beginning of this section, no further elaboration needed.</li> <li>Quick sort: Quick sort selects a pivot value, then divides the array into two subarrays, one with elements smaller than the pivot and the other with elements larger than the pivot, then performs the same division operation on these two parts until the subarrays have only one element.</li> <li>Bucket sort: The basic idea of bucket sort is to scatter data into multiple buckets, then sort the elements within each bucket, and finally extract the elements from each bucket in sequence to obtain a sorted array.</li> <li>Trees: For example, binary search trees, AVL trees, red-black trees, B-trees, B+ trees, etc. Their search, insertion, and deletion operations can all be viewed as applications of the divide and conquer strategy.</li> <li>Heaps: A heap is a special complete binary tree, and its various operations, such as insertion, deletion, and heapify, actually imply the divide and conquer idea.</li> <li>Hash tables: Although hash tables do not directly apply divide and conquer, some hash collision resolution solutions indirectly apply the divide and conquer strategy. For example, long linked lists in chaining may be converted to red-black trees to improve query efficiency.</li> </ul> <p>It can be seen that divide and conquer is a \"subtly pervasive\" algorithmic idea, embedded in various algorithms and data structures.</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   Hanota Problem","text":"<p>In merge sort and building binary trees, we decompose the original problem into two subproblems, each half the size of the original problem. However, for the hanota problem, we adopt a different decomposition strategy.</p> <p>Question</p> <p>Given three pillars, denoted as <code>A</code>, <code>B</code>, and <code>C</code>. Initially, pillar <code>A</code> has \\(n\\) discs stacked on it, arranged from top to bottom in ascending order of size. Our task is to move these \\(n\\) discs to pillar <code>C</code> while maintaining their original order (as shown in Figure 12-10). The following rules must be followed when moving the discs.</p> <ol> <li>A disc can only be taken from the top of one pillar and placed on top of another pillar.</li> <li>Only one disc can be moved at a time.</li> <li>A smaller disc must always be on top of a larger disc.</li> </ol> <p></p> <p> Figure 12-10   Example of the hanota problem </p> <p>We denote the hanota problem of size \\(i\\) as \\(f(i)\\). For example, \\(f(3)\\) represents moving \\(3\\) discs from <code>A</code> to <code>C</code>.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1-considering-the-base-cases","level":3,"title":"1.   Considering the Base Cases","text":"<p>As shown in Figure 12-11, for problem \\(f(1)\\), when there is only one disc, we can move it directly from <code>A</code> to <code>C</code>.</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> Figure 12-11   Solution for a problem of size 1 </p> <p>As shown in Figure 12-12, for problem \\(f(2)\\), when there are two discs, since we must always keep the smaller disc on top of the larger disc, we need to use <code>B</code> to assist in the move.</p> <ol> <li>First, move the smaller disc from <code>A</code> to <code>B</code>.</li> <li>Then move the larger disc from <code>A</code> to <code>C</code>.</li> <li>Finally, move the smaller disc from <code>B</code> to <code>C</code>.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 12-12   Solution for a problem of size 2 </p> <p>The process of solving problem \\(f(2)\\) can be summarized as: moving two discs from <code>A</code> to <code>C</code> with the help of <code>B</code>. Here, <code>C</code> is called the target pillar, and <code>B</code> is called the buffer pillar.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2-subproblem-decomposition","level":3,"title":"2.   Subproblem Decomposition","text":"<p>For problem \\(f(3)\\), when there are three discs, the situation becomes slightly more complex.</p> <p>Since we already know the solutions to \\(f(1)\\) and \\(f(2)\\), we can think from a divide and conquer perspective, treating the top two discs on <code>A</code> as a whole, and execute the steps shown in Figure 12-13. This successfully moves the three discs from <code>A</code> to <code>C</code>.</p> <ol> <li>Let <code>B</code> be the target pillar and <code>C</code> be the buffer pillar, and move two discs from <code>A</code> to <code>B</code>.</li> <li>Move the remaining disc from <code>A</code> directly to <code>C</code>.</li> <li>Let <code>C</code> be the target pillar and <code>A</code> be the buffer pillar, and move two discs from <code>B</code> to <code>C</code>.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 12-13   Solution for a problem of size 3 </p> <p>Essentially, we divide problem \\(f(3)\\) into two subproblems \\(f(2)\\) and one subproblem \\(f(1)\\). By solving these three subproblems in order, the original problem is solved. This shows that the subproblems are independent and their solutions can be merged.</p> <p>From this, we can summarize the divide and conquer strategy for solving the hanota problem shown in Figure 12-14: divide the original problem \\(f(n)\\) into two subproblems \\(f(n-1)\\) and one subproblem \\(f(1)\\), and solve these three subproblems in the following order.</p> <ol> <li>Move \\(n-1\\) discs from <code>A</code> to <code>B</code> with the help of <code>C</code>.</li> <li>Move the remaining \\(1\\) disc directly from <code>A</code> to <code>C</code>.</li> <li>Move \\(n-1\\) discs from <code>B</code> to <code>C</code> with the help of <code>A</code>.</li> </ol> <p>For these two subproblems \\(f(n-1)\\), we can recursively divide them in the same way until reaching the smallest subproblem \\(f(1)\\). The solution to \\(f(1)\\) is known and requires only one move operation.</p> <p></p> <p> Figure 12-14   Divide and conquer strategy for solving the hanota problem </p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>In the code, we declare a recursive function <code>dfs(i, src, buf, tar)</code>, whose purpose is to move the top \\(i\\) discs from pillar <code>src</code> to target pillar <code>tar</code> with the help of buffer pillar <code>buf</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"Move a disk\"\"\"\n    # Take out a disk from the top of src\n    pan = src.pop()\n    # Place the disk on top of tar\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"Solve the Tower of Hanoi problem f(i)\"\"\"\n    # If there is only one disk left in src, move it directly to tar\n    if i == 1:\n        move(src, tar)\n        return\n    # Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf)\n    # Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    # Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"Solve the Tower of Hanoi problem\"\"\"\n    n = len(A)\n    # Move the top n disks from A to C using B\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* Move a disk */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // Take out a disk from the top of src\n    int pan = src.back();\n    src.pop_back();\n    // Place the disk on top of tar\n    tar.push_back(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* Move a disk */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // Take out a disk from the top of src\n    Integer pan = src.remove(src.size() - 1);\n    // Place the disk on top of tar\n    tar.add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* Move a disk */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // Take out a disk from the top of src\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // Place the disk on top of tar\n    tar.Add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    DFS(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    Move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    DFS(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // Move the top n disks from A to C using B\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* Move a disk */\nfunc move(src, tar *list.List) {\n    // Take out a disk from the top of src\n    pan := src.Back()\n    // Place the disk on top of tar\n    tar.PushBack(pan.Value)\n    // Remove top disk from src\n    src.Remove(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfsHanota(i-1, src, tar, buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // Move the top n disks from A to C using B\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* Move a disk */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // Take out a disk from the top of src\n    let pan = src.popLast()!\n    // Place the disk on top of tar\n    tar.append(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src: &amp;src, tar: &amp;tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // The tail of the list is the top of the rod\n    // Move top n disks from src to C using B\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* Move a disk */\nfunction move(src, tar) {\n    // Take out a disk from the top of src\n    const pan = src.pop();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunction dfs(i, src, buf, tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* Move a disk */\nfunction move(src: number[], tar: number[]): void {\n    // Take out a disk from the top of src\n    const pan = src.pop();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // If there is only one disk left in src, move it directly to tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* Move a disk */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // Take out a disk from the top of src\n  int pan = src.removeLast();\n  // Place the disk on top of tar\n  tar.add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // If there is only one disk left in src, move it directly to tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n  dfs(i - 1, src, tar, buf);\n  // Subproblem f(1): move the remaining disk from src to tar\n  move(src, tar);\n  // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n  dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // Move the top n disks from A to C using B\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* Move a disk */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Take out a disk from the top of src\n    let pan = src.pop().unwrap();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move_pan(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* Move a disk */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // Take out a disk from the top of src\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // Place the disk on top of tar\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, srcSize, tar, tarSize);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // Move the top n disks from A to C using B\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* Move a disk */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Take out a disk from the top of src\n    val pan = src.removeAt(src.size - 1)\n    // Place the disk on top of tar\n    tar.add(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### Move one disk ###\ndef move(src, tar)\n  # Take out a disk from the top of src\n  pan = src.pop\n  # Place the disk on top of tar\n  tar &lt;&lt; pan\nend\n\n### Solve Tower of Hanoi f(i) ###\ndef dfs(i, src, buf, tar)\n  # If there is only one disk left in src, move it directly to tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n  dfs(i - 1, src, tar, buf)\n  # Subproblem f(1): move the remaining disk from src to tar\n  move(src, tar)\n  # Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n  dfs(i - 1, buf, src, tar)\nend\n\n### Solve Tower of Hanoi ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # Move the top n disks from A to C using B\n  dfs(n, _A, _B, _C)\nend\n</code></pre> <p>As shown in Figure 12-15, the hanota problem forms a recursion tree of height \\(n\\), where each node represents a subproblem corresponding to an invocation of the <code>dfs()</code> function, therefore the time complexity is \\(O(2^n)\\) and the space complexity is \\(O(n)\\).</p> <p></p> <p> Figure 12-15   Recursion tree of the hanota problem </p> <p>Quote</p> <p>The hanota problem originates from an ancient legend. In a temple in ancient India, monks had three tall diamond pillars and \\(64\\) golden discs of different sizes. The monks continuously moved the discs, believing that when the last disc was correctly placed, the world would come to an end.</p> <p>However, even if the monks moved one disc per second, it would take approximately \\(2^{64} \\approx 1.84×10^{19}\\) seconds, which is about \\(5850\\) billion years, far exceeding current estimates of the age of the universe. Therefore, if this legend is true, we should not need to worry about the end of the world.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   Summary","text":"","path":["Chapter 12. Divide and Conquer","12.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Divide and conquer is a common algorithm design strategy, consisting of two phases: divide (partition) and conquer (merge), typically implemented based on recursion.</li> <li>The criteria for determining whether a problem is a divide and conquer problem include: whether the problem can be decomposed, whether subproblems are independent, and whether subproblems can be merged.</li> <li>Merge sort is a typical application of the divide and conquer strategy. It recursively divides an array into two equal-length subarrays until only one element remains, then merges them layer by layer to complete the sorting.</li> <li>Introducing the divide and conquer strategy can often improve algorithm efficiency. On one hand, the divide and conquer strategy reduces the number of operations; on the other hand, it facilitates parallel optimization of the system after division.</li> <li>Divide and conquer can both solve many algorithmic problems and is widely applied in data structure and algorithm design, appearing everywhere.</li> <li>Compared to brute-force search, adaptive search is more efficient. Search algorithms with time complexity of \\(O(\\log n)\\) are typically implemented based on the divide and conquer strategy.</li> <li>Binary search is another typical application of divide and conquer. It does not include the step of merging solutions of subproblems. We can implement binary search through recursive divide and conquer.</li> <li>In the problem of building a binary tree, building the tree (original problem) can be divided into building the left subtree and right subtree (subproblems), which can be achieved by dividing the index intervals of the preorder and inorder traversals.</li> <li>In the hanota problem, a problem of size \\(n\\) can be divided into two subproblems of size \\(n-1\\) and one subproblem of size \\(1\\). After solving these three subproblems in order, the original problem is solved.</li> </ul>","path":["Chapter 12. Divide and Conquer","12.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"Chapter 14.   Dynamic Programming","text":"<p>Abstract</p> <p>Streams converge into rivers, rivers converge into the sea.</p> <p>Dynamic programming gathers solutions to small problems into answers to large problems, step by step guiding us to the shore of problem-solving.</p>","path":["Chapter 14. Dynamic Programming","Chapter 14. &nbsp; Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>14.1   Introduction to Dynamic Programming</li> <li>14.2   Characteristics of Dynamic Programming Problems</li> <li>14.3   Dynamic Programming Problem-Solving Approach</li> <li>14.4   0-1 Knapsack Problem</li> <li>14.5   Unbounded Knapsack Problem</li> <li>14.6   Edit Distance Problem</li> <li>14.7   Summary</li> </ul>","path":["Chapter 14. Dynamic Programming","Chapter 14. &nbsp; Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   Characteristics of Dynamic Programming Problems","text":"<p>In the previous section, we learned how dynamic programming solves the original problem by decomposing it into subproblems. In fact, subproblem decomposition is a general algorithmic approach, with different emphases in divide and conquer, dynamic programming, and backtracking.</p> <ul> <li>Divide and conquer algorithms recursively divide the original problem into multiple independent subproblems until the smallest subproblems are reached, and merge the solutions to the subproblems during backtracking to ultimately obtain the solution to the original problem.</li> <li>Dynamic programming also recursively decomposes problems, but the main difference from divide and conquer algorithms is that subproblems in dynamic programming are interdependent, and many overlapping subproblems appear during the decomposition process.</li> <li>Backtracking algorithms enumerate all possible solutions through trial and error, and avoid unnecessary search branches through pruning. The solution to the original problem consists of a series of decision steps, and we can regard the subsequence before each decision step as a subproblem.</li> </ul> <p>In fact, dynamic programming is commonly used to solve optimization problems, which not only contain overlapping subproblems but also have two other major characteristics: optimal substructure and no aftereffects.</p>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421-optimal-substructure","level":2,"title":"14.2.1   Optimal Substructure","text":"<p>We make a slight modification to the stair climbing problem to make it more suitable for demonstrating the concept of optimal substructure.</p> <p>Climbing stairs with minimum cost</p> <p>Given a staircase, where you can climb \\(1\\) or \\(2\\) steps at a time, and each step has a non-negative integer representing the cost you need to pay at that step. Given a non-negative integer array \\(cost\\), where \\(cost[i]\\) represents the cost at the \\(i\\)-th step, and \\(cost[0]\\) is the ground (starting point). What is the minimum cost required to reach the top?</p> <p>As shown in Figure 14-6, if the costs of the \\(1\\)st, \\(2\\)nd, and \\(3\\)rd steps are \\(1\\), \\(10\\), and \\(1\\) respectively, then climbing from the ground to the \\(3\\)rd step requires a minimum cost of \\(2\\).</p> <p></p> <p> Figure 14-6   Minimum cost to climb to the 3rd step </p> <p>Let \\(dp[i]\\) be the accumulated cost of climbing to the \\(i\\)-th step. Since the \\(i\\)-th step can only come from the \\(i-1\\)-th or \\(i-2\\)-th step, \\(dp[i]\\) can only equal \\(dp[i-1] + cost[i]\\) or \\(dp[i-2] + cost[i]\\). To minimize the cost, we should choose the smaller of the two:</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>This leads us to the meaning of optimal substructure: the optimal solution to the original problem is constructed from the optimal solutions to the subproblems.</p> <p>This problem clearly has optimal substructure: we select the better one from the optimal solutions to the two subproblems \\(dp[i-1]\\) and \\(dp[i-2]\\), and use it to construct the optimal solution to the original problem \\(dp[i]\\).</p> <p>So, does the stair climbing problem from the previous section have optimal substructure? Its goal is to find the number of ways, which seems to be a counting problem, but if we change the question: \"Find the maximum number of ways\". We surprisingly discover that although the problem before and after modification are equivalent, the optimal substructure has emerged: the maximum number of ways for the \\(n\\)-th step equals the sum of the maximum number of ways for the \\(n-1\\)-th and \\(n-2\\)-th steps. Therefore, the interpretation of optimal substructure is quite flexible and will have different meanings in different problems.</p> <p>According to the state transition equation and the initial states \\(dp[1] = cost[1]\\) and \\(dp[2] = cost[2]\\), we can obtain the dynamic programming code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"Minimum cost climbing stairs: Dynamic programming\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [0] * (n + 1)\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1], dp[2] = cost[1], cost[2]\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;int&gt; dp(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: 0, count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![-1; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int *dp = calloc(n + 1, sizeof(int));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = IntArray(n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Minimum cost climbing stairs: DP ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = cost[1], cost[2]\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> <p>Figure 14-7 shows the dynamic programming process for the above code.</p> <p></p> <p> Figure 14-7   Dynamic programming process for climbing stairs with minimum cost </p> <p>This problem can also be space-optimized, compressing from one dimension to zero, reducing the space complexity from \\(O(n)\\) to \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"Minimum cost climbing stairs: Space-optimized dynamic programming\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Initial state: preset the solution to the smallest subproblem\n    a, b := cost[1], cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Minimum cost climbing stairs: DP ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = cost[1], cost[2]\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# Minimum cost climbing stairs: Space-optimized dynamic programming\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422-no-aftereffects","level":2,"title":"14.2.2   No Aftereffects","text":"<p>No aftereffects is one of the important characteristics that enable dynamic programming to solve problems effectively. Its definition is: given a certain state, its future development is only related to the current state and has nothing to do with all past states.</p> <p>Taking the stair climbing problem as an example, given state \\(i\\), it will develop into states \\(i+1\\) and \\(i+2\\), corresponding to jumping \\(1\\) step and jumping \\(2\\) steps, respectively. When making these two choices, we do not need to consider the states before state \\(i\\), as they have no effect on the future of state \\(i\\).</p> <p>However, if we add a constraint to the stair climbing problem, the situation changes.</p> <p>Climbing stairs with constraint</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time, but you cannot jump \\(1\\) step in two consecutive rounds. How many ways are there to climb to the top?</p> <p>As shown in Figure 14-8, there are only \\(2\\) feasible ways to climb to the \\(3\\)rd step. The way of jumping \\(1\\) step three consecutive times does not satisfy the constraint and is therefore discarded.</p> <p></p> <p> Figure 14-8   Number of ways to climb to the 3rd step with constraint </p> <p>In this problem, if the previous round was a jump of \\(1\\) step, then the next round must jump \\(2\\) steps. This means that the next choice cannot be determined solely by the current state (current stair step number), but also depends on the previous state (the stair step number from the previous round).</p> <p>It is not difficult to see that this problem no longer satisfies no aftereffects, and the state transition equation \\(dp[i] = dp[i-1] + dp[i-2]\\) also fails, because \\(dp[i-1]\\) represents jumping \\(1\\) step in this round, but it includes many solutions where \"the previous round was a jump of \\(1\\) step\", which cannot be directly counted in \\(dp[i]\\) to satisfy the constraint.</p> <p>For this reason, we need to expand the state definition: state \\([i, j]\\) represents being on the \\(i\\)-th step with the previous round having jumped \\(j\\) steps, where \\(j \\in \\{1, 2\\}\\). This state definition effectively distinguishes whether the previous round was a jump of \\(1\\) step or \\(2\\) steps, allowing us to determine where the current state came from.</p> <ul> <li>When the previous round jumped \\(1\\) step, the round before that could only choose to jump \\(2\\) steps, i.e., \\(dp[i, 1]\\) can only be transferred from \\(dp[i-1, 2]\\).</li> <li>When the previous round jumped \\(2\\) steps, the round before that could choose to jump \\(1\\) step or \\(2\\) steps, i.e., \\(dp[i, 2]\\) can be transferred from \\(dp[i-2, 1]\\) or \\(dp[i-2, 2]\\).</li> </ul> <p>As shown in Figure 14-9, under this definition, \\(dp[i, j]\\) represents the number of ways for state \\([i, j]\\). The state transition equation is then:</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> Figure 14-9   Recurrence relation considering constraints </p> <p>Finally, return \\(dp[n, 1] + dp[n, 2]\\), where the sum of the two represents the total number of ways to climb to the \\(n\\)-th step:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"Climbing stairs with constraint: Dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int[][] dp = new int[n + 1][3];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int[,] dp = new int[n + 1, 3];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([][3]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = Array(n + 1) { IntArray(3) }\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### Climbing stairs with constraint: DP ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # State transition: gradually solve larger subproblems from smaller ones\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> <p>In the above case, since we only need to consider one more preceding state, we can still make the problem satisfy no aftereffects by expanding the state definition. However, some problems have very severe \"aftereffects\".</p> <p>Climbing stairs with obstacle generation</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time. It is stipulated that when climbing to the \\(i\\)-th step, the system will automatically place an obstacle on the \\(2i\\)-th step, and thereafter no round is allowed to jump to the \\(2i\\)-th step. For example, if the first two rounds jump to the \\(2\\)nd and \\(3\\)rd steps, then afterwards you cannot jump to the \\(4\\)th and \\(6\\)th steps. How many ways are there to climb to the top?</p> <p>In this problem, the next jump depends on all past states, because each jump places obstacles on higher steps, affecting future jumps. For such problems, dynamic programming is often difficult to solve.</p> <p>In fact, many complex combinatorial optimization problems (such as the traveling salesman problem) do not satisfy no aftereffects. For such problems, we usually choose to use other methods, such as heuristic search, genetic algorithms, reinforcement learning, etc., to obtain usable local optimal solutions within a limited time.</p>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   Dynamic Programming Problem-Solving Approach","text":"<p>The previous two sections introduced the main characteristics of dynamic programming problems. Next, let us explore two more practical issues together.</p> <ol> <li>How to determine whether a problem is a dynamic programming problem?</li> <li>What is the complete process for solving a dynamic programming problem, and where should we start?</li> </ol>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431-problem-determination","level":2,"title":"14.3.1   Problem Determination","text":"<p>Generally speaking, if a problem contains overlapping subproblems, optimal substructure, and satisfies no aftereffects, then it is usually suitable for solving with dynamic programming. However, it is difficult to directly extract these characteristics from the problem description. Therefore, we usually relax the conditions and first observe whether the problem is suitable for solving with backtracking (exhaustive search).</p> <p>Problems suitable for solving with backtracking usually satisfy the \"decision tree model\", which means the problem can be described using a tree structure, where each node represents a decision and each path represents a sequence of decisions.</p> <p>In other words, if a problem contains an explicit concept of decisions, and the solution is generated through a series of decisions, then it satisfies the decision tree model and can usually be solved using backtracking.</p> <p>On this basis, dynamic programming problems also have some \"bonus points\" for determination.</p> <ul> <li>The problem contains descriptions such as maximum (minimum) or most (least), indicating optimization.</li> <li>The problem's state can be represented using a list, multi-dimensional matrix, or tree, and a state has a recurrence relation with its surrounding states.</li> </ul> <p>Correspondingly, there are also some \"penalty points\".</p> <ul> <li>The goal of the problem is to find all possible solutions, rather than finding the optimal solution.</li> <li>The problem description has obvious permutation and combination characteristics, requiring the return of specific multiple solutions.</li> </ul> <p>If a problem satisfies the decision tree model and has relatively obvious \"bonus points\", we can assume it is a dynamic programming problem and verify it during the solving process.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432-problem-solving-steps","level":2,"title":"14.3.2   Problem-Solving Steps","text":"<p>The problem-solving process for dynamic programming varies depending on the nature and difficulty of the problem, but generally follows these steps: describe decisions, define states, establish the \\(dp\\) table, derive state transition equations, determine boundary conditions, etc.</p> <p>To illustrate the problem-solving steps more vividly, we use a classic problem \"minimum path sum\" as an example.</p> <p>Question</p> <p>Given an \\(n \\times m\\) two-dimensional grid <code>grid</code>, where each cell in the grid contains a non-negative integer representing the cost of that cell. A robot starts from the top-left cell and can only move down or right at each step until reaching the bottom-right cell. Return the minimum path sum from the top-left to the bottom-right.</p> <p>Figure 14-10 shows an example where the minimum path sum for the given grid is \\(13\\).</p> <p></p> <p> Figure 14-10   Minimum path sum example data </p> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>The decision in each round of this problem is to move one step down or right from the current cell. Let the row and column indices of the current cell be \\([i, j]\\). After moving down or right, the indices become \\([i+1, j]\\) or \\([i, j+1]\\). Therefore, the state should include two variables, the row index and column index, denoted as \\([i, j]\\).</p> <p>State \\([i, j]\\) corresponds to the subproblem: the minimum path sum from the starting point \\([0, 0]\\) to \\([i, j]\\), denoted as \\(dp[i, j]\\).</p> <p>From this, we obtain the two-dimensional \\(dp\\) matrix shown in Figure 14-11, whose size is the same as the input grid \\(grid\\).</p> <p></p> <p> Figure 14-11   State definition and dp table </p> <p>Note</p> <p>The dynamic programming and backtracking processes can be described as a sequence of decisions, and the state consists of all decision variables. It should contain all variables describing the progress of problem-solving, and should contain sufficient information to derive the next state.</p> <p>Each state corresponds to a subproblem, and we define a \\(dp\\) table to store the solutions to all subproblems. Each independent variable of the state is a dimension of the \\(dp\\) table. Essentially, the \\(dp\\) table is a mapping between states and solutions to subproblems.</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>For state \\([i, j]\\), it can only be transferred from the cell above \\([i-1, j]\\) or the cell to the left \\([i, j-1]\\). Therefore, the optimal substructure is: the minimum path sum to reach \\([i, j]\\) is determined by the smaller of the minimum path sums of \\([i, j-1]\\) and \\([i-1, j]\\).</p> <p>Based on the above analysis, the state transition equation shown in Figure 14-12 can be derived:</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> Figure 14-12   Optimal substructure and state transition equation </p> <p>Note</p> <p>Based on the defined \\(dp\\) table, think about the relationship between the original problem and subproblems, and find the method to construct the optimal solution to the original problem from the optimal solutions to the subproblems, which is the optimal substructure.</p> <p>Once we identify the optimal substructure, we can use it to construct the state transition equation.</p> <p>Step 3: Determine boundary conditions and state transition order</p> <p>In this problem, states in the first row can only come from the state to their left, and states in the first column can only come from the state above them. Therefore, the first row \\(i = 0\\) and first column \\(j = 0\\) are boundary conditions.</p> <p>As shown in Figure 14-13, since each cell is transferred from the cell to its left and the cell above it, we use loops to traverse the matrix, with the outer loop traversing rows and the inner loop traversing columns.</p> <p></p> <p> Figure 14-13   Boundary conditions and state transition order </p> <p>Note</p> <p>Boundary conditions in dynamic programming are used to initialize the \\(dp\\) table, and in search are used for pruning.</p> <p>The core of state transition order is to ensure that when computing the solution to the current problem, all the smaller subproblems it depends on have already been computed correctly.</p> <p>Based on the above analysis, we can directly write the dynamic programming code. However, subproblem decomposition is a top-down approach, so implementing in the order \"brute force search \\(\\rightarrow\\) memoization \\(\\rightarrow\\) dynamic programming\" is more aligned with thinking habits.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-method-1-brute-force-search","level":3,"title":"1.   Method 1: Brute Force Search","text":"<p>Starting from state \\([i, j]\\), continuously decompose into smaller states \\([i-1, j]\\) and \\([i, j-1]\\). The recursive function includes the following elements.</p> <ul> <li>Recursive parameters: state \\([i, j]\\).</li> <li>Return value: minimum path sum from \\([0, 0]\\) to \\([i, j]\\), which is \\(dp[i, j]\\).</li> <li>Termination condition: when \\(i = 0\\) and \\(j = 0\\), return cost \\(grid[0, 0]\\).</li> <li>Pruning: when \\(i &lt; 0\\) or \\(j &lt; 0\\), the index is out of bounds, return cost \\(+\\infty\\), representing infeasibility.</li> </ul> <p>The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"Minimum path sum: Brute-force search\"\"\"\n    # If it's the top-left cell, terminate the search\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Brute-force search */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Brute-force search */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // Return the minimum path cost from top-left to (i, j)\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Brute-force search */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // If it's the top-left cell, terminate the search\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Brute-force search */\nfunction minPathSumDFS(grid, i, j) {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Brute-force search */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // If it's the top-left cell, terminate the search\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // If row or column index is out of bounds, return +∞ cost\n  if (i &lt; 0 || j &lt; 0) {\n    // In Dart, int type is fixed-range integer, no value representing \"infinity\"\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // Return the minimum path cost from top-left to (i, j)\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Brute-force search */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Brute-force search */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: brute force search ###\ndef min_path_sum_dfs(grid, i, j)\n  # If it's the top-left cell, terminate the search\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # If row or column index is out of bounds, return +∞ cost\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # Return the minimum path cost from top-left to (i, j)\n  [left, up].min + grid[i][j]\nend\n</code></pre> <p>Figure 14-14 shows the recursion tree rooted at \\(dp[2, 1]\\), which includes some overlapping subproblems whose number will increase sharply as the size of grid <code>grid</code> grows.</p> <p>Essentially, the reason for overlapping subproblems is: there are multiple paths from the top-left corner to reach a certain cell.</p> <p></p> <p> Figure 14-14   Brute force search recursion tree </p> <p>Each state has two choices, down and right, so the total number of steps from the top-left corner to the bottom-right corner is \\(m + n - 2\\), giving a worst-case time complexity of \\(O(2^{m + n})\\), where \\(n\\) and \\(m\\) are the number of rows and columns of the grid, respectively. Note that this calculation does not account for situations near the grid boundaries, where only one choice remains when reaching the grid boundary, so the actual number of paths will be somewhat less.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-method-2-memoization","level":3,"title":"2.   Method 2: Memoization","text":"<p>We introduce a memo list <code>mem</code> of the same size as grid <code>grid</code> to record the solutions to subproblems and prune overlapping subproblems:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"Minimum path sum: Memoization search\"\"\"\n    # If it's the top-left cell, terminate the search\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # If there's a record, return it directly\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # Minimum path cost for left and upper cells\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Memoization search */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Memoization search */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // If there's a record, return it directly\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Memoization search */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // If it's the top-left cell, terminate the search\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // If there's a record, return it directly\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Memoization search */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Memoization search */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // If it's the top-left cell, terminate the search\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // If row or column index is out of bounds, return +∞ cost\n  if (i &lt; 0 || j &lt; 0) {\n    // In Dart, int type is fixed-range integer, no value representing \"infinity\"\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // If there's a record, return it directly\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // Minimum path cost for left and upper cells\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // Record and return the minimum path cost from top-left to (i, j)\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Memoization search */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // If there's a record, return it directly\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // Minimum path cost for left and upper cells\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Memoization search */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: memoization search ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # If it's the top-left cell, terminate the search\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # If row or column index is out of bounds, return +∞ cost\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # If there's a record, return it directly\n  return mem[i][j] if mem[i][j] != -1\n  # Minimum path cost for left and upper cells\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # Record and return the minimum path cost from top-left to (i, j)\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> <p>As shown in Figure 14-15, after introducing memoization, all subproblem solutions only need to be computed once, so the time complexity depends on the total number of states, which is the grid size \\(O(nm)\\).</p> <p></p> <p> Figure 14-15   Memoization recursion tree </p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-method-3-dynamic-programming","level":3,"title":"3.   Method 3: Dynamic Programming","text":"<p>Implement the dynamic programming solution based on iteration, as shown in the code below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Minimum path sum: Dynamic programming\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Initialize dp table\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # State transition: first row\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # State transition: first column\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # State transition: rest of the rows and columns\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Initialize dp table\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Dynamic programming */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Initialize dp table\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Dynamic programming */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Initialize dp table\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // State transition: first column\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Dynamic programming */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // State transition: first column\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Dynamic programming */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Dynamic programming */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // State transition: first row\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // State transition: first column\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Dynamic programming */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Initialize dp table\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Initialize dp table\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // Free memory\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Dynamic programming */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Initialize dp table\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // State transition: first column\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: dynamic programming ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # Initialize dp table\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # State transition: first row\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # State transition: first column\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # State transition: rest of the rows and columns\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> <p>Figure 14-16 shows the state transition process for minimum path sum, which traverses the entire grid, thus the time complexity is \\(O(nm)\\).</p> <p>The array <code>dp</code> has size \\(n \\times m\\), thus the space complexity is \\(O(nm)\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-16   Dynamic programming process for minimum path sum </p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4-space-optimization","level":3,"title":"4.   Space Optimization","text":"<p>Since each cell is only related to the cell to its left and the cell above it, we can use a single-row array to implement the \\(dp\\) table.</p> <p>Note that since the array <code>dp</code> can only represent the state of one row, we cannot initialize the first column state in advance, but rather update it when traversing each row:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Minimum path sum: Space-optimized dynamic programming\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Initialize dp table\n    dp = [0] * m\n    # State transition: first row\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # State transition: rest of the rows\n    for i in range(1, n):\n        # State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        # State transition: rest of the columns\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Initialize dp table\n    int[] dp = new int[m];\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Initialize dp table\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Initialize dp table\n    dp := make([]int, m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt; n; i++ {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // State transition: rest of the rows\n    for i in 1 ..&lt; n {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = new Array(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = new Array(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // State transition: rest of the rows\n  for (int i = 1; i &lt; n; i++) {\n    // State transition: first column\n    dp[0] = dp[0] + grid[i][0];\n    // State transition: rest of the columns\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Initialize dp table\n    let mut dp = vec![0; m];\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for i in 1..n {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Initialize dp table\n    int *dp = calloc(m, sizeof(int));\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Initialize dp table\n    val dp = IntArray(m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // State transition: rest of the rows\n    for (i in 1..&lt;n) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: space-optimized DP ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # Initialize dp table\n  dp = Array.new(m, 0)\n  # State transition: first row\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # State transition: rest of the rows\n  for i in 1...n\n    # State transition: first column\n    dp[0] = dp[0] + grid[i][0]\n    # State transition: rest of the columns\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   Edit Distance Problem","text":"<p>Edit distance, also known as Levenshtein distance, refers to the minimum number of edits required to transform one string into another, commonly used in information retrieval and natural language processing to measure the similarity between two sequences.</p> <p>Question</p> <p>Given two strings \\(s\\) and \\(t\\), return the minimum number of edits required to transform \\(s\\) into \\(t\\).</p> <p>You can perform three types of edit operations on a string: insert a character, delete a character, or replace a character with any other character.</p> <p>As shown in Figure 14-27, transforming <code>kitten</code> into <code>sitting</code> requires 3 edits, including 2 replacements and 1 insertion; transforming <code>hello</code> into <code>algo</code> requires 3 steps, including 2 replacements and 1 deletion.</p> <p></p> <p> Figure 14-27   Example data for edit distance </p> <p>The edit distance problem can be naturally explained using the decision tree model. Strings correspond to tree nodes, and a round of decision (one edit operation) corresponds to an edge of the tree.</p> <p>As shown in Figure 14-28, without restricting operations, each node can branch into many edges, with each edge corresponding to one operation, meaning there are many possible paths to transform <code>hello</code> into <code>algo</code>.</p> <p>From the perspective of the decision tree, the goal of this problem is to find the shortest path between node <code>hello</code> and node <code>algo</code>.</p> <p></p> <p> Figure 14-28   Representing edit distance problem based on decision tree model </p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1-dynamic-programming-approach","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>Each round of decision involves performing one edit operation on string \\(s\\).</p> <p>We want the problem scale to gradually decrease during the editing process, which allows us to construct subproblems. Let the lengths of strings \\(s\\) and \\(t\\) be \\(n\\) and \\(m\\) respectively. We first consider the tail characters of the two strings, \\(s[n-1]\\) and \\(t[m-1]\\).</p> <ul> <li>If \\(s[n-1]\\) and \\(t[m-1]\\) are the same, we can skip them and directly consider \\(s[n-2]\\) and \\(t[m-2]\\).</li> <li>If \\(s[n-1]\\) and \\(t[m-1]\\) are different, we need to perform one edit on \\(s\\) (insert, delete, or replace) to make the tail characters of the two strings the same, allowing us to skip them and consider a smaller-scale problem.</li> </ul> <p>In other words, each round of decision (edit operation) we make on string \\(s\\) will change the remaining characters to be matched in \\(s\\) and \\(t\\). Therefore, the state is the \\(i\\)-th and \\(j\\)-th characters currently being considered in \\(s\\) and \\(t\\), denoted as \\([i, j]\\).</p> <p>State \\([i, j]\\) corresponds to the subproblem: the minimum number of edits required to change the first \\(i\\) characters of \\(s\\) into the first \\(j\\) characters of \\(t\\).</p> <p>From this, we obtain a two-dimensional \\(dp\\) table of size \\((i+1) \\times (j+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>Consider subproblem \\(dp[i, j]\\), where the tail characters of the corresponding two strings are \\(s[i-1]\\) and \\(t[j-1]\\), which can be divided into the three cases shown in Figure 14-29 based on different edit operations.</p> <ol> <li>Insert \\(t[j-1]\\) after \\(s[i-1]\\), then the remaining subproblem is \\(dp[i, j-1]\\).</li> <li>Delete \\(s[i-1]\\), then the remaining subproblem is \\(dp[i-1, j]\\).</li> <li>Replace \\(s[i-1]\\) with \\(t[j-1]\\), then the remaining subproblem is \\(dp[i-1, j-1]\\).</li> </ol> <p></p> <p> Figure 14-29   State transition for edit distance </p> <p>Based on the above analysis, the optimal substructure can be obtained: the minimum number of edits for \\(dp[i, j]\\) equals the minimum among the minimum edit steps of \\(dp[i, j-1]\\), \\(dp[i-1, j]\\), and \\(dp[i-1, j-1]\\), plus the edit step \\(1\\) for this time. The corresponding state transition equation is:</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>Please note that when \\(s[i-1]\\) and \\(t[j-1]\\) are the same, no edit is required for the current character, in which case the state transition equation is:</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>Step 3: Determine boundary conditions and state transition order</p> <p>When both strings are empty, the number of edit steps is \\(0\\), i.e., \\(dp[0, 0] = 0\\). When \\(s\\) is empty but \\(t\\) is not, the minimum number of edit steps equals the length of \\(t\\), i.e., the first row \\(dp[0, j] = j\\). When \\(s\\) is not empty but \\(t\\) is empty, the minimum number of edit steps equals the length of \\(s\\), i.e., the first column \\(dp[i, 0] = i\\).</p> <p>Observing the state transition equation, the solution \\(dp[i, j]\\) depends on solutions to the left, above, and upper-left, so the entire \\(dp\\) table can be traversed in order through two nested loops.</p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"Edit distance: Dynamic programming\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # State transition: first row and first column\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # State transition: rest of the rows and columns\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Edit distance: Dynamic programming */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* Edit distance: Dynamic programming */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // State transition: first row and first column\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Edit distance: Dynamic programming */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // State transition: first row and first column\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* Edit distance: Dynamic programming */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // State transition: first row and first column\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Edit distance: Dynamic programming */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // State transition: first row and first column\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // If two characters are equal, skip both characters\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Edit distance: Dynamic programming */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // State transition: first row and first column\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Edit distance: Dynamic programming */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // State transition: first row and first column\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### Edit distance: dynamic programming ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # State transition: first row and first column\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # State transition: rest of the rows and columns\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # If two characters are equal, skip both characters\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> <p>As shown in Figure 14-30, the state transition process for the edit distance problem is very similar to the knapsack problem and can both be viewed as the process of filling a two-dimensional grid.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-30   Dynamic programming process for edit distance </p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3-space-optimization","level":3,"title":"3.   Space Optimization","text":"<p>Since \\(dp[i, j]\\) is transferred from the solutions above \\(dp[i-1, j]\\), to the left \\(dp[i, j-1]\\), and to the upper-left \\(dp[i-1, j-1]\\), forward traversal will lose the upper-left solution \\(dp[i-1, j-1]\\), and reverse traversal cannot build \\(dp[i, j-1]\\) in advance, so neither traversal order is feasible.</p> <p>For this reason, we can use a variable <code>leftup</code> to temporarily store the upper-left solution \\(dp[i-1, j-1]\\), so we only need to consider the solutions to the left and above. This situation is the same as the unbounded knapsack problem, allowing for forward traversal. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"Edit distance: Space-optimized dynamic programming\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # State transition: first row\n    for j in range(1, m + 1):\n        dp[j] = j\n    # State transition: rest of the rows\n    for i in range(1, n + 1):\n        # State transition: first column\n        leftup = dp[0]  # Temporarily store dp[i-1, j-1]\n        dp[0] += 1\n        # State transition: rest of the columns\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # If two characters are equal, skip both characters\n                dp[j] = leftup\n            else:\n                # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # Update for next round's dp[i-1, j-1]\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // State transition: first row\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for i := 1; i &lt;= n; i++ {\n        // State transition: first column\n        leftUp := dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // If two characters are equal, skip both characters\n                dp[j] = leftUp\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // State transition: first row\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for i in 1 ... n {\n        // State transition: first column\n        var leftup = dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // State transition: first row\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        let leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // State transition: first row\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        let leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // State transition: first row\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // State transition: rest of the rows\n  for (int i = 1; i &lt;= n; i++) {\n    // State transition: first column\n    int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n    dp[0] = i;\n    // State transition: rest of the columns\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // If two characters are equal, skip both characters\n        dp[j] = leftup;\n      } else {\n        // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // Update for next round's dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // State transition: first row\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // State transition: rest of the rows\n    for i in 1..=n {\n        // State transition: first column\n        let mut leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i as i32;\n        // State transition: rest of the columns\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // State transition: first row\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for (i in 1..n) {\n        // State transition: first column\n        var leftup = dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### Edit distance: space-optimized DP ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # State transition: first row\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # State transition: rest of the rows\n  for i in 1...(n + 1)\n    # State transition: first column\n    leftup = dp.first # Temporarily store dp[i-1, j-1]\n    dp[0] += 1\n    # State transition: rest of the columns\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # If two characters are equal, skip both characters\n        dp[j] = leftup\n      else\n        # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # Update for next round's dp[i-1, j-1]\n    end\n  end\n  dp[m]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   Introduction to Dynamic Programming","text":"<p>Dynamic programming is an important algorithmic paradigm that decomposes a problem into a series of smaller subproblems and avoids redundant computation by storing the solutions to subproblems, thereby significantly improving time efficiency.</p> <p>In this section, we start with a classic example, first presenting its brute force backtracking solution, observing the overlapping subproblems within it, and then gradually deriving a more efficient dynamic programming solution.</p> <p>Climbing stairs</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time, how many different ways are there to reach the top?</p> <p>As shown in Figure 14-1, for a \\(3\\)-step staircase, there are \\(3\\) different ways to reach the top.</p> <p></p> <p> Figure 14-1   Number of ways to reach the 3rd step </p> <p>The goal of this problem is to find the number of ways, we can consider using backtracking to enumerate all possibilities. Specifically, imagine climbing stairs as a multi-round selection process: starting from the ground, choosing to go up \\(1\\) or \\(2\\) steps in each round, incrementing the count by \\(1\\) whenever the top of the stairs is reached, and pruning when exceeding the top. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"Backtracking\"\"\"\n    # When climbing to the n-th stair, add 1 to the solution count\n    if state == n:\n        res[0] += 1\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n:\n            continue\n        # Attempt: make a choice, update state\n        backtrack(choices, state + choice, n, res)\n        # Backtrack\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Backtracking\"\"\"\n    choices = [1, 2]  # Can choose to climb up 1 or 2 stairs\n    state = 0  # Start climbing from the 0-th stair\n    res = [0]  # Use res[0] to record the solution count\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* Backtracking */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    for (auto &amp;choice : choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // Can choose to climb up 1 or 2 stairs\n    int state = 0;                // Start climbing from the 0-th stair\n    vector&lt;int&gt; res = {0};        // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* Backtracking */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (Integer choice : choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // Can choose to climb up 1 or 2 stairs\n    int state = 0; // Start climbing from the 0-th stair\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* Backtracking */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    foreach (int choice in choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        Backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    int state = 0; // Start climbing from the 0-th stair\n    List&lt;int&gt; res = [0]; // Use res[0] to record the solution count\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* Backtracking */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // Traverse all choices\n    for _, choice := range choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state+choice &gt; n {\n            continue\n        }\n        // Attempt: make choice, update state\n        backtrack(choices, state+choice, n, res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunc climbingStairsBacktrack(n int) int {\n    // Can choose to climb up 1 or 2 stairs\n    choices := []int{1, 2}\n    // Start climbing from the 0-th stair\n    state := 0\n    res := make([]int, 1)\n    // Use res[0] to record the solution count\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* Backtracking */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] += 1\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n {\n            continue\n        }\n        // Attempt: make choice, update state\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // Can choose to climb up 1 or 2 stairs\n    let state = 0 // Start climbing from the 0-th stair\n    var res: [Int] = []\n    res.append(0) // Use res[0] to record the solution count\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* Backtracking */\nfunction backtrack(choices, state, n, res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    const state = 0; // Start climbing from the 0-th stair\n    const res = new Map();\n    res.set(0, 0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* Backtracking */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    const state = 0; // Start climbing from the 0-th stair\n    const res = new Map();\n    res.set(0, 0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* Backtracking */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // When climbing to the n-th stair, add 1 to the solution count\n  if (state == n) {\n    res[0]++;\n  }\n  // Traverse all choices\n  for (int choice in choices) {\n    // Pruning: not allowed to go beyond the n-th stair\n    if (state + choice &gt; n) continue;\n    // Attempt: make choice, update state\n    backtrack(choices, state + choice, n, res);\n    // Backtrack\n  }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n  int state = 0; // Start climbing from the 0-th stair\n  List&lt;int&gt; res = [];\n  res.add(0); // Use res[0] to record the solution count\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* Backtracking */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // Traverse all choices\n    for &amp;choice in choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n {\n            continue;\n        }\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // Can choose to climb up 1 or 2 stairs\n    let state = 0; // Start climbing from the 0-th stair\n    let mut res = Vec::new();\n    res.push(0); // Use res[0] to record the solution count\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* Backtracking */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res, len);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // Can choose to climb up 1 or 2 stairs\n    int state = 0;           // Start climbing from the 0-th stair\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // Use res[0] to record the solution count\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* Backtracking */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0] = res[0] + 1\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // Can choose to climb up 1 or 2 stairs\n    val state = 0 // Start climbing from the 0-th stair\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // Use res[0] to record the solution count\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### Backtracking ###\ndef backtrack(choices, state, n, res)\n  # When climbing to the n-th stair, add 1 to the solution count\n  res[0] += 1 if state == n\n  # Traverse all choices\n  for choice in choices\n    # Pruning: not allowed to go beyond the n-th stair\n    next if state + choice &gt; n\n\n    # Attempt: make choice, update state\n    backtrack(choices, state + choice, n, res)\n  end\n  # Backtrack\nend\n\n### Climbing stairs: backtracking ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # Can choose to climb up 1 or 2 stairs\n  state = 0 # Start climbing from the 0-th stair\n  res = [0] # Use res[0] to record the solution count\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-method-1-brute-force-search","level":2,"title":"14.1.1   Method 1: Brute Force Search","text":"<p>Backtracking algorithms typically do not explicitly decompose problems, but rather treat solving the problem as a series of decision steps, searching for all possible solutions through trial and pruning.</p> <p>We can try to analyze this problem from the perspective of problem decomposition. Let the number of ways to climb to the \\(i\\)-th step be \\(dp[i]\\), then \\(dp[i]\\) is the original problem, and its subproblems include:</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>Since we can only go up \\(1\\) or \\(2\\) steps in each round, when we stand on the \\(i\\)-th step, we could only have been on the \\(i-1\\)-th or \\(i-2\\)-th step in the previous round. In other words, we can only reach the \\(i\\)-th step from the \\(i-1\\)-th or \\(i-2\\)-th step.</p> <p>This leads to an important conclusion: the number of ways to climb to the \\(i-1\\)-th step plus the number of ways to climb to the \\(i-2\\)-th step equals the number of ways to climb to the \\(i\\)-th step. The formula is as follows:</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>This means that in the stair climbing problem, there exists a recurrence relation among the subproblems, the solution to the original problem can be constructed from the solutions to the subproblems. Figure 14-2 illustrates this recurrence relation.</p> <p></p> <p> Figure 14-2   Recurrence relation for the number of ways </p> <p>We can obtain a brute force search solution based on the recurrence formula. Starting from \\(dp[n]\\), recursively decompose a larger problem into the sum of two smaller problems, until reaching the smallest subproblems \\(dp[1]\\) and \\(dp[2]\\) and returning. Among them, the solutions to the smallest subproblems are known, namely \\(dp[1] = 1\\) and \\(dp[2] = 2\\), representing \\(1\\) and \\(2\\) ways to climb to the \\(1\\)st and \\(2\\)nd steps, respectively.</p> <p>Observe the following code, which, like standard backtracking code, belongs to depth-first search but is more concise:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"Search\"\"\"\n    # Known dp[1] and dp[2], return them\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Search\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* Search */\nint DFS(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* Search */\nfunc dfs(i int) int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* Search */\nfunc dfs(i: Int) -&gt; Int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* Search */\nfunction dfs(i) {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* Search */\nfunction dfs(i: number): number {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* Search */\nint dfs(int i) {\n  // Known dp[1] and dp[2], return them\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* Search */\nfn dfs(i: usize) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* Climbing stairs: Search */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* Search */\nfun dfs(i: Int): Int {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### Search ###\ndef dfs(i)\n  # Known dp[1] and dp[2], return them\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### Climbing stairs: search ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> <p>Figure 14-3 shows the recursion tree formed by brute force search. For the problem \\(dp[n]\\), the depth of its recursion tree is \\(n\\), with a time complexity of \\(O(2^n)\\). Exponential order represents explosive growth; if we input a relatively large \\(n\\), we will fall into a long wait.</p> <p></p> <p> Figure 14-3   Recursion tree for climbing stairs </p> <p>Observing the above figure, the exponential time complexity is caused by \"overlapping subproblems\". For example, \\(dp[9]\\) is decomposed into \\(dp[8]\\) and \\(dp[7]\\), and \\(dp[8]\\) is decomposed into \\(dp[7]\\) and \\(dp[6]\\), both of which contain the subproblem \\(dp[7]\\).</p> <p>And so on, subproblems contain smaller overlapping subproblems, ad infinitum. The vast majority of computational resources are wasted on these overlapping subproblems.</p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-method-2-memoization","level":2,"title":"14.1.2   Method 2: Memoization","text":"<p>To improve algorithm efficiency, we want all overlapping subproblems to be computed only once. For this purpose, we declare an array <code>mem</code> to record the solution to each subproblem and prune overlapping subproblems during the search process.</p> <ol> <li>When computing \\(dp[i]\\) for the first time, we record it in <code>mem[i]</code> for later use.</li> <li>When we need to compute \\(dp[i]\\) again, we can directly retrieve the result from <code>mem[i]</code>, thereby avoiding redundant computation of that subproblem.</li> </ol> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"Memoization search\"\"\"\n    # Known dp[1] and dp[2], return them\n    if i == 1 or i == 2:\n        return i\n    # If record dp[i] exists, return it directly\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # Record dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Memoization search\"\"\"\n    # mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* Memoization search */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* Memoization search */\nint dfs(int i, int[] mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* Memoization search */\nint DFS(int i, int[] mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* Memoization search */\nfunc dfsMem(i int, mem []int) int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* Memoization search */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* Memoization search */\nfunction dfs(i, mem) {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* Memoization search */\nfunction dfs(i: number, mem: number[]): number {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* Memoization search */\nint dfs(int i, List&lt;int&gt; mem) {\n  // Known dp[1] and dp[2], return them\n  if (i == 1 || i == 2) return i;\n  // If record dp[i] exists, return it directly\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // Record dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n  // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* Memoization search */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    count\n}\n\n/* Climbing stairs: Memoization search */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* Memoization search */\nint dfs(int i, int *mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* Memoization search */\nfun dfs(i: Int, mem: IntArray): Int {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2) return i\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### Memoization search ###\ndef dfs(i, mem)\n  # Known dp[1] and dp[2], return them\n  return i if i == 1 || i == 2\n  # If record dp[i] exists, return it directly\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # Record dp[i]\n  mem[i] = count\nend\n\n### Climbing stairs: memoization search ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> <p>Observe Figure 14-4, after memoization, all overlapping subproblems only need to be computed once, optimizing the time complexity to \\(O(n)\\), which is a tremendous leap.</p> <p></p> <p> Figure 14-4   Recursion tree with memoization </p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-method-3-dynamic-programming","level":2,"title":"14.1.3   Method 3: Dynamic Programming","text":"<p>Memoization is a \"top-down\" method: we start from the original problem (root node), recursively decompose larger subproblems into smaller ones, until reaching the smallest known subproblems (leaf nodes). Afterward, by backtracking, we collect the solutions to the subproblems layer by layer to construct the solution to the original problem.</p> <p>In contrast, dynamic programming is a \"bottom-up\" method: starting from the solutions to the smallest subproblems, iteratively constructing solutions to larger subproblems until obtaining the solution to the original problem.</p> <p>Since dynamic programming does not include a backtracking process, it only requires loop iteration for implementation and does not need recursion. In the following code, we initialize an array <code>dp</code> to store the solutions to subproblems, which serves the same recording function as the array <code>mem</code> in memoization:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [0] * (n + 1)\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1], dp[2] = 1, 2\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;int&gt; dp(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Climbing stairs: Dynamic programming */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Climbing stairs: Dynamic programming */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Climbing stairs: Dynamic programming */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: 0, count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Climbing stairs: Dynamic programming */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1).fill(-1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Climbing stairs: Dynamic programming */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1).fill(-1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1] = 1;\n  dp[2] = 2;\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Climbing stairs: Dynamic programming */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![-1; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Climbing stairs: Dynamic programming */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = IntArray(n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Climbing stairs: dynamic programming ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = 1, 2\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> <p>Figure 14-5 simulates the execution process of the above code.</p> <p></p> <p> Figure 14-5   Dynamic programming process for climbing stairs </p> <p>Like backtracking algorithms, dynamic programming also uses the \"state\" concept to represent specific stages of problem solving, with each state corresponding to a subproblem and its corresponding local optimal solution. For example, the state in the stair climbing problem is defined as the current stair step number \\(i\\).</p> <p>Based on the above content, we can summarize the commonly used terminology in dynamic programming.</p> <ul> <li>The array <code>dp</code> is called the dp table, where \\(dp[i]\\) represents the solution to the subproblem corresponding to state \\(i\\).</li> <li>The states corresponding to the smallest subproblems (the \\(1\\)st and \\(2\\)nd steps) are called initial states.</li> <li>The recurrence formula \\(dp[i] = dp[i-1] + dp[i-2]\\) is called the state transition equation.</li> </ul>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414-space-optimization","level":2,"title":"14.1.4   Space Optimization","text":"<p>Observant readers may have noticed that since \\(dp[i]\\) is only related to \\(dp[i-1]\\) and \\(dp[i-2]\\), we do not need to use an array <code>dp</code> to store the solutions to all subproblems, but can simply use two variables to roll forward. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Space-optimized dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Climbing stairs: space-optimized DP ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> <p>Observing the above code, since the space occupied by the array <code>dp</code> is saved, the space complexity is reduced from \\(O(n)\\) to \\(O(1)\\).</p> <p>In dynamic programming problems, the current state often depends only on a limited number of preceding states, allowing us to retain only the necessary states and save memory space through \"dimension reduction\". This space optimization technique is called \"rolling variable\" or \"rolling array\".</p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 Knapsack Problem","text":"<p>The knapsack problem is an excellent introductory problem for dynamic programming and is one of the most common problem forms in dynamic programming. It has many variants, such as the 0-1 knapsack problem, the unbounded knapsack problem, and the multiple knapsack problem.</p> <p>In this section, we will first solve the most common 0-1 knapsack problem.</p> <p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can only be selected once. What is the maximum value that can be placed in the knapsack within the capacity limit?</p> <p>Observe Figure 14-17. Since item number \\(i\\) starts counting from \\(1\\) and array indices start from \\(0\\), item \\(i\\) corresponds to weight \\(wgt[i-1]\\) and value \\(val[i-1]\\).</p> <p></p> <p> Figure 14-17   Example data for 0-1 knapsack </p> <p>We can view the 0-1 knapsack problem as a process consisting of \\(n\\) rounds of decisions, where for each item there are two decisions: not putting it in and putting it in, thus the problem satisfies the decision tree model.</p> <p>The goal of this problem is to find \"the maximum value that can be placed in the knapsack within the capacity limit\", so it is more likely to be a dynamic programming problem.</p> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>For each item, if not placed in the knapsack, the knapsack capacity remains unchanged; if placed in, the knapsack capacity decreases. From this, we can derive the state definition: current item number \\(i\\) and knapsack capacity \\(c\\), denoted as \\([i, c]\\).</p> <p>State \\([i, c]\\) corresponds to the subproblem: the maximum value among the first \\(i\\) items in a knapsack of capacity \\(c\\), denoted as \\(dp[i, c]\\).</p> <p>What we need to find is \\(dp[n, cap]\\), so we need a two-dimensional \\(dp\\) table of size \\((n+1) \\times (cap+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>After making the decision for item \\(i\\), what remains is the subproblem of the first \\(i-1\\) items, which can be divided into the following two cases.</p> <ul> <li>Not putting item \\(i\\): The knapsack capacity remains unchanged, and the state changes to \\([i-1, c]\\).</li> <li>Putting item \\(i\\): The knapsack capacity decreases by \\(wgt[i-1]\\), the value increases by \\(val[i-1]\\), and the state changes to \\([i-1, c-wgt[i-1]]\\).</li> </ul> <p>The above analysis reveals the optimal substructure of this problem: the maximum value \\(dp[i, c]\\) equals the larger value between not putting item \\(i\\) and putting item \\(i\\). From this, the state transition equation can be derived:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>Note that if the weight of the current item \\(wgt[i - 1]\\) exceeds the remaining knapsack capacity \\(c\\), then the only option is not to put it in the knapsack.</p> <p>Step 3: Determine boundary conditions and state transition order</p> <p>When there are no items or the knapsack capacity is \\(0\\), the maximum value is \\(0\\), i.e., the first column \\(dp[i, 0]\\) and the first row \\(dp[0, c]\\) are both equal to \\(0\\).</p> <p>The current state \\([i, c]\\) is transferred from the state above \\([i-1, c]\\) and the state in the upper-left \\([i-1, c-wgt[i-1]]\\), so the entire \\(dp\\) table is traversed in order through two nested loops.</p> <p>Based on the above analysis, we will next implement the brute force search, memoization, and dynamic programming solutions in order.</p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-method-1-brute-force-search","level":3,"title":"1.   Method 1: Brute Force Search","text":"<p>The search code includes the following elements.</p> <ul> <li>Recursive parameters: state \\([i, c]\\).</li> <li>Return value: solution to the subproblem \\(dp[i, c]\\).</li> <li>Termination condition: when the item number is out of bounds \\(i = 0\\) or the remaining knapsack capacity is \\(0\\), terminate recursion and return value \\(0\\).</li> <li>Pruning: if the weight of the current item exceeds the remaining knapsack capacity, only the option of not putting it in is available.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 knapsack: Brute-force search\"\"\"\n    # If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 or c == 0:\n        return 0\n    # If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # Calculate the maximum value of not putting in and putting in item i\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Return the larger value of the two options\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Brute-force search */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Brute-force search */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // Return the larger value of the two options\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Brute-force search */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Return the larger value of the two options\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Brute-force search */\nfunction knapsackDFS(wgt, val, i, c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Brute-force search */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // If all items have been selected or knapsack has no remaining capacity, return value 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // If exceeds knapsack capacity, can only choose not to put it in\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // Calculate the maximum value of not putting in and putting in item i\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Return the larger value of the two options\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Brute-force search */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Return the larger value of the two options\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Brute-force search */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Return the larger value of the two options\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: brute force search ###\ndef knapsack_dfs(wgt, val, i, c)\n  # If all items have been selected or knapsack has no remaining capacity, return value 0\n  return 0 if i == 0 || c == 0\n  # If exceeds knapsack capacity, can only choose not to put it in\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # Calculate the maximum value of not putting in and putting in item i\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Return the larger value of the two options\n  [no, yes].max\nend\n</code></pre> <p>As shown in Figure 14-18, since each item generates two search branches of not selecting and selecting, the time complexity is \\(O(2^n)\\).</p> <p>Observing the recursion tree, it is easy to see overlapping subproblems, such as \\(dp[1, 10]\\). When there are many items, large knapsack capacity, and especially many items with the same weight, the number of overlapping subproblems will increase significantly.</p> <p></p> <p> Figure 14-18   Brute force search recursion tree for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-method-2-memoization","level":3,"title":"2.   Method 2: Memoization","text":"<p>To ensure that overlapping subproblems are only computed once, we use a memo list <code>mem</code> to record the solutions to subproblems, where <code>mem[i][c]</code> corresponds to \\(dp[i, c]\\).</p> <p>After introducing memoization, the time complexity depends on the number of subproblems, which is \\(O(n \\times cap)\\). The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 knapsack: Memoization search\"\"\"\n    # If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 or c == 0:\n        return 0\n    # If there's a record, return it directly\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # Calculate the maximum value of not putting in and putting in item i\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Memoization search */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Memoization search */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // Return the larger value of the two options\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Memoization search */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Memoization search */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Memoization search */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // If all items have been selected or knapsack has no remaining capacity, return value 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // If there's a record, return it directly\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // If exceeds knapsack capacity, can only choose not to put it in\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // Calculate the maximum value of not putting in and putting in item i\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Record and return the larger value of the two options\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Memoization search */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Memoization search */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: memoization search ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # If all items have been selected or knapsack has no remaining capacity, return value 0\n  return 0 if i == 0 || c == 0\n  # If there's a record, return it directly\n  return mem[i][c] if mem[i][c] != -1\n  # If exceeds knapsack capacity, can only choose not to put it in\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # Calculate the maximum value of not putting in and putting in item i\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Record and return the larger value of the two options\n  mem[i][c] = [no, yes].max\nend\n</code></pre> <p>Figure 14-19 shows the search branches pruned in memoization.</p> <p></p> <p> Figure 14-19   Memoization recursion tree for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-method-3-dynamic-programming","level":3,"title":"3.   Method 3: Dynamic Programming","text":"<p>Dynamic programming is essentially the process of filling the \\(dp\\) table during state transitions. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 knapsack: Dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # State transition\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Dynamic programming */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Dynamic programming */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Dynamic programming */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: dynamic programming ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # State transition\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> <p>As shown in Figure 14-20, both time complexity and space complexity are determined by the size of the array <code>dp</code>, which is \\(O(n \\times cap)\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-20   Dynamic programming process for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4-space-optimization","level":3,"title":"4.   Space Optimization","text":"<p>Since each state is only related to the state in the row above it, we can use two arrays rolling forward to reduce the space complexity from \\(O(n^2)\\) to \\(O(n)\\).</p> <p>Further thinking, can we achieve space optimization using just one array? Observing, we can see that each state is transferred from the cell directly above or the cell in the upper-left. If there is only one array, when we start traversing row \\(i\\), that array still stores the state of row \\(i-1\\).</p> <ul> <li>If using forward traversal, then when traversing to \\(dp[i, j]\\), the values in the upper-left \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) may have already been overwritten, thus preventing correct state transition.</li> <li>If using reverse traversal, there will be no overwriting issue, and state transition can proceed correctly.</li> </ul> <p>Figure 14-21 shows the transition process from row \\(i = 1\\) to row \\(i = 2\\) using a single array. Please consider the difference between forward and reverse traversal.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-21   Space-optimized dynamic programming process for 0-1 knapsack </p> <p>In the code implementation, we simply need to delete the first dimension \\(i\\) of the array <code>dp</code> and change the inner loop to reverse traversal:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 knapsack: Space-optimized dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [0] * (cap + 1)\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in reverse order\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([]int, cap+1)\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in reverse order\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // The larger value between not selecting and selecting item i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: cap + 1)\n    // State transition\n    for i in 1 ... n {\n        // Traverse in reverse order\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(cap + 1).fill(0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(cap + 1).fill(0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    // Traverse in reverse order\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // The larger value between not selecting and selecting item i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![0; cap + 1];\n    // State transition\n    for i in 1..=n {\n        // Traverse in reverse order\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // The larger value between not selecting and selecting item i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int *dp = calloc(cap + 1, sizeof(int));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = IntArray(cap + 1)\n    // State transition\n    for (i in 1..n) {\n        // Traverse in reverse order\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: space-optimized DP ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(cap + 1, 0)\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in reverse order\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   Summary","text":"","path":["Chapter 14. Dynamic Programming","14.7 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Dynamic programming decomposes problems and avoids redundant computation by storing the solutions to subproblems, thereby significantly improving computational efficiency.</li> <li>Without considering time constraints, all dynamic programming problems can be solved using backtracking (brute force search), but the recursion tree contains a large number of overlapping subproblems, resulting in extremely low efficiency. By introducing a memo list, we can store the solutions to all computed subproblems, ensuring that overlapping subproblems are only computed once.</li> <li>Memoization is a top-down recursive solution, while the corresponding dynamic programming is a bottom-up iterative solution, similar to \"filling in a table\". Since the current state only depends on certain local states, we can eliminate one dimension of the \\(dp\\) table to reduce space complexity.</li> <li>Subproblem decomposition is a general algorithmic approach, with different properties in divide and conquer, dynamic programming, and backtracking.</li> <li>Dynamic programming problems have three major characteristics: overlapping subproblems, optimal substructure, and no aftereffects.</li> <li>If the optimal solution to the original problem can be constructed from the optimal solutions to the subproblems, then it has optimal substructure.</li> <li>No aftereffects means that for a given state, its future development is only related to that state and has nothing to do with all past states. Many combinatorial optimization problems do not have no aftereffects and cannot be quickly solved using dynamic programming.</li> </ul> <p>Knapsack problem</p> <ul> <li>The knapsack problem is one of the most typical dynamic programming problems, with variants such as the 0-1 knapsack, unbounded knapsack, and multiple knapsack.</li> <li>The state definition for the 0-1 knapsack is the maximum value among the first \\(i\\) items in a knapsack of capacity \\(c\\). Based on the two decisions of not putting an item in the knapsack and putting it in, the optimal substructure can be identified and the state transition equation constructed. In space optimization, since each state depends on the state directly above and to the upper-left, the list needs to be traversed in reverse order to avoid overwriting the upper-left state.</li> <li>The unbounded knapsack problem has no limit on the selection quantity of each type of item, so the state transition for choosing to put in an item differs from the 0-1 knapsack problem. Since the state depends on the state directly above and directly to the left, space optimization should use forward traversal.</li> <li>The coin change problem is a variant of the unbounded knapsack problem. It changes from seeking the \"maximum\" value to seeking the \"minimum\" number of coins, so \\(\\max()\\) in the state transition equation should be changed to \\(\\min()\\). It changes from seeking \"not exceeding\" the knapsack capacity to seeking \"exactly\" making up the target amount, so \\(amt + 1\\) is used to represent the invalid solution of \"unable to make up the target amount\".</li> <li>Coin change problem II changes from seeking the \"minimum number of coins\" to seeking the \"number of coin combinations\", so the state transition equation correspondingly changes from \\(\\min()\\) to a summation operator.</li> </ul> <p>Edit distance problem</p> <ul> <li>Edit distance (Levenshtein distance) is used to measure the similarity between two strings, defined as the minimum number of edit steps from one string to another, with edit operations including insert, delete, and replace.</li> <li>The state definition for the edit distance problem is the minimum number of edit steps required to change the first \\(i\\) characters of \\(s\\) into the first \\(j\\) characters of \\(t\\). When \\(s[i] \\ne t[j]\\), there are three decisions: insert, delete, replace, each with corresponding remaining subproblems. From this, the optimal substructure can be identified and the state transition equation constructed. When \\(s[i] = t[j]\\), no edit is required for the current character.</li> <li>In edit distance, the state depends on the state directly above, directly to the left, and to the upper-left, so after space optimization, neither forward nor reverse traversal can correctly perform state transitions. For this reason, we use a variable to temporarily store the upper-left state, thus transforming to a situation equivalent to the unbounded knapsack problem, allowing for forward traversal after space optimization.</li> </ul>","path":["Chapter 14. Dynamic Programming","14.7 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   Unbounded Knapsack Problem","text":"<p>In this section, we first solve another common knapsack problem: the unbounded knapsack, and then explore a special case of it: the coin change problem.</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451-unbounded-knapsack-problem","level":2,"title":"14.5.1   Unbounded Knapsack Problem","text":"<p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can be selected multiple times. What is the maximum value that can be placed in the knapsack within the capacity limit? An example is shown in Figure 14-22.</p> <p></p> <p> Figure 14-22   Example data for unbounded knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>The unbounded knapsack problem is very similar to the 0-1 knapsack problem, differing only in that there is no limit on the number of times an item can be selected.</p> <ul> <li>In the 0-1 knapsack problem, there is only one of each type of item, so after placing item \\(i\\) in the knapsack, we can only choose from the first \\(i-1\\) items.</li> <li>In the unbounded knapsack problem, the quantity of each type of item is unlimited, so after placing item \\(i\\) in the knapsack, we can still choose from the first \\(i\\) items.</li> </ul> <p>Under the rules of the unbounded knapsack problem, the changes in state \\([i, c]\\) are divided into two cases.</p> <ul> <li>Not putting item \\(i\\): Same as the 0-1 knapsack problem, transfer to \\([i-1, c]\\).</li> <li>Putting item \\(i\\): Different from the 0-1 knapsack problem, transfer to \\([i, c-wgt[i-1]]\\).</li> </ul> <p>Thus, the state transition equation becomes:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>Comparing the code for the two problems, there is one change in state transition from \\(i-1\\) to \\(i\\), with everything else identical:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Unbounded knapsack: Dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # State transition\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Unbounded knapsack: Dynamic programming */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Unbounded knapsack: Dynamic programming */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Unbounded knapsack: Dynamic programming */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Unbounded knapsack: dynamic programming ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # State transition\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization","level":3,"title":"3.   Space Optimization","text":"<p>Since the current state is transferred from states on the left and above, after space optimization, each row in the \\(dp\\) table should be traversed in forward order.</p> <p>This traversal order is exactly opposite to the 0-1 knapsack. Please refer to Figure 14-23 to understand the difference between the two.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-23   Space-optimized dynamic programming process for unbounded knapsack problem </p> <p>The code implementation is relatively simple, just delete the first dimension of the array <code>dp</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Unbounded knapsack: Space-optimized dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [0] * (cap + 1)\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([]int, cap+1)\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: cap + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![0; cap + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int *dp = calloc(cap + 1, sizeof(int));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = IntArray(cap + 1)\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Unbounded knapsack: space-optimized DP ###\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(cap + 1, 0)\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452-coin-change-problem","level":2,"title":"14.5.2   Coin Change Problem","text":"<p>The knapsack problem represents a large class of dynamic programming problems and has many variants, such as the coin change problem.</p> <p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\). Each type of coin can be selected multiple times. What is the minimum number of coins needed to make up the target amount? If it is impossible to make up the target amount, return \\(-1\\). An example is shown in Figure 14-24.</p> <p></p> <p> Figure 14-24   Example data for coin change problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach_1","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>The coin change problem can be viewed as a special case of the unbounded knapsack problem, with the following connections and differences.</p> <ul> <li>The two problems can be converted to each other: \"item\" corresponds to \"coin\", \"item weight\" corresponds to \"coin denomination\", and \"knapsack capacity\" corresponds to \"target amount\".</li> <li>The optimization goals are opposite: the unbounded knapsack problem aims to maximize item value, while the coin change problem aims to minimize the number of coins.</li> <li>The unbounded knapsack problem seeks solutions \"not exceeding\" the knapsack capacity, while the coin change problem seeks solutions that \"exactly\" make up the target amount.</li> </ul> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>State \\([i, a]\\) corresponds to the subproblem: the minimum number of coins among the first \\(i\\) types of coins that can make up amount \\(a\\), denoted as \\(dp[i, a]\\).</p> <p>The two-dimensional \\(dp\\) table has size \\((n+1) \\times (amt+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>This problem differs from the unbounded knapsack problem in the following two aspects regarding the state transition equation.</p> <ul> <li>This problem seeks the minimum value, so the operator \\(\\max()\\) needs to be changed to \\(\\min()\\).</li> <li>The optimization target is the number of coins rather than item value, so when a coin is selected, simply execute \\(+1\\).</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>Step 3: Determine boundary conditions and state transition order</p> <p>When the target amount is \\(0\\), the minimum number of coins needed to make it up is \\(0\\), so all \\(dp[i, 0]\\) in the first column equal \\(0\\).</p> <p>When there are no coins, it is impossible to make up any amount \\(&gt; 0\\), which is an invalid solution. To enable the \\(\\min()\\) function in the state transition equation to identify and filter out invalid solutions, we consider using \\(+ \\infty\\) to represent them, i.e., set all \\(dp[0, a]\\) in the first row to \\(+ \\infty\\).</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation_1","level":3,"title":"2.   Code Implementation","text":"<p>Most programming languages do not provide a \\(+ \\infty\\) variable, and can only use the maximum value of integer type <code>int</code> as a substitute. However, this can lead to large number overflow: the \\(+ 1\\) operation in the state transition equation may cause overflow.</p> <p>For this reason, we use the number \\(amt + 1\\) to represent invalid solutions, because the maximum number of coins needed to make up \\(amt\\) is at most \\(amt\\). Before returning, check whether \\(dp[n, amt]\\) equals \\(amt + 1\\); if so, return \\(-1\\), indicating that the target amount cannot be made up. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Dynamic programming\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Initialize dp table\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # State transition: first row and first column\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # State transition: rest of the rows and columns\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][amt + 1];\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Coin change: Dynamic programming */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, amt + 1];\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // State transition: first row and first column\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // State transition: first row and first column\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Coin change: Dynamic programming */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Coin change: Dynamic programming */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // State transition: first row and first column\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // The smaller value between not selecting and selecting coin i\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Coin change: Dynamic programming */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Initialize dp table\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // State transition: first row and first column\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Coin change: Dynamic programming */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // State transition: first row and first column\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Coin change: dynamic programming ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # State transition: first row and first column\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # State transition: rest of the rows and columns\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # The smaller value between not selecting and selecting coin i\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> <p>Figure 14-25 shows the dynamic programming process for coin change, which is very similar to the unbounded knapsack problem.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-25   Dynamic programming process for coin change problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization_1","level":3,"title":"3.   Space Optimization","text":"<p>The space optimization for the coin change problem is handled in the same way as the unbounded knapsack problem:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Space-optimized dynamic programming\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Initialize dp table\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            else:\n                # The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Initialize dp table\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Coin change: Space-optimized dynamic programming */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Initialize dp table\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in forward order\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Initialize dp table\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[a] = dp[a];\n      } else {\n        // The smaller value between not selecting and selecting coin i\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Coin change: Space-optimized dynamic programming */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Initialize dp table\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Coin change: Space-optimized dynamic programming */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Initialize dp table\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Coin change: space-optimized DP ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Initialize dp table\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[a] = dp[a]\n      else\n        # The smaller value between not selecting and selecting coin i\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-coin-change-problem-ii","level":2,"title":"14.5.3   Coin Change Problem Ii","text":"<p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\). Each type of coin can be selected multiple times. What is the number of coin combinations that can make up the target amount? An example is shown in Figure 14-26.</p> <p></p> <p> Figure 14-26   Example data for coin change problem II </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach_2","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>Compared to the previous problem, this problem's goal is to find the number of combinations, so the subproblem becomes: the number of combinations among the first \\(i\\) types of coins that can make up amount \\(a\\). The \\(dp\\) table remains a two-dimensional matrix of size \\((n+1) \\times (amt + 1)\\).</p> <p>The number of combinations for the current state equals the sum of the combinations from not selecting the current coin and selecting the current coin. The state transition equation is:</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>When the target amount is \\(0\\), no coins need to be selected to make up the target amount, so all \\(dp[i, 0]\\) in the first column should be initialized to \\(1\\). When there are no coins, it is impossible to make up any amount \\(&gt;0\\), so all \\(dp[0, a]\\) in the first row equal \\(0\\).</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation_2","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change II: Dynamic programming\"\"\"\n    n = len(coins)\n    # Initialize dp table\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Initialize first column\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # State transition\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][amt + 1];\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Coin change II: Dynamic programming */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, amt + 1];\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Coin change II: Dynamic programming */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Initialize first column\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Coin change II: Dynamic programming */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Initialize first column\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Coin change II: Dynamic programming */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Initialize first column\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Coin change II: Dynamic programming */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Initialize first column\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Initialize first column\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Sum of the two options: not selecting and selecting coin i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Coin change II: Dynamic programming */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Initialize first column\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Coin change II: Dynamic programming */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Initialize first column\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Coin change II: dynamic programming ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Initialize first column\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # State transition\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Sum of the two options: not selecting and selecting coin i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization_2","level":3,"title":"3.   Space Optimization","text":"<p>The space optimization is handled in the same way, just delete the coin dimension:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change II: Space-optimized dynamic programming\"\"\"\n    n = len(coins)\n    # Initialize dp table\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            else:\n                # Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // Initialize dp table\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in forward order\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[a] = dp[a];\n      } else {\n        // Sum of the two options: not selecting and selecting coin i\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Initialize dp table\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Initialize dp table\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Initialize dp table\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Coin change II: space-optimized DP ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # Initialize dp table\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[a] = dp[a]\n      else\n        # Sum of the two options: not selecting and selecting coin i\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"Chapter 9.   Graph","text":"<p>Abstract</p> <p>In the journey of life, we are like nodes, connected by countless invisible edges.</p> <p>Each encounter and parting leaves a unique mark on this vast network graph.</p>","path":["Chapter 9. Graph","Chapter 9. &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>9.1   Graph</li> <li>9.2   Basic Operations on Graphs</li> <li>9.3   Graph Traversal</li> <li>9.4   Summary</li> </ul>","path":["Chapter 9. Graph","Chapter 9. &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   Graph","text":"<p>A graph is a nonlinear data structure consisting of vertices and edges. We can abstractly represent a graph \\(G\\) as a set of vertices \\(V\\) and a set of edges \\(E\\). The following example shows a graph containing 5 vertices and 7 edges.</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>If we view vertices as nodes and edges as references (pointers) connecting the nodes, we can see graphs as a data structure extended from linked lists. As shown in Figure 9-1, compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.</p> <p></p> <p> Figure 9-1   Relationships among linked lists, trees, and graphs </p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#911-common-types-and-terminology-of-graphs","level":2,"title":"9.1.1   Common Types and Terminology of Graphs","text":"<p>Graphs can be divided into undirected graphs and directed graphs based on whether edges have direction, as shown in Figure 9-2.</p> <ul> <li>In undirected graphs, edges represent a \"bidirectional\" connection between two vertices, such as the \"friend relationship\" on WeChat or QQ.</li> <li>In directed graphs, edges have directionality, meaning edges \\(A \\rightarrow B\\) and \\(A \\leftarrow B\\) are independent of each other, such as the \"follow\" and \"be followed\" relationships on Weibo or TikTok.</li> </ul> <p></p> <p> Figure 9-2   Directed and undirected graphs </p> <p>Graphs can be divided into connected graphs and disconnected graphs based on whether all vertices are connected, as shown in Figure 9-3.</p> <ul> <li>For connected graphs, starting from any vertex, all other vertices can be reached.</li> <li>For disconnected graphs, starting from a certain vertex, at least one vertex cannot be reached.</li> </ul> <p></p> <p> Figure 9-3   Connected and disconnected graphs </p> <p>We can also add a \"weight\" variable to edges, resulting in weighted graphs as shown in Figure 9-4. For example, in mobile games like \"Honor of Kings\", the system calculates the \"intimacy\" between players based on their shared game time, and such intimacy networks can be represented using weighted graphs.</p> <p></p> <p> Figure 9-4   Weighted and unweighted graphs </p> <p>Graph data structures include the following commonly used terms.</p> <ul> <li>Adjacency: When two vertices are connected by an edge, these two vertices are said to be \"adjacent\". In Figure 9-4, the adjacent vertices of vertex 1 are vertices 2, 3, and 5.</li> <li>Path: The sequence of edges from vertex A to vertex B is called a \"path\" from A to B. In Figure 9-4, the edge sequence 1-5-2-4 is a path from vertex 1 to vertex 4.</li> <li>Degree: The number of edges a vertex has. For directed graphs, in-degree indicates how many edges point to the vertex, and out-degree indicates how many edges point out from the vertex.</li> </ul>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#912-representation-of-graphs","level":2,"title":"9.1.2   Representation of Graphs","text":"<p>Common representations of graphs include \"adjacency matrices\" and \"adjacency lists\". The following uses undirected graphs as examples.</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#1-adjacency-matrix","level":3,"title":"1.   Adjacency Matrix","text":"<p>Given a graph with \\(n\\) vertices, an adjacency matrix uses an \\(n \\times n\\) matrix to represent the graph, where each row (column) represents a vertex, and matrix elements represent edges, using \\(1\\) or \\(0\\) to indicate whether an edge exists between two vertices.</p> <p>As shown in Figure 9-5, let the adjacency matrix be \\(M\\) and the vertex list be \\(V\\). Then matrix element \\(M[i, j] = 1\\) indicates that an edge exists between vertex \\(V[i]\\) and vertex \\(V[j]\\), whereas \\(M[i, j] = 0\\) indicates no edge between the two vertices.</p> <p></p> <p> Figure 9-5   Adjacency matrix representation of a graph </p> <p>Adjacency matrices have the following properties.</p> <ul> <li>In simple graphs, vertices cannot connect to themselves, so the elements on the main diagonal of the adjacency matrix are meaningless.</li> <li>For undirected graphs, edges in both directions are equivalent, so the adjacency matrix is symmetric about the main diagonal.</li> <li>Replacing the elements of the adjacency matrix from \\(1\\) and \\(0\\) to weights allows representation of weighted graphs.</li> </ul> <p>When using adjacency matrices to represent graphs, we can directly access matrix elements to obtain edges, resulting in highly efficient addition, deletion, lookup, and modification operations, all with a time complexity of \\(O(1)\\). However, the space complexity of the matrix is \\(O(n^2)\\), which consumes significant memory.</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#2-adjacency-list","level":3,"title":"2.   Adjacency List","text":"<p>An adjacency list uses \\(n\\) linked lists to represent a graph, with linked list nodes representing vertices. The \\(i\\)-th linked list corresponds to vertex \\(i\\) and stores all adjacent vertices of that vertex (vertices connected to that vertex). Figure 9-6 shows an example of a graph stored using an adjacency list.</p> <p></p> <p> Figure 9-6   Adjacency list representation of a graph </p> <p>Adjacency lists only store edges that actually exist, and the total number of edges is typically much less than \\(n^2\\), making them more space-efficient. However, finding edges in an adjacency list requires traversing the linked list, so its time efficiency is inferior to that of adjacency matrices.</p> <p>Observing Figure 9-6, the structure of adjacency lists is very similar to \"chaining\" in hash tables, so we can adopt similar methods to optimize efficiency. For example, when linked lists are long, they can be converted to AVL trees or red-black trees, thereby optimizing time efficiency from \\(O(n)\\) to \\(O(\\log n)\\); linked lists can also be converted to hash tables, thereby reducing time complexity to \\(O(1)\\).</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#913-common-applications-of-graphs","level":2,"title":"9.1.3   Common Applications of Graphs","text":"<p>As shown in Table 9-1, many real-world systems can be modeled using graphs, and corresponding problems can be reduced to graph computation problems.</p> <p> Table 9-1   Common graphs in real life </p> Vertices Edges Graph Computation Problem Social network Users Friend relationships Potential friend recommendation Subway lines Stations Connectivity between stations Shortest route recommendation Solar system Celestial bodies Gravitational forces between celestial bodies Planetary orbit calculation","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   Basic Operations on Graphs","text":"<p>Basic operations on graphs can be divided into operations on \"edges\" and operations on \"vertices\". Under the two representation methods of \"adjacency matrix\" and \"adjacency list\", the implementation methods differ.</p>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#921-implementation-based-on-adjacency-matrix","level":2,"title":"9.2.1   Implementation Based on Adjacency Matrix","text":"<p>Given an undirected graph with \\(n\\) vertices, the various operations are implemented as shown in Figure 9-7.</p> <ul> <li>Adding or removing an edge: Directly modify the specified edge in the adjacency matrix, using \\(O(1)\\) time. Since it is an undirected graph, both directions of the edge need to be updated simultaneously.</li> <li>Adding a vertex: Add a row and a column at the end of the adjacency matrix and fill them all with \\(0\\)s, using \\(O(n)\\) time.</li> <li>Removing a vertex: Delete a row and a column in the adjacency matrix. The worst case occurs when removing the first row and column, requiring \\((n-1)^2\\) elements to be \"moved up and to the left\", thus using \\(O(n^2)\\) time.</li> <li>Initialization: Pass in \\(n\\) vertices, initialize a vertex list <code>vertices</code> of length \\(n\\), using \\(O(n)\\) time; initialize an adjacency matrix <code>adjMat</code> of size \\(n \\times n\\), using \\(O(n^2)\\) time.</li> </ul> Initialize adjacency matrixAdd an edgeRemove an edgeAdd a vertexRemove a vertex <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-7   Initialization, adding and removing edges, adding and removing vertices in adjacency matrix </p> <p>The following is the implementation code for graphs represented using an adjacency matrix:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"Undirected graph class based on adjacency matrix\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"Constructor\"\"\"\n        # Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n        self.vertices: list[int] = []\n        # Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n        self.adj_mat: list[list[int]] = []\n        # Add vertices\n        for val in vertices:\n            self.add_vertex(val)\n        # Add edges\n        # Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Get the number of vertices\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"Add vertex\"\"\"\n        n = self.size()\n        # Add the value of the new vertex to the vertex list\n        self.vertices.append(val)\n        # Add a row to the adjacency matrix\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # Add a column to the adjacency matrix\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"Remove vertex\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # Remove the vertex at index from the vertex list\n        self.vertices.pop(index)\n        # Remove the row at index from the adjacency matrix\n        self.adj_mat.pop(index)\n        # Remove the column at index from the adjacency matrix\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"Add edge\"\"\"\n        # Parameters i, j correspond to the vertices element indices\n        # Handle index out of bounds and equality\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"Remove edge\"\"\"\n        # Parameters i, j correspond to the vertices element indices\n        # Handle index out of bounds and equality\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"Print adjacency matrix\"\"\"\n        print(\"Vertex list =\", self.vertices)\n        print(\"Adjacency matrix =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n  public:\n    /* Constructor */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // Add vertex\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* Add vertex */\n    void addVertex(int val) {\n        int n = size();\n        // Add the value of the new vertex to the vertex list\n        vertices.push_back(val);\n        // Add a row to the adjacency matrix\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // Add a column to the adjacency matrix\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* Remove vertex */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        // Remove the vertex at index from the vertex list\n        vertices.erase(vertices.begin() + index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.erase(adjMat.begin() + index);\n        // Remove the column at index from the adjacency matrix\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    void addEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    void removeEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    void print() {\n        cout &lt;&lt; \"Vertex list = \";\n        printVector(vertices);\n        cout &lt;&lt; \"Adjacency matrix =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // Add vertex\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* Add vertex */\n    public void addVertex(int val) {\n        int n = size();\n        // Add the value of the new vertex to the vertex list\n        vertices.add(val);\n        // Add a row to the adjacency matrix\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // Add a column to the adjacency matrix\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* Remove vertex */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // Remove the vertex at index from the vertex list\n        vertices.remove(index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.remove(index);\n        // Remove the column at index from the adjacency matrix\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void addEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void removeEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* Print adjacency matrix */\n    public void print() {\n        System.out.print(\"Vertex list = \");\n        System.out.println(vertices);\n        System.out.println(\"Adjacency matrix =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    List&lt;List&lt;int&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* Add vertex */\n    public void AddVertex(int val) {\n        int n = Size();\n        // Add the value of the new vertex to the vertex list\n        vertices.Add(val);\n        // Add a row to the adjacency matrix\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // Add a column to the adjacency matrix\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* Remove vertex */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // Remove the vertex at index from the vertex list\n        vertices.RemoveAt(index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.RemoveAt(index);\n        // Remove the column at index from the adjacency matrix\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void AddEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void RemoveEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    public void Print() {\n        Console.Write(\"Vertex list = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"Adjacency matrix =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* Undirected graph class based on adjacency matrix */\ntype graphAdjMat struct {\n    // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    vertices []int\n    // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    adjMat [][]int\n}\n\n/* Constructor */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // Add vertex\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // Initialize graph\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // Add edge\n    // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* Get the number of vertices */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* Add vertex */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // Add the value of the new vertex to the vertex list\n    g.vertices = append(g.vertices, val)\n    // Add a row to the adjacency matrix\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // Add a column to the adjacency matrix\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* Remove vertex */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // Remove the vertex at index from the vertex list\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // Remove the row at index from the adjacency matrix\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // Remove the column at index from the adjacency matrix\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* Add edge */\n// Parameters i, j correspond to the vertices element indices\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* Remove edge */\n// Parameters i, j correspond to the vertices element indices\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* Print adjacency matrix */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\tVertex list = %v\\n\", g.vertices)\n    fmt.Printf(\"\\tAdjacency matrix = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    private var vertices: [Int] // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    private var adjMat: [[Int]] // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // Add vertex\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* Add vertex */\n    func addVertex(val: Int) {\n        let n = size()\n        // Add the value of the new vertex to the vertex list\n        vertices.append(val)\n        // Add a row to the adjacency matrix\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // Add a column to the adjacency matrix\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* Remove vertex */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"Out of bounds\")\n        }\n        // Remove the vertex at index from the vertex list\n        vertices.remove(at: index)\n        // Remove the row at index from the adjacency matrix\n        adjMat.remove(at: index)\n        // Remove the column at index from the adjacency matrix\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    func addEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Out of bounds\")\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    func removeEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Out of bounds\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Print adjacency matrix */\n    func print() {\n        Swift.print(\"Vertex list = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"Adjacency matrix =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vertices; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* Add vertex */\n    addVertex(val) {\n        const n = this.size();\n        // Add the value of the new vertex to the vertex list\n        this.vertices.push(val);\n        // Add a row to the adjacency matrix\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Add a column to the adjacency matrix\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Remove the vertex at index from the vertex list\n        this.vertices.splice(index, 1);\n\n        // Remove the row at index from the adjacency matrix\n        this.adjMat.splice(index, 1);\n        // Remove the column at index from the adjacency matrix\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    addEdge(i, j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // In undirected graph, adjacency matrix is symmetric about main diagonal, i.e., satisfies (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    removeEdge(i, j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    print() {\n        console.log('Vertex list = ', this.vertices);\n        console.log('Adjacency matrix =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vertices: number[]; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    adjMat: number[][]; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* Add vertex */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // Add the value of the new vertex to the vertex list\n        this.vertices.push(val);\n        // Add a row to the adjacency matrix\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Add a column to the adjacency matrix\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Remove the vertex at index from the vertex list\n        this.vertices.splice(index, 1);\n\n        // Remove the row at index from the adjacency matrix\n        this.adjMat.splice(index, 1);\n        // Remove the column at index from the adjacency matrix\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    addEdge(i: number, j: number): void {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // In undirected graph, adjacency matrix is symmetric about main diagonal, i.e., satisfies (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    removeEdge(i: number, j: number): void {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    print(): void {\n        console.log('Vertex list = ', this.vertices);\n        console.log('Adjacency matrix =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // Vertex elements, elements represent \"vertex values\", indices represent \"vertex indices\"\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n  /* Constructor */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // Add vertex\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // Add edge\n    // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* Get the number of vertices */\n  int size() {\n    return vertices.length;\n  }\n\n  /* Add vertex */\n  void addVertex(int val) {\n    int n = size();\n    // Add the value of the new vertex to the vertex list\n    vertices.add(val);\n    // Add a row to the adjacency matrix\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // Add a column to the adjacency matrix\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* Remove vertex */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // Remove the vertex at index from the vertex list\n    vertices.removeAt(index);\n    // Remove the row at index from the adjacency matrix\n    adjMat.removeAt(index);\n    // Remove the column at index from the adjacency matrix\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* Add edge */\n  // Parameters i, j correspond to the vertices element indices\n  void addEdge(int i, int j) {\n    // Handle index out of bounds and equality\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* Remove edge */\n  // Parameters i, j correspond to the vertices element indices\n  void removeEdge(int i, int j) {\n    // Handle index out of bounds and equality\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* Print adjacency matrix */\n  void printAdjMat() {\n    print(\"Vertex list = $vertices\");\n    print(\"Adjacency matrix = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* Undirected graph type based on adjacency matrix */\npub struct GraphAdjMat {\n    // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    pub vertices: Vec&lt;i32&gt;,\n    // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* Constructor */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // Add vertex\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* Get the number of vertices */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* Add vertex */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // Add the value of the new vertex to the vertex list\n        self.vertices.push(val);\n        // Add a row to the adjacency matrix\n        self.adj_mat.push(vec![0; n]);\n        // Add a column to the adjacency matrix\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // Remove the vertex at index from the vertex list\n        self.vertices.remove(index);\n        // Remove the row at index from the adjacency matrix\n        self.adj_mat.remove(index);\n        // Remove the column at index from the adjacency matrix\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* Add edge */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // Parameters i, j correspond to the vertices element indices\n        // Handle index out of bounds and equality\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // Parameters i, j correspond to the vertices element indices\n        // Handle index out of bounds and equality\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    pub fn print(&amp;self) {\n        println!(\"Vertex list = {:?}\", self.vertices);\n        println!(\"Adjacency matrix =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* Undirected graph structure based on adjacency matrix */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* Constructor */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* Destructor */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* Add vertex */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"Graph vertex count has reached maximum\\n\");\n        return;\n    }\n    // Add nth vertex and zero nth row and column\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* Remove vertex */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"Vertex index out of bounds\\n\");\n        return;\n    }\n    // Remove the vertex at index from the vertex list\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // Remove the row at index from the adjacency matrix\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // Remove the column at index from the adjacency matrix\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* Add edge */\n// Parameters i, j correspond to the vertices element indices\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"Edge index out of bounds or equal\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* Remove edge */\n// Parameters i, j correspond to the vertices element indices\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"Edge index out of bounds or equal\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* Print adjacency matrix */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"Vertex list = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"Adjacency matrix =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    init {\n        // Add vertex\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* Add vertex */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // Add the value of the new vertex to the vertex list\n        vertices.add(_val)\n        // Add a row to the adjacency matrix\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // Add a column to the adjacency matrix\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* Remove vertex */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // Remove the vertex at index from the vertex list\n        vertices.removeAt(index)\n        // Remove the row at index from the adjacency matrix\n        adjMat.removeAt(index)\n        // Remove the column at index from the adjacency matrix\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    fun addEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    fun removeEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Print adjacency matrix */\n    fun print() {\n        print(\"Vertex list = \")\n        println(vertices)\n        println(\"Adjacency matrix =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### Undirected graph class based on adjacency matrix ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### Constructor ###\n    # Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    @vertices = []\n    # Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    @adj_mat = []\n    # Add vertex\n    vertices.each { |val| add_vertex(val) }\n    # Add edge\n    # Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### Get number of vertices ###\n  def size\n    @vertices.length\n  end\n\n  ### Add vertex ###\n  def add_vertex(val)\n    n = size\n    # Add the value of the new vertex to the vertex list\n    @vertices &lt;&lt; val\n    # Add a row to the adjacency matrix\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # Add a column to the adjacency matrix\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### Delete vertex ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # Remove the vertex at index from the vertex list\n    @vertices.delete_at(index)\n    # Remove the row at index from the adjacency matrix\n    @adj_mat.delete_at(index)\n    # Remove the column at index from the adjacency matrix\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### Add edge ###\n  def add_edge(i, j)\n    # Parameters i, j correspond to the vertices element indices\n    # Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### Delete edge ###\n  def remove_edge(i, j)\n    # Parameters i, j correspond to the vertices element indices\n    # Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### Print adjacency matrix ###\n  def __print__\n    puts \"Vertex list = #{@vertices}\"\n    puts 'Adjacency matrix ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#922-implementation-based-on-adjacency-list","level":2,"title":"9.2.2   Implementation Based on Adjacency List","text":"<p>Given an undirected graph with a total of \\(n\\) vertices and \\(m\\) edges, the various operations can be implemented as shown in Figure 9-8.</p> <ul> <li>Adding an edge: Add the edge at the end of the corresponding vertex's linked list, using \\(O(1)\\) time. Since it is an undirected graph, edges in both directions need to be added simultaneously.</li> <li>Removing an edge: Find and remove the specified edge in the corresponding vertex's linked list, using \\(O(m)\\) time. In an undirected graph, edges in both directions need to be removed simultaneously.</li> <li>Adding a vertex: Add a linked list in the adjacency list and set the new vertex as the head node of the list, using \\(O(1)\\) time.</li> <li>Removing a vertex: Traverse the entire adjacency list and remove all edges containing the specified vertex, using \\(O(n + m)\\) time.</li> <li>Initialization: Create \\(n\\) vertices and \\(2m\\) edges in the adjacency list, using \\(O(n + m)\\) time.</li> </ul> Initialize adjacency listAdd an edgeRemove an edgeAdd a vertexRemove a vertex <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-8   Initialization, adding and removing edges, adding and removing vertices in adjacency list </p> <p>The following is the adjacency list code implementation. Compared to Figure 9-8, the actual code has the following differences.</p> <ul> <li>For convenience in adding and removing vertices, and to simplify the code, we use lists (dynamic arrays) instead of linked lists.</li> <li>A hash table is used to store the adjacency list, where <code>key</code> is the vertex instance and <code>value</code> is the list (linked list) of adjacent vertices for that vertex.</li> </ul> <p>Additionally, we use the <code>Vertex</code> class to represent vertices in the adjacency list. The reason for this is: if we used list indices to distinguish different vertices as with adjacency matrices, then to delete the vertex at index \\(i\\), we would need to traverse the entire adjacency list and decrement all indices greater than \\(i\\) by \\(1\\), which is very inefficient. However, if each vertex is a unique <code>Vertex</code> instance, deleting a vertex does not require modifying other vertices.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"Undirected graph class based on adjacency list\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"Constructor\"\"\"\n        # Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # Add all vertices and edges\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Get the number of vertices\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Add edge\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Add edge vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Remove edge\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Remove edge vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"Add vertex\"\"\"\n        if vet in self.adj_list:\n            return\n        # Add a new linked list in the adjacency list\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"Remove vertex\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # Remove the linked list corresponding to vertex vet in the adjacency list\n        self.adj_list.pop(vet)\n        # Traverse the linked lists of other vertices and remove all edges containing vet\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"Print adjacency list\"\"\"\n        print(\"Adjacency list =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n  public:\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* Remove specified node from vector */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* Constructor */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // Add all vertices and edges\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int size() {\n        return adjList.size();\n    }\n\n    /* Add edge */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"Vertex does not exist\");\n        // Add edge vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* Remove edge */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"Vertex does not exist\");\n        // Remove edge vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* Add vertex */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* Remove vertex */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"Vertex does not exist\");\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.erase(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* Print adjacency list */\n    void print() {\n        cout &lt;&lt; \"Adjacency list =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Constructor */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // Add all vertices and edges\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* Add edge */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Add edge vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* Remove edge */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Remove edge vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* Add vertex */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* Remove vertex */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.remove(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* Print adjacency list */\n    public void print() {\n        System.out.println(\"Adjacency list =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Constructor */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // Add all vertices and edges\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* Add edge */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Add edge vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* Remove edge */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Remove edge vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* Add vertex */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList.Add(vet, []);\n    }\n\n    /* Remove vertex */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.Remove(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* Print adjacency list */\n    public void Print() {\n        Console.WriteLine(\"Adjacency list =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* Undirected graph class based on adjacency list */\ntype graphAdjList struct {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList map[Vertex][]Vertex\n}\n\n/* Constructor */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // Add all vertices and edges\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* Get the number of vertices */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* Add edge */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Add edge vet1 - vet2, add anonymous struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* Remove edge */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Remove edge vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* Add vertex */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // Add a new linked list in the adjacency list\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* Remove vertex */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    delete(g.adjList, vet)\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* Print adjacency list */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"Adjacency list = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* Constructor */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // Add all vertices and edges\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* Add edge */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Invalid parameter\")\n        }\n        // Add edge vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* Remove edge */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Invalid parameter\")\n        }\n        // Remove edge vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* Add vertex */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // Add a new linked list in the adjacency list\n        adjList[vet] = []\n    }\n\n    /* Remove vertex */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"Invalid parameter\")\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.removeValue(forKey: vet)\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* Print adjacency list */\n    public func print() {\n        Swift.print(\"Adjacency list =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList;\n\n    /* Constructor */\n    constructor(edges) {\n        this.adjList = new Map();\n        // Add all vertices and edges\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* Add edge */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Add edge vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Remove edge */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove edge vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Add vertex */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // Add a new linked list in the adjacency list\n        this.adjList.set(vet, []);\n    }\n\n    /* Remove vertex */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        this.adjList.delete(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Print adjacency list */\n    print() {\n        console.log('Adjacency list =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* Constructor */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // Add all vertices and edges\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* Add edge */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Add edge vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Remove edge */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove edge vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Add vertex */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // Add a new linked list in the adjacency list\n        this.adjList.set(vet, []);\n    }\n\n    /* Remove vertex */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        this.adjList.delete(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Print adjacency list */\n    print(): void {\n        console.log('Adjacency list =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n  // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* Constructor */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* Get the number of vertices */\n  int size() {\n    return adjList.length;\n  }\n\n  /* Add edge */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Add edge vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* Remove edge */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Remove edge vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* Add vertex */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // Add a new linked list in the adjacency list\n    adjList[vet] = [];\n  }\n\n  /* Remove vertex */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    adjList.remove(vet);\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* Print adjacency list */\n  void printAdjList() {\n    print(\"Adjacency list =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* Undirected graph type based on adjacency list */\npub struct GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* Constructor */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // Add all vertices and edges\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* Get the number of vertices */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* Add edge */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Add edge vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* Remove edge */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Remove edge vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* Add vertex */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // Add a new linked list in the adjacency list\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* Remove vertex */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        self.adj_list.remove(&amp;vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* Print adjacency list */\n    pub fn print(&amp;self) {\n        println!(\"Adjacency list =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* Node structure */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // Vertex\n    struct AdjListNode *next; // Successor node\n} AdjListNode;\n\n/* Find node corresponding to vertex */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Add edge helper function */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // Head insertion\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* Remove edge helper function */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // Search for node corresponding to vet in list\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // Remove node corresponding to vet from list\n    pre-&gt;next = cur-&gt;next;\n    // Free memory\n    free(cur);\n}\n\n/* Undirected graph class based on adjacency list */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // Node array\n    int size;                     // Node count\n} GraphAdjList;\n\n/* Constructor */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* Destructor */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* Find node corresponding to vertex */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Add edge */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // Add edge vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* Remove edge */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // Remove edge vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* Add vertex */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // Add a new linked list in the adjacency list\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* Remove vertex */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // Move vertices after this vertex forward to fill gap\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* Constructor */\n    init {\n        // Add all vertices and edges\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* Get the number of vertices */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* Add edge */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Add edge vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* Remove edge */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Remove edge vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* Add vertex */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // Add a new linked list in the adjacency list\n        adjList[vet] = mutableListOf()\n    }\n\n    /* Remove vertex */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.remove(vet)\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* Print adjacency list */\n    fun print() {\n        println(\"Adjacency list =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### Undirected graph class based on adjacency list ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### Constructor ###\n  def initialize(edges)\n    # Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    @adj_list = {}\n    # Add all vertices and edges\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### Get number of vertices ###\n  def size\n    @adj_list.length\n  end\n\n  ### Add edge ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### Delete edge ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # Remove edge vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### Add vertex ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # Add a new linked list in the adjacency list\n    @adj_list[vet] = []\n  end\n\n  ### Delete vertex ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # Remove the linked list corresponding to vertex vet in the adjacency list\n    @adj_list.delete(vet)\n    # Traverse the linked lists of other vertices and remove all edges containing vet\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### Print adjacency list ###\n  def __print__\n    puts 'Adjacency list ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#923-efficiency-comparison","level":2,"title":"9.2.3   Efficiency Comparison","text":"<p>Assuming the graph has \\(n\\) vertices and \\(m\\) edges, Table 9-2 compares the time efficiency and space efficiency of adjacency matrices and adjacency lists. Note that the adjacency list (linked list) corresponds to the implementation in this text, while the adjacency list (hash table) refers specifically to the implementation where all linked lists are replaced with hash tables.</p> <p> Table 9-2   Comparison of adjacency matrix and adjacency list </p> Adjacency matrix Adjacency list (linked list) Adjacency list (hash table) Determine adjacency \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Add an edge \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Remove an edge \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Add a vertex \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) Remove a vertex \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) Memory space usage \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>Observing Table 9-2, it appears that the adjacency list (hash table) has the best time efficiency and space efficiency. However, in practice, operating on edges in the adjacency matrix is more efficient, requiring only a single array access or assignment operation. Overall, adjacency matrices embody the principle of \"trading space for time\", while adjacency lists embody \"trading time for space\".</p>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   Graph Traversal","text":"<p>Trees represent \"one-to-many\" relationships, while graphs have a higher degree of freedom and can represent any \"many-to-many\" relationships. Therefore, we can view trees as a special case of graphs. Clearly, tree traversal operations are also a special case of graph traversal operations.</p> <p>Both graphs and trees require the application of search algorithms to implement traversal operations. Graph traversal methods can also be divided into two types: breadth-first traversal and depth-first traversal.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931-breadth-first-search","level":2,"title":"9.3.1   Breadth-First Search","text":"<p>Breadth-first search is a near-to-far traversal method that, starting from a certain node, always prioritizes visiting the nearest vertices and expands outward layer by layer. As shown in Figure 9-9, starting from the top-left vertex, first traverse all adjacent vertices of that vertex, then traverse all adjacent vertices of the next vertex, and so on, until all vertices have been visited.</p> <p></p> <p> Figure 9-9   Breadth-first search of a graph </p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation","level":3,"title":"1.   Algorithm Implementation","text":"<p>BFS is typically implemented with the help of a queue, as shown in the code below. The queue has a \"first in, first out\" property, which aligns with the BFS idea of \"near to far\".</p> <ol> <li>Add the starting vertex <code>startVet</code> to the queue and begin the loop.</li> <li>In each iteration of the loop, pop the vertex at the front of the queue and record it as visited, then add all adjacent vertices of that vertex to the back of the queue.</li> <li>Repeat step <code>2.</code> until all vertices have been visited.</li> </ol> <p>To prevent revisiting vertices, we use a hash set <code>visited</code> to record which nodes have been visited.</p> <p>Tip</p> <p>A hash set can be viewed as a hash table that stores only <code>key</code> without storing <code>value</code>. It can perform addition, deletion, lookup, and modification operations on <code>key</code> in \\(O(1)\\) time complexity. Based on the uniqueness of <code>key</code>, hash sets are typically used for data deduplication and similar scenarios.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Breadth-first traversal\"\"\"\n    # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n    # Vertex traversal sequence\n    res = []\n    # Hash set for recording vertices that have been visited\n    visited = set[Vertex]([start_vet])\n    # Queue used to implement BFS\n    que = deque[Vertex]([start_vet])\n    # Starting from vertex vet, loop until all vertices are visited\n    while len(que) &gt; 0:\n        vet = que.popleft()  # Dequeue the front vertex\n        res.append(vet)  # Record visited vertex\n        # Traverse all adjacent vertices of this vertex\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # Skip vertices that have been visited\n            que.append(adj_vet)  # Only enqueue unvisited vertices\n            visited.add(adj_vet)  # Mark this vertex as visited\n    # Return vertex traversal sequence\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Vertex traversal sequence\n    vector&lt;Vertex *&gt; res;\n    // Hash set for recording vertices that have been visited\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // Queue used to implement BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // Dequeue the front vertex\n        res.push_back(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // Skip vertices that have been visited\n            que.push(adjVet);        // Only enqueue unvisited vertices\n            visited.emplace(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Hash set for recording vertices that have been visited\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // Dequeue the front vertex\n        res.add(vet);            // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // Skip vertices that have been visited\n            que.offer(adjVet);   // Only enqueue unvisited vertices\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = [];\n    // Hash set for recording vertices that have been visited\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // Queue used to implement BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // Dequeue the front vertex\n        res.Add(vet);               // Record visited vertex\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // Skip vertices that have been visited\n            }\n            que.Enqueue(adjVet);   // Only enqueue unvisited vertices\n            visited.Add(adjVet);   // Mark this vertex as visited\n        }\n    }\n\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Vertex traversal sequence\n    res := make([]Vertex, 0)\n    // Hash set for recording vertices that have been visited\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // Queue used to implement BFS, using slice to simulate queue\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // Starting from vertex vet, loop until all vertices are visited\n    for len(queue) &gt; 0 {\n        // Dequeue the front vertex\n        vet := queue[0]\n        queue = queue[1:]\n        // Record visited vertex\n        res = append(res, vet)\n        // Traverse all adjacent vertices of this vertex\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // Only enqueue unvisited vertices\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Vertex traversal sequence\n    var res: [Vertex] = []\n    // Hash set for recording vertices that have been visited\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // Queue used to implement BFS\n    var que: [Vertex] = [startVet]\n    // Starting from vertex vet, loop until all vertices are visited\n    while !que.isEmpty {\n        let vet = que.removeFirst() // Dequeue the front vertex\n        res.append(vet) // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // Skip vertices that have been visited\n            }\n            que.append(adjVet) // Only enqueue unvisited vertices\n            visited.insert(adjVet) // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphBFS(graph, startVet) {\n    // Vertex traversal sequence\n    const res = [];\n    // Hash set for recording vertices that have been visited\n    const visited = new Set();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    const que = [startVet];\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.length) {\n        const vet = que.shift(); // Dequeue the front vertex\n        res.push(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Skip vertices that have been visited\n            }\n            que.push(adjVet); // Only enqueue unvisited vertices\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Vertex traversal sequence\n    const res: Vertex[] = [];\n    // Hash set for recording vertices that have been visited\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    const que = [startVet];\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.length) {\n        const vet = que.shift(); // Dequeue the front vertex\n        res.push(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Skip vertices that have been visited\n            }\n            que.push(adjVet); // Only enqueue unvisited\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* Breadth-first traversal */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  // Vertex traversal sequence\n  List&lt;Vertex&gt; res = [];\n  // Hash set for recording vertices that have been visited\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // Queue used to implement BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // Starting from vertex vet, loop until all vertices are visited\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // Dequeue the front vertex\n    res.add(vet); // Record visited vertex\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // Skip vertices that have been visited\n      }\n      que.add(adjVet); // Only enqueue unvisited vertices\n      visited.add(adjVet); // Mark this vertex as visited\n    }\n  }\n  // Return vertex traversal sequence\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Vertex traversal sequence\n    let mut res = vec![];\n    // Hash set for recording vertices that have been visited\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // Queue used to implement BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // Record visited vertex\n\n        // Traverse all adjacent vertices of this vertex\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // Skip vertices that have been visited\n                }\n                que.push_back(adj_vet); // Only enqueue unvisited vertices\n                visited.insert(adj_vet); // Mark this vertex as visited\n            }\n        }\n    }\n    // Return vertex traversal sequence\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* Node queue structure */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* Constructor */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* Check if the queue is empty */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* Enqueue operation */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* Dequeue operation */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* Check if vertex has been visited */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // Traverse to find node using O(n) time\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // Queue used to implement BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // Dequeue the front vertex\n        res[(*resSize)++] = vet;      // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // Skip vertices that have been visited\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // Only enqueue unvisited vertices\n                visited[(*visitedSize)++] = node-&gt;vertex; // Mark this vertex as visited\n            }\n            node = node-&gt;next;\n        }\n    }\n    // Free memory\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // Vertex traversal sequence\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Hash set for recording vertices that have been visited\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // Queue used to implement BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.isEmpty()) {\n        val vet = que.poll() // Dequeue the front vertex\n        res.add(vet)         // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // Skip vertices that have been visited\n            que.offer(adjVet)   // Only enqueue unvisited vertices\n            visited.add(adjVet) // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### Breadth-first traversal ###\ndef graph_bfs(graph, start_vet)\n  # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  # Vertex traversal sequence\n  res = []\n  # Hash set for recording vertices that have been visited\n  visited = Set.new([start_vet])\n  # Queue used to implement BFS\n  que = [start_vet]\n  # Starting from vertex vet, loop until all vertices are visited\n  while que.length &gt; 0\n    vet = que.shift # Dequeue the front vertex\n    res &lt;&lt; vet # Record visited vertex\n    # Traverse all adjacent vertices of this vertex\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # Skip vertices that have been visited\n      que &lt;&lt; adj_vet # Only enqueue unvisited vertices\n      visited.add(adj_vet) # Mark this vertex as visited\n    end\n  end\n  # Return vertex traversal sequence\n  res\nend\n</code></pre> <p>The code is relatively abstract; it is recommended to refer to Figure 9-10 to deepen understanding.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-10   Steps of breadth-first search of a graph </p> <p>Is the breadth-first traversal sequence unique?</p> <p>Not unique. Breadth-first search only requires traversing in a \"near to far\" order, and the traversal order of vertices at the same distance can be arbitrarily shuffled. Taking Figure 9-10 as an example, the visit order of vertices \\(1\\) and \\(3\\) can be swapped, as can the visit order of vertices \\(2\\), \\(4\\), and \\(6\\).</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis","level":3,"title":"2.   Complexity Analysis","text":"<p>Time complexity: All vertices will be enqueued and dequeued once, using \\(O(|V|)\\) time; in the process of traversing adjacent vertices, since it is an undirected graph, all edges will be visited \\(2\\) times, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.</p> <p>Space complexity: The list <code>res</code>, hash set <code>visited</code>, and queue <code>que</code> can contain at most \\(|V|\\) vertices, using \\(O(|V|)\\) space.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932-depth-first-search","level":2,"title":"9.3.2   Depth-First Search","text":"<p>Depth-first search is a traversal method that prioritizes going as far as possible, then backtracks when no path remains. As shown in Figure 9-11, starting from the top-left vertex, visit an adjacent vertex of the current vertex, continuing until reaching a dead end, then return and continue going as far as possible before returning again, and so on, until all vertices have been traversed.</p> <p></p> <p> Figure 9-11   Depth-first search of a graph </p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation_1","level":3,"title":"1.   Algorithm Implementation","text":"<p>This \"go as far as possible then return\" algorithm paradigm is typically implemented using recursion. Similar to breadth-first search, in depth-first search we also need a hash set <code>visited</code> to record visited vertices and avoid revisiting.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"Depth-first traversal helper function\"\"\"\n    res.append(vet)  # Record visited vertex\n    visited.add(vet)  # Mark this vertex as visited\n    # Traverse all adjacent vertices of this vertex\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # Skip vertices that have been visited\n        # Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Depth-first traversal\"\"\"\n    # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n    # Vertex traversal sequence\n    res = []\n    # Hash set for recording vertices that have been visited\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // Record visited vertex\n    visited.emplace(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Vertex traversal sequence\n    vector&lt;Vertex *&gt; res;\n    // Hash set for recording vertices that have been visited\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Hash set for recording vertices that have been visited\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* Depth-first traversal helper function */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // Record visited vertex\n    visited.Add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = [];\n    // Hash set for recording vertices that have been visited\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* Depth-first traversal helper function */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append operation returns a new reference, must reassign original reference to new slice's reference\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // Traverse all adjacent vertices of this vertex\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // Recursively visit adjacent vertices\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Vertex traversal sequence\n    res := make([]Vertex, 0)\n    // Hash set for recording vertices that have been visited\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* Depth-first traversal helper function */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // Record visited vertex\n    visited.insert(vet) // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Vertex traversal sequence\n    var res: [Vertex] = []\n    // Hash set for recording vertices that have been visited\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphDFS(graph, startVet) {\n    // Vertex traversal sequence\n    const res = [];\n    // Hash set for recording vertices that have been visited\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* Depth-first traversal helper function */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Vertex traversal sequence\n    const res: Vertex[] = [];\n    // Hash set for recording vertices that have been visited\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* Depth-first traversal helper function */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // Record visited vertex\n  visited.add(vet); // Mark this vertex as visited\n  // Traverse all adjacent vertices of this vertex\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // Skip vertices that have been visited\n    }\n    // Recursively visit adjacent vertices\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* Depth-first traversal */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // Vertex traversal sequence\n  List&lt;Vertex&gt; res = [];\n  // Hash set for recording vertices that have been visited\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* Depth-first traversal helper function */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // Record visited vertex\n    visited.insert(vet); // Mark this vertex as visited\n                         // Traverse all adjacent vertices of this vertex\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // Skip vertices that have been visited\n            }\n            // Recursively visit adjacent vertices\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Vertex traversal sequence\n    let mut res = vec![];\n    // Hash set for recording vertices that have been visited\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* Check if vertex has been visited */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // Traverse to find node using O(n) time\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // Record visited vertex\n    res[(*resSize)++] = vet;\n    // Traverse all adjacent vertices of this vertex\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // Skip vertices that have been visited\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // Recursively visit adjacent vertices\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* Depth-first traversal helper function */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // Record visited vertex\n    visited.add(vet) // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // Vertex traversal sequence\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Hash set for recording vertices that have been visited\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### Depth-first traversal helper function ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # Record visited vertex\n  visited.add(vet) # Mark this vertex as visited\n  # Traverse all adjacent vertices of this vertex\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # Skip vertices that have been visited\n    # Recursively visit adjacent vertices\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### Depth-first traversal ###\ndef graph_dfs(graph, start_vet)\n  # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  # Vertex traversal sequence\n  res = []\n  # Hash set for recording vertices that have been visited\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> <p>The algorithm flow of depth-first search is shown in Figure 9-12.</p> <ul> <li>Straight dashed lines represent downward recursion, indicating that a new recursive method has been initiated to visit a new vertex.</li> <li>Curved dashed lines represent upward backtracking, indicating that this recursive method has returned to the position where it was initiated.</li> </ul> <p>To deepen understanding, it is recommended to combine Figure 9-12 with the code to mentally simulate (or draw out) the entire DFS process, including when each recursive method is initiated and when it returns.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-12   Steps of depth-first search of a graph </p> <p>Is the depth-first traversal sequence unique?</p> <p>Similar to breadth-first search, the order of depth-first traversal sequences is also not unique. Given a certain vertex, exploring in any direction first is valid, meaning the order of adjacent vertices can be arbitrarily shuffled, all being depth-first search.</p> <p>Taking tree traversal as an example, \"root \\(\\rightarrow\\) left \\(\\rightarrow\\) right\", \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\", and \"left \\(\\rightarrow\\) right \\(\\rightarrow\\) root\" correspond to pre-order, in-order, and post-order traversals, respectively. They represent three different traversal priorities, yet all three belong to depth-first search.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis_1","level":3,"title":"2.   Complexity Analysis","text":"<p>Time complexity: All vertices will be visited \\(1\\) time, using \\(O(|V|)\\) time; all edges will be visited \\(2\\) times, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.</p> <p>Space complexity: The list <code>res</code> and hash set <code>visited</code> can contain at most \\(|V|\\) vertices, and the maximum recursion depth is \\(|V|\\), therefore using \\(O(|V|)\\) space.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   Summary","text":"","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_graph/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Graphs consist of vertices and edges and can be represented as a set of vertices and a set of edges.</li> <li>Compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.</li> <li>Directed graphs have edges with directionality, connected graphs have all vertices reachable from any vertex, and weighted graphs have edges that each contain a weight variable.</li> <li>Adjacency matrices use matrices to represent graphs, where each row (column) represents a vertex, and matrix elements represent edges, using \\(1\\) or \\(0\\) to indicate whether two vertices have an edge or not. Adjacency matrices are highly efficient for addition, deletion, lookup, and modification operations, but consume significant space.</li> <li>Adjacency lists use multiple linked lists to represent graphs, where the \\(i\\)-th linked list corresponds to vertex \\(i\\) and stores all adjacent vertices of that vertex. Adjacency lists are more space-efficient than adjacency matrices, but have lower time efficiency because they require traversing linked lists to find edges.</li> <li>When linked lists in adjacency lists become too long, they can be converted to red-black trees or hash tables, thereby improving lookup efficiency.</li> <li>From an algorithmic perspective, adjacency matrices embody \"trading space for time\", while adjacency lists embody \"trading time for space\".</li> <li>Graphs can be used to model various real-world systems, such as social networks and subway lines.</li> <li>Trees are a special case of graphs, and tree traversal is a special case of graph traversal.</li> <li>Breadth-first search of graphs is a near-to-far, layer-by-layer expansion search method, typically implemented using a queue.</li> <li>Depth-first search of graphs is a search method that prioritizes going as far as possible and backtracks when no path remains, commonly implemented using recursion.</li> </ul>","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is a path defined as a sequence of vertices or a sequence of edges?</p> <p>The definitions in different language versions of Wikipedia are inconsistent: the English version states \"a path is a sequence of edges\", while the Chinese version states \"a path is a sequence of vertices\". The following is the original English text: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>In this text, a path is viewed as a sequence of edges, not a sequence of vertices. This is because there may be multiple edges connecting two vertices, in which case each edge corresponds to a path.</p> <p>Q: In a disconnected graph, will there be unreachable vertices?</p> <p>In a disconnected graph, starting from a certain vertex, at least one vertex cannot be reached. Traversing a disconnected graph requires setting multiple starting points to traverse all connected components of the graph.</p> <p>Q: In an adjacency list, is there a requirement for the order of \"all vertices connected to that vertex\"?</p> <p>It can be in any order. However, in practical applications, it may be necessary to sort according to specified rules, such as the order in which vertices were added, or the order of vertex values, which helps quickly find vertices \"with certain extreme values\".</p>","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"Chapter 15.   Greedy","text":"<p>Abstract</p> <p>Sunflowers turn toward the sun, constantly pursuing the maximum potential for their own growth.</p> <p>Through rounds of simple choices, greedy strategies gradually lead to the best answer.</p>","path":["Chapter 15. Greedy","Chapter 15. &nbsp; Greedy"],"tags":[]},{"location":"chapter_greedy/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>15.1   Greedy Algorithm</li> <li>15.2   Fractional Knapsack Problem</li> <li>15.3   Maximum Capacity Problem</li> <li>15.4   Maximum Product Cutting Problem</li> <li>15.5   Summary</li> </ul>","path":["Chapter 15. Greedy","Chapter 15. &nbsp; Greedy"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   Fractional Knapsack Problem","text":"<p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can be selected only once, but a portion of an item can be selected, with the value calculated based on the proportion of weight selected, what is the maximum value of items in the knapsack under the limited capacity? An example is shown in Figure 15-3.</p> <p></p> <p> Figure 15-3   Example data for the fractional knapsack problem </p> <p>The fractional knapsack problem is very similar overall to the 0-1 knapsack problem, with states including the current item \\(i\\) and capacity \\(c\\), and the goal being to maximize value under the limited knapsack capacity.</p> <p>The difference is that this problem allows selecting only a portion of an item. As shown in Figure 15-4, we can arbitrarily split items and calculate the corresponding value based on the weight proportion.</p> <ol> <li>For item \\(i\\), its value per unit weight is \\(val[i-1] / wgt[i-1]\\), referred to as unit value.</li> <li>Suppose we put a portion of item \\(i\\) with weight \\(w\\) into the knapsack, then the value added to the knapsack is \\(w \\times val[i-1] / wgt[i-1]\\).</li> </ol> <p></p> <p> Figure 15-4   Value of items per unit weight </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>Maximizing the total value of items in the knapsack is essentially maximizing the value per unit weight of items. From this, we can derive the greedy strategy shown in Figure 15-5.</p> <ol> <li>Sort items by unit value from high to low.</li> <li>Iterate through all items, greedily selecting the item with the highest unit value in each round.</li> <li>If the remaining knapsack capacity is insufficient, use a portion of the current item to fill the knapsack.</li> </ol> <p></p> <p> Figure 15-5   Greedy strategy for the fractional knapsack problem </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>We created an <code>Item</code> class to facilitate sorting items by unit value. We loop to make greedy selections, breaking when the knapsack is full and returning the solution:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"Item\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # Item weight\n        self.v = v  # Item value\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Fractional knapsack: Greedy algorithm\"\"\"\n    # Create item list with two attributes: weight, value\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # Sort by unit value item.v / item.w from high to low\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # Loop for greedy selection\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v\n            cap -= item.w\n        else:\n            # If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap\n            # No remaining capacity, so break out of the loop\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* Item */\nclass Item {\n  public:\n    int w; // Item weight\n    int v; // Item value\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // Create item list with two attributes: weight, value\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // Sort by unit value item.v / item.w from high to low\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // Loop for greedy selection\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double)item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* Item */\nclass Item {\n    int w; // Item weight\n    int v; // Item value\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Create item list with two attributes: weight, value\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Sort by unit value item.v / item.w from high to low\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // Loop for greedy selection\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double) item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* Item */\nclass Item(int w, int v) {\n    public int w = w; // Item weight\n    public int v = v; // Item value\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Create item list with two attributes: weight, value\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Sort by unit value item.v / item.w from high to low\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // Loop for greedy selection\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double)item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* Item */\ntype Item struct {\n    w int // Item weight\n    v int // Item value\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // Create item list with two attributes: weight, value\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // Sort by unit value item.v / item.w from high to low\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // Loop for greedy selection\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* Item */\nclass Item {\n    var w: Int // Item weight\n    var v: Int // Item value\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // Create item list with two attributes: weight, value\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // Sort by unit value item.v / item.w from high to low\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // Loop for greedy selection\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* Item */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // Item weight\n        this.v = v; // Item value\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // Create item list with two attributes: weight, value\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Sort by unit value item.v / item.w from high to low\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Loop for greedy selection\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* Item */\nclass Item {\n    w: number; // Item weight\n    v: number; // Item value\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // Create item list with two attributes: weight, value\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Sort by unit value item.v / item.w from high to low\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Loop for greedy selection\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* Item */\nclass Item {\n  int w; // Item weight\n  int v; // Item value\n\n  Item(this.w, this.v);\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // Create item list with two attributes: weight, value\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // Sort by unit value item.v / item.w from high to low\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // Loop for greedy selection\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // If remaining capacity is sufficient, put the entire current item into the knapsack\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // If remaining capacity is insufficient, put part of the current item into the knapsack\n      res += item.v / item.w * cap;\n      // No remaining capacity, so break out of the loop\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* Item */\nstruct Item {\n    w: i32, // Item weight\n    v: i32, // Item value\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // Create item list with two attributes: weight, value\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // Sort by unit value item.v / item.w from high to low\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // Loop for greedy selection\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* Item */\ntypedef struct {\n    int w; // Item weight\n    int v; // Item value\n} Item;\n\n/* Fractional knapsack: Greedy algorithm */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // Create item list with two attributes: weight, value\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // Sort by unit value item.v / item.w from high to low\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // Loop for greedy selection\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* Item */\nclass Item(\n    val w: Int, // Item\n    val v: Int  // Item value\n)\n\n/* Fractional knapsack: Greedy algorithm */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // Create item list with two attributes: weight, value\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // Sort by unit value item.v / item.w from high to low\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // Loop for greedy selection\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += item.v.toDouble() / item.w * cap\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### Item ###\nclass Item\n  attr_accessor :w # Item weight\n  attr_accessor :v # Item value\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### Fractional knapsack: greedy ###\ndef fractional_knapsack(wgt, val, cap)\n  # Create item list with two attributes: weight, value\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # Sort by unit value item.v / item.w from high to low\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # Loop for greedy selection\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # If remaining capacity is sufficient, put the entire current item into the knapsack\n      res += item.v\n      cap -= item.w\n    else\n      # If remaining capacity is insufficient, put part of the current item into the knapsack\n      res += (item.v.to_f / item.w) * cap\n      # No remaining capacity, so break out of the loop\n      break\n    end\n  end\n  res\nend\n</code></pre> <p>The time complexity of built-in sorting algorithms is usually \\(O(\\log n)\\), and the space complexity is usually \\(O(\\log n)\\) or \\(O(n)\\), depending on the specific implementation of the programming language.</p> <p>Apart from sorting, in the worst case the entire item list needs to be traversed, therefore the time complexity is \\(O(n)\\), where \\(n\\) is the number of items.</p> <p>Since an <code>Item</code> object list is initialized, the space complexity is \\(O(n)\\).</p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>Using proof by contradiction. Suppose item \\(x\\) has the highest unit value, and some algorithm yields a maximum value of <code>res</code>, but this solution does not include item \\(x\\).</p> <p>Now remove a unit weight of any item from the knapsack and replace it with a unit weight of item \\(x\\). Since item \\(x\\) has the highest unit value, the total value after replacement will definitely be greater than <code>res</code>. This contradicts the assumption that <code>res</code> is the optimal solution, proving that the optimal solution must include item \\(x\\).</p> <p>For other items in this solution, we can also construct the above contradiction. In summary, items with greater unit value are always better choices, which proves that the greedy strategy is effective.</p> <p>As shown in Figure 15-6, if we view item weight and item unit value as the horizontal and vertical axes of a two-dimensional chart respectively, then the fractional knapsack problem can be transformed into \"finding the maximum area enclosed within a limited horizontal axis range\". This analogy can help us understand the effectiveness of the greedy strategy from a geometric perspective.</p> <p></p> <p> Figure 15-6   Geometric representation of the fractional knapsack problem </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   Greedy Algorithm","text":"<p>Greedy algorithm is a common algorithm for solving optimization problems. Its basic idea is to make the seemingly best choice at each decision stage of the problem, that is, to greedily make locally optimal decisions in hopes of obtaining a globally optimal solution. Greedy algorithms are simple and efficient, and are widely applied in many practical problems.</p> <p>Greedy algorithms and dynamic programming are both commonly used to solve optimization problems. They share some similarities, such as both relying on the optimal substructure property, but they work differently.</p> <ul> <li>Dynamic programming considers all previous decisions when making the current decision, and uses solutions to past subproblems to construct the solution to the current subproblem.</li> <li>Greedy algorithms do not consider past decisions, but instead make greedy choices moving forward, continually reducing the problem size until the problem is solved.</li> </ul> <p>We will first understand how greedy algorithms work through the example problem \"coin change\". This problem has already been introduced in the \"Complete Knapsack Problem\" chapter, so I believe you are not unfamiliar with it.</p> <p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\), with each type of coin available for repeated selection, what is the minimum number of coins needed to make up the target amount? If it is impossible to make up the target amount, return \\(-1\\).</p> <p>The greedy strategy adopted for this problem is shown in Figure 15-1. Given a target amount, we greedily select the coin that is not greater than and closest to it, and continuously repeat this step until the target amount is reached.</p> <p></p> <p> Figure 15-1   Greedy strategy for coin change </p> <p>The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Greedy algorithm\"\"\"\n    # Assume coins list is sorted\n    i = len(coins) - 1\n    count = 0\n    # Loop to make greedy choices until no remaining amount\n    while amt &gt; 0:\n        # Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # Choose coins[i]\n        amt -= coins[i]\n        count += 1\n    # If no feasible solution is found, return -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.size() - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(int[] coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.length - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* Coin change: Greedy algorithm */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.Length - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* Coin change: Greedy algorithm */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // Assume coins list is sorted\n    i := len(coins) - 1\n    count := 0\n    // Loop to make greedy choices until no remaining amount\n    for amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // Choose coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // If no feasible solution is found, return -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* Coin change: Greedy algorithm */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // Assume coins list is sorted\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // Loop to make greedy choices until no remaining amount\n    while amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // Choose coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* Coin change: Greedy algorithm */\nfunction coinChangeGreedy(coins, amt) {\n    // Assume coins array is sorted\n    let i = coins.length - 1;\n    let count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* Coin change: Greedy algorithm */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // Assume coins array is sorted\n    let i = coins.length - 1;\n    let count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // Assume coins list is sorted\n  int i = coins.length - 1;\n  int count = 0;\n  // Loop to make greedy choices until no remaining amount\n  while (amt &gt; 0) {\n    // Find the coin that is less than and closest to the remaining amount\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // Choose coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // If no feasible solution is found, return -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* Coin change: Greedy algorithm */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // Assume coins list is sorted\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // If no feasible solution is found, return -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // Assume coins list is sorted\n    int i = size - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* Coin change: Greedy algorithm */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // Assume coins list is sorted\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // Loop to make greedy choices until no remaining amount\n    while (am &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // Choose coins[i]\n        am -= coins[i]\n        count++\n    }\n    // If no feasible solution is found, return -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### Coin change: greedy ###\ndef coin_change_greedy(coins, amt)\n  # Assume coins list is sorted\n  i = coins.length - 1\n  count = 0\n  # Loop to make greedy choices until no remaining amount\n  while amt &gt; 0\n    # Find the coin that is less than and closest to the remaining amount\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # Choose coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # Return -1 if no solution found\n  amt == 0 ? count : -1\nend\n</code></pre> <p>You might exclaim: So clean! The greedy algorithm solves the coin change problem in about ten lines of code.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511-advantages-and-limitations-of-greedy-algorithms","level":2,"title":"15.1.1   Advantages and Limitations of Greedy Algorithms","text":"<p>Greedy algorithms are not only straightforward and simple to implement, but are also usually very efficient. In the code above, if the smallest coin denomination is \\(\\min(coins)\\), the greedy choice loops at most \\(amt / \\min(coins)\\) times, giving a time complexity of \\(O(amt / \\min(coins))\\). This is an order of magnitude smaller than the time complexity of the dynamic programming solution \\(O(n \\times amt)\\).</p> <p>However, for certain coin denomination combinations, greedy algorithms cannot find the optimal solution. Figure 15-2 provides two examples.</p> <ul> <li>Positive example \\(coins = [1, 5, 10, 20, 50, 100]\\): With this coin combination, given any \\(amt\\), the greedy algorithm can find the optimal solution.</li> <li>Negative example \\(coins = [1, 20, 50]\\): Suppose \\(amt = 60\\), the greedy algorithm can only find the combination \\(50 + 1 \\times 10\\), totaling \\(11\\) coins, but dynamic programming can find the optimal solution \\(20 + 20 + 20\\), requiring only \\(3\\) coins.</li> <li>Negative example \\(coins = [1, 49, 50]\\): Suppose \\(amt = 98\\), the greedy algorithm can only find the combination \\(50 + 1 \\times 48\\), totaling \\(49\\) coins, but dynamic programming can find the optimal solution \\(49 + 49\\), requiring only \\(2\\) coins.</li> </ul> <p></p> <p> Figure 15-2   Examples where greedy algorithms cannot find the optimal solution </p> <p>In other words, for the coin change problem, greedy algorithms cannot guarantee finding the global optimal solution, and may even find very poor solutions. It is better suited for solving with dynamic programming.</p> <p>Generally, the applicability of greedy algorithms falls into the following two situations.</p> <ol> <li>Can guarantee finding the optimal solution: In this situation, greedy algorithms are often the best choice, because they tend to be more efficient than backtracking and dynamic programming.</li> <li>Can find an approximate optimal solution: Greedy algorithms are also applicable in this situation. For many complex problems, finding the global optimal solution is very difficult, and being able to find a suboptimal solution with high efficiency is also very good.</li> </ol>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512-characteristics-of-greedy-algorithms","level":2,"title":"15.1.2   Characteristics of Greedy Algorithms","text":"<p>So the question arises: what kind of problems are suitable for solving with greedy algorithms? Or in other words, under what conditions can greedy algorithms guarantee finding the optimal solution?</p> <p>Compared to dynamic programming, the conditions for using greedy algorithms are stricter, mainly focusing on two properties of the problem.</p> <ul> <li>Greedy choice property: Only when locally optimal choices can always lead to a globally optimal solution can greedy algorithms guarantee obtaining the optimal solution.</li> <li>Optimal substructure: The optimal solution to the original problem contains the optimal solutions to subproblems.</li> </ul> <p>Optimal substructure has already been introduced in the \"Dynamic Programming\" chapter, so we won't elaborate on it here. It's worth noting that the optimal substructure of some problems is not obvious, but they can still be solved using greedy algorithms.</p> <p>We mainly explore methods for determining the greedy choice property. Although its description seems relatively simple, in practice, for many problems, proving the greedy choice property is not easy.</p> <p>For example, in the coin change problem, although we can easily provide counterexamples to disprove the greedy choice property, proving it is quite difficult. If asked: what conditions must a coin combination satisfy to be solvable using a greedy algorithm? We often can only rely on intuition or examples to give an ambiguous answer, and find it difficult to provide a rigorous mathematical proof.</p> <p>Quote</p> <p>There is a paper that presents an algorithm with \\(O(n^3)\\) time complexity for determining whether a coin combination can use a greedy algorithm to find the optimal solution for any amount.</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513-steps-for-solving-problems-with-greedy-algorithms","level":2,"title":"15.1.3   Steps for Solving Problems with Greedy Algorithms","text":"<p>The problem-solving process for greedy problems can generally be divided into the following three steps.</p> <ol> <li>Problem analysis: Sort out and understand the problem characteristics, including state definition, optimization objectives, and constraints, etc. This step is also involved in backtracking and dynamic programming.</li> <li>Determine the greedy strategy: Determine how to make greedy choices at each step. This strategy should be able to reduce the problem size at each step, ultimately solving the entire problem.</li> <li>Correctness proof: It is usually necessary to prove that the problem has both greedy choice property and optimal substructure. This step may require mathematical proofs, such as mathematical induction or proof by contradiction.</li> </ol> <p>Determining the greedy strategy is the core step in solving the problem, but it may not be easy to implement, mainly for the following reasons.</p> <ul> <li>Greedy strategies differ greatly between different problems. For many problems, the greedy strategy is relatively straightforward, and we can derive it through some general thinking and attempts. However, for some complex problems, the greedy strategy may be very elusive, which really tests one's problem-solving experience and algorithmic ability.</li> <li>Some greedy strategies are highly misleading. When we confidently design a greedy strategy, write the solution code and submit it for testing, we may find that some test cases cannot pass. This is because the designed greedy strategy is only \"partially correct\", as exemplified by the coin change problem discussed above.</li> </ul> <p>To ensure correctness, we should rigorously mathematically prove the greedy strategy, usually using proof by contradiction or mathematical induction.</p> <p>However, correctness proofs may also not be easy. If we have no clue, we usually choose to debug the code based on test cases, step by step modifying and verifying the greedy strategy.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514-typical-problems-solved-by-greedy-algorithms","level":2,"title":"15.1.4   Typical Problems Solved by Greedy Algorithms","text":"<p>Greedy algorithms are often applied to optimization problems that satisfy greedy choice property and optimal substructure. Below are some typical greedy algorithm problems.</p> <ul> <li>Coin change problem: With certain coin combinations, greedy algorithms can always obtain the optimal solution.</li> <li>Interval scheduling problem: Suppose you have some tasks, each taking place during a period of time, and your goal is to complete as many tasks as possible. If you always choose the task that ends earliest, then the greedy algorithm can obtain the optimal solution.</li> <li>Fractional knapsack problem: Given a set of items and a carrying capacity, your goal is to select a set of items such that the total weight does not exceed the carrying capacity and the total value is maximized. If you always choose the item with the highest value-to-weight ratio (value / weight), then the greedy algorithm can obtain the optimal solution in some cases.</li> <li>Stock trading problem: Given a set of historical stock prices, you can make multiple trades, but if you already hold stocks, you cannot buy again before selling, and the goal is to obtain the maximum profit.</li> <li>Huffman coding: Huffman coding is a greedy algorithm used for lossless data compression. By constructing a Huffman tree and always merging the two nodes with the lowest frequency, the resulting Huffman tree has the minimum weighted path length (encoding length).</li> <li>Dijkstra's algorithm: It is a greedy algorithm for solving the shortest path problem from a given source vertex to all other vertices.</li> </ul>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   Max Capacity Problem","text":"<p>Question</p> <p>Input an array \\(ht\\), where each element represents the height of a vertical partition. Any two partitions in the array, along with the space between them, can form a container.</p> <p>The capacity of the container equals the product of height and width (area), where the height is determined by the shorter partition, and the width is the difference in array indices between the two partitions.</p> <p>Please select two partitions in the array such that the capacity of the formed container is maximized, and return the maximum capacity. An example is shown in Figure 15-7.</p> <p></p> <p> Figure 15-7   Example data for the max capacity problem </p> <p>The container is formed by any two partitions, therefore the state of this problem is the indices of two partitions, denoted as \\([i, j]\\).</p> <p>According to the problem description, capacity equals height multiplied by width, where height is determined by the shorter partition, and width is the difference in array indices between the two partitions. Let the capacity be \\(cap[i, j]\\), then the calculation formula is:</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>Let the array length be \\(n\\), then the number of combinations of two partitions (total number of states) is \\(C_n^2 = \\frac{n(n - 1)}{2}\\). Most directly, we can exhaustively enumerate all states to find the maximum capacity, with time complexity \\(O(n^2)\\).</p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>This problem has a more efficient solution. As shown in Figure 15-8, select a state \\([i, j]\\) where index \\(i &lt; j\\) and height \\(ht[i] &lt; ht[j]\\), meaning \\(i\\) is the short partition and \\(j\\) is the long partition.</p> <p></p> <p> Figure 15-8   Initial state </p> <p>As shown in Figure 15-9, if we now move the long partition \\(j\\) closer to the short partition \\(i\\), the capacity will definitely decrease.</p> <p>This is because after moving the long partition \\(j\\), the width \\(j-i\\) definitely decreases; and since height is determined by the short partition, the height can only remain unchanged (\\(i\\) is still the short partition) or decrease (the moved \\(j\\) becomes the short partition).</p> <p></p> <p> Figure 15-9   State after moving the long partition inward </p> <p>Conversely, we can only possibly increase capacity by contracting the short partition \\(i\\) inward. Because although width will definitely decrease, height may increase (the moved short partition \\(i\\) may become taller). For example, in Figure 15-10, the area increases after moving the short partition.</p> <p></p> <p> Figure 15-10   State after moving the short partition inward </p> <p>From this we can derive the greedy strategy for this problem: initialize two pointers at both ends of the container, and in each round contract the pointer corresponding to the short partition inward, until the two pointers meet.</p> <p>Figure 15-11 shows the execution process of the greedy strategy.</p> <ol> <li>In the initial state, pointers \\(i\\) and \\(j\\) are at both ends of the array.</li> <li>Calculate the capacity of the current state \\(cap[i, j]\\), and update the maximum capacity.</li> <li>Compare the heights of partition \\(i\\) and partition \\(j\\), and move the short partition inward by one position.</li> <li>Loop through steps <code>2.</code> and <code>3.</code> until \\(i\\) and \\(j\\) meet.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 15-11   Greedy process for the max capacity problem </p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>The code loops at most \\(n\\) rounds, therefore the time complexity is \\(O(n)\\).</p> <p>Variables \\(i\\), \\(j\\), and \\(res\\) use a constant amount of extra space, therefore the space complexity is \\(O(1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"Max capacity: Greedy algorithm\"\"\"\n    # Initialize i, j to be at both ends of the array\n    i, j = 0, len(ht) - 1\n    # Initial max capacity is 0\n    res = 0\n    # Loop for greedy selection until the two boards meet\n    while i &lt; j:\n        # Update max capacity\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # Move the shorter board inward\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.size() - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(int[] ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.length - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* Max capacity: Greedy algorithm */\nint MaxCapacity(int[] ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.Length - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* Max capacity: Greedy algorithm */\nfunc maxCapacity(ht []int) int {\n    // Initialize i, j to be at both ends of the array\n    i, j := 0, len(ht)-1\n    // Initial max capacity is 0\n    res := 0\n    // Loop for greedy selection until the two boards meet\n    for i &lt; j {\n        // Update max capacity\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* Max capacity: Greedy algorithm */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // Initialize i, j to be at both ends of the array\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // Initial max capacity is 0\n    var res = 0\n    // Loop for greedy selection until the two boards meet\n    while i &lt; j {\n        // Update max capacity\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* Max capacity: Greedy algorithm */\nfunction maxCapacity(ht) {\n    // Initialize i, j to be at both ends of the array\n    let i = 0,\n        j = ht.length - 1;\n    // Initial max capacity is 0\n    let res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* Max capacity: Greedy algorithm */\nfunction maxCapacity(ht: number[]): number {\n    // Initialize i, j to be at both ends of the array\n    let i = 0,\n        j = ht.length - 1;\n    // Initial max capacity is 0\n    let res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(List&lt;int&gt; ht) {\n  // Initialize i, j to be at both ends of the array\n  int i = 0, j = ht.length - 1;\n  // Initial max capacity is 0\n  int res = 0;\n  // Loop for greedy selection until the two boards meet\n  while (i &lt; j) {\n    // Update max capacity\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // Move the shorter board inward\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* Max capacity: Greedy algorithm */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // Initialize i, j to be at both ends of the array\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // Initial max capacity is 0\n    let mut res = 0;\n    // Loop for greedy selection until the two boards meet\n    while i &lt; j {\n        // Update max capacity\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(int ht[], int htLength) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0;\n    int j = htLength - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* Max capacity: Greedy algorithm */\nfun maxCapacity(ht: IntArray): Int {\n    // Initialize i, j to be at both ends of the array\n    var i = 0\n    var j = ht.size - 1\n    // Initial max capacity is 0\n    var res = 0\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### Maximum capacity: greedy ###\ndef max_capacity(ht)\n  # Initialize i, j to be at both ends of the array\n  i, j = 0, ht.length - 1\n  # Initial max capacity is 0\n  res = 0\n\n  # Loop for greedy selection until the two boards meet\n  while i &lt; j\n    # Update max capacity\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # Move the shorter board inward\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>The reason greedy is faster than exhaustive enumeration is that each round of greedy selection \"skips\" some states.</p> <p>For example, in state \\(cap[i, j]\\) where \\(i\\) is the short partition and \\(j\\) is the long partition, if we greedily move the short partition \\(i\\) inward by one position, the states shown in Figure 15-12 will be \"skipped\". This means that the capacities of these states cannot be verified later.</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> Figure 15-12   States skipped by moving the short partition </p> <p>Observing carefully, these skipped states are actually all the states obtained by moving the long partition \\(j\\) inward. We have already proven that moving the long partition inward will definitely decrease capacity. That is, the skipped states cannot possibly be the optimal solution, skipping them will not cause us to miss the optimal solution.</p> <p>The above analysis shows that the operation of moving the short partition is \"safe\", and the greedy strategy is effective.</p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   Max Product Cutting Problem","text":"<p>Question</p> <p>Given a positive integer \\(n\\), split it into the sum of at least two positive integers, and find the maximum product of all integers after splitting, as shown in Figure 15-13.</p> <p></p> <p> Figure 15-13   Problem definition of max product cutting </p> <p>Suppose we split \\(n\\) into \\(m\\) integer factors, where the \\(i\\)-th factor is denoted as \\(n_i\\), that is</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>The goal of this problem is to find the maximum product of all integer factors, namely</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>We need to think about: how large should the splitting count \\(m\\) be, and what should each \\(n_i\\) be?</p>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>Based on experience, the product of two integers is often greater than their sum. Suppose we split out a factor of \\(2\\) from \\(n\\), then their product is \\(2(n-2)\\). We compare this product with \\(n\\):</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>As shown in Figure 15-14, when \\(n \\geq 4\\), splitting out a \\(2\\) will increase the product, which indicates that integers greater than or equal to \\(4\\) should all be split.</p> <p>Greedy strategy one: If the splitting scheme includes factors \\(\\geq 4\\), then they should continue to be split. The final splitting scheme should only contain factors \\(1\\), \\(2\\), and \\(3\\).</p> <p></p> <p> Figure 15-14   Splitting causes product to increase </p> <p>Next, consider which factor is optimal. Among the three factors \\(1\\), \\(2\\), and \\(3\\), clearly \\(1\\) is the worst, because \\(1 \\times (n-1) &lt; n\\) always holds, meaning splitting out \\(1\\) will actually decrease the product.</p> <p>As shown in Figure 15-15, when \\(n = 6\\), we have \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\). This means that splitting out \\(3\\) is better than splitting out \\(2\\).</p> <p>Greedy strategy two: In the splitting scheme, there should be at most two \\(2\\)s. Because three \\(2\\)s can always be replaced by two \\(3\\)s to obtain a larger product.</p> <p></p> <p> Figure 15-15   Optimal splitting factor </p> <p>In summary, the following greedy strategies can be derived.</p> <ol> <li>Input integer \\(n\\), continuously split out factor \\(3\\) until the remainder is \\(0\\), \\(1\\), or \\(2\\).</li> <li>When the remainder is \\(0\\), it means \\(n\\) is a multiple of \\(3\\), so no further action is needed.</li> <li>When the remainder is \\(2\\), do not continue splitting, keep it.</li> <li>When the remainder is \\(1\\), since \\(2 \\times 2 &gt; 1 \\times 3\\), the last \\(3\\) should be replaced with \\(2\\).</li> </ol>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>As shown in Figure 15-16, we don't need to use loops to split the integer, but can use integer division to get the count of \\(3\\)s as \\(a\\), and modulo operation to get the remainder as \\(b\\), at which point we have:</p> \\[ n = 3 a + b \\] <p>Please note that for the edge case of \\(n \\leq 3\\), a \\(1\\) must be split out, with product \\(1 \\times (n - 1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"Max product cutting: Greedy algorithm\"\"\"\n    # When n &lt;= 3, must cut out a 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # Greedily cut out 3, a is the number of 3s, b is the remainder\n    a, b = n // 3, n % 3\n    if b == 1:\n        # When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # When the remainder is 2, do nothing\n        return int(math.pow(3, a)) * 2\n    # When the remainder is 0, do nothing\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int)pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int) Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* Max product cutting: Greedy algorithm */\nint MaxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* Max product cutting: Greedy algorithm */\nfunc maxProductCutting(n int) int {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // When the remainder is 2, do nothing\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // When the remainder is 0, do nothing\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* Max product cutting: Greedy algorithm */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // When the remainder is 2, do nothing\n        return pow(3, a) * 2\n    }\n    // When the remainder is 0, do nothing\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* Max product cutting: Greedy algorithm */\nfunction maxProductCutting(n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // When the remainder is 2, do nothing\n        return Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* Max product cutting: Greedy algorithm */\nfunction maxProductCutting(n: number): number {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // When the remainder is 2, do nothing\n        return Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n  // When n &lt;= 3, must cut out a 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // Greedily cut out 3, a is the number of 3s, b is the remainder\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // When the remainder is 2, do nothing\n    return (pow(3, a) * 2).toInt();\n  }\n  // When the remainder is 0, do nothing\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* Max product cutting: Greedy algorithm */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // When the remainder is 2, do nothing\n        3_i32.pow(a as u32) * 2\n    } else {\n        // When the remainder is 0, do nothing\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* Max product cutting: Greedy algorithm */\nfun maxProductCutting(n: Int): Int {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // When the remainder is 0, do nothing\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### Maximum cutting product: greedy ###\ndef max_product_cutting(n)\n  # When n &lt;= 3, must cut out a 1\n  return 1 * (n - 1) if n &lt;= 3\n  # Greedily cut out 3, a is the number of 3s, b is the remainder\n  a, b = n / 3, n % 3\n  # When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # When the remainder is 2, do nothing\n  return (3.pow(a) * 2).to_i if b == 2\n  # When the remainder is 0, do nothing\n  3.pow(a).to_i\nend\n</code></pre> <p></p> <p> Figure 15-16   Calculation method for max product cutting </p> <p>The time complexity depends on the implementation of the exponentiation operation in the programming language. Taking Python as an example, there are three commonly used power calculation functions.</p> <ul> <li>Both the operator <code>**</code> and the function <code>pow()</code> have time complexity \\(O(\\log⁡ a)\\).</li> <li>The function <code>math.pow()</code> internally calls the C library's <code>pow()</code> function, which performs floating-point exponentiation, with time complexity \\(O(1)\\).</li> </ul> <p>Variables \\(a\\) and \\(b\\) use a constant amount of extra space, therefore the space complexity is \\(O(1)\\).</p>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>Using proof by contradiction, only analyzing the case where \\(n \\geq 4\\).</p> <ol> <li>All factors \\(\\leq 3\\): Suppose the optimal splitting scheme includes a factor \\(x \\geq 4\\), then it can definitely continue to be split into \\(2(x-2)\\) to obtain a larger (or equal) product. This contradicts the assumption.</li> <li>The splitting scheme does not contain \\(1\\): Suppose the optimal splitting scheme includes a factor of \\(1\\), then it can definitely be merged into another factor to obtain a larger product. This contradicts the assumption.</li> <li>The splitting scheme contains at most two \\(2\\)s: Suppose the optimal splitting scheme includes three \\(2\\)s, then they can definitely be replaced by two \\(3\\)s for a larger product. This contradicts the assumption.</li> </ol>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   Summary","text":"","path":["Chapter 15. Greedy","15.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_greedy/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Greedy algorithms are typically used to solve optimization problems. The principle is to make locally optimal decisions at each decision stage in hopes of obtaining a globally optimal solution.</li> <li>Greedy algorithms iteratively make one greedy choice after another, transforming the problem into a smaller subproblem in each round, until the problem is solved.</li> <li>Greedy algorithms are not only simple to implement, but also have high problem-solving efficiency. Compared to dynamic programming, greedy algorithms typically have lower time complexity.</li> <li>In the coin change problem, for certain coin combinations, greedy algorithms can guarantee finding the optimal solution; for other coin combinations, however, greedy algorithms may find very poor solutions.</li> <li>Problems suitable for solving with greedy algorithms have two major properties: greedy choice property and optimal substructure. The greedy choice property represents the effectiveness of the greedy strategy.</li> <li>For some complex problems, proving the greedy choice property is not simple. Relatively speaking, disproving it is easier, such as in the coin change problem.</li> <li>Solving greedy problems mainly consists of three steps: problem analysis, determining the greedy strategy, and correctness proof. Among these, determining the greedy strategy is the core step, and correctness proof is often the difficult point.</li> <li>The fractional knapsack problem, based on the 0-1 knapsack problem, allows selecting a portion of items, and therefore can be solved using greedy algorithms. The correctness of the greedy strategy can be proven using proof by contradiction.</li> <li>The max capacity problem can be solved using exhaustive enumeration with time complexity \\(O(n^2)\\). By designing a greedy strategy to move the short partition inward in each round, the time complexity can be optimized to \\(O(n)\\).</li> <li>In the max product cutting problem, we successively derive two greedy strategies: integers \\(\\geq 4\\) should all continue to be split, and the optimal splitting factor is \\(3\\). The code includes exponentiation operations, and the time complexity depends on the implementation method of exponentiation, typically being \\(O(1)\\) or \\(O(\\log n)\\).</li> </ul>","path":["Chapter 15. Greedy","15.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"Chapter 6.   Hashing","text":"<p>Abstract</p> <p>In the world of computing, a hash table is like a clever librarian.</p> <p>They know how to calculate call numbers, enabling them to quickly locate the target book.</p>","path":["Chapter 6. Hashing","Chapter 6. &nbsp; Hashing"],"tags":[]},{"location":"chapter_hashing/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>6.1   Hash Table</li> <li>6.2   Hash Collision</li> <li>6.3   Hash Algorithm</li> <li>6.4   Summary</li> </ul>","path":["Chapter 6. Hashing","Chapter 6. &nbsp; Hashing"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   Hash Algorithm","text":"<p>The previous two sections introduced the working principle of hash tables and the methods to handle hash collisions. However, both open addressing and separate chaining can only ensure that the hash table functions normally when hash collisions occur, but cannot reduce the frequency of hash collisions.</p> <p>If hash collisions occur too frequently, the performance of the hash table will deteriorate drastically. As shown in Figure 6-8, for a separate chaining hash table, in the ideal case, the key-value pairs are evenly distributed across the buckets, achieving optimal query efficiency; in the worst case, all key-value pairs are stored in the same bucket, degrading the time complexity to \\(O(n)\\).</p> <p></p> <p> Figure 6-8   Ideal and worst cases of hash collisions </p> <p>The distribution of key-value pairs is determined by the hash function. Recalling the calculation steps of the hash function, first compute the hash value, then take the modulo by the array length:</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Observing the above formula, when the hash table capacity <code>capacity</code> is fixed, the hash algorithm <code>hash()</code> determines the output value, thereby determining the distribution of key-value pairs in the hash table.</p> <p>This means that, to reduce the probability of hash collisions, we should focus on the design of the hash algorithm <code>hash()</code>.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631-goals-of-hash-algorithms","level":2,"title":"6.3.1   Goals of Hash Algorithms","text":"<p>To achieve a \"fast and stable\" hash table data structure, hash algorithms should have the following characteristics:</p> <ul> <li>Determinism: For the same input, the hash algorithm should always produce the same output. Only then can the hash table be reliable.</li> <li>High efficiency: The process of computing the hash value should be fast enough. The smaller the computational overhead, the more practical the hash table.</li> <li>Uniform distribution: The hash algorithm should ensure that key-value pairs are evenly distributed in the hash table. The more uniform the distribution, the lower the probability of hash collisions.</li> </ul> <p>In fact, hash algorithms are not only used to implement hash tables but are also widely applied in other fields.</p> <ul> <li>Password storage: To protect the security of user passwords, systems usually do not store the plaintext passwords but rather the hash values of the passwords. When a user enters a password, the system calculates the hash value of the input and compares it with the stored hash value. If they match, the password is considered correct.</li> <li>Data integrity check: The data sender can calculate the hash value of the data and send it along; the receiver can recalculate the hash value of the received data and compare it with the received hash value. If they match, the data is considered intact.</li> </ul> <p>For cryptographic applications, to prevent reverse engineering such as deducing the original password from the hash value, hash algorithms need higher-level security features.</p> <ul> <li>Unidirectionality: It should be impossible to deduce any information about the input data from the hash value.</li> <li>Collision resistance: It should be extremely difficult to find two different inputs that produce the same hash value.</li> <li>Avalanche effect: Minor changes in the input should lead to significant and unpredictable changes in the output.</li> </ul> <p>Note that \"uniform distribution\" and \"collision resistance\" are two independent concepts. Satisfying uniform distribution does not necessarily mean collision resistance. For example, under random input <code>key</code>, the hash function <code>key % 100</code> can produce a uniformly distributed output. However, this hash algorithm is too simple, and all <code>key</code> with the same last two digits will have the same output, making it easy to deduce a usable <code>key</code> from the hash value, thereby cracking the password.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632-design-of-hash-algorithms","level":2,"title":"6.3.2   Design of Hash Algorithms","text":"<p>The design of hash algorithms is a complex issue that requires consideration of many factors. However, for some less demanding scenarios, we can also design some simple hash algorithms.</p> <ul> <li>Additive hash: Add up the ASCII codes of each character in the input and use the total sum as the hash value.</li> <li>Multiplicative hash: Utilize the non-correlation of multiplication, multiplying each round by a constant, accumulating the ASCII codes of each character into the hash value.</li> <li>XOR hash: Accumulate the hash value by XORing each element of the input data.</li> <li>Rotating hash: Accumulate the ASCII code of each character into a hash value, performing a rotation operation on the hash value before each accumulation.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"Additive hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"Multiplicative hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"Rotational hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* Additive hash */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* Additive hash */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* Multiplicative hash */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR hash */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* Additive hash */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* Additive hash */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* Multiplicative hash */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR hash */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* Rotational hash */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* Additive hash */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* Multiplicative hash */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR hash */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* Rotational hash */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* Additive hash */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Multiplicative hash */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR hash */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Rotational hash */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* Additive hash */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Multiplicative hash */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR hash */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Rotational hash */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* Additive hash */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* Multiplicative hash */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR hash */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* Additive hash */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* Multiplicative hash */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR hash */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* Rotational hash */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* Additive hash */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* Additive hash */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* Multiplicative hash */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR hash */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* Rotational hash */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### Additive hash ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### Multiplicative hash ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR hash ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### Rotational hash ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> <p>It is observed that the last step of each hash algorithm is to take the modulus of the large prime number \\(1000000007\\) to ensure that the hash value is within an appropriate range. It is worth pondering why emphasis is placed on modulo a prime number, or what are the disadvantages of modulo a composite number? This is an interesting question.</p> <p>To conclude: Using a large prime number as the modulus can maximize the uniform distribution of hash values. Since a prime number does not share common factors with other numbers, it can reduce the periodic patterns caused by the modulo operation, thus avoiding hash collisions.</p> <p>For example, suppose we choose the composite number \\(9\\) as the modulus, which can be divided by \\(3\\), then all <code>key</code> divisible by \\(3\\) will be mapped to hash values \\(0\\), \\(3\\), \\(6\\).</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>If the input <code>key</code> happens to have this kind of arithmetic sequence distribution, then the hash values will cluster, thereby exacerbating hash collisions. Now, suppose we replace <code>modulus</code> with the prime number \\(13\\), since there are no common factors between <code>key</code> and <code>modulus</code>, the uniformity of the output hash values will be significantly improved.</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>It is worth noting that if the <code>key</code> is guaranteed to be randomly and uniformly distributed, then choosing a prime number or a composite number as the modulus can both produce uniformly distributed hash values. However, when the distribution of <code>key</code> has some periodicity, modulo a composite number is more likely to result in clustering.</p> <p>In summary, we usually choose a prime number as the modulus, and this prime number should be large enough to eliminate periodic patterns as much as possible, enhancing the robustness of the hash algorithm.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633-common-hash-algorithms","level":2,"title":"6.3.3   Common Hash Algorithms","text":"<p>It is not hard to see that the simple hash algorithms mentioned above are quite \"fragile\" and far from reaching the design goals of hash algorithms. For example, since addition and XOR obey the commutative law, additive hash and XOR hash cannot distinguish strings with the same content but in different order, which may exacerbate hash collisions and cause security issues.</p> <p>In practice, we usually use some standard hash algorithms, such as MD5, SHA-1, SHA-2, and SHA-3. They can map input data of any length to a fixed-length hash value.</p> <p>Over the past century, hash algorithms have been in a continuous process of upgrading and optimization. Some researchers strive to improve the performance of hash algorithms, while others, including hackers, are dedicated to finding security issues in hash algorithms. Table 6-2 shows hash algorithms commonly used in practical applications.</p> <ul> <li>MD5 and SHA-1 have been successfully attacked multiple times and are thus abandoned in various security applications.</li> <li>SHA-2 series, especially SHA-256, is one of the most secure hash algorithms to date, with no successful attacks reported, hence commonly used in various security applications and protocols.</li> <li>SHA-3 has lower implementation costs and higher computational efficiency compared to SHA-2, but its current usage coverage is not as extensive as the SHA-2 series.</li> </ul> <p> Table 6-2   Common hash algorithms </p> MD5 SHA-1 SHA-2 SHA-3 Release Year 1992 1995 2002 2008 Output Length 128 bit 160 bit 256/512 bit 224/256/384/512 bit Hash Collisions Frequent Frequent Rare Rare Security Level Low, has been successfully attacked Low, has been successfully attacked High High Applications Abandoned, still used for data integrity checks Abandoned Cryptocurrency transaction verification, digital signatures, etc. Can be used to replace SHA-2","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#hash-values-in-data-structures","level":1,"title":"Hash Values in Data Structures","text":"<p>We know that the keys in a hash table can be of various data types such as integers, decimals, or strings. Programming languages usually provide built-in hash algorithms for these data types to calculate the bucket indices in the hash table. Taking Python as an example, we can use the <code>hash()</code> function to compute the hash values for various data types.</p> <ul> <li>The hash values of integers and booleans are their own values.</li> <li>The calculation of hash values for floating-point numbers and strings is more complex, and interested readers are encouraged to study this on their own.</li> <li>The hash value of a tuple is a combination of the hash values of each of its elements, resulting in a single hash value.</li> <li>The hash value of an object is generated based on its memory address. By overriding the hash method of an object, hash values can be generated based on content.</li> </ul> <p>Tip</p> <p>Be aware that the definition and methods of the built-in hash value calculation functions in different programming languages vary.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# Hash value of integer 3 is 3\n\nbol = True\nhash_bol = hash(bol)\n# Hash value of boolean True is 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Hash value of decimal 3.14159 is 326484311674566659\n\nstr = \"Hello 算法\"\nhash_str = hash(str)\n# Hash value of string \"Hello 算法\" is 4617003410720528961\n\ntup = (12836, \"小哈\")\nhash_tup = hash(tup)\n# Hash value of tuple (12836, '小哈') is 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Hash value of ListNode object at 0x1058fd810 is 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// Hash value of integer 3 is 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// Hash value of boolean 1 is 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// Hash value of decimal 3.14159 is 4614256650576692846\n\nstring str = \"Hello 算法\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// Hash value of string \"Hello 算法\" is 15466937326284535026\n\n// In C++, built-in std::hash() only provides hash values for basic data types\n// Hash values for arrays and objects need to be implemented separately\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// Hash value of integer 3 is 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Hash value of decimal 3.14159 is -1340954729\n\nString str = \"Hello 算法\";\nint hashStr = str.hashCode();\n// Hash value of string \"Hello 算法\" is -727081396\n\nObject[] arr = { 12836, \"小哈\" };\nint hashTup = Arrays.hashCode(arr);\n// Hash value of array [12836, 小哈] is 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Hash value of ListNode object utils.ListNode@7dc5e7b4 is 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// Hash value of integer 3 is 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Hash value of boolean true is 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Hash value of decimal 3.14159 is -1340954729;\n\nstring str = \"Hello 算法\";\nint hashStr = str.GetHashCode();\n// Hash value of string \"Hello 算法\" is -586107568;\n\nobject[] arr = [12836, \"小哈\"];\nint hashTup = arr.GetHashCode();\n// Hash value of array [12836, 小哈] is 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Hash value of ListNode object 0 is 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go does not provide built-in hash code functions\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// Hash value of integer 3 is 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Hash value of boolean true is -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Hash value of decimal 3.14159 is -2465384235396674631\n\nlet str = \"Hello 算法\"\nlet hashStr = str.hashValue\n// Hash value of string \"Hello 算法\" is -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"小哈\")]\nlet hashTup = arr.hashValue\n// Hash value of array [AnyHashable(12836), AnyHashable(\"小哈\")] is -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Hash value of ListNode object utils.ListNode is -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript does not provide built-in hash code functions\n</code></pre> built_in_hash.ts<pre><code>// TypeScript does not provide built-in hash code functions\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// Hash value of integer 3 is 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Hash value of decimal 3.14159 is 2570631074981783\n\nString str = \"Hello 算法\";\nint hashStr = str.hashCode;\n// Hash value of string \"Hello 算法\" is 468167534\n\nList arr = [12836, \"小哈\"];\nint hashArr = arr.hashCode;\n// Hash value of array [12836, 小哈] is 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Hash value of ListNode object Instance of 'ListNode' is 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Hash value of integer 3 is 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Hash value of boolean true is 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Hash value of decimal 3.14159 is 2566941990314602357\n\nlet str = \"Hello 算法\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Hash value of string \"Hello 算法\" is 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"小哈\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Hash value of tuple (12836, \"小哈\") is 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// Hash value of ListNode object RefCell { value: ListNode { val: 42, next: None } } is 15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C does not provide built-in hash code functions\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// Hash value of integer 3 is 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// Hash value of boolean true is 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// Hash value of decimal 3.14159 is -1340954729\n\nval str = \"Hello 算法\"\nval hashStr = str.hashCode()\n// Hash value of string \"Hello 算法\" is -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"小哈\")\nval hashTup = arr.hashCode()\n// Hash value of array [12836, 小哈] is 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// Hash value of ListNode object utils.ListNode@1d81eb93 is 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# Hash value of integer 3 is -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# Hash value of boolean true is -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# Hash value of decimal 3.14159 is -1479186995943067893\n\nstr = \"Hello 算法\"\nhash_str = str.hash\n# Hash value of string \"Hello 算法\" is -4075943250025831763\n\ntup = [12836, '小哈']\nhash_tup = tup.hash\n# Hash value of tuple (12836, '小哈') is 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# Hash value of ListNode object #&lt;ListNode:0x000078133140ab70&gt; is 4302940560806366381\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%E6%95%B4%E6%95%B0%203%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%E5%B8%83%E5%B0%94%E9%87%8F%20True%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%E5%B0%8F%E6%95%B0%203.14159%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20%E7%AE%97%E6%B3%95%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%E5%AD%97%E7%AC%A6%E4%B8%B2%E2%80%9CHello%20%E7%AE%97%E6%B3%95%E2%80%9D%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836,%20%22%E5%B0%8F%E5%93%88%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%E5%85%83%E7%BB%84%20%2812836,%20'%E5%B0%8F%E5%93%88'%29%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%AF%B9%E8%B1%A1%20%3CListNode%20object%20at%200x1058fd810%3E%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>In many programming languages, only immutable objects can serve as the <code>key</code> in a hash table. If we use a list (dynamic array) as a <code>key</code>, when the contents of the list change, its hash value also changes, and we would no longer be able to find the original <code>value</code> in the hash table.</p> <p>Although the member variables of a custom object (such as a linked list node) are mutable, it is hashable. This is because the hash value of an object is usually generated based on its memory address, and even if the contents of the object change, the memory address remains the same, so the hash value remains unchanged.</p> <p>You might have noticed that the hash values output in different consoles are different. This is because the Python interpreter adds a random salt to the string hash function each time it starts up. This approach effectively prevents HashDoS attacks and enhances the security of the hash algorithm.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   Hash Collision","text":"<p>The previous section mentioned that, in most cases, the input space of a hash function is much larger than the output space, so theoretically, hash collisions are inevitable. For example, if the input space is all integers and the output space is the array capacity size, then multiple integers will inevitably be mapped to the same bucket index.</p> <p>Hash collisions can lead to incorrect query results, severely impacting the usability of the hash table. To address this issue, whenever a hash collision occurs, we can perform hash table expansion until the collision disappears. This approach is simple, straightforward, and effective, but it is very inefficient because hash table expansion involves a large amount of data migration and hash value recalculation. To improve efficiency, we can adopt the following strategies:</p> <ol> <li>Improve the hash table data structure so that the hash table can function normally when hash collisions occur.</li> <li>Only expand when necessary, that is, only when hash collisions are severe.</li> </ol> <p>The main methods for improving the structure of hash tables include \"separate chaining\" and \"open addressing\".</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621-separate-chaining","level":2,"title":"6.2.1   Separate Chaining","text":"<p>In the original hash table, each bucket can store only one key-value pair. Separate chaining converts a single element into a linked list, treating key-value pairs as linked list nodes and storing all colliding key-value pairs in the same linked list. Figure 6-5 shows an example of a separate chaining hash table.</p> <p></p> <p> Figure 6-5   Separate chaining hash table </p> <p>The operations of a hash table implemented with separate chaining have changed as follows:</p> <ul> <li>Querying elements: Input <code>key</code>, obtain the bucket index through the hash function, then access the head node of the linked list, then traverse the linked list and compare <code>key</code> to find the target key-value pair.</li> <li>Adding elements: First access the linked list head node through the hash function, then append the node (key-value pair) to the linked list.</li> <li>Deleting elements: Access the head of the linked list based on the result of the hash function, then traverse the linked list to find the target node and delete it.</li> </ul> <p>Separate chaining has the following limitations:</p> <ul> <li>Increased Space Usage: The linked list contains node pointers, which consume more memory space than arrays.</li> <li>Reduced Query Efficiency: This is because linear traversal of the linked list is required to find the corresponding element.</li> </ul> <p>The code below provides a simple implementation of a separate chaining hash table, with two things to note:</p> <ul> <li>Lists (dynamic arrays) are used instead of linked lists to simplify the code. In this setup, the hash table (array) contains multiple buckets, each of which is a list.</li> <li>This implementation includes a hash table expansion method. When the load factor exceeds \\(\\frac{2}{3}\\), we expand the hash table to \\(2\\) times its original size.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"Hash table with separate chaining\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self.size = 0  # Number of key-value pairs\n        self.capacity = 4  # Hash table capacity\n        self.load_thres = 2.0 / 3.0  # Load factor threshold for triggering expansion\n        self.extend_ratio = 2  # Expansion multiplier\n        self.buckets = [[] for _ in range(self.capacity)]  # Bucket array\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Load factor\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Query operation\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket, if key is found, return corresponding val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # If key is not found, return None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Add operation\"\"\"\n        # When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # If key does not exist, append key-value pair to the end\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket and remove key-value pair from it\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"Expand hash table\"\"\"\n        # Temporarily store the original hash table\n        buckets = self.buckets\n        # Initialize expanded new hash table\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # Move key-value pairs from original hash table to new hash table\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n  private:\n    int size;                       // Number of key-value pairs\n    int capacity;                   // Hash table capacity\n    double loadThres;               // Load factor threshold for triggering expansion\n    int extendRatio;                // Expansion multiplier\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // Bucket array\n\n  public:\n    /* Constructor */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* Destructor */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // Free memory\n                delete pair;\n            }\n        }\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        int index = hashFunc(key);\n        // Traverse bucket, if key is found, return corresponding val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // Return empty string if key not found\n        return \"\";\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // Remove key-value pair from it\n                delete tmp;                       // Free memory\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // Free memory\n                delete pair;\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    int size; // Number of key-value pairs\n    int capacity; // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio; // Expansion multiplier\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n    /* Constructor */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Query operation */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket, if key is found, return corresponding val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    void put(int key, String val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket and remove key-value pair from it\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    int size; // Number of key-value pairs\n    int capacity; // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio; // Expansion multiplier\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n    /* Constructor */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // Traverse bucket, if key is found, return corresponding val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Traverse bucket and remove key-value pair from it\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void Extend() {\n        // Temporarily store the original hash table\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* Hash table with separate chaining */\ntype hashMapChaining struct {\n    size        int      // Number of key-value pairs\n    capacity    int      // Hash table capacity\n    loadThres   float64  // Load factor threshold for triggering expansion\n    extendRatio int      // Expansion multiplier\n    buckets     [][]pair // Bucket array\n}\n\n/* Constructor */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* Hash function */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* Load factor */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* Query operation */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // Traverse bucket, if key is found, return corresponding val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // Return empty string if key not found\n    return \"\"\n}\n\n/* Add operation */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // When load factor exceeds threshold, perform expansion\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // If key does not exist, append key-value pair to the end\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* Remove operation */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // Traverse bucket and remove key-value pair from it\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // Slice deletion\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* Expand hash table */\nfunc (m *hashMapChaining) extend() {\n    // Temporarily store the original hash table\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // Initialize expanded new hash table\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // Move key-value pairs from original hash table to new hash table\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* Print hash table */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    var loadThres: Double // Load factor threshold for triggering expansion\n    var extendRatio: Int // Expansion multiplier\n    var buckets: [[Pair]] // Bucket array\n\n    /* Constructor */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* Hash function */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Load factor */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket, if key is found, return corresponding val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // Return nil if key not found\n        return nil\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket and remove key-value pair from it\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* Expand hash table */\n    func extend() {\n        // Temporarily store the original hash table\n        let bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    #size; // Number of key-value pairs\n    #capacity; // Hash table capacity\n    #loadThres; // Load factor threshold for triggering expansion\n    #extendRatio; // Expansion multiplier\n    #buckets; // Bucket array\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Query operation */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if key is found, return corresponding val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key, val) {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    #extend() {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    #size: number; // Number of key-value pairs\n    #capacity: number; // Hash table capacity\n    #loadThres: number; // Load factor threshold for triggering expansion\n    #extendRatio: number; // Expansion multiplier\n    #buckets: Pair[][]; // Bucket array\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Hash function */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* Query operation */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if key is found, return corresponding val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key: number, val: string): void {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    #extend(): void {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n  late int size; // Number of key-value pairs\n  late int capacity; // Hash table capacity\n  late double loadThres; // Load factor threshold for triggering expansion\n  late int extendRatio; // Expansion multiplier\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n  /* Constructor */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* Hash function */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* Load factor */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket, if key is found, return corresponding val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // If key is not found, return null\n    return null;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // If key does not exist, append key-value pair to the end\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket and remove key-value pair from it\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* Expand hash table */\n  void extend() {\n    // Temporarily store the original hash table\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // Initialize expanded new hash table\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* Hash table with separate chaining */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* Constructor */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* Load factor */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* Remove operation */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // Traverse bucket and remove key-value pair from it\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // If key is not found, return None\n        None\n    }\n\n    /* Expand hash table */\n    fn extend(&amp;mut self) {\n        // Temporarily store the original hash table\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // Initialize expanded new hash table\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // Move key-value pairs from original hash table to new hash table\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* Add operation */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // If key does not exist, append key-value pair to the end\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* Query operation */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // Traverse bucket, if key is found, return corresponding val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // If key is not found, return None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* Linked list node */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* Hash table with separate chaining */\ntypedef struct {\n    int size;         // Number of key-value pairs\n    int capacity;     // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio;  // Expansion multiplier\n    Node **buckets;   // Bucket array\n} HashMapChaining;\n\n/* Constructor */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* Destructor */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* Hash function */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Load factor */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Query operation */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // Traverse bucket, if key is found, return corresponding val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // Return empty string if key not found\n}\n\n/* Add operation */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // If specified key is found, update corresponding val and return\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // If key not found, add key-value pair to list head\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* Expand hash table */\nvoid extend(HashMapChaining *hashMap) {\n    // Temporarily store the original hash table\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // Initialize expanded new hash table\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // Free memory\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* Remove operation */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // Remove key-value pair from it\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // Free memory\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* Print hash table */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    val loadThres: Double // Load factor threshold for triggering expansion\n    val extendRatio: Int // Expansion multiplier\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // Bucket array\n\n    /* Constructor */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Load factor */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket, if key is found, return corresponding val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // If key is not found, return null\n        return null\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket and remove key-value pair from it\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* Expand hash table */\n    fun extend() {\n        // Temporarily store the original hash table\n        val bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        // mutablelist has no fixed size\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### Hash map with chaining ###\nclass HashMapChaining\n  ### Constructor ###\n  def initialize\n    @size = 0 # Number of key-value pairs\n    @capacity = 4 # Hash table capacity\n    @load_thres = 2.0 / 3.0 # Load factor threshold for triggering expansion\n    @extend_ratio = 2 # Expansion multiplier\n    @buckets = Array.new(@capacity) { [] } # Bucket array\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Load factor ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Query operation ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket, if key is found, return corresponding val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # Return nil if key not found\n    nil\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    # When load factor exceeds threshold, perform expansion\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket, if specified key is encountered, update corresponding val and return\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # If key does not exist, append key-value pair to the end\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket and remove key-value pair from it\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### Expand hash table ###\n  def extend\n    # Temporarily store original hash table\n    buckets = @buckets\n    # Initialize expanded new hash table\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # Move key-value pairs from original hash table to new hash table\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### Print hash table ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> <p>It's worth noting that when the linked list is very long, the query efficiency \\(O(n)\\) is poor. In this case, the list can be converted to an \"AVL tree\" or \"Red-Black tree\" to optimize the time complexity of the query operation to \\(O(\\log n)\\).</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622-open-addressing","level":2,"title":"6.2.2   Open Addressing","text":"<p>Open addressing does not introduce additional data structures but instead handles hash collisions through \"multiple probes\". The probing methods mainly include linear probing, quadratic probing, and double hashing.</p> <p>Let's use linear probing as an example to introduce the mechanism of open addressing hash tables.</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1-linear-probing","level":3,"title":"1.   Linear Probing","text":"<p>Linear probing uses a fixed-step linear search for probing, and its operation method differs from ordinary hash tables.</p> <ul> <li>Inserting elements: Calculate the bucket index using the hash function. If the bucket already contains an element, linearly traverse forward from the conflict position (usually with a step size of \\(1\\)) until an empty bucket is found, then insert the element.</li> <li>Searching for elements: If a hash collision is encountered, use the same step size to linearly traverse forward until the corresponding element is found and return <code>value</code>; if an empty bucket is encountered, it means the target element is not in the hash table, so return <code>None</code>.</li> </ul> <p>Figure 6-6 shows the distribution of key-value pairs in an open addressing (linear probing) hash table. According to this hash function, keys with the same last two digits will be mapped to the same bucket. Through linear probing, they are stored sequentially in that bucket and the buckets below it.</p> <p></p> <p> Figure 6-6   Distribution of key-value pairs in open addressing (linear probing) hash table </p> <p>However, linear probing is prone to create \"clustering\". Specifically, the longer the continuously occupied positions in the array, the greater the probability of hash collisions occurring in these continuous positions, further promoting clustering growth at that position, forming a vicious cycle, and ultimately leading to degraded efficiency of insertion, deletion, query, and update operations.</p> <p>It's important to note that we cannot directly delete elements in an open addressing hash table. Deleting an element creates an empty bucket <code>None</code> in the array. When searching for elements, if linear probing encounters this empty bucket, it will return, making the elements below this empty bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in Figure 6-7.</p> <p></p> <p> Figure 6-7   Query issues caused by deletion in open addressing </p> <p>To solve this problem, we can adopt the lazy deletion mechanism: instead of directly removing elements from the hash table, use a constant <code>TOMBSTONE</code> to mark the bucket. In this mechanism, both <code>None</code> and <code>TOMBSTONE</code> represent empty buckets and can hold key-value pairs. However, when linear probing encounters <code>TOMBSTONE</code>, it should continue traversing since there may still be key-value pairs below it.</p> <p>However, lazy deletion may accelerate the performance degradation of the hash table. Every deletion operation produces a deletion mark, and as <code>TOMBSTONE</code> increases, the search time will also increase because linear probing may need to skip multiple <code>TOMBSTONE</code> to find the target element.</p> <p>To address this, consider recording the index of the first encountered <code>TOMBSTONE</code> during linear probing and swapping the searched target element with that <code>TOMBSTONE</code>. The benefit of doing this is that each time an element is queried or added, the element will be moved to a bucket closer to its ideal position (the starting point of probing), thereby optimizing query efficiency.</p> <p>The code below implements an open addressing (linear probing) hash table with lazy deletion. To make better use of the hash table space, we treat the hash table as a \"circular array\". When going beyond the end of the array, we return to the beginning and continue traversing.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"Hash table with open addressing\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self.size = 0  # Number of key-value pairs\n        self.capacity = 4  # Hash table capacity\n        self.load_thres = 2.0 / 3.0  # Load factor threshold for triggering expansion\n        self.extend_ratio = 2  # Expansion multiplier\n        self.buckets: list[Pair | None] = [None] * self.capacity  # Bucket array\n        self.TOMBSTONE = Pair(-1, \"-1\")  # Removal marker\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Load factor\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"Search for bucket index corresponding to key\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # Linear probing, break when encountering an empty bucket\n        while self.buckets[index] is not None:\n            # If key is encountered, return the corresponding bucket index\n            if self.buckets[index].key == key:\n                # If a removal marker was encountered before, move the key-value pair to that index\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # Return the moved bucket index\n                return index  # Return bucket index\n            # Record the first removal marker encountered\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % self.capacity\n        # If key does not exist, return the index for insertion\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"Query operation\"\"\"\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, return corresponding val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # If key-value pair does not exist, return None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Add operation\"\"\"\n        # When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, overwrite val and return\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # If key-value pair does not exist, add the key-value pair\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, overwrite it with removal marker\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"Expand hash table\"\"\"\n        # Temporarily store the original hash table\n        buckets_tmp = self.buckets\n        # Initialize expanded new hash table\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # Move key-value pairs from original hash table to new hash table\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // Number of key-value pairs\n    int capacity = 4;                     // Hash table capacity\n    const double loadThres = 2.0 / 3.0;     // Load factor threshold for triggering expansion\n    const int extendRatio = 2;            // Expansion multiplier\n    vector&lt;Pair *&gt; buckets;               // Bucket array\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // Removal marker\n\n  public:\n    /* Constructor */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* Destructor */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != nullptr) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index]-&gt;key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // Return empty string if key-value pair does not exist\n        return \"\";\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private int size; // Number of key-value pairs\n    private int capacity = 4; // Hash table capacity\n    private final double loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n    private final int extendRatio = 2; // Expansion multiplier\n    private Pair[] buckets; // Bucket array\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // Removal marker\n\n    /* Constructor */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Hash function */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index].key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    public String get(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void put(int key, String val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    public void remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    private void extend() {\n        // Temporarily store the original hash table\n        Pair[] bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    int size; // Number of key-value pairs\n    int capacity = 4; // Hash table capacity\n    double loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n    int extendRatio = 2; // Expansion multiplier\n    Pair[] buckets; // Bucket array\n    Pair TOMBSTONE = new(-1, \"-1\"); // Removal marker\n\n    /* Constructor */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index].key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    void Extend() {\n        // Temporarily store the original hash table\n        Pair[] bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* Hash table with open addressing */\ntype hashMapOpenAddressing struct {\n    size        int     // Number of key-value pairs\n    capacity    int     // Hash table capacity\n    loadThres   float64 // Load factor threshold for triggering expansion\n    extendRatio int     // Expansion multiplier\n    buckets     []*pair // Bucket array\n    TOMBSTONE   *pair   // Removal marker\n}\n\n/* Constructor */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* Hash function */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // Calculate hash value based on key\n}\n\n/* Load factor */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // Calculate current load factor\n}\n\n/* Search for bucket index corresponding to key */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // Get initial index\n    firstTombstone := -1     // Record position of first TOMBSTONE encountered\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // Return the moved bucket index\n            }\n            return index // Return found index\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // Record position of first deletion marker encountered\n        }\n        index = (index + 1) % h.capacity // Linear probing, wrap around to head if past tail\n    }\n    // If key does not exist, return the index for insertion\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* Query operation */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // If key-value pair is found, return corresponding val\n    }\n    return \"\" // Return \"\" if key-value pair does not exist\n}\n\n/* Add operation */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // When load factor exceeds threshold, perform expansion\n    }\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // If key-value pair does not exist, add the key-value pair\n        h.size++\n    } else {\n        h.buckets[index].val = val // If key-value pair found, overwrite val\n    }\n}\n\n/* Remove operation */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // If key-value pair is found, overwrite it with removal marker\n        h.size--\n    }\n}\n\n/* Expand hash table */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // Temporarily store the original hash table\n    h.capacity *= h.extendRatio           // Update capacity\n    h.buckets = make([]*pair, h.capacity) // Initialize expanded new hash table\n    h.size = 0                            // Reset size\n    // Move key-value pairs from original hash table to new hash table\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* Print hash table */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    var loadThres: Double // Load factor threshold for triggering expansion\n    var extendRatio: Int // Expansion multiplier\n    var buckets: [Pair?] // Bucket array\n    var TOMBSTONE: Pair // Removal marker\n\n    /* Constructor */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* Hash function */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Load factor */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Search for bucket index corresponding to key */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // Linear probing, break when encountering an empty bucket\n        while buckets[index] != nil {\n            // If key is encountered, return the corresponding bucket index\n            if buckets[index]!.key == key {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Return the moved bucket index\n                }\n                return index // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, return corresponding val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // If key-value pair does not exist, return null\n        return nil\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, overwrite val and return\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, overwrite it with removal marker\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* Expand hash table */\n    func extend() {\n        // Temporarily store the original hash table\n        let bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    #size; // Number of key-value pairs\n    #capacity; // Hash table capacity\n    #loadThres; // Load factor threshold for triggering expansion\n    #extendRatio; // Expansion multiplier\n    #buckets; // Bucket array\n    #TOMBSTONE; // Removal marker\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0; // Number of key-value pairs\n        this.#capacity = 4; // Hash table capacity\n        this.#loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n        this.#extendRatio = 2; // Expansion multiplier\n        this.#buckets = Array(this.#capacity).fill(null); // Bucket array\n        this.#TOMBSTONE = new Pair(-1, '-1'); // Removal marker\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (this.#buckets[index] !== null) {\n            // If key is encountered, return the corresponding bucket index\n            if (this.#buckets[index].key === key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % this.#capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    get(key) {\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key, val) {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key) {\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* Expand hash table */\n    #extend() {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private size: number; // Number of key-value pairs\n    private capacity: number; // Hash table capacity\n    private loadThres: number; // Load factor threshold for triggering expansion\n    private extendRatio: number; // Expansion multiplier\n    private buckets: Array&lt;Pair | null&gt;; // Bucket array\n    private TOMBSTONE: Pair; // Removal marker\n\n    /* Constructor */\n    constructor() {\n        this.size = 0; // Number of key-value pairs\n        this.capacity = 4; // Hash table capacity\n        this.loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n        this.extendRatio = 2; // Expansion multiplier\n        this.buckets = Array(this.capacity).fill(null); // Bucket array\n        this.TOMBSTONE = new Pair(-1, '-1'); // Removal marker\n    }\n\n    /* Hash function */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* Load factor */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (this.buckets[index] !== null) {\n            // If key is encountered, return the corresponding bucket index\n            if (this.buckets[index]!.key === key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % this.capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    get(key: number): string | null {\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key: number, val: string): void {\n        // When load factor exceeds threshold, perform expansion\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* Remove operation */\n    remove(key: number): void {\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* Expand hash table */\n    private extend(): void {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.buckets;\n        // Initialize expanded new hash table\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n  late int _size; // Number of key-value pairs\n  int _capacity = 4; // Hash table capacity\n  double _loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n  int _extendRatio = 2; // Expansion multiplier\n  late List&lt;Pair?&gt; _buckets; // Bucket array\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // Removal marker\n\n  /* Constructor */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* Hash function */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* Load factor */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* Search for bucket index corresponding to key */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // Linear probing, break when encountering an empty bucket\n    while (_buckets[index] != null) {\n      // If key is encountered, return the corresponding bucket index\n      if (_buckets[index]!.key == key) {\n        // If a removal marker was encountered before, move the key-value pair to that index\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // Return the moved bucket index\n        }\n        return index; // Return bucket index\n      }\n      // Record the first removal marker encountered\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // Calculate bucket index, wrap around to the head if past the tail\n      index = (index + 1) % _capacity;\n    }\n    // If key does not exist, return the index for insertion\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, return corresponding val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // If key-value pair does not exist, return null\n    return null;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, overwrite val and return\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // If key-value pair does not exist, add the key-value pair\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, overwrite it with removal marker\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* Expand hash table */\n  void extend() {\n    // Temporarily store the original hash table\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // Initialize expanded new hash table\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* Hash table with open addressing */\nstruct HashMapOpenAddressing {\n    size: usize,                // Number of key-value pairs\n    capacity: usize,            // Hash table capacity\n    load_thres: f64,            // Load factor threshold for triggering expansion\n    extend_ratio: usize,        // Expansion multiplier\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // Bucket array\n    TOMBSTONE: Option&lt;Pair&gt;,    // Removal marker\n}\n\nimpl HashMapOpenAddressing {\n    /* Constructor */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* Load factor */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* Search for bucket index corresponding to key */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while self.buckets[index].is_some() {\n            // If key is found, return corresponding bucket index\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // If deletion marker was encountered before, move key-value pair to that index\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % self.capacity;\n        }\n        // If key does not exist, return the index for insertion\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* Query operation */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, return corresponding val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // If key-value pair does not exist, return null\n        None\n    }\n\n    /* Add operation */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, overwrite val and return\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* Remove operation */\n    fn remove(&amp;mut self, key: i32) {\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* Expand hash table */\n    fn extend(&amp;mut self) {\n        // Temporarily store the original hash table\n        let buckets_tmp = self.buckets.clone();\n        // Initialize expanded new hash table\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // Move key-value pairs from original hash table to new hash table\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* Print hash table */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* Hash table with open addressing */\ntypedef struct {\n    int size;         // Number of key-value pairs\n    int capacity;     // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio;  // Expansion multiplier\n    Pair **buckets;   // Bucket array\n    Pair *TOMBSTONE;  // Removal marker\n} HashMapOpenAddressing;\n\n/* Constructor */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* Destructor */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* Hash function */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Load factor */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Search for bucket index corresponding to key */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // Linear probing, break when encountering an empty bucket\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // If key is encountered, return the corresponding bucket index\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // If a removal marker was encountered before, move the key-value pair to that index\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // Return the moved bucket index\n            }\n            return index; // Return bucket index\n        }\n        // Record the first removal marker encountered\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // Calculate bucket index, wrap around to the head if past the tail\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // If key does not exist, return the index for insertion\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* Query operation */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, return corresponding val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // Return empty string if key-value pair does not exist\n    return \"\";\n}\n\n/* Add operation */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, overwrite val and return\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // If key-value pair does not exist, add the key-value pair\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* Remove operation */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, overwrite it with removal marker\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* Expand hash table */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // Temporarily store the original hash table\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // Initialize expanded new hash table\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* Print hash table */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private var size: Int               // Number of key-value pairs\n    private var capacity: Int           // Hash table capacity\n    private val loadThres: Double       // Load factor threshold for triggering expansion\n    private val extendRatio: Int        // Expansion multiplier\n    private var buckets: Array&lt;Pair?&gt;   // Bucket array\n    private val TOMBSTONE: Pair         // Removal marker\n\n    /* Constructor */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Load factor */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Search for bucket index corresponding to key */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index]?.key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Return the moved bucket index\n                }\n                return index // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity\n        }\n        // If key does not exist, return the index for insertion\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // If key-value pair does not exist, return null\n        return null\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* Expand hash table */\n    fun extend() {\n        // Temporarily store the original hash table\n        val bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### Hash map with open addressing ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # Removal marker\n\n  ### Constructor ###\n  def initialize\n    @size = 0 # Number of key-value pairs\n    @capacity = 4 # Hash table capacity\n    @load_thres = 2.0 / 3.0 # Load factor threshold for triggering expansion\n    @extend_ratio = 2 # Expansion multiplier\n    @buckets = Array.new(@capacity) # Bucket array\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Load factor ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Search bucket index for key ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # Linear probing, break when encountering an empty bucket\n    while !@buckets[index].nil?\n      # If key is encountered, return the corresponding bucket index\n      if @buckets[index].key == key\n        # If a removal marker was encountered before, move the key-value pair to that index\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # Return the moved bucket index\n        end\n        return index # Return bucket index\n      end\n      # Record the first removal marker encountered\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # Calculate bucket index, wrap around to the head if past the tail\n      index = (index + 1) % @capacity\n    end\n    # If key does not exist, return the index for insertion\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### Query operation ###\n  def get(key)\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair is found, return corresponding val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # Return nil if key-value pair does not exist\n    nil\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    # When load factor exceeds threshold, perform expansion\n    extend if load_factor &gt; @load_thres\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair found, overwrite val and return\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # If key-value pair does not exist, add the key-value pair\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair is found, overwrite it with removal marker\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### Expand hash table ###\n  def extend\n    # Temporarily store the original hash table\n    buckets_tmp = @buckets\n    # Initialize expanded new hash table\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # Move key-value pairs from original hash table to new hash table\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### Print hash table ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2-quadratic-probing","level":3,"title":"2.   Quadratic Probing","text":"<p>Quadratic probing is similar to linear probing and is one of the common strategies for open addressing. When a collision occurs, quadratic probing does not simply skip a fixed number of steps but skips a number of steps equal to the \"square of the number of probes\", i.e., \\(1, 4, 9, \\dots\\) steps.</p> <p>Quadratic probing has the following advantages:</p> <ul> <li>Quadratic probing attempts to alleviate the clustering effect of linear probing by skipping distances equal to the square of the probe count.</li> <li>Quadratic probing skips larger distances to find empty positions, which helps to distribute data more evenly.</li> </ul> <p>However, quadratic probing is not perfect:</p> <ul> <li>Clustering still exists, i.e., some positions are more likely to be occupied than others.</li> <li>Due to the growth of squares, quadratic probing may not probe the entire hash table, meaning that even if there are empty buckets in the hash table, quadratic probing may not be able to access them.</li> </ul>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3-double-hashing","level":3,"title":"3.   Double Hashing","text":"<p>As the name suggests, the double hashing method uses multiple hash functions \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) for probing.</p> <ul> <li>Inserting elements: If hash function \\(f_1(x)\\) encounters a conflict, try \\(f_2(x)\\), and so on, until an empty position is found and the element is inserted.</li> <li>Searching for elements: Search in the same order of hash functions until the target element is found and return it; if an empty position is encountered or all hash functions have been tried, it indicates the element is not in the hash table, then return <code>None</code>.</li> </ul> <p>Compared to linear probing, the double hashing method is less prone to clustering, but multiple hash functions introduce additional computational overhead.</p> <p>Tip</p> <p>Please note that open addressing (linear probing, quadratic probing, and double hashing) hash tables all have the problem of \"cannot directly delete elements\".</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623-choice-of-programming-languages","level":2,"title":"6.2.3   Choice of Programming Languages","text":"<p>Different programming languages adopt different hash table implementation strategies. Here are a few examples:</p> <ul> <li>Python uses open addressing. The <code>dict</code> dictionary uses pseudo-random numbers for probing.</li> <li>Java uses separate chaining. Since JDK 1.8, when the array length in <code>HashMap</code> reaches 64 and the length of a linked list reaches 8, the linked list is converted to a red-black tree to improve search performance.</li> <li>Go uses separate chaining. Go stipulates that each bucket can store up to 8 key-value pairs, and if the capacity is exceeded, an overflow bucket is linked; when there are too many overflow buckets, a special equal-capacity expansion operation is performed to ensure performance.</li> </ul>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   Hash Table","text":"<p>A hash table, also known as a hash map, establishes a mapping between keys <code>key</code> and values <code>value</code>, enabling efficient element retrieval. Specifically, when we input a key <code>key</code> into a hash table, we can retrieve the corresponding value <code>value</code> in \\(O(1)\\) time.</p> <p>As shown in Figure 6-1, given \\(n\\) students, each with two pieces of data: \"name\" and \"student ID\". If we want to implement a query function that \"inputs a student ID and returns the corresponding name\", we can use the hash table shown below.</p> <p></p> <p> Figure 6-1   Abstract representation of a hash table </p> <p>In addition to hash tables, arrays and linked lists can also implement query functionality. Their efficiency comparison is shown in the following table.</p> <ul> <li>Adding elements: Simply add elements to the end of the array (linked list), using \\(O(1)\\) time.</li> <li>Querying elements: Since the array (linked list) is unordered, all elements need to be traversed, using \\(O(n)\\) time.</li> <li>Deleting elements: The element must first be located, then deleted from the array (linked list), using \\(O(n)\\) time.</li> </ul> <p> Table 6-1   Comparison of element query efficiency </p> Array Linked List Hash Table Find element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Add element \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Delete element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>As observed, the time complexity for insertion, deletion, search, and modification operations in a hash table is \\(O(1)\\), which is very efficient.</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#611-common-hash-table-operations","level":2,"title":"6.1.1   Common Hash Table Operations","text":"<p>Common operations on hash tables include: initialization, query operations, adding key-value pairs, and deleting key-value pairs. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Initialize hash table\nhmap: dict = {}\n\n# Add operation\n# Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n# Query operation\n# Input key into hash table to get value\nname: str = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* Initialize hash table */\nunordered_map&lt;int, string&gt; map;\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\";\nmap[15937] = \"XiaoLuo\";\nmap[16750] = \"XiaoSuan\";\nmap[13276] = \"XiaoFa\";\nmap[10583] = \"XiaoYa\";\n\n/* Query operation */\n// Input key into hash table to get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* Initialize hash table */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.put(12836, \"XiaoHa\");\nmap.put(15937, \"XiaoLuo\");\nmap.put(16750, \"XiaoSuan\");\nmap.put(13276, \"XiaoFa\");\nmap.put(10583, \"XiaoYa\");\n\n/* Query operation */\n// Input key into hash table to get value\nString name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* Initialize hash table */\nDictionary&lt;int, string&gt; map = new() {\n    /* Add operation */\n    // Add key-value pair (key, value) to hash table\n    { 12836, \"XiaoHa\" },\n    { 15937, \"XiaoLuo\" },\n    { 16750, \"XiaoSuan\" },\n    { 13276, \"XiaoFa\" },\n    { 10583, \"XiaoYa\" }\n};\n\n/* Query operation */\n// Input key into hash table to get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* Initialize hash table */\nhmap := make(map[int]string)\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nname := hmap[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* Initialize hash table */\nvar map: [Int: String] = [:]\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\"\nmap[15937] = \"XiaoLuo\"\nmap[16750] = \"XiaoSuan\"\nmap[13276] = \"XiaoFa\"\nmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map[15937]!\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* Initialize hash table */\nconst map = new Map();\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.set(12836, 'XiaoHa');\nmap.set(15937, 'XiaoLuo');\nmap.set(16750, 'XiaoSuan');\nmap.set(13276, 'XiaoFa');\nmap.set(10583, 'XiaoYa');\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* Initialize hash table */\nconst map = new Map&lt;number, string&gt;();\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.set(12836, 'XiaoHa');\nmap.set(15937, 'XiaoLuo');\nmap.set(16750, 'XiaoSuan');\nmap.set(13276, 'XiaoFa');\nmap.set(10583, 'XiaoYa');\nconsole.info('\\nAfter adding, hash table is\\nKey -&gt; Value');\nconsole.info(map);\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map.get(15937);\nconsole.info('\\nInput student ID 15937, queried name ' + name);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\nconsole.info('\\nAfter deleting 10583, hash table is\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* Initialize hash table */\nMap&lt;int, String&gt; map = {};\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\";\nmap[15937] = \"XiaoLuo\";\nmap[16750] = \"XiaoSuan\";\nmap[13276] = \"XiaoFa\";\nmap[10583] = \"XiaoYa\";\n\n/* Query operation */\n// Input key into hash table to get value\nString name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* Initialize hash table */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.insert(12836, \"XiaoHa\".to_string());\nmap.insert(15937, \"XiaoLuo\".to_string());\nmap.insert(16750, \"XiaoSuan\".to_string());\nmap.insert(13279, \"XiaoFa\".to_string());\nmap.insert(10583, \"XiaoYa\".to_string());\n\n/* Query operation */\n// Input key into hash table to get value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C does not provide a built-in hash table\n</code></pre> hash_map.kt<pre><code>/* Initialize hash table */\nval map = HashMap&lt;Int,String&gt;()\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\"\nmap[15937] = \"XiaoLuo\"\nmap[16750] = \"XiaoSuan\"\nmap[13276] = \"XiaoFa\"\nmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nval name = map[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># Initialize hash table\nhmap = {}\n\n# Add operation\n# Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n# Query operation\n# Input key into hash table to get value\nname = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.delete(10583)\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%9F%A5%E8%AF%A2%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%90%91%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E8%BE%93%E5%85%A5%E9%94%AE%20key%20%EF%BC%8C%E5%BE%97%E5%88%B0%E5%80%BC%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E5%88%A0%E9%99%A4%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>There are three common ways to traverse a hash table: traversing key-value pairs, traversing keys, and traversing values. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Traverse hash table\n# Traverse key-value pairs key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# Traverse keys only\nfor key in hmap.keys():\n    print(key)\n# Traverse values only\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// Traverse using iterator key-&gt;value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor (Map.Entry&lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// Traverse keys only\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Traverse values only\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// Traverse keys only\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Traverse values only\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// Traverse keys only\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Traverse values only\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// Traverse keys only\nfor key in map.keys {\n    print(key)\n}\n// Traverse values only\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// Traverse keys only\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// Traverse values only\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// Traverse keys only\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// Traverse values only\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C does not provide a built-in hash table\n</code></pre> hash_map.kt<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// Traverse keys only\nfor (key in map.keys) {\n    println(key)\n}\n// Traverse values only\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># Traverse hash table\n# Traverse key-value pairs key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# Traverse keys only\nhmap.keys.each { |key| puts key }\n\n# Traverse values only\nhmap.values.each { |val| puts val }\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E9%94%AE%E5%80%BC%E5%AF%B9%20key-%3Evalue%0A%20%20%20%20for%20key,%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key,%20%22-%3E%22,%20value%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E9%94%AE%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E5%80%BC%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#612-simple-hash-table-implementation","level":2,"title":"6.1.2   Simple Hash Table Implementation","text":"<p>Let's first consider the simplest case: implementing a hash table using only an array. In a hash table, each empty position in the array is called a bucket, and each bucket can store a key-value pair. Therefore, the query operation is to find the bucket corresponding to <code>key</code> and retrieve the <code>value</code> from the bucket.</p> <p>So how do we locate the corresponding bucket based on <code>key</code>? This is achieved through a hash function. The role of the hash function is to map a larger input space to a smaller output space. In a hash table, the input space is all <code>key</code>s, and the output space is all buckets (array indices). In other words, given a <code>key</code>, we can use the hash function to obtain the storage location of the key-value pair corresponding to that <code>key</code> in the array.</p> <p>When inputting a <code>key</code>, the hash function's calculation process consists of the following two steps:</p> <ol> <li>Calculate the hash value through a hash algorithm <code>hash()</code>.</li> <li>Take the modulo of the hash value by the number of buckets (array length) <code>capacity</code> to obtain the bucket (array index) <code>index</code> corresponding to that <code>key</code>.</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Subsequently, we can use <code>index</code> to access the corresponding bucket in the hash table and retrieve the <code>value</code>.</p> <p>Assuming the array length is <code>capacity = 100</code> and the hash algorithm is <code>hash(key) = key</code>, the hash function becomes <code>key % 100</code>. Figure 6-2 shows the working principle of the hash function using <code>key</code> as student ID and <code>value</code> as name.</p> <p></p> <p> Figure 6-2   Working principle of hash function </p> <p>The following code implements a simple hash table. Here, we encapsulate <code>key</code> and <code>value</code> into a class <code>Pair</code> to represent a key-value pair.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"Key-value pair\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"Hash table based on array implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        # Initialize array with 100 buckets\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Query operation\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"Add and update operation\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        index: int = self.hash_func(key)\n        # Set to None to represent removal\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"Get all key-value pairs\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"Get all keys\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"Get all values\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* Key-value pair */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // Free memory\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // Free memory and set to nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* Get all key-value pairs */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* Key-value pair */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* Hash function */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* Remove operation */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // Set to null to represent deletion\n        buckets.set(index, null);\n    }\n\n    /* Get all key-value pairs */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* Key-value pair int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Set to null to represent deletion\n        buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* Key-value pair */\ntype pair struct {\n    key int\n    val string\n}\n\n/* Hash table based on array implementation */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* Initialize hash table */\nfunc newArrayHashMap() *arrayHashMap {\n    // Initialize array with 100 buckets\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* Hash function */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* Query operation */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* Add operation */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* Remove operation */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // Set to nil to delete\n    a.buckets[index] = nil\n}\n\n/* Get all key pairs */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* Get all keys */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* Get all values */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* Print hash table */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* Key-value pair */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // Initialize array with 100 buckets\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* Hash function */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // Set to nil to delete\n        buckets[index] = nil\n    }\n\n    /* Get all key-value pairs */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* Get all keys */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* Get all values */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* Print hash table */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* Key-value pair Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // Initialize array with 100 buckets\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* Query operation */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* Remove operation */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // Set to null to represent deletion\n        this.#buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all keys */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all values */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Print hash table */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* Key-value pair Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // Initialize array with 100 buckets\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* Hash function */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* Query operation */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* Remove operation */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // Set to null to represent deletion\n        this.buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all keys */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all values */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Print hash table */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* Key-value pair */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // Initialize array with 100 buckets\n    _buckets = List.filled(100, null);\n  }\n\n  /* Hash function */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* Get all key-value pairs */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* Get all keys */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* Get all values */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* Key-value pair */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* Hash table based on array implementation */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // Initialize array with 100 buckets\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* Query operation */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* Add operation */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* Remove operation */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // Set to None to represent removal\n        self.buckets[index] = None;\n    }\n\n    /* Get all key-value pairs */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* Get all keys */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* Get all values */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* Print hash table */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* Key-value pair int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* Hash table based on array implementation */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* Constructor */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* Destructor */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* Add operation */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* Remove operation */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* Get all key-value pairs */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* Get all keys */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* Get all values */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* Print hash table */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* Key-value pair */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    // Initialize array with 100 buckets\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // Set to null to represent deletion\n        buckets[index] = null\n    }\n\n    /* Get all key-value pairs */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* Get all keys */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* Get all values */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### Key-value pair ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### Hash map based on array ###\nclass ArrayHashMap\n  ### Constructor ###\n  def initialize\n    # Initialize array with 100 buckets\n    @buckets = Array.new(100)\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### Query operation ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    index = hash_func(key)\n    # Set to nil to delete\n    @buckets[index] = nil\n  end\n\n  ### Get all key-value pairs ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### Get all keys ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### Get all values ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### Print hash table ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#613-hash-collision-and-resizing","level":2,"title":"6.1.3   Hash Collision and Resizing","text":"<p>Fundamentally, the role of a hash function is to map the input space consisting of all <code>key</code>s to the output space consisting of all array indices, and the input space is often much larger than the output space. Therefore, theoretically there must be cases where \"multiple inputs correspond to the same output\".</p> <p>For the hash function in the above example, when the input <code>key</code>s have the same last two digits, the hash function produces the same output. For example, when querying two students with IDs 12836 and 20336, we get:</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>As shown in Figure 6-3, two student IDs point to the same name, which is obviously incorrect. We call this situation where multiple inputs correspond to the same output a hash collision.</p> <p></p> <p> Figure 6-3   Hash collision example </p> <p>It's easy to see that the larger the hash table capacity \\(n\\), the lower the probability that multiple <code>key</code>s will be assigned to the same bucket, and the fewer collisions. Therefore, we can reduce hash collisions by expanding the hash table.</p> <p>As shown in Figure 6-4, before expansion, the key-value pairs <code>(136, A)</code> and <code>(236, D)</code> collided, but after expansion, the collision disappears.</p> <p></p> <p> Figure 6-4   Hash table resizing </p> <p>Similar to array expansion, hash table expansion requires migrating all key-value pairs from the original hash table to the new hash table, which is very time-consuming. Moreover, since the hash table capacity <code>capacity</code> changes, we need to recalculate the storage locations of all key-value pairs through the hash function, further increasing the computational overhead of the expansion process. For this reason, programming languages typically reserve a sufficiently large hash table capacity to prevent frequent expansion.</p> <p>The load factor is an important concept for hash tables. It is defined as the number of elements in the hash table divided by the number of buckets, and is used to measure the severity of hash collisions. It is also commonly used as a trigger condition for hash table expansion. For example, in Java, when the load factor exceeds \\(0.75\\), the system will expand the hash table to \\(2\\) times its original size.</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   Summary","text":"","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Given an input <code>key</code>, a hash table can retrieve the corresponding <code>value</code> in \\(O(1)\\) time, which is highly efficient.</li> <li>Common hash table operations include querying, adding key-value pairs, deleting key-value pairs, and traversing the hash table.</li> <li>The hash function maps a <code>key</code> to an array index, allowing access to the corresponding bucket and retrieval of the <code>value</code>.</li> <li>Two different keys may end up with the same array index after hashing, leading to erroneous query results. This phenomenon is known as hash collision.</li> <li>The larger the capacity of the hash table, the lower the probability of hash collisions. Therefore, hash table expansion can mitigate hash collisions. Similar to array expansion, hash table expansion is costly.</li> <li>The load factor, defined as the number of elements divided by the number of buckets, reflects the severity of hash collisions and is often used as a condition to trigger hash table expansion.</li> <li>Separate chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same linked list. However, excessively long linked lists can reduce query efficiency, which can be improved by converting the linked lists into red-black trees.</li> <li>Open addressing handles hash collisions through multiple probing. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Double hashing uses multiple hash functions for probing, which reduces clustering compared to linear probing but increases computational overhead.</li> <li>Different programming languages adopt various hash table implementations. For example, Java's <code>HashMap</code> uses separate chaining, while Python's <code>dict</code> employs open addressing.</li> <li>In hash tables, we desire hash algorithms with determinism, high efficiency, and uniform distribution. In cryptography, hash algorithms should also possess collision resistance and the avalanche effect.</li> <li>Hash algorithms typically use large prime numbers as moduli to maximize the uniform distribution of hash values and reduce hash collisions.</li> <li>Common hash algorithms include MD5, SHA-1, SHA-2, and SHA-3. MD5 is often used for file integrity checks, while SHA-2 is commonly used in secure applications and protocols.</li> <li>Programming languages usually provide built-in hash algorithms for data types to calculate bucket indices in hash tables. Generally, only immutable objects are hashable.</li> </ul>","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: When does the time complexity of a hash table degrade to \\(O(n)\\)?</p> <p>The time complexity of a hash table can degrade to \\(O(n)\\) when hash collisions are severe. When the hash function is well-designed, the capacity is set appropriately, and collisions are evenly distributed, the time complexity is \\(O(1)\\). We usually consider the time complexity to be \\(O(1)\\) when using built-in hash tables in programming languages.</p> <p>Q: Why not use the hash function \\(f(x) = x\\)? This would eliminate collisions.</p> <p>Under the hash function \\(f(x) = x\\), each element corresponds to a unique bucket index, which is equivalent to an array. However, the input space is usually much larger than the output space (array length), so the last step of a hash function is often to take the modulo of the array length. In other words, the goal of a hash table is to map a larger state space to a smaller one while providing \\(O(1)\\) query efficiency.</p> <p>Q: Why can hash tables be more efficient than arrays, linked lists, or binary trees, even though hash tables are implemented using these structures?</p> <p>Firstly, hash tables have higher time efficiency but lower space efficiency. A significant portion of memory in hash tables remains unused.</p> <p>Secondly, hash tables are only more time-efficient in specific use cases. If a feature can be implemented with the same time complexity using an array or a linked list, it's usually faster than using a hash table. This is because the computation of the hash function incurs overhead, making the constant factor in the time complexity larger.</p> <p>Lastly, the time complexity of hash tables can degrade. For example, in separate chaining, we perform search operations in a linked list or red-black tree, which still risks degrading to \\(O(n)\\) time.</p> <p>Q: Does double hashing also have the flaw of not being able to delete elements directly? Can space marked as deleted be reused?</p> <p>Double hashing is a form of open addressing, and all open addressing methods have the drawback of not being able to delete elements directly; they require marking elements as deleted. Marked spaces can be reused. When inserting new elements into the hash table, and the hash function points to a position marked as deleted, that position can be used by the new element. This maintains the probing sequence of the hash table while ensuring efficient use of space.</p> <p>Q: Why do hash collisions occur during the search process in linear probing?</p> <p>During the search process, the hash function points to the corresponding bucket and key-value pair. If the <code>key</code> doesn't match, it indicates a hash collision. Therefore, linear probing will search downward at a predetermined step size until the correct key-value pair is found or the search fails.</p> <p>Q: Why can expanding a hash table alleviate hash collisions?</p> <p>The last step of a hash function often involves taking the modulo of the array length \\(n\\), to keep the output within the array index range. When expanding, the array length \\(n\\) changes, and the indices corresponding to the keys may also change. Keys that were previously mapped to the same bucket might be distributed across multiple buckets after expansion, thereby mitigating hash collisions.</p>","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"Chapter 8.   Heap","text":"<p>Abstract</p> <p>Heaps are like mountain peaks, layered and undulating, each with its unique form.</p> <p>The peaks rise and fall at varying heights, yet the tallest peak always catches the eye first.</p>","path":["Chapter 8. Heap","Chapter 8. &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>8.1   Heap</li> <li>8.2   Building a Heap</li> <li>8.3   Top-K Problem</li> <li>8.4   Summary</li> </ul>","path":["Chapter 8. Heap","Chapter 8. &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   Heap Construction Operation","text":"<p>In some cases, we want to build a heap using all elements of a list, and this process is called \"heap construction operation.\"</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#821-implementing-with-element-insertion","level":2,"title":"8.2.1   Implementing with Element Insertion","text":"<p>We first create an empty heap, then iterate through the list, performing the \"element insertion operation\" on each element in sequence. This means adding the element to the bottom of the heap and then performing \"bottom-to-top\" heapify on that element.</p> <p>Each time an element is inserted into the heap, the heap's length increases by one. Since nodes are added to the binary tree sequentially from top to bottom, the heap is constructed \"from top to bottom.\"</p> <p>Given \\(n\\) elements, each element's insertion operation takes \\(O(\\log{n})\\) time, so the time complexity of this heap construction method is \\(O(n \\log n)\\).</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#822-implementing-through-heapify-traversal","level":2,"title":"8.2.2   Implementing Through Heapify Traversal","text":"<p>In fact, we can implement a more efficient heap construction method in two steps.</p> <ol> <li>Add all elements of the list as-is to the heap, at which point the heap property is not yet satisfied.</li> <li>Traverse the heap in reverse order (reverse of level-order traversal), performing \"top-to-bottom heapify\" on each non-leaf node in sequence.</li> </ol> <p>After heapifying a node, the subtree rooted at that node becomes a valid sub-heap. Since we traverse in reverse order, the heap is constructed \"from bottom to top.\"</p> <p>The reason for choosing reverse order traversal is that it ensures the subtree below the current node is already a valid sub-heap, making the heapification of the current node effective.</p> <p>It's worth noting that since leaf nodes have no children, they are naturally valid sub-heaps and do not require heapification. As shown in the code below, the last non-leaf node is the parent of the last node; we start from it and traverse in reverse order to perform heapification:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"Constructor, build heap based on input list\"\"\"\n    # Add list elements to heap as is\n    self.max_heap = nums\n    # Heapify all nodes except leaf nodes\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(vector&lt;int&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = nums;\n    // Heapify all nodes except leaf nodes\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // Heapify all nodes except leaf nodes\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Constructor, build heap from input list */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = new List&lt;int&gt;(nums);\n    // Heapify all nodes except leaf nodes\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Constructor, build heap from slice */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // Add list elements to heap as is\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // Heapify all nodes except leaf nodes\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* Constructor, build heap based on input list */\ninit(nums: [Int]) {\n    // Add list elements to heap as is\n    maxHeap = nums\n    // Heapify all nodes except leaf nodes\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Constructor, build empty heap or build heap from input list */\nconstructor(nums) {\n    // Add list elements to heap as is\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // Heapify all nodes except leaf nodes\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Constructor, build empty heap or build heap from input list */\nconstructor(nums?: number[]) {\n    // Add list elements to heap as is\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // Heapify all nodes except leaf nodes\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(List&lt;int&gt; nums) {\n  // Add list elements to heap as is\n  _maxHeap = nums;\n  // Heapify all nodes except leaf nodes\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Constructor, build heap based on input list */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // Add list elements to heap as is\n    let mut heap = MaxHeap { max_heap: nums };\n    // Heapify all nodes except leaf nodes\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* Constructor, build heap from slice */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // Push all elements to heap\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // Heapify all nodes except leaf nodes\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* Max heap */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // Use list instead of array, no need to consider capacity expansion\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* Constructor, build heap based on input list */\n    init {\n        // Add list elements to heap as is\n        maxHeap.addAll(nums!!)\n        // Heapify all nodes except leaf nodes\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* Get index of left child node */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Get index of right child node */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Get index of parent node */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // Floor division\n    }\n\n    /* Swap elements */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* Get heap size */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* Check if heap is empty */\n    fun isEmpty(): Boolean {\n        /* Check if heap is empty */\n        return size() == 0\n    }\n\n    /* Access top element */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* Element enters heap */\n    fun push(_val: Int) {\n        // Add node\n        maxHeap.add(_val)\n        // Heapify from bottom to top\n        siftUp(size() - 1)\n    }\n\n    /* Starting from node i, heapify from bottom to top */\n    private fun siftUp(it: Int) {\n        // Kotlin function parameters are immutable, so create temporary variable\n        var i = it\n        while (true) {\n            // Get parent node of node i\n            val p = parent(i)\n            // When \"crossing root node\" or \"node needs no repair\", end heapify\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // Swap two nodes\n            swap(i, p)\n            // Loop upward heapify\n            i = p\n        }\n    }\n\n    /* Element exits heap */\n    fun pop(): Int {\n        // Handle empty case\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Delete node\n        swap(0, size() - 1)\n        // Remove node\n        val _val = maxHeap.removeAt(size() - 1)\n        // Return top element\n        siftDown(0)\n        // Return heap top element\n        return _val\n    }\n\n    /* Starting from node i, heapify from top to bottom */\n    private fun siftDown(it: Int) {\n        // Kotlin function parameters are immutable, so create temporary variable\n        var i = it\n        while (true) {\n            // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // Swap two nodes\n            if (ma == i) break\n            // Swap two nodes\n            swap(i, ma)\n            // Loop downwards heapification\n            i = ma\n        }\n    }\n\n    /* Driver Code */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Constructor, build heap from input list ###\ndef initialize(nums)\n  # Add list elements to heap as is\n  @max_heap = nums\n  # Heapify all nodes except leaf nodes\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#823-complexity-analysis","level":2,"title":"8.2.3   Complexity Analysis","text":"<p>Next, let's attempt to derive the time complexity of this second heap construction method.</p> <ul> <li>Assuming the complete binary tree has \\(n\\) nodes, then the number of leaf nodes is \\((n + 1) / 2\\), where \\(/\\) is floor division. Therefore, the number of nodes that need heapification is \\((n - 1) / 2\\).</li> <li>In the top-to-bottom heapify process, each node is heapified at most to the leaf nodes, so the maximum number of iterations is the binary tree height \\(\\log n\\).</li> </ul> <p>Multiplying these two together, we get a time complexity of \\(O(n \\log n)\\) for the heap construction process. However, this estimate is not accurate because it doesn't account for the property that binary trees have far more nodes at lower levels than at upper levels.</p> <p>Let's perform a more accurate calculation. To reduce calculation difficulty, assume a \"perfect binary tree\" with \\(n\\) nodes and height \\(h\\); this assumption does not affect the correctness of the result.</p> <p></p> <p> Figure 8-5   Node count at each level of a perfect binary tree </p> <p>As shown in Figure 8-5, the maximum number of iterations for a node's \"top-to-bottom heapify\" equals the distance from that node to the leaf nodes, which is precisely the \"node height.\" Therefore, we can sum the \"number of nodes \\(\\times\\) node height\" at each level to obtain the total number of heapify iterations for all nodes.</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>To simplify the above expression, we need to use sequence knowledge from high school. First, multiply \\(T(h)\\) by \\(2\\) to get:</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>Using the method of differences, subtract the first equation \\(T(h)\\) from the second equation \\(2 T(h)\\) to get:</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>Observing the above expression, we find that \\(T(h)\\) is a geometric series, which can be calculated directly using the sum formula, yielding a time complexity of:</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>Furthermore, a perfect binary tree with height \\(h\\) has \\(n = 2^{h+1} - 1\\) nodes, so the complexity is \\(O(2^h) = O(n)\\). This derivation shows that the time complexity of building a heap from an input list is \\(O(n)\\), which is highly efficient.</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   Heap","text":"<p>A heap is a complete binary tree that satisfies specific conditions and can be mainly categorized into two types, as shown in Figure 8-1.</p> <ul> <li>min heap: The value of any node \\(\\leq\\) the values of its child nodes.</li> <li>max heap: The value of any node \\(\\geq\\) the values of its child nodes.</li> </ul> <p></p> <p> Figure 8-1   Min heap and max heap </p> <p>As a special case of a complete binary tree, heaps have the following characteristics.</p> <ul> <li>The bottom layer nodes are filled from left to right, and nodes in other layers are fully filled.</li> <li>We call the root node of the binary tree the \"heap top\" and the bottom-rightmost node the \"heap bottom.\"</li> <li>For max heaps (min heaps), the value of the heap top element (root node) is the largest (smallest).</li> </ul>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#811-common-heap-operations","level":2,"title":"8.1.1   Common Heap Operations","text":"<p>It should be noted that many programming languages provide a priority queue, which is an abstract data structure defined as a queue with priority sorting.</p> <p>In fact, heaps are typically used to implement priority queues, with max heaps corresponding to priority queues where elements are dequeued in descending order. From a usage perspective, we can regard \"priority queue\" and \"heap\" as equivalent data structures. Therefore, this book does not make a special distinction between the two and uniformly refers to them as \"heap.\"</p> <p>Common heap operations are shown in Table 8-1, and method names need to be determined based on the programming language.</p> <p> Table 8-1   Efficiency of Heap Operations </p> Method name Description Time complexity <code>push()</code> Insert an element into the heap \\(O(\\log n)\\) <code>pop()</code> Remove the heap top element \\(O(\\log n)\\) <code>peek()</code> Access the heap top element (max/min value for max/min heap) \\(O(1)\\) <code>size()</code> Get the number of elements in the heap \\(O(1)\\) <code>isEmpty()</code> Check if the heap is empty \\(O(1)\\) <p>In practical applications, we can directly use the heap class (or priority queue class) provided by programming languages.</p> <p>Similar to \"ascending order\" and \"descending order\" in sorting algorithms, we can implement conversion between \"min heap\" and \"max heap\" by setting a <code>flag</code> or modifying the <code>Comparator</code>. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># Initialize a min heap\nmin_heap, flag = [], 1\n# Initialize a max heap\nmax_heap, flag = [], -1\n\n# Python's heapq module implements a min heap by default\n# Consider negating elements before pushing them to the heap, which inverts the size relationship and thus implements a max heap\n# In this example, flag = 1 corresponds to a min heap, flag = -1 corresponds to a max heap\n\n# Push elements into the heap\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# Get the heap top element\npeek: int = flag * max_heap[0] # 5\n\n# Remove the heap top element\n# The removed elements will form a descending sequence\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# Get the heap size\nsize: int = len(max_heap)\n\n# Check if the heap is empty\nis_empty: bool = not max_heap\n\n# Build a heap from an input list\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* Initialize a heap */\n// Initialize a min heap\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// Initialize a max heap\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* Push elements into the heap */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* Get the heap top element */\nint peek = maxHeap.top(); // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* Get the heap size */\nint size = maxHeap.size();\n\n/* Check if the heap is empty */\nbool isEmpty = maxHeap.empty();\n\n/* Build a heap from an input list */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* Initialize a heap */\n// Initialize a min heap\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// Initialize a max heap (use lambda expression to modify Comparator)\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* Push elements into the heap */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* Get the heap top element */\nint peek = maxHeap.peek(); // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* Get the heap size */\nint size = maxHeap.size();\n\n/* Check if the heap is empty */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* Build a heap from an input list */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* Initialize a heap */\n// Initialize a min heap\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// Initialize a max heap (use lambda expression to modify Comparer)\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* Push elements into the heap */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* Get the heap top element */\nint peek = maxHeap.Peek();//5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* Get the heap size */\nint size = maxHeap.Count;\n\n/* Check if the heap is empty */\nbool isEmpty = maxHeap.Count == 0;\n\n/* Build a heap from an input list */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// In Go, we can construct a max heap of integers by implementing heap.Interface\n// Implementing heap.Interface also requires implementing sort.Interface\ntype intHeap []any\n\n// Push implements the heap.Interface method for pushing an element into the heap\nfunc (h *intHeap) Push(x any) {\n    // Push and Pop use pointer receiver as parameters\n    // because they not only adjust the slice contents but also modify the slice length\n    *h = append(*h, x.(int))\n}\n\n// Pop implements the heap.Interface method for popping the heap top element\nfunc (h *intHeap) Pop() any {\n    // The element to be removed is stored at the end\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len is a sort.Interface method\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less is a sort.Interface method\nfunc (h *intHeap) Less(i, j int) bool {\n    // To implement a min heap, change this to a less-than sign\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap is a sort.Interface method\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top gets the heap top element\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* Initialize a heap */\n    // Initialize a max heap\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* Push elements into the heap */\n    // Call heap.Interface methods to add elements\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* Get the heap top element */\n    top := maxHeap.Top()\n    fmt.Printf(\"Heap top element is %d\\n\", top)\n\n    /* Remove the heap top element */\n    // Call heap.Interface methods to remove elements\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* Get the heap size */\n    size := len(*maxHeap)\n    fmt.Printf(\"Number of heap elements is %d\\n\", size)\n\n    /* Check if the heap is empty */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"Is the heap empty? %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* Initialize a heap */\n// Swift's Heap type supports both max heaps and min heaps, and requires importing swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* Push elements into the heap */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* Get the heap top element */\nvar peek = heap.max()!\n\n/* Remove the heap top element */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* Get the heap size */\nlet size = heap.count\n\n/* Check if the heap is empty */\nlet isEmpty = heap.isEmpty\n\n/* Build a heap from an input list */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript does not provide a built-in Heap class\n</code></pre> heap.ts<pre><code>// TypeScript does not provide a built-in Heap class\n</code></pre> heap.dart<pre><code>// Dart does not provide a built-in Heap class\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* Initialize a heap */\n// Initialize a min heap\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// Initialize a max heap\nlet mut max_heap = BinaryHeap::new();\n\n/* Push elements into the heap */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* Get the heap top element */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* Get the heap size */\nlet size = max_heap.len();\n\n/* Check if the heap is empty */\nlet is_empty = max_heap.is_empty();\n\n/* Build a heap from an input list */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C does not provide a built-in Heap class\n</code></pre> heap.kt<pre><code>/* Initialize a heap */\n// Initialize a min heap\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// Initialize a max heap (use lambda expression to modify Comparator)\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* Push elements into the heap */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* Get the heap top element */\nvar peek = maxHeap.peek() // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* Get the heap size */\nval size = maxHeap.size\n\n/* Check if the heap is empty */\nval isEmpty = maxHeap.isEmpty()\n\n/* Build a heap from an input list */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby does not provide a built-in Heap class\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#812-implementation-of-the-heap","level":2,"title":"8.1.2   Implementation of the Heap","text":"<p>The following implementation is of a max heap. To convert it to a min heap, simply invert all size logic comparisons (for example, replace \\(\\geq\\) with \\(\\leq\\)). Interested readers are encouraged to implement this on their own.</p>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#1-heap-storage-and-representation","level":3,"title":"1.   Heap Storage and Representation","text":"<p>As mentioned in the \"Binary Tree\" chapter, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, we will use arrays to store heaps.</p> <p>When representing a binary tree with an array, elements represent node values, and indexes represent node positions in the binary tree. Node pointers are implemented through index mapping formulas.</p> <p>As shown in Figure 8-2, given an index \\(i\\), the index of its left child is \\(2i + 1\\), the index of its right child is \\(2i + 2\\), and the index of its parent is \\((i - 1) / 2\\) (floor division). When an index is out of bounds, it indicates a null node or that the node does not exist.</p> <p></p> <p> Figure 8-2   Representation and storage of heaps </p> <p>We can encapsulate the index mapping formula into functions for convenient subsequent use:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"Get index of left child node\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"Get index of right child node\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"Get index of parent node\"\"\"\n    return (i - 1) // 2  # Floor division\n</code></pre> my_heap.cpp<pre><code>/* Get index of left child node */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.java<pre><code>/* Get index of left child node */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.cs<pre><code>/* Get index of left child node */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint Parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.go<pre><code>/* Get index of left child node */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* Get index of right child node */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* Get index of parent node */\nfunc (h *maxHeap) parent(i int) int {\n    // Floor division\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* Get index of left child node */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* Get index of right child node */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* Get index of parent node */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.js<pre><code>/* Get index of left child node */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // Floor division\n}\n</code></pre> my_heap.ts<pre><code>/* Get index of left child node */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // Floor division\n}\n</code></pre> my_heap.dart<pre><code>/* Get index of left child node */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // Floor division\n}\n</code></pre> my_heap.rs<pre><code>/* Get index of left child node */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* Get index of right child node */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* Get index of parent node */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.c<pre><code>/* Get index of left child node */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // Round down\n}\n</code></pre> my_heap.kt<pre><code>/* Get index of left child node */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* Get index of right child node */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* Get index of parent node */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.rb<pre><code>### Get left child index ###\ndef left(i)\n  2 * i + 1\nend\n\n### Get right child index ###\ndef right(i)\n  2 * i + 2\nend\n\n### Get parent node index ###\ndef parent(i)\n  (i - 1) / 2     # Floor division\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#2-accessing-the-heap-top-element","level":3,"title":"2.   Accessing the Heap Top Element","text":"<p>The heap top element is the root node of the binary tree, which is also the first element of the list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"Access top element\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* Access top element */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* Access top element */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* Access top element */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* Access top element */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* Access top element */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* Access top element */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* Access top element */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* Access top element */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* Access top element */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* Access top element */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* Access top element */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### Access heap top element ###\ndef peek\n  @max_heap[0]\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#3-inserting-an-element-into-the-heap","level":3,"title":"3.   Inserting an Element Into the Heap","text":"<p>Given an element <code>val</code>, we first add it to the bottom of the heap. After addition, since <code>val</code> may be larger than other elements in the heap, the heap's property may be violated. Therefore, it's necessary to repair the path from the inserted node to the root node. This operation is called heapify.</p> <p>Starting from the inserted node, perform heapify from bottom to top. As shown in Figure 8-3, we compare the inserted node with its parent node, and if the inserted node is larger, swap them. Then continue this operation, repairing nodes in the heap from bottom to top until we pass the root node or encounter a node that does not need swapping.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-3   Steps of inserting an element into the heap </p> <p>Given a total of \\(n\\) nodes, the tree height is \\(O(\\log n)\\). Thus, the number of loop iterations in the heapify operation is at most \\(O(\\log n)\\), making the time complexity of the element insertion operation \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"Element enters heap\"\"\"\n    # Add node\n    self.max_heap.append(val)\n    # Heapify from bottom to top\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"Starting from node i, heapify from bottom to top\"\"\"\n    while True:\n        # Get parent node of node i\n        p = self.parent(i)\n        # When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # Swap two nodes\n        self.swap(i, p)\n        # Loop upward heapify\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* Element enters heap */\nvoid push(int val) {\n    // Add node\n    maxHeap.push_back(val);\n    // Heapify from bottom to top\n    siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Swap two nodes\n        swap(maxHeap[i], maxHeap[p]);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Element enters heap */\nvoid push(int val) {\n    // Add node\n    maxHeap.add(val);\n    // Heapify from bottom to top\n    siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // Swap two nodes\n        swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Element enters heap */\nvoid Push(int val) {\n    // Add node\n    maxHeap.Add(val);\n    // Heapify from bottom to top\n    SiftUp(Size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid SiftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = Parent(i);\n        // If 'past root node' or 'node needs no repair', end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Swap two nodes\n        Swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Element enters heap */\nfunc (h *maxHeap) push(val any) {\n    // Add node\n    h.data = append(h.data, val)\n    // Heapify from bottom to top\n    h.siftUp(len(h.data) - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // Get parent node of node i\n        p := h.parent(i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // Swap two nodes\n        h.swap(i, p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Element enters heap */\nfunc push(val: Int) {\n    // Add node\n    maxHeap.append(val)\n    // Heapify from bottom to top\n    siftUp(i: size() - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // Get parent node of node i\n        let p = parent(i: i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // Swap two nodes\n        swap(i: i, j: p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Element enters heap */\npush(val) {\n    // Add node\n    this.#maxHeap.push(val);\n    // Heapify from bottom to top\n    this.#siftUp(this.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\n#siftUp(i) {\n    while (true) {\n        // Get parent node of node i\n        const p = this.#parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // Swap two nodes\n        this.#swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Element enters heap */\npush(val: number): void {\n    // Add node\n    this.maxHeap.push(val);\n    // Heapify from bottom to top\n    this.siftUp(this.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nsiftUp(i: number): void {\n    while (true) {\n        // Get parent node of node i\n        const p = this.parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // Swap two nodes\n        this.swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Element enters heap */\nvoid push(int val) {\n  // Add node\n  _maxHeap.add(val);\n  // Heapify from bottom to top\n  siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n  while (true) {\n    // Get parent node of node i\n    int p = _parent(i);\n    // When \"crossing root node\" or \"node needs no repair\", end heapify\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // Swap two nodes\n    _swap(i, p);\n    // Loop upward heapify\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Element enters heap */\nfn push(&amp;mut self, val: i32) {\n    // Add node\n    self.max_heap.push(val);\n    // Heapify from bottom to top\n    self.sift_up(self.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // Node i is already the heap root, end heapification\n        if i == 0 {\n            break;\n        }\n        // Get parent node of node i\n        let p = Self::parent(i);\n        // When \"node needs no repair\", end heapification\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // Swap two nodes\n        self.swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Element enters heap */\nvoid push(MaxHeap *maxHeap, int val) {\n    // By default, should not add this many nodes\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // Add node\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // Heapify from bottom to top\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(maxHeap, i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // Swap two nodes\n        swap(maxHeap, i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Element enters heap */\nfun push(_val: Int) {\n    // Add node\n    maxHeap.add(_val)\n    // Heapify from bottom to top\n    siftUp(size() - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfun siftUp(it: Int) {\n    // Kotlin function parameters are immutable, so create temporary variable\n    var i = it\n    while (true) {\n        // Get parent node of node i\n        val p = parent(i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // Swap two nodes\n        swap(i, p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Push element to heap ###\ndef push(val)\n  # Add node\n  @max_heap &lt;&lt; val\n  # Heapify from bottom to top\n  sift_up(size - 1)\nend\n\n### Heapify from node i, bottom to top ###\ndef sift_up(i)\n  loop do\n    # Get parent node of node i\n    p = parent(i)\n    # When \"crossing root node\" or \"node needs no repair\", end heapify\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # Swap two nodes\n    swap(i, p)\n    # Loop upward heapify\n    i = p\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#4-removing-the-heap-top-element","level":3,"title":"4.   Removing the Heap Top Element","text":"<p>The heap top element is the root node of the binary tree, which is the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making subsequent repair with heapify difficult. To minimize changes in element indexes, we use the following steps.</p> <ol> <li>Swap the heap top element with the heap bottom element (swap the root node with the rightmost leaf node).</li> <li>After swapping, remove the heap bottom from the list (note that since we've swapped, we're actually removing the original heap top element).</li> <li>Starting from the root node, perform heapify from top to bottom.</li> </ol> <p>As shown in Figure 8-4, the direction of \"top-to-bottom heapify\" is opposite to \"bottom-to-top heapify\". We compare the root node's value with its two children and swap it with the largest child. Then loop this operation until we pass a leaf node or encounter a node that doesn't need swapping.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-4   Steps of removing the heap top element </p> <p>Similar to the element insertion operation, the time complexity of the heap top element removal operation is also \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"Element exits heap\"\"\"\n    # Handle empty case\n    if self.is_empty():\n        raise IndexError(\"Heap is empty\")\n    # Swap root node with rightmost leaf node (swap first element with last element)\n    self.swap(0, self.size() - 1)\n    # Delete node\n    val = self.max_heap.pop()\n    # Heapify from top to bottom\n    self.sift_down(0)\n    # Return top element\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"Starting from node i, heapify from top to bottom\"\"\"\n    while True:\n        # Find node with largest value among i, l, r, denoted as ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        if ma == i:\n            break\n        # Swap two nodes\n        self.swap(i, ma)\n        # Loop downward heapify\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* Element exits heap */\nvoid pop() {\n    // Handle empty case\n    if (isEmpty()) {\n        throw out_of_range(\"Heap is empty\");\n    }\n    // Delete node\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // Remove node\n    maxHeap.pop_back();\n    // Return top element\n    siftDown(0);\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Element exits heap */\nint pop() {\n    // Handle empty case\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // Delete node\n    swap(0, size() - 1);\n    // Remove node\n    int val = maxHeap.remove(size() - 1);\n    // Return top element\n    siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Element exits heap */\nint Pop() {\n    // Handle empty case\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // Delete node\n    Swap(0, Size() - 1);\n    // Remove node\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // Return top element\n    SiftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid SiftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // If 'node i is largest' or 'past leaf node', end heapify\n        if (ma == i) break;\n        // Swap two nodes\n        Swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Element exits heap */\nfunc (h *maxHeap) pop() any {\n    // Handle empty case\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // Delete node\n    h.swap(0, h.size()-1)\n    // Remove node\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // Return top element\n    h.siftDown(0)\n\n    // Return heap top element\n    return val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // Find node with maximum value among nodes i, l, r, denoted as max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // Swap two nodes\n        if max == i {\n            break\n        }\n        // Swap two nodes\n        h.swap(i, max)\n        // Loop downwards heapification\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Element exits heap */\nfunc pop() -&gt; Int {\n    // Handle empty case\n    if isEmpty() {\n        fatalError(\"Heap is empty\")\n    }\n    // Delete node\n    swap(i: 0, j: size() - 1)\n    // Remove node\n    let val = maxHeap.remove(at: size() - 1)\n    // Return top element\n    siftDown(i: 0)\n    // Return heap top element\n    return val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        swap(i: i, j: ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Element exits heap */\npop() {\n    // Handle empty case\n    if (this.isEmpty()) throw new Error('Heap is empty');\n    // Delete node\n    this.#swap(0, this.size() - 1);\n    // Remove node\n    const val = this.#maxHeap.pop();\n    // Return top element\n    this.#siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\n#siftDown(i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // Swap two nodes\n        if (ma === i) break;\n        // Swap two nodes\n        this.#swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Element exits heap */\npop(): number {\n    // Handle empty case\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // Delete node\n    this.swap(0, this.size() - 1);\n    // Remove node\n    const val = this.maxHeap.pop();\n    // Return top element\n    this.siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nsiftDown(i: number): void {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // Swap two nodes\n        if (ma === i) break;\n        // Swap two nodes\n        this.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Element exits heap */\nint pop() {\n  // Handle empty case\n  if (isEmpty()) throw Exception('Heap is empty');\n  // Delete node\n  _swap(0, size() - 1);\n  // Remove node\n  int val = _maxHeap.removeLast();\n  // Return top element\n  siftDown(0);\n  // Return heap top element\n  return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n  while (true) {\n    // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // Swap two nodes\n    if (ma == i) break;\n    // Swap two nodes\n    _swap(i, ma);\n    // Loop downwards heapification\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Element exits heap */\nfn pop(&amp;mut self) -&gt; i32 {\n    // Handle empty case\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // Delete node\n    self.swap(0, self.size() - 1);\n    // Remove node\n    let val = self.max_heap.pop().unwrap();\n    // Return top element\n    self.sift_down(0);\n    // Return heap top element\n    val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // Swap two nodes\n        if ma == i {\n            break;\n        }\n        // Swap two nodes\n        self.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Element exits heap */\nint pop(MaxHeap *maxHeap) {\n    // Handle empty case\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // Delete node\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // Remove node\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // Return top element\n    siftDown(maxHeap, 0);\n\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Find node with maximum value among nodes i, l, r, denoted as max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // Swap two nodes\n        if (max == i) {\n            break;\n        }\n        // Swap two nodes\n        swap(maxHeap, i, max);\n        // Loop downwards heapification\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Element exits heap */\nfun pop(): Int {\n    // Handle empty case\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // Delete node\n    swap(0, size() - 1)\n    // Remove node\n    val _val = maxHeap.removeAt(size() - 1)\n    // Return top element\n    siftDown(0)\n    // Return heap top element\n    return _val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfun siftDown(it: Int) {\n    // Kotlin function parameters are immutable, so create temporary variable\n    var i = it\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // Swap two nodes\n        if (ma == i) break\n        // Swap two nodes\n        swap(i, ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Pop element from heap ###\ndef pop\n  # Handle empty case\n  raise IndexError, \"Heap is empty\" if is_empty?\n  # Delete node\n  swap(0, size - 1)\n  # Remove node\n  val = @max_heap.pop\n  # Return top element\n  sift_down(0)\n  # Return heap top element\n  val\nend\n\n### Heapify from node i, top to bottom ###\ndef sift_down(i)\n  loop do\n    # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # Swap two nodes\n    break if ma == i\n\n    # Swap two nodes\n    swap(i, ma)\n    # Loop downwards heapification\n    i = ma\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#813-common-applications-of-heaps","level":2,"title":"8.1.3   Common Applications of Heaps","text":"<ul> <li>Priority queue: Heaps are typically the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of \\(O(\\log n)\\), and the heap construction operation having \\(O(n)\\), all of which are highly efficient.</li> <li>Heap sort: Given a set of data, we can build a heap with them and then continuously perform element removal operations to obtain sorted data. However, we usually use a more elegant approach to implement heap sort, as detailed in the \"Heap Sort\" chapter.</li> <li>Getting the largest \\(k\\) elements: This is a classic algorithm problem and also a typical application, such as selecting the top 10 trending news for Weibo hot search, selecting the top 10 best-selling products, etc.</li> </ul>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   Summary","text":"","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A heap is a complete binary tree that can be categorized as a max heap or min heap based on its property. The heap top element of a max heap (min heap) is the largest (smallest).</li> <li>A priority queue is defined as a queue with priority sorting, typically implemented using heaps.</li> <li>Common heap operations and their corresponding time complexities include: element insertion \\(O(\\log n)\\), heap top element removal \\(O(\\log n)\\), and accessing the heap top element \\(O(1)\\).</li> <li>Complete binary trees are well-suited for array representation, so we typically use arrays to store heaps.</li> <li>Heapify operations are used to maintain the heap property and are employed in both element insertion and removal operations.</li> <li>The time complexity of building a heap with \\(n\\) input elements can be optimized to \\(O(n)\\), which is highly efficient.</li> <li>Top-k is a classic algorithm problem that can be efficiently solved using the heap data structure, with a time complexity of \\(O(n \\log k)\\).</li> </ul>","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Are the \"heap\" in data structures and the \"heap\" in memory management the same concept?</p> <p>The two are not the same concept; they just happen to share the name \"heap.\" The heap in computer system memory is part of dynamic memory allocation, where programs can use it to store data during runtime. Programs can request a certain amount of heap memory to store complex structures such as objects and arrays. When this data is no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, heap memory management and usage require more caution, as improper use can lead to issues such as memory leaks and dangling pointers.</p>","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-K Problem","text":"<p>Question</p> <p>Given an unordered array <code>nums</code> of length \\(n\\), return the largest \\(k\\) elements in the array.</p> <p>For this problem, we'll first introduce two solutions with relatively straightforward approaches, then introduce a more efficient heap-based solution.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#831-method-1-iterative-selection","level":2,"title":"8.3.1   Method 1: Iterative Selection","text":"<p>We can perform \\(k\\) rounds of traversal as shown in Figure 8-6, extracting the \\(1^{st}\\), \\(2^{nd}\\), \\(\\dots\\), \\(k^{th}\\) largest elements in each round, with a time complexity of \\(O(nk)\\).</p> <p>This method is only suitable when \\(k \\ll n\\), because when \\(k\\) is close to \\(n\\), the time complexity approaches \\(O(n^2)\\), which is very time-consuming.</p> <p></p> <p> Figure 8-6   Traversing to find the largest k elements </p> <p>Tip</p> <p>When \\(k = n\\), we can obtain a complete sorted sequence, which is equivalent to the \"selection sort\" algorithm.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#832-method-2-sorting","level":2,"title":"8.3.2   Method 2: Sorting","text":"<p>As shown in Figure 8-7, we can first sort the array <code>nums</code>, then return the rightmost \\(k\\) elements, with a time complexity of \\(O(n \\log n)\\).</p> <p>Clearly, this method \"overachieves\" the task, as we only need to find the largest \\(k\\) elements, without needing to sort the other elements.</p> <p></p> <p> Figure 8-7   Sorting to find the largest k elements </p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#833-method-3-heap","level":2,"title":"8.3.3   Method 3: Heap","text":"<p>We can solve the Top-k problem more efficiently using heaps, with the process shown in Figure 8-8.</p> <ol> <li>Initialize a min heap, where the heap top element is the smallest.</li> <li>First, insert the first \\(k\\) elements of the array into the heap in sequence.</li> <li>Starting from the \\((k + 1)^{th}\\) element, if the current element is greater than the heap top element, remove the heap top element and insert the current element into the heap.</li> <li>After traversal is complete, the heap contains the largest \\(k\\) elements.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-8   Finding the largest k elements using a heap </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"Find the largest k elements in array based on heap\"\"\"\n    # Initialize min heap\n    heap = []\n    # Enter the first k elements of array into heap\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # Starting from the (k+1)th element, maintain heap length as k\n    for i in range(k, len(nums)):\n        # If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* Find the largest k elements in array based on heap */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // Python's heapq module implements min heap by default\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* Find the largest k elements in array based on heap */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // Python's heapq module implements min heap by default\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* Find the largest k elements in array based on heap */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // Python's heapq module implements min heap by default\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* Find the largest k elements in array based on heap */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // Python's heapq module implements min heap by default\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // Enter the first k elements of array into heap\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for i := k; i &lt; len(nums); i++ {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* Find the largest k elements in array based on heap */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // Initialize min heap and build heap with first k elements\n    var heap = Heap(nums.prefix(k))\n    // Starting from the (k+1)th element, maintain heap length as k\n    for i in nums.indices.dropFirst(k) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* Element enters heap */\nfunction pushMinHeap(maxHeap, val) {\n    // Negate element\n    maxHeap.push(-val);\n}\n\n/* Element exits heap */\nfunction popMinHeap(maxHeap) {\n    // Negate element\n    return -maxHeap.pop();\n}\n\n/* Access top element */\nfunction peekMinHeap(maxHeap) {\n    // Negate element\n    return -maxHeap.peek();\n}\n\n/* Extract elements from heap */\nfunction getMinHeap(maxHeap) {\n    // Negate element\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* Find the largest k elements in array based on heap */\nfunction topKHeap(nums, k) {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    const maxHeap = new MaxHeap([]);\n    // Enter the first k elements of array into heap\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (let i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Return elements in heap\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* Element enters heap */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // Negate element\n    maxHeap.push(-val);\n}\n\n/* Element exits heap */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // Negate element\n    return -maxHeap.pop();\n}\n\n/* Access top element */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // Negate element\n    return -maxHeap.peek();\n}\n\n/* Extract elements from heap */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // Negate element\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* Find the largest k elements in array based on heap */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    const maxHeap = new MaxHeap([]);\n    // Enter the first k elements of array into heap\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (let i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Return elements in heap\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* Find the largest k elements in array based on heap */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // Initialize min heap, push first k elements of array to heap\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // Starting from the (k+1)th element, maintain heap length as k\n  for (int i = k; i &lt; nums.length; i++) {\n    // If current element is greater than top element, top element exits heap, current element enters heap\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* Find the largest k elements in array based on heap */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap is a max heap, use Reverse to negate elements to implement min heap\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // Enter the first k elements of array into heap\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for &amp;num in nums.iter().skip(k) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* Element enters heap */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // Negate element\n    push(maxHeap, -val);\n}\n\n/* Element exits heap */\nint popMinHeap(MaxHeap *maxHeap) {\n    // Negate element\n    return -pop(maxHeap);\n}\n\n/* Access top element */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // Negate element\n    return -peek(maxHeap);\n}\n\n/* Extract elements from heap */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Negate all heap elements and store in res array\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* Extract elements from heap */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Negate all heap elements and store in res array\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// Function to find k largest elements in array using heap\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // Free memory\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* Find the largest k elements in array based on heap */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // Python's heapq module implements min heap by default\n    val heap = PriorityQueue&lt;Int&gt;()\n    // Enter the first k elements of array into heap\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (i in k..&lt;nums.size) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### Find largest k elements in array using heap ###\ndef top_k_heap(nums, k)\n  # Python's heapq module implements min heap by default\n  # Note: We negate all heap elements to simulate min heap using max heap\n  max_heap = MaxHeap.new([])\n\n  # Enter the first k elements of array into heap\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # Starting from the (k+1)th element, maintain heap length as k\n  for i in k...nums.length\n    # If current element is greater than top element, top element exits heap, current element enters heap\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> <p>A total of \\(n\\) rounds of heap insertions and removals are performed, with the heap's maximum length being \\(k\\), so the time complexity is \\(O(n \\log k)\\). This method is very efficient; when \\(k\\) is small, the time complexity approaches \\(O(n)\\); when \\(k\\) is large, the time complexity does not exceed \\(O(n \\log n)\\).</p> <p>Additionally, this method is suitable for dynamic data stream scenarios. By continuously adding data, we can maintain the elements in the heap, thus achieving dynamic updates of the largest \\(k\\) elements.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"Before Starting","text":"<p>A few years ago, I shared the \"Sword for Offer\" problem solutions on LeetCode, receiving encouragement and support from many readers. During interactions with readers, the most frequently asked question I encountered was \"how to get started with algorithms.\" Gradually, I developed a keen interest in this question.</p> <p>Diving straight into problem-solving seems to be the most popular approach—it's simple, direct, and effective. However, problem-solving is like playing Minesweeper: those with strong self-learning abilities can successfully defuse the mines one by one, while those with insufficient foundations may end up bruised and battered, retreating step by step in frustration. Reading through textbooks is also a common practice, but for job seekers, graduation theses, resume submissions, and preparations for written tests and interviews have already consumed most of their energy, making working through thick books an arduous challenge.</p> <p>If you're facing similar struggles, then it's fortunate that this book has \"found\" you. This book is my answer to this question—even if it may not be the optimal solution, it is at least a positive attempt. While this book alone won't directly land you a job offer, it will guide you to explore the \"knowledge map\" of data structures and algorithms, help you understand the shapes, sizes, and distributions of different \"mines,\" and enable you to master various \"mine-clearing methods.\" With these skills, I believe you can tackle problems and read technical literature more confidently, gradually building a complete knowledge system.</p> <p>I deeply agree with Professor Feynman's words: \"Knowledge isn't free. You have to pay attention.\" In this sense, this book is not entirely \"free.\" In order to live up to the precious \"attention\" you invest in this book, I will do my utmost and devote my greatest \"attention\" to completing this work.</p> <p>I'm acutely aware of my limited knowledge and shallow expertise. Although the content of this book has been refined over a period of time, there are certainly still many errors, and I sincerely welcome critiques and corrections from teachers and fellow students.</p> <p></p> Hello, Algorithms! <p>The advent of computers has brought tremendous changes to the world. With their high-speed computing capabilities and excellent programmability, they have become the ideal medium for executing algorithms and processing data. Whether it's the realistic graphics in video games, the intelligent decision-making in autonomous driving, AlphaGo's brilliant Go matches, or ChatGPT's natural interactions, these applications are all exquisite interpretations of algorithms on computers.</p> <p>In fact, before the advent of computers, algorithms and data structures already existed in every corner of the world. Early algorithms were relatively simple, such as ancient counting methods and tool-making procedures. As civilization progressed, algorithms gradually became more refined and complex. From the ingenious craftsmanship of master artisans, to industrial products that liberate productive forces, to the scientific laws governing the operation of the universe, behind almost every ordinary or astonishing thing lies ingenious algorithmic thinking.</p> <p>Similarly, data structures are everywhere: from large-scale social networks to small subway systems, many systems can be modeled as \"graphs\"; from a nation to a family, the primary organizational forms of society exhibit characteristics of \"trees\"; winter clothing is like a \"stack,\" where the first item put on is the last to be taken off; a badminton tube is like a \"queue,\" with items inserted at one end and retrieved from the other; a dictionary is like a \"hash table,\" enabling quick lookup of target entries.</p> <p>This book aims to help readers understand the core concepts of algorithms and data structures through clear and accessible animated illustrations and runnable code examples, and to implement them through programming. Building on this foundation, the book endeavors to reveal the vivid manifestations of algorithms in the complex world and showcase the beauty of algorithms. I hope this book can be of help to you!</p>","path":["Before Starting"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"Chapter 1.   Encounter with Algorithms","text":"<p>Abstract</p> <p>A young girl dances gracefully, intertwined with data, her skirt flowing with the melody of algorithms.</p> <p>She invites you to dance with her. Follow her steps closely and enter the world of algorithms, full of logic and beauty.</p>","path":["Chapter 1. Encounter With Algorithms","Chapter 1. &nbsp; Encounter with Algorithms"],"tags":[]},{"location":"chapter_introduction/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>1.1   Algorithms Are Everywhere</li> <li>1.2   What Is an Algorithm</li> <li>1.3   Summary</li> </ul>","path":["Chapter 1. Encounter With Algorithms","Chapter 1. &nbsp; Encounter with Algorithms"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   Algorithms Are Everywhere","text":"<p>When we hear the term \"algorithm,\" we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives.</p> <p>Before we start discussing about algorithms officially, there's an interesting fact worth sharing: you've learned many algorithms unconsciously and are used to applying them in your daily life. Here, I will give a few specific examples to prove this point.</p> <p>Example 1: Looking Up a Dictionary. In an English dictionary, words are listed alphabetically. Assuming we're searching for a word that starts with the letter \\(r\\), this is typically done in the following way:</p> <ol> <li>Open the dictionary to about halfway and check the first vocabulary of the page, let's say the letter starts with \\(m\\).</li> <li>Since \\(r\\) comes after \\(m\\) in the alphabet, the first half can be ignored and the search space is narrowed down to the second half.</li> <li>Repeat steps <code>1.</code> and <code>2.</code> until you find the page where the word starts with \\(r\\).</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 1-1   Process of looking up a dictionary </p> <p>Looking up a dictionary, an essential skill for elementary school students is actually the famous \"Binary Search\" algorithm. From a data structure perspective, we can consider the dictionary as a sorted \"array\"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as the algorithm \"Binary Search.\"</p> <p>Example 2: Organizing Card Deck. When playing cards, we need to arrange the cards in our hands in ascending order, as shown in the following process.</p> <ol> <li>Divide the playing cards into \"ordered\" and \"unordered\" sections, assuming initially the leftmost card is already in order.</li> <li>Take out a card from the unordered section and insert it into the correct position in the ordered section; after this, the leftmost two cards are in order.</li> <li>Repeat step <code>2</code> until all cards are in order.</li> </ol> <p></p> <p> Figure 1-2   Process of sorting a deck of cards </p> <p>The above method of organizing playing cards is practically the \"Insertion Sort\" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort.</p> <p>Example 3: Making Change. Assume making a purchase of \\(69\\) at a supermarket. If you give the cashier \\(100\\), they will need to provide you with \\(31\\) in change. This process can be clearly understood as illustrated in Figure 1-3.</p> <ol> <li>The options are currencies valued below \\(31\\), including \\(1\\), \\(5\\), \\(10\\), and \\(20\\).</li> <li>Take out the largest \\(20\\) from the options, leaving \\(31 - 20 = 11\\).</li> <li>Take out the largest \\(10\\) from the remaining options, leaving \\(11 - 10 = 1\\).</li> <li>Take out the largest \\(1\\) from the remaining options, leaving \\(1 - 1 = 0\\).</li> <li>Complete change-making, the solution is \\(20 + 10 + 1 = 31\\).</li> </ol> <p></p> <p> Figure 1-3   Process of making change </p> <p>In the steps described, we choose the best option at each stage by utilizing the largest denomination available, which leads to an effective change-making strategy. From a data structures and algorithms perspective, this approach is known as a \"Greedy\" algorithm.</p> <p>From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers and solve various complex issues in a more efficient way.</p> <p>Tip</p> <p>If you are still confused about concepts like data structures, algorithms, arrays, and binary searches, I encourage you to keep reading. This book will gently guide you into the realm of understanding data structures and algorithms.</p>","path":["Chapter 1. Encounter With Algorithms","1.1 &nbsp; Algorithms Are Everywhere"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   Summary","text":"","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Algorithms are ubiquitous in daily life and are not distant, esoteric knowledge. In fact, we have already learned many algorithms unconsciously and use them to solve problems big and small in life.</li> <li>The principle of looking up a dictionary is consistent with the binary search algorithm. Binary search embodies the important algorithmic idea of divide and conquer.</li> <li>The process of organizing playing cards is very similar to the insertion sort algorithm. Insertion sort is suitable for sorting small datasets.</li> <li>The steps of making change are essentially a greedy algorithm, where the best choice is made at each step based on the current situation.</li> <li>An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time, while a data structure is the way computers organize and store data.</li> <li>Data structures and algorithms are closely connected. Data structures are the foundation of algorithms, and algorithms breathe life into data structures.</li> <li>We can compare data structures and algorithms to assembling building blocks. The blocks represent data, the shape and connection method of the blocks represent the data structure, and the steps to assemble the blocks correspond to the algorithm.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: As a programmer, I have never used algorithms to solve problems in my daily work. Common algorithms are already encapsulated by programming languages and can be used directly. Does this mean that the problems in our work have not yet reached the level where algorithms are needed?</p> <p>If we compare specific work skills to \"techniques\" in martial arts, then fundamental subjects should be more like \"internal skills\".</p> <p>I believe the significance of learning algorithms (and other fundamental subjects) is not to implement them from scratch at work, but rather to be able to make professional reactions and judgments when solving problems based on the knowledge learned, thereby improving the overall quality of work. Here is a simple example. Every programming language has a built-in sorting function:</p> <ul> <li>If we have not studied data structures and algorithms, we might simply feed any given data to this sorting function. It runs smoothly with good performance, and there doesn't seem to be any problem.</li> <li>But if we have studied algorithms, we would know that the time complexity of the built-in sorting function is \\(O(n \\log n)\\). However, if the given data consists of integers with a fixed number of digits (such as student IDs), we can use the more efficient \"radix sort\", reducing the time complexity to \\(O(nk)\\), where \\(k\\) is the number of digits. When the data volume is very large, the saved running time can create significant value (reduced costs, improved experience, etc.).</li> </ul> <p>In the field of engineering, a large number of problems are difficult to reach optimal solutions, and many problems are only solved \"approximately\". The difficulty of a problem depends on one hand on the nature of the problem itself, and on the other hand on the knowledge reserve of the person observing the problem. The more complete a person's knowledge and the more experience they have, the deeper their analysis of the problem will be, and the more elegantly the problem can be solved.</p>","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   What Is an Algorithm","text":"","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121-algorithm-definition","level":2,"title":"1.2.1   Algorithm Definition","text":"<p>An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time. It has the following characteristics.</p> <ul> <li>The problem is well-defined, with clear input and output definitions.</li> <li>It is feasible and can be completed within a finite number of steps, time, and memory space.</li> <li>Each step has a definite meaning, and under the same input and operating conditions, the output is always the same.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122-data-structure-definition","level":2,"title":"1.2.2   Data Structure Definition","text":"<p>A data structure is a way of organizing and storing data, covering the data content, relationships between data, and methods for data operations. It has the following design objectives.</p> <ul> <li>Occupy as little space as possible to save computer memory.</li> <li>Data operations should be as fast as possible, covering data access, addition, deletion, update, etc.</li> <li>Provide a concise data representation and logical information so that algorithms can run efficiently.</li> </ul> <p>Data structure design is a process full of trade-offs. If we want to achieve improvements in one aspect, we often need to make compromises in another aspect. Here are two examples.</p> <ul> <li>Compared to arrays, linked lists are more convenient for data addition and deletion operations but sacrifice data access speed.</li> <li>Compared to linked lists, graphs provide richer logical information but require larger memory space.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123-the-relationship-between-data-structures-and-algorithms","level":2,"title":"1.2.3   The Relationship Between Data Structures and Algorithms","text":"<p>As shown in Figure 1-4, data structures and algorithms are highly related and tightly coupled, specifically manifested in the following three aspects.</p> <ul> <li>Data structures are the foundation of algorithms. Data structures provide algorithms with structured storage of data and methods for operating on data.</li> <li>Algorithms breathe life into data structures. Data structures themselves only store data information; combined with algorithms, they can solve specific problems.</li> <li>Algorithms can usually be implemented based on different data structures, but execution efficiency may vary greatly. Choosing the appropriate data structure is key.</li> </ul> <p></p> <p> Figure 1-4   The relationship between data structures and algorithms </p> <p>Data structures and algorithms are like assembling building blocks as shown in Figure 1-5. A set of building blocks, in addition to containing many parts, also comes with detailed assembly instructions. By following the instructions step by step, we can assemble an exquisite building block model.</p> <p></p> <p> Figure 1-5   Assembling blocks </p> <p>The detailed correspondence between the two is shown in Table 1-1.</p> <p> Table 1-1   Comparing data structures and algorithms to assembling building blocks </p> Data structures and algorithms Assembling building blocks Input data Unassembled building blocks Data structure Organization form of building blocks, including shape, size, connection method, etc. Algorithm A series of operational steps to assemble the blocks into the target form Output data Building block model <p>It is worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations based on multiple programming languages.</p> <p>Conventional abbreviation</p> <p>In actual discussions, we usually abbreviate \"data structures and algorithms\" as \"algorithms\". For example, the well-known LeetCode algorithm problems actually examine knowledge of both data structures and algorithms.</p>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"Chapter 0.   Preface","text":"<p>Abstract</p> <p>Algorithms are like a beautiful symphony, each line of code flows like a melody.</p> <p>May this book gently resonate in your mind, leaving a unique and profound melody.</p>","path":["Chapter 0. Preface","Chapter 0. &nbsp; Preface"],"tags":[]},{"location":"chapter_preface/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>0.1   About This Book</li> <li>0.2   How to Use This Book</li> <li>0.3   Summary</li> </ul>","path":["Chapter 0. Preface","Chapter 0. &nbsp; Preface"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   About This Book","text":"<p>This project aims to create an open-source, free, beginner-friendly introductory tutorial on data structures and algorithms.</p> <ul> <li>The entire book uses animated illustrations, with clear and easy-to-understand content and a smooth learning curve, guiding beginners to explore the knowledge map of data structures and algorithms.</li> <li>The source code can be run with one click, helping readers improve their programming skills through practice and understand how algorithms work and the underlying implementation of data structures.</li> <li>We encourage readers to learn from each other, and everyone is welcome to ask questions and share insights in the comments section, making progress together through discussion and exchange.</li> </ul>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#011-target-audience","level":2,"title":"0.1.1   Target Audience","text":"<p>If you are an algorithm beginner who has never been exposed to algorithms, or if you already have some problem-solving experience and have a vague understanding of data structures and algorithms, oscillating between knowing and not knowing, then this book is tailor-made for you!</p> <p>If you have already accumulated a certain amount of problem-solving experience and are familiar with most question types, this book can help you review and organize your algorithm knowledge system, and the repository's source code can be used as a \"problem-solving toolkit\" or \"algorithm dictionary.\"</p> <p>If you are an algorithm \"expert,\" we look forward to receiving your valuable suggestions, or participating in creation together.</p> <p>Prerequisites</p> <p>You need to have at least a programming foundation in any language, and be able to read and write simple code.</p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#012-content-structure","level":2,"title":"0.1.2   Content Structure","text":"<p>The main content of this book is shown in Figure 0-1.</p> <ul> <li>Complexity analysis: Evaluation dimensions and methods for data structures and algorithms. Methods for calculating time complexity and space complexity, common types, examples, etc.</li> <li>Data structures: Classification methods for basic data types and data structures. The definition, advantages and disadvantages, common operations, common types, typical applications, implementation methods, etc. of data structures such as arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs.</li> <li>Algorithms: The definition, advantages and disadvantages, efficiency, application scenarios, problem-solving steps, and example problems of algorithms such as searching, sorting, divide and conquer, backtracking, dynamic programming, and greedy algorithms.</li> </ul> <p></p> <p> Figure 0-1   Main content of this book </p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#013-acknowledgements","level":2,"title":"0.1.3   Acknowledgements","text":"<p>This book has been continuously improved through the joint efforts of many contributors in the open-source community. Thanks to every contributor who invested time and effort, they are (in the order automatically generated by GitHub): krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, rongyi, msk397, gvenusleo, khoaxuantu, rivertwilight, K3v123, gyt95, zhuoqinyue, yuelinxin, Zuoxun, mingXta, Phoenix0415, FangYuan33, GN-Yu, longsizhuo, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, pengchzn, QiLOL, magentaqin, hello-ikun, JoseHung, qualifier1024, thomasq0, sunshinesDL, L-Super, Guanngxu, Transmigration-zhou, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, Shyam-Chen, theNefelibatas, longranger2, codeberg-user, xiongsp, JeffersonHuang, prinpal, seven1240, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, SamJin98, hongyun-robot, nanlei, XiaChuerwu, yd-j, iron-irax, mgisr, steventimes, junminhong, heshuyue, danny900714, MolDuM, Nigh, Dr-XYZ, XC-Zero, reeswell, PXG-XPG, NI-SW, Horbin-Magician, Enlightenus, YangXuanyi, beatrix-chan, DullSword, xjr7670, jiaxianhua, qq909244296, iStig, boloboloda, hts0000, gledfish, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, linyejoe2, liuxjerry, llql1211, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, ZhongGuanbin, hezhizhen, linzeyan, ZJKung, luluxia, xb534, ztkuaikuai, yw-1021, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yanedie, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, lyl625760, lucaswangdev, 0130w, shanghai-Jerry, EJackYang, Javesun99, eltociear, lipusheng, KNChiu, BlindTerran, ShiMaRing, lovelock, FreddieLi, FloranceYeh, fanchenggang, gltianwen, goerll, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, Asashishi, Asa0oo0o0o, fanenr, eagleanurag, akshiterate, 52coder, foursevenlove, KorsChen, GaochaoZhu, hopkings2008, yang-le, realwujing, Evilrabbit520, Umer-Jahangir, Turing-1024-Lee, Suremotoo, paoxiaomooo, Chieko-Seren, Allen-Scai, ymmmas, Risuntsy, Richard-Zhang1019, RafaelCaso, qingpeng9802, primexiao, Urbaner3, zhongfq, nidhoggfgg, MwumLi, CreatorMetaSky, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai, and KawaiiAsh.</p> <p>The code review work for this book was completed by coderonion, curtishd, Gonglja, gvenusleo, hpstory, justin-tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon and rongyi (in alphabetical order). Thanks to them for the time and effort they put in, it is they who ensure the standardization and unity of code in various languages.</p> <p>The Traditional Chinese version of this book was reviewed by Shyam-Chen and Dr-XYZ, the English version was reviewed by yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0 and magentaqin, and the Japanese edition was reviewed by eltociear. It is because of their continuous contributions that this book can serve a wider readership, and we thank them.</p> <p>The ePub ebook generation tool for this book was developed by zhongfq. We thank him for his contribution, which provides readers with a more flexible way to read.</p> <p>During the creation of this book, I received help from many people.</p> <ul> <li>Thanks to my mentor at the company, Dr. Li Xi, who encouraged me to \"take action quickly\" during a conversation, strengthening my determination to write this book;</li> <li>Thanks to my girlfriend Bubble as the first reader of this book, who provided many valuable suggestions from the perspective of an algorithm beginner, making this book more suitable for novices to read;</li> <li>Thanks to Tengbao, Qibao, and Feibao for coming up with a creative name for this book, evoking everyone's fond memories of writing their first line of code \"Hello World!\";</li> <li>Thanks to Xiaoquan for providing professional help in intellectual property rights, which played an important role in the improvement of this open-source book;</li> <li>Thanks to Sutong for designing the beautiful cover and logo for this book, and for patiently making revisions multiple times driven by my obsessive-compulsive disorder;</li> <li>Thanks to @squidfunk for the typesetting suggestions, as well as for developing the open-source documentation theme Material-for-MkDocs.</li> </ul> <p>During the writing process, I read many textbooks and articles on data structures and algorithms. These works provided excellent examples for this book and ensured the accuracy and quality of the book's content. I would like to thank all the teachers and predecessors for their outstanding contributions!</p> <p>This book advocates a learning method that combines hands and brain, and in this regard I was deeply inspired by Dive into Deep Learning. I highly recommend this excellent work to all readers.</p> <p>Heartfelt thanks to my parents, it is your support and encouragement that has given me the opportunity to do this interesting thing.</p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   How to Use This Book","text":"<p>Tip</p> <p>For the best reading experience, it is recommended that you read through this section.</p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#021-writing-style-conventions","level":2,"title":"0.2.1   Writing Style Conventions","text":"<ul> <li>Titles marked with <code>*</code> are optional sections with relatively difficult content. If you have limited time, you can skip them first.</li> <li>Technical terms will be in bold (in paper and PDF versions) or underlined (in web versions), such as array. It is recommended to memorize them for reading literature.</li> <li>Key content and summary statements will be bolded, and such text deserves special attention.</li> <li>Words and phrases with specific meanings will be marked with \"quotation marks\" to avoid ambiguity.</li> <li>When it comes to nouns that are inconsistent between programming languages, this book uses Python as the standard, for example, using <code>None</code> to represent \"null\".</li> <li>This book partially abandons the comment conventions of programming languages in favor of more compact content layout. Comments are mainly divided into three types: title comments, content comments, and multi-line comments.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"Title comment, used to label functions, classes, test cases, etc.\"\"\"\n\n# Content comment, used to explain code in detail\n\n\"\"\"\nMulti-line\ncomment\n\"\"\"\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n// Multi-line\n// comment\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>### Title comment, used to label functions, classes, test cases, etc. ###\n\n# Content comment, used to explain code in detail\n\n# Multi-line\n# comment\n</code></pre>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#022-learning-efficiently-with-animated-illustrations","level":2,"title":"0.2.2   Learning Efficiently with Animated Illustrations","text":"<p>Compared to text, videos and images have higher information density and structural organization, making them easier to understand. In this book, key and difficult knowledge will mainly be presented in the form of animated illustrations, with text serving as explanation and supplement.</p> <p>If you find that a section of content provides animated illustrations as shown in Figure 0-2 while reading this book, please focus on the illustrations first, with text as a supplement, and combine the two to understand the content.</p> <p></p> <p> Figure 0-2   Example of animated illustrations </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#023-deepening-understanding-through-code-practice","level":2,"title":"0.2.3   Deepening Understanding Through Code Practice","text":"<p>The accompanying code for this book is hosted in the GitHub repository. As shown in Figure 0-3, the source code comes with test cases and can be run with one click.</p> <p>If time permits, it is recommended that you type out the code yourself. If you have limited study time, please at least read through and run all the code.</p> <p>Compared to reading code, the process of writing code often brings more rewards. Learning by doing is the real learning.</p> <p></p> <p> Figure 0-3   Example of running code </p> <p>The preliminary work for running code is mainly divided into three steps.</p> <p>Step 1: Install the local programming environment. Please follow the tutorial shown in the appendix for installation. If already installed, you can skip this step.</p> <p>Step 2: Clone or download the code repository. Visit the GitHub repository. If you have already installed Git, you can clone this repository with the following command:</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>Of course, you can also click the \"Download ZIP\" button at the location shown in Figure 0-4 to directly download the code compressed package, and then extract it locally.</p> <p></p> <p> Figure 0-4   Clone repository and download code </p> <p>Step 3: Run the source code. As shown in Figure 0-5, for code blocks with file names at the top, we can find the corresponding source code files in the <code>codes</code> folder of the repository. The source code files can be run with one click, which will help you save unnecessary debugging time and allow you to focus on learning content.</p> <p></p> <p> Figure 0-5   Code blocks and corresponding source code files </p> <p>In addition to running code locally, the web version also supports visual running of Python code (implemented based on pythontutor). As shown in Figure 0-6, you can click \"Visual Run\" below the code block to expand the view and observe the execution process of the algorithm code; you can also click \"Full Screen View\" for a better viewing experience.</p> <p></p> <p> Figure 0-6   Visual running of Python code </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#024-growing-together-through-questions-and-discussions","level":2,"title":"0.2.4   Growing Together Through Questions and Discussions","text":"<p>When reading this book, please do not easily skip knowledge points that you have not learned well. Feel free to ask your questions in the comments section, and my friends and I will do our best to answer you, and generally reply within two days.</p> <p>As shown in Figure 0-7, the web version has a comments section at the bottom of each chapter. I hope you will pay more attention to the content of the comments section. On the one hand, you can learn about the problems that everyone encounters, thus checking for omissions and stimulating deeper thinking. On the other hand, I hope you can generously answer other friends' questions, share your insights, and help others progress.</p> <p></p> <p> Figure 0-7   Example of comments section </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#025-algorithm-learning-roadmap","level":2,"title":"0.2.5   Algorithm Learning Roadmap","text":"<p>From an overall perspective, we can divide the process of learning data structures and algorithms into three stages.</p> <ol> <li>Stage 1: Algorithm introduction. We need to familiarize ourselves with the characteristics and usage of various data structures, and learn the principles, processes, uses, and efficiency of different algorithms.</li> <li>Stage 2: Practice algorithm problems. It is recommended to start with popular problems, and accumulate at least 100 problems first, to familiarize yourself with mainstream algorithm problems. When first practicing problems, \"knowledge forgetting\" may be a challenge, but rest assured, this is very normal. We can review problems according to the \"Ebbinghaus forgetting curve\", and usually after 3-5 rounds of repetition, we can firmly remember them. For recommended problem lists and practice plans, please see this GitHub repository.</li> <li>Stage 3: Building a knowledge system. In terms of learning, we can read algorithm column articles, problem-solving frameworks, and algorithm textbooks to continuously enrich our knowledge system. In terms of practicing problems, we can try advanced problem-solving strategies, such as categorization by topic, one problem multiple solutions, one solution multiple problems, etc. Related problem-solving insights can be found in various communities.</li> </ol> <p>As shown in Figure 0-8, the content of this book mainly covers \"Stage 1\", aiming to help you more efficiently carry out Stage 2 and Stage 3 learning.</p> <p></p> <p> Figure 0-8   Algorithm learning roadmap </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   Summary","text":"","path":["Chapter 0. Preface","0.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_preface/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>The main audience of this book is algorithm beginners. If you already have a certain foundation, this book can help you systematically review algorithm knowledge, and the source code in the book can also be used as a \"problem-solving toolkit.\"</li> <li>The content of the book mainly includes three parts: complexity analysis, data structures, and algorithms, covering most topics in this field.</li> <li>For algorithm novices, reading an introductory book during the initial learning stage is crucial, as it can help you avoid many detours.</li> <li>The animated illustrations in the book are usually used to introduce key and difficult knowledge. When reading this book, you should pay more attention to these contents.</li> <li>Practice is the best way to learn programming. It is strongly recommended to run the source code and type the code yourself.</li> <li>The web version of this book has a comments section for each chapter, where you are welcome to share your questions and insights at any time.</li> </ul>","path":["Chapter 0. Preface","0.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"References","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] Yan Weimin. Data Structures (C Language Version).</p> <p>[5] Deng Junhui. Data Structures (C++ Language Version, Third Edition).</p> <p>[6] Mark Allen Weiss, translated by Chen Yue. Data Structures and Algorithm Analysis in Java (Third Edition).</p> <p>[7] Cheng Jie. Conversational Data Structures.</p> <p>[8] Wang Zheng. The Beauty of Data Structures and Algorithms.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["References"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"Chapter 10.   Searching","text":"<p>Abstract</p> <p>Searching is an adventure into the unknown, where we may need to traverse every corner of the mysterious space, or we may be able to quickly lock onto the target.</p> <p>In this journey of discovery, each exploration may yield an unexpected answer.</p>","path":["Chapter 10. Searching","Chapter 10. &nbsp; Searching"],"tags":[]},{"location":"chapter_searching/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>10.1   Binary Search</li> <li>10.2   Binary Search Insertion</li> <li>10.3   Binary Search Edge Cases</li> <li>10.4   Hash Optimization Strategy</li> <li>10.5   Search Algorithms Revisited</li> <li>10.6   Summary</li> </ul>","path":["Chapter 10. Searching","Chapter 10. &nbsp; Searching"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   Binary Search","text":"<p>Binary search is an efficient searching algorithm based on the divide-and-conquer strategy. It leverages the orderliness of data to reduce the search range by half in each round until the target element is found or the search interval becomes empty.</p> <p>Question</p> <p>Given an array <code>nums</code> of length \\(n\\) with elements arranged in ascending order and no duplicates, search for and return the index of element <code>target</code> in the array. If the array does not contain the element, return \\(-1\\). An example is shown in Figure 10-1.</p> <p></p> <p> Figure 10-1   Binary search example data </p> <p>As shown in Figure 10-2, we first initialize pointers \\(i = 0\\) and \\(j = n - 1\\), pointing to the first and last elements of the array respectively, representing the search interval \\([0, n - 1]\\). Note that square brackets denote a closed interval, which includes the boundary values themselves.</p> <p>Next, perform the following two steps in a loop:</p> <ol> <li>Calculate the midpoint index \\(m = \\lfloor {(i + j) / 2} \\rfloor\\), where \\(\\lfloor \\: \\rfloor\\) denotes the floor operation.</li> <li>Compare <code>nums[m]</code> and <code>target</code>, which results in three cases:<ol> <li>When <code>nums[m] &lt; target</code>, it indicates that <code>target</code> is in the interval \\([m + 1, j]\\), so execute \\(i = m + 1\\).</li> <li>When <code>nums[m] &gt; target</code>, it indicates that <code>target</code> is in the interval \\([i, m - 1]\\), so execute \\(j = m - 1\\).</li> <li>When <code>nums[m] = target</code>, it indicates that <code>target</code> has been found, so return index \\(m\\).</li> </ol> </li> </ol> <p>If the array does not contain the target element, the search interval will eventually shrink to empty. In this case, return \\(-1\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 10-2   Binary search process </p> <p>It's worth noting that since both \\(i\\) and \\(j\\) are of <code>int</code> type, \\(i + j\\) may exceed the range of the <code>int</code> type. To avoid large number overflow, we typically use the formula \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) to calculate the midpoint.</p> <p>The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search (closed interval)\"\"\"\n    # Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    i, j = 0, len(nums) - 1\n    # Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j:\n        # In theory, Python numbers can be infinitely large (depending on memory size), no need to consider large number overflow\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # This means target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # This means target is in the interval [i, m-1]\n        else:\n            return m  # Found the target element, return its index\n    return -1  # Target element not found, return -1\n</code></pre> binary_search.cpp<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.size() - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(int[] nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Binary search (closed interval on both sides) */\nint BinarySearch(int[] nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.Length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // Calculate the midpoint index m\n        if (nums[m] &lt; target)      // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else                       // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Binary search (closed interval on both sides) */\nfunc binarySearch(nums []int, target int) int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    i, j := 0, len(nums)-1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    for i &lt;= j {\n        m := i + (j-i)/2      // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m-1]\n            j = m - 1\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Binary search (closed interval on both sides) */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m-1]\n            j = m - 1\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Binary search (closed interval on both sides) */\nfunction binarySearch(nums, target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let i = 0,\n        j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        // Calculate midpoint index m, use parseInt() to round down\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else return m; // Found the target element, return its index\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Binary search (closed interval on both sides) */\nfunction binarySearch(nums: number[], target: number): number {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let i = 0,\n        j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        // Calculate the midpoint index m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    return -1; // Target element not found, return -1\n}\n</code></pre> binary_search.dart<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n  int i = 0, j = nums.length - 1;\n  // Loop, exit when the search interval is empty (empty when i &gt; j)\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      // This means target is in the interval [m+1, j]\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // This means target is in the interval [i, m-1]\n      j = m - 1;\n    } else {\n      // Found the target element, return its index\n      return m;\n    }\n  }\n  // Target element not found, return -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Binary search (closed interval on both sides) */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(int *nums, int len, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = len - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Binary search (closed interval on both sides) */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    var i = 0\n    var j = nums.size - 1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j]\n            i = m + 1\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1\n        else  // Found the target element, return its index\n            return m\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Binary search (closed interval) ###\ndef binary_search(nums, target)\n  # Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n  i, j = 0, nums.length - 1\n\n  # Loop, exit when the search interval is empty (empty when i &gt; j)\n  while i &lt;= j\n    # In theory, Ruby numbers can be infinitely large (limited by memory), no need to consider overflow\n    m = (i + j) / 2   # Calculate the midpoint index m\n\n    if nums[m] &lt; target\n      i = m + 1 # This means target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # This means target is in the interval [i, m-1]\n    else\n      return m  # Found the target element, return its index\n    end\n  end\n\n  -1  # Target element not found, return -1\nend\n</code></pre> <p>Time complexity is \\(O(\\log n)\\): In the binary loop, the interval is reduced by half each round, so the number of loops is \\(\\log_2 n\\).</p> <p>Space complexity is \\(O(1)\\): Pointers \\(i\\) and \\(j\\) use constant-size space.</p>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search/#1011-interval-representation-methods","level":2,"title":"10.1.1   Interval Representation Methods","text":"<p>In addition to the closed interval mentioned above, another common interval representation is the \"left-closed right-open\" interval, defined as \\([0, n)\\), meaning the left boundary includes itself while the right boundary does not. Under this representation, the interval \\([i, j)\\) is empty when \\(i = j\\).</p> <p>We can implement a binary search algorithm with the same functionality based on this representation:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search (left-closed right-open interval)\"\"\"\n    # Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    i, j = 0, len(nums)\n    # Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # This means target is in the interval [m+1, j)\n        elif nums[m] &gt; target:\n            j = m  # This means target is in the interval [i, m)\n        else:\n            return m  # Found the target element, return its index\n    return -1  # Target element not found, return -1\n</code></pre> binary_search.cpp<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.size();\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(int[] nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Binary search (left-closed right-open interval) */\nint BinarySearchLCRO(int[] nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.Length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // Calculate the midpoint index m\n        if (nums[m] &lt; target)      // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else                       // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Binary search (left-closed right-open interval) */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    i, j := 0, len(nums)\n    // Loop, exit when the search interval is empty (empty when i = j)\n    for i &lt; j {\n        m := i + (j-i)/2      // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m)\n            j = m\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Binary search (left-closed right-open interval) */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m)\n            j = m\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Binary search (left-closed right-open interval) */\nfunction binarySearchLCRO(nums, target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let i = 0,\n        j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        // Calculate midpoint index m, use parseInt() to round down\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // This means target is in the interval [i, m)\n            j = m;\n        // Found the target element, return its index\n        else return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Binary search (left-closed right-open interval) */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let i = 0,\n        j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        // Calculate the midpoint index m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // This means target is in the interval [i, m)\n            j = m;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    return -1; // Target element not found, return -1\n}\n</code></pre> binary_search.dart<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n  int i = 0, j = nums.length;\n  // Loop, exit when the search interval is empty (empty when i = j)\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      // This means target is in the interval [m+1, j)\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // This means target is in the interval [i, m)\n      j = m;\n    } else {\n      // Found the target element, return its index\n      return m;\n    }\n  }\n  // Target element not found, return -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Binary search (left-closed right-open interval) */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // This means target is in the interval [i, m)\n            j = m;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = len;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Binary search (left-closed right-open interval) */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    var i = 0\n    var j = nums.size\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j)\n            i = m + 1\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m\n        else  // Found the target element, return its index\n            return m\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Binary search (left-closed right-open interval) ###\ndef binary_search_lcro(nums, target)\n  # Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n  i, j = 0, nums.length\n\n  # Loop, exit when the search interval is empty (empty when i = j)\n  while i &lt; j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # This means target is in the interval [m+1, j)\n    elsif nums[m] &gt; target\n      j = m - 1 # This means target is in the interval [i, m)\n    else\n      return m  # Found the target element, return its index\n    end\n  end\n\n  -1  # Target element not found, return -1\nend\n</code></pre> <p>As shown in Figure 10-3, under the two interval representations, the initialization, loop condition, and interval narrowing operations of the binary search algorithm are all different.</p> <p>Since both the left and right boundaries in the \"closed interval\" representation are defined as closed, the operations to narrow the interval through pointers \\(i\\) and \\(j\\) are also symmetric. This makes it less error-prone, so the \"closed interval\" approach is generally recommended.</p> <p></p> <p> Figure 10-3   Two interval definitions </p>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search/#1012-advantages-and-limitations","level":2,"title":"10.1.2   Advantages and Limitations","text":"<p>Binary search performs well in both time and space aspects.</p> <ul> <li>Binary search has high time efficiency. With large data volumes, the logarithmic time complexity has significant advantages. For example, when the data size \\(n = 2^{20}\\), linear search requires \\(2^{20} = 1048576\\) loop rounds, while binary search only needs \\(\\log_2 2^{20} = 20\\) rounds.</li> <li>Binary search requires no extra space. Compared to searching algorithms that require additional space (such as hash-based search), binary search is more space-efficient.</li> </ul> <p>However, binary search is not suitable for all situations, mainly for the following reasons:</p> <ul> <li>Binary search is only applicable to sorted data. If the input data is unsorted, sorting specifically to use binary search would be counterproductive, as sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), which is higher than both linear search and binary search. For scenarios with frequent element insertions, maintaining array orderliness requires inserting elements at specific positions with a time complexity of \\(O(n)\\), which is also very expensive.</li> <li>Binary search is only applicable to arrays. Binary search requires jump-style (non-contiguous) element access, and jump-style access has low efficiency in linked lists, making it unsuitable for linked lists or data structures based on linked list implementations.</li> <li>For small data volumes, linear search performs better. In linear search, each round requires only 1 comparison operation; while in binary search, it requires 1 addition, 1 division, 1-3 comparison operations, and 1 addition (subtraction), totaling 4-6 unit operations. Therefore, when the data volume \\(n\\) is small, linear search is actually faster than binary search.</li> </ul>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   Binary Search Edge Cases","text":"","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031-finding-the-left-boundary","level":2,"title":"10.3.1   Finding the Left Boundary","text":"<p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\) that may contain duplicate elements, return the index of the leftmost element <code>target</code> in the array. If the array does not contain the element, return \\(-1\\).</p> <p>Recall the method for finding the insertion point with binary search. After the search completes, \\(i\\) points to the leftmost <code>target</code>, so finding the insertion point is essentially finding the index of the leftmost <code>target</code>.</p> <p>Consider implementing the left boundary search using the insertion point finding function. Note that the array may not contain <code>target</code>, which could result in the following two cases:</p> <ul> <li>The insertion point index \\(i\\) is out of bounds.</li> <li>The element <code>nums[i]</code> is not equal to <code>target</code>.</li> </ul> <p>When either of these situations occurs, simply return \\(-1\\). The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for the leftmost target\"\"\"\n    # Equivalent to finding the insertion point of target\n    i = binary_search_insertion(nums, target)\n    # Target not found, return -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # Found target, return index i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Binary search for the leftmost target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Binary search for the leftmost target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // Equivalent to finding the insertion point of target\n    i := binarySearchInsertion(nums, target)\n    // Target not found, return -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Binary search for the leftmost target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // Equivalent to finding the insertion point of target\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // Target not found, return -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* Binary search for the leftmost target */\nfunction binarySearchLeftEdge(nums, target) {\n    // Equivalent to finding the insertion point of target\n    const i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Binary search for the leftmost target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Equivalent to finding the insertion point of target\n    const i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // Equivalent to finding the insertion point of target\n  int i = binarySearchInsertion(nums, target);\n  // Target not found, return -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // Found target, return index i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Binary search for the leftmost target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Equivalent to finding the insertion point of target\n    let i = binary_search_insertion(nums, target);\n    // Target not found, return -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // Found target, return index i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binarySearchInsertion(nums, numSize, target);\n    // Target not found, return -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Binary search for the leftmost target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // Equivalent to finding the insertion point of target\n    val i = binarySearchInsertion(nums, target)\n    // Target not found, return -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### Binary search leftmost target ###\ndef binary_search_left_edge(nums, target)\n  # Equivalent to finding the insertion point of target\n  i = binary_search_insertion(nums, target)\n\n  # Target not found, return -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # Found target, return index i\nend\n</code></pre>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032-finding-the-right-boundary","level":2,"title":"10.3.2   Finding the Right Boundary","text":"<p>So how do we find the rightmost <code>target</code>? The most direct approach is to modify the code and replace the pointer shrinking operation in the <code>nums[m] == target</code> case. The code is omitted here; interested readers can implement it themselves.</p> <p>Below we introduce two more clever methods.</p>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1-reusing-left-boundary-search","level":3,"title":"1.   Reusing Left Boundary Search","text":"<p>In fact, we can use the function for finding the leftmost element to find the rightmost element. The specific method is: Convert finding the rightmost <code>target</code> into finding the leftmost <code>target + 1</code>.</p> <p>As shown in Figure 10-7, after the search completes, pointer \\(i\\) points to the leftmost <code>target + 1</code> (if it exists), while \\(j\\) points to the rightmost <code>target</code>, so we can simply return \\(j\\).</p> <p></p> <p> Figure 10-7   Converting right boundary search to left boundary search </p> <p>Note that the returned insertion point is \\(i\\), so we need to subtract \\(1\\) from it to obtain \\(j\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for the rightmost target\"\"\"\n    # Convert to finding the leftmost target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j points to the rightmost target, i points to the first element greater than target\n    j = i - 1\n    # Target not found, return -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # Found target, return index j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Binary search for the rightmost target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Binary search for the rightmost target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // Convert to finding the leftmost target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j points to the rightmost target, i points to the first element greater than target\n    j := i - 1\n    // Target not found, return -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Binary search for the rightmost target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // Convert to finding the leftmost target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j points to the rightmost target, i points to the first element greater than target\n    let j = i - 1\n    // Target not found, return -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* Binary search for the rightmost target */\nfunction binarySearchRightEdge(nums, target) {\n    // Convert to finding the leftmost target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    const j = i - 1;\n    // Target not found, return -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Binary search for the rightmost target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Convert to finding the leftmost target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    const j = i - 1;\n    // Target not found, return -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // Convert to finding the leftmost target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j points to the rightmost target, i points to the first element greater than target\n  int j = i - 1;\n  // Target not found, return -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // Found target, return index j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Binary search for the rightmost target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Convert to finding the leftmost target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    let j = i - 1;\n    // Target not found, return -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // Found target, return index j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Binary search for the rightmost target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // Convert to finding the leftmost target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j points to the rightmost target, i points to the first element greater than target\n    val j = i - 1\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### Binary search rightmost target ###\ndef binary_search_right_edge(nums, target)\n  # Convert to finding the leftmost target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j points to the rightmost target, i points to the first element greater than target\n  j = i - 1\n\n  # Target not found, return -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # Found target, return index j\nend\n</code></pre>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2-converting-to-element-search","level":3,"title":"2.   Converting to Element Search","text":"<p>We know that when the array does not contain <code>target</code>, \\(i\\) and \\(j\\) will eventually point to the first elements greater than and less than <code>target</code>, respectively.</p> <p>Therefore, as shown in Figure 10-8, we can construct an element that does not exist in the array to find the left and right boundaries.</p> <ul> <li>Finding the leftmost <code>target</code>: Can be converted to finding <code>target - 0.5</code> and returning pointer \\(i\\).</li> <li>Finding the rightmost <code>target</code>: Can be converted to finding <code>target + 0.5</code> and returning pointer \\(j\\).</li> </ul> <p></p> <p> Figure 10-8   Converting boundary search to element search </p> <p>The code is omitted here, but the following two points are worth noting:</p> <ul> <li>Since the given array does not contain decimals, we don't need to worry about how to handle equal cases.</li> <li>Because this method introduces decimals, the variable <code>target</code> in the function needs to be changed to a floating-point type (Python does not require this change).</li> </ul>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   Binary Search Insertion Point","text":"<p>Binary search can not only be used to search for target elements but also to solve many variant problems, such as searching for the insertion position of a target element.</p>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021-case-without-duplicate-elements","level":2,"title":"10.2.1   Case Without Duplicate Elements","text":"<p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\) and an element <code>target</code>, where the array contains no duplicate elements. Insert <code>target</code> into the array <code>nums</code> while maintaining its sorted order. If the array already contains the element <code>target</code>, insert it to its left. Return the index of <code>target</code> in the array after insertion. An example is shown in Figure 10-4.</p> <p></p> <p> Figure 10-4   Binary search insertion point example data </p> <p>If we want to reuse the binary search code from the previous section, we need to answer the following two questions.</p> <p>Question 1: When the array contains <code>target</code>, is the insertion point index the same as that element's index?</p> <p>The problem requires inserting <code>target</code> to the left of equal elements, which means the newly inserted <code>target</code> replaces the position of the original <code>target</code>. In other words, when the array contains <code>target</code>, the insertion point index is the index of that <code>target</code>.</p> <p>Question 2: When the array does not contain <code>target</code>, what is the insertion point index?</p> <p>Further consider the binary search process: When <code>nums[m] &lt; target</code>, \\(i\\) moves, which means pointer \\(i\\) is approaching elements greater than or equal to <code>target</code>. Similarly, pointer \\(j\\) is always approaching elements less than or equal to <code>target</code>.</p> <p>Therefore, when the binary search ends, we must have: \\(i\\) points to the first element greater than <code>target</code>, and \\(j\\) points to the first element less than <code>target</code>. It's easy to see that when the array does not contain <code>target</code>, the insertion index is \\(i\\). The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for insertion point (no duplicate elements)\"\"\"\n    i, j = 0, len(nums) - 1  # Initialize closed interval [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target is in the interval [i, m-1]\n        else:\n            return m  # Found target, return insertion point m\n    # Target not found, return insertion point i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // Initialize closed interval [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Calculate the midpoint index m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target is in the interval [i, m-1]\n            j = m - 1\n        } else {\n            // Found target, return insertion point m\n            return m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            return m // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target is in the interval [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target is in the interval [i, m-1]\n    } else {\n      return m; // Found target, return insertion point m\n    }\n  }\n  // Target not found, return insertion point i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Initialize closed interval [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m;\n        }\n    }\n    // Target not found, return insertion point i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            return m // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Binary search insertion point (no duplicates) ###\ndef binary_search_insertion_simple(nums, target)\n  # Initialize closed interval [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target is in the interval [i, m-1]\n    else\n      return m  # Found target, return insertion point m\n    end\n  end\n\n  i # Target not found, return insertion point i\nend\n</code></pre>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022-case-with-duplicate-elements","level":2,"title":"10.2.2   Case with Duplicate Elements","text":"<p>Question</p> <p>Based on the previous problem, assume the array may contain duplicate elements, with everything else remaining the same.</p> <p>Suppose there are multiple <code>target</code> elements in the array. Ordinary binary search can only return the index of one <code>target</code>, and cannot determine how many <code>target</code> elements are to the left and right of that element.</p> <p>The problem requires inserting the target element at the leftmost position, so we need to find the index of the leftmost <code>target</code> in the array. Initially, consider implementing this through the steps shown in Figure 10-5:</p> <ol> <li>Perform binary search to obtain the index of any <code>target</code>, denoted as \\(k\\).</li> <li>Starting from index \\(k\\), perform linear traversal to the left, and return when the leftmost <code>target</code> is found.</li> </ol> <p></p> <p> Figure 10-5   Linear search for insertion point of duplicate elements </p> <p>Although this method works, it includes linear search, resulting in a time complexity of \\(O(n)\\). When the array contains many duplicate <code>target</code> elements, this method is very inefficient.</p> <p>Now consider extending the binary search code. As shown in Figure 10-6, the overall process remains unchanged: calculate the midpoint index \\(m\\) in each round, then compare <code>target</code> with <code>nums[m]</code>, divided into the following cases:</p> <ul> <li>When <code>nums[m] &lt; target</code> or <code>nums[m] &gt; target</code>, it means <code>target</code> has not been found yet, so use the ordinary binary search interval narrowing operation to make pointers \\(i\\) and \\(j\\) approach <code>target</code>.</li> <li>When <code>nums[m] == target</code>, it means elements less than <code>target</code> are in the interval \\([i, m - 1]\\), so use \\(j = m - 1\\) to narrow the interval, thereby making pointer \\(j\\) approach elements less than <code>target</code>.</li> </ul> <p>After the loop completes, \\(i\\) points to the leftmost <code>target</code>, and \\(j\\) points to the first element less than <code>target</code>, so index \\(i\\) is the insertion point.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 10-6   Steps for binary search insertion point of duplicate elements </p> <p>Observe the following code: the operations for branches <code>nums[m] &gt; target</code> and <code>nums[m] == target</code> are the same, so the two can be merged.</p> <p>Even so, we can still keep the conditional branches expanded, as the logic is clearer and more readable.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for insertion point (with duplicate elements)\"\"\"\n    i, j = 0, len(nums) - 1  # Initialize closed interval [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target is in the interval [i, m-1]\n        else:\n            j = m - 1  # The first element less than target is in the interval [i, m-1]\n    # Return insertion point i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // Initialize closed interval [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Calculate the midpoint index m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target is in the interval [i, m-1]\n            j = m - 1\n        } else {\n            // The first element less than target is in the interval [i, m-1]\n            j = m - 1\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            j = m - 1 // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target is in the interval [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target is in the interval [i, m-1]\n    } else {\n      j = m - 1; // The first element less than target is in the interval [i, m-1]\n    }\n  }\n  // Return insertion point i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Binary search for insertion point (with duplicate elements) */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Initialize closed interval [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            j = m - 1 // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Binary search insertion point (with duplicates) ###\ndef binary_search_insertion(nums, target)\n  # Initialize closed interval [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target is in the interval [i, m-1]\n    else\n      j = m - 1 # The first element less than target is in the interval [i, m-1]\n    end\n  end\n\n  i # Return insertion point i\nend\n</code></pre> <p>Tip</p> <p>The code in this section all uses the \"closed interval\" approach. Interested readers can implement the \"left-closed right-open\" approach themselves.</p> <p>Overall, binary search is simply about setting search targets for pointers \\(i\\) and \\(j\\) separately. The target could be a specific element (such as <code>target</code>) or a range of elements (such as elements less than <code>target</code>).</p> <p>Through continuous binary iterations, both pointers \\(i\\) and \\(j\\) gradually approach their preset targets. Ultimately, they either successfully find the answer or stop after crossing the boundaries.</p>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   Hash Optimization Strategy","text":"<p>In algorithm problems, we often reduce the time complexity of algorithms by replacing linear search with hash-based search. Let's use an algorithm problem to deepen our understanding.</p> <p>Question</p> <p>Given an integer array <code>nums</code> and a target element <code>target</code>, search for two elements in the array whose \"sum\" equals <code>target</code>, and return their array indices. Any solution will do.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041-linear-search-trading-time-for-space","level":2,"title":"10.4.1   Linear Search: Trading Time for Space","text":"<p>Consider directly traversing all possible combinations. As shown in Figure 10-9, we open a two-layer loop and judge in each round whether the sum of two integers equals <code>target</code>. If so, return their indices.</p> <p></p> <p> Figure 10-9   Linear search solution for two sum </p> <p>The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Method 1: Brute force enumeration\"\"\"\n    # Two nested loops, time complexity is O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Method 1: Brute force enumeration */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Method 1: Brute force enumeration */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Method 1: Brute force enumeration */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Method 1: Brute force enumeration */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // Two nested loops, time complexity is O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Method 1: Brute force enumeration */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // Two nested loops, time complexity is O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Method 1: Brute force enumeration */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Method 1: Brute force enumeration */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Method 1: Brute force enumeration */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Two nested loops, time complexity is O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Method 1: Brute force enumeration */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // Two nested loops, time complexity is O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Method 1: Brute force enumeration */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Method 1: Brute force enumeration */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Two nested loops, time complexity is O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Method 1: Brute force enumeration ###\ndef two_sum_brute_force(nums, target)\n  # Two nested loops, time complexity is O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> <p>This method has a time complexity of \\(O(n^2)\\) and a space complexity of \\(O(1)\\), which is very time-consuming with large data volumes.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042-hash-based-search-trading-space-for-time","level":2,"title":"10.4.2   Hash-Based Search: Trading Space for Time","text":"<p>Consider using a hash table where key-value pairs are array elements and element indices respectively. Loop through the array, performing the steps shown in Figure 10-10 in each round:</p> <ol> <li>Check if the number <code>target - nums[i]</code> is in the hash table. If so, directly return the indices of these two elements.</li> <li>Add the key-value pair <code>nums[i]</code> and index <code>i</code> to the hash table.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> Figure 10-10   Hash table solution for two sum </p> <p>The implementation code is shown below, requiring only a single loop:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Method 2: Auxiliary hash table\"\"\"\n    # Auxiliary hash table, space complexity is O(n)\n    dic = {}\n    # Single loop, time complexity is O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Method 2: Auxiliary hash table */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Auxiliary hash table, space complexity is O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Method 2: Auxiliary hash table */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // Auxiliary hash table, space complexity is O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Method 2: Auxiliary hash table */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // Auxiliary hash table, space complexity is O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Method 2: Auxiliary hash table */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // Auxiliary hash table, space complexity is O(n)\n    hashTable := map[int]int{}\n    // Single loop, time complexity is O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Method 2: Auxiliary hash table */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // Auxiliary hash table, space complexity is O(n)\n    var dic: [Int: Int] = [:]\n    // Single loop, time complexity is O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Method 2: Auxiliary hash table */\nfunction twoSumHashTable(nums, target) {\n    // Auxiliary hash table, space complexity is O(n)\n    let m = {};\n    // Single loop, time complexity is O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Method 2: Auxiliary hash table */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // Auxiliary hash table, space complexity is O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // Single loop, time complexity is O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Method 2: Auxiliary hash table */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Auxiliary hash table, space complexity is O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // Single loop, time complexity is O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Method 2: Auxiliary hash table */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // Auxiliary hash table, space complexity is O(n)\n    let mut dic = HashMap::new();\n    // Single loop, time complexity is O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Hash table */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Implemented using uthash.h\n} HashTable;\n\n/* Hash table lookup */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* Hash table element insertion */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* Method 2: Auxiliary hash table */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Method 2: Auxiliary hash table */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Auxiliary hash table, space complexity is O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // Single loop, time complexity is O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Method 2: Auxiliary hash table ###\ndef two_sum_hash_table(nums, target)\n  # Auxiliary hash table, space complexity is O(n)\n  dic = {}\n  # Single loop, time complexity is O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> <p>This method reduces the time complexity from \\(O(n^2)\\) to \\(O(n)\\) through hash-based search, greatly improving runtime efficiency.</p> <p>Since an additional hash table needs to be maintained, the space complexity is \\(O(n)\\). Nevertheless, this method achieves a more balanced overall time-space efficiency, making it the optimal solution for this problem.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   Searching Algorithms Revisited","text":"<p>Searching algorithms are used to search for one or a group of elements that meet specific conditions in data structures (such as arrays, linked lists, trees, or graphs).</p> <p>Searching algorithms can be divided into the following two categories based on their implementation approach:</p> <ul> <li>Locating target elements by traversing the data structure, such as traversing arrays, linked lists, trees, and graphs.</li> <li>Achieving efficient element search by utilizing data organization structure or prior information contained in the data, such as binary search, hash-based search, and binary search tree search.</li> </ul> <p>It's not hard to see that these topics have all been covered in previous chapters, so searching algorithms are not unfamiliar to us. In this section, we will approach from a more systematic perspective and re-examine searching algorithms.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051-brute-force-search","level":2,"title":"10.5.1   Brute-Force Search","text":"<p>Brute-force search locates target elements by traversing each element of the data structure.</p> <ul> <li>\"Linear search\" is applicable to linear data structures such as arrays and linked lists. It starts from one end of the data structure and accesses elements one by one until the target element is found or the other end is reached without finding the target element.</li> <li>\"Breadth-first search\" and \"depth-first search\" are two traversal strategies for graphs and trees. Breadth-first search starts from the initial node and searches layer by layer, visiting nodes from near to far. Depth-first search starts from the initial node, follows a path to the end, then backtracks and tries other paths until the entire data structure is traversed.</li> </ul> <p>The advantage of brute-force search is that it is simple and has good generality, requiring no data preprocessing or additional data structures.</p> <p>However, the time complexity of such algorithms is \\(O(n)\\), where \\(n\\) is the number of elements, so performance is poor when dealing with large amounts of data.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052-adaptive-search","level":2,"title":"10.5.2   Adaptive Search","text":"<p>Adaptive search utilizes the unique properties of data (such as orderliness) to optimize the search process, thereby locating target elements more efficiently.</p> <ul> <li>\"Binary search\" uses the orderliness of data to achieve efficient searching, applicable only to arrays.</li> <li>\"Hash-based search\" uses hash tables to establish key-value pair mappings between search data and target data, thereby achieving query operations.</li> <li>\"Tree search\" in specific tree structures (such as binary search trees), quickly eliminates nodes based on comparing node values to locate target elements.</li> </ul> <p>The advantage of such algorithms is high efficiency, with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\).</p> <p>However, using these algorithms often requires data preprocessing. For example, binary search requires pre-sorting the array, while hash-based search and tree search both require additional data structures, and maintaining these data structures also requires extra time and space overhead.</p> <p>Tip</p> <p>Adaptive search algorithms are often called lookup algorithms, mainly used to quickly retrieve target elements in specific data structures.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053-search-method-selection","level":2,"title":"10.5.3   Search Method Selection","text":"<p>Given a dataset of size \\(n\\), we can use linear search, binary search, tree search, hash-based search, and other methods to search for the target element. The working principles of each method are shown in Figure 10-11.</p> <p></p> <p> Figure 10-11   Multiple search strategies </p> <p>The operational efficiency and characteristics of the above methods are as follows:</p> <p> Table 10-1   Comparison of search algorithm efficiency </p> Linear search Binary search Tree search Hash-based search Search element \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) Insert element \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Delete element \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Extra space \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) Data preprocessing / Sorting \\(O(n \\log n)\\) Tree building \\(O(n \\log n)\\) Hash table building \\(O(n)\\) Data ordered Unordered Ordered Ordered Unordered <p>The choice of search algorithm also depends on data volume, search performance requirements, data query and update frequency, etc.</p> <p>Linear search</p> <ul> <li>Good generality, requiring no data preprocessing operations. If we only need to query the data once, the data preprocessing time for the other three methods would be longer than linear search.</li> <li>Suitable for small data volumes, where time complexity has less impact on efficiency.</li> <li>Suitable for scenarios with high data update frequency, as this method does not require any additional data maintenance.</li> </ul> <p>Binary search</p> <ul> <li>Suitable for large data volumes with stable efficiency performance, worst-case time complexity of \\(O(\\log n)\\).</li> <li>Data volume cannot be too large, as storing arrays requires contiguous memory space.</li> <li>Not suitable for scenarios with frequent data insertion and deletion, as maintaining a sorted array has high overhead.</li> </ul> <p>Hash-based search</p> <ul> <li>Suitable for scenarios with high query performance requirements, with an average time complexity of \\(O(1)\\).</li> <li>Not suitable for scenarios requiring ordered data or range searches, as hash tables cannot maintain data orderliness.</li> <li>High dependence on hash functions and hash collision handling strategies, with significant risk of performance degradation.</li> <li>Not suitable for excessively large data volumes, as hash tables require extra space to minimize collisions and thus provide good query performance.</li> </ul> <p>Tree search</p> <ul> <li>Suitable for massive data, as tree nodes are stored dispersedly in memory.</li> <li>Suitable for scenarios requiring maintained ordered data or range searches.</li> <li>During continuous node insertion and deletion, binary search trees may become skewed, degrading time complexity to \\(O(n)\\).</li> <li>If using AVL trees or red-black trees, all operations can run stably at \\(O(\\log n)\\) efficiency, but operations to maintain tree balance add extra overhead.</li> </ul>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   Summary","text":"","path":["Chapter 10. Searching","10.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_searching/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Binary search relies on data orderliness and progressively reduces the search interval by half through loops. It requires input data to be sorted and is only applicable to arrays or data structures based on array implementations.</li> <li>Brute-force search locates data by traversing the data structure. Linear search is applicable to arrays and linked lists, while breadth-first search and depth-first search are applicable to graphs and trees. Such algorithms have good generality and require no data preprocessing, but have a relatively high time complexity of \\(O(n)\\).</li> <li>Hash-based search, tree search, and binary search are efficient search methods that can quickly locate target elements in specific data structures. Such algorithms are highly efficient with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\), but typically require additional data structures.</li> <li>In practice, we need to analyze factors such as data scale, search performance requirements, and data query and update frequency to choose the appropriate search method.</li> <li>Linear search is suitable for small-scale or frequently updated data; binary search is suitable for large-scale, sorted data; hash-based search is suitable for data with high query efficiency requirements and no need for range queries; tree search is suitable for large-scale dynamic data that needs to maintain order and support range queries.</li> <li>Replacing linear search with hash-based search is a commonly used strategy to optimize runtime, reducing time complexity from \\(O(n)\\) to \\(O(1)\\).</li> </ul>","path":["Chapter 10. Searching","10.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"Chapter 11.   Sorting","text":"<p>Abstract</p> <p>Sorting is like a magic key that transforms chaos into order, enabling us to understand and process data more efficiently.</p> <p>Whether it's simple ascending order or complex categorized arrangements, sorting demonstrates the harmonious beauty of data.</p>","path":["Chapter 11. Sorting","Chapter 11. &nbsp; Sorting"],"tags":[]},{"location":"chapter_sorting/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>11.1   Sorting Algorithms</li> <li>11.2   Selection Sort</li> <li>11.3   Bubble Sort</li> <li>11.4   Insertion Sort</li> <li>11.5   Quick Sort</li> <li>11.6   Merge Sort</li> <li>11.7   Heap Sort</li> <li>11.8   Bucket Sort</li> <li>11.9   Counting Sort</li> <li>11.10   Radix Sort</li> <li>11.11   Summary</li> </ul>","path":["Chapter 11. Sorting","Chapter 11. &nbsp; Sorting"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   Bubble Sort","text":"<p>Bubble sort (bubble sort) achieves sorting by continuously comparing and swapping adjacent elements. This process is like bubbles rising from the bottom to the top, hence the name bubble sort.</p> <p>As shown in Figure 11-4, the bubbling process can be simulated using element swap operations: starting from the leftmost end of the array and traversing to the right, compare the size of adjacent elements, and if \"left element &gt; right element\", swap them. After completing the traversal, the largest element will be moved to the rightmost end of the array.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-4   Simulating bubble using element swap operation </p>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131-algorithm-flow","level":2,"title":"11.3.1   Algorithm Flow","text":"<p>Assume the array has length \\(n\\). The steps of bubble sort are shown in Figure 11-5.</p> <ol> <li>First, perform \"bubbling\" on \\(n\\) elements, swapping the largest element of the array to its correct position.</li> <li>Next, perform \"bubbling\" on the remaining \\(n - 1\\) elements, swapping the second largest element to its correct position.</li> <li>And so on. After \\(n - 1\\) rounds of \"bubbling\", the largest \\(n - 1\\) elements have all been swapped to their correct positions.</li> <li>The only remaining element must be the smallest element, requiring no sorting, so the array sorting is complete.</li> </ol> <p></p> <p> Figure 11-5   Bubble sort flow </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"Bubble sort\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [0, i]\n    for i in range(n - 1, 0, -1):\n        # Inner loop: swap the largest element in the unsorted interval [0, i] to the rightmost end of the interval\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* Bubble sort */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                // Using std::swap() function here\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Bubble sort */\nvoid bubbleSort(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Bubble sort */\nvoid BubbleSort(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Bubble sort */\nfunc bubbleSort(nums []int) {\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Bubble sort */\nfunc bubbleSort(nums: inout [Int]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Bubble sort */\nfunction bubbleSort(nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Bubble sort */\nfunction bubbleSort(nums: number[]): void {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Bubble sort */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // Outer loop: unsorted range is [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Bubble sort */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Bubble sort */\nvoid bubbleSort(int nums[], int size) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Bubble sort */\nfun bubbleSort(nums: IntArray) {\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Bubble sort ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Outer loop: unsorted range is [0, i]\n  for i in (n - 1).downto(1)\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132-efficiency-optimization","level":2,"title":"11.3.2   Efficiency Optimization","text":"<p>We notice that if no swap operations are performed during a certain round of \"bubbling\", it means the array has already completed sorting and can directly return the result. Therefore, we can add a flag <code>flag</code> to monitor this situation and return immediately once it occurs.</p> <p>After optimization, the worst-case time complexity and average time complexity of bubble sort remain \\(O(n^2)\\); but when the input array is completely ordered, the best-case time complexity can reach \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"Bubble sort (flag optimization)\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # Initialize flag\n        # Inner loop: swap the largest element in the unsorted interval [0, i] to the rightmost end of the interval\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # Record element swap\n        if not flag:\n            break  # No elements were swapped in this round of \"bubbling\", exit directly\n</code></pre> bubble_sort.cpp<pre><code>/* Bubble sort (flag optimization)*/\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                // Using std::swap() function here\n                swap(nums[j], nums[j + 1]);\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag)\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag)\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Bubble sort (flag optimization) */\nvoid BubbleSortWithFlag(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // Record element swap\n            }\n        }\n        if (!flag) break;     // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Bubble sort (flag optimization) */\nfunc bubbleSortWithFlag(nums []int) {\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // Record element swap\n            }\n        }\n        if flag == false { // No elements were swapped in this round of \"bubbling\", exit directly\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Bubble sort (flag optimization) */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // Initialize flag\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // Record element swap\n            }\n        }\n        if !flag { // No elements were swapped in this round of \"bubbling\", exit directly\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Bubble sort (flag optimization) */\nfunction bubbleSortWithFlag(nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Bubble sort (flag optimization) */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // Outer loop: unsorted range is [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // Initialize flag\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // Record element swap\n      }\n    }\n    if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Bubble sort (flag optimization) */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // Record element swap\n            }\n        }\n        if !flag {\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Bubble sort (flag optimization) */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // Record element swap\n            }\n        }\n        if (!flag) break // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Bubble sort (flag optimization) ###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # Outer loop: unsorted range is [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # Initialize flag\n\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # Record element swap\n      end\n    end\n\n    break unless flag # No elements were swapped in this round of \"bubbling\", exit directly\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133-algorithm-characteristics","level":2,"title":"11.3.3   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), adaptive sorting: The array lengths traversed in each round of \"bubbling\" are \\(n - 1\\), \\(n - 2\\), \\(\\dots\\), \\(2\\), \\(1\\), totaling \\((n - 1) n / 2\\). After introducing the <code>flag</code> optimization, the best-case time complexity can reach \\(O(n)\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Stable sorting: Since equal elements are not swapped during \"bubbling\".</li> </ul>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   Bucket Sort","text":"<p>The several sorting algorithms mentioned earlier all belong to \"comparison-based sorting algorithms\", which achieve sorting by comparing the size of elements. The time complexity of such sorting algorithms cannot exceed \\(O(n \\log n)\\). Next, we will explore several \"non-comparison sorting algorithms\", whose time complexity can reach linear order.</p> <p>Bucket sort (bucket sort) is a typical application of the divide-and-conquer strategy. It works by setting up buckets with size order, each bucket corresponding to a data range, evenly distributing data to each bucket; then, sorting within each bucket separately; finally, merging all data in the order of the buckets.</p>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181-algorithm-flow","level":2,"title":"11.8.1   Algorithm Flow","text":"<p>Consider an array of length \\(n\\), whose elements are floating-point numbers in the range \\([0, 1)\\). The flow of bucket sort is shown in Figure 11-13.</p> <ol> <li>Initialize \\(k\\) buckets and distribute the \\(n\\) elements into the \\(k\\) buckets.</li> <li>Sort each bucket separately (here we use the built-in sorting function of the programming language).</li> <li>Merge the results in order from smallest to largest bucket.</li> </ol> <p></p> <p> Figure 11-13   Bucket sort algorithm flow </p> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"Bucket sort\"\"\"\n    # Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. Distribute array elements into various buckets\n    for num in nums:\n        # Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        i = int(num * k)\n        # Add num to bucket i\n        buckets[i].append(num)\n    # 2. Sort each bucket\n    for bucket in buckets:\n        # Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort()\n    # 3. Traverse buckets to merge results\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* Bucket sort */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. Distribute array elements into various buckets\n    for (float num : nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = num * k;\n        // Add num to bucket bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. Sort each bucket\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. Traverse buckets to merge results\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* Bucket sort */\nvoid bucketSort(float[] nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. Distribute array elements into various buckets\n    for (float num : nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = (int) (num * k);\n        // Add num to bucket i\n        buckets.get(i).add(num);\n    }\n    // 2. Sort each bucket\n    for (List&lt;Float&gt; bucket : buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        Collections.sort(bucket);\n    }\n    // 3. Traverse buckets to merge results\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* Bucket sort */\nvoid BucketSort(float[] nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. Distribute array elements into various buckets\n    foreach (float num in nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = (int)(num * k);\n        // Add num to bucket i\n        buckets[i].Add(num);\n    }\n    // 2. Sort each bucket\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.Sort();\n    }\n    // 3. Traverse buckets to merge results\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* Bucket sort */\nfunc bucketSort(nums []float64) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. Distribute array elements into various buckets\n    for _, num := range nums {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        i := int(num * float64(k))\n        // Add num to bucket i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. Sort each bucket\n    for i := 0; i &lt; k; i++ {\n        // Use built-in slice sorting function, can also be replaced with other sorting algorithms\n        sort.Float64s(buckets[i])\n    }\n    // 3. Traverse buckets to merge results\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* Bucket sort */\nfunc bucketSort(nums: inout [Double]) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. Distribute array elements into various buckets\n    for num in nums {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        let i = Int(num * Double(k))\n        // Add num to bucket i\n        buckets[i].append(num)\n    }\n    // 2. Sort each bucket\n    for i in buckets.indices {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        buckets[i].sort()\n    }\n    // 3. Traverse buckets to merge results\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* Bucket sort */\nfunction bucketSort(nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Distribute array elements into various buckets\n    for (const num of nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        const i = Math.floor(num * k);\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for (const bucket of buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Traverse buckets to merge results\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* Bucket sort */\nfunction bucketSort(nums: number[]): void {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Distribute array elements into various buckets\n    for (const num of nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        const i = Math.floor(num * k);\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for (const bucket of buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Traverse buckets to merge results\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* Bucket sort */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. Distribute array elements into various buckets\n  for (double _num in nums) {\n    // Input data range is [0, 1), use _num * k to map to index range [0, k-1]\n    int i = (_num * k).toInt();\n    // Add _num to bucket bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. Sort each bucket\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. Traverse buckets to merge results\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* Bucket sort */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. Distribute array elements into various buckets\n    for &amp;num in nums.iter() {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        let i = (num * k as f64) as usize;\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for bucket in &amp;mut buckets {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. Traverse buckets to merge results\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* Bucket sort */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // Initialize k = n/2 buckets\n    int *sizes = malloc(k * sizeof(int));          // Record each bucket's size\n    float **buckets = malloc(k * sizeof(float *)); // Array of dynamic arrays (buckets)\n    // Pre-allocate sufficient space for each bucket\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. Distribute array elements into various buckets\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. Sort each bucket\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. Merge sorted buckets\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // Free memory\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* Bucket sort */\nfun bucketSort(nums: FloatArray) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. Distribute array elements into various buckets\n    for (num in nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        val i = (num * k).toInt()\n        // Add num to bucket i\n        buckets[i].add(num)\n    }\n    // 2. Sort each bucket\n    for (bucket in buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort()\n    }\n    // 3. Traverse buckets to merge results\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### Bucket sort ###\ndef bucket_sort(nums)\n  # Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. Distribute array elements into various buckets\n  nums.each do |num|\n    # Input data range is [0, 1), use num * k to map to index range [0, k-1]\n    i = (num * k).to_i\n    # Add num to bucket i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. Sort each bucket\n  buckets.each do |bucket|\n    # Use built-in sorting function, can also replace with other sorting algorithms\n    bucket.sort!\n  end\n\n  # 3. Traverse buckets to merge results\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182-algorithm-characteristics","level":2,"title":"11.8.2   Algorithm Characteristics","text":"<p>Bucket sort is suitable for processing very large data volumes. For example, if the input data contains 1 million elements and system memory cannot load all the data at once, the data can be divided into 1000 buckets, each bucket sorted separately, and then the results merged.</p> <ul> <li>Time complexity of \\(O(n + k)\\): Assuming the elements are evenly distributed among the buckets, then the number of elements in each bucket is \\(\\frac{n}{k}\\). Assuming sorting a single bucket uses \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) time, then sorting all buckets uses \\(O(n \\log\\frac{n}{k})\\) time. When the number of buckets \\(k\\) is relatively large, the time complexity approaches \\(O(n)\\). Merging results requires traversing all buckets and elements, taking \\(O(n + k)\\) time. In the worst case, all data is distributed into one bucket, and sorting that bucket uses \\(O(n^2)\\) time.</li> <li>Space complexity of \\(O(n + k)\\), non-in-place sorting: Additional space is required for \\(k\\) buckets and a total of \\(n\\) elements.</li> <li>Whether bucket sort is stable depends on whether the algorithm for sorting elements within buckets is stable.</li> </ul>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183-how-to-achieve-even-distribution","level":2,"title":"11.8.3   How to Achieve Even Distribution","text":"<p>Theoretically, bucket sort can achieve \\(O(n)\\) time complexity. The key is to evenly distribute elements to each bucket, because real data is often not evenly distributed. For example, if we want to evenly distribute all products on Taobao into 10 buckets by price range, there may be very many products below 100 yuan and very few above 1000 yuan. If the price intervals are evenly divided into 10, the difference in the number of products in each bucket will be very large.</p> <p>To achieve even distribution, we can first set an approximate dividing line to roughly divide the data into 3 buckets. After distribution is complete, continue dividing buckets with more products into 3 buckets until the number of elements in all buckets is roughly equal.</p> <p>As shown in Figure 11-14, this method essentially creates a recursion tree, with the goal of making the values of leaf nodes as even as possible. Of course, it is not necessary to divide the data into 3 buckets every round; the specific division method can be flexibly chosen according to data characteristics.</p> <p></p> <p> Figure 11-14   Recursively dividing buckets </p> <p>If we know the probability distribution of product prices in advance, we can set the price dividing line for each bucket based on the data probability distribution. It is worth noting that the data distribution does not necessarily need to be specifically calculated, but can also be approximated using a certain probability model based on data characteristics.</p> <p>As shown in Figure 11-15, we assume that product prices follow a normal distribution, which allows us to reasonably set price intervals to evenly distribute products to each bucket.</p> <p></p> <p> Figure 11-15   Dividing buckets based on probability distribution </p>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   Counting Sort","text":"<p>Counting sort (counting sort) achieves sorting by counting the number of elements, typically applied to integer arrays.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191-simple-implementation","level":2,"title":"11.9.1   Simple Implementation","text":"<p>Let's start with a simple example. Given an array <code>nums</code> of length \\(n\\), where the elements are all \"non-negative integers\", the overall flow of counting sort is shown in Figure 11-16.</p> <ol> <li>Traverse the array to find the largest number, denoted as \\(m\\), and then create an auxiliary array <code>counter</code> of length \\(m + 1\\).</li> <li>Use <code>counter</code> to count the number of occurrences of each number in <code>nums</code>, where <code>counter[num]</code> corresponds to the number of occurrences of the number <code>num</code>. The counting method is simple: just traverse <code>nums</code> (let the current number be <code>num</code>), and increase <code>counter[num]</code> by \\(1\\) in each round.</li> <li>Since each index of <code>counter</code> is naturally ordered, this is equivalent to all numbers being sorted. Next, we traverse <code>counter</code> and fill in <code>nums</code> in ascending order based on the number of occurrences of each number.</li> </ol> <p></p> <p> Figure 11-16   Counting sort flow </p> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"Counting sort\"\"\"\n    # Simple implementation, cannot be used for sorting objects\n    # 1. Count the maximum element m in the array\n    m = 0\n    for num in nums:\n        m = max(m, num)\n    # 2. Count the occurrence of each number\n    # counter[num] represents the occurrence of num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Traverse counter, filling each element back into the original array nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid CountingSortNaive(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunc countingSortNaive(nums []int) {\n    // 1. Count the maximum element m in the array\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. Count the maximum element m in the array\n    let m = nums.max()!\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunction countingSortNaive(nums) {\n    // 1. Count the maximum element m in the array\n    let m = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunction countingSortNaive(nums: number[]): void {\n    // 1. Count the maximum element m in the array\n    let m: number = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. Count the maximum element m in the array\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Count the occurrence of each number\n  // counter[_num] represents occurrence count of _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Traverse counter, filling each element back into the original array nums\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. Count the maximum element m in the array\n    let m = *nums.iter().max().unwrap();\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(int nums[], int size) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. Free memory\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfun countingSortNaive(nums: IntArray) {\n    // 1. Count the maximum element m in the array\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Counting sort ###\ndef counting_sort_naive(nums)\n  # Simple implementation, cannot be used for sorting objects\n  # 1. Count the maximum element m in the array\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. Count the occurrence of each number\n  # counter[num] represents the occurrence of num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Traverse counter, filling each element back into the original array nums\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> <p>Connection between counting sort and bucket sort</p> <p>From the perspective of bucket sort, we can regard each index of the counting array <code>counter</code> in counting sort as a bucket, and the process of counting quantities as distributing each element to the corresponding bucket. Essentially, counting sort is a special case of bucket sort for integer data.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192-complete-implementation","level":2,"title":"11.9.2   Complete Implementation","text":"<p>Observant readers may have noticed that if the input data is objects, step <code>3.</code> above becomes invalid. Suppose the input data is product objects, and we want to sort the products by price (a member variable of the class), but the above algorithm can only give the sorting result of prices.</p> <p>So how can we obtain the sorting result of the original data? We first calculate the \"prefix sum\" of <code>counter</code>. As the name suggests, the prefix sum at index <code>i</code>, <code>prefix[i]</code>, equals the sum of the first <code>i</code> elements of the array:</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>The prefix sum has a clear meaning: <code>prefix[num] - 1</code> represents the index of the last occurrence of element <code>num</code> in the result array <code>res</code>. This information is very critical because it tells us where each element should appear in the result array. Next, we traverse each element <code>num</code> of the original array <code>nums</code> in reverse order, performing the following two steps in each iteration.</p> <ol> <li>Fill <code>num</code> into the array <code>res</code> at index <code>prefix[num] - 1</code>.</li> <li>Decrease the prefix sum <code>prefix[num]</code> by \\(1\\) to get the index for the next placement of <code>num</code>.</li> </ol> <p>After the traversal is complete, the array <code>res</code> contains the sorted result, and finally <code>res</code> is used to overwrite the original array <code>nums</code>. The complete counting sort flow is shown in Figure 11-17.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-17   Counting sort steps </p> <p>The implementation code of counting sort is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"Counting sort\"\"\"\n    # Complete implementation, can sort objects and is a stable sort\n    # 1. Count the maximum element m in the array\n    m = max(nums)\n    # 2. Count the occurrence of each number\n    # counter[num] represents the occurrence of num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    # counter[num]-1 is the last index where num appears in res\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. Traverse nums in reverse order, placing each element into the result array res\n    # Initialize the array res to record results\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # Place num at the corresponding index\n        counter[num] -= 1  # Decrement the prefix sum by 1, getting the next index to place num\n    # Use result array res to overwrite the original array nums\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--;              // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid CountingSort(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunc countingSort(nums []int) {\n    // 1. Count the maximum element m in the array\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // Place num at the corresponding index\n        res[counter[num]-1] = num\n        // Decrement the prefix sum by 1, getting the next index to place num\n        counter[num]--\n    }\n    // Use result array res to overwrite the original array nums\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunc countingSort(nums: inout [Int]) {\n    // 1. Count the maximum element m in the array\n    let m = nums.max()!\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // Place num at the corresponding index\n        counter[num] -= 1 // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunction countingSort(nums) {\n    // 1. Count the maximum element m in the array\n    let m = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunction countingSort(nums: number[]): void {\n    // 1. Count the maximum element m in the array\n    let m: number = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. Count the maximum element m in the array\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Count the occurrence of each number\n  // counter[_num] represents occurrence count of _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n  // That is, counter[_num]-1 is the last occurrence index of _num in res\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. Traverse nums in reverse order, placing each element into the result array res\n  // Initialize the array res to record results\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // Place _num at corresponding index\n    counter[_num]--; // Decrement prefix sum by 1 to get next placement index for _num\n  }\n  // Use result array res to overwrite the original array nums\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. Count the maximum element m in the array\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // Place num at the corresponding index\n        counter[num as usize] -= 1; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(int nums[], int size) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--;              // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    memcpy(nums, res, size * sizeof(int));\n    // 5. Free memory\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfun countingSort(nums: IntArray) {\n    // 1. Count the maximum element m in the array\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // Place num at the corresponding index\n        counter[num]-- // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Counting sort ###\ndef counting_sort(nums)\n  # Complete implementation, can sort objects and is a stable sort\n  # 1. Count the maximum element m in the array\n  m = nums.max\n  # 2. Count the occurrence of each number\n  # counter[num] represents the occurrence of num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n  # counter[num]-1 is the last index where num appears in res\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. Traverse nums in reverse, fill elements into result array res\n  # Initialize the array res to record results\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # Place num at the corresponding index\n    counter[num] -= 1 # Decrement the prefix sum by 1, getting the next index to place num\n  end\n  # Use result array res to overwrite the original array nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193-algorithm-characteristics","level":2,"title":"11.9.3   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n + m)\\), non-adaptive sorting: Involves traversing <code>nums</code> and traversing <code>counter</code>, both using linear time. Generally, \\(n \\gg m\\), and time complexity tends toward \\(O(n)\\).</li> <li>Space complexity of \\(O(n + m)\\), non-in-place sorting: Uses arrays <code>res</code> and <code>counter</code> of lengths \\(n\\) and \\(m\\) respectively.</li> <li>Stable sorting: Since elements are filled into <code>res</code> in a \"right-to-left\" order, traversing <code>nums</code> in reverse can avoid changing the relative positions of equal elements, thereby achieving stable sorting. In fact, traversing <code>nums</code> in forward order can also yield correct sorting results, but the result would be unstable.</li> </ul>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194-limitations","level":2,"title":"11.9.4   Limitations","text":"<p>By this point, you might think counting sort is very clever, as it can achieve efficient sorting just by counting quantities. However, the prerequisites for using counting sort are relatively strict.</p> <p>Counting sort is only suitable for non-negative integers. If you want to apply it to other types of data, you need to ensure that the data can be converted to non-negative integers without changing the relative size relationships between elements. For example, for an integer array containing negative numbers, you can first add a constant to all numbers to convert them all to positive numbers, and then convert them back after sorting is complete.</p> <p>Counting sort is suitable for situations where the data volume is large but the data range is small. For example, in the above example, \\(m\\) cannot be too large, otherwise it will occupy too much space. And when \\(n \\ll m\\), counting sort uses \\(O(m)\\) time, which may be slower than \\(O(n \\log n)\\) sorting algorithms.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   Heap Sort","text":"<p>Tip</p> <p>Before reading this section, please ensure you have completed the \"Heap\" chapter.</p> <p>Heap sort (heap sort) is an efficient sorting algorithm based on the heap data structure. We can use the \"build heap operation\" and \"element out-heap operation\" that we have already learned to implement heap sort.</p> <ol> <li>Input the array and build a min-heap, at which point the smallest element is at the heap top.</li> <li>Continuously perform the out-heap operation, record the out-heap elements in sequence, and an ascending sorted sequence can be obtained.</li> </ol> <p>Although the above method is feasible, it requires an additional array to save the popped elements, which is quite wasteful of space. In practice, we usually use a more elegant implementation method.</p>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171-algorithm-flow","level":2,"title":"11.7.1   Algorithm Flow","text":"<p>Assume the array length is \\(n\\). The flow of heap sort is shown in Figure 11-12.</p> <ol> <li>Input the array and build a max-heap. After completion, the largest element is at the heap top.</li> <li>Swap the heap top element (first element) with the heap bottom element (last element). After the swap is complete, reduce the heap length by \\(1\\) and increase the count of sorted elements by \\(1\\).</li> <li>Starting from the heap top element, perform top-to-bottom heapify operation (sift down). After heapify is complete, the heap property is restored.</li> <li>Loop through steps <code>2.</code> and <code>3.</code> After looping \\(n - 1\\) rounds, the array sorting can be completed.</li> </ol> <p>Tip</p> <p>In fact, the element out-heap operation also includes steps <code>2.</code> and <code>3.</code>, with just an additional step to pop the element.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-12   Heap sort steps </p> <p>In the code implementation, we use the same top-to-bottom heapify function <code>sift_down()</code> from the \"Heap\" chapter. It is worth noting that since the heap length will decrease as the largest element is extracted, we need to add a length parameter \\(n\\) to the <code>sift_down()</code> function to specify the current effective length of the heap. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"Heap length is n, start heapifying node i, from top to bottom\"\"\"\n    while True:\n        # Determine the largest node among i, l, r, noted as ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # If node i is the largest or indices l, r are out of bounds, no further heapification needed, break\n        if ma == i:\n            break\n        # Swap two nodes\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # Loop downwards heapification\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"Heap sort\"\"\"\n    # Build heap operation: heapify all nodes except leaves\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # Extract the largest element from the heap and repeat for n-1 rounds\n    for i in range(len(nums) - 1, 0, -1):\n        # Swap the root node with the rightmost leaf node (swap the first element with the last element)\n        nums[0], nums[i] = nums[i], nums[0]\n        # Start heapifying the root node, from top to bottom\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i) {\n            break;\n        }\n        // Swap two nodes\n        swap(nums[i], nums[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // Delete node\n        swap(nums[0], nums[i]);\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(int[] nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid HeapSort(int[] nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Delete node\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // Start heapifying the root node, from top to bottom\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfunc heapSort(nums *[]int) {\n    // Build heap operation: heapify all nodes except leaves\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // Delete node\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        nums.swapAt(i, ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfunc heapSort(nums: inout [Int]) {\n    // Build heap operation: heapify all nodes except leaves\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i in nums.indices.dropFirst().reversed() {\n        // Delete node\n        nums.swapAt(0, i)\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Swap two nodes\n        if (ma === i) {\n            break;\n        }\n        // Swap two nodes\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfunction heapSort(nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Swap two nodes\n        if (ma === i) {\n            break;\n        }\n        // Swap two nodes\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfunction heapSort(nums: number[]): void {\n    // Build heap operation: heapify all nodes except leaves\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // Swap two nodes\n    if (ma == i) break;\n    // Swap two nodes\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // Loop downwards heapification\n    i = ma;\n  }\n}\n\n/* Heap sort */\nvoid heapSort(List&lt;int&gt; nums) {\n  // Build heap operation: heapify all nodes except leaves\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // Extract the largest element from the heap and repeat for n-1 rounds\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Delete node\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // Start heapifying the root node, from top to bottom\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // Swap two nodes\n        if ma == i {\n            break;\n        }\n        // Swap two nodes\n        nums.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // Build heap operation: heapify all nodes except leaves\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i in (1..nums.len()).rev() {\n        // Delete node\n        nums.swap(0, i);\n        // Start heapifying the root node, from top to bottom\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i) {\n            break;\n        }\n        // Swap two nodes\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(int nums[], int n) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = n - 1; i &gt; 0; --i) {\n        // Delete node\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // Swap two nodes\n        if (ma == i) \n            break\n        // Swap two nodes\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfun heapSort(nums: IntArray) {\n    // Build heap operation: heapify all nodes except leaves\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (i in nums.size - 1 downTo 1) {\n        // Delete node\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### Heap length is n, heapify from node i, top to bottom ###\ndef sift_down(nums, n, i)\n  while true\n    # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # Swap two nodes\n    break if ma == i\n    # Swap two nodes\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # Loop downwards heapification\n    i = ma\n  end\nend\n\n### Heap sort ###\ndef heap_sort(nums)\n  # Build heap operation: heapify all nodes except leaves\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # Extract the largest element from the heap and repeat for n-1 rounds\n  (nums.length - 1).downto(1) do |i|\n    # Delete node\n    nums[0], nums[i] = nums[i], nums[0]\n    # Start heapifying the root node, from top to bottom\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172-algorithm-characteristics","level":2,"title":"11.7.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: The build heap operation uses \\(O(n)\\) time. Extracting the largest element from the heap has a time complexity of \\(O(\\log n)\\), looping a total of \\(n - 1\\) rounds.</li> <li>Space complexity of \\(O(1)\\), in-place sorting: A few pointer variables use \\(O(1)\\) space. Element swapping and heapify operations are both performed on the original array.</li> <li>Non-stable sorting: When swapping the heap top element and heap bottom element, the relative positions of equal elements may change.</li> </ul>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   Insertion Sort","text":"<p>Insertion sort (insertion sort) is a simple sorting algorithm that works very similarly to the process of manually organizing a deck of cards.</p> <p>Specifically, we select a base element from the unsorted interval, compare the element with elements in the sorted interval to its left one by one, and insert the element into the correct position.</p> <p>Figure 11-6 shows the operation flow of inserting an element into the array. Let the base element be <code>base</code>. We need to move all elements from the target index to <code>base</code> one position to the right, and then assign <code>base</code> to the target index.</p> <p></p> <p> Figure 11-6   Single insertion operation </p>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141-algorithm-flow","level":2,"title":"11.4.1   Algorithm Flow","text":"<p>The overall flow of insertion sort is shown in Figure 11-7.</p> <ol> <li>Initially, the first element of the array has completed sorting.</li> <li>Select the second element of the array as <code>base</code>, and after inserting it into the correct position, the first 2 elements of the array are sorted.</li> <li>Select the third element as <code>base</code>, and after inserting it into the correct position, the first 3 elements of the array are sorted.</li> <li>And so on. In the last round, select the last element as <code>base</code>, and after inserting it into the correct position, all elements are sorted.</li> </ol> <p></p> <p> Figure 11-7   Insertion sort flow </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"Insertion sort\"\"\"\n    # Outer loop: sorted interval is [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # Move nums[j] to the right by one position\n            j -= 1\n        nums[j + 1] = base  # Assign base to the correct position\n</code></pre> insertion_sort.cpp<pre><code>/* Insertion sort */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* Insertion sort */\nvoid insertionSort(int[] nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base;        // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* Insertion sort */\nvoid InsertionSort(int[] nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = bas;         // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* Insertion sort */\nfunc insertionSort(nums []int) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // Move nums[j] to the right by one position\n            j--\n        }\n        nums[j+1] = base // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* Insertion sort */\nfunc insertionSort(nums: inout [Int]) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // Move nums[j] to the right by one position\n            j -= 1\n        }\n        nums[j + 1] = base // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* Insertion sort */\nfunction insertionSort(nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* Insertion sort */\nfunction insertionSort(nums: number[]): void {\n    // Outer loop: sorted interval is [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* Insertion sort */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // Outer loop: sorted interval is [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n      j--;\n    }\n    nums[j + 1] = base; // Assign base to the correct position\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* Insertion sort */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // Move nums[j] to the right by one position\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* Insertion sort */\nvoid insertionSort(int nums[], int size) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // Move nums[j] to the right by one position\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // Assign base to the correct position\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* Insertion sort */\nfun insertionSort(nums: IntArray) {\n    // Outer loop: sorted elements are 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // Move nums[j] to the right by one position\n            j--\n        }\n        nums[j + 1] = base        // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### Insertion sort ###\ndef insertion_sort(nums)\n  n = nums.length\n  # Outer loop: sorted interval is [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # Move nums[j] to the right by one position\n      j -= 1\n    end\n    nums[j + 1] = base # Assign base to the correct position\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142-algorithm-characteristics","level":2,"title":"11.4.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), adaptive sorting: In the worst case, each insertion operation requires loops of \\(n - 1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\), summing to \\((n - 1) n / 2\\), so the time complexity is \\(O(n^2)\\). When encountering ordered data, the insertion operation will terminate early. When the input array is completely ordered, insertion sort achieves the best-case time complexity of \\(O(n)\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Stable sorting: During the insertion operation process, we insert elements to the right of equal elements, without changing their order.</li> </ul>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143-advantages-of-insertion-sort","level":2,"title":"11.4.3   Advantages of Insertion Sort","text":"<p>The time complexity of insertion sort is \\(O(n^2)\\), while the time complexity of quick sort, which we will learn about next, is \\(O(n \\log n)\\). Although insertion sort has a higher time complexity, insertion sort is usually faster for smaller data volumes.</p> <p>This conclusion is similar to the applicable situations of linear search and binary search. Algorithms like quick sort with \\(O(n \\log n)\\) complexity are sorting algorithms based on divide-and-conquer strategy and often contain more unit computation operations. When the data volume is small, \\(n^2\\) and \\(n \\log n\\) are numerically close, and complexity does not dominate; the number of unit operations per round plays a decisive role.</p> <p>In fact, the built-in sorting functions in many programming languages (such as Java) adopt insertion sort. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategy, such as quick sort; for short arrays, directly use insertion sort.</p> <p>Although bubble sort, selection sort, and insertion sort all have a time complexity of \\(O(n^2)\\), in actual situations, insertion sort is used significantly more frequently than bubble sort and selection sort, mainly for the following reasons.</p> <ul> <li>Bubble sort is based on element swapping, requiring the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, the computational overhead of bubble sort is usually higher than that of insertion sort.</li> <li>Selection sort has a time complexity of \\(O(n^2)\\) in any case. If given a set of partially ordered data, insertion sort is usually more efficient than selection sort.</li> <li>Selection sort is unstable and cannot be applied to multi-level sorting.</li> </ul>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   Merge Sort","text":"<p>Merge sort (merge sort) is a sorting algorithm based on the divide-and-conquer strategy, which includes the \"divide\" and \"merge\" phases shown in Figure 11-10.</p> <ol> <li>Divide phase: Recursively split the array from the midpoint, transforming the sorting problem of a long array into the sorting problems of shorter arrays.</li> <li>Merge phase: When the sub-array length is 1, terminate the division and start merging, continuously merging two shorter sorted arrays into one longer sorted array until the process is complete.</li> </ol> <p></p> <p> Figure 11-10   Divide and merge phases of merge sort </p>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161-algorithm-flow","level":2,"title":"11.6.1   Algorithm Flow","text":"<p>As shown in Figure 11-11, the \"divide phase\" recursively splits the array from the midpoint into two sub-arrays from top to bottom.</p> <ol> <li>Calculate the array midpoint <code>mid</code>, recursively divide the left sub-array (interval <code>[left, mid]</code>) and right sub-array (interval <code>[mid + 1, right]</code>).</li> <li>Recursively execute step <code>1.</code> until the sub-array interval length is 1, then terminate.</li> </ol> <p>The \"merge phase\" merges the left sub-array and right sub-array into a sorted array from bottom to top. Note that merging starts from sub-arrays of length 1, and each sub-array in the merge phase is sorted.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-11   Merge sort steps </p> <p>It can be observed that the recursive order of merge sort is consistent with the post-order traversal of a binary tree.</p> <ul> <li>Post-order traversal: First recursively traverse the left subtree, then recursively traverse the right subtree, and finally process the root node.</li> <li>Merge sort: First recursively process the left sub-array, then recursively process the right sub-array, and finally perform the merge.</li> </ul> <p>The implementation of merge sort is shown in the code below. Note that the interval to be merged in <code>nums</code> is <code>[left, right]</code>, while the corresponding interval in <code>tmp</code> is <code>[0, right - left]</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"Merge left subarray and right subarray\"\"\"\n    # Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    # Create a temporary array tmp to store the merged results\n    tmp = [0] * (right - left + 1)\n    # Initialize the start indices of the left and right subarrays\n    i, j, k = left, mid + 1, 0\n    # While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"Merge sort\"\"\"\n    # Termination condition\n    if left &gt;= right:\n        return  # Terminate recursion when subarray length is 1\n    # Divide and conquer stage\n    mid = (left + right) // 2  # Calculate midpoint\n    merge_sort(nums, left, mid)  # Recursively process the left subarray\n    merge_sort(nums, mid + 1, right)  # Recursively process the right subarray\n    # Merge stage\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* Merge left subarray and right subarray */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    vector&lt;int&gt; tmp(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    mergeSort(nums, left, mid);      // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* Merge left subarray and right subarray */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int[] tmp = new int[right - left + 1];\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid mergeSort(int[] nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2; // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* Merge left subarray and right subarray */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int[] tmp = new int[right - left + 1];\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid MergeSort(int[] nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right) return;       // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    MergeSort(nums, left, mid);      // Recursively process the left subarray\n    MergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* Merge left subarray and right subarray */\nfunc merge(nums []int, left, mid, right int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    tmp := make([]int, right-left+1)\n    // Initialize the start indices of the left and right subarrays\n    i, j, k := left, mid+1, 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* Merge sort */\nfunc mergeSort(nums []int, left, right int) {\n    // Termination condition\n    if left &gt;= right {\n        return\n    }\n    // Divide and conquer stage\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // Merge stage\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* Merge left subarray and right subarray */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // Initialize the start indices of the left and right subarrays\n    var i = left, j = mid + 1, k = 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* Merge sort */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // Termination condition\n    if left &gt;= right { // Terminate recursion when subarray length is 1\n        return\n    }\n    // Divide and conquer stage\n    let mid = left + (right - left) / 2 // Calculate midpoint\n    mergeSort(nums: &amp;nums, left: left, right: mid) // Recursively process the left subarray\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // Recursively process the right subarray\n    // Merge stage\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* Merge left subarray and right subarray */\nfunction merge(nums, left, mid, right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    const tmp = new Array(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfunction mergeSort(nums, left, right) {\n    // Termination condition\n    if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    let mid = Math.floor(left + (right - left) / 2); // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* Merge left subarray and right subarray */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    const tmp = new Array(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // Termination condition\n    if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    let mid = Math.floor(left + (right - left) / 2); // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* Merge left subarray and right subarray */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n  // Create a temporary array tmp to store the merged results\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // Initialize the start indices of the left and right subarrays\n  int i = left, j = mid + 1, k = 0;\n  // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // Copy the remaining elements of the left and right subarrays into the temporary array\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* Merge sort */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // Termination condition\n  if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n  // Divide and conquer stage\n  int mid = left + (right - left) ~/ 2; // Calculate midpoint\n  mergeSort(nums, left, mid); // Recursively process the left subarray\n  mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n  // Merge stage\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* Merge left subarray and right subarray */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // Initialize the start indices of the left and right subarrays\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // Termination condition\n    if left &gt;= right {\n        return; // Terminate recursion when subarray length is 1\n    }\n\n    // Divide and conquer stage\n    let mid = left + (right - left) / 2; // Calculate midpoint\n    merge_sort(nums, left, mid); // Recursively process the left subarray\n    merge_sort(nums, mid + 1, right); // Recursively process the right subarray\n\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* Merge left subarray and right subarray */\nvoid merge(int *nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // Free memory\n    free(tmp);\n}\n\n/* Merge sort */\nvoid mergeSort(int *nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    mergeSort(nums, left, mid);      // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* Merge left subarray and right subarray */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    val tmp = IntArray(right - left + 1)\n    // Initialize the start indices of the left and right subarrays\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* Merge sort */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // Termination condition\n    if (left &gt;= right) return  // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    val mid = left + (right - left) / 2 // Calculate midpoint\n    mergeSort(nums, left, mid) // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right) // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### Merge left and right subarrays ###\ndef merge(nums, left, mid, right)\n  # Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n  # Create temporary array tmp to store merged result\n  tmp = Array.new(right - left + 1, 0)\n  # Initialize the start indices of the left and right subarrays\n  i, j, k = left, mid + 1, 0\n  # While both subarrays still have elements, compare and copy the smaller element into the temporary array\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # Copy the remaining elements of the left and right subarrays into the temporary array\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### Merge sort ###\ndef merge_sort(nums, left, right)\n  # Termination condition\n  # Terminate recursion when subarray length is 1\n  return if left &gt;= right\n  # Divide and conquer stage\n  mid = left + (right - left) / 2 # Calculate midpoint\n  merge_sort(nums, left, mid) # Recursively process the left subarray\n  merge_sort(nums, mid + 1, right) # Recursively process the right subarray\n  # Merge stage\n  merge(nums, left, mid, right)\nend\n</code></pre>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162-algorithm-characteristics","level":2,"title":"11.6.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: The division produces a recursion tree of height \\(\\log n\\), and the total number of merge operations at each level is \\(n\\), so the overall time complexity is \\(O(n \\log n)\\).</li> <li>Space complexity of \\(O(n)\\), non-in-place sorting: The recursion depth is \\(\\log n\\), using \\(O(\\log n)\\) size of stack frame space. The merge operation requires the aid of an auxiliary array, using \\(O(n)\\) size of additional space.</li> <li>Stable sorting: In the merge process, the order of equal elements remains unchanged.</li> </ul>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163-linked-list-sorting","level":2,"title":"11.6.3   Linked List Sorting","text":"<p>For linked lists, merge sort has significant advantages over other sorting algorithms, and can optimize the space complexity of linked list sorting tasks to \\(O(1)\\).</p> <ul> <li>Divide phase: \"Iteration\" can be used instead of \"recursion\" to implement linked list division work, thus saving the stack frame space used by recursion.</li> <li>Merge phase: In linked lists, node insertion and deletion operations can be achieved by just changing references (pointers), so there is no need to create additional linked lists during the merge phase (merging two short ordered linked lists into one long ordered linked list).</li> </ul> <p>The specific implementation details are quite complex, and interested readers can consult related materials for learning.</p>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   Quick Sort","text":"<p>Quick sort (quick sort) is a sorting algorithm based on the divide-and-conquer strategy, which operates efficiently and is widely applied.</p> <p>The core operation of quick sort is \"sentinel partitioning\", which aims to: select a certain element in the array as the \"pivot\", move all elements smaller than the pivot to its left, and move elements larger than the pivot to its right. Specifically, the flow of sentinel partitioning is shown in Figure 11-8.</p> <ol> <li>Select the leftmost element of the array as the pivot, and initialize two pointers <code>i</code> and <code>j</code> pointing to the two ends of the array.</li> <li>Set up a loop in which <code>i</code> (<code>j</code>) is used in each round to find the first element larger (smaller) than the pivot, and then swap these two elements.</li> <li>Loop through step <code>2.</code> until <code>i</code> and <code>j</code> meet, and finally swap the pivot to the boundary line of the two sub-arrays.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-8   Sentinel partitioning steps </p> <p>After sentinel partitioning is complete, the original array is divided into three parts: left sub-array, pivot, right sub-array, satisfying \"any element in left sub-array \\(\\leq\\) pivot \\(\\leq\\) any element in right sub-array\". Therefore, we next only need to sort these two sub-arrays.</p> <p>Divide-and-conquer strategy of quick sort</p> <p>The essence of sentinel partitioning is to simplify the sorting problem of a longer array into the sorting problems of two shorter arrays.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Sentinel partition\"\"\"\n    # Use nums[left] as the pivot\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Search from right to left for the first element smaller than the pivot\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Search from left to right for the first element greater than the pivot\n        # Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    # Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Return the index of the pivot\n</code></pre> quick_sort.cpp<pre><code>/* Sentinel partition */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Search from left to right for the first element greater than the pivot\n        swap(nums[i], nums[j]); // Swap these two elements\n    }\n    swap(nums[i], nums[left]);  // Swap the pivot to the boundary between the two subarrays\n    return i;                   // Return the index of the pivot\n}\n</code></pre> quick_sort.java<pre><code>/* Swap elements */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint partition(int[] nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.cs<pre><code>/* Swap elements */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* Sentinel partition */\nint Partition(int[] nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        Swap(nums, i, j); // Swap these two elements\n    }\n    Swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.go<pre><code>/* Sentinel partition */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // Use nums[left] as the pivot\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Search from right to left for the first element smaller than the pivot\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.swift<pre><code>/* Sentinel partition */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // Search from left to right for the first element greater than the pivot\n        }\n        nums.swapAt(i, j) // Swap these two elements\n    }\n    nums.swapAt(i, left) // Swap the pivot to the boundary between the two subarrays\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.js<pre><code>/* Swap elements */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\npartition(nums, left, right) {\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.ts<pre><code>/* Swap elements */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\npartition(nums: number[], left: number, right: number): number {\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.dart<pre><code>/* Swap elements */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Use nums[left] as the pivot\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n    _swap(nums, i, j); // Swap these two elements\n  }\n  _swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n  return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.rs<pre><code>/* Sentinel partition */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Use nums[left] as the pivot\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        nums.swap(i, j); // Swap these two elements\n    }\n    nums.swap(i, left); // Swap the pivot to the boundary between the two subarrays\n    i // Return the index of the pivot\n}\n</code></pre> quick_sort.c<pre><code>/* Swap elements */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint partition(int nums[], int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap these two elements\n        swap(nums, i, j);\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    swap(nums, i, left);\n    // Return the index of the pivot\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* Swap elements */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* Sentinel partition */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j)  // Swap these two elements\n    }\n    swap(nums, i, left)   // Swap the pivot to the boundary between the two subarrays\n    return i              // Return the index of the pivot\n}\n</code></pre> quick_sort.rb<pre><code>### Sentinel partition ###\ndef partition(nums, left, right)\n  # Use nums[left] as the pivot\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Search from right to left for the first element smaller than the pivot\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Search from left to right for the first element greater than the pivot\n    end\n    # Swap elements\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Swap the pivot to the boundary between the two subarrays\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Return the index of the pivot\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151-algorithm-flow","level":2,"title":"11.5.1   Algorithm Flow","text":"<p>The overall flow of quick sort is shown in Figure 11-9.</p> <ol> <li>First, perform one \"sentinel partitioning\" on the original array to obtain the unsorted left sub-array and right sub-array.</li> <li>Then, recursively perform \"sentinel partitioning\" on the left sub-array and right sub-array respectively.</li> <li>Continue recursively until the sub-array length is 1, at which point sorting of the entire array is complete.</li> </ol> <p></p> <p> Figure 11-9   Quick sort flow </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Quick sort\"\"\"\n    # Terminate recursion when subarray length is 1\n    if left &gt;= right:\n        return\n    # Sentinel partition\n    pivot = self.partition(nums, left, right)\n    # Recursively process the left subarray and right subarray\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* Quick sort */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* Quick sort */\nvoid quickSort(int[] nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* Quick sort */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = Partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* Quick sort */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return\n    }\n    // Sentinel partition\n    pivot := q.partition(nums, left, right)\n    // Recursively process the left subarray and right subarray\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* Quick sort */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return\n    }\n    // Sentinel partition\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // Recursively process the left subarray and right subarray\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Quick sort */\nquickSort(nums, left, right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) return;\n    // Sentinel partition\n    const pivot = this.partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* Quick sort */\nquickSort(nums: number[], left: number, right: number): void {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Sentinel partition\n    const pivot = this.partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* Quick sort */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Terminate recursion when subarray length is 1\n  if (left &gt;= right) return;\n  // Sentinel partition\n  int pivot = _partition(nums, left, right);\n  // Recursively process the left subarray and right subarray\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* Quick sort */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return;\n    }\n    // Sentinel partition\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // Recursively process the left subarray and right subarray\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* Quick sort */\nvoid quickSort(int nums[], int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* Quick sort */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) return\n    // Sentinel partition\n    val pivot = partition(nums, left, right)\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### Quick sort class ###\ndef quick_sort(nums, left, right)\n  # Recurse when subarray length is not 1\n  if left &lt; right\n    # Sentinel partition\n    pivot = partition(nums, left, right)\n    # Recursively process the left subarray and right subarray\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152-algorithm-characteristics","level":2,"title":"11.5.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: In the average case, the number of recursive levels of sentinel partitioning is \\(\\log n\\), and the total number of loops at each level is \\(n\\), using \\(O(n \\log n)\\) time overall. In the worst case, each round of sentinel partitioning divides an array of length \\(n\\) into two sub-arrays of length \\(0\\) and \\(n - 1\\), at which point the number of recursive levels reaches \\(n\\), the number of loops at each level is \\(n\\), and the total time used is \\(O(n^2)\\).</li> <li>Space complexity of \\(O(n)\\), in-place sorting: In the case where the input array is completely reversed, the worst recursive depth reaches \\(n\\), using \\(O(n)\\) stack frame space. The sorting operation is performed on the original array without the aid of an additional array.</li> <li>Non-stable sorting: In the last step of sentinel partitioning, the pivot may be swapped to the right of equal elements.</li> </ul>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153-why-is-quick-sort-fast","level":2,"title":"11.5.3   Why Is Quick Sort Fast","text":"<p>From the name, we can see that quick sort should have certain advantages in terms of efficiency. Although the average time complexity of quick sort is the same as \"merge sort\" and \"heap sort\", quick sort is usually more efficient, mainly for the following reasons.</p> <ul> <li>The probability of the worst case occurring is very low: Although the worst-case time complexity of quick sort is \\(O(n^2)\\), which is not as stable as merge sort, in the vast majority of cases, quick sort can run with a time complexity of \\(O(n \\log n)\\).</li> <li>High cache utilization: When performing sentinel partitioning operations, the system can load the entire sub-array into the cache, so element access efficiency is relatively high. Algorithms like \"heap sort\" require jump-style access to elements, thus lacking this characteristic.</li> <li>Small constant coefficient of complexity: Among the three algorithms mentioned above, quick sort has the smallest total number of operations such as comparisons, assignments, and swaps. This is similar to the reason why \"insertion sort\" is faster than \"bubble sort\".</li> </ul>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154-pivot-optimization","level":2,"title":"11.5.4   Pivot Optimization","text":"<p>Quick sort may have reduced time efficiency for certain inputs. Take an extreme example: suppose the input array is completely reversed. Since we select the leftmost element as the pivot, after sentinel partitioning is complete, the pivot is swapped to the rightmost end of the array, causing the left sub-array length to be \\(n - 1\\) and the right sub-array length to be \\(0\\). If we recurse down like this, each round of sentinel partitioning will have a sub-array length of \\(0\\), the divide-and-conquer strategy fails, and quick sort degrades to a form approximate to \"bubble sort\".</p> <p>To avoid this situation as much as possible, we can optimize the pivot selection strategy in sentinel partitioning. For example, we can randomly select an element as the pivot. However, if luck is not good and we select a non-ideal pivot every time, efficiency is still not satisfactory.</p> <p>It should be noted that programming languages usually generate \"pseudo-random numbers\". If we construct a specific test case for a pseudo-random number sequence, the efficiency of quick sort may still degrade.</p> <p>For further improvement, we can select three candidate elements in the array (usually the first, last, and middle elements of the array), and use the median of these three candidate elements as the pivot. In this way, the probability that the pivot is \"neither too small nor too large\" will be greatly increased. Of course, we can also select more candidate elements to further improve the robustness of the algorithm. After adopting this method, the probability of time complexity degrading to \\(O(n^2)\\) is greatly reduced.</p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"Select the median of three candidate elements\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m is between l and r\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l is between m and r\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Sentinel partition (median of three)\"\"\"\n    # Use nums[left] as the pivot\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # Swap the median to the array's leftmost position\n    nums[left], nums[med] = nums[med], nums[left]\n    # Use nums[left] as the pivot\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Search from right to left for the first element smaller than the pivot\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Search from left to right for the first element greater than the pivot\n        # Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    # Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Return the index of the pivot\n</code></pre> quick_sort.cpp<pre><code>/* Select the median of three candidate elements */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums[left], nums[med]);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Search from left to right for the first element greater than the pivot\n        swap(nums[i], nums[j]); // Swap these two elements\n    }\n    swap(nums[i], nums[left]);  // Swap the pivot to the boundary between the two subarrays\n    return i;                   // Return the index of the pivot\n}\n</code></pre> quick_sort.java<pre><code>/* Select the median of three candidate elements */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partition(int[] nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.cs<pre><code>/* Select the median of three candidate elements */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint Partition(int[] nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    Swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        Swap(nums, i, j); // Swap these two elements\n    }\n    Swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.go<pre><code>/* Select the median of three candidate elements */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l is between m and r\n    }\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // Use nums[left] as the pivot\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // Swap the median to the array's leftmost position\n    nums[left], nums[med] = nums[med], nums[left]\n    // Use nums[left] as the pivot\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Search from right to left for the first element smaller than the pivot\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.swift<pre><code>/* Select the median of three candidate elements */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l is between m and r\n    }\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Select the median of three candidate elements\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // Swap the median to the array's leftmost position\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Select the median of three candidate elements */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m is between l and r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l is between m and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Sentinel partition (median of three) */\npartition(nums, left, right) {\n    // Select the median of three candidate elements\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Swap the median to the array's leftmost position\n    this.swap(nums, left, med);\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.ts<pre><code>/* Select the median of three candidate elements */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m is between l and r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l is between m and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Sentinel partition (median of three) */\npartition(nums: number[], left: number, right: number): number {\n    // Select the median of three candidate elements\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Swap the median to the array's leftmost position\n    this.swap(nums, left, med);\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Search from left to right for the first element greater than the pivot\n        }\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.dart<pre><code>/* Select the median of three candidate elements */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m is between l and r\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l is between m and r\n  return right;\n}\n\n/* Sentinel partition (median of three) */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Select the median of three candidate elements\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // Swap the median to the array's leftmost position\n  _swap(nums, left, med);\n  // Use nums[left] as the pivot\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n    _swap(nums, i, j); // Swap these two elements\n  }\n  _swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n  return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.rs<pre><code>/* Select the median of three candidate elements */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l is between m and r\n    }\n    right\n}\n\n/* Sentinel partition (median of three) */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Select the median of three candidate elements\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    nums.swap(left, med);\n    // Use nums[left] as the pivot\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        nums.swap(i, j); // Swap these two elements\n    }\n    nums.swap(i, left); // Swap the pivot to the boundary between the two subarrays\n    i // Return the index of the pivot\n}\n</code></pre> quick_sort.c<pre><code>/* Select the median of three candidate elements */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partitionMedian(int nums[], int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i;            // Return the index of the pivot\n}\n</code></pre> quick_sort.kt<pre><code>/* Select the median of three candidate elements */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m is between l and r\n    if ((l in m..r) || (l in r..m))\n        return left // l is between m and r\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // Select the median of three candidate elements\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med)\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j)             // Swap these two elements\n    }\n    swap(nums, i, left)              // Swap the pivot to the boundary between the two subarrays\n    return i                         // Return the index of the pivot\n}\n</code></pre> quick_sort.rb<pre><code>### Select median of three candidate elements ###\ndef median_three(nums, left, mid, right)\n  # Select the median of three candidate elements\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m is between l and r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l is between m and r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### Sentinel partition (median of three) ###\ndef partition(nums, left, right)\n  ### Use nums[left] as pivot\n  med = median_three(nums, left, (left + right) / 2, right)\n  # Swap median to leftmost position of array\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Search from right to left for the first element smaller than the pivot\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Search from left to right for the first element greater than the pivot\n    end\n    # Swap elements\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Swap the pivot to the boundary between the two subarrays\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Return the index of the pivot\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155-recursive-depth-optimization","level":2,"title":"11.5.5   Recursive Depth Optimization","text":"<p>For certain inputs, quick sort may occupy more space. Taking a completely ordered input array as an example, let the length of the sub-array in recursion be \\(m\\). Each round of sentinel partitioning will produce a left sub-array of length \\(0\\) and a right sub-array of length \\(m - 1\\), which means that the problem scale reduced per recursive call is very small (only one element is reduced), and the height of the recursion tree will reach \\(n - 1\\), at which point \\(O(n)\\) size of stack frame space is required.</p> <p>To prevent the accumulation of stack frame space, we can compare the lengths of the two sub-arrays after each round of sentinel sorting is complete, and only recurse on the shorter sub-array. Since the length of the shorter sub-array will not exceed \\(n / 2\\), this method can ensure that the recursion depth does not exceed \\(\\log n\\), thus optimizing the worst-case space complexity to \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Quick sort (recursion depth optimization)\"\"\"\n    # Terminate when subarray length is 1\n    while left &lt; right:\n        # Sentinel partition operation\n        pivot = self.partition(nums, left, right)\n        # Perform quick sort on the shorter of the two subarrays\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # Recursively sort the left subarray\n            left = pivot + 1  # Remaining unsorted interval is [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # Recursively sort the right subarray\n            right = pivot - 1  # Remaining unsorted interval is [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1;                 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1;                 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(int[] nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* Quick sort (recursion depth optimization) */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = Partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // Recursively sort the left subarray\n            left = pivot + 1;  // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* Quick sort (recursion depth optimization) */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // Terminate when subarray length is 1\n    for left &lt; right {\n        // Sentinel partition operation\n        pivot := q.partition(nums, left, right)\n        // Perform quick sort on the shorter of the two subarrays\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // Recursively sort the left subarray\n            left = pivot + 1                 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // Recursively sort the right subarray\n            right = pivot - 1                 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* Quick sort (recursion depth optimization) */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // Terminate when subarray length is 1\n    while left &lt; right {\n        // Sentinel partition operation\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // Recursively sort the left subarray\n            left = pivot + 1 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // Recursively sort the right subarray\n            right = pivot - 1 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* Quick sort (recursion depth optimization) */\nquickSort(nums, left, right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        let pivot = this.partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* Quick sort (recursion depth optimization) */\nquickSort(nums: number[], left: number, right: number): void {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        let pivot = this.partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Terminate when subarray length is 1\n  while (left &lt; right) {\n    // Sentinel partition operation\n    int pivot = _partition(nums, left, right);\n    // Perform quick sort on the shorter of the two subarrays\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n      left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n      right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* Quick sort (recursion depth optimization) */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // Terminate when subarray length is 1\n    while left &lt; right {\n        // Sentinel partition operation\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // Perform quick sort on the shorter of the two subarrays\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            // Recursively sort the left subarray\n            quickSortTailCall(nums, left, pivot - 1);\n            // Remaining unsorted interval is [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // Recursively sort the right subarray\n            quickSortTailCall(nums, pivot + 1, right);\n            // Remaining unsorted interval is [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* Quick sort (recursion depth optimization) */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // Terminate when subarray length is 1\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // Sentinel partition operation\n        val pivot = partition(nums, l, r)\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // Recursively sort the left subarray\n            l = pivot + 1 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // Recursively sort the right subarray\n            r = pivot - 1 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### Quick sort (recursion depth optimization) ###\ndef quick_sort(nums, left, right)\n  # Recurse when subarray length is not 1\n  while left &lt; right\n    # Sentinel partition\n    pivot = partition(nums, left, right)\n    # Perform quick sort on the shorter of the two subarrays\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # Remaining unsorted interval is [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # Remaining unsorted interval is [left, pivot - 1]\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   Radix Sort","text":"<p>The previous section introduced counting sort, which is suitable for situations where the data volume \\(n\\) is large but the data range \\(m\\) is small. Suppose we need to sort \\(n = 10^6\\) student IDs, and the student ID is an 8-digit number, which means the data range \\(m = 10^8\\) is very large. Using counting sort would require allocating a large amount of memory space, whereas radix sort can avoid this situation.</p> <p>Radix sort (radix sort) has a core idea consistent with counting sort, which also achieves sorting by counting quantities. Building on this, radix sort utilizes the progressive relationship between the digits of numbers, sorting each digit in turn to obtain the final sorting result.</p>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101-algorithm-flow","level":2,"title":"11.10.1   Algorithm Flow","text":"<p>Taking student ID data as an example, assume the lowest digit is the \\(1\\)st digit and the highest digit is the \\(8\\)th digit. The flow of radix sort is shown in Figure 11-18.</p> <ol> <li>Initialize the digit \\(k = 1\\).</li> <li>Perform \"counting sort\" on the \\(k\\)th digit of the student IDs. After completion, the data will be sorted from smallest to largest according to the \\(k\\)th digit.</li> <li>Increase \\(k\\) by \\(1\\), then return to step <code>2.</code> and continue iterating until all digits are sorted, at which point the process ends.</li> </ol> <p></p> <p> Figure 11-18   Radix sort algorithm flow </p> <p>Below we analyze the code implementation. For a \\(d\\)-base number \\(x\\), to get its \\(k\\)th digit \\(x_k\\), the following calculation formula can be used:</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>Where \\(\\lfloor a \\rfloor\\) denotes rounding down the floating-point number \\(a\\), and \\(\\bmod \\: d\\) denotes taking the modulo (remainder) with respect to \\(d\\). For student ID data, \\(d = 10\\) and \\(k \\in [1, 8]\\).</p> <p>Additionally, we need to slightly modify the counting sort code to make it sort based on the \\(k\\)th digit of the number:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"Get the k-th digit of element num, where exp = 10^(k-1)\"\"\"\n    # Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"Counting sort (based on nums k-th digit)\"\"\"\n    # Decimal digit range is 0~9, therefore need a bucket array of length 10\n    counter = [0] * 10\n    n = len(nums)\n    # Count the occurrence of digits 0~9\n    for i in range(n):\n        d = digit(nums[i], exp)  # Get the k-th digit of nums[i], noted as d\n        counter[d] += 1  # Count the occurrence of digit d\n    # Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # Traverse in reverse, based on bucket statistics, place each element into res\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # Get the index j for d in the array\n        res[j] = nums[i]  # Place the current element at index j\n        counter[d] -= 1  # Decrease the count of d by 1\n    # Use result to overwrite the original array nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"Radix sort\"\"\"\n    # Get the maximum element of the array, used to determine the maximum number of digits\n    m = max(nums)\n    # Traverse from the lowest to the highest digit\n    exp = 1\n    while exp &lt;= m:\n        # Perform counting sort on the k-th digit of array elements\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # i.e., exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = *max_element(nums.begin(), nums.end());\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(int[] nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int[] counter = new int[10];\n    int n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(int[] nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nvoid RadixSort(int[] nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunc countingSortDigit(nums []int, exp int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    counter := make([]int, 10)\n    n := len(nums)\n    // Count the occurrence of digits 0~9\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // Get the k-th digit of nums[i], noted as d\n        counter[d]++             // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i]    // Place the current element at index j\n        counter[d]--        // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* Radix sort */\nfunc radixSort(nums []int) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    var counter = Array(repeating: 0, count: 10)\n    // Count the occurrence of digits 0~9\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // Get the k-th digit of nums[i], noted as d\n        counter[d] += 1 // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i] // Place the current element at index j\n        counter[d] -= 1 // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* Radix sort */\nfunc radixSort(nums: inout [Int]) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return Math.floor(num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunction countingSortDigit(nums, exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d]--; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nfunction radixSort(nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m = Math.max(... nums);\n    // Traverse from the lowest to the highest digit\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return Math.floor(num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d]--; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nfunction radixSort(nums: number[]): void {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m: number = Math.max(... nums);\n    // Traverse from the lowest to the highest digit\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* Get k-th digit of element _num, where exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // Passing exp instead of k can avoid repeated expensive exponentiation here\n  return (_num ~/ exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // Decimal digit range is 0~9, therefore need a bucket array of length 10\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // Count the occurrence of digits 0~9\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n    counter[d]++; // Count the occurrence of digit d\n  }\n  // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // Traverse in reverse, based on bucket statistics, place each element into res\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // Get the index j for d in the array\n    res[j] = nums[i]; // Place the current element at index j\n    counter[d]--; // Decrease the count of d by 1\n  }\n  // Use result to overwrite the original array nums\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(List&lt;int&gt; nums) {\n  // Get the maximum element of the array, used to determine the maximum number of digits\n  // In Dart, int length is 64 bits\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // Traverse from the lowest to the highest digit\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // Perform counting sort on the k-th digit of array elements\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // i.e., exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return ((num / exp) % 10) as usize;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // Count the occurrence of digits 0~9\n    for i in 0..n {\n        let d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d] += 1; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d] -= 1; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    nums.copy_from_slice(&amp;res);\n}\n\n/* Radix sort */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m = *nums.into_iter().max().unwrap();\n    // Traverse from the lowest to the highest digit\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // Initialize to 0 to support subsequent memory release\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; size; i++) {\n        // Get the k-th digit of nums[i], noted as d\n        int d = digit(nums[i], exp);\n        // Count the occurrence of digit d\n        counter[d]++;\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // Free memory\n    free(res);\n    free(counter);\n}\n\n/* Radix sort */\nvoid radixSort(int nums[], int size) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    val counter = IntArray(10)\n    val n = nums.size\n    // Count the occurrence of digits 0~9\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // Get the k-th digit of nums[i], noted as d\n        counter[d]++                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i]       // Place the current element at index j\n        counter[d]--           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* Radix sort */\nfun radixSort(nums: IntArray) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // Traverse from the lowest to the highest digit\n    while (exp &lt;= m) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### Get k-th digit of element num, where exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Passing exp instead of k avoids expensive exponentiation calculations\n  (num / exp) % 10\nend\n\n### Counting sort (sort by k-th digit of nums) ###\ndef counting_sort_digit(nums, exp)\n  # Decimal digit range is 0~9, therefore need a bucket array of length 10\n  counter = Array.new(10, 0)\n  n = nums.length\n  # Count the occurrence of digits 0~9\n  for i in 0...n\n    d = digit(nums[i], exp) # Get the k-th digit of nums[i], noted as d\n    counter[d] += 1 # Count the occurrence of digit d\n  end\n  # Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # Traverse in reverse, based on bucket statistics, place each element into res\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # Get the index j for d in the array\n    res[j] = nums[i] # Place the current element at index j\n    counter[d] -= 1 # Decrease the count of d by 1\n  end\n  # Use result to overwrite the original array nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### Radix sort ###\ndef radix_sort(nums)\n  # Get the maximum element of the array, used to determine the maximum number of digits\n  m = nums.max\n  # Traverse from the lowest to the highest digit\n  exp = 1\n  while exp &lt;= m\n    # Perform counting sort on the k-th digit of array elements\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # i.e., exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> <p>Why start sorting from the lowest digit?</p> <p>In successive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the first round result is \\(a &lt; b\\), while the second round result is \\(a &gt; b\\), then the second round's result will replace the first round's result. Since higher-order digits have higher priority than lower-order digits, we should sort the lower digits first and then sort the higher digits.</p>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102-algorithm-characteristics","level":2,"title":"11.10.2   Algorithm Characteristics","text":"<p>Compared to counting sort, radix sort is suitable for larger numerical ranges, but the prerequisite is that the data must be representable in a fixed number of digits, and the number of digits should not be too large. For example, floating-point numbers are not suitable for radix sort because their number of digits \\(k\\) may be too large, potentially leading to time complexity \\(O(nk) \\gg O(n^2)\\).</p> <ul> <li>Time complexity of \\(O(nk)\\), non-adaptive sorting: Let the data volume be \\(n\\), the data be in base \\(d\\), and the maximum number of digits be \\(k\\). Then performing counting sort on a certain digit uses \\(O(n + d)\\) time, and sorting all \\(k\\) digits uses \\(O((n + d)k)\\) time. Typically, both \\(d\\) and \\(k\\) are relatively small, and the time complexity approaches \\(O(n)\\).</li> <li>Space complexity of \\(O(n + d)\\), non-in-place sorting: Same as counting sort, radix sort requires auxiliary arrays <code>res</code> and <code>counter</code> of lengths \\(n\\) and \\(d\\).</li> <li>Stable sorting: When counting sort is stable, radix sort is also stable; when counting sort is unstable, radix sort cannot guarantee obtaining correct sorting results.</li> </ul>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   Selection Sort","text":"<p>Selection sort (selection sort) works very simply: it opens a loop, and in each round, selects the smallest element from the unsorted interval and places it at the end of the sorted interval.</p> <p>Assume the array has length \\(n\\). The algorithm flow of selection sort is shown in Figure 11-2.</p> <ol> <li>Initially, all elements are unsorted, i.e., the unsorted (index) interval is \\([0, n-1]\\).</li> <li>Select the smallest element in the interval \\([0, n-1]\\) and swap it with the element at index \\(0\\). After completion, the first element of the array is sorted.</li> <li>Select the smallest element in the interval \\([1, n-1]\\) and swap it with the element at index \\(1\\). After completion, the first 2 elements of the array are sorted.</li> <li>And so on. After \\(n - 1\\) rounds of selection and swapping, the first \\(n - 1\\) elements of the array are sorted.</li> <li>The only remaining element must be the largest element, requiring no sorting, so the array sorting is complete.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-2   Selection sort steps </p> <p>In the code, we use \\(k\\) to record the smallest element within the unsorted interval:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"Selection sort\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [i, n-1]\n    for i in range(n - 1):\n        # Inner loop: find the smallest element within the unsorted interval\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # Record the index of the smallest element\n        # Swap the smallest element with the first element of the unsorted interval\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* Selection sort */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* Selection sort */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* Selection sort */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* Selection sort */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // Outer loop: unsorted interval is [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // Inner loop: find the smallest element within the unsorted interval\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // Record the index of the smallest element\n                k = j\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* Selection sort */\nfunc selectionSort(nums: inout [Int]) {\n    // Outer loop: unsorted interval is [i, n-1]\n    for i in nums.indices.dropLast() {\n        // Inner loop: find the smallest element within the unsorted interval\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* Selection sort */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* Selection sort */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* Selection sort */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // Outer loop: unsorted interval is [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // Inner loop: find the smallest element within the unsorted interval\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // Record the index of the smallest element\n    }\n    // Swap the smallest element with the first element of the unsorted interval\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* Selection sort */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // Outer loop: unsorted interval is [i, n-1]\n    for i in 0..n - 1 {\n        // Inner loop: find the smallest element within the unsorted interval\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* Selection sort */\nvoid selectionSort(int nums[], int n) {\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* Selection sort */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // Outer loop: unsorted interval is [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // Inner loop: find the smallest element within the unsorted interval\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### Selection sort ###\ndef selection_sort(nums)\n  n = nums.length\n  # Outer loop: unsorted interval is [i, n-1]\n  for i in 0...(n - 1)\n    # Inner loop: find the smallest element within the unsorted interval\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # Record the index of the smallest element\n      end\n    end\n    # Swap the smallest element with the first element of the unsorted interval\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.2 &nbsp; Selection Sort"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121-algorithm-characteristics","level":2,"title":"11.2.1   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), non-adaptive sorting: The outer loop has \\(n - 1\\) rounds in total. The length of the unsorted interval in the first round is \\(n\\), and the length of the unsorted interval in the last round is \\(2\\). That is, each round of the outer loop contains \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(3\\), \\(2\\) inner loop iterations, summing to \\(\\frac{(n - 1)(n + 2)}{2}\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Non-stable sorting: As shown in Figure 11-3, element <code>nums[i]</code> may be swapped to the right of an element equal to it, causing a change in their relative order.</li> </ul> <p> Figure 11-3   Selection sort non-stability example </p>","path":["Chapter 11. Sorting","11.2 &nbsp; Selection Sort"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   Sorting Algorithm","text":"<p>Sorting algorithm (sorting algorithm) is used to arrange a group of data in a specific order. Sorting algorithms have extensive applications because ordered data can usually be searched, analyzed, and processed more efficiently.</p> <p>As shown in Figure 11-1, data types in sorting algorithms can be integers, floating-point numbers, characters, or strings, etc. The sorting criterion can be set according to requirements, such as numerical size, character ASCII code order, or custom rules.</p> <p></p> <p> Figure 11-1   Data type and criterion examples </p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111-evaluation-dimensions","level":2,"title":"11.1.1   Evaluation Dimensions","text":"<p>Execution efficiency: We expect the time complexity of sorting algorithms to be as low as possible, with a smaller total number of operations (reducing the constant factor in time complexity). For large data volumes, execution efficiency is particularly important.</p> <p>In-place property: As the name implies, in-place sorting achieves sorting by operating directly on the original array without requiring additional auxiliary arrays, thus saving memory. Typically, in-place sorting involves fewer data movement operations and runs faster.</p> <p>Stability: Stable sorting ensures that the relative order of equal elements in the array does not change after sorting is completed.</p> <p>Stable sorting is a necessary condition for multi-level sorting scenarios. Suppose we have a table storing student information, where column 1 and column 2 are name and age, respectively. In this case, unstable sorting may cause the ordered nature of the input data to be lost:</p> <pre><code># Input Data Is Sorted by Name\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# Assuming We Use an Unstable Sorting Algorithm to Sort the List by Age,\n# In the Result, the Relative Positions of ('D', 19) and ('A', 19) Are Changed,\n# And the Property That the Input Data Is Sorted by Name Is Lost\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>Adaptability: Adaptive sorting can utilize the existing order information in the input data to reduce the amount of computation, achieving better time efficiency. The best-case time complexity of adaptive sorting algorithms is typically better than the average time complexity.</p> <p>Comparison-based or not: Comparison-based sorting relies on comparison operators (\\(&lt;\\), \\(=\\), \\(&gt;\\)) to determine the relative order of elements, thereby sorting the entire array, with a theoretical optimal time complexity of \\(O(n \\log n)\\). Non-comparison sorting does not use comparison operators and can achieve a time complexity of \\(O(n)\\), but its versatility is relatively limited.</p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112-ideal-sorting-algorithm","level":2,"title":"11.1.2   Ideal Sorting Algorithm","text":"<p>Fast execution, in-place, stable, adaptive, good versatility. Clearly, no sorting algorithm has been discovered to date that combines all of these characteristics. Therefore, when selecting a sorting algorithm, it is necessary to decide based on the specific characteristics of the data and the requirements of the problem.</p> <p>Next, we will learn about various sorting algorithms together and analyze the advantages and disadvantages of each sorting algorithm based on the above evaluation dimensions.</p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   Summary","text":"","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Bubble sort achieves sorting by swapping adjacent elements. By adding a flag to enable early return, we can optimize the best-case time complexity of bubble sort to \\(O(n)\\).</li> <li>Insertion sort completes sorting by inserting elements from the unsorted interval into the correct position in the sorted interval each round. Although the time complexity of insertion sort is \\(O(n^2)\\), it is very popular in small data volume sorting tasks because it involves relatively few unit operations.</li> <li>Quick sort is implemented based on sentinel partitioning operations. In sentinel partitioning, it is possible to select the worst pivot every time, causing the time complexity to degrade to \\(O(n^2)\\). Introducing median pivot or random pivot can reduce the probability of such degradation. By preferentially recursing on the shorter sub-interval, the recursion depth can be effectively reduced, optimizing the space complexity to \\(O(\\log n)\\).</li> <li>Merge sort includes two phases: divide and merge, which typically embody the divide-and-conquer strategy. In merge sort, sorting an array requires creating auxiliary arrays, with a space complexity of \\(O(n)\\); however, the space complexity of sorting a linked list can be optimized to \\(O(1)\\).</li> <li>Bucket sort consists of three steps: distributing data into buckets, sorting within buckets, and merging results. It also embodies the divide-and-conquer strategy and is suitable for very large data volumes. The key to bucket sort is distributing data evenly.</li> <li>Counting sort is a special case of bucket sort, which achieves sorting by counting the number of occurrences of data. Counting sort is suitable for situations where the data volume is large but the data range is limited, and requires that data can be converted to positive integers.</li> <li>Radix sort achieves data sorting by sorting digit by digit, requiring that data can be represented as fixed-digit numbers.</li> <li>Overall, we hope to find a sorting algorithm that is efficient, stable, in-place, and adaptive, with good versatility. However, just like other data structures and algorithms, no sorting algorithm has been found so far that simultaneously possesses all these characteristics. In practical applications, we need to select the appropriate sorting algorithm based on the specific characteristics of the data.</li> <li>Figure 11-19 compares mainstream sorting algorithms in terms of efficiency, stability, in-place property, and adaptability.</li> </ul> <p> Figure 11-19   Sorting algorithm comparison </p>","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: In what situations is the stability of sorting algorithms necessary?</p> <p>In reality, we may sort based on a certain attribute of objects. For example, students have two attributes: name and height. We want to implement multi-level sorting: first sort by name to get <code>(A, 180) (B, 185) (C, 170) (D, 170)</code>; then sort by height. Because the sorting algorithm is unstable, we may get <code>(D, 170) (C, 170) (A, 180) (B, 185)</code>.</p> <p>It can be seen that the positions of students D and C have been swapped, and the orderliness of names has been disrupted, which is something we don't want to see.</p> <p>Q: Can the order of \"searching from right to left\" and \"searching from left to right\" in sentinel partitioning be swapped?</p> <p>No. When we use the leftmost element as the pivot, we must first \"search from right to left\" and then \"search from left to right\". This conclusion is somewhat counterintuitive; let's analyze the reason.</p> <p>The last step of sentinel partitioning <code>partition()</code> is to swap <code>nums[left]</code> and <code>nums[i]</code>. After the swap is complete, the elements to the left of the pivot are all <code>&lt;=</code> the pivot, which requires that <code>nums[left] &gt;= nums[i]</code> must hold before the last swap. Suppose we first \"search from left to right\", then if we cannot find an element larger than the pivot, we will exit the loop when <code>i == j</code>, at which point it may be that <code>nums[j] == nums[i] &gt; nums[left]</code>. In other words, the last swap operation will swap an element larger than the pivot to the leftmost end of the array, causing sentinel partitioning to fail.</p> <p>For example, given the array <code>[0, 0, 0, 0, 1]</code>, if we first \"search from left to right\", the array after sentinel partitioning is <code>[1, 0, 0, 0, 0]</code>, which is incorrect.</p> <p>Thinking deeper, if we select <code>nums[right]</code> as the pivot, then it's exactly the opposite - we must first \"search from left to right\".</p> <p>Q: Regarding the optimization of recursion depth in quick sort, why can selecting the shorter array ensure that the recursion depth does not exceed \\(\\log n\\)?</p> <p>The recursion depth is the number of currently unreturned recursive methods. Each round of sentinel partitioning divides the original array into two sub-arrays. After recursion depth optimization, the length of the sub-array to be recursively processed is at most half of the original array length. Assuming the worst case is always half the length, the final recursion depth will be \\(\\log n\\).</p> <p>Reviewing the original quick sort, we may continuously recurse on the longer array. In the worst case, it would be \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(2\\), \\(1\\), with a recursion depth of \\(n\\). Recursion depth optimization can avoid this situation.</p> <p>Q: When all elements in the array are equal, is the time complexity of quick sort \\(O(n^2)\\)? How should this degenerate case be handled?</p> <p>Yes. For this situation, consider partitioning the array into three parts through sentinel partitioning: less than, equal to, and greater than the pivot. Only recursively process the less than and greater than parts. Under this method, an array where all input elements are equal can complete sorting in just one round of sentinel partitioning.</p> <p>Q: Why is the worst-case time complexity of bucket sort \\(O(n^2)\\)?</p> <p>In the worst case, all elements are distributed into the same bucket. If we use an \\(O(n^2)\\) algorithm to sort these elements, the time complexity will be \\(O(n^2)\\).</p>","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"Chapter 5.   Stack and Queue","text":"<p>Abstract</p> <p>Stacks are like stacking cats, while queues are like cats lining up.</p> <p>They represent LIFO (Last In First Out) and FIFO (First In First Out) logic, respectively.</p>","path":["Chapter 5. Stack and Queue","Chapter 5. &nbsp; Stack and Queue"],"tags":[]},{"location":"chapter_stack_and_queue/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>5.1   Stack</li> <li>5.2   Queue</li> <li>5.3   Double-Ended Queue</li> <li>5.4   Summary</li> </ul>","path":["Chapter 5. Stack and Queue","Chapter 5. &nbsp; Stack and Queue"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   Deque","text":"<p>In a queue, we can only remove elements from the front or add elements at the rear. As shown in Figure 5-7, a double-ended queue (deque) provides greater flexibility, allowing the addition or removal of elements at both the front and rear.</p> <p></p> <p> Figure 5-7   Operations of deque </p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531-common-deque-operations","level":2,"title":"5.3.1   Common Deque Operations","text":"<p>The common operations on a deque are shown in Table 5-3. The specific method names depend on the programming language used.</p> <p> Table 5-3   Efficiency of Deque Operations </p> Method Description Time Complexity <code>push_first()</code> Add element to front \\(O(1)\\) <code>push_last()</code> Add element to rear \\(O(1)\\) <code>pop_first()</code> Remove front element \\(O(1)\\) <code>pop_last()</code> Remove rear element \\(O(1)\\) <code>peek_first()</code> Access front element \\(O(1)\\) <code>peek_last()</code> Access rear element \\(O(1)\\) <p>Similarly, we can directly use the deque classes already implemented in programming languages:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# Initialize deque\ndeq: deque[int] = deque()\n\n# Enqueue elements\ndeq.append(2)      # Add to rear\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # Add to front\ndeq.appendleft(1)\n\n# Access elements\nfront: int = deq[0]  # Front element\nrear: int = deq[-1]  # Rear element\n\n# Dequeue elements\npop_front: int = deq.popleft()  # Front element dequeue\npop_rear: int = deq.pop()       # Rear element dequeue\n\n# Get deque length\nsize: int = len(deq)\n\n# Check if deque is empty\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* Initialize deque */\ndeque&lt;int&gt; deque;\n\n/* Enqueue elements */\ndeque.push_back(2);   // Add to rear\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Add to front\ndeque.push_front(1);\n\n/* Access elements */\nint front = deque.front(); // Front element\nint back = deque.back();   // Rear element\n\n/* Dequeue elements */\ndeque.pop_front();  // Front element dequeue\ndeque.pop_back();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.size();\n\n/* Check if deque is empty */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* Initialize deque */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* Enqueue elements */\ndeque.offerLast(2);   // Add to rear\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Add to front\ndeque.offerFirst(1);\n\n/* Access elements */\nint peekFirst = deque.peekFirst();  // Front element\nint peekLast = deque.peekLast();    // Rear element\n\n/* Dequeue elements */\nint popFirst = deque.pollFirst();  // Front element dequeue\nint popLast = deque.pollLast();    // Rear element dequeue\n\n/* Get deque length */\nint size = deque.size();\n\n/* Check if deque is empty */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* Initialize deque */\n// In C#, use LinkedList as a deque\nLinkedList&lt;int&gt; deque = new();\n\n/* Enqueue elements */\ndeque.AddLast(2);   // Add to rear\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Add to front\ndeque.AddFirst(1);\n\n/* Access elements */\nint peekFirst = deque.First.Value;  // Front element\nint peekLast = deque.Last.Value;    // Rear element\n\n/* Dequeue elements */\ndeque.RemoveFirst();  // Front element dequeue\ndeque.RemoveLast();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.Count;\n\n/* Check if deque is empty */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* Initialize deque */\n// In Go, use list as a deque\ndeque := list.New()\n\n/* Enqueue elements */\ndeque.PushBack(2)      // Add to rear\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Add to front\ndeque.PushFront(1)\n\n/* Access elements */\nfront := deque.Front() // Front element\nrear := deque.Back()   // Rear element\n\n/* Dequeue elements */\ndeque.Remove(front)    // Front element dequeue\ndeque.Remove(rear)     // Rear element dequeue\n\n/* Get deque length */\nsize := deque.Len()\n\n/* Check if deque is empty */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* Initialize deque */\n// Swift does not have a built-in deque class, can use Array as a deque\nvar deque: [Int] = []\n\n/* Enqueue elements */\ndeque.append(2) // Add to rear\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Add to front\ndeque.insert(1, at: 0)\n\n/* Access elements */\nlet peekFirst = deque.first! // Front element\nlet peekLast = deque.last! // Rear element\n\n/* Dequeue elements */\n// When using Array simulation, popFirst has O(n) complexity\nlet popFirst = deque.removeFirst() // Front element dequeue\nlet popLast = deque.removeLast() // Rear element dequeue\n\n/* Get deque length */\nlet size = deque.count\n\n/* Check if deque is empty */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* Initialize deque */\n// JavaScript does not have a built-in deque, can only use Array as a deque\nconst deque = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Please note that since it's an array, unshift() has O(n) time complexity\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* Dequeue elements */\n// Please note that since it's an array, shift() has O(n) time complexity\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* Get deque length */\nconst size = deque.length;\n\n/* Check if deque is empty */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* Initialize deque */\n// TypeScript does not have a built-in deque, can only use Array as a deque\nconst deque: number[] = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Please note that since it's an array, unshift() has O(n) time complexity\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* Dequeue elements */\n// Please note that since it's an array, shift() has O(n) time complexity\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* Get deque length */\nconst size: number = deque.length;\n\n/* Check if deque is empty */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* Initialize deque */\n// In Dart, Queue is defined as a deque\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* Enqueue elements */\ndeque.addLast(2);  // Add to rear\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Add to front\ndeque.addFirst(1);\n\n/* Access elements */\nint peekFirst = deque.first; // Front element\nint peekLast = deque.last;   // Rear element\n\n/* Dequeue elements */\nint popFirst = deque.removeFirst(); // Front element dequeue\nint popLast = deque.removeLast();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.length;\n\n/* Check if deque is empty */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* Initialize deque */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(2);  // Add to rear\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Add to front\ndeque.push_front(1);\n\n/* Access elements */\nif let Some(front) = deque.front() { // Front element\n}\nif let Some(rear) = deque.back() {   // Rear element\n}\n\n/* Dequeue elements */\nif let Some(pop_front) = deque.pop_front() { // Front element dequeue\n}\nif let Some(pop_rear) = deque.pop_back() {   // Rear element dequeue\n}\n\n/* Get deque length */\nlet size = deque.len();\n\n/* Check if deque is empty */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C does not provide a built-in deque\n</code></pre> deque.kt<pre><code>/* Initialize deque */\nval deque = LinkedList&lt;Int&gt;()\n\n/* Enqueue elements */\ndeque.offerLast(2)  // Add to rear\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // Add to front\ndeque.offerFirst(1)\n\n/* Access elements */\nval peekFirst = deque.peekFirst() // Front element\nval peekLast = deque.peekLast()   // Rear element\n\n/* Dequeue elements */\nval popFirst = deque.pollFirst() // Front element dequeue\nval popLast = deque.pollLast()   // Rear element dequeue\n\n/* Get deque length */\nval size = deque.size\n\n/* Check if deque is empty */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># Initialize deque\n# Ruby does not have a built-in deque, can only use Array as a deque\ndeque = []\n\n# Enqueue elements\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# Please note that since it's an array, Array#unshift has O(n) time complexity\ndeque.unshift(3)\ndeque.unshift(1)\n\n# Access elements\npeek_first = deque.first\npeek_last = deque.last\n\n# Dequeue elements\n# Please note that since it's an array, Array#shift has O(n) time complexity\npop_front = deque.shift\npop_back = deque.pop\n\n# Get deque length\nsize = deque.length\n\n# Check if deque is empty\nis_empty = size.zero?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532-deque-implementation","level":2,"title":"5.3.2   Deque Implementation *","text":"<p>The implementation of a deque is similar to that of a queue. You can choose either a linked list or an array as the underlying data structure.</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1-doubly-linked-list-implementation","level":3,"title":"1.   Doubly Linked List Implementation","text":"<p>Reviewing the previous section, we used a regular singly linked list to implement a queue because it conveniently allows deleting the head node (corresponding to dequeue) and adding new nodes after the tail node (corresponding to enqueue).</p> <p>For a deque, both the front and rear can perform enqueue and dequeue operations. In other words, a deque needs to implement operations in the opposite direction as well. For this reason, we use a \"doubly linked list\" as the underlying data structure for the deque.</p> <p>As shown in Figure 5-8, we treat the head and tail nodes of the doubly linked list as the front and rear of the deque, implementing functionality to add and remove nodes at both ends.</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 5-8   Enqueue and dequeue operations in linked list implementation of deque </p> <p>The implementation code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"Doubly linked list node\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"Constructor\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # Successor node reference\n        self.prev: ListNode | None = None  # Predecessor node reference\n\nclass LinkedListDeque:\n    \"\"\"Double-ended queue based on doubly linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._front: ListNode | None = None  # Head node front\n        self._rear: ListNode | None = None  # Tail node rear\n        self._size: int = 0  # Length of the double-ended queue\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the double-ended queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the double-ended queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"Enqueue operation\"\"\"\n        node = ListNode(num)\n        # If the linked list is empty, make both front and rear point to node\n        if self.is_empty():\n            self._front = self._rear = node\n        # Front of the queue enqueue operation\n        elif is_front:\n            # Add node to the head of the linked list\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # Update head node\n        # Rear of the queue enqueue operation\n        else:\n            # Add node to the tail of the linked list\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # Update tail node\n        self._size += 1  # Update queue length\n\n    def push_first(self, num: int):\n        \"\"\"Front of the queue enqueue\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"Rear of the queue enqueue\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"Dequeue operation\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        # Front of the queue dequeue operation\n        if is_front:\n            val: int = self._front.val  # Temporarily store head node value\n            # Delete head node\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # Update head node\n        # Rear of the queue dequeue operation\n        else:\n            val: int = self._rear.val  # Temporarily store tail node value\n            # Delete tail node\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # Update tail node\n        self._size -= 1  # Update queue length\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Front of the queue dequeue\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Rear of the queue dequeue\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Access rear of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return array for printing\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* Doubly linked list node */\nstruct DoublyListNode {\n    int val;              // Node value\n    DoublyListNode *next; // Successor node pointer\n    DoublyListNode *prev; // Predecessor node pointer\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // Head node front, tail node rear\n    int queSize = 0;              // Length of the double-ended queue\n\n  public:\n    /* Constructor */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* Destructor */\n    ~LinkedListDeque() {\n        // Traverse linked list to delete nodes and free memory\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* Get the length of the double-ended queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue operation */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty())\n            front = rear = node;\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // Update head node\n        // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // Update tail node\n        }\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Dequeue operation */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"Queue is empty\");\n        int val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front-&gt;val; // Delete head node\n            // Delete head node\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // Update head node\n        // Temporarily store tail node value\n        } else {\n            val = rear-&gt;val; // Delete tail node\n            // Update tail node\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // Update tail node\n        }\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* Access rear of the queue element */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* Return list for printing */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return front-&gt;val;\n    }\n\n    /* Driver Code */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return rear-&gt;val;\n    }\n\n    /* Return array for printing */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* Doubly linked list node */\nclass ListNode {\n    int val; // Node value\n    ListNode next; // Successor node reference\n    ListNode prev; // Predecessor node reference\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private ListNode front, rear; // Head node front, tail node rear\n    private int queSize = 0; // Length of the double-ended queue\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue operation */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty())\n            front = rear = node;\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front.prev = node;\n            node.next = front;\n            front = node; // Update head node\n        // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // Update tail node\n        }\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Dequeue operation */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front.val; // Delete head node\n            // Delete head node\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // Update head node\n        // Temporarily store tail node value\n        } else {\n            val = rear.val; // Delete tail node\n            // Update tail node\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // Update tail node\n        }\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* Access rear of the queue element */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* Return list for printing */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Driver Code */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* Return array for printing */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* Doubly linked list node */\nclass ListNode(int val) {\n    public int val = val;       // Node value\n    public ListNode? next = null; // Successor node reference\n    public ListNode? prev = null; // Predecessor node reference\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    ListNode? front, rear; // Head node front, tail node rear\n    int queSize = 0;      // Length of the double-ended queue\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Enqueue operation */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front!.prev = node;\n            node.next = front;\n            front = node; // Update head node\n        }\n        // Rear of the queue enqueue operation\n        else {\n            // Add node to the tail of the linked list\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // Update tail node\n        }\n\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* Dequeue operation */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front?.val; // Delete head node\n            // Delete head node\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // Update head node\n        }\n        // Temporarily store tail node value\n        else {\n            val = rear?.val;  // Delete tail node\n            // Update tail node\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // Update tail node\n        }\n\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* Access rear of the queue element */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* Return list for printing */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* Driver Code */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* Return array for printing */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* Double-ended queue based on doubly linked list implementation */\ntype linkedListDeque struct {\n    // Use built-in package list\n    data *list.List\n}\n\n/* Initialize deque */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* Front element enqueue */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* Rear element enqueue */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* Check if the double-ended queue is empty */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Rear element dequeue */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Driver Code */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Get the length of the queue */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* Check if the queue is empty */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* Doubly linked list node */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Successor node reference\n    weak var prev: ListNode? // Predecessor node reference\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private var front: ListNode? // Head node front\n    private var rear: ListNode? // Tail node rear\n    private var _size: Int // Length of the double-ended queue\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the double-ended queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the double-ended queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue operation */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // If the linked list is empty, make both front and rear point to node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // Front of the queue enqueue operation\n        else if isFront {\n            // Add node to the head of the linked list\n            front?.prev = node\n            node.next = front\n            front = node // Update head node\n        }\n        // Rear of the queue enqueue operation\n        else {\n            // Add node to the tail of the linked list\n            rear?.next = node\n            node.prev = rear\n            rear = node // Update tail node\n        }\n        _size += 1 // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* Rear of the queue enqueue */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* Dequeue operation */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        let val: Int\n        // Temporarily store head node value\n        if isFront {\n            val = front!.val // Delete head node\n            // Delete head node\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // Update head node\n        }\n        // Temporarily store tail node value\n        else {\n            val = rear!.val // Delete tail node\n            // Update tail node\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // Update tail node\n        }\n        _size -= 1 // Update queue length\n        return val\n    }\n\n    /* Rear of the queue dequeue */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* Access rear of the queue element */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* Return list for printing */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return front!.val\n    }\n\n    /* Driver Code */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return rear!.val\n    }\n\n    /* Return array for printing */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* Doubly linked list node */\nclass ListNode {\n    prev; // Predecessor node reference (pointer)\n    next; // Successor node reference (pointer)\n    val; // Node value\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    #front; // Head node front\n    #rear; // Tail node rear\n    #queSize; // Length of the double-ended queue\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* Rear of the queue enqueue operation */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Add node to the tail of the linked list\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // Update tail node\n        }\n        this.#queSize++;\n    }\n\n    /* Front of the queue enqueue operation */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Add node to the head of the linked list\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // Update head node\n        }\n        this.#queSize++;\n    }\n\n    /* Temporarily store tail node value */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // Store tail node value\n        // Update tail node\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // Update tail node\n        this.#queSize--;\n        return value;\n    }\n\n    /* Temporarily store head node value */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // Store tail node value\n        // Delete head node\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // Update head node\n        this.#queSize--;\n        return value;\n    }\n\n    /* Driver Code */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* Return list for printing */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* Get the length of the double-ended queue */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Print deque */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* Doubly linked list node */\nclass ListNode {\n    prev: ListNode; // Predecessor node reference (pointer)\n    next: ListNode; // Successor node reference (pointer)\n    val: number; // Node value\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private front: ListNode; // Head node front\n    private rear: ListNode; // Tail node rear\n    private queSize: number; // Length of the double-ended queue\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* Rear of the queue enqueue operation */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Add node to the tail of the linked list\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // Update tail node\n        }\n        this.queSize++;\n    }\n\n    /* Front of the queue enqueue operation */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Add node to the head of the linked list\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // Update head node\n        }\n        this.queSize++;\n    }\n\n    /* Temporarily store tail node value */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // Store tail node value\n        // Update tail node\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // Update tail node\n        this.queSize--;\n        return value;\n    }\n\n    /* Temporarily store head node value */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // Store tail node value\n        // Delete head node\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // Update head node\n        this.queSize--;\n        return value;\n    }\n\n    /* Driver Code */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* Return list for printing */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* Get the length of the double-ended queue */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Print deque */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* Doubly linked list node */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Successor node reference\n  ListNode? prev; // Predecessor node reference\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* Deque implemented based on doubly linked list */\nclass LinkedListDeque {\n  late ListNode? _front; // Head node _front\n  late ListNode? _rear; // Tail node _rear\n  int _queSize = 0; // Length of the double-ended queue\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* Get deque length */\n  int size() {\n    return this._queSize;\n  }\n\n  /* Check if the double-ended queue is empty */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* Enqueue operation */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // If list is empty, let both _front and _rear point to node\n      _front = _rear = node;\n    } else if (isFront) {\n      // Front of the queue enqueue operation\n      // Add node to the head of the linked list\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // Update head node\n    } else {\n      // Rear of the queue enqueue operation\n      // Add node to the tail of the linked list\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // Update tail node\n    }\n    _queSize++; // Update queue length\n  }\n\n  /* Front of the queue enqueue */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* Rear of the queue enqueue */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* Dequeue operation */\n  int? pop(bool isFront) {\n    // If queue is empty, return null directly\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // Temporarily store head node value\n      val = _front!.val; // Delete head node\n      // Delete head node\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // Update head node\n    } else {\n      // Temporarily store tail node value\n      val = _rear!.val; // Delete tail node\n      // Update tail node\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // Update tail node\n    }\n    _queSize--; // Update queue length\n    return val;\n  }\n\n  /* Rear of the queue dequeue */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* Access rear of the queue element */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* Return list for printing */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* Driver Code */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* Return array for printing */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* Doubly linked list node */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // Node value\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Successor node pointer\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Predecessor node pointer\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Head node front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Tail node rear\n    que_size: usize,                         // Length of the double-ended queue\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Get the length of the double-ended queue */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Check if the double-ended queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Enqueue operation */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // Front of the queue enqueue operation\n        if is_front {\n            match self.front.take() {\n                // If the linked list is empty, make both front and rear point to node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // Add node to the head of the linked list\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // Update head node\n                }\n            }\n        }\n        // Rear of the queue enqueue operation\n        else {\n            match self.rear.take() {\n                // If the linked list is empty, make both front and rear point to node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // Add node to the tail of the linked list\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // Update tail node\n                }\n            }\n        }\n        self.que_size += 1; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* Dequeue operation */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // If queue is empty, return None directly\n        if self.is_empty() {\n            return None;\n        };\n        // Temporarily store head node value\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // Update head node\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // Update queue length\n                old_front.borrow().val\n            })\n        }\n        // Temporarily store tail node value\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // Update tail node\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // Update queue length\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* Rear of the queue dequeue */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* Access rear of the queue element */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* Return list for printing */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Driver Code */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* Return array for printing */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* Doubly linked list node */\ntypedef struct DoublyListNode {\n    int val;                     // Node value\n    struct DoublyListNode *next; // Successor node\n    struct DoublyListNode *prev; // Predecessor node\n} DoublyListNode;\n\n/* Constructor */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* Destructor */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* Double-ended queue based on doubly linked list implementation */\ntypedef struct {\n    DoublyListNode *front, *rear; // Head node front, tail node rear\n    int queSize;                  // Length of the double-ended queue\n} LinkedListDeque;\n\n/* Constructor */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Destructor */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // Free all nodes\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Free deque structure\n    free(deque);\n}\n\n/* Get the length of the queue */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* Enqueue */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // If list is empty, set both front and rear to node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // Front of the queue enqueue operation\n    else if (isFront) {\n        // Add node to the head of the linked list\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // Update head node\n    }\n    // Rear of the queue enqueue operation\n    else {\n        // Add node to the tail of the linked list\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // Update queue length\n}\n\n/* Front of the queue enqueue */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* Rear of the queue enqueue */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* Return list for printing */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* Driver Code */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* Dequeue */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // Temporarily store head node value\n    if (isFront) {\n        val = peekFirst(deque); // Delete head node\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // Update head node\n    }\n    // Temporarily store tail node value\n    else {\n        val = peekLast(deque); // Delete tail node\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // Update tail node\n    }\n    deque-&gt;queSize--; // Update queue length\n    return val;\n}\n\n/* Rear of the queue dequeue */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* Access rear of the queue element */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* Print queue */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // Copy data from list to array\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* Doubly linked list node */\nclass ListNode(var _val: Int) {\n    // Node value\n    var next: ListNode? = null // Successor node reference\n    var prev: ListNode? = null // Predecessor node reference\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private var front: ListNode? = null // Head node front\n    private var rear: ListNode? = null // Tail node rear\n    private var queSize: Int = 0 // Length of the double-ended queue\n\n    /* Get the length of the double-ended queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the double-ended queue is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Enqueue operation */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // Front of the queue enqueue operation\n        } else if (isFront) {\n            // Add node to the head of the linked list\n            front?.prev = node\n            node.next = front\n            front = node // Update head node\n            // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear?.next = node\n            node.prev = rear\n            rear = node // Update tail node\n        }\n        queSize++ // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* Rear of the queue enqueue */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* Dequeue operation */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // Temporarily store head node value\n        if (isFront) {\n            _val = front!!._val // Delete head node\n            // Delete head node\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // Update head node\n            // Temporarily store tail node value\n        } else {\n            _val = rear!!._val // Delete tail node\n            // Update tail node\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // Update tail node\n        }\n        queSize-- // Update queue length\n        return _val\n    }\n\n    /* Rear of the queue dequeue */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* Access rear of the queue element */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* Return list for printing */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Driver Code */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* Return array for printing */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n### Doubly linked list node\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # Successor node reference\n  attr_accessor :prev # Predecessor node reference\n\n  ### Constructor ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### Deque based on doubly linked list ###\nclass LinkedListDeque\n  ### Get deque length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @front = nil  # Head node front\n    @rear = nil   # Tail node rear\n    @size = 0     # Length of the double-ended queue\n  end\n\n  ### Check if deque is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue operation ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # If list is empty, set both front and rear to node\n    if is_empty?\n      @front = @rear = node\n    # Front of the queue enqueue operation\n    elsif is_front\n      # Add node to the head of the linked list\n      @front.prev = node\n      node.next = @front\n      @front = node # Update head node\n    # Rear of the queue enqueue operation\n    else\n      # Add node to the tail of the linked list\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # Update tail node\n    end\n    @size += 1 # Update queue length\n  end\n\n  ### Enqueue at front ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### Enqueue at rear ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### Dequeue operation ###\n  def pop(is_front)\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    # Temporarily store head node value\n    if is_front\n      val = @front.val # Delete head node\n      # Delete head node\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # Update head node\n    # Temporarily store tail node value\n    else\n      val = @rear.val # Delete tail node\n      # Update tail node\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # Update tail node\n    end\n    @size -= 1 # Update queue length\n\n    val\n  end\n\n  ### Dequeue from front ###\n  def pop_first\n    pop(true)\n  end\n\n  ### Dequeue from front ###\n  def pop_last\n    pop(false)\n  end\n\n  ### Access front element ###\n  def peek_first\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @front.val\n  end\n\n  ### Access rear element ###\n  def peek_last\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @rear.val\n  end\n\n  ### Return array for printing ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>As shown in Figure 5-9, similar to implementing a queue based on an array, we can also use a circular array to implement a deque.</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 5-9   Enqueue and dequeue operations in array implementation of deque </p> <p>Based on the queue implementation, we only need to add methods for \"enqueue at front\" and \"dequeue from rear\":</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"Double-ended queue based on circular array implementation\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"Constructor\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get the capacity of the double-ended queue\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the double-ended queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the double-ended queue is empty\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"Calculate circular array index\"\"\"\n        # Use modulo operation to wrap the array head and tail together\n        # When i passes the tail of the array, return to the head\n        # When i passes the head of the array, return to the tail\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"Front of the queue enqueue\"\"\"\n        if self._size == self.capacity():\n            print(\"Double-ended queue is full\")\n            return\n        # Front pointer moves one position to the left\n        # Use modulo operation to wrap front around to the tail after passing the head of the array\n        self._front = self.index(self._front - 1)\n        # Add num to the front of the queue\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"Rear of the queue enqueue\"\"\"\n        if self._size == self.capacity():\n            print(\"Double-ended queue is full\")\n            return\n        # Calculate rear pointer, points to rear index + 1\n        rear = self.index(self._front + self._size)\n        # Add num to the rear of the queue\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Front of the queue dequeue\"\"\"\n        num = self.peek_first()\n        # Front pointer moves one position backward\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Rear of the queue dequeue\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Access rear of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        # Calculate tail element index\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return array for printing\"\"\"\n        # Only convert list elements within the valid length range\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // Array for storing double-ended queue elements\n    int front;        // Front pointer, points to the front of the queue element\n    int queSize;      // Double-ended queue length\n\n  public:\n    /* Constructor */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* Get the length of the double-ended queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    int index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity();\n    }\n\n    /* Front of the queue enqueue */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Double-ended queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Double-ended queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    int popFirst() {\n        int num = peekFirst();\n        // Move front pointer backward by one position\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return nums[front];\n    }\n\n    /* Driver Code */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        // Initialize double-ended queue\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private int[] nums; // Array for storing double-ended queue elements\n    private int front; // Front pointer, points to the front of the queue element\n    private int queSize; // Double-ended queue length\n\n    /* Constructor */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    private int index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity();\n    }\n\n    /* Front of the queue enqueue */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    public int popFirst() {\n        int num = peekFirst();\n        // Move front pointer backward by one position\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Driver Code */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // Initialize double-ended queue\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    public int[] toArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    int[] nums;  // Array for storing double-ended queue elements\n    int front;   // Front pointer, points to the front of the queue element\n    int queSize; // Double-ended queue length\n\n    /* Constructor */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    int Index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* Front of the queue enqueue */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = Index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = Index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // Move front pointer backward by one position\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* Driver Code */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // Initialize double-ended queue\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* Double-ended queue based on circular array implementation */\ntype arrayDeque struct {\n    nums        []int // Array for storing double-ended queue elements\n    front       int   // Front pointer, points to the front of the queue element\n    queSize     int   // Double-ended queue length\n    queCapacity int   // Queue capacity (maximum number of elements)\n}\n\n/* Access front of the queue element */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Get the length of the double-ended queue */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* Check if the double-ended queue is empty */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Calculate circular array index */\nfunc (q *arrayDeque) index(i int) int {\n    // Use modulo operation to wrap the array head and tail together\n    // When i passes the tail of the array, return to the head\n    // When i passes the head of the array, return to the tail\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* Front of the queue enqueue */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Double-ended queue is full\")\n        return\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Add num to the front of the queue\n    q.front = q.index(q.front - 1)\n    // Add num to front of queue\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* Rear of the queue enqueue */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Double-ended queue is full\")\n        return\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    rear := q.index(q.front + q.queSize)\n    // Front pointer moves one position backward\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Rear of the queue dequeue */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // Move front pointer backward by one position\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* Access rear of the queue element */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* Return list for printing */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Driver Code */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // Initialize double-ended queue\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* Get Slice for printing */\nfunc (q *arrayDeque) toSlice() []int {\n    // Elements enqueue\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private var nums: [Int] // Array for storing double-ended queue elements\n    private var front: Int // Front pointer, points to the front of the queue element\n    private var _size: Int // Double-ended queue length\n\n    /* Constructor */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Get the capacity of the double-ended queue */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Get the length of the double-ended queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the double-ended queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Calculate circular array index */\n    private func index(i: Int) -&gt; Int {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        (i + capacity()) % capacity()\n    }\n\n    /* Front of the queue enqueue */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(i: front - 1)\n        // Add num to front of queue\n        nums[front] = num\n        _size += 1\n    }\n\n    /* Rear of the queue enqueue */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        let rear = index(i: front + size())\n        // Front pointer moves one position backward\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Rear of the queue dequeue */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // Move front pointer backward by one position\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* Access rear of the queue element */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return nums[front]\n    }\n\n    /* Driver Code */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        // Initialize double-ended queue\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* Return array for printing */\n    func toArray() -&gt; [Int] {\n        // Elements enqueue\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    #nums; // Array for storing double-ended queue elements\n    #front; // Front pointer, points to the front of the queue element\n    #queSize; // Double-ended queue length\n\n    /* Constructor */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Calculate circular array index */\n    index(i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Front of the queue enqueue */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        this.#front = this.index(this.#front - 1);\n        // Add num to front of queue\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        const rear = this.index(this.#front + this.#queSize);\n        // Front pointer moves one position backward\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    popFirst() {\n        const num = this.peekFirst();\n        // Move front pointer backward by one position\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* Driver Code */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Initialize double-ended queue\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* Return array for printing */\n    toArray() {\n        // Elements enqueue\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private nums: number[]; // Array for storing double-ended queue elements\n    private front: number; // Front pointer, points to the front of the queue element\n    private queSize: number; // Double-ended queue length\n\n    /* Constructor */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Calculate circular array index */\n    index(i: number): number {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Front of the queue enqueue */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        this.front = this.index(this.front - 1);\n        // Add num to front of queue\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        const rear: number = this.index(this.front + this.queSize);\n        // Front pointer moves one position backward\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // Move front pointer backward by one position\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* Driver Code */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Initialize double-ended queue\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* Return array for printing */\n    toArray(): number[] {\n        // Elements enqueue\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // Array for storing double-ended queue elements\n  late int _front; // Front pointer, points to the front of the queue element\n  late int _queSize; // Double-ended queue length\n\n  /* Constructor */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* Get the capacity of the double-ended queue */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* Get the length of the double-ended queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the double-ended queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Calculate circular array index */\n  int index(int i) {\n    // Use modulo operation to wrap the array head and tail together\n    // When i passes the tail of the array, return to the head\n    // When i passes the head of the array, return to the tail\n    return (i + capacity()) % capacity();\n  }\n\n  /* Front of the queue enqueue */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Double-ended queue is full\");\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Use modulo operation to wrap _front from array head back to tail\n    _front = index(_front - 1);\n    // Add _num to queue front\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* Rear of the queue enqueue */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Double-ended queue is full\");\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    int rear = index(_front + _queSize);\n    // Add _num to queue rear\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Rear of the queue dequeue */\n  int popFirst() {\n    int _num = peekFirst();\n    // Move front pointer right by one\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* Access rear of the queue element */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"Deque is empty\");\n    }\n    return _nums[_front];\n  }\n\n  /* Driver Code */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"Deque is empty\");\n    }\n    // Initialize double-ended queue\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* Return array for printing */\n  List&lt;int&gt; toArray() {\n    // Elements enqueue\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* Double-ended queue based on circular array implementation */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // Array for storing double-ended queue elements\n    front: usize,    // Front pointer, points to the front of the queue element\n    que_size: usize, // Double-ended queue length\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* Constructor */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* Get the capacity of the double-ended queue */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* Get the length of the double-ended queue */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* Check if the double-ended queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Calculate circular array index */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* Front of the queue enqueue */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        self.front = self.index(self.front as i32 - 1);\n        // Add num to front of queue\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* Rear of the queue enqueue */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // Front pointer moves one position backward\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* Rear of the queue dequeue */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // Move front pointer backward by one position\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* Access rear of the queue element */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* Return list for printing */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"Deque is empty\")\n        };\n        self.nums[self.front]\n    }\n\n    /* Driver Code */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"Deque is empty\")\n        };\n        // Initialize double-ended queue\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* Return array for printing */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // Elements enqueue\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* Double-ended queue based on circular array implementation */\ntypedef struct {\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Rear pointer, points to rear + 1\n    int queCapacity; // Queue capacity\n} ArrayDeque;\n\n/* Constructor */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // Initialize array\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Destructor */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* Get the capacity of the double-ended queue */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* Get the length of the double-ended queue */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Check if the double-ended queue is empty */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* Calculate circular array index */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // Use modulo operation to wrap the array head and tail together\n    // When i exceeds array end, wrap to head\n    // When i passes the head of the array, return to the tail\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* Front of the queue enqueue */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Deque is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Use modulo to wrap front from array head to rear\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // Add num to queue front\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* Rear of the queue enqueue */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Deque is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // Front pointer moves one position backward\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* Return list for printing */\nint peekFirst(ArrayDeque *deque) {\n    // Access error: Deque is empty\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* Driver Code */\nint peekLast(ArrayDeque *deque) {\n    // Access error: Deque is empty\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* Rear of the queue dequeue */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // Move front pointer backward by one position\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Access rear of the queue element */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Return array for printing */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* Constructor */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // Array for storing double-ended queue elements\n    private var front: Int = 0 // Front pointer, points to the front of the queue element\n    private var queSize: Int = 0 // Double-ended queue length\n\n    /* Get the capacity of the double-ended queue */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Get the length of the double-ended queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the double-ended queue is empty */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Calculate circular array index */\n    private fun index(i: Int): Int {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity()\n    }\n\n    /* Front of the queue enqueue */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1)\n        // Add num to front of queue\n        nums[front] = num\n        queSize++\n    }\n\n    /* Rear of the queue enqueue */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        val rear = index(front + queSize)\n        // Front pointer moves one position backward\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Rear of the queue dequeue */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // Move front pointer backward by one position\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* Access rear of the queue element */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Driver Code */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Initialize double-ended queue\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* Return array for printing */\n    fun toArray(): IntArray {\n        // Elements enqueue\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### Deque based on circular array ###\nclass ArrayDeque\n  ### Get deque length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### Get deque capacity ###\n  def capacity\n    @nums.length\n  end\n\n  ### Check if deque is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue at front ###\n  def push_first(num)\n    if size == capacity\n      puts 'Double-ended queue is full'\n      return\n    end\n\n    # Use modulo operation to wrap front around to the tail after passing the head of the array\n    # Add num to the front of the queue\n    @front = index(@front - 1)\n    # Add num to front of queue\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### Enqueue at rear ###\n  def push_last(num)\n    if size == capacity\n      puts 'Double-ended queue is full'\n      return\n    end\n\n    # Use modulo operation to wrap rear around to the head after passing the tail of the array\n    rear = index(@front + size)\n    # Front pointer moves one position backward\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Dequeue from front ###\n  def pop_first\n    num = peek_first\n    # Move front pointer backward by one position\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### Dequeue from rear ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek_first\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Access rear element ###\n  def peek_last\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    # Initialize double-ended queue\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### Return array for printing ###\n  def to_array\n    # Elements enqueue\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### Calculate circular array index ###\n  def index(i)\n    # Use modulo operation to wrap the array head and tail together\n    # When i passes the tail of the array, return to the head\n    # When i passes the head of the array, return to the tail\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533-deque-applications","level":2,"title":"5.3.3   Deque Applications","text":"<p>A deque combines the logic of both stacks and queues. Therefore, it can implement all application scenarios of both, while providing greater flexibility.</p> <p>We know that the \"undo\" function in software is typically implemented using a stack: the system pushes each change operation onto the stack and then implements undo through pop. However, considering system resource limitations, software usually limits the number of undo steps (for example, only allowing 50 steps to be saved). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (front of the queue). But a stack cannot implement this functionality, so a deque is needed to replace the stack. Note that the core logic of \"undo\" still follows the LIFO principle of a stack; it's just that the deque can more flexibly implement some additional logic.</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   Queue","text":"<p>A queue is a linear data structure that follows the First In First Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers continuously join the end of the queue, while people at the front of the queue leave one by one.</p> <p>As shown in Figure 5-4, we call the front of the queue the \"front\" and the end the \"rear.\" The operation of adding an element to the rear is called \"enqueue,\" and the operation of removing the front element is called \"dequeue.\"</p> <p></p> <p> Figure 5-4   FIFO rule of queue </p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521-common-queue-operations","level":2,"title":"5.2.1   Common Queue Operations","text":"<p>The common operations on a queue are shown in Table 5-2. Note that method names may vary across different programming languages. We adopt the same naming convention as for stacks here.</p> <p> Table 5-2   Efficiency of Queue Operations </p> Method Description Time Complexity <code>push()</code> Enqueue element, add element to rear \\(O(1)\\) <code>pop()</code> Dequeue front element \\(O(1)\\) <code>peek()</code> Access front element \\(O(1)\\) <p>We can directly use the ready-made queue classes in programming languages:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# Initialize queue\n# In Python, we generally use the deque class as a queue\n# Although queue.Queue() is a pure queue class, it is not very user-friendly, so it is not recommended\nque: deque[int] = deque()\n\n# Enqueue elements\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Access front element\nfront: int = que[0]\n\n# Dequeue element\npop: int = que.popleft()\n\n# Get queue length\nsize: int = len(que)\n\n# Check if queue is empty\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* Initialize queue */\nqueue&lt;int&gt; queue;\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nint front = queue.front();\n\n/* Dequeue element */\nqueue.pop();\n\n/* Get queue length */\nint size = queue.size();\n\n/* Check if queue is empty */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* Initialize queue */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* Enqueue elements */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Access front element */\nint peek = queue.peek();\n\n/* Dequeue element */\nint pop = queue.poll();\n\n/* Get queue length */\nint size = queue.size();\n\n/* Check if queue is empty */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* Initialize queue */\nQueue&lt;int&gt; queue = new();\n\n/* Enqueue elements */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Access front element */\nint peek = queue.Peek();\n\n/* Dequeue element */\nint pop = queue.Dequeue();\n\n/* Get queue length */\nint size = queue.Count;\n\n/* Check if queue is empty */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* Initialize queue */\n// In Go, use list as a queue\nqueue := list.New()\n\n/* Enqueue elements */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Access front element */\npeek := queue.Front()\n\n/* Dequeue element */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Get queue length */\nsize := queue.Len()\n\n/* Check if queue is empty */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* Initialize queue */\n// Swift does not have a built-in queue class, can use Array as a queue\nvar queue: [Int] = []\n\n/* Enqueue elements */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Access front element */\nlet peek = queue.first!\n\n/* Dequeue element */\n// Since it's an array, removeFirst has O(n) complexity\nlet pool = queue.removeFirst()\n\n/* Get queue length */\nlet size = queue.count\n\n/* Check if queue is empty */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* Initialize queue */\n// JavaScript does not have a built-in queue, can use Array as a queue\nconst queue = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nconst peek = queue[0];\n\n/* Dequeue element */\n// The underlying structure is an array, so shift() has O(n) time complexity\nconst pop = queue.shift();\n\n/* Get queue length */\nconst size = queue.length;\n\n/* Check if queue is empty */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* Initialize queue */\n// TypeScript does not have a built-in queue, can use Array as a queue\nconst queue: number[] = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nconst peek = queue[0];\n\n/* Dequeue element */\n// The underlying structure is an array, so shift() has O(n) time complexity\nconst pop = queue.shift();\n\n/* Get queue length */\nconst size = queue.length;\n\n/* Check if queue is empty */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* Initialize queue */\n// In Dart, the Queue class is a deque and can also be used as a queue\nQueue&lt;int&gt; queue = Queue();\n\n/* Enqueue elements */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Access front element */\nint peek = queue.first;\n\n/* Dequeue element */\nint pop = queue.removeFirst();\n\n/* Get queue length */\nint size = queue.length;\n\n/* Check if queue is empty */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* Initialize deque */\n// In Rust, use deque as a regular queue\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Access front element */\nif let Some(front) = deque.front() {\n}\n\n/* Dequeue element */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Get queue length */\nlet size = deque.len();\n\n/* Check if queue is empty */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C does not provide a built-in queue\n</code></pre> queue.kt<pre><code>/* Initialize queue */\nval queue = LinkedList&lt;Int&gt;()\n\n/* Enqueue elements */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* Access front element */\nval peek = queue.peek()\n\n/* Dequeue element */\nval pop = queue.poll()\n\n/* Get queue length */\nval size = queue.size\n\n/* Check if queue is empty */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># Initialize queue\n# Ruby's built-in queue (Thread::Queue) does not have peek and traversal methods, can use Array as a queue\nqueue = []\n\n# Enqueue elements\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# Access front element\npeek = queue.first\n\n# Dequeue element\n# Please note that since it's an array, Array#shift has O(n) time complexity\npop = queue.shift\n\n# Get queue length\nsize = queue.length\n\n# Check if queue is empty\nis_empty = queue.empty?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522-queue-implementation","level":2,"title":"5.2.2   Queue Implementation","text":"<p>To implement a queue, we need a data structure that allows adding elements at one end and removing elements at the other end. Both linked lists and arrays meet this requirement.</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1-linked-list-implementation","level":3,"title":"1.   Linked List Implementation","text":"<p>As shown in Figure 5-5, we can treat the \"head node\" and \"tail node\" of a linked list as the \"front\" and \"rear\" of the queue, respectively, with the rule that nodes can only be added at the rear and removed from the front.</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> Figure 5-5   Enqueue and dequeue operations in linked list implementation of queue </p> <p>Below is the code for implementing a queue using a linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"Queue based on linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._front: ListNode | None = None  # Head node front\n        self._rear: ListNode | None = None  # Tail node rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Enqueue\"\"\"\n        # Add num after the tail node\n        node = ListNode(num)\n        # If the queue is empty, make both front and rear point to the node\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # If the queue is not empty, add the node after the tail node\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Dequeue\"\"\"\n        num = self.peek()\n        # Delete head node\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Queue is empty\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Convert to list for printing\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // Head node front, tail node rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // Traverse linked list to delete nodes and free memory\n        freeMemoryLinkedList(front);\n    }\n\n    /* Get the length of the queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    void push(int num) {\n        // Add num after the tail node\n        ListNode *node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // If the queue is not empty, add the node after the tail node\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    int pop() {\n        int num = peek();\n        // Delete head node\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // Free memory\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"Queue is empty\");\n        return front-&gt;val;\n    }\n\n    /* Convert linked list to Vector and return */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private ListNode front, rear; // Head node front, tail node rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue */\n    public void push(int num) {\n        // Add num after the tail node\n        ListNode node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node;\n            rear = node;\n        // If the queue is not empty, add the node after the tail node\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int pop() {\n        int num = peek();\n        // Delete head node\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Convert linked list to Array and return */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    ListNode? front, rear;  // Head node front, tail node rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Enqueue */\n    public void Push(int num) {\n        // Add num after the tail node\n        ListNode node = new(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node;\n            rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int Pop() {\n        int num = Peek();\n        // Delete head node\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* Convert linked list to Array and return */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* Queue based on linked list implementation */\ntype linkedListQueue struct {\n    // Use built-in package list to implement queue\n    data *list.List\n}\n\n/* Access front of the queue element */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* Enqueue */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* Dequeue */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Get the length of the queue */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* Check if the queue is empty */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private var front: ListNode? // Head node\n    private var rear: ListNode? // Tail node\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue */\n    func push(num: Int) {\n        // Add num after the tail node\n        let node = ListNode(x: num)\n        // If the queue is empty, make both front and rear point to the node\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // If the queue is not empty, add the node after the tail node\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* Dequeue */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Delete head node\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Queue is empty\")\n        }\n        return front!.val\n    }\n\n    /* Convert linked list to Array and return */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    #front; // Front node #front\n    #rear; // Rear node #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* Get the length of the queue */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Enqueue */\n    push(num) {\n        // Add num after the tail node\n        const node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* Dequeue */\n    pop() {\n        const num = this.peek();\n        // Delete head node\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (this.size === 0) throw new Error('Queue is empty');\n        return this.#front.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private front: ListNode | null; // Head node front\n    private rear: ListNode | null; // Tail node rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* Get the length of the queue */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Enqueue */\n    push(num: number): void {\n        // Add num after the tail node\n        const node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* Dequeue */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('Queue is empty');\n        // Delete head node\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (this.size === 0) throw new Error('Queue is empty');\n        return this.front!.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n  ListNode? _front; // Head node _front\n  ListNode? _rear; // Tail node _rear\n  int _queSize = 0; // Queue length\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* Get the length of the queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Enqueue */\n  void push(int _num) {\n    // Add _num after tail node\n    final node = ListNode(_num);\n    // If the queue is empty, make both front and rear point to the node\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // If the queue is not empty, add the node after the tail node\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* Dequeue */\n  int pop() {\n    final int _num = peek();\n    // Delete head node\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('Queue is empty');\n    }\n    return _front!.val;\n  }\n\n  /* Convert linked list to Array and return */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* Queue based on linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Head node front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Tail node rear\n    que_size: usize,                         // Queue length\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Get the length of the queue */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Check if the queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Enqueue */\n    pub fn push(&amp;mut self, num: T) {\n        // Add num after the tail node\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // If the queue is not empty, add the node after the tail node\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // If the queue is empty, make both front and rear point to the node\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* Dequeue */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* Return list for printing */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Convert linked list to Array and return */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* Queue based on linked list implementation */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* Constructor */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Destructor */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // Free all nodes\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Free queue structure\n    free(queue);\n}\n\n/* Get the length of the queue */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* Enqueue */\nvoid push(LinkedListQueue *queue, int num) {\n    // Add node at tail\n    ListNode *node = newListNode(num);\n    // If the queue is empty, make both front and rear point to the node\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // If the queue is not empty, add the node after the tail node\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* Return list for printing */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* Dequeue */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Print queue */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // Copy data from list to array\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue(\n    // Head node front, tail node rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* Get the length of the queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the queue is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Enqueue */\n    fun push(num: Int) {\n        // Add num after the tail node\n        val node = ListNode(num)\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node\n            rear = node\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* Dequeue */\n    fun pop(): Int {\n        val num = peek()\n        // Delete head node\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Convert linked list to Array and return */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### Queue based on linked list ###\nclass LinkedListQueue\n  ### Get queue length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @front = nil  # Head node front\n    @rear = nil   # Tail node rear\n    @size = 0\n  end\n\n  ### Check if queue is empty ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### Enqueue ###\n  def push(num)\n    # Add num after the tail node\n    node = ListNode.new(num)\n\n    # If queue is empty, set both front and rear to this node\n    if @front.nil?\n      @front = node\n      @rear = node\n    # If queue is not empty, add this node after rear\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### Dequeue ###\n  def pop\n    num = peek\n    # Delete head node\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek\n    raise IndexError, 'Queue is empty' if is_empty?\n\n    @front.val\n  end\n\n  ### Convert linked list to Array and return ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>Deleting the first element in an array has a time complexity of \\(O(n)\\), which would make the dequeue operation inefficient. However, we can use the following clever method to avoid this problem.</p> <p>We can use a variable <code>front</code> to point to the index of the front element and maintain a variable <code>size</code> to record the queue length. We define <code>rear = front + size</code>, which calculates the position right after the rear element.</p> <p>Based on this design, the valid interval containing elements in the array is <code>[front, rear - 1]</code>. The implementation methods for various operations are shown in Figure 5-6:</p> <ul> <li>Enqueue operation: Assign the input element to the <code>rear</code> index and increase <code>size</code> by 1.</li> <li>Dequeue operation: Simply increase <code>front</code> by 1 and decrease <code>size</code> by 1.</li> </ul> <p>As you can see, both enqueue and dequeue operations require only one operation, with a time complexity of \\(O(1)\\).</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> Figure 5-6   Enqueue and dequeue operations in array implementation of queue </p> <p>You may notice a problem: as we continuously enqueue and dequeue, both <code>front</code> and <code>rear</code> move to the right. When they reach the end of the array, they cannot continue moving. To solve this problem, we can treat the array as a \"circular array\" with head and tail connected.</p> <p>For a circular array, we need to let <code>front</code> or <code>rear</code> wrap around to the beginning of the array when they cross the end. This periodic pattern can be implemented using the \"modulo operation,\" as shown in the code below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"Queue based on circular array implementation\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"Constructor\"\"\"\n        self._nums: list[int] = [0] * size  # Array for storing queue elements\n        self._front: int = 0  # Front pointer, points to the front of the queue element\n        self._size: int = 0  # Queue length\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get the capacity of the queue\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Enqueue\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"Queue is full\")\n        # Calculate rear pointer, points to rear index + 1\n        # Use modulo operation to wrap rear around to the head after passing the tail of the array\n        rear: int = (self._front + self._size) % self.capacity()\n        # Add num to the rear of the queue\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Dequeue\"\"\"\n        num: int = self.peek()\n        # Front pointer moves one position backward, if it passes the tail, return to the head of the array\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Queue is empty\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Return list for printing\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n  private:\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Queue length\n    int queCapacity; // Queue capacity\n\n  public:\n    ArrayQueue(int capacity) {\n        // Initialize array\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* Get the capacity of the queue */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* Get the length of the queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"Queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % queCapacity;\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    int pop() {\n        int num = peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"Queue is empty\");\n        return nums[front];\n    }\n\n    /* Convert array to Vector and return */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private int[] nums; // Array for storing queue elements\n    private int front; // Front pointer, points to the front of the queue element\n    private int queSize; // Queue length\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Get the length of the queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % capacity();\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int pop() {\n        int num = peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Return array */\n    public int[] toArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    int[] nums;  // Array for storing queue elements\n    int front;   // Front pointer, points to the front of the queue element\n    int queSize; // Queue length\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Get the length of the queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % Capacity();\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int Pop() {\n        int num = Peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* Return array */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* Queue based on circular array implementation */\ntype arrayQueue struct {\n    nums        []int // Array for storing queue elements\n    front       int   // Front pointer, points to the front of the queue element\n    queSize     int   // Queue length\n    queCapacity int   // Queue capacity (maximum number of elements)\n}\n\n/* Access front of the queue element */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Get the length of the queue */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* Check if the queue is empty */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Enqueue */\nfunc (q *arrayQueue) push(num int) {\n    // When rear == queCapacity, queue is full\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    rear := (q.front + q.queSize) % q.queCapacity\n    // Front pointer moves one position backward\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Dequeue */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* Return list for printing */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Get Slice for printing */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private var nums: [Int] // Array for storing queue elements\n    private var front: Int // Front pointer, points to the front of the queue element\n    private var _size: Int // Queue length\n\n    init(capacity: Int) {\n        // Initialize array\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Get the capacity of the queue */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Get the length of the queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"Queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        let rear = (front + size()) % capacity()\n        // Front pointer moves one position backward\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Dequeue */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Queue is empty\")\n        }\n        return nums[front]\n    }\n\n    /* Return array */\n    func toArray() -&gt; [Int] {\n        // Elements enqueue\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    #nums; // Array for storing queue elements\n    #front = 0; // Front pointer, points to the front of the queue element\n    #queSize = 0; // Queue length\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* Get the capacity of the queue */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* Get the length of the queue */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Enqueue */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('Queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        const rear = (this.#front + this.size) % this.capacity;\n        // Front pointer moves one position backward\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Dequeue */\n    pop() {\n        const num = this.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (this.isEmpty()) throw new Error('Queue is empty');\n        return this.#nums[this.#front];\n    }\n\n    /* Return Array */\n    toArray() {\n        // Elements enqueue\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private nums: number[]; // Array for storing queue elements\n    private front: number; // Front pointer, points to the front of the queue element\n    private queSize: number; // Queue length\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Get the length of the queue */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Enqueue */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('Queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        const rear = (this.front + this.queSize) % this.capacity;\n        // Front pointer moves one position backward\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Dequeue */\n    pop(): number {\n        const num = this.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('Queue is empty');\n        return this.nums[this.front];\n    }\n\n    /* Return Array */\n    toArray(): number[] {\n        // Elements enqueue\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // Array for storing queue elements\n  late int _front; // Front pointer, points to the front of the queue element\n  late int _queSize; // Queue length\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* Get the capacity of the queue */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* Get the length of the queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Enqueue */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"Queue is full\");\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    int rear = (_front + _queSize) % capaCity();\n    // Add _num to queue rear\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Dequeue */\n  int pop() {\n    int _num = peek();\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"Queue is empty\");\n    }\n    return _nums[_front];\n  }\n\n  /* Return Array */\n  List&lt;int&gt; toArray() {\n    // Elements enqueue\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* Queue based on circular array implementation */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // Array for storing queue elements\n    front: i32,        // Front pointer, points to the front of the queue element\n    que_size: i32,     // Queue length\n    que_capacity: i32, // Queue capacity\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* Constructor */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* Get the capacity of the queue */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* Get the length of the queue */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* Check if the queue is empty */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Enqueue */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // Front pointer moves one position backward\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* Dequeue */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* Return list for printing */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* Return array */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* Queue based on circular array implementation */\ntypedef struct {\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Rear pointer, points to rear + 1\n    int queCapacity; // Queue capacity\n} ArrayQueue;\n\n/* Constructor */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // Initialize array\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Destructor */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* Get the capacity of the queue */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* Get the length of the queue */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* Return list for printing */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* Enqueue */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"Queue is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // Front pointer moves one position backward\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* Dequeue */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Return array for printing */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // Array for storing queue elements\n    private var front: Int = 0 // Front pointer, points to the front of the queue element\n    private var queSize: Int = 0 // Queue length\n\n    /* Get the capacity of the queue */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Get the length of the queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the queue is empty */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Enqueue */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        val rear = (front + queSize) % capacity()\n        // Front pointer moves one position backward\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Dequeue */\n    fun pop(): Int {\n        val num = peek()\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Return array */\n    fun toArray(): IntArray {\n        // Elements enqueue\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### Queue based on circular array ###\nclass ArrayQueue\n  ### Get queue length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # Array for storing queue elements\n    @front = 0 # Front pointer, points to the front of the queue element\n    @size = 0 # Queue length\n  end\n\n  ### Get queue capacity ###\n  def capacity\n    @nums.length\n  end\n\n  ### Check if queue is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue ###\n  def push(num)\n    raise IndexError, 'Queue is full' if size == capacity\n\n    # Use modulo operation to wrap rear around to the head after passing the tail of the array\n    # Add num to the rear of the queue\n    rear = (@front + size) % capacity\n    # Front pointer moves one position backward\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Dequeue ###\n  def pop\n    num = peek\n    # Move front pointer backward by one position, if it passes the tail, return to array head\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek\n    raise IndexError, 'Queue is empty' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Return list for printing ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> <p>The queue implemented above still has limitations: its length is immutable. However, this problem is not difficult to solve. We can replace the array with a dynamic array to introduce an expansion mechanism. Interested readers can try to implement this themselves.</p> <p>The comparison conclusions for the two implementations are consistent with those for stacks and will not be repeated here.</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523-typical-applications-of-queue","level":2,"title":"5.2.3   Typical Applications of Queue","text":"<ul> <li>Taobao orders. After shoppers place orders, the orders are added to a queue, and the system subsequently processes the orders in the queue according to their sequence. During Double Eleven, massive orders are generated in a short time, and high concurrency becomes a key challenge that engineers need to tackle.</li> <li>Various to-do tasks. Any scenario that needs to implement \"first come, first served\" functionality, such as a printer's task queue or a restaurant's order queue, can effectively maintain the processing order using queues.</li> </ul>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   Stack","text":"<p>A stack is a linear data structure that follows the Last In First Out (LIFO) logic.</p> <p>We can compare a stack to a pile of plates on a table. If we specify that only one plate can be moved at a time, then to get the bottom plate, we must first remove the plates above it one by one. If we replace the plates with various types of elements (such as integers, characters, objects, etc.), we get the stack data structure.</p> <p>As shown in Figure 5-1, we call the top of the stacked elements the \"top\" and the bottom the \"base.\" The operation of adding an element to the top is called \"push,\" and the operation of removing the top element is called \"pop.\"</p> <p></p> <p> Figure 5-1   LIFO rule of stack </p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511-common-stack-operations","level":2,"title":"5.1.1   Common Stack Operations","text":"<p>The common operations on a stack are shown in Table 5-1. The specific method names depend on the programming language used. Here, we use the common naming convention of <code>push()</code>, <code>pop()</code>, and <code>peek()</code>.</p> <p> Table 5-1   Efficiency of Stack Operations </p> Method Description Time Complexity <code>push()</code> Push element onto stack (add to top) \\(O(1)\\) <code>pop()</code> Pop top element from stack \\(O(1)\\) <code>peek()</code> Access top element \\(O(1)\\) <p>Typically, we can directly use the built-in stack class provided by the programming language. However, some languages may not provide a dedicated stack class. In these cases, we can use the language's \"array\" or \"linked list\" as a stack and ignore operations unrelated to the stack in the program logic.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># Initialize stack\n# Python does not have a built-in stack class, can use list as a stack\nstack: list[int] = []\n\n# Push elements\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Access top element\npeek: int = stack[-1]\n\n# Pop element\npop: int = stack.pop()\n\n# Get stack length\nsize: int = len(stack)\n\n# Check if empty\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* Initialize stack */\nstack&lt;int&gt; stack;\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nint top = stack.top();\n\n/* Pop element */\nstack.pop(); // No return value\n\n/* Get stack length */\nint size = stack.size();\n\n/* Check if empty */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* Initialize stack */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nint peek = stack.peek();\n\n/* Pop element */\nint pop = stack.pop();\n\n/* Get stack length */\nint size = stack.size();\n\n/* Check if empty */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* Initialize stack */\nStack&lt;int&gt; stack = new();\n\n/* Push elements */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Access top element */\nint peek = stack.Peek();\n\n/* Pop element */\nint pop = stack.Pop();\n\n/* Get stack length */\nint size = stack.Count;\n\n/* Check if empty */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* Initialize stack */\n// In Go, it is recommended to use Slice as a stack\nvar stack []int\n\n/* Push elements */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Access top element */\npeek := stack[len(stack)-1]\n\n/* Pop element */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Get stack length */\nsize := len(stack)\n\n/* Check if empty */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* Initialize stack */\n// Swift does not have a built-in stack class, can use Array as a stack\nvar stack: [Int] = []\n\n/* Push elements */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Access top element */\nlet peek = stack.last!\n\n/* Pop element */\nlet pop = stack.removeLast()\n\n/* Get stack length */\nlet size = stack.count\n\n/* Check if empty */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* Initialize stack */\n// JavaScript does not have a built-in stack class, can use Array as a stack\nconst stack = [];\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nconst peek = stack[stack.length-1];\n\n/* Pop element */\nconst pop = stack.pop();\n\n/* Get stack length */\nconst size = stack.length;\n\n/* Check if empty */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* Initialize stack */\n// TypeScript does not have a built-in stack class, can use Array as a stack\nconst stack: number[] = [];\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nconst peek = stack[stack.length - 1];\n\n/* Pop element */\nconst pop = stack.pop();\n\n/* Get stack length */\nconst size = stack.length;\n\n/* Check if empty */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* Initialize stack */\n// Dart does not have a built-in stack class, can use List as a stack\nList&lt;int&gt; stack = [];\n\n/* Push elements */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Access top element */\nint peek = stack.last;\n\n/* Pop element */\nint pop = stack.removeLast();\n\n/* Get stack length */\nint size = stack.length;\n\n/* Check if empty */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* Initialize stack */\n// Use Vec as a stack\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nlet top = stack.last().unwrap();\n\n/* Pop element */\nlet pop = stack.pop().unwrap();\n\n/* Get stack length */\nlet size = stack.len();\n\n/* Check if empty */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C does not provide a built-in stack\n</code></pre> stack.kt<pre><code>/* Initialize stack */\nval stack = Stack&lt;Int&gt;()\n\n/* Push elements */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* Access top element */\nval peek = stack.peek()\n\n/* Pop element */\nval pop = stack.pop()\n\n/* Get stack length */\nval size = stack.size\n\n/* Check if empty */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># Initialize stack\n# Ruby does not have a built-in stack class, can use Array as a stack\nstack = []\n\n# Push elements\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# Access top element\npeek = stack.last\n\n# Pop element\npop = stack.pop\n\n# Get stack length\nsize = stack.length\n\n# Check if empty\nis_empty = stack.empty?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512-stack-implementation","level":2,"title":"5.1.2   Stack Implementation","text":"<p>To gain a deeper understanding of how a stack operates, let's try implementing a stack class ourselves.</p> <p>A stack follows the LIFO principle, so we can only add or remove elements at the top. However, both arrays and linked lists allow adding and removing elements at any position. Therefore, a stack can be viewed as a restricted array or linked list. In other words, we can \"shield\" some irrelevant operations of arrays or linked lists so that their external logic conforms to the characteristics of a stack.</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1-linked-list-implementation","level":3,"title":"1.   Linked List Implementation","text":"<p>When implementing a stack using a linked list, we can treat the head node of the linked list as the top of the stack and the tail node as the base.</p> <p>As shown in Figure 5-2, for the push operation, we simply insert an element at the head of the linked list. This node insertion method is called the \"head insertion method.\" For the pop operation, we just need to remove the head node from the linked list.</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> Figure 5-2   Push and pop operations in linked list implementation of stack </p> <p>Below is sample code for implementing a stack based on a linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"Stack based on linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the stack\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the stack is empty\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"Push\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Pop\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access top of the stack element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Convert to list for printing\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // Use head node as stack top\n    int stkSize;        // Stack length\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // Traverse linked list to delete nodes and free memory\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* Get the length of the stack */\n    int size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // Free memory\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"Stack is empty\");\n        return stackTop-&gt;val;\n    }\n\n    /* Convert List to Array and return */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private ListNode stackPeek; // Use head node as stack top\n    private int stkSize = 0; // Stack length\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    public int size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* Convert List to Array and return */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    ListNode? stackPeek;  // Use head node as stack top\n    int stkSize = 0;   // Stack length\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Push */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* Convert List to Array and return */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* Stack based on linked list implementation */\ntype linkedListStack struct {\n    // Use built-in package list to implement stack\n    data *list.List\n}\n\n/* Access top of the stack element */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* Push */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* Pop */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Get the length of the stack */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* Check if the stack is empty */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private var _peek: ListNode? // Use head node as stack top\n    private var _size: Int // Stack length\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the stack */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the stack is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Push */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* Pop */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return _peek!.val\n    }\n\n    /* Convert List to Array and return */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    #stackPeek; // Use head node as stack top\n    #stkSize = 0; // Stack length\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Push */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* Pop */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (!this.#stackPeek) throw new Error('Stack is empty');\n        return this.#stackPeek.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // Use head node as stack top\n    private stkSize: number = 0; // Stack length\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Push */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* Pop */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('Stack is empty');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('Stack is empty');\n        return this.stackPeek.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* Stack implemented based on linked list class */\nclass LinkedListStack {\n  ListNode? _stackPeek; // Use head node as stack top\n  int _stkSize = 0; // Stack length\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* Get the length of the stack */\n  int size() {\n    return _stkSize;\n  }\n\n  /* Check if the stack is empty */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* Push */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* Pop */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* Convert linked list to List and return */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* Stack based on linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Use head node as stack top\n    stk_size: usize,                              // Stack length\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* Get the length of the stack */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* Check if the stack is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* Push */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* Pop */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* Return list for printing */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* Convert List to Array and return */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* Stack based on linked list implementation */\ntypedef struct {\n    ListNode *top; // Use head node as stack top\n    int size;      // Stack length\n} LinkedListStack;\n\n/* Constructor */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* Destructor */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* Get the length of the stack */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* Check if the stack is empty */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* Push */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // Update new node's pointer field\n    node-&gt;val = num;     // Update new node's data field\n    s-&gt;top = node;       // Update stack top\n    s-&gt;size++;           // Update stack size\n}\n\n/* Return list for printing */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"Stack is empty\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* Pop */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // Free memory\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // Use head node as stack top\n    private var stkSize: Int = 0 // Stack length\n) {\n\n    /* Get the length of the stack */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* Check if the stack is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Push */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* Pop */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* Convert List to Array and return */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### Stack based on linked list ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @size = 0\n  end\n\n  ### Check if stack is empty ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### Push ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### Pop ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### Access top element ###\n  def peek\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @peek.val\n  end\n\n  ### Convert linked list to Array and return ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>When implementing a stack using an array, we can treat the end of the array as the top of the stack. As shown in Figure 5-3, push and pop operations correspond to adding and removing elements at the end of the array, both with a time complexity of \\(O(1)\\).</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> Figure 5-3   Push and pop operations in array implementation of stack </p> <p>Since elements pushed onto the stack may increase continuously, we can use a dynamic array, which eliminates the need to handle array expansion ourselves. Here is the sample code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"Stack based on array implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the stack\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the stack is empty\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"Push\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"Pop\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"Access top of the stack element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Return list for printing\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* Get the length of the stack */\n    int size() {\n        return stack.size();\n    }\n\n    /* Check if the stack is empty */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* Push */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* Pop */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* Return list for printing */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"Stack is empty\");\n        return stack.back();\n    }\n\n    /* Return Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // Initialize list (dynamic array)\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* Get the length of the stack */\n    public int size() {\n        return stack.size();\n    }\n\n    /* Check if the stack is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* Pop */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* Convert List to Array and return */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // Initialize list (dynamic array)\n        stack = [];\n    }\n\n    /* Get the length of the stack */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* Check if the stack is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Push */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* Pop */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* Convert List to Array and return */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* Stack based on array implementation */\ntype arrayStack struct {\n    data []int // Data\n}\n\n/* Access top of the stack element */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // Set stack length to 0, capacity to 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* Stack length */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* Is stack empty */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* Push */\nfunc (s *arrayStack) push(v int) {\n    // Slice will automatically expand\n    s.data = append(s.data, v)\n}\n\n/* Pop */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* Get stack top element */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* Get Slice for printing */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // Initialize list (dynamic array)\n        stack = []\n    }\n\n    /* Get the length of the stack */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* Check if the stack is empty */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* Push */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* Pop */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return stack.removeLast()\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return stack.last!\n    }\n\n    /* Convert List to Array and return */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* Get the length of the stack */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* Push */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* Pop */\n    pop() {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.#stack.pop();\n    }\n\n    /* Return list for printing */\n    top() {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Return Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* Get the length of the stack */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* Push */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* Pop */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.stack.pop();\n    }\n\n    /* Return list for printing */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Return Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* Get the length of the stack */\n  int size() {\n    return _stack.length;\n  }\n\n  /* Check if the stack is empty */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* Push */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* Pop */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stack.last;\n  }\n\n  /* Convert stack to Array and return */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* Stack based on array implementation */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* Access top of the stack element */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* Get the length of the stack */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* Check if the stack is empty */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* Push */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* Pop */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* Return list for printing */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"Stack is empty\")\n        };\n        self.stack.last()\n    }\n\n    /* Return &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* Stack based on array implementation */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* Constructor */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // Initialize with large capacity to avoid expansion\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* Destructor */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* Get the length of the stack */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* Check if the stack is empty */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* Push */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"Stack is full\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* Return list for printing */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"Stack is empty\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* Pop */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    // Initialize list (dynamic array)\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* Get the length of the stack */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* Check if the stack is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Push */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* Pop */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* Convert List to Array and return */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### Stack based on array ###\nclass ArrayStack\n  ### Constructor ###\n  def initialize\n    @stack = []\n  end\n\n  ### Get stack length ###\n  def size\n    @stack.length\n  end\n\n  ### Check if stack is empty ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### Push ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### Pop ###\n  def pop\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @stack.pop\n  end\n\n  ### Access top element ###\n  def peek\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @stack.last\n  end\n\n  ### Return list for printing ###\n  def to_array\n    @stack\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513-comparison-of-the-two-implementations","level":2,"title":"5.1.3   Comparison of the Two Implementations","text":"<p>Supported Operations</p> <p>Both implementations support all operations defined by the stack. The array implementation additionally supports random access, but this goes beyond the stack definition and is generally not used.</p> <p>Time Efficiency</p> <p>In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and is therefore more efficient. However, if pushing exceeds the array capacity, it triggers an expansion mechanism, causing the time complexity of that particular push operation to become \\(O(n)\\).</p> <p>In the linked list-based implementation, list expansion is very flexible, and there is no issue of reduced efficiency due to array expansion. However, the push operation requires initializing a node object and modifying pointers, so it is relatively less efficient. Nevertheless, if the pushed elements are already node objects, the initialization step can be omitted, thereby improving efficiency.</p> <p>In summary, when the elements pushed and popped are basic data types such as <code>int</code> or <code>double</code>, we can draw the following conclusions:</p> <ul> <li>The array-based stack implementation has reduced efficiency when expansion is triggered, but since expansion is an infrequent operation, the average efficiency is higher.</li> <li>The linked list-based stack implementation can provide more stable efficiency performance.</li> </ul> <p>Space Efficiency</p> <p>When initializing a list, the system allocates an \"initial capacity\" that may exceed the actual need. Additionally, the expansion mechanism typically expands at a specific ratio (e.g., 2x), and the capacity after expansion may also exceed actual needs. Therefore, the array-based stack implementation may cause some space wastage.</p> <p>However, since linked list nodes need to store additional pointers, the space occupied by linked list nodes is relatively large.</p> <p>In summary, we cannot simply determine which implementation is more memory-efficient and need to analyze the specific situation.</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514-typical-applications-of-stack","level":2,"title":"5.1.4   Typical Applications of Stack","text":"<ul> <li>Back and forward in browsers, undo and redo in software. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to return to the previous page via the back operation. The back operation is essentially performing a pop. To support both back and forward, two stacks are needed to work together.</li> <li>Program memory management. Each time a function is called, the system adds a stack frame to the top of the stack to record the function's context information. During recursion, the downward recursive phase continuously performs push operations, while the upward backtracking phase continuously performs pop operations.</li> </ul>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   Summary","text":"","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A stack is a data structure that follows the LIFO principle and can be implemented using arrays or linked lists.</li> <li>In terms of time efficiency, the array implementation of a stack has higher average efficiency, but during expansion, the time complexity of a single push operation degrades to \\(O(n)\\). In contrast, the linked list implementation of a stack provides more stable efficiency performance.</li> <li>In terms of space efficiency, the array implementation of a stack may lead to some degree of space wastage. However, it should be noted that the memory space occupied by linked list nodes is larger than that of array elements.</li> <li>A queue is a data structure that follows the FIFO principle and can also be implemented using arrays or linked lists. The conclusions regarding time efficiency and space efficiency comparisons for queues are similar to those for stacks mentioned above.</li> <li>A deque is a queue with greater flexibility that allows adding and removing elements at both ends.</li> </ul>","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is the browser's forward and backward functionality implemented with a doubly linked list?</p> <p>The forward and backward functionality of a browser is essentially a manifestation of a \"stack.\" When a user visits a new page, that page is added to the top of the stack; when the user clicks the back button, that page is popped from the top of the stack. Using a deque can conveniently implement some additional operations, as mentioned in the \"Deque\" section.</p> <p>Q: After popping from the stack, do we need to free the memory of the popped node?</p> <p>If the popped node will still be needed later, then memory does not need to be freed. If it won't be used afterward, languages like Java and Python have automatic garbage collection, so manual memory deallocation is not required; in C and C++, manual memory deallocation is necessary.</p> <p>Q: A deque seems like two stacks joined together. What is its purpose?</p> <p>A deque is like a combination of a stack and a queue, or two stacks joined together. It exhibits the logic of both stack and queue, so it can implement all applications of stacks and queues, and is more flexible.</p> <p>Q: How are undo and redo specifically implemented?</p> <p>Use two stacks: stack <code>A</code> for undo and stack <code>B</code> for redo.</p> <ol> <li>Whenever the user performs an operation, push this operation onto stack <code>A</code> and clear stack <code>B</code>.</li> <li>When the user performs \"undo,\" pop the most recent operation from stack <code>A</code> and push it onto stack <code>B</code>.</li> <li>When the user performs \"redo,\" pop the most recent operation from stack <code>B</code> and push it onto stack <code>A</code>.</li> </ol>","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"Chapter 7.   Tree","text":"<p>Abstract</p> <p>Towering trees are full of vitality, with deep roots and lush leaves, spreading branches and flourishing.</p> <p>They show us the vivid form of divide and conquer in data.</p>","path":["Chapter 7. Tree","Chapter 7. &nbsp; Tree"],"tags":[]},{"location":"chapter_tree/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>7.1   Binary Tree</li> <li>7.2   Binary Tree Traversal</li> <li>7.3   Array Representation of Tree</li> <li>7.4   Binary Search Tree</li> <li>7.5   AVL Tree *</li> <li>7.6   Summary</li> </ul>","path":["Chapter 7. Tree","Chapter 7. &nbsp; Tree"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   Array Representation of Binary Trees","text":"<p>Under the linked list representation, the storage unit of a binary tree is a node <code>TreeNode</code>, and nodes are connected by pointers. The previous section introduced the basic operations of binary trees under the linked list representation.</p> <p>So, can we use an array to represent a binary tree? The answer is yes.</p>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731-representing-perfect-binary-trees","level":2,"title":"7.3.1   Representing Perfect Binary Trees","text":"<p>Let's analyze a simple case first. Given a perfect binary tree, we store all nodes in an array according to the order of level-order traversal, where each node corresponds to a unique array index.</p> <p>Based on the characteristics of level-order traversal, we can derive a \"mapping formula\" between parent node index and child node indices: If a node's index is \\(i\\), then its left child index is \\(2i + 1\\) and its right child index is \\(2i + 2\\). Figure 7-12 shows the mapping relationships between various node indices.</p> <p></p> <p> Figure 7-12   Array representation of a perfect binary tree </p> <p>The mapping formula plays a role similar to the node references (pointers) in linked lists. Given any node in the array, we can access its left (right) child node using the mapping formula.</p>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732-representing-any-binary-tree","level":2,"title":"7.3.2   Representing Any Binary Tree","text":"<p>Perfect binary trees are a special case; in the middle levels of a binary tree, there are typically many <code>None</code> values. Since the level-order traversal sequence does not include these <code>None</code> values, we cannot infer the number and distribution of <code>None</code> values based on this sequence alone. This means multiple binary tree structures can correspond to the same level-order traversal sequence.</p> <p>As shown in Figure 7-13, given a non-perfect binary tree, the above method of array representation fails.</p> <p></p> <p> Figure 7-13   Level-order traversal sequence corresponds to multiple binary tree possibilities </p> <p>To solve this problem, we can consider explicitly writing out all <code>None</code> values in the level-order traversal sequence. As shown in Figure 7-14, after this treatment, the level-order traversal sequence can uniquely represent a binary tree. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Array representation of a binary tree\n# Using None to represent empty slots\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the maximum integer value INT_MAX to mark empty slots\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the Integer wrapper class allows for using null to mark empty slots\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using an any type slice, allowing for nil to mark empty slots\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using optional Int (Int?) allows for using nil to mark empty slots\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using None to mark empty slots\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the maximum int value to mark empty slots, therefore, node values must not be INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### Array representation of a binary tree ###\n# Using nil to represent empty slots\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> Figure 7-14   Array representation of any type of binary tree </p> <p>It's worth noting that complete binary trees are very well-suited for array representation. Recalling the definition of a complete binary tree, <code>None</code> only appears at the bottom level and towards the right, meaning all <code>None</code> values must appear at the end of the level-order traversal sequence.</p> <p>This means that when using an array to represent a complete binary tree, it's possible to omit storing all <code>None</code> values, which is very convenient. Figure 7-15 gives an example.</p> <p></p> <p> Figure 7-15   Array representation of a complete binary tree </p> <p>The following code implements a binary tree based on array representation, including the following operations:</p> <ul> <li>Given a certain node, obtain its value, left (right) child node, and parent node.</li> <li>Obtain the preorder, inorder, postorder, and level-order traversal sequences.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"Binary tree class represented by array\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"Constructor\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"List capacity\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"Get value of node at index i\"\"\"\n        # If index is out of bounds, return None, representing empty position\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"Get index of left child node of node at index i\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"Get index of right child node of node at index i\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"Get index of parent node of node at index i\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"Level-order traversal\"\"\"\n        self.res = []\n        # Traverse array directly\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"Depth-first traversal\"\"\"\n        if self.val(i) is None:\n            return\n        # Preorder traversal\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # Inorder traversal\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # Postorder traversal\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"Preorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"Inorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"Postorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n  public:\n    /* Constructor */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* List capacity */\n    int size() {\n        return tree.size();\n    }\n\n    /* Get value of node at index i */\n    int val(int i) {\n        // Return INT_MAX if index out of bounds, representing empty position\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // Traverse array directly\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* Preorder traversal */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* Depth-first traversal */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // If empty position, return\n        if (val(i) == INT_MAX)\n            return;\n        // Preorder traversal\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // Inorder traversal\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // Postorder traversal\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* Constructor */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* List capacity */\n    public int size() {\n        return tree.size();\n    }\n\n    /* Get value of node at index i */\n    public Integer val(int i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* Get index of left child node of node at index i */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // Traverse array directly\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // If empty position, return\n        if (val(i) == null)\n            return;\n        // Preorder traversal\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // Inorder traversal\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // Postorder traversal\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* Preorder traversal */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* List capacity */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* Get value of node at index i */\n    public int? Val(int i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // Traverse array directly\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // If empty position, return\n        if (!Val(i).HasValue)\n            return;\n        // Preorder traversal\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // Inorder traversal\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // Postorder traversal\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* Preorder traversal */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* Binary tree class represented by array */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* Constructor */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* List capacity */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* Get value of node at index i */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // If index out of bounds, return null to represent empty position\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* Get index of left child node of node at index i */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* Get index of right child node of node at index i */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* Get index of parent node of node at index i */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* Level-order traversal */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // Traverse array directly\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* Depth-first traversal */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // If empty position, return\n    if abt.val(i) == nil {\n        return\n    }\n    // Preorder traversal\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // Inorder traversal\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // Postorder traversal\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* Preorder traversal */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* Inorder traversal */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* Postorder traversal */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* Constructor */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* List capacity */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* Get value of node at index i */\n    func val(i: Int) -&gt; Int? {\n        // If index out of bounds, return null to represent empty position\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* Get index of left child node of node at index i */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // Traverse array directly\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* Depth-first traversal */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // If empty position, return\n        guard let val = val(i: i) else {\n            return\n        }\n        // Preorder traversal\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // Inorder traversal\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // Postorder traversal\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* Preorder traversal */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* Inorder traversal */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* Postorder traversal */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* Constructor */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* List capacity */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* Get value of node at index i */\n    val(i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // Floor division\n    }\n\n    /* Level-order traversal */\n    levelOrder() {\n        let res = [];\n        // Traverse array directly\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    #dfs(i, order, res) {\n        // If empty position, return\n        if (this.val(i) === null) return;\n        // Preorder traversal\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Inorder traversal\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Postorder traversal\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Preorder traversal */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* Constructor */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* List capacity */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* Get value of node at index i */\n    val(i: number): number | null {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // Floor division\n    }\n\n    /* Level-order traversal */\n    levelOrder(): number[] {\n        let res = [];\n        // Traverse array directly\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // If empty position, return\n        if (this.val(i) === null) return;\n        // Preorder traversal\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Inorder traversal\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Postorder traversal\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Preorder traversal */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* Constructor */\n  ArrayBinaryTree(this._tree);\n\n  /* List capacity */\n  int size() {\n    return _tree.length;\n  }\n\n  /* Get value of node at index i */\n  int? val(int i) {\n    // If index out of bounds, return null to represent empty position\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* Get index of left child node of node at index i */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* Get index of right child node of node at index i */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* Get index of parent node of node at index i */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* Level-order traversal */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* Depth-first traversal */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // If empty position, return\n    if (val(i) == null) {\n      return;\n    }\n    // Preorder traversal\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // Inorder traversal\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // Postorder traversal\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* Preorder traversal */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* Inorder traversal */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* Postorder traversal */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* Binary tree class represented by array */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* Constructor */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* List capacity */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* Get value of node at index i */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // If index is out of bounds, return None, representing empty position\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* Get index of left child node of node at index i */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* Depth-first traversal */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // Preorder traversal\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // Inorder traversal\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // Postorder traversal\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* Preorder traversal */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* Inorder traversal */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* Postorder traversal */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* Binary tree structure in array representation */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* Constructor */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* Destructor */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* List capacity */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* Get value of node at index i */\nint val(ArrayBinaryTree *abt, int i) {\n    // Return INT_MAX if index out of bounds, representing empty position\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* Level-order traversal */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // Traverse array directly\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* Depth-first traversal */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // If empty position, return\n    if (val(abt, i) == INT_MAX)\n        return;\n    // Preorder traversal\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // Inorder traversal\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // Postorder traversal\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* Preorder traversal */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Inorder traversal */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Postorder traversal */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* List capacity */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* Get value of node at index i */\n    fun _val(i: Int): Int? {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* Get index of left child node of node at index i */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // Traverse array directly\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* Depth-first traversal */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // If empty position, return\n        if (_val(i) == null)\n            return\n        // Preorder traversal\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // Inorder traversal\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // Postorder traversal\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* Preorder traversal */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* Inorder traversal */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* Postorder traversal */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### Array representation of binary tree class ###\nclass ArrayBinaryTree\n  ### Constructor ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### List capacity ###\n  def size\n    @tree.length\n  end\n\n  ### Get value of node at index i ###\n  def val(i)\n    # Return nil if index out of bounds, representing empty position\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### Get left child index of node at index i ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### Get right child index of node at index i ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### Get parent node index of node at index i ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### Level-order traversal ###\n  def level_order\n    @res = []\n\n    # Traverse array directly\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### Depth-first traversal ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # Preorder traversal\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # Inorder traversal\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # Postorder traversal\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### Pre-order traversal ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### In-order traversal ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### Post-order traversal ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733-advantages-and-limitations","level":2,"title":"7.3.3   Advantages and Limitations","text":"<p>The array representation of binary trees has the following advantages:</p> <ul> <li>Arrays are stored in contiguous memory space, which is cache-friendly, allowing faster access and traversal.</li> <li>It does not require storing pointers, which saves space.</li> <li>It allows random access to nodes.</li> </ul> <p>However, the array representation also has some limitations:</p> <ul> <li>Array storage requires contiguous memory space, so it is not suitable for storing trees with a large amount of data.</li> <li>Adding or removing nodes requires array insertion and deletion operations, which have lower efficiency.</li> <li>When there are many <code>None</code> values in the binary tree, the proportion of node data contained in the array is low, leading to lower space utilization.</li> </ul>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   Avl Tree *","text":"<p>In the \"Binary Search Tree\" section, we mentioned that after multiple insertion and removal operations, a binary search tree may degenerate into a linked list. In this case, the time complexity of all operations degrades from \\(O(\\log n)\\) to \\(O(n)\\).</p> <p>As shown in Figure 7-24, after two node removal operations, this binary search tree will degrade into a linked list.</p> <p></p> <p> Figure 7-24   Degradation of an AVL tree after removing nodes </p> <p>For example, in the perfect binary tree shown in Figure 7-25, after inserting two nodes, the tree will lean heavily to the left, and the time complexity of search operations will also degrade.</p> <p></p> <p> Figure 7-25   Degradation of an AVL tree after inserting nodes </p> <p>In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the AVL tree in their paper \"An algorithm for the organization of information\". The paper described in detail a series of operations ensuring that after continuously adding and removing nodes, the AVL tree does not degenerate, thus keeping the time complexity of various operations at the \\(O(\\log n)\\) level. In other words, in scenarios requiring frequent insertions, deletions, searches, and modifications, the AVL tree can always maintain efficient data operation performance, making it very valuable in applications.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-common-terminology-in-avl-trees","level":2,"title":"7.5.1   Common Terminology in Avl Trees","text":"<p>An AVL tree is both a binary search tree and a balanced binary tree, simultaneously satisfying all the properties of these two types of binary trees, hence it is a balanced binary search tree.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-node-height","level":3,"title":"1.   Node Height","text":"<p>Since the operations related to AVL trees require obtaining node heights, we need to add a <code>height</code> variable to the node class:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # Node value\n        self.height: int = 0                # Node height\n        self.left: TreeNode | None = None   # Left child reference\n        self.right: TreeNode | None = None  # Right child reference\n</code></pre> <pre><code>/* AVL tree node */\nstruct TreeNode {\n    int val{};          // Node value\n    int height = 0;     // Node height\n    TreeNode *left{};   // Left child\n    TreeNode *right{};  // Right child\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    public int val;        // Node value\n    public int height;     // Node height\n    public TreeNode left;  // Left child\n    public TreeNode right; // Right child\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public int height;      // Node height\n    public TreeNode? left;  // Left child reference\n    public TreeNode? right; // Right child reference\n}\n</code></pre> <pre><code>/* AVL tree node */\ntype TreeNode struct {\n    Val    int       // Node value\n    Height int       // Node height\n    Left   *TreeNode // Left child reference\n    Right  *TreeNode // Right child reference\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var height: Int // Node height\n    var left: TreeNode? // Left child\n    var right: TreeNode? // Right child\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    val; // Node value\n    height; // Node height\n    left; // Left child pointer\n    right; // Right child pointer\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    val: number;            // Node value\n    height: number;         // Node height\n    left: TreeNode | null;  // Left child pointer\n    right: TreeNode | null; // Right child pointer\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height; \n        this.left = left === undefined ? null : left; \n        this.right = right === undefined ? null : right; \n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n  int val;         // Node value\n  int height;      // Node height\n  TreeNode? left;  // Left child\n  TreeNode? right; // Right child\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    height: i32,                            // Node height\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Left child\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Right child\n}\n\nimpl TreeNode {\n    /* Constructor */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* Constructor */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val height: Int = 0          // Node height\n    val left: TreeNode? = null   // Left child\n    val right: TreeNode? = null  // Right child\n}\n</code></pre> <pre><code>### AVL tree node class ###\nclass TreeNode\n  attr_accessor :val    # Node value\n  attr_accessor :height # Node height\n  attr_accessor :left   # Left child reference\n  attr_accessor :right  # Right child reference\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>The \"node height\" refers to the distance from that node to its farthest leaf node, i.e., the number of \"edges\" passed. It is important to note that the height of a leaf node is \\(0\\), and the height of a null node is \\(-1\\). We will create two utility functions for getting and updating the height of a node:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Get node height\"\"\"\n    # Empty node height is -1, leaf node height is 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"Update node height\"\"\"\n    # Node height equals the height of the tallest subtree + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* Get node height */\nint height(TreeNode *node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode *node) {\n    // Node height equals the height of the tallest subtree + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* Get node height */\nint height(TreeNode node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* Get node height */\nint Height(TreeNode? node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid UpdateHeight(TreeNode node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* Get node height */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // Empty node height is -1, leaf node height is 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* Update node height */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // Node height equals the height of the tallest subtree + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* Get node height */\nfunc height(node: TreeNode?) -&gt; Int {\n    // Empty node height is -1, leaf node height is 0\n    node?.height ?? -1\n}\n\n/* Update node height */\nfunc updateHeight(node: TreeNode?) {\n    // Node height equals the height of the tallest subtree + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* Get node height */\nheight(node) {\n    // Empty node height is -1, leaf node height is 0\n    return node === null ? -1 : node.height;\n}\n\n/* Update node height */\n#updateHeight(node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* Get node height */\nheight(node: TreeNode): number {\n    // Empty node height is -1, leaf node height is 0\n    return node === null ? -1 : node.height;\n}\n\n/* Update node height */\nupdateHeight(node: TreeNode): void {\n    // Node height equals the height of the tallest subtree + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* Get node height */\nint height(TreeNode? node) {\n  // Empty node height is -1, leaf node height is 0\n  return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode? node) {\n  // Node height equals the height of the tallest subtree + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* Get node height */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // Empty node height is -1, leaf node height is 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* Update node height */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // Node height equals the height of the tallest subtree + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Get node height */\nint height(TreeNode *node) {\n    // Empty node height is -1, leaf node height is 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // Node height equals the height of the tallest subtree + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* Get node height */\nfun height(node: TreeNode?): Int {\n    // Empty node height is -1, leaf node height is 0\n    return node?.height ?: -1\n}\n\n/* Update node height */\nfun updateHeight(node: TreeNode?) {\n    // Node height equals the height of the tallest subtree + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### Get node height ###\ndef height(node)\n  # Empty node height is -1, leaf node height is 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### Update node height ###\ndef update_height(node)\n  # Node height equals the height of the tallest subtree + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-node-balance-factor","level":3,"title":"2.   Node Balance Factor","text":"<p>The balance factor of a node is defined as the height of the node's left subtree minus the height of its right subtree, and the balance factor of a null node is defined as \\(0\\). We also encapsulate the function to obtain the node's balance factor for convenient subsequent use:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Get balance factor\"\"\"\n    # Empty node balance factor is 0\n    if node is None:\n        return 0\n    # Node balance factor = left subtree height - right subtree height\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode *node) {\n    // Empty node balance factor is 0\n    if (node == nullptr)\n        return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode node) {\n    // Empty node balance factor is 0\n    if (node == null)\n        return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* Get balance factor */\nint BalanceFactor(TreeNode? node) {\n    // Empty node balance factor is 0\n    if (node == null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* Get balance factor */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // Empty node balance factor is 0\n    if node == nil {\n        return 0\n    }\n    // Node balance factor = left subtree height - right subtree height\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* Get balance factor */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // Empty node balance factor is 0\n    guard let node = node else { return 0 }\n    // Node balance factor = left subtree height - right subtree height\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* Get balance factor */\nbalanceFactor(node) {\n    // Empty node balance factor is 0\n    if (node === null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* Get balance factor */\nbalanceFactor(node: TreeNode): number {\n    // Empty node balance factor is 0\n    if (node === null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode? node) {\n  // Empty node balance factor is 0\n  if (node == null) return 0;\n  // Node balance factor = left subtree height - right subtree height\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* Get balance factor */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // Empty node balance factor is 0\n        None =&gt; 0,\n        // Node balance factor = left subtree height - right subtree height\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode *node) {\n    // Empty node balance factor is 0\n    if (node == NULL) {\n        return 0;\n    }\n    // Node balance factor = left subtree height - right subtree height\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* Get balance factor */\nfun balanceFactor(node: TreeNode?): Int {\n    // Empty node balance factor is 0\n    if (node == null) return 0\n    // Node balance factor = left subtree height - right subtree height\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### Get balance factor ###\ndef balance_factor(node)\n  # Empty node balance factor is 0\n  return 0 if node.nil?\n\n  # Node balance factor = left subtree height - right subtree height\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>Let the balance factor be \\(f\\), then the balance factor of any node in an AVL tree satisfies \\(-1 \\le f \\le 1\\).</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-rotations-in-avl-trees","level":2,"title":"7.5.2   Rotations in Avl Trees","text":"<p>The characteristic of AVL trees lies in the \"rotation\" operation, which can restore balance to unbalanced nodes without affecting the inorder traversal sequence of the binary tree. In other words, rotation operations can both maintain the property of a \"binary search tree\" and make the tree return to a \"balanced binary tree\".</p> <p>We call nodes with a balance factor absolute value \\(&gt; 1\\) \"unbalanced nodes\". Depending on the imbalance situation, rotation operations are divided into four types: right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. Below we describe these rotation operations in detail.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-right-rotation","level":3,"title":"1.   Right Rotation","text":"<p>As shown in Figure 7-26, the value below the node is the balance factor. From bottom to top, the first unbalanced node in the binary tree is \"node 3\". We focus on the subtree with this unbalanced node as the root, denoting the node as <code>node</code> and its left child as <code>child</code>, and perform a \"right rotation\" operation. After the right rotation is completed, the subtree regains balance and still maintains the properties of a binary search tree.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-26   Steps of right rotation </p> <p>As shown in Figure 7-27, when the <code>child</code> node has a right child (denoted as <code>grand_child</code>), a step needs to be added in the right rotation: set <code>grand_child</code> as the left child of <code>node</code>.</p> <p></p> <p> Figure 7-27   Right rotation with grand_child </p> <p>\"Right rotation\" is a figurative term; in practice, it is achieved by modifying node pointers, as shown in the following code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Right rotation operation\"\"\"\n    child = node.left\n    grand_child = child.right\n    # Using child as pivot, rotate node to the right\n    child.right = node\n    node.left = grand_child\n    # Update node height\n    self.update_height(node)\n    self.update_height(child)\n    # Return root node of subtree after rotation\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Right rotation operation */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // Using child as pivot, rotate node to the right\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Right rotation operation */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Right rotation operation */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Right rotation operation */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // Using child as pivot, rotate node to the right\n    child.Right = node\n    node.Left = grandChild\n    // Update node height\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Right rotation operation */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // Using child as pivot, rotate node to the right\n    child?.right = node\n    node?.left = grandChild\n    // Update node height\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Right rotation operation */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Right rotation operation */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Right rotation operation */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // Using child as pivot, rotate node to the right\n  child.right = node;\n  node.left = grandChild;\n  // Update node height\n  updateHeight(node);\n  updateHeight(child);\n  // Return root node of subtree after rotation\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Right rotation operation */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // Using child as pivot, rotate node to the right\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // Update node height\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Return root node of subtree after rotation\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Right rotation operation */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // Using child as pivot, rotate node to the right\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Right rotation operation */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // Using child as pivot, rotate node to the right\n    child.right = node\n    node.left = grandChild\n    // Update node height\n    updateHeight(node)\n    updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Right rotation ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # Using child as pivot, rotate node to the right\n  child.right = node\n  node.left = grand_child\n  # Update node height\n  update_height(node)\n  update_height(child)\n  # Return root node of subtree after rotation\n  child\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-left-rotation","level":3,"title":"2.   Left Rotation","text":"<p>Correspondingly, if considering the \"mirror\" of the above unbalanced binary tree, the \"left rotation\" operation shown in Figure 7-28 needs to be performed.</p> <p></p> <p> Figure 7-28   Left rotation operation </p> <p>Similarly, as shown in Figure 7-29, when the <code>child</code> node has a left child (denoted as <code>grand_child</code>), a step needs to be added in the left rotation: set <code>grand_child</code> as the right child of <code>node</code>.</p> <p></p> <p> Figure 7-29   Left rotation with grand_child </p> <p>It can be observed that right rotation and left rotation operations are mirror symmetric in logic, and the two imbalance cases they solve are also symmetric. Based on symmetry, we only need to replace all <code>left</code> in the right rotation implementation code with <code>right</code>, and all <code>right</code> with <code>left</code>, to obtain the left rotation implementation code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Left rotation operation\"\"\"\n    child = node.right\n    grand_child = child.left\n    # Using child as pivot, rotate node to the left\n    child.left = node\n    node.right = grand_child\n    # Update node height\n    self.update_height(node)\n    self.update_height(child)\n    # Return root node of subtree after rotation\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Left rotation operation */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // Using child as pivot, rotate node to the left\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Left rotation operation */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Left rotation operation */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Left rotation operation */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // Using child as pivot, rotate node to the left\n    child.Left = node\n    node.Right = grandChild\n    // Update node height\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Left rotation operation */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // Using child as pivot, rotate node to the left\n    child?.left = node\n    node?.right = grandChild\n    // Update node height\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Left rotation operation */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Left rotation operation */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Left rotation operation */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // Using child as pivot, rotate node to the left\n  child.left = node;\n  node.right = grandChild;\n  // Update node height\n  updateHeight(node);\n  updateHeight(child);\n  // Return root node of subtree after rotation\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Left rotation operation */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // Using child as pivot, rotate node to the left\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // Update node height\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Return root node of subtree after rotation\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Left rotation operation */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // Using child as pivot, rotate node to the left\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Left rotation operation */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // Using child as pivot, rotate node to the left\n    child.left = node\n    node.right = grandChild\n    // Update node height\n    updateHeight(node)\n    updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Left rotation ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # Using child as pivot, rotate node to the left\n  child.left = node\n  node.right = grand_child\n  # Update node height\n  update_height(node)\n  update_height(child)\n  # Return root node of subtree after rotation\n  child\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3-left-rotation-then-right-rotation","level":3,"title":"3.   Left Rotation Then Right Rotation","text":"<p>For the unbalanced node 3 in Figure 7-30, using either left rotation or right rotation alone cannot restore the subtree to balance. In this case, a \"left rotation\" needs to be performed on <code>child</code> first, followed by a \"right rotation\" on <code>node</code>.</p> <p></p> <p> Figure 7-30   Left-right rotation </p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4-right-rotation-then-left-rotation","level":3,"title":"4.   Right Rotation Then Left Rotation","text":"<p>As shown in Figure 7-31, for the mirror case of the above unbalanced binary tree, a \"right rotation\" needs to be performed on <code>child</code> first, then a \"left rotation\" on <code>node</code>.</p> <p></p> <p> Figure 7-31   Right-left rotation </p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5-choice-of-rotation","level":3,"title":"5.   Choice of Rotation","text":"<p>The four imbalances shown in Figure 7-32 correspond one-to-one with the above cases, requiring right rotation, left rotation then right rotation, right rotation then left rotation, and left rotation operations respectively.</p> <p></p> <p> Figure 7-32   The four rotation cases of AVL tree </p> <p>As shown in Table 7-3, we determine which case the unbalanced node belongs to by judging the signs of the balance factor of the unbalanced node and the balance factor of its taller-side child node.</p> <p> Table 7-3   Conditions for Choosing Among the Four Rotation Cases </p> Balance factor of the unbalanced node Balance factor of the child node Rotation method to apply \\(&gt; 1\\) (left-leaning tree) \\(\\geq 0\\) Right rotation \\(&gt; 1\\) (left-leaning tree) \\(&lt;0\\) Left rotation then right rotation \\(&lt; -1\\) (right-leaning tree) \\(\\leq 0\\) Left rotation \\(&lt; -1\\) (right-leaning tree) \\(&gt;0\\) Right rotation then left rotation <p>For ease of use, we encapsulate the rotation operations into a function. With this function, we can perform rotations for various imbalance situations, restoring balance to unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Perform rotation operation to restore balance to this subtree\"\"\"\n    # Get balance factor of node\n    balance_factor = self.balance_factor(node)\n    # Left-leaning tree\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # Right rotation\n            return self.right_rotate(node)\n        else:\n            # First left rotation then right rotation\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # Right-leaning tree\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # Left rotation\n            return self.left_rotate(node)\n        else:\n            # First right rotation then left rotation\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # Balanced tree, no rotation needed, return directly\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode *rotate(TreeNode *node) {\n    // Get balance factor of node\n    int _balanceFactor = balanceFactor(node);\n    // Left-leaning tree\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode rotate(TreeNode node) {\n    // Get balance factor of node\n    int balanceFactor = balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode? Rotate(TreeNode? node) {\n    // Get balance factor of node\n    int balanceFactorInt = BalanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // Right rotation\n            return RightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // Left rotation\n            return LeftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // Get balance factor of node\n    // Go recommends short variables, here bf refers to t.balanceFactor\n    bf := t.balanceFactor(node)\n    // Left-leaning tree\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // Right rotation\n            return t.rightRotate(node)\n        } else {\n            // First left rotation then right rotation\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // Right-leaning tree\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // Left rotation\n            return t.leftRotate(node)\n        } else {\n            // First right rotation then left rotation\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // Get balance factor of node\n    let balanceFactor = balanceFactor(node: node)\n    // Left-leaning tree\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // Right rotation\n            return rightRotate(node: node)\n        } else {\n            // First left rotation then right rotation\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // Right-leaning tree\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // Left rotation\n            return leftRotate(node: node)\n        } else {\n            // First right rotation then left rotation\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Perform rotation operation to restore balance to this subtree */\n#rotate(node) {\n    // Get balance factor of node\n    const balanceFactor = this.balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return this.#rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return this.#leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Perform rotation operation to restore balance to this subtree */\nrotate(node: TreeNode): TreeNode {\n    // Get balance factor of node\n    const balanceFactor = this.balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return this.rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return this.leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode? rotate(TreeNode? node) {\n  // Get balance factor of node\n  int factor = balanceFactor(node);\n  // Left-leaning tree\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // Right rotation\n      return rightRotate(node);\n    } else {\n      // First left rotation then right rotation\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // Right-leaning tree\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // Left rotation\n      return leftRotate(node);\n    } else {\n      // First right rotation then left rotation\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // Balanced tree, no rotation needed, return directly\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // Get balance factor of node\n    let balance_factor = Self::balance_factor(node.clone());\n    // Left-leaning tree\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // Right rotation\n            Self::right_rotate(Some(node))\n        } else {\n            // First left rotation then right rotation\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // Right-leaning tree\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // Left rotation\n            Self::left_rotate(Some(node))\n        } else {\n            // First right rotation then left rotation\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // Balanced tree, no rotation needed, return directly\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode *rotate(TreeNode *node) {\n    // Get balance factor of node\n    int bf = balanceFactor(node);\n    // Left-leaning tree\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfun rotate(node: TreeNode): TreeNode {\n    // Get balance factor of node\n    val balanceFactor = balanceFactor(node)\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node)\n        } else {\n            // First left rotation then right rotation\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node)\n        } else {\n            // First right rotation then left rotation\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Perform rotation to rebalance subtree ###\ndef rotate(node)\n  # Get balance factor of node\n  balance_factor = balance_factor(node)\n  # Left-heavy tree\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # Right rotation\n      return right_rotate(node)\n    else\n      # First left rotation then right rotation\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # Right-heavy tree\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # Left rotation\n      return left_rotate(node)\n    else\n      # First right rotation then left rotation\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # Balanced tree, no rotation needed, return directly\n  node\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-common-operations-in-avl-trees","level":2,"title":"7.5.3   Common Operations in Avl Trees","text":"","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-node-insertion","level":3,"title":"1.   Node Insertion","text":"<p>The node insertion operation in AVL trees is similar in principle to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear on the path from that node to the root. Therefore, we need to start from this node and perform rotation operations from bottom to top, restoring balance to all unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"Insert node\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"Recursively insert node (helper method)\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. Find insertion position and insert node\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # Duplicate node not inserted, return directly\n        return node\n    # Update node height\n    self.update_height(node)\n    # 2. Perform rotation operation to restore balance to this subtree\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Insert node */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // Duplicate node not inserted, return directly\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Insert node */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // Duplicate node not inserted, return directly\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Insert node */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // Duplicate node not inserted, return directly\n    UpdateHeight(node);  // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = Rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Insert node */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* Recursively insert node (helper function) */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. Find insertion position and insert node */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // Duplicate node not inserted, return directly\n        return node\n    }\n    // Update node height\n    t.updateHeight(node)\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = t.rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Insert node */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* Recursively insert node (helper method) */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. Find insertion position and insert node */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // Duplicate node not inserted, return directly\n    }\n    updateHeight(node: node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node: node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Insert node */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* Recursively insert node (helper method) */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // Duplicate node not inserted, return directly\n    this.#updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.#rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Insert node */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* Recursively insert node (helper method) */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // Duplicate node not inserted, return directly\n    }\n    this.updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Insert node */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. Find insertion position and insert node */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // Duplicate node not inserted, return directly\n  updateHeight(node); // Update node height\n  /* 2. Perform rotation operation to restore balance to this subtree */\n  node = rotate(node);\n  // Return root node of subtree\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Insert node */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* Recursively insert node (helper method) */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Find insertion position and insert node */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // Duplicate node not inserted, return directly\n                }\n            }\n            Self::update_height(Some(node.clone())); // Update node height\n\n            /* 2. Perform rotation operation to restore balance to this subtree */\n            node = Self::rotate(Some(node)).unwrap();\n            // Return root node of subtree\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Insert node */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* Recursively insert node (helper function) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // Duplicate node not inserted, return directly\n        return node;\n    }\n    // Update node height\n    updateHeight(node);\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Insert node */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* Recursively insert node (helper method) */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. Find insertion position and insert node */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // Duplicate node not inserted, return directly\n    updateHeight(node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Insert node ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### Recursively insert node (helper method) ###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. Find insertion position and insert node\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # Duplicate node not inserted, return directly\n    return node\n  end\n  # Update node height\n  update_height(node)\n  # 2. Perform rotation operation to restore balance to this subtree\n  rotate(node)\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-node-removal","level":3,"title":"2.   Node Removal","text":"<p>Similarly, on the basis of the binary search tree's node removal method, rotation operations need to be performed from bottom to top to restore balance to all unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"Delete node\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"Recursively delete node (helper method)\"\"\"\n    if node is None:\n        return None\n    # 1. Find node and delete\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # Number of child nodes = 0, delete node directly and return\n            if child is None:\n                return None\n            # Number of child nodes = 1, delete node directly\n            else:\n                node = child\n        else:\n            # Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # Update node height\n    self.update_height(node)\n    # 2. Perform rotation operation to restore balance to this subtree\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Remove node */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. Find node and delete */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // Number of child nodes = 1, delete node directly\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Remove node */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null;\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Remove node */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null;\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = Rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Remove node */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* Recursively remove node (helper function) */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. Find node and delete */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // Number of child nodes = 0, delete node directly and return\n                return nil\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // Update node height\n    t.updateHeight(node)\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = t.rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Remove node */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* Recursively delete node (helper method) */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. Find node and delete */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // Number of child nodes = 0, delete node directly and return\n            if child == nil {\n                return nil\n            }\n            // Number of child nodes = 1, delete node directly\n            else {\n                node = child\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node: node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Remove node */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* Recursively delete node (helper method) */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child === null) return null;\n            // Number of child nodes = 1, delete node directly\n            else node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.#rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Remove node */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* Recursively delete node (helper method) */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child === null) {\n                return null;\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Remove node */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. Find node and delete */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // Number of child nodes = 0, delete node directly and return\n      if (child == null)\n        return null;\n      // Number of child nodes = 1, delete node directly\n      else\n        node = child;\n    } else {\n      // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // Update node height\n  /* 2. Perform rotation operation to restore balance to this subtree */\n  node = rotate(node);\n  // Return root node of subtree\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Remove node */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* Recursively delete node (helper method) */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Find node and delete */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // Number of child nodes = 0, delete node directly and return\n                    None =&gt; {\n                        return None;\n                    }\n                    // Number of child nodes = 1, delete node directly\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // Update node height\n\n            /* 2. Perform rotation operation to restore balance to this subtree */\n            node = Self::rotate(Some(node)).unwrap();\n            // Return root node of subtree\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Remove node */\n// Cannot use remove keyword here due to stdio.h inclusion\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* Recursively remove node (helper function) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. Find node and delete */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // Number of child nodes = 0, delete node directly and return\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // Update node height\n    updateHeight(node);\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Remove node */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* Recursively delete node (helper method) */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. Find node and delete */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Delete node ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### Recursively delete node (helper method) ###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. Find node and delete\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # Number of child nodes = 0, delete node directly and return\n      return if child.nil?\n      # Number of child nodes = 1, delete node directly\n      node = child\n    else\n      # Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # Update node height\n  update_height(node)\n  # 2. Perform rotation operation to restore balance to this subtree\n  rotate(node)\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3-node-search","level":3,"title":"3.   Node Search","text":"<p>The node search operation in AVL trees is consistent with that in binary search trees, and will not be elaborated here.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-typical-applications-of-avl-trees","level":2,"title":"7.5.4   Typical Applications of Avl Trees","text":"<ul> <li>Organizing and storing large-scale data, suitable for scenarios with high-frequency searches and low-frequency insertions and deletions.</li> <li>Used to build index systems in databases.</li> <li>Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balance conditions, require fewer rotation operations for node insertion and deletion, and have higher average efficiency for node addition and deletion operations.</li> </ul>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   Binary Search Tree","text":"<p>As shown in Figure 7-16, a binary search tree satisfies the following conditions.</p> <ol> <li>For the root node, the value of all nodes in the left subtree \\(&lt;\\) the value of the root node \\(&lt;\\) the value of all nodes in the right subtree.</li> <li>The left and right subtrees of any node are also binary search trees, i.e., they satisfy condition <code>1.</code> as well.</li> </ol> <p></p> <p> Figure 7-16   Binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741-operations-on-a-binary-search-tree","level":2,"title":"7.4.1   Operations on a Binary Search Tree","text":"<p>We encapsulate the binary search tree as a class <code>BinarySearchTree</code> and declare a member variable <code>root</code> pointing to the tree's root node.</p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1-searching-for-a-node","level":3,"title":"1.   Searching for a Node","text":"<p>Given a target node value <code>num</code>, we can search according to the properties of the binary search tree. As shown in Figure 7-17, we declare a node <code>cur</code> and start from the binary tree's root node <code>root</code>, looping to compare the node value <code>cur.val</code> with <code>num</code>.</p> <ul> <li>If <code>cur.val &lt; num</code>, it means the target node is in <code>cur</code>'s right subtree, thus execute <code>cur = cur.right</code>.</li> <li>If <code>cur.val &gt; num</code>, it means the target node is in <code>cur</code>'s left subtree, thus execute <code>cur = cur.left</code>.</li> <li>If <code>cur.val = num</code>, it means the target node is found, exit the loop, and return the node.</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-17   Example of searching for a node in a binary search tree </p> <p>The search operation in a binary search tree works on the same principle as the binary search algorithm, both eliminating half of the cases in each round. The number of loop iterations is at most the height of the binary tree. When the binary tree is balanced, it uses \\(O(\\log n)\\) time. The example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"Search node\"\"\"\n    cur = self._root\n    # Loop search, exit after passing leaf node\n    while cur is not None:\n        # Target node is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Target node is in cur's left subtree\n        elif cur.val &gt; num:\n            cur = cur.left\n        # Found target node, exit loop\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* Search node */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Target node is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Target node is in cur's left subtree\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Search node */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Search node */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* Search node */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // Loop search, exit after passing leaf node\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // Target node is in cur's right subtree\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // Target node is in cur's left subtree\n            node = node.Left\n        } else {\n            // Found target node, exit loop\n            break\n        }\n    }\n    // Return target node\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Search node */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Target node is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Target node is in cur's left subtree\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // Found target node, exit loop\n        else {\n            break\n        }\n    }\n    // Return target node\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* Search node */\nsearch(num) {\n    let cur = this.root;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num) cur = cur.left;\n        // Found target node, exit loop\n        else break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Search node */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num) cur = cur.left;\n        // Found target node, exit loop\n        else break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Search node */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Target node is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Target node is in cur's left subtree\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // Found target node, exit loop\n    else\n      break;\n  }\n  // Return target node\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Search node */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Target node is in cur's right subtree\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // Target node is in cur's left subtree\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // Found target node, exit loop\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // Return target node\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* Search node */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // Target node is in cur's right subtree\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // Target node is in cur's left subtree\n            cur = cur-&gt;left;\n        } else {\n            // Found target node, exit loop\n            break;\n        }\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Search node */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Target node is in cur's left subtree\n        else if (cur._val &gt; num)\n            cur.left\n        // Found target node, exit loop\n        else\n            break\n    }\n    // Return target node\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### Search node ###\ndef search(num)\n  cur = @root\n\n  # Loop search, exit after passing leaf node\n  while !cur.nil?\n    # Target node is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Target node is in cur's left subtree\n    elsif cur.val &gt; num\n      cur = cur.left\n    # Found target node, exit loop\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2-inserting-a-node","level":3,"title":"2.   Inserting a Node","text":"<p>Given an element <code>num</code> to be inserted, in order to maintain the property of the binary search tree \"left subtree &lt; root node &lt; right subtree,\" the insertion process is as shown in Figure 7-18.</p> <ol> <li>Finding the insertion position: Similar to the search operation, start from the root node and loop downward searching according to the size relationship between the current node value and <code>num</code>, until passing the leaf node (traversing to <code>None</code>) and then exit the loop.</li> <li>Insert the node at that position: Initialize node <code>num</code> and place it at the <code>None</code> position.</li> </ol> <p></p> <p> Figure 7-18   Inserting a node into a binary search tree </p> <p>In the code implementation, note the following two points:</p> <ul> <li>Binary search trees do not allow duplicate nodes; otherwise, it would violate its definition. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed and it returns directly.</li> <li>To implement the node insertion, we need to use node <code>pre</code> to save the node from the previous loop iteration. This way, when traversing to <code>None</code>, we can obtain its parent node, thereby completing the node insertion operation.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"Insert node\"\"\"\n    # If tree is empty, initialize root node\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # Loop search, exit after passing leaf node\n    cur, pre = self._root, None\n    while cur is not None:\n        # Found duplicate node, return directly\n        if cur.val == num:\n            return\n        pre = cur\n        # Insertion position is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Insertion position is in cur's left subtree\n        else:\n            cur = cur.left\n    # Insert node\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* Insert node */\nvoid insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Found duplicate node, return directly\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur-&gt;left;\n    }\n    // Insert node\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Insert node */\nvoid insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // Insert node\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Insert node */\nvoid Insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n\n    // Insert node\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Insert node */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // If tree is empty, initialize root node\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // Node position before the node to be inserted\n    var pre *TreeNode = nil\n    // Loop search, exit after passing leaf node\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // Insert node\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Insert node */\nfunc insert(num: Int) {\n    // If tree is empty, initialize root node\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Found duplicate node, return directly\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // Insertion position is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Insertion position is in cur's left subtree\n        else {\n            cur = cur?.left\n        }\n    }\n    // Insert node\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Insert node */\ninsert(num) {\n    // If tree is empty, initialize root node\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found duplicate node, return directly\n        if (cur.val === num) return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else cur = cur.left;\n    }\n    // Insert node\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Insert node */\ninsert(num: number): void {\n    // If tree is empty, initialize root node\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found duplicate node, return directly\n        if (cur.val === num) return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else cur = cur.left;\n    }\n    // Insert node\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Insert node */\nvoid insert(int _num) {\n  // If tree is empty, initialize root node\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Found duplicate node, return directly\n    if (cur.val == _num) return;\n    pre = cur;\n    // Insertion position is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Insertion position is in cur's left subtree\n    else\n      cur = cur.left;\n  }\n  // Insert node\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Insert node */\npub fn insert(&amp;mut self, num: i32) {\n    // If tree is empty, initialize root node\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Found duplicate node, return directly\n            Ordering::Equal =&gt; return,\n            // Insertion position is in cur's right subtree\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Insertion position is in cur's left subtree\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Insert node\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Insert node */\nvoid insert(BinarySearchTree *bst, int num) {\n    // If tree is empty, initialize root node\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        // Found duplicate node, return directly\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Insertion position is in cur's right subtree\n            cur = cur-&gt;right;\n        } else {\n            // Insertion position is in cur's left subtree\n            cur = cur-&gt;left;\n        }\n    }\n    // Insert node\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Insert node */\nfun insert(num: Int) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur._val == num)\n            return\n        pre = cur\n        // Insertion position is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Insertion position is in cur's left subtree\n        else\n            cur.left\n    }\n    // Insert node\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### Insert node ###\ndef insert(num)\n  # If tree is empty, initialize root node\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # Loop search, exit after passing leaf node\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Found duplicate node, return directly\n    return if cur.val == num\n\n    pre = cur\n    # Insertion position is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Insertion position is in cur's left subtree\n    else\n      cur = cur.left\n    end\n  end\n\n  # Insert node\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> <p>Similar to searching for a node, inserting a node uses \\(O(\\log n)\\) time.</p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3-removing-a-node","level":3,"title":"3.   Removing a Node","text":"<p>First, find the target node in the binary tree, then remove it. Similar to node insertion, we need to ensure that after the removal operation is completed, the binary search tree's property of \"left subtree \\(&lt;\\) root node \\(&lt;\\) right subtree\" is still maintained. Therefore, depending on the number of child nodes the target node has, we divide it into 0, 1, and 2 three cases, and execute the corresponding node removal operations.</p> <p>As shown in Figure 7-19, when the degree of the node to be removed is \\(0\\), it means the node is a leaf node and can be directly removed.</p> <p></p> <p> Figure 7-19   Removing a node in a binary search tree (degree 0) </p> <p>As shown in Figure 7-20, when the degree of the node to be removed is \\(1\\), replacing the node to be removed with its child node is sufficient.</p> <p></p> <p> Figure 7-20   Removing a node in a binary search tree (degree 1) </p> <p>When the degree of the node to be removed is \\(2\\), we cannot directly remove it; instead, we need to use a node to replace it. To maintain the binary search tree's property of \"left subtree \\(&lt;\\) root node \\(&lt;\\) right subtree,\" this node can be either the smallest node in the right subtree or the largest node in the left subtree.</p> <p>Assuming we choose the smallest node in the right subtree (the next node in the inorder traversal), the removal process is as shown in Figure 7-21.</p> <ol> <li>Find the next node of the node to be removed in the \"inorder traversal sequence,\" denoted as <code>tmp</code>.</li> <li>Replace the value of the node to be removed with the value of <code>tmp</code>, and recursively remove node <code>tmp</code> in the tree.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-21   Removing a node in a binary search tree (degree 2) </p> <p>The node removal operation also uses \\(O(\\log n)\\) time, where finding the node to be removed requires \\(O(\\log n)\\) time, and obtaining the inorder successor node requires \\(O(\\log n)\\) time. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"Delete node\"\"\"\n    # If tree is empty, return directly\n    if self._root is None:\n        return\n    # Loop search, exit after passing leaf node\n    cur, pre = self._root, None\n    while cur is not None:\n        # Found node to delete, exit loop\n        if cur.val == num:\n            break\n        pre = cur\n        # Node to delete is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Node to delete is in cur's left subtree\n        else:\n            cur = cur.left\n    # If no node to delete, return directly\n    if cur is None:\n        return\n\n    # Number of child nodes = 0 or 1\n    if cur.left is None or cur.right is None:\n        # When number of child nodes = 0 / 1, child = null / that child node\n        child = cur.left or cur.right\n        # Delete node cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # If deleted node is root node, reassign root node\n            self._root = child\n    # Number of child nodes = 2\n    else:\n        # Get next node of cur in inorder traversal\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # Recursively delete node tmp\n        self.remove(tmp.val)\n        # Replace cur with tmp\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* Remove node */\nvoid remove(int num) {\n    // If tree is empty, return directly\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Found node to delete, exit loop\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur-&gt;left;\n    }\n    // If no node to delete, return directly\n    if (cur == nullptr)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // When number of child nodes = 0 / 1, child = nullptr / that child node\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n        // Free memory\n        delete cur;\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Recursively delete node tmp\n        remove(tmp-&gt;val);\n        // Replace cur with tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* Remove node */\nvoid remove(int num) {\n    // If tree is empty, return directly\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        remove(tmp.val);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Remove node */\nvoid Remove(int num) {\n    // If tree is empty, return directly\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        TreeNode? child = cur.left ?? cur.right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        Remove(tmp.val!.Value);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Remove node */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // If tree is empty, return directly\n    if cur == nil {\n        return\n    }\n    // Node position before the node to be removed\n    var pre *TreeNode = nil\n    // Loop search, exit after passing leaf node\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // Node to be removed is in right subtree\n            cur = cur.Right\n        } else {\n            // Node to be removed is in left subtree\n            cur = cur.Left\n        }\n    }\n    // If no node to delete, return directly\n    if cur == nil {\n        return\n    }\n    // Number of child nodes is 0 or 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // Get child node of node to be removed\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // Delete node cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // If deleted node is root node, reassign root node\n            bst.root = child\n        }\n        // Number of child nodes is 2\n    } else {\n        // Get next node of node cur to be removed in in-order traversal\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // Recursively delete node tmp\n        bst.remove(tmp.Val.(int))\n        // Replace cur with tmp\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Remove node */\nfunc remove(num: Int) {\n    // If tree is empty, return directly\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Found node to delete, exit loop\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // Node to delete is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Node to delete is in cur's left subtree\n        else {\n            cur = cur?.left\n        }\n    }\n    // If no node to delete, return directly\n    if cur == nil {\n        return\n    }\n    // Number of child nodes = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        let child = cur?.left ?? cur?.right\n        // Delete node cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // Recursively delete node tmp\n        remove(num: tmp!.val)\n        // Replace cur with tmp\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Remove node */\nremove(num) {\n    // If tree is empty, return directly\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found node to delete, exit loop\n        if (cur.val === num) break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur === null) return;\n    // Number of child nodes = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        const child = cur.left !== null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            this.root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        this.remove(tmp.val);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Remove node */\nremove(num: number): void {\n    // If tree is empty, return directly\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found node to delete, exit loop\n        if (cur.val === num) break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur === null) return;\n    // Number of child nodes = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            this.root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // Recursively delete node tmp\n        this.remove(tmp!.val);\n        // Replace cur with tmp\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Remove node */\nvoid remove(int _num) {\n  // If tree is empty, return directly\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Found node to delete, exit loop\n    if (cur.val == _num) break;\n    pre = cur;\n    // Node to delete is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Node to delete is in cur's left subtree\n    else\n      cur = cur.left;\n  }\n  // If no node to delete, return directly\n  if (cur == null) return;\n  // Number of child nodes = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // When number of child nodes = 0 / 1, child = null / that child node\n    TreeNode? child = cur.left ?? cur.right;\n    // Delete node cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // If deleted node is root node, reassign root node\n      _root = child;\n    }\n  } else {\n    // Number of child nodes = 2\n    // Get next node of cur in inorder traversal\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // Recursively delete node tmp\n    remove(tmp.val);\n    // Replace cur with tmp\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Remove node */\npub fn remove(&amp;mut self, num: i32) {\n    // If tree is empty, return directly\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Found node to delete, exit loop\n            Ordering::Equal =&gt; break,\n            // Node to delete is in cur's right subtree\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Node to delete is in cur's left subtree\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // If no node to delete, return directly\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // Number of child nodes = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // When number of child nodes = 0 / 1, child = nullptr / that child node\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // Delete node cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // If deleted node is root node, reassign root node\n                self.root = child;\n            }\n        }\n        // Number of child nodes = 2\n        (Some(_), Some(_)) =&gt; {\n            // Get next node of cur in inorder traversal\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // Recursively delete node tmp\n            self.remove(tmp_val);\n            // Replace cur with tmp\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Remove node */\n// Cannot use remove keyword here due to stdio.h inclusion\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // If tree is empty, return directly\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        // Found node to delete, exit loop\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Node to delete is in right subtree of root\n            cur = cur-&gt;right;\n        } else {\n            // Node to delete is in left subtree of root\n            cur = cur-&gt;left;\n        }\n    }\n    // If no node to delete, return directly\n    if (cur == NULL)\n        return;\n    // Check if node to delete has children\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* Number of child nodes = 0 or 1 */\n        // When number of child nodes = 0 / 1, child = nullptr / that child node\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // Delete node cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // Free memory\n        free(cur);\n    } else {\n        /* Number of child nodes = 2 */\n        // Get next node of cur in inorder traversal\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Recursively delete node tmp\n        removeItem(bst, tmp-&gt;val);\n        // Replace cur with tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Remove node */\nfun remove(num: Int) {\n    // If tree is empty, return directly\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur._val == num)\n            break\n        pre = cur\n        // Node to delete is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Node to delete is in cur's left subtree\n        else\n            cur.left\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // Delete node cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child\n        }\n        // Number of child nodes = 2\n    } else {\n        // Get next node of cur in inorder traversal\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // Recursively delete node tmp\n        remove(tmp._val)\n        // Replace cur with tmp\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### Delete node ###\ndef remove(num)\n  # If tree is empty, return directly\n  return if @root.nil?\n\n  # Loop search, exit after passing leaf node\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Found node to delete, exit loop\n    break if cur.val == num\n\n    pre = cur\n    # Node to delete is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Node to delete is in cur's left subtree\n    else\n      cur = cur.left\n    end\n  end\n  # If no node to delete, return directly\n  return if cur.nil?\n\n  # Number of child nodes = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # When number of child nodes = 0 / 1, child = null / that child node\n    child = cur.left || cur.right\n    # Delete node cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # If deleted node is root node, reassign root node\n      @root = child\n    end\n  # Number of child nodes = 2\n  else\n    # Get next node of cur in inorder traversal\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # Recursively delete node tmp\n    remove(tmp.val)\n    # Replace cur with tmp\n    cur.val = tmp.val\n  end\nend\n</code></pre>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4-inorder-traversal-is-ordered","level":3,"title":"4.   Inorder Traversal Is Ordered","text":"<p>As shown in Figure 7-22, the inorder traversal of a binary tree follows the \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\" traversal order, while the binary search tree satisfies the \"left child node \\(&lt;\\) root node \\(&lt;\\) right child node\" size relationship.</p> <p>This means that when performing an inorder traversal in a binary search tree, the next smallest node is always traversed first, thus yielding an important property: The inorder traversal sequence of a binary search tree is ascending.</p> <p>Using the property of inorder traversal being ascending, we can obtain ordered data in a binary search tree in only \\(O(n)\\) time, without the need for additional sorting operations, which is very efficient.</p> <p></p> <p> Figure 7-22   Inorder traversal sequence of a binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742-efficiency-of-binary-search-trees","level":2,"title":"7.4.2   Efficiency of Binary Search Trees","text":"<p>Given a set of data, we consider using an array or a binary search tree for storage. Observing Table 7-2, all operations in a binary search tree have logarithmic time complexity, providing stable and efficient performance. Arrays are more efficient than binary search trees only in scenarios with high-frequency additions and low-frequency searches and deletions.</p> <p> Table 7-2   Efficiency comparison between arrays and search trees </p> Unsorted array Binary search tree Search element \\(O(n)\\) \\(O(\\log n)\\) Insert element \\(O(1)\\) \\(O(\\log n)\\) Remove element \\(O(n)\\) \\(O(\\log n)\\) <p>In the ideal case, a binary search tree is \"balanced,\" such that any node can be found within \\(\\log n\\) loop iterations.</p> <p>However, if we continuously insert and remove nodes in a binary search tree, it may degenerate into a linked list as shown in Figure 7-23, where the time complexity of various operations also degrades to \\(O(n)\\).</p> <p></p> <p> Figure 7-23   Degradation of a binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743-common-applications-of-binary-search-trees","level":2,"title":"7.4.3   Common Applications of Binary Search Trees","text":"<ul> <li>Used as multi-level indexes in systems to implement efficient search, insertion, and removal operations.</li> <li>Serves as the underlying data structure for certain search algorithms.</li> <li>Used to store data streams to maintain their ordered state.</li> </ul>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   Binary Tree","text":"<p>A binary tree is a non-linear data structure that represents the derivation relationship between \"ancestors\" and \"descendants\" and embodies the divide-and-conquer logic of \"one divides into two\". Similar to a linked list, the basic unit of a binary tree is a node, and each node contains a value, a reference to its left child node, and a reference to its right child node.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Binary tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.left: TreeNode | None = None  # Reference to left child node\n        self.right: TreeNode | None = None # Reference to right child node\n</code></pre> <pre><code>/* Binary tree node */\nstruct TreeNode {\n    int val;          // Node value\n    TreeNode *left;   // Pointer to left child node\n    TreeNode *right;  // Pointer to right child node\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    int val;         // Node value\n    TreeNode left;   // Reference to left child node\n    TreeNode right;  // Reference to right child node\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public TreeNode? left;  // Reference to left child node\n    public TreeNode? right; // Reference to right child node\n}\n</code></pre> <pre><code>/* Binary tree node */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* Constructor */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // Pointer to left child node\n        Right: nil, // Pointer to right child node\n        Val:   v,   // Node value\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var left: TreeNode? // Reference to left child node\n    var right: TreeNode? // Reference to right child node\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    val; // Node value\n    left; // Pointer to left child node\n    right; // Pointer to right child node\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.left = left === undefined ? null : left; // Reference to left child node\n        this.right = right === undefined ? null : right; // Reference to right child node\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n  int val;         // Node value\n  TreeNode? left;  // Reference to left child node\n  TreeNode? right; // Reference to right child node\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Binary tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Reference to left child node\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Reference to right child node\n}\n\nimpl TreeNode {\n    /* Constructor */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\ntypedef struct TreeNode {\n    int val;                // Node value\n    int height;             // Node height\n    struct TreeNode *left;  // Pointer to left child node\n    struct TreeNode *right; // Pointer to right child node\n} TreeNode;\n\n/* Constructor */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val left: TreeNode? = null   // Reference to left child node\n    val right: TreeNode? = null  // Reference to right child node\n}\n</code></pre> <pre><code>### Binary tree node class ###\nclass TreeNode\n  attr_accessor :val    # Node value\n  attr_accessor :left   # Reference to left child node\n  attr_accessor :right  # Reference to right child node\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>Each node has two references (pointers), pointing respectively to the left-child node and right-child node. This node is called the parent node of these two child nodes. When given a node of a binary tree, we call the tree formed by this node's left child and all nodes below it the left subtree of this node. Similarly, the right subtree can be defined.</p> <p>In a binary tree, except leaf nodes, all other nodes contain child nodes and non-empty subtrees. As shown in Figure 7-1, if \"Node 2\" is regarded as a parent node, its left and right child nodes are \"Node 4\" and \"Node 5\" respectively. The left subtree is formed by \"Node 4\" and all nodes beneath it, while the right subtree is formed by \"Node 5\" and all nodes beneath it.</p> <p></p> <p> Figure 7-1   Parent Node, child Node, subtree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#711-common-terminology-of-binary-trees","level":2,"title":"7.1.1   Common Terminology of Binary Trees","text":"<p>The commonly used terminology of binary trees is shown in Figure 7-2.</p> <ul> <li>Root node: The node at the top level of a binary tree, which does not have a parent node.</li> <li>Leaf node: A node that does not have any child nodes, with both of its pointers pointing to <code>None</code>.</li> <li>Edge: A line segment that connects two nodes, representing a reference (pointer) between the nodes.</li> <li>The level of a node: It increases from top to bottom, with the root node being at level 1.</li> <li>The degree of a node: The number of child nodes that a node has. In a binary tree, the degree can be 0, 1, or 2.</li> <li>The height of a binary tree: The number of edges from the root node to the farthest leaf node.</li> <li>The depth of a node: The number of edges from the root node to the node.</li> <li>The height of a node: The number of edges from the farthest leaf node to the node.</li> </ul> <p></p> <p> Figure 7-2   Common Terminology of Binary Trees </p> <p>Tip</p> <p>Please note that we usually define \"height\" and \"depth\" as \"the number of edges traversed\", but some questions or textbooks may define them as \"the number of nodes traversed\". In this case, both height and depth need to be incremented by 1.</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#712-basic-operations-of-binary-trees","level":2,"title":"7.1.2   Basic Operations of Binary Trees","text":"","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#1-initializing-a-binary-tree","level":3,"title":"1.   Initializing a Binary Tree","text":"<p>Similar to a linked list, the initialization of a binary tree involves first creating the nodes and then establishing the references (pointers) between them.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Initializing a binary tree\n# Initializing nodes\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// Initializing nodes\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// Linking references (pointers) between nodes\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// Initializing nodes\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// Initializing nodes\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// Linking references (pointers) between nodes\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// Linking references (pointers) between nodes\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// Initializing nodes\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># Initializing a binary tree\n# Initializing nodes\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#2-inserting-and-removing-nodes","level":3,"title":"2.   Inserting and Removing Nodes","text":"<p>Similar to a linked list, inserting and removing nodes in a binary tree can be achieved by modifying pointers. Figure 7-3 provides an example.</p> <p></p> <p> Figure 7-3   Inserting and removing nodes in a binary tree </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Inserting and removing nodes\np = TreeNode(0)\n# Inserting node P between n1 -&gt; n2\nn1.left = p\np.left = n2\n# Removing node P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* Inserting and removing nodes */\nTreeNode* P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Removing node P\nn1-&gt;left = n2;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* Inserting and removing nodes */\nTreeNode P = new(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* Inserting and removing nodes */\n// Inserting node P between n1 and n2\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// Removing node P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* Inserting and removing nodes */\nlet P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* Inserting and removing nodes */\nconst P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* Inserting and removing nodes */\nTreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// Inserting node P between n1 and n2\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// Removing node P\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* Inserting and removing nodes */\nTreeNode *P = newTreeNode(0);\n// Inserting node P between n1 and n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Removing node P\nn1-&gt;left = n2;\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># Inserting and removing nodes\n_p = TreeNode.new(0)\n# Inserting node _p between n1 and n2\nn1.left = _p\n_p.left = n2\n# Removing node _p\nn1.left = n2\n</code></pre> Code Visualization <p> Full Screen &gt;</p> <p>Tip</p> <p>It should be noted that inserting nodes may change the original logical structure of the binary tree, while removing nodes typically involves removing the node and all its subtrees. Therefore, in a binary tree, insertion and removal are usually performed through a set of operations to achieve meaningful outcomes.</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#713-common-types-of-binary-trees","level":2,"title":"7.1.3   Common Types of Binary Trees","text":"","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#1-perfect-binary-tree","level":3,"title":"1.   Perfect Binary Tree","text":"<p>As shown in Figure 7-4, a perfect binary tree has all levels completely filled with nodes. In a perfect binary tree, leaf nodes have a degree of \\(0\\), while all other nodes have a degree of \\(2\\). If the tree height is \\(h\\), the total number of nodes is \\(2^{h+1} - 1\\), exhibiting a standard exponential relationship that reflects the common phenomenon of cell division in nature.</p> <p>Tip</p> <p>Please note that in the Chinese community, a perfect binary tree is often referred to as a full binary tree.</p> <p></p> <p> Figure 7-4   Perfect binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#2-complete-binary-tree","level":3,"title":"2.   Complete Binary Tree","text":"<p>As shown in Figure 7-5, a complete binary tree only allows the bottom level to be incompletely filled, and the nodes at the bottom level must be filled continuously from left to right. Note that a perfect binary tree is also a complete binary tree.</p> <p></p> <p> Figure 7-5   Complete binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#3-full-binary-tree","level":3,"title":"3.   Full Binary Tree","text":"<p>As shown in Figure 7-6, in a full binary tree, all nodes except leaf nodes have two child nodes.</p> <p></p> <p> Figure 7-6   Full binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#4-balanced-binary-tree","level":3,"title":"4.   Balanced Binary Tree","text":"<p>As shown in Figure 7-7, in a balanced binary tree, the absolute difference between the height of the left and right subtrees of any node does not exceed 1.</p> <p></p> <p> Figure 7-7   Balanced binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#714-degeneration-of-binary-trees","level":2,"title":"7.1.4   Degeneration of Binary Trees","text":"<p>Figure 7-8 shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the \"perfect binary tree\" state; when all nodes are biased toward one side, the binary tree degenerates into a \"linked list\".</p> <ul> <li>A perfect binary tree is the ideal case, fully leveraging the \"divide and conquer\" advantage of binary trees.</li> <li>A linked list represents the other extreme, where all operations become linear operations with time complexity degrading to \\(O(n)\\).</li> </ul> <p></p> <p> Figure 7-8   The Best and Worst Structures of Binary Trees </p> <p>As shown in Table 7-1, in the best and worst structures, the binary tree achieves either maximum or minimum values for leaf node count, total number of nodes, and height.</p> <p> Table 7-1   The Best and Worst Structures of Binary Trees </p> Perfect binary tree Linked list Number of nodes at level \\(i\\) \\(2^{i-1}\\) \\(1\\) Number of leaf nodes in a tree with height \\(h\\) \\(2^h\\) \\(1\\) Total number of nodes in a tree with height \\(h\\) \\(2^{h+1} - 1\\) \\(h + 1\\) Height of a tree with \\(n\\) total nodes \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   Binary Tree Traversal","text":"<p>From a physical structure perspective, a tree is a data structure based on linked lists. Hence, its traversal method involves accessing nodes one by one through pointers. However, a tree is a non-linear data structure, which makes traversing a tree more complex than traversing a linked list, requiring the assistance of search algorithms.</p> <p>The common traversal methods for binary trees include level-order traversal, pre-order traversal, in-order traversal, and post-order traversal.</p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721-level-order-traversal","level":2,"title":"7.2.1   Level-Order Traversal","text":"<p>As shown in Figure 7-9, level-order traversal traverses the binary tree from top to bottom, layer by layer. Within each level, it visits nodes from left to right.</p> <p>Level-order traversal is essentially breadth-first traversal, also known as breadth-first search (BFS), which embodies a \"expanding outward circle by circle\" layer-by-layer traversal method.</p> <p></p> <p> Figure 7-9   Level-order traversal of a binary tree </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation","level":3,"title":"1.   Code Implementation","text":"<p>Breadth-first traversal is typically implemented with the help of a \"queue\". The queue follows the \"first in, first out\" rule, while breadth-first traversal follows the \"layer-by-layer progression\" rule; the underlying ideas of the two are consistent. The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"Level-order traversal\"\"\"\n    # Initialize queue, add root node\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # Initialize a list to save the traversal sequence\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # Dequeue\n        res.append(node.val)  # Save node value\n        if node.left is not None:\n            queue.append(node.left)  # Left child node enqueue\n        if node.right is not None:\n            queue.append(node.right)  # Right child node enqueue\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* Level-order traversal */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // Initialize queue, add root node\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // Initialize a list to save the traversal sequence\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // Dequeue\n        vec.push_back(node-&gt;val); // Save node value\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // Left child node enqueue\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // Right child node enqueue\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* Level-order traversal */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // Initialize queue, add root node\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // Initialize a list to save the traversal sequence\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // Dequeue\n        list.add(node.val);           // Save node value\n        if (node.left != null)\n            queue.offer(node.left);   // Left child node enqueue\n        if (node.right != null)\n            queue.offer(node.right);  // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* Level-order traversal */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // Initialize queue, add root node\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // Initialize a list to save the traversal sequence\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // Dequeue\n        list.Add(node.val!.Value);       // Save node value\n        if (node.left != null)\n            queue.Enqueue(node.left);    // Left child node enqueue\n        if (node.right != null)\n            queue.Enqueue(node.right);   // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* Level-order traversal */\nfunc levelOrder(root *TreeNode) []any {\n    // Initialize queue, add root node\n    queue := list.New()\n    queue.PushBack(root)\n    // Initialize a slice to save traversal sequence\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // Dequeue\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // Save node value\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // Left child node enqueue\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // Right child node enqueue\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* Level-order traversal */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // Initialize queue, add root node\n    var queue: [TreeNode] = [root]\n    // Initialize a list to save the traversal sequence\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // Dequeue\n        list.append(node.val) // Save node value\n        if let left = node.left {\n            queue.append(left) // Left child node enqueue\n        }\n        if let right = node.right {\n            queue.append(right) // Right child node enqueue\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* Level-order traversal */\nfunction levelOrder(root) {\n    // Initialize queue, add root node\n    const queue = [root];\n    // Initialize a list to save the traversal sequence\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // Dequeue\n        list.push(node.val); // Save node value\n        if (node.left) queue.push(node.left); // Left child node enqueue\n        if (node.right) queue.push(node.right); // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* Level-order traversal */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // Initialize queue, add root node\n    const queue = [root];\n    // Initialize a list to save the traversal sequence\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // Dequeue\n        list.push(node.val); // Save node value\n        if (node.left) {\n            queue.push(node.left); // Left child node enqueue\n        }\n        if (node.right) {\n            queue.push(node.right); // Right child node enqueue\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* Level-order traversal */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // Initialize queue, add root node\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // Initialize a list to save the traversal sequence\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // Dequeue\n    res.add(node!.val); // Save node value\n    if (node.left != null) queue.add(node.left); // Left child node enqueue\n    if (node.right != null) queue.add(node.right); // Right child node enqueue\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* Level-order traversal */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // Initialize queue, add root node\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // Initialize a list to save the traversal sequence\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // Dequeue\n        vec.push(node.borrow().val); // Save node value\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // Left child node enqueue\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // Right child node enqueue\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* Level-order traversal */\nint *levelOrder(TreeNode *root, int *size) {\n    /* Auxiliary queue */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* Auxiliary queue */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // Queue pointer\n    front = 0, rear = 0;\n    // Add root node\n    queue[rear++] = root;\n    // Initialize a list to save the traversal sequence\n    /* Auxiliary array */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // Array pointer\n    index = 0;\n    while (front &lt; rear) {\n        // Dequeue\n        node = queue[front++];\n        // Save node value\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // Left child node enqueue\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // Right child node enqueue\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // Update array length value\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // Free auxiliary array space\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* Level-order traversal */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // Initialize queue, add root node\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // Initialize a list to save the traversal sequence\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // Dequeue\n        list.add(node?._val!!)       // Save node value\n        if (node.left != null)\n            queue.offer(node.left)   // Left child node enqueue\n        if (node.right != null)\n            queue.offer(node.right)  // Right child node enqueue\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### Level-order traversal ###\ndef level_order(root)\n  # Initialize queue, add root node\n  queue = [root]\n  # Initialize a list to save the traversal sequence\n  res = []\n  while !queue.empty?\n    node = queue.shift # Dequeue\n    res &lt;&lt; node.val # Save node value\n    queue &lt;&lt; node.left unless node.left.nil? # Left child node enqueue\n    queue &lt;&lt; node.right unless node.right.nil? # Right child node enqueue\n  end\n  res\nend\n</code></pre>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis","level":3,"title":"2.   Complexity Analysis","text":"<ul> <li>Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time, where \\(n\\) is the number of nodes.</li> <li>Space complexity is \\(O(n)\\): In the worst case, i.e., a full binary tree, before traversing to the bottom level, the queue contains at most \\((n + 1) / 2\\) nodes simultaneously, occupying \\(O(n)\\) space.</li> </ul>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722-preorder-inorder-and-postorder-traversal","level":2,"title":"7.2.2   Preorder, Inorder, and Postorder Traversal","text":"<p>Correspondingly, preorder, inorder, and postorder traversals all belong to depth-first traversal, also known as depth-first search (DFS), which embodies a \"first go to the end, then backtrack and continue\" traversal method.</p> <p>Figure 7-10 shows how depth-first traversal works on a binary tree. Depth-first traversal is like \"walking\" around the perimeter of the entire binary tree, encountering three positions at each node, corresponding to preorder, inorder, and postorder traversal.</p> <p></p> <p> Figure 7-10   Preorder, inorder, and postorder traversal of a binary tree </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation_1","level":3,"title":"1.   Code Implementation","text":"<p>Depth-first search is usually implemented based on recursion:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"Preorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: root node -&gt; left subtree -&gt; right subtree\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"Inorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: left subtree -&gt; root node -&gt; right subtree\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"Postorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: left subtree -&gt; right subtree -&gt; root node\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* Preorder traversal */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* Inorder traversal */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* Postorder traversal */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* Preorder traversal */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* Inorder traversal */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* Postorder traversal */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* Preorder traversal */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* Inorder traversal */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* Postorder traversal */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* Preorder traversal */\nfunction preOrder(root) {\n    if (root === null) return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nfunction inOrder(root) {\n    if (root === null) return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nfunction postOrder(root) {\n    if (root === null) return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* Preorder traversal */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: root node -&gt; left subtree -&gt; right subtree\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: left subtree -&gt; root node -&gt; right subtree\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: left subtree -&gt; right subtree -&gt; root node\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* Preorder traversal */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: root node -&gt; left subtree -&gt; right subtree\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Inorder traversal */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: left subtree -&gt; root node -&gt; right subtree\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Postorder traversal */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: left subtree -&gt; right subtree -&gt; root node\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* Preorder traversal */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* Inorder traversal */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* Postorder traversal */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### Pre-order traversal ###\ndef pre_order(root)\n  return if root.nil?\n\n  # Visit priority: root node -&gt; left subtree -&gt; right subtree\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### In-order traversal ###\ndef in_order(root)\n  return if root.nil?\n\n  # Visit priority: left subtree -&gt; root node -&gt; right subtree\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### Post-order traversal ###\ndef post_order(root)\n  return if root.nil?\n\n  # Visit priority: left subtree -&gt; right subtree -&gt; root node\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> <p>Tip</p> <p>Depth-first search can also be implemented based on iteration, interested readers can study this on their own.</p> <p>Figure 7-11 shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite parts: \"recursion\" and \"return\".</p> <ol> <li>\"Recursion\" means opening a new method, where the program accesses the next node in this process.</li> <li>\"Return\" means the function returns, indicating that the current node has been fully visited.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 7-11   The recursive process of preorder traversal </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis_1","level":3,"title":"2.   Complexity Analysis","text":"<ul> <li>Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time.</li> <li>Space complexity is \\(O(n)\\): In the worst case, i.e., the tree degenerates into a linked list, the recursion depth reaches \\(n\\), and the system occupies \\(O(n)\\) stack frame space.</li> </ul>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   Summary","text":"","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A binary tree is a non-linear data structure that embodies the divide-and-conquer logic of \"one divides into two\". Each binary tree node contains a value and two pointers, which respectively point to its left and right child nodes.</li> <li>For a certain node in a binary tree, the tree formed by its left (right) child node and all nodes below is called the left (right) subtree of that node.</li> <li>Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth.</li> <li>The initialization, node insertion, and node removal operations of binary trees are similar to those of linked lists.</li> <li>Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree is the ideal state, while the linked list is the worst state after degradation.</li> <li>A binary tree can be represented using an array by arranging node values and empty slots in level-order traversal sequence, and implementing pointers based on the index mapping relationship between parent and child nodes.</li> <li>Level-order traversal of a binary tree is a breadth-first search method, embodying a layer-by-layer traversal approach of \"expanding outward circle by circle\", typically implemented using a queue.</li> <li>Preorder, inorder, and postorder traversals all belong to depth-first search, embodying a traversal approach of \"first go to the end, then backtrack and continue\", typically implemented using recursion.</li> <li>A binary search tree is an efficient data structure for element searching, with search, insertion, and removal operations all having time complexity of \\(O(\\log n)\\). When a binary search tree degenerates into a linked list, all time complexities degrade to \\(O(n)\\).</li> <li>An AVL tree, also known as a balanced binary search tree, ensures the tree remains balanced after continuous node insertions and removals through rotation operations.</li> <li>Rotation operations in AVL trees include right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. After inserting or removing nodes, AVL trees perform rotation operations from bottom to top to restore the tree to balance.</li> </ul>","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: For a binary tree with only one node, are both the height of the tree and the depth of the root node \\(0\\)?</p> <p>Yes, because height and depth are typically defined as \"the number of edges passed.\"</p> <p>Q: The insertion and removal in a binary tree are generally accomplished by a set of operations. What does \"a set of operations\" refer to here? Does it imply releasing the resources of the child nodes?</p> <p>Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.</p> <p>Q: Why does DFS traversal of binary trees have three orders: preorder, inorder, and postorder, and what are their uses?</p> <p>Similar to forward and reverse traversal of arrays, preorder, inorder, and postorder traversals are three methods of binary tree traversal that allow us to obtain a traversal result in a specific order. For example, in a binary search tree, since nodes satisfy the relationship <code>left child node value &lt; root node value &lt; right child node value</code>, we only need to traverse the tree with the priority of \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\" to obtain an ordered node sequence.</p> <p>Q: In a right rotation operation handling the relationship between unbalanced nodes <code>node</code>, <code>child</code>, and <code>grand_child</code>, doesn't the connection between <code>node</code> and its parent node get lost after the right rotation?</p> <p>We need to view this problem from a recursive perspective. The right rotation operation <code>right_rotate(root)</code> passes in the root node of the subtree and eventually returns the root node of the subtree after rotation with <code>return child</code>. The connection between the subtree's root node and its parent node is completed after the function returns, which is not within the maintenance scope of the right rotation operation.</p> <p>Q: In C++, functions are divided into <code>private</code> and <code>public</code> sections. What considerations are there for this? Why are the <code>height()</code> function and the <code>updateHeight()</code> function placed in <code>public</code> and <code>private</code>, respectively?</p> <p>It mainly depends on the method's usage scope. If a method is only used within the class, then it is designed as <code>private</code>. For example, calling <code>updateHeight()</code> alone by the user makes no sense, as it is only a step in insertion or removal operations. However, <code>height()</code> is used to access node height, similar to <code>vector.size()</code>, so it is set to <code>public</code> for ease of use.</p> <p>Q: How do you build a binary search tree from a set of input data? Is the choice of root node very important?</p> <p>Yes, the method for building a tree is provided in the <code>build_tree()</code> method in the binary search tree code. As for the choice of root node, we typically sort the input data, then select the middle element as the root node, and recursively build the left and right subtrees. This approach maximizes the tree's balance.</p> <p>Q: In Java, do you always have to use the <code>equals()</code> method for string comparison?</p> <p>In Java, for primitive data types, <code>==</code> is used to compare whether the values of two variables are equal. For reference types, the working principles of the two symbols are different.</p> <ul> <li><code>==</code>: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.</li> <li><code>equals()</code>: Used to compare whether the values of two objects are equal.</li> </ul> <p>Therefore, if we want to compare values, we should use <code>equals()</code>. However, strings initialized via <code>String a = \"hi\"; String b = \"hi\";</code> are stored in the string constant pool and point to the same object, so <code>a == b</code> can also be used to compare the contents of the two strings.</p> <p>Q: Before reaching the bottom level, is the number of nodes in the queue \\(2^h\\) in breadth-first traversal?</p> <p>Yes, for example, a full binary tree with height \\(h = 2\\) has a total of \\(n = 7\\) nodes, then the bottom level has \\(4 = 2^h = (n + 1) / 2\\) nodes.</p>","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]}]}
\ No newline at end of file
+{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"Chapter 16.   Appendix","text":"","path":["Chapter 16. Appendix","Chapter 16. &nbsp; Appendix"],"tags":[]},{"location":"chapter_appendix/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>16.1   Programming Environment Installation</li> <li>16.2   Contributing Together</li> <li>16.3   Terminology Table</li> </ul>","path":["Chapter 16. Appendix","Chapter 16. &nbsp; Appendix"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   Contributing Together","text":"<p>Due to limited capacity, there may be inevitable omissions and errors in this book. We appreciate your understanding and are grateful for your help in correcting them. If you discover typos, broken links, missing content, ambiguous wording, unclear explanations, or structural issues, please help us make corrections to provide readers with higher-quality learning resources.</p> <p>The GitHub IDs of all contributors will be displayed on the homepage of the book repository, the web version, and the PDF version to acknowledge their selfless contributions to the open source community.</p> <p>The Charm of Open Source</p> <p>The interval between two printings of a physical book is often quite long, making content updates very inconvenient.</p> <p>In this open source book, the time for content updates has been shortened to just days or even hours.</p>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#1-minor-content-adjustments","level":3,"title":"1.   Minor Content Adjustments","text":"<p>As shown in Figure 16-3, there is an \"edit icon\" in the top-right corner of each page. You can modify text or code by following these steps.</p> <ol> <li>Click the \"edit icon\". If you encounter a prompt asking you to \"Fork this repository\", please approve the operation.</li> <li>Modify the content of the Markdown source file, verify the correctness of the content, and maintain consistent formatting as much as possible.</li> <li>Fill in a description of your changes at the bottom of the page, then click the \"Propose file change\" button. After the page transitions, click the \"Create pull request\" button to submit your pull request.</li> </ol> <p></p> <p> Figure 16-3   Page edit button </p> <p>Images cannot be directly modified. Please describe the issue by creating a new Issue or leaving a comment. We will promptly redraw and replace the images.</p>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#2-content-creation","level":3,"title":"2.   Content Creation","text":"<p>If you are interested in contributing to this open source project, including translating code into other programming languages or expanding article content, you will need to follow the Pull Request workflow below.</p> <ol> <li>Log in to GitHub and Fork the book's code repository to your personal account.</li> <li>Enter your forked repository webpage and use the <code>git clone</code> command to clone the repository to your local machine.</li> <li>Create content locally and conduct comprehensive tests to verify code correctness.</li> <li>Commit your local changes and push them to the remote repository.</li> <li>Refresh the repository webpage and click the \"Create pull request\" button to submit your pull request.</li> </ol>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker-deployment","level":3,"title":"3.   Docker Deployment","text":"<p>From the root directory of <code>hello-algo</code>, run the following Docker script to access the project at <code>http://localhost:8000</code>:</p> <pre><code>docker-compose up -d\n</code></pre> <p>Use the following command to remove the deployment:</p> <pre><code>docker-compose down\n</code></pre>","path":["Chapter 16. Appendix","16.2 &nbsp; Contributing Together"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   Programming Environment Installation","text":"","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1611-installing-ide","level":2,"title":"16.1.1   Installing Ide","text":"<p>We recommend using the open-source and lightweight VS Code as the local integrated development environment (IDE). Visit the VS Code official website, and download and install the appropriate version of VS Code according to your operating system.</p> <p></p> <p> Figure 16-1   Download VS Code from the Official Website </p> <p>VS Code has a powerful ecosystem of extensions that supports running and debugging most programming languages. For example, after installing the \"Python Extension Pack\" extension, you can debug Python code. The installation steps are shown in the following figure.</p> <p></p> <p> Figure 16-2   Install VS Code Extensions </p>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1612-installing-language-environments","level":2,"title":"16.1.2   Installing Language Environments","text":"","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#1-python-environment","level":3,"title":"1.   Python Environment","text":"<ol> <li>Download and install Miniconda3, which requires Python 3.10 or newer.</li> <li>Search for <code>python</code> in the VS Code extension marketplace and install the Python Extension Pack.</li> <li>(Optional) Enter <code>pip install black</code> on the command line to install the code formatter.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc-environment","level":3,"title":"2.   C/c++ Environment","text":"<ol> <li>Windows systems need to install MinGW (configuration tutorial); macOS comes with Clang built-in and does not require installation.</li> <li>Search for <code>c++</code> in the VS Code extension marketplace and install the C/C++ Extension Pack.</li> <li>(Optional) Open the Settings page, search for the <code>Clang_format_fallback Style</code> code formatting option, and set it to <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code>.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#3-java-environment","level":3,"title":"3.   Java Environment","text":"<ol> <li>Download and install OpenJDK (version must be &gt; JDK 9).</li> <li>Search for <code>java</code> in the VS Code extension marketplace and install the Extension Pack for Java.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#4-c-environment","level":3,"title":"4.   C# Environment","text":"<ol> <li>Download and install .Net 8.0.</li> <li>Search for <code>C# Dev Kit</code> in the VS Code extension marketplace and install C# Dev Kit (configuration tutorial).</li> <li>You can also use Visual Studio (installation tutorial).</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#5-go-environment","level":3,"title":"5.   Go Environment","text":"<ol> <li>Download and install Go.</li> <li>Search for <code>go</code> in the VS Code extension marketplace and install Go.</li> <li>Press <code>Ctrl + Shift + P</code> to open the command palette, type <code>go</code>, select <code>Go: Install/Update Tools</code>, check all options and install.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift-environment","level":3,"title":"6.   Swift Environment","text":"<ol> <li>Download and install Swift.</li> <li>Search for <code>swift</code> in the VS Code extension marketplace and install Swift for Visual Studio Code.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript-environment","level":3,"title":"7.   Javascript Environment","text":"<ol> <li>Download and install Node.js.</li> <li>(Optional) Search for <code>Prettier</code> in the VS Code extension marketplace and install the code formatter.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript-environment","level":3,"title":"8.   Typescript Environment","text":"<ol> <li>Follow the same installation steps as the JavaScript environment.</li> <li>Install TypeScript Execute (tsx).</li> <li>Search for <code>typescript</code> in the VS Code extension marketplace and install Pretty TypeScript Errors.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart-environment","level":3,"title":"9.   Dart Environment","text":"<ol> <li>Download and install Dart.</li> <li>Search for <code>dart</code> in the VS Code extension marketplace and install Dart.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust-environment","level":3,"title":"10.   Rust Environment","text":"<ol> <li>Download and install Rust.</li> <li>Search for <code>rust</code> in the VS Code extension marketplace and install rust-analyzer.</li> </ol>","path":["Chapter 16. Appendix","16.1 &nbsp; Programming Environment Installation"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   Terminology Table","text":"<p>The following table lists important terms that appear in this book. It is worth noting the following points:</p> <ul> <li>We recommend remembering the English names of terms to help with reading English literature.</li> <li>Some terms have different names in Simplified Chinese and Traditional Chinese.</li> </ul> <p> Table 16-1   Important Terms in Data Structures and Algorithms </p> English Simplified Chinese Traditional Chinese algorithm 算法 演算法 data structure 数据结构 資料結構 code 代码 程式碼 file 文件 檔案 function 函数 函式 method 方法 方法 variable 变量 變數 asymptotic complexity analysis 渐近复杂度分析 漸近複雜度分析 time complexity 时间复杂度 時間複雜度 space complexity 空间复杂度 空間複雜度 loop 循环 迴圈 iteration 迭代 迭代 recursion 递归 遞迴 tail recursion 尾递归 尾遞迴 recursion tree 递归树 遞迴樹 big-\\(O\\) notation 大 \\(O\\) 记号 大 \\(O\\) 記號 asymptotic upper bound 渐近上界 漸近上界 sign-magnitude 原码 原碼 1’s complement 反码 一補數 2’s complement 补码 二補數 array 数组 陣列 index 索引 索引 linked list 链表 鏈結串列 linked list node, list node 链表节点 鏈結串列節點 head node 头节点 頭節點 tail node 尾节点 尾節點 list 列表 串列 dynamic array 动态数组 動態陣列 hard disk 硬盘 硬碟 random-access memory (RAM) 内存 記憶體 cache memory 缓存 快取 cache miss 缓存未命中 快取未命中 cache hit rate 缓存命中率 快取命中率 stack 栈 堆疊 top of the stack 栈顶 堆疊頂 bottom of the stack 栈底 堆疊底 queue 队列 佇列 double-ended queue 双向队列 雙向佇列 front of the queue 队首 佇列首 rear of the queue 队尾 佇列尾 hash table 哈希表 雜湊表 hash set 哈希集合 雜湊集合 bucket 桶 桶 hash function 哈希函数 雜湊函式 hash collision 哈希冲突 雜湊衝突 load factor 负载因子 負載因子 separate chaining 链式地址 鏈結位址 open addressing 开放寻址 開放定址 linear probing 线性探测 線性探查 lazy deletion 懒删除 懶刪除 binary tree 二叉树 二元樹 tree node 树节点 樹節點 left-child node 左子节点 左子節點 right-child node 右子节点 右子節點 parent node 父节点 父節點 left subtree 左子树 左子樹 right subtree 右子树 右子樹 root node 根节点 根節點 leaf node 叶节点 葉節點 edge 边 邊 level 层 層 degree 度 度 height 高度 高度 depth 深度 深度 perfect binary tree 完美二叉树 完美二元樹 complete binary tree 完全二叉树 完全二元樹 full binary tree 完满二叉树 完滿二元樹 balanced binary tree 平衡二叉树 平衡二元樹 binary search tree 二叉搜索树 二元搜尋樹 AVL tree AVL 树 AVL 樹 red-black tree 红黑树 紅黑樹 level-order traversal 层序遍历 層序走訪 breadth-first traversal 广度优先遍历 廣度優先走訪 depth-first traversal 深度优先遍历 深度優先走訪 binary search tree 二叉搜索树 二元搜尋樹 balanced binary search tree 平衡二叉搜索树 平衡二元搜尋樹 balance factor 平衡因子 平衡因子 heap 堆 堆積 max heap 大顶堆 大頂堆積 min heap 小顶堆 小頂堆積 priority queue 优先队列 優先佇列 heapify 堆化 堆積化 top-\\(k\\) problem Top-\\(k\\) 问题 Top-\\(k\\) 問題 graph 图 圖 vertex 顶点 頂點 undirected graph 无向图 無向圖 directed graph 有向图 有向圖 connected graph 连通图 連通圖 disconnected graph 非连通图 非連通圖 weighted graph 有权图 有權圖 adjacency 邻接 鄰接 path 路径 路徑 in-degree 入度 入度 out-degree 出度 出度 adjacency matrix 邻接矩阵 鄰接矩陣 adjacency list 邻接表 鄰接表 breadth-first search 广度优先搜索 廣度優先搜尋 depth-first search 深度优先搜索 深度優先搜尋 binary search 二分查找 二分搜尋 searching algorithm 搜索算法 搜尋演算法 sorting algorithm 排序算法 排序演算法 selection sort 选择排序 選擇排序 bubble sort 冒泡排序 泡沫排序 insertion sort 插入排序 插入排序 quick sort 快速排序 快速排序 merge sort 归并排序 合併排序 heap sort 堆排序 堆積排序 bucket sort 桶排序 桶排序 counting sort 计数排序 計數排序 radix sort 基数排序 基數排序 divide and conquer 分治 分治 hanota problem 汉诺塔问题 河內塔問題 backtracking algorithm 回溯算法 回溯演算法 constraint 约束 約束 solution 解 解 state 状态 狀態 pruning 剪枝 剪枝 permutations problem 全排列问题 全排列問題 subset-sum problem 子集和问题 子集合問題 \\(n\\)-queens problem \\(n\\) 皇后问题 \\(n\\) 皇后問題 dynamic programming 动态规划 動態規劃 initial state 初始状态 初始狀態 state-transition equation 状态转移方程 狀態轉移方程 knapsack problem 背包问题 背包問題 edit distance problem 编辑距离问题 編輯距離問題 greedy algorithm 贪心算法 貪婪演算法","path":["Chapter 16. Appendix","16.3 &nbsp; Terminology Table"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"Chapter 4.   Array and Linked List","text":"<p>Abstract</p> <p>The world of data structures is like a solid brick wall.</p> <p>Array bricks are neatly arranged, tightly packed one by one. Linked list bricks are scattered everywhere, with connecting vines freely weaving through the gaps between bricks.</p>","path":["Chapter 4. Array and Linked List","Chapter 4. &nbsp; Array and Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>4.1   Array</li> <li>4.2   Linked List</li> <li>4.3   List</li> <li>4.4   Memory and Cache *</li> <li>4.5   Summary</li> </ul>","path":["Chapter 4. Array and Linked List","Chapter 4. &nbsp; Array and Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   Array","text":"<p>An array is a linear data structure that stores elements of the same type in contiguous memory space. The position of an element in the array is called the element's index. Figure 4-1 illustrates the main concepts and storage method of arrays.</p> <p></p> <p> Figure 4-1   Array definition and storage method </p>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411-common-array-operations","level":2,"title":"4.1.1   Common Array Operations","text":"","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1-initializing-arrays","level":3,"title":"1.   Initializing Arrays","text":"<p>We can choose between two array initialization methods based on our needs: without initial values or with given initial values. When no initial values are specified, most programming languages will initialize array elements to \\(0\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># Initialize array\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* Initialize array */\n// Stored on stack\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Stored on heap (requires manual memory release)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* Initialize array */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* Initialize array */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* Initialize array */\nvar arr [5]int\n// In Go, specifying length ([5]int) creates an array; not specifying length ([]int) creates a slice\n// Since Go's arrays are designed to have their length determined at compile time, only constants can be used to specify the length\n// For convenience in implementing the extend() method, slices are treated as arrays below\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* Initialize array */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* Initialize array */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* Initialize array */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* Initialize array */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* Initialize array */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// In Rust, specifying length ([i32; 5]) creates an array; not specifying length (&amp;[i32]) creates a slice\n// Since Rust's arrays are designed to have their length determined at compile time, only constants can be used to specify the length\n// Vector is the type generally used as a dynamic array in Rust\n// For convenience in implementing the extend() method, vectors are treated as arrays below\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* Initialize array */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* Initialize array */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># Initialize array\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2-accessing-elements","level":3,"title":"2.   Accessing Elements","text":"<p>Array elements are stored in contiguous memory space, which means calculating the memory address of array elements is very easy. Given the array's memory address (the memory address of the first element) and an element's index, we can use the formula shown in Figure 4-2 to calculate the element's memory address and directly access that element.</p> <p></p> <p> Figure 4-2   Memory address calculation for array elements </p> <p>Observing Figure 4-2, we find that the first element of an array has an index of \\(0\\), which may seem counterintuitive since counting from \\(1\\) would be more natural. However, from the perspective of the address calculation formula, an index is essentially an offset from the memory address. The address offset of the first element is \\(0\\), so it is reasonable for its index to be \\(0\\).</p> <p>Accessing elements in an array is highly efficient; we can randomly access any element in the array in \\(O(1)\\) time.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"Random access to element\"\"\"\n    # Randomly select a number from the interval [0, len(nums)-1]\n    random_index = random.randint(0, len(nums) - 1)\n    # Retrieve and return the random element\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* Random access to element */\nint randomAccess(int *nums, int size) {\n    // Randomly select a number from interval [0, size)\n    int randomIndex = rand() % size;\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* Random access to element */\nint randomAccess(int[] nums) {\n    // Randomly select a number in the interval [0, nums.length)\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* Random access to element */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // Randomly select a number in interval [0, nums.Length)\n    int randomIndex = random.Next(nums.Length);\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* Random access to element */\nfunc randomAccess(nums []int) (randomNum int) {\n    // Randomly select a number in the interval [0, nums.length)\n    randomIndex := rand.Intn(len(nums))\n    // Retrieve and return the random element\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* Random access to element */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // Randomly select a number in interval [0, nums.count)\n    let randomIndex = nums.indices.randomElement()!\n    // Retrieve and return the random element\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* Random access to element */\nfunction randomAccess(nums) {\n    // Randomly select a number in the interval [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Retrieve and return the random element\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* Random access to element */\nfunction randomAccess(nums: number[]): number {\n    // Randomly select a number in the interval [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Retrieve and return the random element\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* Random access to element */\nint randomAccess(List&lt;int&gt; nums) {\n  // Randomly select a number in the interval [0, nums.length)\n  int randomIndex = Random().nextInt(nums.length);\n  // Retrieve and return the random element\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* Random access to element */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // Randomly select a number in interval [0, nums.len())\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // Retrieve and return the random element\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* Random access to element */\nint randomAccess(int *nums, int size) {\n    // Randomly select a number from interval [0, size)\n    int randomIndex = rand() % size;\n    // Retrieve and return the random element\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* Random access to element */\nfun randomAccess(nums: IntArray): Int {\n    // Randomly select a number in interval [0, nums.size)\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // Retrieve and return the random element\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### Random access element ###\ndef random_access(nums)\n  # Randomly select a number in the interval [0, nums.length)\n  random_index = Random.rand(0...nums.length)\n\n  # Retrieve and return the random element\n  nums[random_index]\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3-inserting-elements","level":3,"title":"3.   Inserting Elements","text":"<p>Array elements are stored \"tightly adjacent\" in memory, with no space between them to store any additional data. As shown in Figure 4-3, if we want to insert an element in the middle of an array, we need to shift all elements after that position backward by one position, and then assign the value to that index.</p> <p></p> <p> Figure 4-3   Example of inserting an element into an array </p> <p>It is worth noting that since the length of an array is fixed, inserting an element will inevitably cause the element at the end of the array to be \"lost\". We will leave the solution to this problem for discussion in the \"List\" chapter.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"Insert element num at index index in the array\"\"\"\n    # Move all elements at and after index index backward by one position\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # Assign num to the element at index index\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* Insert element num at index index in the array */\nvoid insert(int *nums, int size, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* Insert element num at index index in the array */\nvoid insert(int[] nums, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* Insert element num at index index in the array */\nvoid Insert(int[] nums, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* Insert element num at index index in the array */\nfunc insert(nums []int, num int, index int) {\n    // Move all elements at and after index index backward by one position\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* Insert element num at index index in the array */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // Move all elements at and after index index backward by one position\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* Insert element num at index index in the array */\nfunction insert(nums, num, index) {\n    // Move all elements at and after index index backward by one position\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* Insert element num at index index in the array */\nfunction insert(nums: number[], num: number, index: number): void {\n    // Move all elements at and after index index backward by one position\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* Insert element _num at array index index */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // Move all elements at and after index index backward by one position\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // Assign _num to element at index\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* Insert element num at index index in the array */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // Move all elements at and after index index backward by one position\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* Insert element num at index index in the array */\nvoid insert(int *nums, int size, int num, int index) {\n    // Move all elements at and after index index backward by one position\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Assign num to the element at index index\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* Insert element num at index index in the array */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // Move all elements at and after index index backward by one position\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // Assign num to the element at index index\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### Insert element num at index in array ###\ndef insert(nums, num, index)\n  # Move all elements at and after index index backward by one position\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # Assign num to the element at index index\n  nums[index] = num\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4-removing-elements","level":3,"title":"4.   Removing Elements","text":"<p>Similarly, as shown in Figure 4-4, to delete the element at index \\(i\\), we need to shift all elements after index \\(i\\) forward by one position.</p> <p></p> <p> Figure 4-4   Example of removing an element from an array </p> <p>Note that after the deletion is complete, the original last element becomes \"meaningless\", so we do not need to specifically modify it.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"Remove the element at index index\"\"\"\n    # Move all elements after index index forward by one position\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* Remove the element at index index */\nvoid remove(int *nums, int size, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* Remove the element at index index */\nvoid remove(int[] nums, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* Remove the element at index index */\nvoid Remove(int[] nums, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* Remove the element at index index */\nfunc remove(nums []int, index int) {\n    // Move all elements after index index forward by one position\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* Remove the element at index index */\nfunc remove(nums: inout [Int], index: Int) {\n    // Move all elements after index index forward by one position\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* Remove the element at index index */\nfunction remove(nums, index) {\n    // Move all elements after index index forward by one position\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* Remove the element at index index */\nfunction remove(nums: number[], index: number): void {\n    // Move all elements after index index forward by one position\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* Remove the element at index index */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // Move all elements after index index forward by one position\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* Remove the element at index index */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // Move all elements after index index forward by one position\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* Remove the element at index index */\n// Note: stdio.h occupies the remove keyword\nvoid removeItem(int *nums, int size, int index) {\n    // Move all elements after index index forward by one position\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* Remove the element at index index */\nfun remove(nums: IntArray, index: Int) {\n    // Move all elements after index index forward by one position\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### Delete element at index ###\ndef remove(nums, index)\n  # Move all elements after index index forward by one position\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> <p>Overall, array insertion and deletion operations have the following drawbacks:</p> <ul> <li>High time complexity: The average time complexity for both insertion and deletion in arrays is \\(O(n)\\), where \\(n\\) is the length of the array.</li> <li>Loss of elements: Since the length of an array is immutable, after inserting an element, elements that exceed the array's length will be lost.</li> <li>Memory waste: We can initialize a relatively long array and only use the front portion, so that when inserting data, the lost elements at the end are \"meaningless\", but this causes some memory space to be wasted.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5-traversing-arrays","level":3,"title":"5.   Traversing Arrays","text":"<p>In most programming languages, we can traverse an array either by index or by directly iterating through each element in the array:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"Traverse array\"\"\"\n    count = 0\n    # Traverse array by index\n    for i in range(len(nums)):\n        count += nums[i]\n    # Direct traversal of array elements\n    for num in nums:\n        count += num\n    # Traverse simultaneously data index and elements\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* Traverse array */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* Traverse array */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* Traverse array */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* Traverse array */\nfunc traverse(nums []int) {\n    count := 0\n    // Traverse array by index\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // Direct traversal of array elements\n    for _, num := range nums {\n        count += num\n    }\n    // Traverse simultaneously data index and elements\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* Traverse array */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // Traverse array by index\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // Direct traversal of array elements\n    for num in nums {\n        count += num\n    }\n    // Traverse simultaneously data index and elements\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* Traverse array */\nfunction traverse(nums) {\n    let count = 0;\n    // Traverse array by index\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* Traverse array */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // Traverse array by index\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Direct traversal of array elements\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* Traverse array elements */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // Traverse array by index\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // Direct traversal of array elements\n  for (int _num in nums) {\n    count += _num;\n  }\n  // Traverse array using forEach method\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* Traverse array */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // Traverse array by index\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // Direct traversal of array elements\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* Traverse array */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Traverse array by index\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* Traverse array */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // Traverse array by index\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // Direct traversal of array elements\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### Traverse array ###\ndef traverse(nums)\n  count = 0\n\n  # Traverse array by index\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # Direct traversal of array elements\n  for num in nums\n    count += num\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6-finding-elements","level":3,"title":"6.   Finding Elements","text":"<p>Finding a specified element in an array requires traversing the array and checking whether the element value matches in each iteration; if it matches, output the corresponding index.</p> <p>Since an array is a linear data structure, the above search operation is called a \"linear search\".</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"Find the specified element in the array\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* Find the specified element in the array */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* Find the specified element in the array */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* Find the specified element in the array */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* Find the specified element in the array */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* Find the specified element in the array */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* Find the specified element in the array */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* Find the specified element in the array */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* Find the specified element in the array */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* Find the specified element in the array */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* Find the specified element in the array */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* Find the specified element in the array */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### Find specified element in array ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7-expanding-arrays","level":3,"title":"7.   Expanding Arrays","text":"<p>In complex system environments, programs cannot guarantee that the memory space after an array is available, making it unsafe to expand the array's capacity. Therefore, in most programming languages, the length of an array is immutable.</p> <p>If we want to expand an array, we need to create a new, larger array and then copy the original array elements to the new array one by one. This is an \\(O(n)\\) operation, which is very time-consuming when the array is large. The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"Extend array length\"\"\"\n    # Initialize an array with extended length\n    res = [0] * (len(nums) + enlarge)\n    # Copy all elements from the original array to the new array\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # Return the extended new array\n    return res\n</code></pre> array.cpp<pre><code>/* Extend array length */\nint *extend(int *nums, int size, int enlarge) {\n    // Initialize an array with extended length\n    int *res = new int[size + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Free memory\n    delete[] nums;\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.java<pre><code>/* Extend array length */\nint[] extend(int[] nums, int enlarge) {\n    // Initialize an array with extended length\n    int[] res = new int[nums.length + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.cs<pre><code>/* Extend array length */\nint[] Extend(int[] nums, int enlarge) {\n    // Initialize an array with extended length\n    int[] res = new int[nums.Length + enlarge];\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.go<pre><code>/* Extend array length */\nfunc extend(nums []int, enlarge int) []int {\n    // Initialize an array with extended length\n    res := make([]int, len(nums)+enlarge)\n    // Copy all elements from the original array to the new array\n    for i, num := range nums {\n        res[i] = num\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.swift<pre><code>/* Extend array length */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // Initialize an array with extended length\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // Copy all elements from the original array to the new array\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.js<pre><code>/* Extend array length */\n// Note: JavaScript's Array is dynamic array, can be directly expanded\n// For learning purposes, this function treats Array as fixed-length array\nfunction extend(nums, enlarge) {\n    // Initialize an array with extended length\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Copy all elements from the original array to the new array\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.ts<pre><code>/* Extend array length */\n// Note: TypeScript's Array is dynamic array, can be directly expanded\n// For learning purposes, this function treats Array as fixed-length array\nfunction extend(nums: number[], enlarge: number): number[] {\n    // Initialize an array with extended length\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Copy all elements from the original array to the new array\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.dart<pre><code>/* Extend array length */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // Initialize an array with extended length\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // Copy all elements from the original array to the new array\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // Return the extended new array\n  return res;\n}\n</code></pre> array.rs<pre><code>/* Extend array length */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // Initialize an array with extended length\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // Copy all elements from original array to new\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // Return the extended new array\n    res\n}\n</code></pre> array.c<pre><code>/* Extend array length */\nint *extend(int *nums, int size, int enlarge) {\n    // Initialize an array with extended length\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // Copy all elements from the original array to the new array\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Initialize expanded space\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // Return the extended new array\n    return res;\n}\n</code></pre> array.kt<pre><code>/* Extend array length */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // Initialize an array with extended length\n    val res = IntArray(nums.size + enlarge)\n    // Copy all elements from the original array to the new array\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // Return the extended new array\n    return res\n}\n</code></pre> array.rb<pre><code>### Extend array length ###\n# Note: Ruby's Array is dynamic array, can be directly expanded\n# For learning purposes, this function treats Array as fixed-length array\ndef extend(nums, enlarge)\n  # Initialize an array with extended length\n  res = Array.new(nums.length + enlarge, 0)\n\n  # Copy all elements from the original array to the new array\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # Return the extended new array\n  res\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412-advantages-and-limitations-of-arrays","level":2,"title":"4.1.2   Advantages and Limitations of Arrays","text":"<p>Arrays are stored in contiguous memory space with elements of the same type. This approach contains rich prior information that the system can use to optimize the efficiency of data structure operations.</p> <ul> <li>High space efficiency: Arrays allocate contiguous memory blocks for data without additional structural overhead.</li> <li>Support for random access: Arrays allow accessing any element in \\(O(1)\\) time.</li> <li>Cache locality: When accessing array elements, the computer not only loads the element but also caches the surrounding data, thereby leveraging the cache to improve the execution speed of subsequent operations.</li> </ul> <p>Contiguous space storage is a double-edged sword with the following limitations:</p> <ul> <li>Low insertion and deletion efficiency: When an array has many elements, insertion and deletion operations require shifting a large number of elements.</li> <li>Immutable length: After an array is initialized, its length is fixed. Expanding the array requires copying all data to a new array, which is very costly.</li> <li>Space waste: If the allocated size of an array exceeds what is actually needed, the extra space is wasted.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413-typical-applications-of-arrays","level":2,"title":"4.1.3   Typical Applications of Arrays","text":"<p>Arrays are a fundamental and common data structure, frequently used in various algorithms and for implementing various complex data structures.</p> <ul> <li>Random access: If we want to randomly sample some items, we can use an array to store them and generate a random sequence to implement random sampling based on indices.</li> <li>Sorting and searching: Arrays are the most commonly used data structure for sorting and searching algorithms. Quick sort, merge sort, binary search, and others are primarily performed on arrays.</li> <li>Lookup tables: When we need to quickly find an element or its corresponding relationship, we can use an array as a lookup table. For example, if we want to implement a mapping from characters to ASCII codes, we can use the ASCII code value of a character as an index, with the corresponding element stored at that position in the array.</li> <li>Machine learning: Neural networks make extensive use of linear algebra operations between vectors, matrices, and tensors, all of which are constructed in the form of arrays. Arrays are the most commonly used data structure in neural network programming.</li> <li>Data structure implementation: Arrays can be used to implement stacks, queues, hash tables, heaps, graphs, and other data structures. For example, the adjacency matrix representation of a graph is essentially a two-dimensional array.</li> </ul>","path":["Chapter 4. Array and Linked List","4.1 &nbsp; Array"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   Linked List","text":"<p>Memory space is a shared resource for all programs. In a complex system runtime environment, available memory space may be scattered throughout the memory. We know that the memory space for storing an array must be contiguous, and when the array is very large, the memory may not be able to provide such a large contiguous space. This is where the flexibility advantage of linked lists becomes apparent.</p> <p>A linked list is a linear data structure in which each element is a node object, and the nodes are connected through \"references\". A reference records the memory address of the next node, through which the next node can be accessed from the current node.</p> <p>The design of linked lists allows nodes to be stored scattered throughout the memory, and their memory addresses do not need to be contiguous.</p> <p></p> <p> Figure 4-5   Linked list definition and storage method </p> <p>Observing Figure 4-5, the basic unit of a linked list is a node object. Each node contains two pieces of data: the node's \"value\" and a \"reference\" to the next node.</p> <ul> <li>The first node of a linked list is called the \"head node\", and the last node is called the \"tail node\".</li> <li>The tail node points to \"null\", which is denoted as <code>null</code>, <code>nullptr</code>, and <code>None</code> in Java, C++, and Python, respectively.</li> <li>In languages that support pointers, such as C, C++, Go, and Rust, the aforementioned \"reference\" should be replaced with \"pointer\".</li> </ul> <p>As shown in the following code, a linked list node <code>ListNode</code> contains not only a value but also an additional reference (pointer). Therefore, linked lists occupy more memory space than arrays when storing the same amount of data.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Linked list node class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Node value\n        self.next: ListNode | None = None # Reference to the next node\n</code></pre> <pre><code>/* Linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the next node\n    ListNode(int x) : val(x), next(nullptr) {}  // Constructor\n};\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode(int x) { val = x; }  // Constructor\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;         // Node value\n    ListNode? next;      // Reference to the next node\n}\n</code></pre> <pre><code>/* Linked list node structure */\ntype ListNode struct {\n    Val  int       // Node value\n    Next *ListNode // Pointer to the next node\n}\n\n// NewListNode Constructor, creates a new linked list\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Node value\n        this.next = (next === undefined ? null : next); // Reference to the next node\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Node value\n        this.next = next === undefined ? null : next;  // Reference to the next node\n    }\n}\n</code></pre> <pre><code>/* Linked list node class */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Reference to the next node\n  ListNode(this.val, [this.next]); // Constructor\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* Linked list node class */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the next node\n}\n</code></pre> <pre><code>/* Linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the next node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Linked list node class */\n// Constructor\nclass ListNode(x: Int) {\n    val _val: Int = x          // Node value\n    val next: ListNode? = null // Reference to the next node\n}\n</code></pre> <pre><code># Linked list node class\nclass ListNode\n  attr_accessor :val  # Node value\n  attr_accessor :next # Reference to the next node\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421-common-linked-list-operations","level":2,"title":"4.2.1   Common Linked List Operations","text":"","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1-initializing-a-linked-list","level":3,"title":"1.   Initializing a Linked List","text":"<p>Building a linked list involves two steps: first, initializing each node object; second, constructing the reference relationships between nodes. Once initialization is complete, we can traverse all nodes starting from the head node of the linked list through the reference <code>next</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Initialize each node\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// Build references between nodes\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Build references between nodes\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// Initialize each node\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Build references between nodes\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Build references between nodes\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Initialize each node\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># Initialize linked list 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Initialize each node\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> Code Visualization <p> Full Screen &gt;</p> <p>An array is a single variable; for example, an array <code>nums</code> contains elements <code>nums[0]</code>, <code>nums[1]</code>, etc. A linked list, however, is composed of multiple independent node objects. We typically use the head node as the reference to the linked list; for example, the linked list in the above code can be referred to as linked list <code>n0</code>.</p>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2-inserting-a-node","level":3,"title":"2.   Inserting a Node","text":"<p>Inserting a node in a linked list is very easy. As shown in Figure 4-6, suppose we want to insert a new node <code>P</code> between two adjacent nodes <code>n0</code> and <code>n1</code>. We only need to change two node references (pointers), with a time complexity of \\(O(1)\\).</p> <p>In contrast, the time complexity of inserting an element in an array is \\(O(n)\\), which is inefficient when dealing with large amounts of data.</p> <p></p> <p> Figure 4-6   Example of inserting a node into a linked list </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"Insert node P after node n0 in the linked list\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* Insert node P after node n0 in the linked list */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* Insert node P after node n0 in the linked list */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* Insert node P after node n0 in the linked list */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* Insert node P after node n0 in the linked list */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* Insert node P after node n0 in the linked list */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* Insert node P after node n0 in the linked list */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* Insert node P after node n0 in the linked list */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* Insert node P after node n0 in the linked list */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### Insert node _p after node n0 in linked list ###\n# Ruby's `p` is a built-in function, `P` is a constant, so use `_p` instead\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3-removing-a-node","level":3,"title":"3.   Removing a Node","text":"<p>As shown in Figure 4-7, removing a node in a linked list is also very convenient. We only need to change one node's reference (pointer).</p> <p>Note that although node <code>P</code> still points to <code>n1</code> after the deletion operation is complete, the linked list can no longer access <code>P</code> when traversing, which means <code>P</code> no longer belongs to this linked list.</p> <p></p> <p> Figure 4-7   Removing a node from a linked list </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"Remove the first node after node n0 in the linked list\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Free memory\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* Remove the first node after node n0 in the linked list */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* Remove the first node after node n0 in the linked list */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* Remove the first node after node n0 in the linked list */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* Remove the first node after node n0 in the linked list */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* Remove the first node after node n0 in the linked list */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* Remove the first node after node n0 in the linked list */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* Remove the first node after node n0 in the linked list */\n// Note: stdio.h occupies the remove keyword\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Free memory\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* Remove the first node after node n0 in the linked list */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### Delete first node after node n0 in linked list ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4-accessing-a-node","level":3,"title":"4.   Accessing a Node","text":"<p>Accessing nodes in a linked list is less efficient. As mentioned in the previous section, we can access any element in an array in \\(O(1)\\) time. This is not the case with linked lists. The program needs to start from the head node and traverse backward one by one until the target node is found. That is, accessing the \\(i\\)-th node in a linked list requires \\(i - 1\\) iterations, with a time complexity of \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"Access the node at index index in the linked list\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* Access the node at index index in the linked list */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* Access the node at index index in the linked list */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* Access the node at index index in the linked list */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* Access the node at index index in the linked list */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* Access the node at index index in the linked list */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* Access the node at index index in the linked list */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* Access the node at index index in the linked list */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* Access the node at index index in the linked list */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* Access the node at index index in the linked list */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* Access the node at index index in the linked list */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* Access the node at index index in the linked list */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### Access node at index in linked list ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5-finding-a-node","level":3,"title":"5.   Finding a Node","text":"<p>Traverse the linked list to find a node with value <code>target</code>, and output the index of that node in the linked list. This process is also a linear search. The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"Find the first node with value target in the linked list\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* Find the first node with value target in the linked list */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* Find the first node with value target in the linked list */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* Find the first node with value target in the linked list */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* Find the first node with value target in the linked list */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* Find the first node with value target in the linked list */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* Find the first node with value target in the linked list */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* Find the first node with value target in the linked list */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* Find the first node with value target in the linked list */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### Find first node with value target in linked list ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-arrays-vs-linked-lists","level":2,"title":"4.2.2   Arrays vs. Linked Lists","text":"<p>Table 4-1 summarizes the characteristics of arrays and linked lists and compares their operational efficiencies. Since they employ two opposite storage strategies, their various properties and operational efficiencies also exhibit contrasting characteristics.</p> <p> Table 4-1   Comparison of array and linked list efficiencies </p> Array Linked List Storage method Contiguous memory space Scattered memory space Capacity expansion Immutable length Flexible expansion Memory efficiency Elements occupy less memory, but space may be wasted Elements occupy more memory Accessing an element \\(O(1)\\) \\(O(n)\\) Adding an element \\(O(n)\\) \\(O(1)\\) Removing an element \\(O(n)\\) \\(O(1)\\)","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423-common-types-of-linked-lists","level":2,"title":"4.2.3   Common Types of Linked Lists","text":"<p>As shown in Figure 4-8, there are three common types of linked lists:</p> <ul> <li>Singly linked list: This is the ordinary linked list introduced earlier. The nodes of a singly linked list contain a value and a reference to the next node. We call the first node the head node and the last node the tail node, which points to null <code>None</code>.</li> <li>Circular linked list: If we make the tail node of a singly linked list point to the head node (connecting the tail to the head), we get a circular linked list. In a circular linked list, any node can be viewed as the head node.</li> <li>Doubly linked list: Compared to a singly linked list, a doubly linked list records references in both directions. The node definition of a doubly linked list includes references to both the successor node (next node) and the predecessor node (previous node). Compared to a singly linked list, a doubly linked list is more flexible and can traverse the linked list in both directions, but it also requires more memory space.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Doubly linked list node class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.next: ListNode | None = None  # Reference to the successor node\n        self.prev: ListNode | None = None  # Reference to the predecessor node\n</code></pre> <pre><code>/* Doubly linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the successor node\n    ListNode *prev;  // Pointer to the predecessor node\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Constructor\n};\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the successor node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(int x) { val = x; }  // Constructor\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;    // Node value\n    ListNode next;  // Reference to the successor node\n    ListNode prev;  // Reference to the predecessor node\n}\n</code></pre> <pre><code>/* Doubly linked list node structure */\ntype DoublyListNode struct {\n    Val  int             // Node value\n    Next *DoublyListNode // Pointer to the successor node\n    Prev *DoublyListNode // Pointer to the predecessor node\n}\n\n// NewDoublyListNode Initialization\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the successor node\n    var prev: ListNode? // Reference to the predecessor node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode? next;  // Reference to the successor node\n    ListNode? prev;  // Reference to the predecessor node\n    ListNode(this.val, [this.next, this.prev]);  // Constructor\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Doubly linked list node type */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the successor node\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Pointer to the predecessor node\n}\n\n/* Constructor */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* Doubly linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the successor node\n    struct ListNode *prev; // Pointer to the predecessor node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Doubly linked list node class */\n// Constructor\nclass ListNode(x: Int) {\n    val _val: Int = x           // Node value\n    val next: ListNode? = null  // Reference to the successor node\n    val prev: ListNode? = null  // Reference to the predecessor node\n}\n</code></pre> <pre><code># Doubly linked list node class\nclass ListNode\n  attr_accessor :val    # Node value\n  attr_accessor :next   # Reference to the successor node\n  attr_accessor :prev   # Reference to the predecessor node\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> Figure 4-8   Common types of linked lists </p>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424-typical-applications-of-linked-lists","level":2,"title":"4.2.4   Typical Applications of Linked Lists","text":"<p>Singly linked lists are commonly used to implement stacks, queues, hash tables, and graphs.</p> <ul> <li>Stacks and queues: When insertion and deletion operations both occur at one end of the linked list, it exhibits last-in-first-out characteristics, corresponding to a stack. When insertion operations occur at one end of the linked list and deletion operations occur at the other end, it exhibits first-in-first-out characteristics, corresponding to a queue.</li> <li>Hash tables: Separate chaining is one of the mainstream solutions for resolving hash collisions. In this approach, all colliding elements are placed in a linked list.</li> <li>Graphs: An adjacency list is a common way to represent a graph, where each vertex in the graph is associated with a linked list, and each element in the linked list represents another vertex connected to that vertex.</li> </ul> <p>Doubly linked lists are commonly used in scenarios where quick access to the previous and next elements is needed.</p> <ul> <li>Advanced data structures: For example, in red-black trees and B-trees, we need to access the parent node of a node, which can be achieved by saving a reference to the parent node in the node, similar to a doubly linked list.</li> <li>Browser history: In web browsers, when a user clicks the forward or backward button, the browser needs to know the previous and next web pages the user visited. The characteristics of doubly linked lists make this operation simple.</li> <li>LRU algorithm: In cache eviction (LRU) algorithms, we need to quickly find the least recently used data and support quick addition and deletion of nodes. Using a doubly linked list is very suitable for this.</li> </ul> <p>Circular linked lists are commonly used in scenarios that require periodic operations, such as operating system resource scheduling.</p> <ul> <li>Round-robin scheduling algorithm: In operating systems, round-robin scheduling is a common CPU scheduling algorithm that needs to cycle through a set of processes. Each process is assigned a time slice, and when the time slice expires, the CPU switches to the next process. This cyclic operation can be implemented using a circular linked list.</li> <li>Data buffers: In some data buffer implementations, circular linked lists may also be used. For example, in audio and video players, the data stream may be divided into multiple buffer blocks and placed in a circular linked list to achieve seamless playback.</li> </ul>","path":["Chapter 4. Array and Linked List","4.2 &nbsp; Linked List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   List","text":"<p>A list is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, insertion, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays.</p> <ul> <li>A linked list can naturally be viewed as a list, supporting element insertion, deletion, search, and modification operations, and can flexibly expand dynamically.</li> <li>An array also supports element insertion, deletion, search, and modification, but since its length is immutable, it can only be viewed as a list with length limitations.</li> </ul> <p>When implementing lists using arrays, the immutable length property reduces the practicality of the list. This is because we usually cannot determine in advance how much data we need to store, making it difficult to choose an appropriate list length. If the length is too small, it may fail to meet usage requirements; if the length is too large, it will waste memory space.</p> <p>To solve this problem, we can use a dynamic array to implement a list. It inherits all the advantages of arrays and can dynamically expand during program execution.</p> <p>In fact, the lists provided in the standard libraries of many programming languages are implemented based on dynamic arrays, such as <code>list</code> in Python, <code>ArrayList</code> in Java, <code>vector</code> in C++, and <code>List</code> in C#. In the following discussion, we will treat \"list\" and \"dynamic array\" as equivalent concepts.</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431-common-list-operations","level":2,"title":"4.3.1   Common List Operations","text":"","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1-initialize-a-list","level":3,"title":"1.   Initialize a List","text":"<p>We typically use two initialization methods: \"without initial values\" and \"with initial values\":</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Initialize a list\n# Without initial values\nnums1: list[int] = []\n# With initial values\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* Initialize a list */\n// Note that vector in C++ is equivalent to nums as described in this article\n// Without initial values\nvector&lt;int&gt; nums1;\n// With initial values\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// With initial values (note that array elements should use the wrapper class Integer[] instead of int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;int&gt; nums1 = [];\n// With initial values\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* Initialize a list */\n// Without initial values\nnums1 := []int{}\n// With initial values\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* Initialize a list */\n// Without initial values\nlet nums1: [Int] = []\n// With initial values\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* Initialize a list */\n// Without initial values\nconst nums1 = [];\n// With initial values\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* Initialize a list */\n// Without initial values\nconst nums1: number[] = [];\n// With initial values\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* Initialize a list */\n// Without initial values\nList&lt;int&gt; nums1 = [];\n// With initial values\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* Initialize a list */\n// Without initial values\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// With initial values\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Initialize a list */\n// Without initial values\nvar nums1 = listOf&lt;Int&gt;()\n// With initial values\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># Initialize a list\n# Without initial values\nnums1 = []\n# With initial values\nnums = [1, 3, 2, 5, 4]\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2-access-elements","level":3,"title":"2.   Access Elements","text":"<p>Since a list is essentially an array, we can access and update elements in \\(O(1)\\) time complexity, which is very efficient.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Access an element\nnum: int = nums[1]  # Access element at index 1\n\n# Update an element\nnums[1] = 0    # Update element at index 1 to 0\n</code></pre> list.cpp<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.java<pre><code>/* Access an element */\nint num = nums.get(1);  // Access element at index 1\n\n/* Update an element */\nnums.set(1, 0);  // Update element at index 1 to 0\n</code></pre> list.cs<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list_test.go<pre><code>/* Access an element */\nnum := nums[1]  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0     // Update element at index 1 to 0\n</code></pre> list.swift<pre><code>/* Access an element */\nlet num = nums[1] // Access element at index 1\n\n/* Update an element */\nnums[1] = 0 // Update element at index 1 to 0\n</code></pre> list.js<pre><code>/* Access an element */\nconst num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.ts<pre><code>/* Access an element */\nconst num: number = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.dart<pre><code>/* Access an element */\nint num = nums[1];  // Access element at index 1\n\n/* Update an element */\nnums[1] = 0;  // Update element at index 1 to 0\n</code></pre> list.rs<pre><code>/* Access an element */\nlet num: i32 = nums[1];  // Access element at index 1\n/* Update an element */\nnums[1] = 0;             // Update element at index 1 to 0\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Access an element */\nval num = nums[1]       // Access element at index 1\n/* Update an element */\nnums[1] = 0             // Update element at index 1 to 0\n</code></pre> list.rb<pre><code># Access an element\nnum = nums[1] # Access element at index 1\n# Update an element\nnums[1] = 0 # Update element at index 1 to 0\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3-insert-and-delete-elements","level":3,"title":"3.   Insert and Delete Elements","text":"<p>Compared to arrays, lists can freely add and delete elements. Adding an element at the end of a list has a time complexity of \\(O(1)\\), but inserting and deleting elements still have the same efficiency as arrays, with a time complexity of \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Clear the list\nnums.clear()\n\n# Add elements at the end\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Insert an element in the middle\nnums.insert(3, 6)  # Insert number 6 at index 3\n\n# Delete an element\nnums.pop(3)        # Delete element at index 3\n</code></pre> list.cpp<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Insert an element in the middle */\nnums.insert(nums.begin() + 3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.erase(nums.begin() + 3);      // Delete element at index 3\n</code></pre> list.java<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);  // Delete element at index 3\n</code></pre> list.cs<pre><code>/* Clear the list */\nnums.Clear();\n\n/* Add elements at the end */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Insert an element in the middle */\nnums.Insert(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.RemoveAt(3);  // Delete element at index 3\n</code></pre> list_test.go<pre><code>/* Clear the list */\nnums = nil\n\n/* Add elements at the end */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Insert an element in the middle */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Insert number 6 at index 3\n\n/* Delete an element */\nnums = append(nums[:3], nums[4:]...) // Delete element at index 3\n</code></pre> list.swift<pre><code>/* Clear the list */\nnums.removeAll()\n\n/* Add elements at the end */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Insert an element in the middle */\nnums.insert(6, at: 3) // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(at: 3) // Delete element at index 3\n</code></pre> list.js<pre><code>/* Clear the list */\nnums.length = 0;\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.splice(3, 0, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.splice(3, 1);  // Delete element at index 3\n</code></pre> list.ts<pre><code>/* Clear the list */\nnums.length = 0;\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.splice(3, 0, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.splice(3, 1);  // Delete element at index 3\n</code></pre> list.dart<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.insert(3, 6); // Insert number 6 at index 3\n\n/* Delete an element */\nnums.removeAt(3); // Delete element at index 3\n</code></pre> list.rs<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert an element in the middle */\nnums.insert(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);    // Delete element at index 3\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Clear the list */\nnums.clear();\n\n/* Add elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert an element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Delete an element */\nnums.remove(3);  // Delete element at index 3\n</code></pre> list.rb<pre><code># Clear the list\nnums.clear\n\n# Add elements at the end\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# Insert an element in the middle\nnums.insert(3, 6) # Insert number 6 at index 3\n\n# Delete an element\nnums.delete_at(3) # Delete element at index 3\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4-traverse-a-list","level":3,"title":"4.   Traverse a List","text":"<p>Like arrays, lists can be traversed by index or by directly iterating through elements.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Traverse the list by index\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Traverse list elements directly\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Traverse list elements directly */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* Traverse the list by index */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* Traverse the list by index */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* Traverse the list by index */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* Traverse the list by index */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* Traverse the list by index */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Traverse list elements directly */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// Traverse the list by index\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Traverse list elements directly\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Traverse the list by index */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* Traverse list elements directly */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># Traverse the list by index\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# Traverse list elements directly\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5-concatenate-lists","level":3,"title":"5.   Concatenate Lists","text":"<p>Given a new list <code>nums1</code>, we can concatenate it to the end of the original list.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Concatenate two lists\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Concatenate list nums1 to the end of nums\n</code></pre> list.cpp<pre><code>/* Concatenate two lists */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// Concatenate list nums1 to the end of nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* Concatenate two lists */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.cs<pre><code>/* Concatenate two lists */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list_test.go<pre><code>/* Concatenate two lists */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Concatenate list nums1 to the end of nums\n</code></pre> list.swift<pre><code>/* Concatenate two lists */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Concatenate list nums1 to the end of nums\n</code></pre> list.js<pre><code>/* Concatenate two lists */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.ts<pre><code>/* Concatenate two lists */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.dart<pre><code>/* Concatenate two lists */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Concatenate list nums1 to the end of nums\n</code></pre> list.rs<pre><code>/* Concatenate two lists */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Concatenate two lists */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // Concatenate list nums1 to the end of nums\n</code></pre> list.rb<pre><code># Concatenate two lists\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6-sort-a-list","level":3,"title":"6.   Sort a List","text":"<p>After sorting a list, we can use \"binary search\" and \"two-pointer\" algorithms, which are frequently tested in array algorithm problems.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Sort a list\nnums.sort()  # After sorting, list elements are arranged from smallest to largest\n</code></pre> list.cpp<pre><code>/* Sort a list */\nsort(nums.begin(), nums.end());  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.java<pre><code>/* Sort a list */\nCollections.sort(nums);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.cs<pre><code>/* Sort a list */\nnums.Sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list_test.go<pre><code>/* Sort a list */\nsort.Ints(nums)  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.swift<pre><code>/* Sort a list */\nnums.sort() // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.js<pre><code>/* Sort a list */\nnums.sort((a, b) =&gt; a - b);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.ts<pre><code>/* Sort a list */\nnums.sort((a, b) =&gt; a - b);  // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.dart<pre><code>/* Sort a list */\nnums.sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.rs<pre><code>/* Sort a list */\nnums.sort(); // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.c<pre><code>// C does not provide built-in dynamic arrays\n</code></pre> list.kt<pre><code>/* Sort a list */\nnums.sort() // After sorting, list elements are arranged from smallest to largest\n</code></pre> list.rb<pre><code># Sort a list\nnums = nums.sort { |a, b| a &lt;=&gt; b } # After sorting, list elements are arranged from smallest to largest\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432-list-implementation","level":2,"title":"4.3.2   List Implementation","text":"<p>Many programming languages have built-in lists, such as Java, C++, and Python. Their implementations are quite complex, and the parameters are carefully considered, such as initial capacity, expansion multiples, and so on. Interested readers can consult the source code to learn more.</p> <p>To deepen our understanding of how lists work, we attempt to implement a simple list with three key design considerations:</p> <ul> <li>Initial capacity: Select a reasonable initial capacity for the underlying array. In this example, we choose 10 as the initial capacity.</li> <li>Size tracking: Declare a variable <code>size</code> to record the current number of elements in the list and update it in real-time as elements are inserted and deleted. Based on this variable, we can locate the end of the list and determine whether expansion is needed.</li> <li>Expansion mechanism: When the list capacity is full upon inserting an element, we need to expand. We create a larger array based on the expansion multiple and then move all elements from the current array to the new array in order. In this example, we specify that the array should be expanded to 2 times its previous size each time.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"List class\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._capacity: int = 10  # List capacity\n        self._arr: list[int] = [0] * self._capacity  # Array (stores list elements)\n        self._size: int = 0  # List length (current number of elements)\n        self._extend_ratio: int = 2  # Multiple by which the list capacity is extended each time\n\n    def size(self) -&gt; int:\n        \"\"\"Get list length (current number of elements)\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get list capacity\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"Access element\"\"\"\n        # If the index is out of bounds, throw an exception, as below\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"Update element\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"Add element at the end\"\"\"\n        # When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"Insert element in the middle\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        # When the number of elements exceeds capacity, trigger the extension mechanism\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # Move all elements at and after index index backward by one position\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # Update the number of elements\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"Remove element\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"Index out of bounds\")\n        num = self._arr[index]\n        # Move all elements after index index forward by one position\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # Update the number of elements\n        self._size -= 1\n        # Return the removed element\n        return num\n\n    def extend_capacity(self):\n        \"\"\"Extend list capacity\"\"\"\n        # Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # Update list capacity\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return list with valid length\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* List class */\nclass MyList {\n  private:\n    int *arr;             // Array (stores list elements)\n    int arrCapacity = 10; // List capacity\n    int arrSize = 0;      // List length (current number of elements)\n    int extendRatio = 2;   // Multiple by which the list capacity is extended each time\n\n  public:\n    /* Constructor */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Destructor */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* Get list length (current number of elements)*/\n    int size() {\n        return arrSize;\n    }\n\n    /* Get list capacity */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* Update element */\n    int get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    void add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Sort list */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size() == capacity())\n            extendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Remove element */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"Index out of bounds\");\n        int num = arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        arrSize--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    void extendCapacity() {\n        // Create a new array with length extendRatio times the original array\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // Copy all elements from the original array to the new array\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // Free memory\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* Convert list to Vector for printing */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* List class */\nclass MyList {\n    private int[] arr; // Array (stores list elements)\n    private int capacity = 10; // List capacity\n    private int size = 0; // List length (current number of elements)\n    private int extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* Get list length (current number of elements) */\n    public int size() {\n        return size;\n    }\n\n    /* Get list capacity */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* Update element */\n    public int get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public void add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // Update the number of elements\n        size++;\n    }\n\n    /* Sort list */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        size++;\n    }\n\n    /* Remove element */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"Index out of bounds\");\n        int num = arr[index];\n        // Move all elements after index forward by one position\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public void extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // Add elements at the end\n        capacity = arr.length;\n    }\n\n    /* Convert list to array */\n    public int[] toArray() {\n        int size = size();\n        // Elements enqueue\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* List class */\nclass MyList {\n    private int[] arr;           // Array (stores list elements)\n    private int arrCapacity = 10;    // List capacity\n    private int arrSize = 0;         // List length (current number of elements)\n    private readonly int extendRatio = 2;  // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Get list length (current number of elements) */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* Get list capacity */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* Update element */\n    public int Get(int index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        return arr[index];\n    }\n\n    /* Add elements at the end */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public void Add(int num) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Sort list */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // Move all elements after index index forward by one position\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Update the number of elements\n        arrSize++;\n    }\n\n    /* Remove element */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"Index out of bounds\");\n        int num = arr[index];\n        // Move all elements after index forward by one position\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Update the number of elements\n        arrSize--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public void ExtendCapacity() {\n        // Create new array of length arrCapacity * extendRatio and copy original array to new array\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // Add elements at the end\n        arrCapacity = arr.Length;\n    }\n\n    /* Convert list to array */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* List class */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* Constructor */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // List capacity\n        arr:         make([]int, 10), // Array (stores list elements)\n        arrSize:     0,               // List length (current number of elements)\n        extendRatio: 2,               // Multiple by which the list capacity is extended each time\n    }\n}\n\n/* Get list length (current number of elements) */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* Get list capacity */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* Update element */\nfunc (l *myList) get(index int) int {\n    // If the index is out of bounds, throw an exception, as below\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    return l.arr[index]\n}\n\n/* Add elements at the end */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    l.arr[index] = num\n}\n\n/* Direct traversal of list elements */\nfunc (l *myList) add(num int) {\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // Update the number of elements\n    l.arrSize++\n}\n\n/* Sort list */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // Move all elements after index index forward by one position\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // Update the number of elements\n    l.arrSize++\n}\n\n/* Remove element */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"Index out of bounds\")\n    }\n    num := l.arr[index]\n    // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // Update the number of elements\n    l.arrSize--\n    // Return the removed element\n    return num\n}\n\n/* Driver Code */\nfunc (l *myList) extendCapacity() {\n    // Create a new array with length extendRatio times the original array and copy the original array to the new array\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // Add elements at the end\n    l.arrCapacity = len(l.arr)\n}\n\n/* Return list with valid length */\nfunc (l *myList) toArray() []int {\n    // Elements enqueue\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* List class */\nclass MyList {\n    private var arr: [Int] // Array (stores list elements)\n    private var _capacity: Int // List capacity\n    private var _size: Int // List length (current number of elements)\n    private let extendRatio: Int // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* Get list length (current number of elements) */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Get list capacity */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* Update element */\n    func get(index: Int) -&gt; Int {\n        // Throw error if index out of bounds, same below\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        return arr[index]\n    }\n\n    /* Add elements at the end */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        arr[index] = num\n    }\n\n    /* Direct traversal of list elements */\n    func add(num: Int) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // Update the number of elements\n        _size += 1\n    }\n\n    /* Sort list */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // Move all elements after index index forward by one position\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // Update the number of elements\n        _size += 1\n    }\n\n    /* Remove element */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"Index out of bounds\")\n        }\n        let num = arr[index]\n        // Move all elements after index forward by one position\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // Update the number of elements\n        _size -= 1\n        // Return the removed element\n        return num\n    }\n\n    /* Driver Code */\n    func extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // Add elements at the end\n        _capacity = arr.count\n    }\n\n    /* Convert list to array */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* List class */\nclass MyList {\n    #arr = new Array(); // Array (stores list elements)\n    #capacity = 10; // List capacity\n    #size = 0; // List length (current number of elements)\n    #extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* Get list length (current number of elements) */\n    size() {\n        return this.#size;\n    }\n\n    /* Get list capacity */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* Update element */\n    get(index) {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        return this.#arr[index];\n    }\n\n    /* Add elements at the end */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        this.#arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    add(num) {\n        // If length equals capacity, need to expand\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Add new element to end of list\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* Sort list */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Move all elements after index index forward by one position\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // Update the number of elements\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* Remove element */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('Index out of bounds');\n        let num = this.#arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // Update the number of elements\n        this.#size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // Add elements at the end\n        this.#capacity = this.#arr.length;\n    }\n\n    /* Convert list to array */\n    toArray() {\n        let size = this.size();\n        // Elements enqueue\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* List class */\nclass MyList {\n    private arr: Array&lt;number&gt;; // Array (stores list elements)\n    private _capacity: number = 10; // List capacity\n    private _size: number = 0; // List length (current number of elements)\n    private extendRatio: number = 2; // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* Get list length (current number of elements) */\n    public size(): number {\n        return this._size;\n    }\n\n    /* Get list capacity */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* Update element */\n    public get(index: number): number {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        return this.arr[index];\n    }\n\n    /* Add elements at the end */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        this.arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    public add(num: number): void {\n        // If length equals capacity, need to expand\n        if (this._size === this._capacity) this.extendCapacity();\n        // Add new element to end of list\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* Sort list */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // Move all elements after index index forward by one position\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // Update the number of elements\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* Remove element */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('Index out of bounds');\n        let num = this.arr[index];\n        // Move all elements after index forward by one position\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // Update the number of elements\n        this._size--;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    public extendCapacity(): void {\n        // Create new array of length size and copy original array to new array\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // Add elements at the end\n        this._capacity = this.arr.length;\n    }\n\n    /* Convert list to array */\n    public toArray(): number[] {\n        let size = this.size();\n        // Elements enqueue\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* List class */\nclass MyList {\n  late List&lt;int&gt; _arr; // Array (stores list elements)\n  int _capacity = 10; // List capacity\n  int _size = 0; // List length (current number of elements)\n  int _extendRatio = 2; // Multiple by which the list capacity is extended each time\n\n  /* Constructor */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* Get list length (current number of elements) */\n  int size() =&gt; _size;\n\n  /* Get list capacity */\n  int capacity() =&gt; _capacity;\n\n  /* Update element */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    return _arr[index];\n  }\n\n  /* Add elements at the end */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    _arr[index] = _num;\n  }\n\n  /* Direct traversal of list elements */\n  void add(int _num) {\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // Update the number of elements\n    _size++;\n  }\n\n  /* Sort list */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (_size == _capacity) extendCapacity();\n    // Move all elements after index index forward by one position\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // Update the number of elements\n    _size++;\n  }\n\n  /* Remove element */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('Index out of bounds');\n    int _num = _arr[index];\n    // Move all elements after index forward by one position\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // Update the number of elements\n    _size--;\n    // Return the removed element\n    return _num;\n  }\n\n  /* Driver Code */\n  void extendCapacity() {\n    // Create new array with length _extendRatio times original array\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // Copy original array to new array\n    List.copyRange(_newNums, 0, _arr);\n    // Update _arr reference\n    _arr = _newNums;\n    // Add elements at the end\n    _capacity = _arr.length;\n  }\n\n  /* Convert list to array */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* List class */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // Array (stores list elements)\n    capacity: usize,     // List capacity\n    size: usize,         // List length (current number of elements)\n    extend_ratio: usize, // Multiple by which the list capacity is extended each time\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* Constructor */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* Get list length (current number of elements) */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* Get list capacity */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* Update element */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // If the index is out of bounds, throw an exception, as below\n        if index &gt;= self.size {\n            panic!(\"Index out of bounds\")\n        };\n        return self.arr[index];\n    }\n\n    /* Add elements at the end */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"Index out of bounds\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* Direct traversal of list elements */\n    pub fn add(&amp;mut self, num: i32) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // Update the number of elements\n        self.size += 1;\n    }\n\n    /* Sort list */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"Index out of bounds\")\n        };\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // Move all elements after index index forward by one position\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // Update the number of elements\n        self.size += 1;\n    }\n\n    /* Remove element */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"Index out of bounds\")\n        };\n        let num = self.arr[index];\n        // Create a new array with length _extend_ratio times the original array, and copy the original array to the new array\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // Update the number of elements\n        self.size -= 1;\n        // Return the removed element\n        return num;\n    }\n\n    /* Driver Code */\n    pub fn extend_capacity(&amp;mut self) {\n        // Create new array with length extend_ratio times original, copy original array to new array\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // Add elements at the end\n        self.capacity = new_capacity;\n    }\n\n    /* Convert list to array */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // Elements enqueue\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* List class */\ntypedef struct {\n    int *arr;        // Array (stores list elements)\n    int capacity;    // List capacity\n    int size;        // List size\n    int extendRatio; // List expansion multiplier\n} MyList;\n\n/* Constructor */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* Destructor */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* Get list length */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* Get list capacity */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* Update element */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* Add elements at the end */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* Direct traversal of list elements */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Expand capacity\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* Sort list */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // When the number of elements exceeds capacity, trigger the extension mechanism\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Expand capacity\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* Remove element */\n// Note: stdio.h occupies the remove keyword\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* Driver Code */\nvoid extendCapacity(MyList *nums) {\n    // Allocate space first\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // Copy old data to new data\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // Free old data\n    free(temp);\n\n    // Update new data\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* Convert list to Array for printing */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* List class */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // Array (stores list elements)\n    private var capacity: Int = 10 // List capacity\n    private var size: Int = 0 // List length (current number of elements)\n    private var extendRatio: Int = 2 // Multiple by which the list capacity is extended each time\n\n    /* Constructor */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* Get list length (current number of elements) */\n    fun size(): Int {\n        return size\n    }\n\n    /* Get list capacity */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* Update element */\n    fun get(index: Int): Int {\n        // If the index is out of bounds, throw an exception, as below\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        return arr[index]\n    }\n\n    /* Add elements at the end */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        arr[index] = num\n    }\n\n    /* Direct traversal of list elements */\n    fun add(num: Int) {\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // Update the number of elements\n        size++\n    }\n\n    /* Sort list */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        // When the number of elements exceeds capacity, trigger the extension mechanism\n        if (size == capacity())\n            extendCapacity()\n        // Move all elements after index index forward by one position\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // Update the number of elements\n        size++\n    }\n\n    /* Remove element */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"Index out of bounds\")\n        val num = arr[index]\n        // Move all elements after index forward by one position\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // Update the number of elements\n        size--\n        // Return the removed element\n        return num\n    }\n\n    /* Driver Code */\n    fun extendCapacity() {\n        // Create a new array with length extendRatio times the original array and copy the original array to the new array\n        arr = arr.copyOf(capacity() * extendRatio)\n        // Add elements at the end\n        capacity = arr.size\n    }\n\n    /* Convert list to array */\n    fun toArray(): IntArray {\n        val size = size()\n        // Elements enqueue\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### List class ###\nclass MyList\n  attr_reader :size       # Get list length (current number of elements)\n  attr_reader :capacity   # Get list capacity\n\n  ### Constructor ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### Access element ###\n  def get(index)\n    # If the index is out of bounds, throw an exception, as below\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### Access element ###\n  def set(index, num)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### Add element at end ###\n  def add(num)\n    # When the number of elements exceeds capacity, trigger the extension mechanism\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # Update the number of elements\n    @size += 1\n  end\n\n  ### Insert element in middle ###\n  def insert(index, num)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n\n    # When the number of elements exceeds capacity, trigger the extension mechanism\n    extend_capacity if size == capacity\n\n    # Move all elements after index index forward by one position\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # Update the number of elements\n    @size += 1\n  end\n\n  ### Delete element ###\n  def remove(index)\n    raise IndexError, \"Index out of bounds\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # Move all elements after index forward by one position\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # Update the number of elements\n    @size -= 1\n\n    # Return the removed element\n    num\n  end\n\n  ### Expand list capacity ###\n  def extend_capacity\n    # Create new array with length extend_ratio times original, copy original array to new array\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # Add elements at the end\n    @capacity = arr.length\n  end\n\n  ### Convert list to array ###\n  def to_array\n    sz = size\n    # Elements enqueue\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre>","path":["Chapter 4. Array and Linked List","4.3 &nbsp; List"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   Random-Access Memory and Cache *","text":"<p>In the first two sections of this chapter, we explored arrays and linked lists, two fundamental and important data structures that represent \"contiguous storage\" and \"distributed storage\" as two physical structures, respectively.</p> <p>In fact, physical structure largely determines the efficiency with which programs utilize memory and cache, which in turn affects the overall performance of algorithmic programs.</p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441-computer-storage-devices","level":2,"title":"4.4.1   Computer Storage Devices","text":"<p>Computers include three types of storage devices: hard disk, random-access memory (RAM), and cache memory. The following table shows their different roles and performance characteristics in a computer system.</p> <p> Table 4-2   Computer Storage Devices </p> Hard Disk RAM Cache Purpose Long-term storage of data, including operating systems, programs, and files Temporary storage of currently running programs and data being processed Storage of frequently accessed data and instructions to reduce CPU's accesses to memory Volatility Data is not lost after power-off Data is lost after power-off Data is lost after power-off Capacity Large, on the order of terabytes (TB) Small, on the order of gigabytes (GB) Very small, on the order of megabytes (MB) Speed Slow, hundreds to thousands of MB/s Fast, tens of GB/s Very fast, tens to hundreds of GB/s Cost (USD/GB) Inexpensive, fractions of a dollar to a few dollars per GB Expensive, tens to hundreds of dollars per GB Very expensive, priced as part of the CPU package <p>We can imagine the computer storage system as a pyramid structure as shown in the diagram below. Storage devices closer to the top of the pyramid are faster, have smaller capacity, and are more expensive. This multi-layered design is not by accident, but rather the result of careful consideration by computer scientists and engineers.</p> <ul> <li>Hard disk cannot be easily replaced by RAM. First, data in memory is lost after power-off, making it unsuitable for long-term data storage. Second, memory is tens of times more expensive than hard disk, which makes it difficult to popularize in the consumer market.</li> <li>Cache cannot simultaneously achieve large capacity and high speed. As the capacity of L1, L2, and L3 caches increases, their physical size becomes larger, and the physical distance between them and the CPU core increases, resulting in longer data transmission time and higher element access latency. With current technology, the multi-layered cache structure represents the best balance point between capacity, speed, and cost.</li> </ul> <p></p> <p> Figure 4-9   Computer Storage System </p> <p>Tip</p> <p>The storage hierarchy of computers embodies a delicate balance among speed, capacity, and cost. In fact, such trade-offs are common across all industrial fields, requiring us to find the optimal balance point between different advantages and constraints.</p> <p>In summary, hard disk is used for long-term storage of large amounts of data, RAM is used for temporary storage of data being processed during program execution, and cache is used for storage of frequently accessed data and instructions, to improve program execution efficiency. The three work together to ensure efficient operation of the computer system.</p> <p>As shown in the diagram below, during program execution, data is read from the hard disk into RAM for CPU computation. Cache can be viewed as part of the CPU, it intelligently loads data from RAM, providing the CPU with high-speed data reading, thereby significantly improving program execution efficiency and reducing reliance on slower RAM.</p> <p></p> <p> Figure 4-10   Data Flow Among Hard Disk, RAM, and Cache </p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442-memory-efficiency-of-data-structures","level":2,"title":"4.4.2   Memory Efficiency of Data Structures","text":"<p>In terms of memory space utilization, arrays and linked lists each have advantages and limitations.</p> <p>On one hand, memory is limited, and the same memory cannot be shared by multiple programs, so we hope data structures can utilize space as efficiently as possible. Array elements are tightly packed and do not require additional space to store references (pointers) between linked list nodes, thus having higher space efficiency. However, arrays need to allocate sufficient contiguous memory space at once, which may lead to memory waste, and array expansion requires additional time and space costs. In comparison, linked lists perform dynamic memory allocation and deallocation on a \"node\" basis, providing greater flexibility.</p> <p>On the other hand, during program execution, as memory is repeatedly allocated and freed, the degree of fragmentation of free memory becomes increasingly severe, leading to reduced memory utilization efficiency. Arrays, due to their contiguous storage approach, are relatively less prone to memory fragmentation. Conversely, linked list elements are distributed in storage, and frequent insertion and deletion operations are more likely to cause memory fragmentation.</p>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443-cache-efficiency-of-data-structures","level":2,"title":"4.4.3   Cache Efficiency of Data Structures","text":"<p>Although cache has much smaller space capacity than memory, it is much faster than memory and plays a crucial role in program execution speed. Since cache capacity is limited and can only store a small portion of frequently accessed data, when the CPU attempts to access data that is not in the cache, a cache miss occurs, and the CPU must load the required data from the slower memory.</p> <p>Clearly, the fewer \"cache misses,\" the higher the efficiency of CPU data reads and writes, and the better the program performance. We call the proportion of data that the CPU successfully obtains from the cache the cache hit rate, a metric typically used to measure cache efficiency.</p> <p>To achieve the highest efficiency possible, cache employs the following data loading mechanisms.</p> <ul> <li>Cache lines: The cache does not store and load data on a byte-by-byte basis, but rather as cache lines. Compared to byte-by-byte transmission, cache line transmission is more efficient.</li> <li>Prefetching mechanism: The processor attempts to predict data access patterns (e.g., sequential access, fixed-stride jumping access, etc.) and loads data into the cache according to specific patterns, thereby improving hit rate.</li> <li>Spatial locality: If a piece of data is accessed, nearby data may also be accessed in the near future. Therefore, when the cache loads a particular piece of data, it also loads nearby data to improve hit rate.</li> <li>Temporal locality: If a piece of data is accessed, it is likely to be accessed again in the near future. Cache leverages this principle by retaining recently accessed data to improve hit rate.</li> </ul> <p>In fact, arrays and linked lists have different efficiencies in utilizing cache, manifested in the following aspects.</p> <ul> <li>Space occupied: Linked list elements occupy more space than array elements, resulting in fewer effective data in the cache.</li> <li>Cache lines: Linked list data are scattered throughout memory, while cache loads \"by lines,\" so the proportion of invalid data loaded is higher.</li> <li>Prefetching mechanism: Arrays have more \"predictable\" data access patterns than linked lists, making it easier for the system to guess which data will be loaded next.</li> <li>Spatial locality: Arrays are stored in centralized memory space, so data near loaded data is more likely to be accessed soon.</li> </ul> <p>Overall, arrays have higher cache hit rates, thus they usually outperform linked lists in operation efficiency. This makes data structures implemented based on arrays more popular when solving algorithmic problems.</p> <p>It is important to note that high cache efficiency does not mean arrays are superior to linked lists in all cases. In practical applications, which data structure to choose should be determined based on specific requirements. For example, both arrays and linked lists can implement the \"stack\" data structure (which will be discussed in detail in the next chapter), but they are suitable for different scenarios.</p> <ul> <li>When solving algorithm problems, we tend to prefer stack implementations based on arrays, because they provide higher operation efficiency and the ability of random access, at the cost of needing to pre-allocate a certain amount of memory space for the array.</li> <li>If the data volume is very large, the dynamic nature is high, and the expected size of the stack is difficult to estimate, then a stack implementation based on linked lists is more suitable. Linked lists can distribute large amounts of data across different parts of memory and avoid the additional overhead produced by array expansion.</li> </ul>","path":["Chapter 4. Array and Linked List","4.4 &nbsp; Random-Access Memory and Cache *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   Summary","text":"","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Arrays and linked lists are two fundamental data structures, representing two different ways data can be stored in computer memory: contiguous memory storage and scattered memory storage. The characteristics of the two complement each other.</li> <li>Arrays support random access and use less memory; however, inserting and deleting elements is inefficient, and the length is immutable after initialization.</li> <li>Linked lists achieve efficient insertion and deletion of nodes by modifying references (pointers), and can flexibly adjust length; however, node access is inefficient and memory consumption is higher. Common linked list types include singly linked lists, circular linked lists, and doubly linked lists.</li> <li>A list is an ordered collection of elements that supports insertion, deletion, search, and modification, typically implemented based on dynamic arrays. It retains the advantages of arrays while allowing flexible adjustment of length.</li> <li>The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space.</li> <li>During program execution, data is primarily stored in memory. Arrays provide higher memory space efficiency, while linked lists offer greater flexibility in memory usage.</li> <li>Caches provide fast data access to the CPU through mechanisms such as cache lines, prefetching, and spatial and temporal locality, significantly improving program execution efficiency.</li> <li>Because arrays have higher cache hit rates, they are generally more efficient than linked lists. When choosing a data structure, appropriate selection should be made based on specific requirements and scenarios.</li> </ul>","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Does storing an array on the stack versus on the heap affect time efficiency and space efficiency?</p> <p>Arrays stored on the stack and on the heap are both stored in contiguous memory space, so data operation efficiency is basically the same. However, the stack and heap have their own characteristics, leading to the following differences.</p> <ol> <li>Allocation and deallocation efficiency: The stack is a relatively small piece of memory, with allocation automatically handled by the compiler; the heap is relatively larger and can be dynamically allocated in code, more prone to fragmentation. Therefore, allocation and deallocation operations on the heap are usually slower than on the stack.</li> <li>Size limitations: Stack memory is relatively small, and the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays.</li> <li>Flexibility: The size of an array on the stack must be determined at compile time, while the size of an array on the heap can be determined dynamically at runtime.</li> </ol> <p>Q: Why do arrays require elements of the same type, while linked lists do not emphasize this requirement?</p> <p>Linked lists are composed of nodes, with nodes connected through references (pointers), and each node can store different types of data, such as <code>int</code>, <code>double</code>, <code>string</code>, <code>object</code>, etc.</p> <p>In contrast, array elements must be of the same type, so that the corresponding element position can be obtained by calculating the offset. For example, if an array contains both <code>int</code> and <code>long</code> types, with individual elements occupying 4 bytes and 8 bytes respectively, then the following formula cannot be used to calculate the offset, because the array contains two different \"element lengths\".</p> <pre><code># Element Memory Address = Array Memory Address (first Element Memory address) + Element Length * Element Index\n</code></pre> <p>Q: After deleting node <code>P</code>, do we need to set <code>P.next</code> to <code>None</code>?</p> <p>It is not necessary to modify <code>P.next</code>. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter <code>P</code>. This means that node <code>P</code> has been removed from the linked list, and it doesn't matter where node <code>P</code> points to at this time—it won't affect the linked list.</p> <p>From a data structures and algorithms perspective (problem-solving), not disconnecting the pointer doesn't matter as long as the program logic is correct. From the perspective of standard libraries, disconnecting is safer and the logic is clearer. If not disconnected, assuming the deleted node is not properly reclaimed, it may affect the memory reclamation of its successor nodes.</p> <p>Q: In a linked list, the time complexity of insertion and deletion operations is \\(O(1)\\). However, both insertion and deletion require \\(O(n)\\) time to find the element; why isn't the time complexity \\(O(n)\\)?</p> <p>If the element is first found and then deleted, the time complexity is indeed \\(O(n)\\). However, the advantage of \\(O(1)\\) insertion and deletion in linked lists can be demonstrated in other applications. For example, a deque is well-suited for linked list implementation, where we maintain pointer variables always pointing to the head and tail nodes, with each insertion and deletion operation being \\(O(1)\\).</p> <p>Q: In the diagram \"Linked List Definition and Storage Methods\", does the light blue pointer node occupy a single memory address, or does it share equally with the node value?</p> <p>This diagram is a qualitative representation; a quantitative representation requires analysis based on the specific situation.</p> <ul> <li>Different types of node values occupy different amounts of space, such as <code>int</code>, <code>long</code>, <code>double</code>, and instance objects, etc.</li> <li>The amount of memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes.</li> </ul> <p>Q: Is appending an element at the end of a list always \\(O(1)\\)?</p> <p>If appending an element exceeds the list length, the list must first be expanded before adding. The system allocates a new block of memory and moves all elements from the original list to it, in which case the time complexity becomes \\(O(n)\\).</p> <p>Q: \"The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space\"—does this space waste refer to the memory occupied by additional variables such as capacity, length, and expansion factor?</p> <p>This space waste mainly has two aspects: on one hand, lists typically set an initial length, which we may not need to fully utilize; on the other hand, to prevent frequent expansion, expansion generally multiplies by a coefficient, such as \\(\\times 1.5\\). As a result, there will be many empty positions that we typically cannot completely fill.</p> <p>Q: In Python, after initializing <code>n = [1, 2, 3]</code>, the addresses of these 3 elements are contiguous, but initializing <code>m = [2, 1, 3]</code> reveals that each element's id is not continuous; rather, they are the same as those in <code>n</code>. Since the addresses of these elements are not contiguous, is <code>m</code> still an array?</p> <p>If we replace list elements with linked list nodes <code>n = [n1, n2, n3, n4, n5]</code>, usually these 5 node objects are also scattered throughout memory. However, given a list index, we can still obtain the node memory address in \\(O(1)\\) time, thereby accessing the corresponding node. This is because the array stores references to nodes, not the nodes themselves.</p> <p>Unlike many languages, numbers in Python are wrapped as objects, and lists store not the numbers themselves, but references to the numbers. Therefore, we find that the same numbers in two arrays have the same id, and the memory addresses of these numbers need not be contiguous.</p> <p>Q: C++ STL has <code>std::list</code> which has already implemented a doubly linked list, but it seems that some algorithm books don't use it directly. Is there a limitation?</p> <p>On one hand, we often prefer to use arrays for implementing algorithms and only use linked lists when necessary, mainly for two reasons.</p> <ul> <li>Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next element), <code>std::list</code> typically consumes more space than <code>std::vector</code>.</li> <li>Cache unfriendliness: Since data is not stored contiguously, <code>std::list</code> has lower cache utilization. In general, <code>std::vector</code> has better performance.</li> </ul> <p>On the other hand, cases where linked lists are necessary mainly involve binary trees and graphs. Stacks and queues usually use the <code>stack</code> and <code>queue</code> provided by the programming language, rather than linked lists.</p> <p>Q: Does the operation <code>res = [[0]] * n</code> create a 2D list where each <code>[0]</code> is independent?</p> <p>No, they are not independent. In this 2D list, all the <code>[0]</code> are actually references to the same object. If we modify one element, we will find that all corresponding elements change accordingly.</p> <p>If we want each <code>[0]</code> in the 2D list to be independent, we can use <code>res = [[0] for _ in range(n)]</code> to achieve this. The principle of this approach is to initialize \\(n\\) independent <code>[0]</code> list objects.</p> <p>Q: Does the operation <code>res = [0] * n</code> create a list where each integer 0 is independent?</p> <p>In this list, all integer 0s are references to the same object. This is because Python uses a caching mechanism for small integers (typically -5 to 256) to maximize object reuse and improve performance.</p> <p>Although they point to the same object, we can still independently modify each element in the list. This is because Python integers are \"immutable objects\". When we modify an element, we are actually switching to a reference of another object, rather than changing the original object itself.</p> <p>However, when list elements are \"mutable objects\" (such as lists, dictionaries, or class instances), modifying an element directly changes the object itself, and all elements referencing that object will have the same change.</p>","path":["Chapter 4. Array and Linked List","4.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"Chapter 13.   Backtracking","text":"<p>Abstract</p> <p>We are like explorers in a maze, and may encounter difficulties on the path forward.</p> <p>The power of backtracking allows us to start over, keep trying, and eventually find the exit leading to light.</p>","path":["Chapter 13. Backtracking","Chapter 13. &nbsp; Backtracking"],"tags":[]},{"location":"chapter_backtracking/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>13.1   Backtracking Algorithm</li> <li>13.2   Permutations Problem</li> <li>13.3   Subset-Sum Problem</li> <li>13.4   N-Queens Problem</li> <li>13.5   Summary</li> </ul>","path":["Chapter 13. Backtracking","Chapter 13. &nbsp; Backtracking"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   Backtracking Algorithm","text":"<p>The backtracking algorithm is a method for solving problems through exhaustive search. Its core idea is to start from an initial state and exhaustively search all possible solutions. When a correct solution is found, it is recorded. This process continues until a solution is found or all possible choices have been tried without finding a solution.</p> <p>The backtracking algorithm typically employs \"depth-first search\" to traverse the solution space. In the \"Binary Tree\" chapter, we mentioned that preorder, inorder, and postorder traversals all belong to depth-first search. Next, we will construct a backtracking problem using preorder traversal to progressively understand how the backtracking algorithm works.</p> <p>Example 1</p> <p>Given a binary tree, search and record all nodes with value \\(7\\), and return a list of these nodes.</p> <p>For this problem, we perform a preorder traversal of the tree and check whether the current node's value is \\(7\\). If it is, we add the node to the result list <code>res</code>. The relevant implementation is shown in the following figure and code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # Record solution\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Record solution\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* Preorder traversal: Example 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Record solution\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* Preorder traversal: Example 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // Record solution\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* Preorder traversal: Example 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // Record solution\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* Preorder traversal: Example 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Record solution\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* Preorder traversal: Example 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Record solution\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // Record solution\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* Preorder traversal: Example 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* Preorder traversal: Example 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Record solution\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* Preorder traversal: Example 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### Pre-order traversal: example 1 ###\ndef pre_order(root)\n  return unless root\n\n  # Record solution\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> <p></p> <p> Figure 13-1   Search for nodes in preorder traversal </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311-attempt-and-backtrack","level":2,"title":"13.1.1   Attempt and Backtrack","text":"<p>The reason it is called a backtracking algorithm is that it employs \"attempt\" and \"backtrack\" strategies when searching the solution space. When the algorithm encounters a state where it cannot continue forward or cannot find a solution that satisfies the constraints, it will undo the previous choice, return to a previous state, and try other possible choices.</p> <p>For Example 1, visiting each node represents an \"attempt\", while skipping over a leaf node or a function <code>return</code> from the parent node represents a \"backtrack\".</p> <p>It is worth noting that backtracking is not limited to function returns alone. To illustrate this, let's extend Example 1 slightly.</p> <p>Example 2</p> <p>In a binary tree, search all nodes with value \\(7\\), and return the paths from the root node to these nodes.</p> <p>Based on the code from Example 1, we need to use a list <code>path</code> to record the visited node path. When we reach a node with value \\(7\\), we copy <code>path</code> and add it to the result list <code>res</code>. After traversal is complete, <code>res</code> contains all the solutions. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 2\"\"\"\n    if root is None:\n        return\n    # Attempt\n    path.append(root)\n    if root.val == 7:\n        # Record solution\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Backtrack\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // Attempt\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // Attempt\n    path.add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Backtrack\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* Preorder traversal: Example 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // Attempt\n    path.Add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Backtrack\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* Preorder traversal: Example 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // Attempt\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Record solution\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // Backtrack\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* Preorder traversal: Example 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Attempt\n    path.append(root)\n    if root.val == 7 {\n        // Record solution\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Backtrack\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* Preorder traversal: Example 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* Preorder traversal: Example 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // Attempt\n  path.add(root);\n  if (root.val == 7) {\n    // Record solution\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Backtrack\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* Preorder traversal: Example 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // Attempt\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Backtrack\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* Preorder traversal: Example 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // Attempt\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Record solution\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* Preorder traversal: Example 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // Attempt\n    path!!.add(root)\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Backtrack\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### Pre-order traversal: example 2 ###\ndef pre_order(root)\n  return unless root\n\n  # Attempt\n  $path &lt;&lt; root\n\n  # Record solution\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Backtrack\n  $path.pop\nend\n</code></pre> <p>In each \"attempt\", we record the path by adding the current node to <code>path</code>; before \"backtracking\", we need to remove the node from <code>path</code>, to restore the state before this attempt.</p> <p>Observing the process shown in the following figure, we can understand attempt and backtrack as \"advance\" and \"undo\", two operations that are the reverse of each other.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 13-2   Attempt and backtrack </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312-pruning","level":2,"title":"13.1.2   Pruning","text":"<p>Complex backtracking problems usually contain one or more constraints. Constraints can typically be used for \"pruning\".</p> <p>Example 3</p> <p>In a binary tree, search all nodes with value \\(7\\) and return the paths from the root node to these nodes, but require that the paths do not contain nodes with value \\(3\\).</p> <p>To satisfy the above constraints, we need to add pruning operations: during the search process, if we encounter a node with value \\(3\\), we return early and do not continue searching. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Preorder traversal: Example 3\"\"\"\n    # Pruning\n    if root is None or root.val == 3:\n        return\n    # Attempt\n    path.append(root)\n    if root.val == 7:\n        # Record solution\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Backtrack\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode *root) {\n    // Pruning\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // Attempt\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Record solution\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode root) {\n    // Pruning\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Attempt\n    path.add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Backtrack\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* Preorder traversal: Example 3 */\nvoid PreOrder(TreeNode? root) {\n    // Pruning\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Attempt\n    path.Add(root);\n    if (root.val == 7) {\n        // Record solution\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Backtrack\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* Preorder traversal: Example 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // Pruning\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // Attempt\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Record solution\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // Backtrack\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* Preorder traversal: Example 3 */\nfunc preOrder(root: TreeNode?) {\n    // Pruning\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // Attempt\n    path.append(root)\n    if root.val == 7 {\n        // Record solution\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Backtrack\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* Preorder traversal: Example 3 */\nfunction preOrder(root, path, res) {\n    // Pruning\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* Preorder traversal: Example 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Pruning\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Attempt\n    path.push(root);\n    if (root.val === 7) {\n        // Record solution\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Backtrack\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // Attempt\n  path.add(root);\n  if (root.val == 7) {\n    // Record solution\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Backtrack\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* Preorder traversal: Example 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // Pruning\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // Attempt\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Record solution\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Backtrack\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* Preorder traversal: Example 3 */\nvoid preOrder(TreeNode *root) {\n    // Pruning\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // Attempt\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Record solution\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Backtrack\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* Preorder traversal: Example 3 */\nfun preOrder(root: TreeNode?) {\n    // Pruning\n    if (root == null || root._val == 3) {\n        return\n    }\n    // Attempt\n    path!!.add(root)\n    if (root._val == 7) {\n        // Record solution\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Backtrack\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### Pre-order traversal: example 3 ###\ndef pre_order(root)\n  # Pruning\n  return if !root || root.val == 3\n\n  # Attempt\n  $path.append(root)\n\n  # Record solution\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Backtrack\n  $path.pop\nend\n</code></pre> <p>\"Pruning\" is a vivid term. As shown in the following figure, during the search process, we \"prune\" search branches that do not satisfy the constraints, avoiding many meaningless attempts and thus improving search efficiency.</p> <p></p> <p> Figure 13-3   Pruning according to constraints </p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313-framework-code","level":2,"title":"13.1.3   Framework Code","text":"<p>Next, we attempt to extract the main framework of backtracking's \"attempt, backtrack, and pruning\", to improve code generality.</p> <p>In the following framework code, <code>state</code> represents the current state of the problem, and <code>choices</code> represents the choices available in the current state:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"Backtracking algorithm framework\"\"\"\n    # Check if it is a solution\n    if is_solution(state):\n        # Record the solution\n        record_solution(state, res)\n        # Stop searching\n        return\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: check if the choice is valid\n        if is_valid(state, choice):\n            # Attempt: make a choice and update the state\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (Choice choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (Choice choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Check if it is a solution\n    if (IsSolution(state)) {\n        // Record the solution\n        RecordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    foreach (Choice choice in choices) {\n        // Pruning: check if the choice is valid\n        if (IsValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // Check if it is a solution\n    if isSolution(state) {\n        // Record the solution\n        recordSolution(state, res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for _, choice := range choices {\n        // Pruning: check if the choice is valid\n        if isValid(state, choice) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // Check if it is a solution\n    if isSolution(state: state) {\n        // Record the solution\n        recordSolution(state: state, res: &amp;res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if isValid(state: state, choice: choice) {\n            // Attempt: make a choice and update the state\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunction backtrack(state, choices, res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (let choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (let choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // Check if it is a solution\n  if (isSolution(state)) {\n    // Record the solution\n    recordSolution(state, res);\n    // Stop searching\n    return;\n  }\n  // Traverse all choices\n  for (Choice choice in choices) {\n    // Pruning: check if the choice is valid\n    if (isValid(state, choice)) {\n      // Attempt: make a choice and update the state\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // Backtrack: undo the choice and restore to the previous state\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // Check if it is a solution\n    if is_solution(state) {\n        // Record the solution\n        record_solution(state, res);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if is_valid(state, choice) {\n            // Attempt: make a choice and update the state\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res, numRes);\n        // Stop searching\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; numChoices; i++) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, &amp;choices[i])) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* Backtracking algorithm framework */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record the solution\n        recordSolution(state, res)\n        // Stop searching\n        return\n    }\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make a choice and update the state\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Backtrack: undo the choice and restore to the previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### Backtracking algorithm framework ###\ndef backtrack(state, choices, res)\n    # Check if it is a solution\n    if is_solution?(state)\n        # Record the solution\n        record_solution(state, res)\n        return\n    end\n\n    # Traverse all choices\n    for choice in choices\n        # Pruning: check if the choice is valid\n        if is_valid?(state, choice)\n            # Attempt: make a choice and update the state\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Backtrack: undo the choice and restore to the previous state\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>Next, we solve Example 3 based on the framework code. The state <code>state</code> is the node traversal path, the choices <code>choices</code> are the left and right child nodes of the current node, and the result <code>res</code> is a list of paths:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"Check if the current state is a solution\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"Record solution\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"Check if the choice is valid under the current state\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Update state\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Restore state\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"Backtracking algorithm: Example 3\"\"\"\n    # Check if it is a solution\n    if is_solution(state):\n        # Record solution\n        record_solution(state, res)\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: check if the choice is valid\n        if is_valid(state, choice):\n            # Attempt: make choice, update state\n            make_choice(state, choice)\n            # Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res)\n            # Backtrack: undo choice, restore to previous state\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* Check if the current state is a solution */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Update state */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* Restore state */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (TreeNode *choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* Check if the current state is a solution */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* Check if the choice is valid under the current state */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* Restore state */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (TreeNode choice : choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* Check if the current state is a solution */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* Record solution */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* Check if the choice is valid under the current state */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* Restore state */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Check if it is a solution\n    if (IsSolution(state)) {\n        // Record solution\n        RecordSolution(state, res);\n    }\n    // Traverse all choices\n    foreach (TreeNode choice in choices) {\n        // Pruning: check if the choice is valid\n        if (IsValid(state, choice)) {\n            // Attempt: make choice, update state\n            MakeChoice(state, choice);\n            // Proceed to the next round of selection\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // Backtrack: undo choice, restore to previous state\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* Check if the current state is a solution */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* Record solution */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* Check if the choice is valid under the current state */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* Update state */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* Restore state */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* Backtracking algorithm: Example 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // Check if it is a solution\n    if isSolution(state) {\n        // Record solution\n        recordSolution(state, res)\n    }\n    // Traverse all choices\n    for _, choice := range *choices {\n        // Pruning: check if the choice is valid\n        if isValid(state, choice) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice)\n            // Proceed to the next round of selection\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* Check if the current state is a solution */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* Record solution */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* Check if the choice is valid under the current state */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* Update state */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* Restore state */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* Backtracking algorithm: Example 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // Check if it is a solution\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: check if the choice is valid\n        if isValid(state: state, choice: choice) {\n            // Attempt: make choice, update state\n            makeChoice(state: &amp;state, choice: choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* Check if the current state is a solution */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Record solution */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* Check if the choice is valid under the current state */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Update state */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* Restore state */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfunction backtrack(state, choices, res) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* Check if the current state is a solution */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Record solution */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* Check if the choice is valid under the current state */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Update state */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* Restore state */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res);\n    }\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice);\n            // Proceed to the next round of selection\n            backtrack(state, [choice.left, choice.right], res);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* Check if the current state is a solution */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Update state */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* Restore state */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // Check if it is a solution\n  if (isSolution(state)) {\n    // Record solution\n    recordSolution(state, res);\n  }\n  // Traverse all choices\n  for (TreeNode? choice in choices) {\n    // Pruning: check if the choice is valid\n    if (isValid(state, choice)) {\n      // Attempt: make choice, update state\n      makeChoice(state, choice);\n      // Proceed to the next round of selection\n      backtrack(state, [choice!.left, choice.right], res);\n      // Backtrack: undo choice, restore to previous state\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* Check if the current state is a solution */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* Record solution */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* Check if the choice is valid under the current state */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* Update state */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* Restore state */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* Backtracking algorithm: Example 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // Check if it is a solution\n    if is_solution(state) {\n        // Record solution\n        record_solution(state, res);\n    }\n    // Traverse all choices\n    for &amp;choice in choices.iter() {\n        // Pruning: check if the choice is valid\n        if is_valid(state, choice) {\n            // Attempt: make choice, update state\n            make_choice(state, choice.unwrap().clone());\n            // Proceed to the next round of selection\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // Backtrack: undo choice, restore to previous state\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* Check if the current state is a solution */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* Record solution */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* Check if the choice is valid under the current state */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Update state */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* Restore state */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* Backtracking algorithm: Example 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // Check if it is a solution\n    if (isSolution()) {\n        // Record solution\n        recordSolution();\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // Pruning: check if the choice is valid\n        if (isValid(choice)) {\n            // Attempt: make choice, update state\n            makeChoice(choice);\n            // Proceed to the next round of selection\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // Backtrack: undo choice, restore to previous state\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* Check if the current state is a solution */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* Record solution */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* Check if the choice is valid under the current state */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* Update state */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* Restore state */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* Backtracking algorithm: Example 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // Check if it is a solution\n    if (isSolution(state)) {\n        // Record solution\n        recordSolution(state, res)\n    }\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: check if the choice is valid\n        if (isValid(state, choice)) {\n            // Attempt: make choice, update state\n            makeChoice(state, choice)\n            // Proceed to the next round of selection\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // Backtrack: undo choice, restore to previous state\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### Check if current state is solution ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### Record solution ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### Check if choice is valid in current state ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### Update state ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### Restore state ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### Backtracking: example 3 ###\ndef backtrack(state, choices, res)\n  # Check if it is a solution\n  record_solution(state, res) if is_solution?(state)\n\n  # Traverse all choices\n  for choice in choices\n    # Pruning: check if the choice is valid\n    if is_valid?(state, choice)\n      # Attempt: make choice, update state\n      make_choice(state, choice)\n      # Proceed to the next round of selection\n      backtrack(state, [choice.left, choice.right], res)\n      # Backtrack: undo choice, restore to previous state\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> <p>As per the problem statement, we should continue searching after finding a node with value \\(7\\). Therefore, we need to remove the <code>return</code> statement after recording the solution. The following figure compares the search process with and without the <code>return</code> statement.</p> <p></p> <p> Figure 13-4   Comparison of search process with and without return statement </p> <p>Compared to code based on preorder traversal, code based on the backtracking algorithm framework appears more verbose, but has better generality. In fact, many backtracking problems can be solved within this framework. We only need to define <code>state</code> and <code>choices</code> for the specific problem and implement each method in the framework.</p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314-common-terminology","level":2,"title":"13.1.4   Common Terminology","text":"<p>To analyze algorithmic problems more clearly, we summarize the meanings of common terminology used in backtracking algorithms and provide corresponding examples from Example 3, as shown in the following table.</p> <p> Table 13-1   Common Backtracking Algorithm Terminology </p> Term Definition Example 3 Solution (solution) A solution is an answer that satisfies the specific conditions of a problem; there may be one or more solutions All paths from root to nodes with value \\(7\\) that satisfy the constraint Constraint (constraint) A constraint is a condition in the problem that limits the feasibility of solutions, typically used for pruning Paths do not contain nodes with value \\(3\\) State (state) State represents the situation of a problem at a certain moment, including the choices already made The currently visited node path, i.e., the <code>path</code> list of nodes Attempt (attempt) An attempt is the process of exploring the solution space according to available choices, including making choices, updating state, and checking if it is a solution Recursively visit left (right) child nodes, add nodes to <code>path</code>, check if node value is \\(7\\) Backtrack (backtracking) Backtracking refers to undoing previous choices and returning to a previous state when encountering a state that does not satisfy constraints Stop searching when passing over leaf nodes, ending node visits, or encountering nodes with value \\(3\\); function returns Pruning (pruning) Pruning is a method of avoiding meaningless search paths according to problem characteristics and constraints, which can improve search efficiency When encountering a node with value \\(3\\), do not continue searching <p>Tip</p> <p>The concepts of problem, solution, state, etc. are universal and are involved in divide-and-conquer, backtracking, dynamic programming, greedy and other algorithms.</p>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315-advantages-and-limitations","level":2,"title":"13.1.5   Advantages and Limitations","text":"<p>The backtracking algorithm is essentially a depth-first search algorithm that tries all possible solutions until it finds one that satisfies the conditions. The advantage of this approach is that it can find all possible solutions, and with reasonable pruning operations, it achieves high efficiency.</p> <p>However, when dealing with large-scale or complex problems, the running efficiency of the backtracking algorithm may be unacceptable.</p> <ul> <li>Time: The backtracking algorithm usually needs to traverse all possibilities in the solution space, and the time complexity can reach exponential or factorial order.</li> <li>Space: During recursive calls, the current state needs to be saved (such as paths, auxiliary variables used for pruning, etc.), and when the depth is large, the space requirement can become very large.</li> </ul> <p>Nevertheless, the backtracking algorithm is still the best solution for certain search problems and constraint satisfaction problems. For these problems, since we cannot predict which choices will generate valid solutions, we must traverse all possible choices. In this case, the key is how to optimize efficiency. There are two common efficiency optimization methods.</p> <ul> <li>Pruning: Avoid searching paths that are guaranteed not to produce solutions, thereby saving time and space.</li> <li>Heuristic search: Introduce certain strategies or estimation values during the search process to prioritize searching paths that are most likely to produce valid solutions.</li> </ul>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316-typical-backtracking-examples","level":2,"title":"13.1.6   Typical Backtracking Examples","text":"<p>The backtracking algorithm can be used to solve many search problems, constraint satisfaction problems, and combinatorial optimization problems.</p> <p>Search problems: The goal of these problems is to find solutions that satisfy specific conditions.</p> <ul> <li>Permutation problem: Given a set, find all possible permutations and combinations.</li> <li>Subset sum problem: Given a set and a target sum, find all subsets in the set whose elements sum to the target.</li> <li>Tower of Hanoi: Given three pegs and a series of disks of different sizes, move all disks from one peg to another, moving only one disk at a time, and never placing a larger disk on a smaller disk.</li> </ul> <p>Constraint satisfaction problems: The goal of these problems is to find solutions that satisfy all constraints.</p> <ul> <li>N-Queens: Place \\(n\\) queens on an \\(n \\times n\\) chessboard such that they do not attack each other.</li> <li>Sudoku: Fill numbers \\(1\\) to \\(9\\) in a \\(9 \\times 9\\) grid such that each row, column, and \\(3 \\times 3\\) subgrid contains no repeated digits.</li> <li>Graph coloring: Given an undirected graph, color each vertex with the minimum number of colors such that adjacent vertices have different colors.</li> </ul> <p>Combinatorial optimization problems: The goal of these problems is to find an optimal solution that satisfies certain conditions in a combinatorial space.</p> <ul> <li>0-1 Knapsack: Given a set of items and a knapsack, each item has a value and weight. Under the knapsack capacity constraint, select items to maximize total value.</li> <li>Traveling Salesman Problem: Starting from a point in a graph, visit all other points exactly once and return to the starting point, finding the shortest path.</li> <li>Maximum Clique: Given an undirected graph, find the largest complete subgraph, i.e., a subgraph where any two vertices are connected by an edge.</li> </ul> <p>Note that for many combinatorial optimization problems, backtracking is not the optimal solution.</p> <ul> <li>The 0-1 Knapsack problem is usually solved using dynamic programming to achieve higher time efficiency.</li> <li>The Traveling Salesman Problem is a famous NP-Hard problem; common solutions include genetic algorithms and ant colony algorithms.</li> <li>The Maximum Clique problem is a classical problem in graph theory and can be solved using heuristic algorithms such as greedy algorithms.</li> </ul>","path":["Chapter 13. Backtracking","13.1 &nbsp; Backtracking Algorithm"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   N-Queens Problem","text":"<p>Question</p> <p>According to the rules of chess, a queen can attack pieces that share the same row, column, or diagonal line. Given \\(n\\) queens and an \\(n \\times n\\) chessboard, find a placement scheme such that no two queens can attack each other.</p> <p>As shown in Figure 13-15, when \\(n = 4\\), there are two solutions that can be found. From the perspective of the backtracking algorithm, an \\(n \\times n\\) chessboard has \\(n^2\\) squares, which provide all the choices <code>choices</code>. During the process of placing queens one by one, the chessboard state changes continuously, and the chessboard at each moment represents the state <code>state</code>.</p> <p></p> <p> Figure 13-15   Solution to the 4-queens problem </p> <p>Figure 13-16 illustrates the three constraints of this problem: multiple queens cannot be in the same row, the same column, or on the same diagonal. It is worth noting that diagonals are divided into two types: the main diagonal <code>\\</code> and the anti-diagonal <code>/</code>.</p> <p></p> <p> Figure 13-16   Constraints of the n-queens problem </p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1-row-by-row-placement-strategy","level":3,"title":"1.   Row-By-Row Placement Strategy","text":"<p>Since both the number of queens and the number of rows on the chessboard are \\(n\\), we can easily derive a conclusion: each row of the chessboard allows and only allows exactly one queen to be placed.</p> <p>This means we can adopt a row-by-row placement strategy: starting from the first row, place one queen in each row until the last row is completed.</p> <p>Figure 13-17 shows the row-by-row placement process for the 4-queens problem. Due to space limitations, the figure only expands one search branch of the first row, and all schemes that do not satisfy the column constraint and diagonal constraints are pruned.</p> <p></p> <p> Figure 13-17   Row-by-row placement strategy </p> <p>Essentially, the row-by-row placement strategy serves a pruning function, as it avoids all search branches where multiple queens appear in the same row.</p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2-column-and-diagonal-pruning","level":3,"title":"2.   Column and Diagonal Pruning","text":"<p>To satisfy the column constraint, we can use a boolean array <code>cols</code> of length \\(n\\) to record whether each column has a queen. Before each placement decision, we use <code>cols</code> to prune columns that already have queens, and dynamically update the state of <code>cols</code> during backtracking.</p> <p>Tip</p> <p>Please note that the origin of the matrix is located in the upper-left corner, where the row index increases from top to bottom, and the column index increases from left to right.</p> <p>So how do we handle diagonal constraints? Consider a square on the chessboard with row and column indices \\((row, col)\\). If we select a specific main diagonal in the matrix, we find that all squares on that diagonal have the same difference between their row and column indices, meaning that \\(row - col\\) is a constant value for all squares on the main diagonal.</p> <p>In other words, if two squares satisfy \\(row_1 - col_1 = row_2 - col_2\\), they must be on the same main diagonal. Using this pattern, we can use the array <code>diags1</code> shown in Figure 13-18 to record whether there is a queen on each main diagonal.</p> <p>Similarly, for all squares on an anti-diagonal, the sum \\(row + col\\) is a constant value. We can likewise use the array <code>diags2</code> to handle anti-diagonal constraints.</p> <p></p> <p> Figure 13-18   Handling column and diagonal constraints </p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>Please note that in an \\(n\\)-dimensional square matrix, the range of \\(row - col\\) is \\([-n + 1, n - 1]\\), and the range of \\(row + col\\) is \\([0, 2n - 2]\\). Therefore, the number of both main diagonals and anti-diagonals is \\(2n - 1\\), meaning the length of both arrays <code>diags1</code> and <code>diags2</code> is \\(2n - 1\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"Backtracking algorithm: N queens\"\"\"\n    # When all rows are placed, record the solution\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # Traverse all columns\n    for col in range(n):\n        # Calculate the main diagonal and anti-diagonal corresponding to this cell\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"Solve N queens\"\"\"\n    # Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # Record whether there is a queen in the column\n    diags1 = [False] * (2 * n - 1)  # Record whether there is a queen on the main diagonal\n    diags2 = [False] * (2 * n - 1)  # Record whether there is a queen on the anti-diagonal\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // Record whether there is a queen in the column\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // Record whether there is a queen on the main diagonal\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // Record whether there is a queen on the anti-diagonal\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // Record whether there is a queen in the column\n    boolean[] diags1 = new boolean[2 * n - 1]; // Record whether there is a queen on the main diagonal\n    boolean[] diags2 = new boolean[2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* Backtracking algorithm: N queens */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // Record whether there is a queen in the column\n    bool[] diags1 = new bool[2 * n - 1]; // Record whether there is a queen on the main diagonal\n    bool[] diags2 = new bool[2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* Backtracking algorithm: N queens */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // When all rows are placed, record the solution\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all columns\n    for col := 0; col &lt; n; col++ {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // Attempt: place the queen in this cell\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // Place the next row\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // Backtrack: restore this cell to an empty cell\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* Solve N queens */\nfunc nQueens(n int) [][][]string {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // Record whether there is a queen in the column\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* Backtracking algorithm: N queens */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // When all rows are placed, record the solution\n    if row == n {\n        res.append(state)\n        return\n    }\n    // Traverse all columns\n    for col in 0 ..&lt; n {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // Place the next row\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* Solve N queens */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // Record whether there is a queen in the column\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // Record whether there is a queen on the main diagonal\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // Record whether there is a queen on the anti-diagonal\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* Backtracking algorithm: N queens */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // When all rows are placed, record the solution\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Traverse all columns\n    for (let col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nfunction nQueens(n) {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Record whether there is a queen in the column\n    const diags1 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the main diagonal\n    const diags2 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the anti-diagonal\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* Backtracking algorithm: N queens */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // When all rows are placed, record the solution\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Traverse all columns\n    for (let col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nfunction nQueens(n: number): string[][][] {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Record whether there is a queen in the column\n    const diags1 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the main diagonal\n    const diags2 = Array(2 * n - 1).fill(false); // Record whether there is a queen on the anti-diagonal\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // When all rows are placed, record the solution\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // Traverse all columns\n  for (int col = 0; col &lt; n; col++) {\n    // Calculate the main diagonal and anti-diagonal corresponding to this cell\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // Attempt: place the queen in this cell\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // Place the next row\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // Backtrack: restore this cell to an empty cell\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* Solve N queens */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // Record whether there is a queen in the column\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // Record whether there is a queen on the main diagonal\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // Record whether there is a queen on the anti-diagonal\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* Backtracking algorithm: N queens */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // When all rows are placed, record the solution\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all columns\n    for col in 0..n {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* Solve N queens */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // Record whether there is a queen in the column\n    let mut diags1 = vec![false; 2 * n - 1]; // Record whether there is a queen on the main diagonal\n    let mut diags2 = vec![false; 2 * n - 1]; // Record whether there is a queen on the anti-diagonal\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* Backtracking algorithm: N queens */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all columns\n    for (int col = 0; col &lt; n; col++) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Place the next row\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Solve N queens */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // Record whether there is a queen in the column\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // Record whether there is a queen on the main diagonal\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // Record whether there is a queen on the anti-diagonal\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* Backtracking algorithm: N queens */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // When all rows are placed, record the solution\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // Traverse all columns\n    for (col in 0..&lt;n) {\n        // Calculate the main diagonal and anti-diagonal corresponding to this cell\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Attempt: place the queen in this cell\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // Place the next row\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // Backtrack: restore this cell to an empty cell\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* Solve N queens */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // Record whether there is a queen in the column\n    val diags1 = BooleanArray(2 * n - 1) // Record whether there is a queen on the main diagonal\n    val diags2 = BooleanArray(2 * n - 1) // Record whether there is a queen on the anti-diagonal\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### Backtracking: n queens ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # When all rows are placed, record the solution\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # Traverse all columns\n  for col in 0...n\n    # Calculate the main diagonal and anti-diagonal corresponding to this cell\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # Attempt: place the queen in this cell\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # Place the next row\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # Backtrack: restore this cell to an empty cell\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Solve n queens ###\ndef n_queens(n)\n  # Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # Record whether there is a queen in the column\n  diags1 = Array.new(2 * n - 1, false) # Record whether there is a queen on the main diagonal\n  diags2 = Array.new(2 * n - 1, false) # Record whether there is a queen on the anti-diagonal\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> <p>Placing \\(n\\) queens row by row, considering the column constraint, from the first row to the last row there are \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\) choices, using \\(O(n!)\\) time. When recording a solution, it is necessary to copy the matrix <code>state</code> and add it to <code>res</code>, and the copy operation uses \\(O(n^2)\\) time. Therefore, the overall time complexity is \\(O(n! \\cdot n^2)\\). In practice, pruning based on diagonal constraints can also significantly reduce the search space, so the search efficiency is often better than the time complexity mentioned above.</p> <p>The array <code>state</code> uses \\(O(n^2)\\) space, and the arrays <code>cols</code>, <code>diags1</code>, and <code>diags2</code> each use \\(O(n)\\) space. The maximum recursion depth is \\(n\\), using \\(O(n)\\) stack frame space. Therefore, the space complexity is \\(O(n^2)\\).</p>","path":["Chapter 13. Backtracking","13.4 &nbsp; N-Queens Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   Permutations Problem","text":"<p>The permutations problem is a classic application of backtracking algorithms. It is defined as finding all possible arrangements of elements in a given collection (such as an array or string).</p> <p>Table 13-2 shows several example datasets, including input arrays and their corresponding permutations.</p> <p> Table 13-2   Permutations Examples </p> Input Array All Permutations \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321-case-with-distinct-elements","level":2,"title":"13.2.1   Case with Distinct Elements","text":"<p>Question</p> <p>Given an integer array with no duplicate elements, return all possible permutations.</p> <p>From the perspective of backtracking algorithms, we can imagine the process of generating permutations as the result of a series of choices. Suppose the input array is \\([1, 2, 3]\\). If we first choose \\(1\\), then choose \\(3\\), and finally choose \\(2\\), we obtain the permutation \\([1, 3, 2]\\). Backtracking means undoing a choice and then trying other choices.</p> <p>From the perspective of backtracking code, the candidate set <code>choices</code> consists of all elements in the input array, and the state <code>state</code> is the elements that have been chosen so far. Note that each element can only be chosen once, therefore all elements in <code>state</code> should be unique.</p> <p>As shown in Figure 13-5, we can unfold the search process into a recursion tree, where each node in the tree represents the current state <code>state</code>. Starting from the root node, after three rounds of choices, we reach a leaf node, and each leaf node corresponds to a permutation.</p> <p></p> <p> Figure 13-5   Recursion tree of permutations </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1-pruning-duplicate-choices","level":3,"title":"1.   Pruning Duplicate Choices","text":"<p>To ensure that each element is chosen only once, we consider introducing a boolean array <code>selected</code>, where <code>selected[i]</code> indicates whether <code>choices[i]</code> has been chosen. We implement the following pruning operation based on it.</p> <ul> <li>After making a choice <code>choice[i]</code>, we set <code>selected[i]</code> to \\(\\text{True}\\), indicating that it has been chosen.</li> <li>When traversing the candidate list <code>choices</code>, we skip all nodes that have been chosen, which is pruning.</li> </ul> <p>As shown in Figure 13-6, suppose we choose \\(1\\) in the first round, \\(3\\) in the second round, and \\(2\\) in the third round. Then we need to prune the branch of element \\(1\\) in the second round and prune the branches of elements \\(1\\) and \\(3\\) in the third round.</p> <p></p> <p> Figure 13-6   Pruning example of permutations </p> <p>Observing the above figure, we find that this pruning operation reduces the search space size from \\(O(n^n)\\) to \\(O(n!)\\).</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>After understanding the above information, we can fill in the blanks in the template code. To shorten the overall code, we do not implement each function in the template separately, but instead unfold them in the <code>backtrack()</code> function:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Permutations I\"\"\"\n    # When the state length equals the number of elements, record the solution\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Traverse all choices\n    for i, choice in enumerate(choices):\n        # Pruning: do not allow repeated selection of elements\n        if not selected[i]:\n            # Attempt: make choice, update state\n            selected[i] = True\n            state.append(choice)\n            # Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            # Backtrack: undo choice, restore to previous state\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Permutations I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push_back(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Permutations I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.add(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Permutations I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* Backtracking algorithm: Permutations I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.Add(choice);\n            // Proceed to the next round of selection\n            Backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Permutations I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* Backtracking algorithm: Permutations I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // When the state length equals the number of elements, record the solution\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Traverse all choices\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Pruning: do not allow repeated selection of elements\n        if !(*selected)[i] {\n            // Attempt: make choice, update state\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Proceed to the next round of selection\n            backtrackI(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Permutations I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* Backtracking algorithm: Permutations I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // When the state length equals the number of elements, record the solution\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    for (i, choice) in choices.enumerated() {\n        // Pruning: do not allow repeated selection of elements\n        if !selected[i] {\n            // Attempt: make choice, update state\n            selected[i] = true\n            state.append(choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Permutations I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* Backtracking algorithm: Permutations I */\nfunction backtrack(state, choices, selected, res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* Backtracking algorithm: Permutations I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the state length equals the number of elements, record the solution\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Pruning: do not allow repeated selection of elements\n    if (!selected[i]) {\n      // Attempt: make choice, update state\n      selected[i] = true;\n      state.add(choice);\n      // Proceed to the next round of selection\n      backtrack(state, choices, selected, res);\n      // Backtrack: undo choice, restore to previous state\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Permutations I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* Backtracking algorithm: Permutations I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // When the state length equals the number of elements, record the solution\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Traverse all choices\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if !selected[i] {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state.clone(), choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Permutations I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // State (subset)\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* Backtracking algorithm: Permutations I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // When the state length equals the number of elements, record the solution\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Proceed to the next round of selection\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n        }\n    }\n}\n\n/* Permutations I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* Backtracking algorithm: Permutations I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Pruning: do not allow repeated selection of elements\n        if (!selected[i]) {\n            // Attempt: make choice, update state\n            selected[i] = true\n            state.add(choice)\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Permutations I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### Backtracking: permutations I ###\ndef backtrack(state, choices, selected, res)\n  # When the state length equals the number of elements, record the solution\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  choices.each_with_index do |choice, i|\n    # Pruning: do not allow repeated selection of elements\n    unless selected[i]\n      # Attempt: make choice, update state\n      selected[i] = true\n      state &lt;&lt; choice\n      # Proceed to the next round of selection\n      backtrack(state, choices, selected, res)\n      # Backtrack: undo choice, restore to previous state\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Permutations I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322-case-with-duplicate-elements","level":2,"title":"13.2.2   Case with Duplicate Elements","text":"<p>Question</p> <p>Given an integer array that may contain duplicate elements, return all unique permutations.</p> <p>Suppose the input array is \\([1, 1, 2]\\). To distinguish the two duplicate elements \\(1\\), we denote the second \\(1\\) as \\(\\hat{1}\\).</p> <p>As shown in Figure 13-7, the method described above generates permutations where half are duplicates.</p> <p></p> <p> Figure 13-7   Duplicate permutations </p> <p>So how do we remove duplicate permutations? The most direct approach is to use a hash set to directly deduplicate the permutation results. However, this is not elegant because the search branches that generate duplicate permutations are unnecessary and should be identified and pruned early, which can further improve algorithm efficiency.</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1-pruning-duplicate-elements","level":3,"title":"1.   Pruning Duplicate Elements","text":"<p>Observe Figure 13-8. In the first round, choosing \\(1\\) or choosing \\(\\hat{1}\\) is equivalent. All permutations generated under these two choices are duplicates. Therefore, we should prune \\(\\hat{1}\\).</p> <p>Similarly, after choosing \\(2\\) in the first round, the \\(1\\) and \\(\\hat{1}\\) in the second round also produce duplicate branches, so the second round's \\(\\hat{1}\\) should also be pruned.</p> <p>Essentially, our goal is to ensure that multiple equal elements are chosen only once in a certain round of choices.</p> <p></p> <p> Figure 13-8   Pruning duplicate permutations </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2-code-implementation_1","level":3,"title":"2.   Code Implementation","text":"<p>Building on the code from the previous problem, we consider opening a hash set <code>duplicated</code> in each round of choices to record which elements have been tried in this round, and prune duplicate elements:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Permutations II\"\"\"\n    # When the state length equals the number of elements, record the solution\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Traverse all choices\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if not selected[i] and choice not in duplicated:\n            # Attempt: make choice, update state\n            duplicated.add(choice)  # Record the selected element value\n            selected[i] = True\n            state.append(choice)\n            # Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            # Backtrack: undo choice, restore to previous state\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Permutations II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // Attempt: make choice, update state\n            duplicated.emplace(choice); // Record the selected element value\n            selected[i] = true;\n            state.push_back(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Permutations II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.add(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Permutations II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* Backtracking algorithm: Permutations II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.Add(choice); // Record the selected element value\n            selected[i] = true;\n            state.Add(choice);\n            // Proceed to the next round of selection\n            Backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Permutations II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* Backtracking algorithm: Permutations II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // When the state length equals the number of elements, record the solution\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Traverse all choices\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // Attempt: make choice, update state\n            // Record the selected element value\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Proceed to the next round of selection\n            backtrackII(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Permutations II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* Backtracking algorithm: Permutations II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // When the state length equals the number of elements, record the solution\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if !selected[i], !duplicated.contains(choice) {\n            // Attempt: make choice, update state\n            duplicated.insert(choice) // Record the selected element value\n            selected[i] = true\n            state.append(choice)\n            // Proceed to the next round of selection\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Permutations II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* Backtracking algorithm: Permutations II */\nfunction backtrack(state, choices, selected, res) {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* Backtracking algorithm: Permutations II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // When the state length equals the number of elements, record the solution\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Permutations II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the state length equals the number of elements, record the solution\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // Attempt: make choice, update state\n      duplicated.add(choice); // Record the selected element value\n      selected[i] = true;\n      state.add(choice);\n      // Proceed to the next round of selection\n      backtrack(state, choices, selected, res);\n      // Backtrack: undo choice, restore to previous state\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Permutations II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* Backtracking algorithm: Permutations II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // When the state length equals the number of elements, record the solution\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Traverse all choices\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // Attempt: make choice, update state\n            duplicated.insert(choice); // Record the selected element value\n            selected[i] = true;\n            state.push(choice);\n            // Proceed to the next round of selection\n            backtrack(state.clone(), choices, selected, res);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Permutations II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* Backtracking algorithm: Permutations II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // When the state length equals the number of elements, record the solution\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Traverse all choices\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // Attempt: make choice, update state\n            duplicated[choice] = true; // Record the selected element value\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Proceed to the next round of selection\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false;\n        }\n    }\n}\n\n/* Permutations II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* Backtracking algorithm: Permutations II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the state length equals the number of elements, record the solution\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Attempt: make choice, update state\n            duplicated.add(choice) // Record the selected element value\n            selected[i] = true\n            state.add(choice)\n            // Proceed to the next round of selection\n            backtrack(state, choices, selected, res)\n            // Backtrack: undo choice, restore to previous state\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Permutations II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### Backtracking: permutations II ###\ndef backtrack(state, choices, selected, res)\n  # When the state length equals the number of elements, record the solution\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # Attempt: make choice, update state\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # Proceed to the next round of selection\n      backtrack(state, choices, selected, res)\n      # Backtrack: undo choice, restore to previous state\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Permutations II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> <p>Assuming elements are pairwise distinct, there are \\(n!\\) (factorial) permutations of \\(n\\) elements. When recording results, we need to copy a list of length \\(n\\), using \\(O(n)\\) time. Therefore, the time complexity is \\(O(n! \\cdot n)\\).</p> <p>The maximum recursion depth is \\(n\\), using \\(O(n)\\) stack frame space. <code>selected</code> uses \\(O(n)\\) space. At most \\(n\\) <code>duplicated</code> sets exist simultaneously, using \\(O(n^2)\\) space. Therefore, the space complexity is \\(O(n^2)\\).</p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3-comparison-of-two-pruning-methods","level":3,"title":"3.   Comparison of Two Pruning Methods","text":"<p>Note that although both <code>selected</code> and <code>duplicated</code> are used for pruning, they have different objectives.</p> <ul> <li>Pruning duplicate choices: There is only one <code>selected</code> throughout the entire search process. It records which elements are included in the current state, and its purpose is to prevent an element from appearing repeatedly in <code>state</code>.</li> <li>Pruning duplicate elements: Each round of choices (each <code>backtrack</code> function call) contains a <code>duplicated</code> set. It records which elements have been chosen in this round's iteration (the <code>for</code> loop), and its purpose is to ensure that equal elements are chosen only once.</li> </ul> <p>Figure 13-9 shows the effective scope of the two pruning conditions. Note that each node in the tree represents a choice, and the nodes on the path from the root to a leaf node form a permutation.</p> <p></p> <p> Figure 13-9   Effective scope of two pruning conditions </p>","path":["Chapter 13. Backtracking","13.2 &nbsp; Permutations Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   Subset-Sum Problem","text":"","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331-without-duplicate-elements","level":2,"title":"13.3.1   Without Duplicate Elements","text":"<p>Question</p> <p>Given a positive integer array <code>nums</code> and a target positive integer <code>target</code>, find all possible combinations where the sum of elements in the combination equals <code>target</code>. The given array has no duplicate elements, and each element can be selected multiple times. Return these combinations in list form, where the list should not contain duplicate combinations.</p> <p>For example, given the set \\(\\{3, 4, 5\\}\\) and target integer \\(9\\), the solutions are \\(\\{3, 3, 3\\}, \\{4, 5\\}\\). Note the following two points:</p> <ul> <li>Elements in the input set can be selected repeatedly without limit.</li> <li>Subsets do not distinguish element order; for example, \\(\\{4, 5\\}\\) and \\(\\{5, 4\\}\\) are the same subset.</li> </ul>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1-reference-to-full-permutation-solution","level":3,"title":"1.   Reference to Full Permutation Solution","text":"<p>Similar to the full permutation problem, we can imagine the process of generating subsets as a series of choices, and update the \"sum of elements\" in real-time during the selection process. When the sum equals <code>target</code>, we record the subset to the result list.</p> <p>Unlike the full permutation problem, elements in this problem's set can be selected unlimited times, so we do not need to use a <code>selected</code> boolean list to track whether an element has been selected. We can make minor modifications to the full permutation code and initially obtain the solution:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"Backtracking algorithm: Subset sum I\"\"\"\n    # When the subset sum equals target, record the solution\n    if total == target:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    for i in range(len(choices)):\n        # Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target:\n            continue\n        # Attempt: make choice, update element sum total\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum I (including duplicate subsets)\"\"\"\n    state = []  # State (subset)\n    total = 0  # Subset sum\n    res = []  # Result list (subset list)\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // State (subset)\n    int total = 0;           // Subset sum\n    vector&lt;vector&lt;int&gt;&gt; res; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    int total = 0; // Subset sum\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    int total = 0; // Subset sum\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    for i := 0; i &lt; len(*choices); i++ {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    total := 0              // Subset sum\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if total == target {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    for i in choices.indices {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let total = 0 // Subset sum\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(state, target, total, choices, res) {\n    // When the subset sum equals target, record the solution\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // State (subset)\n    const total = 0; // Subset sum\n    const res = []; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    const total = 0; // Subset sum\n    const res = []; // Result list (subset list)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  for (int i = 0; i &lt; choices.length; i++) {\n    // Pruning: if the subset sum exceeds target, skip this choice\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // Attempt: make choice, update element sum total\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target, total + choices[i], choices, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  int total = 0; // Sum of elements\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* Backtracking algorithm: Subset sum I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    for i in 0..choices.len() {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    let total = 0; // Subset sum\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Attempt: make choice, update element sum total\n        state[stateSize++] = choices[i];\n        // Proceed to the next round of selection\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // Initialize solution count to 0\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* Backtracking algorithm: Subset sum I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    for (i in choices.indices) {\n        // Pruning: if the subset sum exceeds target, skip this choice\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // Attempt: make choice, update element sum total\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target, total + choices[i], choices, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum I (including duplicate subsets) */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    val total = 0 // Subset sum\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### Backtracking: subset sum I ###\ndef backtrack(state, target, total, choices, res)\n  # When the subset sum equals target, record the solution\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  for i in 0...choices.length\n    # Pruning: if the subset sum exceeds target, skip this choice\n    next if total + choices[i] &gt; target\n    # Attempt: make choice, update element sum total\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target, total + choices[i], choices, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum I (with duplicate subsets) ###\ndef subset_sum_i_naive(nums, target)\n  state = [] # State (subset)\n  total = 0 # Subset sum\n  res = [] # Result list (subset list)\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> <p>When we input array \\([3, 4, 5]\\) and target element \\(9\\) to the above code, the output is \\([3, 3, 3], [4, 5], [5, 4]\\). Although we successfully find all subsets that sum to \\(9\\), there are duplicate subsets \\([4, 5]\\) and \\([5, 4]\\).</p> <p>This is because the search process distinguishes the order of selections, but subsets do not distinguish selection order. As shown in Figure 13-10, selecting 4 first and then 5 versus selecting 5 first and then 4 are different branches, but they correspond to the same subset.</p> <p></p> <p> Figure 13-10   Subset search and boundary pruning </p> <p>To eliminate duplicate subsets, one straightforward idea is to deduplicate the result list. However, this approach is very inefficient for two reasons:</p> <ul> <li>When there are many array elements, especially when <code>target</code> is large, the search process generates many duplicate subsets.</li> <li>Comparing subsets (arrays) is very time-consuming, requiring sorting the arrays first, then comparing each element in them.</li> </ul>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2-pruning-duplicate-subsets","level":3,"title":"2.   Pruning Duplicate Subsets","text":"<p>We consider deduplication through pruning during the search process. Observing Figure 13-11, duplicate subsets occur when array elements are selected in different orders, as in the following cases:</p> <ol> <li>When the first and second rounds select \\(3\\) and \\(4\\) respectively, all subsets containing these two elements are generated, denoted as \\([3, 4, \\dots]\\).</li> <li>Afterward, when the first round selects \\(4\\), the second round should skip \\(3\\), because the subset \\([4, 3, \\dots]\\) generated by this choice is completely duplicate with the subset generated in step <code>1.</code></li> </ol> <p>In the search process, each level's choices are tried from left to right, so the rightmost branches are pruned more.</p> <ol> <li>The first two rounds select \\(3\\) and \\(5\\), generating subset \\([3, 5, \\dots]\\).</li> <li>The first two rounds select \\(4\\) and \\(5\\), generating subset \\([4, 5, \\dots]\\).</li> <li>If the first round selects \\(5\\), the second round should skip \\(3\\) and \\(4\\), because subsets \\([5, 3, \\dots]\\) and \\([5, 4, \\dots]\\) are completely duplicate with the subsets described in steps <code>1.</code> and <code>2.</code></li> </ol> <p></p> <p> Figure 13-11   Different selection orders leading to duplicate subsets </p> <p>In summary, given an input array \\([x_1, x_2, \\dots, x_n]\\), let the selection sequence in the search process be \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\). This selection sequence must satisfy \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\); any selection sequence that does not satisfy this condition will cause duplicates and should be pruned.</p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>To implement this pruning, we initialize a variable <code>start</code> to indicate the starting point of traversal. After making choice \\(x_{i}\\), set the next round to start traversal from index \\(i\\). This ensures that the selection sequence satisfies \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\), guaranteeing subset uniqueness.</p> <p>In addition, we have made the following two optimizations to the code:</p> <ul> <li>Before starting the search, first sort the array <code>nums</code>. When traversing all choices, end the loop immediately when the subset sum exceeds <code>target</code>, because subsequent elements are larger, and their subset sums must exceed <code>target</code>.</li> <li>Omit the element sum variable <code>total</code> and use subtraction on <code>target</code> to track the sum of elements. Record the solution when <code>target</code> equals \\(0\\).</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Subset sum I\"\"\"\n    # When the subset sum equals target, record the solution\n    if target == 0:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    # Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in range(start, len(choices)):\n        # Pruning 1: if the subset sum exceeds target, end the loop directly\n        # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0:\n            break\n        # Attempt: make choice, update target, start\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum I\"\"\"\n    state = []  # State (subset)\n    nums.sort()  # Sort nums\n    start = 0  # Start point for traversal\n    res = []  # Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // State (subset)\n    sort(nums.begin(), nums.end()); // Sort nums\n    int start = 0;                  // Start point for traversal\n    vector&lt;vector&lt;int&gt;&gt; res;        // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    Arrays.sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    Array.Sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i := start; i &lt; len(*choices); i++ {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Attempt: make choice, update target, start\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    sort.Ints(nums)         // Sort nums\n    start := 0              // Start point for traversal\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* Backtracking algorithm: Subset sum I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in choices.indices.dropFirst(start) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Attempt: make choice, update target, start\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let nums = nums.sorted() // Sort nums\n    let start = 0 // Start point for traversal\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(state, target, choices, start, res) {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfunction subsetSumI(nums, target) {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* Backtracking algorithm: Subset sum I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  // Pruning 2: start traversing from start to avoid generating duplicate subsets\n  for (int i = start; i &lt; choices.length; i++) {\n    // Pruning 1: if the subset sum exceeds target, end the loop directly\n    // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Attempt: make choice, update target, start\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  nums.sort(); // Sort nums\n  int start = 0; // Start point for traversal\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* Backtracking algorithm: Subset sum I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for i in start..choices.len() {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    nums.sort(); // Sort nums\n    let start = 0; // Start point for traversal\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* Backtracking algorithm: Subset sum I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Attempt: make choice, update target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Proceed to the next round of selection\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // Sort nums\n    int start = 0;                           // Start point for traversal\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* Backtracking algorithm: Subset sum I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    for (i in start..&lt;choices.size) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    nums.sort() // Sort nums\n    val start = 0 // Start point for traversal\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### Backtracking: subset sum I ###\ndef backtrack(state, target, choices, start, res)\n  # When the subset sum equals target, record the solution\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # Traverse all choices\n  # Pruning 2: start traversing from start to avoid generating duplicate subsets\n  for i in start...choices.length\n    # Pruning 1: if the subset sum exceeds target, end the loop directly\n    # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    break if target - choices[i] &lt; 0\n    # Attempt: make choice, update target, start\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum I ###\ndef subset_sum_i(nums, target)\n  state = [] # State (subset)\n  nums.sort! # Sort nums\n  start = 0 # Start point for traversal\n  res = [] # Result list (subset list)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> <p>Figure 13-12 shows the complete backtracking process when array \\([3, 4, 5]\\) and target element \\(9\\) are input to the above code.</p> <p></p> <p> Figure 13-12   Subset-sum I backtracking process </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332-with-duplicate-elements-in-array","level":2,"title":"13.3.2   With Duplicate Elements in Array","text":"<p>Question</p> <p>Given a positive integer array <code>nums</code> and a target positive integer <code>target</code>, find all possible combinations where the sum of elements in the combination equals <code>target</code>. The given array may contain duplicate elements, and each element can be selected at most once. Return these combinations in list form, where the list should not contain duplicate combinations.</p> <p>Compared to the previous problem, the input array in this problem may contain duplicate elements, which introduces new challenges. For example, given array \\([4, \\hat{4}, 5]\\) and target element \\(9\\), the output of the existing code is \\([4, 5], [\\hat{4}, 5]\\), which contains duplicate subsets.</p> <p>The reason for this duplication is that equal elements are selected multiple times in a certain round. In Figure 13-13, the first round has three choices, two of which are \\(4\\), creating two duplicate search branches that output duplicate subsets. Similarly, the two \\(4\\)'s in the second round also produce duplicate subsets.</p> <p></p> <p> Figure 13-13   Duplicate subsets caused by equal elements </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1-pruning-equal-elements","level":3,"title":"1.   Pruning Equal Elements","text":"<p>To solve this problem, we need to limit equal elements to be selected only once in each round. The implementation is quite clever: since the array is already sorted, equal elements are adjacent. This means that in a certain round of selection, if the current element equals the element to its left, it means this element has already been selected, so we skip the current element directly.</p> <p>At the same time, this problem specifies that each array element can only be selected once. Fortunately, we can also use the variable <code>start</code> to satisfy this constraint: after making choice \\(x_{i}\\), set the next round to start traversal from index \\(i + 1\\) onwards. This both eliminates duplicate subsets and avoids selecting elements multiple times.</p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Backtracking algorithm: Subset sum II\"\"\"\n    # When the subset sum equals target, record the solution\n    if target == 0:\n        res.append(list(state))\n        return\n    # Traverse all choices\n    # Pruning 2: start traversing from start to avoid generating duplicate subsets\n    # Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in range(start, len(choices)):\n        # Pruning 1: if the subset sum exceeds target, end the loop directly\n        # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0:\n            break\n        # Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # Attempt: make choice, update target, start\n        state.append(choices[i])\n        # Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # Backtrack: undo choice, restore to previous state\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Solve subset sum II\"\"\"\n    state = []  # State (subset)\n    nums.sort()  # Sort nums\n    start = 0  # Start point for traversal\n    res = []  # Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push_back(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop_back();\n    }\n}\n\n/* Solve subset sum II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // State (subset)\n    sort(nums.begin(), nums.end()); // Sort nums\n    int start = 0;                  // Start point for traversal\n    vector&lt;vector&lt;int&gt;&gt; res;        // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // State (subset)\n    Arrays.sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.Add(choices[i]);\n        // Proceed to the next round of selection\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // State (subset)\n    Array.Sort(nums); // Sort nums\n    int start = 0; // Start point for traversal\n    List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* Backtracking algorithm: Subset sum II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i := start; i &lt; len(*choices); i++ {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        *state = append(*state, (*choices)[i])\n        // Proceed to the next round of selection\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // Backtrack: undo choice, restore to previous state\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Solve subset sum II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // State (subset)\n    sort.Ints(nums)         // Sort nums\n    start := 0              // Start point for traversal\n    res := make([][]int, 0) // Result list (subset list)\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* Backtracking algorithm: Subset sum II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in choices.indices.dropFirst(start) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        state.append(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeLast()\n    }\n}\n\n/* Solve subset sum II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // State (subset)\n    let nums = nums.sorted() // Sort nums\n    let start = 0 // Start point for traversal\n    var res: [[Int]] = [] // Result list (subset list)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* Backtracking algorithm: Subset sum II */\nfunction backtrack(state, target, choices, start, res) {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfunction subsetSumII(nums, target) {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* Backtracking algorithm: Subset sum II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // When the subset sum equals target, record the solution\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (let i = start; i &lt; choices.length; i++) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // State (subset)\n    nums.sort((a, b) =&gt; a - b); // Sort nums\n    const start = 0; // Start point for traversal\n    const res = []; // Result list (subset list)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // When the subset sum equals target, record the solution\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Traverse all choices\n  // Pruning 2: start traversing from start to avoid generating duplicate subsets\n  // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n  for (int i = start; i &lt; choices.length; i++) {\n    // Pruning 1: if the subset sum exceeds target, end the loop directly\n    // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // Attempt: make choice, update target, start\n    state.add(choices[i]);\n    // Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // Backtrack: undo choice, restore to previous state\n    state.removeLast();\n  }\n}\n\n/* Solve subset sum II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // State (subset)\n  nums.sort(); // Sort nums\n  int start = 0; // Start point for traversal\n  List&lt;List&lt;int&gt;&gt; res = []; // Result list (subset list)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* Backtracking algorithm: Subset sum II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // When the subset sum equals target, record the solution\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for i in start..choices.len() {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state.push(choices[i]);\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Backtrack: undo choice, restore to previous state\n        state.pop();\n    }\n}\n\n/* Solve subset sum II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // State (subset)\n    nums.sort(); // Sort nums\n    let start = 0; // Start point for traversal\n    let mut res = Vec::new(); // Result list (subset list)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* Backtracking algorithm: Subset sum II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Pruning 1: Skip if subset sum exceeds target\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Attempt: make choice, update target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Proceed to the next round of selection\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // Backtrack: undo choice, restore to previous state\n        stateSize--;\n    }\n}\n\n/* Solve subset sum II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // Sort nums\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // Start backtracking\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* Backtracking algorithm: Subset sum II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // When the subset sum equals target, record the solution\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Traverse all choices\n    // Pruning 2: start traversing from start to avoid generating duplicate subsets\n    // Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n    for (i in start..&lt;choices.size) {\n        // Pruning 1: if the subset sum exceeds target, end the loop directly\n        // This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // Attempt: make choice, update target, start\n        state.add(choices[i])\n        // Proceed to the next round of selection\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // Backtrack: undo choice, restore to previous state\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Solve subset sum II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // State (subset)\n    nums.sort() // Sort nums\n    val start = 0 // Start point for traversal\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Result list (subset list)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### Backtracking: subset sum II ###\ndef backtrack(state, target, choices, start, res)\n  # When the subset sum equals target, record the solution\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Traverse all choices\n  # Pruning 2: start traversing from start to avoid generating duplicate subsets\n  # Pruning 3: start traversing from start to avoid repeatedly selecting the same element\n  for i in start...choices.length\n    # Pruning 1: if the subset sum exceeds target, end the loop directly\n    # This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target\n    break if target - choices[i] &lt; 0\n    # Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # Attempt: make choice, update target, start\n    state &lt;&lt; choices[i]\n    # Proceed to the next round of selection\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # Backtrack: undo choice, restore to previous state\n    state.pop\n  end\nend\n\n### Solve subset sum II ###\ndef subset_sum_ii(nums, target)\n  state = [] # State (subset)\n  nums.sort! # Sort nums\n  start = 0 # Start point for traversal\n  res = [] # Result list (subset list)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> <p>Figure 13-14 shows the backtracking process for array \\([4, 4, 5]\\) and target element \\(9\\), which includes four types of pruning operations. Combine the illustration with the code comments to understand the entire search process and how each pruning operation works.</p> <p></p> <p> Figure 13-14   Subset-sum II backtracking process </p>","path":["Chapter 13. Backtracking","13.3 &nbsp; Subset-Sum Problem"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   Summary","text":"","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>The backtracking algorithm is fundamentally an exhaustive search method. It finds solutions that meet specified conditions by performing a depth-first traversal of the solution space. During the search process, when a solution satisfying the conditions is found, it is recorded. The search ends either after finding all solutions or when the traversal is complete.</li> <li>The backtracking algorithm search process consists of two parts: attempting and backtracking. It tries various choices through depth-first search. When encountering situations that violate constraints, it reverts the previous choice, returns to the previous state, and continues exploring other options. Attempting and backtracking are operations in opposite directions.</li> <li>Backtracking problems typically contain multiple constraints, which can be utilized to implement pruning operations. Pruning can terminate unnecessary search branches early, significantly improving search efficiency.</li> <li>The backtracking algorithm is primarily used to solve search problems and constraint satisfaction problems. While combinatorial optimization problems can be solved with backtracking, there are often more efficient or better-performing solutions available.</li> <li>The permutation problem aims to find all possible permutations of elements in a given set. We use an array to record whether each element has been selected, thereby pruning search branches that attempt to select the same element repeatedly, ensuring each element is selected exactly once.</li> <li>In the permutation problem, if the set contains duplicate elements, the final result will contain duplicate permutations. We need to impose a constraint so that equal elements can only be selected once per round, which is typically achieved using a hash set.</li> <li>The subset-sum problem aims to find all subsets of a given set that sum to a target value. Since the set is unordered but the search process outputs results in all orders, duplicate subsets are generated. We sort the data before backtracking and use a variable to indicate the starting point of each round's traversal, thereby pruning search branches that generate duplicate subsets.</li> <li>For the subset-sum problem, equal elements in the array produce duplicate sets. We leverage the precondition that the array is sorted by checking whether adjacent elements are equal to implement pruning, ensuring that equal elements can only be selected once per round.</li> <li>The \\(n\\) queens problem aims to find placements of \\(n\\) queens on an \\(n \\times n\\) chessboard such that no two queens can attack each other. The constraints of this problem include row constraints, column constraints, and main and anti-diagonal constraints. To satisfy row constraints, we adopt a row-by-row placement strategy, ensuring exactly one queen is placed in each row.</li> <li>The handling of column constraints and diagonal constraints is similar. For column constraints, we use an array to record whether each column has a queen, thereby indicating whether a selected cell is valid. For diagonal constraints, we use two arrays to separately record whether queens exist on each main or anti-diagonal. The challenge lies in finding the row-column index pattern that characterizes cells on the same main (anti-)diagonal.</li> </ul>","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: How should we understand the relationship between backtracking and recursion?</p> <p>Overall, backtracking is an \"algorithm strategy\", while recursion is more like a \"tool\".</p> <ul> <li>The backtracking algorithm is typically implemented based on recursion. However, backtracking is one application scenario of recursion and represents the application of recursion in search problems.</li> <li>The structure of recursion embodies the \"subproblem decomposition\" problem-solving paradigm, commonly used to solve problems involving divide-and-conquer, backtracking, and dynamic programming (memoized recursion).</li> </ul>","path":["Chapter 13. Backtracking","13.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"Chapter 2.   Complexity Analysis","text":"<p>Abstract</p> <p>Complexity analysis is like a space-time guide in the vast universe of algorithms.</p> <p>It leads us to explore deeply within the two dimensions of time and space, seeking more elegant solutions.</p>","path":["Chapter 2. Complexity Analysis","Chapter 2. &nbsp; Complexity Analysis"],"tags":[]},{"location":"chapter_computational_complexity/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>2.1   Algorithm Efficiency Evaluation</li> <li>2.2   Iteration and Recursion</li> <li>2.3   Time Complexity</li> <li>2.4   Space Complexity</li> <li>2.5   Summary</li> </ul>","path":["Chapter 2. Complexity Analysis","Chapter 2. &nbsp; Complexity Analysis"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   Iteration and Recursion","text":"<p>In algorithms, repeatedly executing a task is very common and closely related to complexity analysis. Therefore, before introducing time complexity and space complexity, let's first understand how to implement repeated task execution in programs, namely the two basic program control structures: iteration and recursion.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221-iteration","level":2,"title":"2.2.1   Iteration","text":"<p>Iteration is a control structure for repeatedly executing a task. In iteration, a program repeatedly executes a segment of code under certain conditions until those conditions are no longer satisfied.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for-loop","level":3,"title":"1.   For Loop","text":"<p>The <code>for</code> loop is one of the most common forms of iteration, suitable for use when the number of iterations is known in advance.</p> <p>The following function implements the summation \\(1 + 2 + \\dots + n\\) based on a <code>for</code> loop, with the sum result recorded using the variable <code>res</code>. Note that in Python, <code>range(a, b)</code> corresponds to a \"left-closed, right-open\" interval, with the traversal range being \\(a, a + 1, \\dots, b-1\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for loop\"\"\"\n    res = 0\n    # Sum 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for loop */\nint ForLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for loop */\nfunc forLoop(n int) int {\n    res := 0\n    // Sum 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for loop */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // Sum 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for loop */\nfunction forLoop(n) {\n    let res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for loop */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for loop */\nint forLoop(int n) {\n  int res = 0;\n  // Sum 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for loop */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for loop */\nint forLoop(int n) {\n    int res = 0;\n    // Sum 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for loop */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // Sum 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for loop ###\ndef for_loop(n)\n  res = 0\n\n  # Sum 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> <p>Figure 2-1 shows the flowchart of this summation function.</p> <p></p> <p> Figure 2-1   Flowchart of the summation function </p> <p>The number of operations in this summation function is proportional to the input data size \\(n\\), or has a \"linear relationship\". In fact, time complexity describes precisely this \"linear relationship\". Related content will be introduced in detail in the next section.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while-loop","level":3,"title":"2.   While Loop","text":"<p>Similar to the <code>for</code> loop, the <code>while</code> loop is also a method for implementing iteration. In a <code>while</code> loop, the program first checks the condition in each round; if the condition is true, it continues execution, otherwise it ends the loop.</p> <p>Below we use a <code>while</code> loop to implement the summation \\(1 + 2 + \\dots + n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while loop\"\"\"\n    res = 0\n    i = 1  # Initialize condition variable\n    # Sum 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # Update condition variable\n    return res\n</code></pre> iteration.cpp<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while loop */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while loop */\nfunc whileLoop(n int) int {\n    res := 0\n    // Initialize condition variable\n    i := 1\n    // Sum 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // Update condition variable\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while loop */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // Update condition variable\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while loop */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while loop */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while loop */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // Initialize condition variable\n  // Sum 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // Update condition variable\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while loop */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Initialize condition variable\n\n    // Sum 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // Update condition variable\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while loop */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Update condition variable\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while loop */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // Update condition variable\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while loop ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Initialize condition variable\n\n  # Sum 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Update condition variable\n  end\n\n  res\nend\n</code></pre> <p>The <code>while</code> loop has greater flexibility than the <code>for</code> loop. In a <code>while</code> loop, we can freely design the initialization and update steps of the condition variable.</p> <p>For example, in the following code, the condition variable \\(i\\) is updated twice per round, which is not convenient to implement using a <code>for</code> loop:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while loop (two updates)\"\"\"\n    res = 0\n    i = 1  # Initialize condition variable\n    # Sum 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # Update condition variable\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while loop (two updates) */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while loop (two updates) */\nfunc whileLoopII(n int) int {\n    res := 0\n    // Initialize condition variable\n    i := 1\n    // Sum 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // Update condition variable\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while loop (two updates) */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // Update condition variable\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while loop (two updates) */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while loop (two updates) */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // Initialize condition variable\n  // Sum 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // Update condition variable\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while loop (two updates) */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Initialize condition variable\n\n    // Sum 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // Update condition variable\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while loop (two updates) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Update condition variable\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while loop (two updates) */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // Initialize condition variable\n    // Sum 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // Update condition variable\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while loop (two updates) ###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # Initialize condition variable\n\n  # Sum 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # Update condition variable\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> <p>Overall, <code>for</code> loops have more compact code, while <code>while</code> loops are more flexible; both can implement iterative structures. The choice of which to use should be determined based on the requirements of the specific problem.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-nested-loops","level":3,"title":"3.   Nested Loops","text":"<p>We can nest one loop structure inside another. Below is an example using <code>for</code> loops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"Nested for loop\"\"\"\n    res = \"\"\n    # Loop i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # Loop j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* Nested for loop */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* Nested for loop */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* Nested for loop */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* Nested for loop */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // Loop i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // Loop j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Nested for loop */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // Loop i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // Loop j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Nested for loop */\nfunction nestedForLoop(n) {\n    let res = '';\n    // Loop i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Nested for loop */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // Loop i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Nested for loop */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // Loop i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // Loop j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Nested for loop */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // Loop i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // Loop j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* Nested for loop */\nchar *nestedForLoop(int n) {\n    // n * n is the number of points, \"(i, j), \" string max length is 6+10*2, plus extra space for null character \\0\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // Loop i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Nested for loop */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // Loop i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // Loop j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### Nested for loop ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # Loop i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # Loop j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> <p>Figure 2-2 shows the flowchart of this nested loop.</p> <p></p> <p> Figure 2-2   Flowchart of nested loops </p> <p>In this case, the number of operations of the function is proportional to \\(n^2\\), or the algorithm's running time has a \"quadratic relationship\" with the input data size \\(n\\).</p> <p>We can continue adding nested loops, where each nesting is a \"dimension increase\", raising the time complexity to \"cubic relationship\", \"quartic relationship\", and so on.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222-recursion","level":2,"title":"2.2.2   Recursion","text":"<p>Recursion is an algorithmic strategy that solves problems by having a function call itself. It mainly consists of two phases.</p> <ol> <li>Descend: The program continuously calls itself deeper, usually passing in smaller or more simplified parameters, until reaching a \"termination condition\".</li> <li>Ascend: After triggering the \"termination condition\", the program returns layer by layer from the deepest recursive function, aggregating the result of each layer.</li> </ol> <p>From an implementation perspective, recursive code mainly consists of three elements.</p> <ol> <li>Termination condition: Used to determine when to switch from \"descending\" to \"ascending\".</li> <li>Recursive call: Corresponds to \"descending\", where the function calls itself, usually with smaller or more simplified parameters.</li> <li>Return result: Corresponds to \"ascending\", returning the result of the current recursion level to the previous layer.</li> </ol> <p>Observe the following code. We only need to call the function <code>recur(n)</code> to complete the calculation of \\(1 + 2 + \\dots + n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"Recursion\"\"\"\n    # Termination condition\n    if n == 1:\n        return 1\n    # Recurse: recursive call\n    res = recur(n - 1)\n    # Return: return result\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* Recursion */\nint Recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = Recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* Recursion */\nfunc recur(n int) int {\n    // Termination condition\n    if n == 1 {\n        return 1\n    }\n    // Recurse: recursive call\n    res := recur(n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* Recursion */\nfunc recur(n: Int) -&gt; Int {\n    // Termination condition\n    if n == 1 {\n        return 1\n    }\n    // Recurse: recursive call\n    let res = recur(n: n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* Recursion */\nfunction recur(n) {\n    // Termination condition\n    if (n === 1) return 1;\n    // Recurse: recursive call\n    const res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* Recursion */\nfunction recur(n: number): number {\n    // Termination condition\n    if (n === 1) return 1;\n    // Recurse: recursive call\n    const res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* Recursion */\nint recur(int n) {\n  // Termination condition\n  if (n == 1) return 1;\n  // Recurse: recursive call\n  int res = recur(n - 1);\n  // Return: return result\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* Recursion */\nfn recur(n: i32) -&gt; i32 {\n    // Termination condition\n    if n == 1 {\n        return 1;\n    }\n    // Recurse: recursive call\n    let res = recur(n - 1);\n    // Return: return result\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* Recursion */\nint recur(int n) {\n    // Termination condition\n    if (n == 1)\n        return 1;\n    // Recurse: recursive call\n    int res = recur(n - 1);\n    // Return: return result\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* Recursion */\nfun recur(n: Int): Int {\n    // Termination condition\n    if (n == 1)\n        return 1\n    // Descend: recursive call\n    val res = recur(n - 1)\n    // Return: return result\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### Recursion ###\ndef recur(n)\n  # Termination condition\n  return 1 if n == 1\n  # Recurse: recursive call\n  res = recur(n - 1)\n  # Return: return result\n  n + res\nend\n</code></pre> <p>Figure 2-3 shows the recursive process of this function.</p> <p></p> <p> Figure 2-3   Recursive process of the summation function </p> <p>Although from a computational perspective, iteration and recursion can achieve the same results, they represent two completely different paradigms for thinking about and solving problems.</p> <ul> <li>Iteration: Solves problems \"bottom-up\". Starting from the most basic steps, these steps are then repeatedly executed or accumulated until the task is complete.</li> <li>Recursion: Solves problems \"top-down\". The original problem is decomposed into smaller subproblems that have the same form as the original problem. These subproblems continue to be decomposed into even smaller subproblems until reaching the base case (where the solution is known).</li> </ul> <p>Taking the above summation function as an example, let the problem be \\(f(n) = 1 + 2 + \\dots + n\\).</p> <ul> <li>Iteration: Simulates the summation process in a loop, traversing from \\(1\\) to \\(n\\), performing the summation operation in each round to obtain \\(f(n)\\).</li> <li>Recursion: Decomposes the problem into the subproblem \\(f(n) = n + f(n-1)\\), continuously decomposing (recursively) until terminating at the base case \\(f(1) = 1\\).</li> </ul>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-call-stack","level":3,"title":"1.   Call Stack","text":"<p>Each time a recursive function calls itself, the system allocates memory for the newly opened function to store local variables, call addresses, and other information. This leads to two consequences.</p> <ul> <li>The function's context data is stored in a memory area called \"stack frame space\", which is not released until the function returns. Therefore, recursion usually consumes more memory space than iteration.</li> <li>Recursive function calls incur additional overhead. Therefore, recursion is usually less time-efficient than loops.</li> </ul> <p>As shown in Figure 2-4, before the termination condition is triggered, there are \\(n\\) unreturned recursive functions existing simultaneously, with a recursion depth of \\(n\\).</p> <p></p> <p> Figure 2-4   Recursion call depth </p> <p>In practice, the recursion depth allowed by programming languages is usually limited, and excessively deep recursion may lead to stack overflow errors.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-tail-recursion","level":3,"title":"2.   Tail Recursion","text":"<p>Interestingly, if a function makes the recursive call as the very last step before returning, the function can be optimized by the compiler or interpreter to have space efficiency comparable to iteration. This case is called tail recursion.</p> <ul> <li>Regular recursion: When a function returns to the previous level, it needs to continue executing code, so the system needs to save the context of the previous layer's call.</li> <li>Tail recursion: The recursive call is the last operation before the function returns, meaning that after returning to the previous level, there is no need to continue executing other operations, so the system does not need to save the context of the previous layer's function.</li> </ul> <p>Taking the calculation of \\(1 + 2 + \\dots + n\\) as an example, we can set the result variable <code>res</code> as a function parameter to implement tail recursion:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"Tail recursion\"\"\"\n    # Termination condition\n    if n == 0:\n        return res\n    # Tail recursive call\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* Tail recursion */\nint TailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* Tail recursion */\nfunc tailRecur(n int, res int) int {\n    // Termination condition\n    if n == 0 {\n        return res\n    }\n    // Tail recursive call\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* Tail recursion */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // Termination condition\n    if n == 0 {\n        return res\n    }\n    // Tail recursive call\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* Tail recursion */\nfunction tailRecur(n, res) {\n    // Termination condition\n    if (n === 0) return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* Tail recursion */\nfunction tailRecur(n: number, res: number): number {\n    // Termination condition\n    if (n === 0) return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n  // Termination condition\n  if (n == 0) return res;\n  // Tail recursive call\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* Tail recursion */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // Termination condition\n    if n == 0 {\n        return res;\n    }\n    // Tail recursive call\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* Tail recursion */\nint tailRecur(int n, int res) {\n    // Termination condition\n    if (n == 0)\n        return res;\n    // Tail recursive call\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* Tail recursion */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // Add tailrec keyword to enable tail recursion optimization\n    // Termination condition\n    if (n == 0)\n        return res\n    // Tail recursive call\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### Tail recursion ###\ndef tail_recur(n, res)\n  # Termination condition\n  return res if n == 0\n  # Tail recursive call\n  tail_recur(n - 1, res + n)\nend\n</code></pre> <p>The execution process of tail recursion is shown in Figure 2-5. Comparing regular recursion and tail recursion, the execution point of the summation operation is different.</p> <ul> <li>Regular recursion: The summation operation is performed during the \"ascending\" process, requiring an additional summation operation after each layer returns.</li> <li>Tail recursion: The summation operation is performed during the \"descending\" process; the \"ascending\" process only needs to return layer by layer.</li> </ul> <p></p> <p> Figure 2-5   Tail recursion process </p> <p>Tip</p> <p>Please note that many compilers or interpreters do not support tail recursion optimization. For example, Python does not support tail recursion optimization by default, so even if a function is in tail recursive form, it may still encounter stack overflow issues.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-recursion-tree","level":3,"title":"3.   Recursion Tree","text":"<p>When dealing with algorithmic problems related to \"divide and conquer\", recursion often provides a more intuitive approach and more readable code than iteration. Taking the \"Fibonacci sequence\" as an example.</p> <p>Question</p> <p>Given a Fibonacci sequence \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\), find the \\(n\\)-th number in the sequence.</p> <p>Let the \\(n\\)-th number of the Fibonacci sequence be \\(f(n)\\). Two conclusions can be easily obtained.</p> <ul> <li>The first two numbers of the sequence are \\(f(1) = 0\\) and \\(f(2) = 1\\).</li> <li>Each number in the sequence is the sum of the previous two numbers, i.e., \\(f(n) = f(n - 1) + f(n - 2)\\).</li> </ul> <p>Following the recurrence relation to make recursive calls, with the first two numbers as termination conditions, we can write the recursive code. Calling <code>fib(n)</code> will give us the \\(n\\)-th number of the Fibonacci sequence:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"Fibonacci sequence: recursion\"\"\"\n    # Termination condition f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # Recursive call f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # Return result f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Fibonacci sequence: recursion */\nint Fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Fibonacci sequence: recursion */\nfunc fib(n int) int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Fibonacci sequence: recursion */\nfunc fib(n: Int) -&gt; Int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Fibonacci sequence: recursion */\nfunction fib(n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Fibonacci sequence: recursion */\nfunction fib(n: number): number {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n  // Termination condition f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // Recursive call f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // Return result f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Fibonacci sequence: recursion */\nfn fib(n: i32) -&gt; i32 {\n    // Termination condition f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // Return result\n    res\n}\n</code></pre> recursion.c<pre><code>/* Fibonacci sequence: recursion */\nint fib(int n) {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Return result f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Fibonacci sequence: recursion */\nfun fib(n: Int): Int {\n    // Termination condition f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // Recursive call f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // Return result f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Fibonacci sequence: recursion ###\ndef fib(n)\n  # Termination condition f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # Recursive call f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # Return result f(n)\n  res\nend\n</code></pre> <p>Observing the above code, we recursively call two functions within the function, meaning that one call produces two call branches. As shown in Figure 2-6, such continuous recursive calling will eventually produce a recursion tree with \\(n\\) levels.</p> <p></p> <p> Figure 2-6   Recursion tree of the Fibonacci sequence </p> <p>Fundamentally, recursion embodies the paradigm of \"decomposing a problem into smaller subproblems\", and this divide-and-conquer strategy is crucial.</p> <ul> <li>From an algorithmic perspective, many important algorithmic strategies such as searching, sorting, backtracking, divide and conquer, and dynamic programming directly or indirectly apply this way of thinking.</li> <li>From a data structure perspective, recursion is naturally suited for handling problems related to linked lists, trees, and graphs, because they are well-suited for analysis using divide-and-conquer thinking.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223-comparison-of-the-two","level":2,"title":"2.2.3   Comparison of the Two","text":"<p>Summarizing the above content, as shown in Table 2-1, iteration and recursion differ in implementation, performance, and applicability.</p> <p> Table 2-1   Comparison of iteration and recursion characteristics </p> Iteration Recursion Implementation Loop structure Function calls itself Time efficiency Generally more efficient, no function call overhead Each function call incurs overhead Memory usage Usually uses a fixed amount of memory space Accumulated function calls may use a large amount of stack frame space Suitable problems Suitable for simple loop tasks, with intuitive and readable code Suitable for subproblem decomposition, such as trees, graphs, divide and conquer, backtracking, etc., with concise and clear code structure <p>Tip</p> <p>If you find the following content difficult to understand, you can review it after reading the \"Stack\" chapter.</p> <p>What is the intrinsic relationship between iteration and recursion? Taking the above recursive function as an example, the summation operation is performed during the \"ascending\" phase of recursion. This means that the function called first actually completes its summation operation last, and this working mechanism is similar to the \"last-in, first-out\" principle of stacks.</p> <p>In fact, recursive terminology such as \"call stack\" and \"stack frame space\" already hints at the close relationship between recursion and stacks.</p> <ol> <li>Descend: When a function is called, the system allocates a new stack frame on the \"call stack\" for that function to store the function's local variables, parameters, return address, and other data.</li> <li>Ascend: When the function completes execution and returns, the corresponding stack frame is removed from the \"call stack\", restoring the execution environment of the previous function.</li> </ol> <p>Therefore, we can use an explicit stack to simulate the behavior of the call stack, thus transforming recursion into iterative form:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"Simulate recursion using iteration\"\"\"\n    # Use an explicit stack to simulate the system call stack\n    stack = []\n    res = 0\n    # Recurse: recursive call\n    for i in range(n, 0, -1):\n        # Simulate \"recurse\" with \"push\"\n        stack.append(i)\n    # Return: return result\n    while stack:\n        # Simulate \"return\" with \"pop\"\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (!stack.empty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (!stack.isEmpty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Simulate recursion using iteration */\nint ForLoopRecur(int n) {\n    // Use an explicit stack to simulate the system call stack\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.Push(i);\n    }\n    // Return: return result\n    while (stack.Count &gt; 0) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Simulate recursion using iteration */\nfunc forLoopRecur(n int) int {\n    // Use an explicit stack to simulate the system call stack\n    stack := list.New()\n    res := 0\n    // Recurse: recursive call\n    for i := n; i &gt; 0; i-- {\n        // Simulate \"recurse\" with \"push\"\n        stack.PushBack(i)\n    }\n    // Return: return result\n    for stack.Len() != 0 {\n        // Simulate \"return\" with \"pop\"\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Simulate recursion using iteration */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // Use an explicit stack to simulate the system call stack\n    var stack: [Int] = []\n    var res = 0\n    // Recurse: recursive call\n    for i in (1 ... n).reversed() {\n        // Simulate \"recurse\" with \"push\"\n        stack.append(i)\n    }\n    // Return: return result\n    while !stack.isEmpty {\n        // Simulate \"return\" with \"pop\"\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Simulate recursion using iteration */\nfunction forLoopRecur(n) {\n    // Use an explicit stack to simulate the system call stack\n    const stack = [];\n    let res = 0;\n    // Recurse: recursive call\n    for (let i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (stack.length) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Simulate recursion using iteration */\nfunction forLoopRecur(n: number): number {\n    // Use an explicit stack to simulate the system call stack\n    const stack: number[] = [];\n    let res: number = 0;\n    // Recurse: recursive call\n    for (let i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while (stack.length) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n  // Use an explicit stack to simulate the system call stack\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // Recurse: recursive call\n  for (int i = n; i &gt; 0; i--) {\n    // Simulate \"recurse\" with \"push\"\n    stack.add(i);\n  }\n  // Return: return result\n  while (!stack.isEmpty) {\n    // Simulate \"return\" with \"pop\"\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Simulate recursion using iteration */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // Use an explicit stack to simulate the system call stack\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // Recurse: recursive call\n    for i in (1..=n).rev() {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i);\n    }\n    // Return: return result\n    while !stack.is_empty() {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* Simulate recursion using iteration */\nint forLoopRecur(int n) {\n    int stack[1000]; // Use a large array to simulate stack\n    int top = -1;    // Stack top index\n    int res = 0;\n    // Recurse: recursive call\n    for (int i = n; i &gt; 0; i--) {\n        // Simulate \"recurse\" with \"push\"\n        stack[1 + top++] = i;\n    }\n    // Return: return result\n    while (top &gt;= 0) {\n        // Simulate \"return\" with \"pop\"\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Simulate recursion using iteration */\nfun forLoopRecur(n: Int): Int {\n    // Use an explicit stack to simulate the system call stack\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // Descend: recursive call\n    for (i in n downTo 0) {\n        // Simulate \"recurse\" with \"push\"\n        stack.push(i)\n    }\n    // Return: return result\n    while (stack.isNotEmpty()) {\n        // Simulate \"return\" with \"pop\"\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Use iteration to simulate recursion ###\ndef for_loop_recur(n)\n  # Use an explicit stack to simulate the system call stack\n  stack = []\n  res = 0\n\n  # Recurse: recursive call\n  for i in n.downto(0)\n    # Simulate \"recurse\" with \"push\"\n    stack &lt;&lt; i\n  end\n  # Return: return result\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> <p>Observing the above code, when recursion is transformed into iteration, the code becomes more complex. Although iteration and recursion can be converted into each other in many cases, it may not be worthwhile to do so for the following two reasons.</p> <ul> <li>The transformed code may be more difficult to understand and less readable.</li> <li>For some complex problems, simulating the behavior of the system call stack can be very difficult.</li> </ul> <p>In summary, choosing between iteration and recursion depends on the nature of the specific problem. In programming practice, it is crucial to weigh the pros and cons of both and choose the appropriate method based on the context.</p>","path":["Chapter 2. Complexity Analysis","2.2 &nbsp; Iteration and Recursion"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   Algorithm Efficiency Evaluation","text":"<p>In algorithm design, we pursue the following two levels of objectives sequentially.</p> <ol> <li>Finding a solution to the problem: The algorithm must reliably obtain the correct solution within the specified input range.</li> <li>Seeking the optimal solution: Multiple solutions may exist for the same problem, and we hope to find an algorithm that is as efficient as possible.</li> </ol> <p>In other words, under the premise of being able to solve the problem, algorithm efficiency has become the primary evaluation criterion for measuring the quality of algorithms. It includes the following two dimensions.</p> <ul> <li>Time efficiency: The length of time the algorithm runs.</li> <li>Space efficiency: The size of memory space the algorithm occupies.</li> </ul> <p>In short, our goal is to design data structures and algorithms that are \"both fast and memory-efficient\". Effectively evaluating algorithm efficiency is crucial, because only in this way can we compare various algorithms and guide the algorithm design and optimization process.</p> <p>Efficiency evaluation methods are mainly divided into two types: actual testing and theoretical estimation.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211-actual-testing","level":2,"title":"2.1.1   Actual Testing","text":"<p>Suppose we now have algorithm <code>A</code> and algorithm <code>B</code>, both of which can solve the same problem, and we need to compare the efficiency of these two algorithms. The most direct method is to find a computer, run these two algorithms, and monitor and record their running time and memory usage. This evaluation approach can reflect the real situation, but it also has considerable limitations.</p> <p>On one hand, it is difficult to eliminate interference factors from the testing environment. Hardware configuration affects the performance of algorithms. For example, if an algorithm has a high degree of parallelism, it is more suitable for running on multi-core CPUs; if an algorithm has intensive memory operations, it will perform better on high-performance memory. In other words, the test results of an algorithm on different machines may be inconsistent. This means we need to test on various machines and calculate average efficiency, which is impractical.</p> <p>On the other hand, conducting complete testing is very resource-intensive. As the input data volume changes, the algorithm will exhibit different efficiencies. For example, when the input data volume is small, the running time of algorithm <code>A</code> is shorter than algorithm <code>B</code>; but when the input data volume is large, the test results may be exactly the opposite. Therefore, to obtain convincing conclusions, we need to test input data of various scales, which requires a large amount of computational resources.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212-theoretical-estimation","level":2,"title":"2.1.2   Theoretical Estimation","text":"<p>Since actual testing has considerable limitations, we can consider evaluating algorithm efficiency through calculations alone. This estimation method is called asymptotic complexity analysis, or complexity analysis for short.</p> <p>Complexity analysis can reflect the relationship between the time and space resources required for algorithm execution and the input data scale. It describes the growth trend of the time and space required for algorithm execution as the input data scale increases. This definition is somewhat convoluted, so we can break it down into three key points to understand.</p> <ul> <li>\"Time and space resources\" correspond to time complexity and space complexity, respectively.</li> <li>\"As the input data scale increases\" means that complexity reflects the relationship between algorithm running efficiency and input data scale.</li> <li>\"Growth trend of time and space\" indicates that complexity analysis focuses not on the specific values of running time or occupied space, but on how \"fast\" time or space grows.</li> </ul> <p>Complexity analysis overcomes the drawbacks of the actual testing method, reflected in the following aspects.</p> <ul> <li>It does not need to actually run the code, making it more environmentally friendly and energy-efficient.</li> <li>It is independent of the testing environment, and the analysis results are applicable to all running platforms.</li> <li>It can reflect algorithm efficiency at different data volumes, especially algorithm performance at large data volumes.</li> </ul> <p>Tip</p> <p>If you are still confused about the concept of complexity, don't worry—we will introduce it in detail in subsequent chapters.</p> <p>Complexity analysis provides us with a \"ruler\" for evaluating algorithm efficiency, allowing us to measure the time and space resources required to execute a certain algorithm and compare the efficiency between different algorithms.</p> <p>Complexity is a mathematical concept that may be relatively abstract for beginners, with a relatively high learning difficulty. From this perspective, complexity analysis may not be very suitable as the first content to be introduced. However, when we discuss the characteristics of a certain data structure or algorithm, it is difficult to avoid analyzing its running speed and space usage.</p> <p>In summary, it is recommended that before diving deep into data structures and algorithms, you first establish a preliminary understanding of complexity analysis so that you can complete complexity analysis of simple algorithms.</p>","path":["Chapter 2. Complexity Analysis","2.1 &nbsp; Algorithm Efficiency Evaluation"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   Space Complexity","text":"<p>Space complexity measures the growth trend of memory space occupied by an algorithm as the data size increases. This concept is very similar to time complexity, except that \"running time\" is replaced with \"occupied memory space\".</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241-algorithm-related-space","level":2,"title":"2.4.1   Algorithm-Related Space","text":"<p>The memory space used by an algorithm during execution mainly includes the following types.</p> <ul> <li>Input space: Used to store the input data of the algorithm.</li> <li>Temporary space: Used to store variables, objects, function contexts, and other data during the algorithm's execution.</li> <li>Output space: Used to store the output data of the algorithm.</li> </ul> <p>In general, the scope of space complexity statistics is \"temporary space\" plus \"output space\".</p> <p>Temporary space can be further divided into three parts.</p> <ul> <li>Temporary data: Used to save various constants, variables, objects, etc., during the algorithm's execution.</li> <li>Stack frame space: Used to save the context data of called functions. The system creates a stack frame at the top of the stack each time a function is called, and the stack frame space is released after the function returns.</li> <li>Instruction space: Used to save compiled program instructions, which are usually ignored in actual statistics.</li> </ul> <p>When analyzing the space complexity of a program, we usually count three parts: temporary data, stack frame space, and output data, as shown in the following figure.</p> <p></p> <p> Figure 2-15   Algorithm-related space </p> <p>The related code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"Class\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # Node value\n        self.next: Node | None = None  # Reference to the next node\n\ndef function() -&gt; int:\n    \"\"\"Function\"\"\"\n    # Perform some operations...\n    return 0\n\ndef algorithm(n) -&gt; int:  # Input data\n    A = 0                 # Temporary data (constant, usually represented by uppercase letters)\n    b = 0                 # Temporary data (variable)\n    node = Node(0)        # Temporary data (object)\n    c = function()        # Stack frame space (function call)\n    return A + b + c      # Output data\n</code></pre> <pre><code>/* Structure */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Function */\nint func() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) {        // Input data\n    const int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node* node = new Node(0); // Temporary data (object)\n    int c = func();           // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Function */\nint function() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) {        // Input data\n    final int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node node = new Node(0);  // Temporary data (object)\n    int c = function();       // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* Function */\nint Function() {\n    // Perform some operations...\n    return 0;\n}\n\nint Algorithm(int n) {        // Input data\n    const int a = 0;          // Temporary data (constant)\n    int b = 0;                // Temporary data (variable)\n    Node node = new(0);       // Temporary data (object)\n    int c = Function();       // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Structure */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Create node structure */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* Function */\nfunc function() int {\n    // Perform some operations...\n    return 0\n}\n\nfunc algorithm(n int) int { // Input data\n    const a = 0             // Temporary data (constant)\n    b := 0                  // Temporary data (variable)\n    newNode(0)              // Temporary data (object)\n    c := function()         // Stack frame space (function call)\n    return a + b + c        // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Function */\nfunc function() -&gt; Int {\n    // Perform some operations...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // Input data\n    let a = 0             // Temporary data (constant)\n    var b = 0             // Temporary data (variable)\n    let node = Node(x: 0) // Temporary data (object)\n    let c = function()    // Stack frame space (function call)\n    return a + b + c      // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.next = null;                       // Reference to the next node\n    }\n}\n\n/* Function */\nfunction constFunc() {\n    // Perform some operations\n    return 0;\n}\n\nfunction algorithm(n) {       // Input data\n    const a = 0;              // Temporary data (constant)\n    let b = 0;                // Temporary data (variable)\n    const node = new Node(0); // Temporary data (object)\n    const c = constFunc();    // Stack frame space (function call)\n    return a + b + c;         // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.next = null;                       // Reference to the next node\n    }\n}\n\n/* Function */\nfunction constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n\nfunction algorithm(n: number): number { // Input data\n    const a = 0;                        // Temporary data (constant)\n    let b = 0;                          // Temporary data (variable)\n    const node = new Node(0);           // Temporary data (object)\n    const c = constFunc();              // Stack frame space (function call)\n    return a + b + c;                   // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Function */\nint function() {\n  // Perform some operations...\n  return 0;\n}\n\nint algorithm(int n) {  // Input data\n  const int a = 0;      // Temporary data (constant)\n  int b = 0;            // Temporary data (variable)\n  Node node = Node(0);  // Temporary data (object)\n  int c = function();   // Stack frame space (function call)\n  return a + b + c;     // Output data\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Structure */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Create Node structure */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Function */\nfn function() -&gt; i32 {\n    // Perform some operations...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // Input data\n    const a: i32 = 0;               // Temporary data (constant)\n    let mut b = 0;                  // Temporary data (variable)\n    let node = Node::new(0);        // Temporary data (object)\n    let c = function();             // Stack frame space (function call)\n    return a + b + c;               // Output data\n}\n</code></pre> <pre><code>/* Function */\nint func() {\n    // Perform some operations...\n    return 0;\n}\n\nint algorithm(int n) { // Input data\n    const int a = 0;   // Temporary data (constant)\n    int b = 0;         // Temporary data (variable)\n    int c = func();    // Stack frame space (function call)\n    return a + b + c;  // Output data\n}\n</code></pre> <pre><code>/* Class */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* Function */\nfun function(): Int {\n    // Perform some operations...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // Input data\n    val a = 0                // Temporary data (constant)\n    var b = 0                // Temporary data (variable)\n    val node = Node(0)       // Temporary data (object)\n    val c = function()       // Stack frame space (function call)\n    return a + b + c         // Output data\n}\n</code></pre> <pre><code>### Class ###\nclass Node\n    attr_accessor :val      # Node value\n    attr_accessor :next     # Reference to the next node\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### Function ###\ndef function\n    # Perform some operations...\n    0\nend\n\n### Algorithm ###\ndef algorithm(n)        # Input data\n    a = 0               # Temporary data (constant)\n    b = 0               # Temporary data (variable)\n    node = Node.new(0)  # Temporary data (object)\n    c = function        # Stack frame space (function call)\n    a + b + c           # Output data\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242-calculation-method","level":2,"title":"2.4.2   Calculation Method","text":"<p>The calculation method for space complexity is roughly the same as for time complexity, except that the statistical object is changed from \"number of operations\" to \"size of space used\".</p> <p>Unlike time complexity, we usually only focus on the worst-case space complexity. This is because memory space is a hard requirement, and we must ensure that sufficient memory space is reserved for all input data.</p> <p>Observe the following code. The \"worst case\" in worst-case space complexity has two meanings.</p> <ol> <li>Based on the worst input data: When \\(n &lt; 10\\), the space complexity is \\(O(1)\\); but when \\(n &gt; 10\\), the initialized array <code>nums</code> occupies \\(O(n)\\) space, so the worst-case space complexity is \\(O(n)\\).</li> <li>Based on the peak memory during algorithm execution: For example, before executing the last line, the program occupies \\(O(1)\\) space; when initializing the array <code>nums</code>, the program occupies \\(O(n)\\) space, so the worst-case space complexity is \\(O(n)\\).</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>In recursive functions, it is necessary to count the stack frame space. Observe the following code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # Perform some operations\n    return 0\n\ndef loop(n: int):\n    \"\"\"Loop has space complexity of O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Recursion has space complexity of O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // Perform some operations\n    return 0\n}\n\n/* Loop has space complexity of O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* Recursion has space complexity of O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // Perform some operations\n    return 0\n}\n\n/* Loop has space complexity of O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* Recursion has space complexity of O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // Perform some operations\n  return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Recursion has space complexity of O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // Perform some operations\n    return 0;\n}\n/* Loop has space complexity of O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Recursion has space complexity of O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // Perform some operations\n    return 0\n}\n/* Loop has space complexity of O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* Recursion has space complexity of O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # Perform some operations\n    0\nend\n\n### Loop has space complexity of O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### Recursion has space complexity of O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>The time complexity of both functions <code>loop()</code> and <code>recur()</code> is \\(O(n)\\), but their space complexities are different.</p> <ul> <li>The function <code>loop()</code> calls <code>function()</code> \\(n\\) times in a loop. In each iteration, <code>function()</code> returns and releases its stack frame space, so the space complexity remains \\(O(1)\\).</li> <li>The recursive function <code>recur()</code> has \\(n\\) unreturned <code>recur()</code> instances existing simultaneously during execution, thus occupying \\(O(n)\\) stack frame space.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243-common-types","level":2,"title":"2.4.3   Common Types","text":"<p>Let the input data size be \\(n\\). The following figure shows common types of space complexity (arranged from low to high).</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{Constant} &lt; \\text{Logarithmic} &lt; \\text{Linear} &lt; \\text{Quadratic} &lt; \\text{Exponential} \\end{aligned} \\] <p></p> <p> Figure 2-16   Common types of space complexity </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-constant-order-o1","level":3,"title":"1.   Constant Order \\(O(1)\\)","text":"<p>Constant order is common in constants, variables, and objects whose quantity is independent of the input data size \\(n\\).</p> <p>It should be noted that memory occupied by initializing variables or calling functions in a loop is released when entering the next iteration, so it does not accumulate space, and the space complexity remains \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"Function\"\"\"\n    # Perform some operations\n    return 0\n\ndef constant(n: int):\n    \"\"\"Constant order\"\"\"\n    # Constants, variables, objects occupy O(1) space\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # Variables in the loop occupy O(1) space\n    for _ in range(n):\n        c = 0\n    # Functions in the loop occupy O(1) space\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* Function */\nint func() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Function */\nint function() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Function */\nint Function() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid Constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Function */\nfunc function() int {\n    // Perform some operations...\n    return 0\n}\n\n/* Constant order */\nfunc spaceConstant(n int) {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // Variables in the loop occupy O(1) space\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* Function */\n@discardableResult\nfunc function() -&gt; Int {\n    // Perform some operations\n    return 0\n}\n\n/* Constant order */\nfunc constant(n: Int) {\n    // Constants, variables, objects occupy O(1) space\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // Variables in the loop occupy O(1) space\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* Function */\nfunction constFunc() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nfunction constant(n) {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Function */\nfunction constFunc(): number {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nfunction constant(n: number): void {\n    // Constants, variables, objects occupy O(1) space\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Variables in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Function */\nint function() {\n  // Perform some operations\n  return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n  // Constants, variables, objects occupy O(1) space\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // Variables in the loop occupy O(1) space\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // Functions in the loop occupy O(1) space\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Function */\nfn function() -&gt; i32 {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\n#[allow(unused)]\nfn constant(n: i32) {\n    // Constants, variables, objects occupy O(1) space\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // Variables in the loop occupy O(1) space\n    for i in 0..n {\n        let c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Function */\nint func() {\n    // Perform some operations\n    return 0;\n}\n\n/* Constant order */\nvoid constant(int n) {\n    // Constants, variables, objects occupy O(1) space\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // Variables in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Functions in the loop occupy O(1) space\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Function */\nfun function(): Int {\n    // Perform some operations\n    return 0\n}\n\n/* Constant order */\nfun constant(n: Int) {\n    // Constants, variables, objects occupy O(1) space\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // Variables in the loop occupy O(1) space\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // Functions in the loop occupy O(1) space\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Function ###\ndef function\n  # Perform some operations\n  0\nend\n\n### Constant time ###\ndef constant(n)\n  # Constants, variables, objects occupy O(1) space\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # Variables in the loop occupy O(1) space\n  (0...n).each { c = 0 }\n  # Functions in the loop occupy O(1) space\n  (0...n).each { function }\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-linear-order-on","level":3,"title":"2.   Linear Order \\(O(n)\\)","text":"<p>Linear order is common in arrays, linked lists, stacks, queues, etc., where the number of elements is proportional to \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"Linear order\"\"\"\n    # A list of length n occupies O(n) space\n    nums = [0] * n\n    # A hash table of length n occupies O(n) space\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    vector&lt;int&gt; nums(n);\n    // A list of length n occupies O(n) space\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    int[] nums = new int[n];\n    // A list of length n occupies O(n) space\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Linear order */\nvoid Linear(int n) {\n    // Array of length n uses O(n) space\n    int[] nums = new int[n];\n    // A list of length n occupies O(n) space\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Linear order */\nfunc spaceLinear(n int) {\n    // Array of length n uses O(n) space\n    _ = make([]int, n)\n    // A list of length n occupies O(n) space\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // A hash table of length n occupies O(n) space\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Linear order */\nfunc linear(n: Int) {\n    // Array of length n uses O(n) space\n    let nums = Array(repeating: 0, count: n)\n    // A list of length n occupies O(n) space\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // A hash table of length n occupies O(n) space\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* Linear order */\nfunction linear(n) {\n    // Array of length n uses O(n) space\n    const nums = new Array(n);\n    // A list of length n occupies O(n) space\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Linear order */\nfunction linear(n: number): void {\n    // Array of length n uses O(n) space\n    const nums = new Array(n);\n    // A list of length n occupies O(n) space\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // A hash table of length n occupies O(n) space\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Linear order */\nvoid linear(int n) {\n  // Array of length n uses O(n) space\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // A list of length n occupies O(n) space\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // A hash table of length n occupies O(n) space\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Linear order */\n#[allow(unused)]\nfn linear(n: i32) {\n    // Array of length n uses O(n) space\n    let mut nums = vec![0; n as usize];\n    // A list of length n occupies O(n) space\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // A hash table of length n occupies O(n) space\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Hash table */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Implemented using uthash.h\n} HashTable;\n\n/* Linear order */\nvoid linear(int n) {\n    // Array of length n uses O(n) space\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // A list of length n occupies O(n) space\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // Memory release\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // A hash table of length n occupies O(n) space\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // Memory release\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Linear order */\nfun linear(n: Int) {\n    // Array of length n uses O(n) space\n    val nums = Array(n) { 0 }\n    // A list of length n occupies O(n) space\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // A hash table of length n occupies O(n) space\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Linear time ###\ndef linear(n)\n  # A list of length n occupies O(n) space\n  nums = Array.new(n, 0)\n\n  # A hash table of length n occupies O(n) space\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> <p>As shown in the following figure, the recursion depth of this function is \\(n\\), meaning that there are \\(n\\) unreturned <code>linear_recur()</code> functions existing simultaneously, using \\(O(n)\\) stack frame space:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"Linear order (recursive implementation)\"\"\"\n    print(\"Recursion n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"Recursion n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    System.out.println(\"Recursion n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Linear order (recursive implementation) */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"Recursion n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Linear order (recursive implementation) */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"Recursion n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Linear order (recursive implementation) */\nfunc linearRecur(n: Int) {\n    print(\"Recursion n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Linear order (recursive implementation) */\nfunction linearRecur(n) {\n    console.log(`Recursion n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Linear order (recursive implementation) */\nfunction linearRecur(n: number): void {\n    console.log(`Recursion n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n  print('Recursion n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Linear order (recursive implementation) */\nfn linear_recur(n: i32) {\n    println!(\"Recursion n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Linear order (recursive implementation) */\nvoid linearRecur(int n) {\n    printf(\"Recursion n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* Linear order (recursive implementation) */\nfun linearRecur(n: Int) {\n    println(\"Recursion n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Linear space (recursive) ###\ndef linear_recur(n)\n  puts \"Recursion n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> <p></p> <p> Figure 2-17   Linear order space complexity generated by recursive function </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-quadratic-order-on2","level":3,"title":"3.   Quadratic Order \\(O(n^2)\\)","text":"<p>Quadratic order is common in matrices and graphs, where the number of elements is quadratically related to \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"Quadratic order\"\"\"\n    # A 2D list occupies O(n^2) space\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // 2D list uses O(n^2) space\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // Matrix uses O(n^2) space\n    int[][] numMatrix = new int[n][n];\n    // 2D list uses O(n^2) space\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Exponential order */\nvoid Quadratic(int n) {\n    // Matrix uses O(n^2) space\n    int[,] numMatrix = new int[n, n];\n    // 2D list uses O(n^2) space\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Exponential order */\nfunc spaceQuadratic(n int) {\n    // Matrix uses O(n^2) space\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Exponential order */\nfunc quadratic(n: Int) {\n    // 2D list uses O(n^2) space\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* Exponential order */\nfunction quadratic(n) {\n    // Matrix uses O(n^2) space\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 2D list uses O(n^2) space\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Exponential order */\nfunction quadratic(n: number): void {\n    // Matrix uses O(n^2) space\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 2D list uses O(n^2) space\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n  // Matrix uses O(n^2) space\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 2D list uses O(n^2) space\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Exponential order */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // Matrix uses O(n^2) space\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 2D list uses O(n^2) space\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Exponential order */\nvoid quadratic(int n) {\n    // 2D list uses O(n^2) space\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // Memory release\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* Exponential order */\nfun quadratic(n: Int) {\n    // Matrix uses O(n^2) space\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 2D list uses O(n^2) space\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Quadratic time ###\ndef quadratic(n)\n  # 2D list uses O(n^2) space\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> <p>As shown in the following figure, the recursion depth of this function is \\(n\\), and an array is initialized in each recursive function with lengths of \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\), with an average length of \\(n / 2\\), thus occupying \\(O(n^2)\\) space overall:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"Quadratic order (recursive implementation)\"\"\"\n    if n &lt;= 0:\n        return 0\n    # Array nums length is n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"In recursion n = \" &lt;&lt; n &lt;&lt; \", nums length = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // Array nums has length n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"In recursion n = \" + n + \", nums length = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Quadratic order (recursive implementation) */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"Recursion n = \" + n + \", nums length = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Quadratic order (recursive implementation) */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"In recursion n = %d, nums length = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Quadratic order (recursive implementation) */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // Array nums has length n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"In recursion n = \\(n), nums length = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Quadratic order (recursive implementation) */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`In recursion n = ${n}, nums length = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Quadratic order (recursive implementation) */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`In recursion n = ${n}, nums length = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('In recursion n = $n, nums length = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Quadratic order (recursive implementation) */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // Array nums has length n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"In recursion n = {}, nums length = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Quadratic order (recursive implementation) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"In recursion n = %d, nums length = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* Quadratic order (recursive implementation) */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // Array nums has length n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"In recursion n = $n, nums length = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Quadratic space (recursive) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Array nums has length n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> <p></p> <p> Figure 2-18   Quadratic order space complexity generated by recursive function </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-exponential-order-o2n","level":3,"title":"4.   Exponential Order \\(O(2^n)\\)","text":"<p>Exponential order is common in binary trees. Observe the following figure: a \"full binary tree\" with \\(n\\) levels has \\(2^n - 1\\) nodes, occupying \\(O(2^n)\\) space:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"Exponential order (build full binary tree)\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* Driver Code */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* Driver Code */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* Driver Code */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* Driver Code */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* Driver Code */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* Driver Code */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* Driver Code */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* Driver Code */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* Driver Code */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* Driver Code */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* Driver Code */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### Exponential space (build full binary tree) ###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> <p></p> <p> Figure 2-19   Exponential order space complexity generated by full binary tree </p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-logarithmic-order-olog-n","level":3,"title":"5.   Logarithmic Order \\(O(\\log n)\\)","text":"<p>Logarithmic order is common in divide-and-conquer algorithms. For example, merge sort: given an input array of length \\(n\\), each recursion divides the array in half from the midpoint, forming a recursion tree of height \\(\\log n\\), using \\(O(\\log n)\\) stack frame space.</p> <p>Another example is converting a number to a string. Given a positive integer \\(n\\), it has \\(\\lfloor \\log_{10} n \\rfloor + 1\\) digits, i.e., the corresponding string length is \\(\\lfloor \\log_{10} n \\rfloor + 1\\), so the space complexity is \\(O(\\log_{10} n + 1) = O(\\log n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244-trading-time-for-space","level":2,"title":"2.4.4   Trading Time for Space","text":"<p>Ideally, we hope that both the time complexity and space complexity of an algorithm can reach optimal. However, in practice, optimizing both time complexity and space complexity simultaneously is usually very difficult.</p> <p>Reducing time complexity usually comes at the cost of increasing space complexity, and vice versa. The approach of sacrificing memory space to improve algorithm execution speed is called \"trading space for time\"; conversely, it is called \"trading time for space\".</p> <p>The choice of which approach depends on which aspect we value more. In most cases, time is more precious than space, so \"trading space for time\" is usually the more common strategy. Of course, when the data volume is very large, controlling space complexity is also very important.</p>","path":["Chapter 2. Complexity Analysis","2.4 &nbsp; Space Complexity"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   Summary","text":"","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<p>Algorithm Efficiency Assessment</p> <ul> <li>Time efficiency and space efficiency are the two primary evaluation metrics for measuring algorithm performance.</li> <li>We can evaluate algorithm efficiency through actual testing, but it is difficult to eliminate the influence of the testing environment, and it consumes substantial computational resources.</li> <li>Complexity analysis can eliminate the drawbacks of actual testing, with results applicable to all running platforms, and it can reveal algorithm efficiency under different data scales.</li> </ul> <p>Time Complexity</p> <ul> <li>Time complexity is used to measure the trend of algorithm runtime as data volume increases. It can effectively evaluate algorithm efficiency, but may fail in certain situations, such as when the input data volume is small or when time complexities are identical, making it impossible to precisely compare algorithm efficiency.</li> <li>Worst-case time complexity is represented using Big \\(O\\) notation, corresponding to the asymptotic upper bound of a function, reflecting the growth level of the number of operations \\(T(n)\\) as \\(n\\) approaches positive infinity.</li> <li>Deriving time complexity involves two steps: first, counting the number of operations, then determining the asymptotic upper bound.</li> <li>Common time complexities arranged from low to high include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\), and \\(O(n!)\\).</li> <li>The time complexity of some algorithms is not fixed, but rather depends on the distribution of input data. Time complexity is divided into worst-case, best-case, and average-case time complexity. Best-case time complexity is rarely used because input data generally needs to satisfy strict conditions to achieve the best case.</li> <li>Average time complexity reflects the algorithm's runtime efficiency under random data input, and is closest to the algorithm's performance in practical applications. Calculating average time complexity requires statistical analysis of input data distribution and the combined mathematical expectation.</li> </ul> <p>Space Complexity</p> <ul> <li>Space complexity serves a similar purpose to time complexity, used to measure the trend of algorithm memory usage as data volume increases.</li> <li>The memory space related to algorithm execution can be divided into input space, temporary space, and output space. Typically, input space is not included in space complexity calculations. Temporary space can be divided into temporary data, stack frame space, and instruction space, where stack frame space usually affects space complexity only in recursive functions.</li> <li>We typically only focus on worst-case space complexity, which is the space complexity of an algorithm under worst-case input data and worst-case runtime.</li> <li>Common space complexities arranged from low to high include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\), and \\(O(2^n)\\).</li> </ul>","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is the space complexity of tail recursion \\(O(1)\\)?</p> <p>Theoretically, the space complexity of tail recursive functions can be optimized to \\(O(1)\\). However, most programming languages (such as Java, Python, C++, Go, C#, etc.) do not support automatic tail recursion optimization, so the space complexity is generally considered to be \\(O(n)\\).</p> <p>Q: What is the difference between the terms function and method?</p> <p>A function can be executed independently, with all parameters passed explicitly. A method is associated with an object, is implicitly passed to the object that invokes it, and can operate on data contained in class instances.</p> <p>The following examples use several common programming languages for illustration.</p> <ul> <li>C is a procedural programming language without object-oriented concepts, so it only has functions. However, we can simulate object-oriented programming by creating structures (struct), and functions associated with structures are equivalent to methods in other programming languages.</li> <li>Java and C# are object-oriented programming languages where code blocks (methods) are typically part of a class. Static methods behave like functions because they are bound to the class and cannot access specific instance variables.</li> <li>C++ and Python support both procedural programming (functions) and object-oriented programming (methods).</li> </ul> <p>Q: Does the diagram for \"common space complexity types\" reflect the absolute size of occupied space?</p> <p>No, the diagram shows space complexity, which reflects growth trends rather than the absolute size of occupied space.</p> <p>Assuming \\(n = 8\\), you might find that the values of each curve do not correspond to the functions. This is because each curve contains a constant term used to compress the value range into a visually comfortable range.</p> <p>In practice, because we generally do not know what the \"constant term\" complexity of each method is, we usually cannot select the optimal solution for \\(n = 8\\) based on complexity alone. But for \\(n = 8^5\\), the choice is straightforward, as the growth trend already dominates.</p> <p>Q: Are there situations where algorithms are designed to sacrifice time (or space) based on actual use cases?</p> <p>In practical applications, most situations choose to sacrifice space for time. For example, with database indexes, we typically choose to build B+ trees or hash indexes, occupying substantial memory space in exchange for efficient queries of \\(O(\\log n)\\) or even \\(O(1)\\).</p> <p>In scenarios where space resources are precious, time may be sacrificed for space. For example, in embedded development, device memory is precious, and engineers may forgo using hash tables and choose to use array sequential search to save memory usage, at the cost of slower searches.</p>","path":["Chapter 2. Complexity Analysis","2.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   Time Complexity","text":"<p>Runtime can intuitively and accurately reflect the efficiency of an algorithm. If we want to accurately estimate the runtime of a piece of code, how should we proceed?</p> <ol> <li>Determine the running platform, including hardware configuration, programming language, system environment, etc., as these factors all affect code execution efficiency.</li> <li>Evaluate the runtime required for various computational operations, for example, an addition operation <code>+</code> requires 1 ns, a multiplication operation <code>*</code> requires 10 ns, a print operation <code>print()</code> requires 5 ns, etc.</li> <li>Count all computational operations in the code, and sum the execution times of all operations to obtain the runtime.</li> </ol> <p>For example, in the following code, the input data size is \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># On a certain running platform\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # Loop n times\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // Loop n times\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // Loop n times\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// On a certain running platform\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // Loop n times\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// On a certain running platform\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># On a certain running platform\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # Loop n times\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>According to the above method, the algorithm's runtime can be obtained as \\((6n + 12)\\) ns:</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>In reality, however, counting an algorithm's runtime is neither reasonable nor realistic. First, we do not want to tie the estimated time to the running platform, because algorithms need to run on various different platforms. Second, it is difficult to know the runtime of each type of operation, which brings great difficulty to the estimation process.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231-counting-time-growth-trends","level":2,"title":"2.3.1   Counting Time Growth Trends","text":"<p>Time complexity analysis does not count the algorithm's runtime, but rather counts the growth trend of the algorithm's runtime as the data volume increases.</p> <p>The concept of \"time growth trend\" is rather abstract; let us understand it through an example. Suppose the input data size is \\(n\\), and given three algorithms <code>A</code>, <code>B</code>, and <code>C</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Time complexity of algorithm A: constant order\ndef algorithm_A(n: int):\n    print(0)\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Time complexity of algorithm B: linear order\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Time complexity of algorithm B: linear order\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Time complexity of algorithm B: linear order\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// Time complexity of algorithm C: constant order\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithmA(int n) {\n  print(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// Time complexity of algorithm A: constant order\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// Time complexity of algorithm B: linear order\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># Time complexity of algorithm A: constant order\ndef algorithm_A(n)\n    puts 0\nend\n\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>Figure 2-7 shows the time complexity of the above three algorithm functions.</p> <ul> <li>Algorithm <code>A</code> has only \\(1\\) print operation, and the algorithm's runtime does not grow as \\(n\\) increases. We call the time complexity of this algorithm \"constant order\".</li> <li>In algorithm <code>B</code>, the print operation needs to loop \\(n\\) times, and the algorithm's runtime grows linearly as \\(n\\) increases. The time complexity of this algorithm is called \"linear order\".</li> <li>In algorithm <code>C</code>, the print operation needs to loop \\(1000000\\) times. Although the runtime is very long, it is independent of the input data size \\(n\\). Therefore, the time complexity of <code>C</code> is the same as <code>A</code>, still \"constant order\".</li> </ul> <p></p> <p> Figure 2-7   Time growth trends of algorithms A, B, and C </p> <p>Compared to directly counting the algorithm's runtime, what are the characteristics of time complexity analysis?</p> <ul> <li>Time complexity can effectively evaluate algorithm efficiency. For example, the runtime of algorithm <code>B</code> grows linearly; when \\(n &gt; 1\\) it is slower than algorithm <code>A</code>, and when \\(n &gt; 1000000\\) it is slower than algorithm <code>C</code>. In fact, as long as the input data size \\(n\\) is sufficiently large, an algorithm with \"constant order\" complexity will always be superior to one with \"linear order\" complexity, which is precisely the meaning of time growth trend.</li> <li>The derivation method for time complexity is simpler. Obviously, the running platform and the types of computational operations are both unrelated to the growth trend of the algorithm's runtime. Therefore, in time complexity analysis, we can simply treat the execution time of all computational operations as the same \"unit time\", thus simplifying \"counting computational operation runtime\" to \"counting the number of computational operations\", which greatly reduces the difficulty of estimation.</li> <li>Time complexity also has certain limitations. For example, although algorithms <code>A</code> and <code>C</code> have the same time complexity, their actual runtimes differ significantly. Similarly, although algorithm <code>B</code> has a higher time complexity than <code>C</code>, when the input data size \\(n\\) is small, algorithm <code>B</code> is clearly superior to algorithm <code>C</code>. In such cases, it is often difficult to judge the efficiency of algorithms based solely on time complexity. Of course, despite the above issues, complexity analysis remains the most effective and commonly used method for evaluating algorithm efficiency.</li> </ul>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232-asymptotic-upper-bound-of-functions","level":2,"title":"2.3.2   Asymptotic Upper Bound of Functions","text":"<p>Given a function with input size \\(n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Loop n times\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // +1 (i++ is executed each round)\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Loop n times\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i &lt; n; i++){ // +1 (i++ is executed each round)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i &lt; n; i++){ // +1 (i++ is executed each round)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Loop n times\n  for (int i = 0; i &lt; n; i++) { // +1 (i++ is executed each round)\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Loop n times\n    for _ in 0..n { // +1 (i++ is executed each round)\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i &lt; n; i++) {   // +1 (i++ is executed each round)\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for (i in 0..&lt;n) { // +1 (i++ is executed each round)\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # Loop n times\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>Let the number of operations of the algorithm be a function of the input data size \\(n\\), denoted as \\(T(n)\\). Then the number of operations of the above function is:</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) is a linear function, indicating that its runtime growth trend is linear, and therefore its time complexity is linear order.</p> <p>We denote the time complexity of linear order as \\(O(n)\\). This mathematical symbol is called big-\\(O\\) notation, representing the asymptotic upper bound of the function \\(T(n)\\).</p> <p>Time complexity analysis essentially calculates the asymptotic upper bound of \"the number of operations \\(T(n)\\)\", which has a clear mathematical definition.</p> <p>Asymptotic upper bound of functions</p> <p>If there exist positive real numbers \\(c\\) and \\(n_0\\) such that for all \\(n &gt; n_0\\), we have \\(T(n) \\leq c \\cdot f(n)\\), then \\(f(n)\\) can be considered as an asymptotic upper bound of \\(T(n)\\), denoted as \\(T(n) = O(f(n))\\).</p> <p>As shown in Figure 2-8, calculating the asymptotic upper bound is to find a function \\(f(n)\\) such that when \\(n\\) tends to infinity, \\(T(n)\\) and \\(f(n)\\) are at the same growth level, differing only by a constant coefficient \\(c\\).</p> <p></p> <p> Figure 2-8   Asymptotic upper bound of a function </p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233-derivation-method","level":2,"title":"2.3.3   Derivation Method","text":"<p>The asymptotic upper bound has a bit of mathematical flavor. If you feel you haven't fully understood it, don't worry. We can first master the derivation method, and gradually grasp its mathematical meaning through continuous practice.</p> <p>According to the definition, after determining \\(f(n)\\), we can obtain the time complexity \\(O(f(n))\\). So how do we determine the asymptotic upper bound \\(f(n)\\)? Overall, it is divided into two steps: first count the number of operations, then determine the asymptotic upper bound.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-step-1-count-the-number-of-operations","level":3,"title":"1.   Step 1: Count the Number of Operations","text":"<p>For code, count from top to bottom line by line. However, since the constant coefficient \\(c\\) in \\(c \\cdot f(n)\\) above can be of any size, coefficients and constant terms in the number of operations \\(T(n)\\) can all be ignored. According to this principle, the following counting simplification techniques can be summarized.</p> <ol> <li>Ignore constants in \\(T(n)\\). Because they are all independent of \\(n\\), they do not affect time complexity.</li> <li>Omit all coefficients. For example, looping \\(2n\\) times, \\(5n + 1\\) times, etc., can all be simplified as \\(n\\) times, because the coefficient before \\(n\\) does not affect time complexity.</li> <li>Use multiplication for nested loops. The total number of operations equals the product of the number of operations in the outer and inner loops, with each layer of loop still able to apply techniques <code>1.</code> and <code>2.</code> separately.</li> </ol> <p>Given a function, we can use the above techniques to count the number of operations:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0 (Technique 1)\n    a = a + n  # +0 (Technique 1)\n    # +n (Technique 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (Technique 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0 (Technique 1)\n    a = a + n  // +0 (Technique 1)\n    // +n (Technique 2)\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (Technique 3)\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0 (Technique 1)\n    a = a + n // +0 (Technique 1)\n    // +n (Technique 2)\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (Technique 3)\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (Technique 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (Technique 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0 (Technique 1)\n  a = a + n; // +0 (Technique 1)\n  // +n (Technique 2)\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (Technique 3)\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (Technique 1)\n    a = a + n;        // +0 (Technique 1)\n\n    // +n (Technique 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (Technique 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (Technique 1)\n    a = a + n;  // +0 (Technique 1)\n    // +n (Technique 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (Technique 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0 (Technique 1)\n    a = a + n   // +0 (Technique 1)\n    // +n (Technique 2)\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n (Technique 3)\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0 (Technique 1)\n    a = a + n   # +0 (Technique 1)\n    # +n (Technique 2)\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n (Technique 3)\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>The following formula shows the counting results before and after using the above techniques; both derive a time complexity of \\(O(n^2)\\).</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{Complete count (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{Simplified count (o.O)} \\end{aligned} \\]","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-step-2-determine-the-asymptotic-upper-bound","level":3,"title":"2.   Step 2: Determine the Asymptotic Upper Bound","text":"<p>Time complexity is determined by the highest-order term in \\(T(n)\\). This is because as \\(n\\) tends to infinity, the highest-order term will play a dominant role, and the influence of other terms can be ignored.</p> <p>Table 2-2 shows some examples, where some exaggerated values are used to emphasize the conclusion that \"coefficients cannot shake the order\". When \\(n\\) tends to infinity, these constants become insignificant.</p> <p> Table 2-2   Time complexities corresponding to different numbers of operations </p> Number of Operations \\(T(n)\\) Time Complexity \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234-common-types","level":2,"title":"2.3.4   Common Types","text":"<p>Let the input data size be \\(n\\). Common time complexity types are shown in Figure 2-9 (arranged in order from low to high).</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{Constant order} &lt; \\text{Logarithmic order} &lt; \\text{Linear order} &lt; \\text{Linearithmic order} &lt; \\text{Quadratic order} &lt; \\text{Exponential order} &lt; \\text{Factorial order} \\end{aligned} \\] <p></p> <p> Figure 2-9   Common time complexity types </p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-constant-order-o1","level":3,"title":"1.   Constant Order \\(O(1)\\)","text":"<p>The number of operations in constant order is independent of the input data size \\(n\\), meaning it does not change as \\(n\\) changes.</p> <p>In the following function, although the number of operations <code>size</code> may be large, since it is independent of the input data size \\(n\\), the time complexity remains \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"Constant order\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Constant order */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Constant order */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Constant order */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Constant order */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Constant order */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Constant order */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Constant order */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Constant order */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Constant order */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Constant time ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-linear-order-on","level":3,"title":"2.   Linear Order \\(O(n)\\)","text":"<p>The number of operations in linear order grows linearly relative to the input data size \\(n\\). Linear order typically appears in single-layer loops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"Linear order\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linear order */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linear order */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linear order */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linear order */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linear order */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linear order */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linear order */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Linear order */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linear order */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linear time ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> <p>Operations such as traversing arrays and traversing linked lists have a time complexity of \\(O(n)\\), where \\(n\\) is the length of the array or linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"Linear order (traversing array)\"\"\"\n    count = 0\n    # Number of iterations is proportional to the array length\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linear order (traversing array) */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linear order (traversing array) */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // Number of iterations is proportional to the array length\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linear order (traversing array) */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // Number of iterations is proportional to the array length\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linear order (traversing array) */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // Number of iterations is proportional to the array length\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linear order (traversing array) */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // Number of iterations is proportional to the array length\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // Number of iterations is proportional to the array length\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linear order (traversing array) */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // Number of iterations is proportional to the array length\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Linear order (traversing array) */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // Number of iterations is proportional to the array length\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linear order (traversing array) */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // Number of iterations is proportional to the array length\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linear time (array traversal) ###\ndef array_traversal(nums)\n  count = 0\n\n  # Number of iterations is proportional to the array length\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> <p>It is worth noting that the input data size \\(n\\) should be determined according to the type of input data. For example, in the first example, the variable \\(n\\) is the input data size; in the second example, the array length \\(n\\) is the data size.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-quadratic-order-on2","level":3,"title":"3.   Quadratic Order \\(O(n^2)\\)","text":"<p>The number of operations in quadratic order grows quadratically relative to the input data size \\(n\\). Quadratic order typically appears in nested loops, where both the outer and inner loops have a time complexity of \\(O(n)\\), resulting in an overall time complexity of \\(O(n^2)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"Quadratic order\"\"\"\n    count = 0\n    # Number of iterations is quadratically related to the data size n\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order */\nint Quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order */\nfunc quadratic(n int) int {\n    count := 0\n    // Number of iterations is quadratically related to the data size n\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // Number of iterations is quadratically related to the data size n\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order */\nfunction quadratic(n) {\n    let count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order */\nint quadratic(int n) {\n  int count = 0;\n  // Number of iterations is quadratically related to the data size n\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order */\nint quadratic(int n) {\n    int count = 0;\n    // Number of iterations is quadratically related to the data size n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // Number of iterations is quadratically related to the data size n\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Quadratic time ###\ndef quadratic(n)\n  count = 0\n\n  # Number of iterations is quadratically related to the data size n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> <p>Figure 2-10 compares constant order, linear order, and quadratic order time complexities.</p> <p></p> <p> Figure 2-10   Time complexities of constant, linear, and quadratic orders </p> <p>Taking bubble sort as an example, the outer loop executes \\(n - 1\\) times, and the inner loop executes \\(n-1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\) times, averaging \\(n / 2\\) times, resulting in a time complexity of \\(O((n - 1) n / 2) = O(n^2)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"Quadratic order (bubble sort)\"\"\"\n    count = 0  # Counter\n    # Outer loop: unsorted range is [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # Element swap includes 3 unit operations\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(int[] nums) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Quadratic order (bubble sort) */\nint BubbleSort(int[] nums) {\n    int count = 0;  // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Quadratic order (bubble sort) */\nfunc bubbleSort(nums []int) int {\n    count := 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Quadratic order (bubble sort) */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Quadratic order (bubble sort) */\nfunction bubbleSort(nums) {\n    let count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Quadratic order (bubble sort) */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // Counter\n  // Outer loop: unsorted range is [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // Element swap includes 3 unit operations\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Quadratic order (bubble sort) */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // Counter\n\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Quadratic order (bubble sort) */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Quadratic order (bubble sort) */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // Counter\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // Element swap includes 3 unit operations\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Quadratic time (bubble sort) ###\ndef bubble_sort(nums)\n  count = 0  # Counter\n\n  # Outer loop: unsorted range is [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Element swap includes 3 unit operations\n      end\n    end\n  end\n\n  count\nend\n</code></pre>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-exponential-order-o2n","level":3,"title":"4.   Exponential Order \\(O(2^n)\\)","text":"<p>Biological \"cell division\" is a typical example of exponential order growth: the initial state is \\(1\\) cell, after one round of division it becomes \\(2\\), after two rounds it becomes \\(4\\), and so on; after \\(n\\) rounds of division there are \\(2^n\\) cells.</p> <p>Figure 2-11 and the following code simulate the cell division process, with a time complexity of \\(O(2^n)\\). Note that the input \\(n\\) represents the number of division rounds, and the return value <code>count</code> represents the total number of divisions.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"Exponential order (loop implementation)\"\"\"\n    count = 0\n    base = 1\n    # Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order (loop implementation) */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order (loop implementation) */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order (loop implementation) */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order (loop implementation) */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order (loop implementation) */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order (loop implementation) */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order (loop implementation) */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order (loop implementation) */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Exponential time (iterative) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> <p></p> <p> Figure 2-11   Time complexity of exponential order </p> <p>In actual algorithms, exponential order often appears in recursive functions. For example, in the following code, it recursively splits in two, stopping after \\(n\\) splits:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"Exponential order (recursive implementation)\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Exponential order (recursive implementation) */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Exponential order (recursive implementation) */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Exponential order (recursive implementation) */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Exponential order (recursive implementation) */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Exponential order (recursive implementation) */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Exponential order (recursive implementation) */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Exponential order (recursive implementation) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Exponential order (recursive implementation) */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Exponential time (recursive) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> <p>Exponential order growth is very rapid and is common in exhaustive methods (brute force search, backtracking, etc.). For problems with large data scales, exponential order is unacceptable and typically requires dynamic programming or greedy algorithms to solve.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-logarithmic-order-olog-n","level":3,"title":"5.   Logarithmic Order \\(O(\\log n)\\)","text":"<p>In contrast to exponential order, logarithmic order reflects the situation of \"reducing to half each round\". Let the input data size be \\(n\\). Since it is reduced to half each round, the number of loops is \\(\\log_2 n\\), which is the inverse function of \\(2^n\\).</p> <p>Figure 2-12 and the following code simulate the process of \"reducing to half each round\", with a time complexity of \\(O(\\log_2 n)\\), abbreviated as \\(O(\\log n)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"Logarithmic order (loop implementation)\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Logarithmic order (loop implementation) */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Logarithmic order (loop implementation) */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Logarithmic order (loop implementation) */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Logarithmic order (loop implementation) */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Logarithmic order (loop implementation) */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Logarithmic order (loop implementation) */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Logarithmic order (loop implementation) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Logarithmic order (loop implementation) */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Logarithmic time (iterative) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> <p></p> <p> Figure 2-12   Time complexity of logarithmic order </p> <p>Like exponential order, logarithmic order also commonly appears in recursive functions. The following code forms a recursion tree of height \\(\\log_2 n\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"Logarithmic order (recursive implementation)\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Logarithmic order (recursive implementation) */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Logarithmic order (recursive implementation) */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Logarithmic order (recursive implementation) */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Logarithmic order (recursive implementation) */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Logarithmic order (recursive implementation) */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Logarithmic order (recursive implementation) */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Logarithmic order (recursive implementation) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Logarithmic order (recursive implementation) */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Logarithmic time (recursive) ###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> <p>Logarithmic order commonly appears in algorithms based on the divide-and-conquer strategy, embodying the algorithmic thinking of \"dividing into many\" and \"simplifying complexity\". It grows slowly and is the ideal time complexity second only to constant order.</p> <p>What is the base of \\(O(\\log n)\\)?</p> <p>To be precise, \"dividing into \\(m\\)\" corresponds to a time complexity of \\(O(\\log_m n)\\). And through the logarithmic base change formula, we can obtain time complexities with different bases that are equal:</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>That is to say, the base \\(m\\) can be converted without affecting the complexity. Therefore, we usually omit the base \\(m\\) and denote logarithmic order simply as \\(O(\\log n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-linearithmic-order-on-log-n","level":3,"title":"6.   Linearithmic Order \\(O(n \\log n)\\)","text":"<p>Linearithmic order commonly appears in nested loops, where the time complexities of the two layers of loops are \\(O(\\log n)\\) and \\(O(n)\\) respectively. The relevant code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"Linearithmic order\"\"\"\n    if n &lt;= 1:\n        return 1\n    # Divide into two, the scale of subproblems is reduced by half\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # Current subproblem contains n operations\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Linearithmic order */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Linearithmic order */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Linearithmic order */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Linearithmic order */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Linearithmic order */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Linearithmic order */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* Linearithmic order */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Linearithmic order */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Linearithmic time ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> <p>Figure 2-13 shows how linearithmic order is generated. Each level of the binary tree has a total of \\(n\\) operations, and the tree has \\(\\log_2 n + 1\\) levels, resulting in a time complexity of \\(O(n \\log n)\\).</p> <p></p> <p> Figure 2-13   Time complexity of linearithmic order </p> <p>Mainstream sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), such as quicksort, merge sort, and heap sort.</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-factorial-order-on","level":3,"title":"7.   Factorial Order \\(O(n!)\\)","text":"<p>Factorial order corresponds to the mathematical \"permutation\" problem. Given \\(n\\) distinct elements, find all possible permutation schemes; the number of schemes is:</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>Factorials are typically implemented using recursion. As shown in Figure 2-14 and the following code, the first level splits into \\(n\\) branches, the second level splits into \\(n - 1\\) branches, and so on, until the \\(n\\)-th level when splitting stops:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"Factorial order (recursive implementation)\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # Split from 1 into n\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Factorial order (recursive implementation) */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // Split from 1 into n\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Factorial order (recursive implementation) */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // Split from 1 into n\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Factorial order (recursive implementation) */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // Split from 1 into n\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Factorial order (recursive implementation) */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // Split from 1 into n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Factorial order (recursive implementation) */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // Split from 1 into n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // Split from 1 into n\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Factorial order (recursive implementation) */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // Split from 1 into n\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Factorial order (recursive implementation) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Factorial order (recursive implementation) */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // Split from 1 into n\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Factorial time (recursive) ###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # Split from 1 into n\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> <p></p> <p> Figure 2-14   Time complexity of factorial order </p> <p>Note that because when \\(n \\geq 4\\) we always have \\(n! &gt; 2^n\\), factorial order grows faster than exponential order, and is also unacceptable for large \\(n\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235-worst-best-and-average-time-complexities","level":2,"title":"2.3.5   Worst, Best, and Average Time Complexities","text":"<p>The time efficiency of an algorithm is often not fixed, but is related to the distribution of the input data. Suppose we input an array <code>nums</code> of length \\(n\\), where <code>nums</code> consists of numbers from \\(1\\) to \\(n\\), with each number appearing only once, but the element order is randomly shuffled. The task is to return the index of element \\(1\\). We can draw the following conclusions.</p> <ul> <li>When <code>nums = [?, ?, ..., 1]</code>, i.e., when the last element is \\(1\\), it requires a complete traversal of the array, reaching worst-case time complexity \\(O(n)\\).</li> <li>When <code>nums = [1, ?, ?, ...]</code>, i.e., when the first element is \\(1\\), no matter how long the array is, there is no need to continue traversing, reaching best-case time complexity \\(\\Omega(1)\\).</li> </ul> <p>The \"worst-case time complexity\" corresponds to the function's asymptotic upper bound, denoted using big-\\(O\\) notation. Correspondingly, the \"best-case time complexity\" corresponds to the function's asymptotic lower bound, denoted using \\(\\Omega\\) notation:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"Generate an array with elements: 1, 2, ..., n, shuffled in order\"\"\"\n    # Generate array nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # Randomly shuffle array elements\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"Find the index of number 1 in array nums\"\"\"\n    for i in range(len(nums)):\n        # When element 1 is at the head of the array, best time complexity O(1) is achieved\n        # When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Use system time to generate random seed\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // Randomly shuffle array elements\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // Randomly shuffle array elements\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // Randomly shuffle array elements\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* Find the index of number 1 in array nums */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // Generate array nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // Randomly shuffle array elements\n    nums.shuffle()\n    return nums\n}\n\n/* Find the index of number 1 in array nums */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // Generate array nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // Randomly shuffle array elements\n  nums.shuffle();\n\n  return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // When element 1 is at the head of the array, best time complexity O(1) is achieved\n    // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // Generate array nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // Randomly shuffle array elements\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* Find the index of number 1 in array nums */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nint *randomNumbers(int n) {\n    // Allocate heap memory (create 1D variable-length array: n elements of type int)\n    int *nums = (int *)malloc(n * sizeof(int));\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Randomly shuffle array elements\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* Find the index of number 1 in array nums */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* Generate an array with elements { 1, 2, ..., n }, order shuffled */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // Generate array nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // Randomly shuffle array elements\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* Find the index of number 1 in array nums */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // When element 1 is at the head of the array, best time complexity O(1) is achieved\n        // When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### Generate array with elements: 1, 2, ..., n, shuffled ###\ndef random_numbers(n)\n  # Generate array nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # Randomly shuffle array elements\n  nums.shuffle!\nend\n\n### Find index of number 1 in array nums ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # When element 1 is at the head of the array, best time complexity O(1) is achieved\n    # When element 1 is at the tail of the array, worst time complexity O(n) is achieved\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> <p>It is worth noting that we rarely use best-case time complexity in practice, because it can usually only be achieved with a very small probability and may be somewhat misleading. The worst-case time complexity is more practical because it gives a safety value for efficiency, allowing us to use the algorithm with confidence.</p> <p>From the above example, we can see that both worst-case and best-case time complexities only occur under \"special data distributions\", which may have a very small probability of occurrence and may not truly reflect the algorithm's running efficiency. In contrast, average time complexity can reflect the algorithm's running efficiency under random input data, denoted using the \\(\\Theta\\) notation.</p> <p>For some algorithms, we can simply derive the average case under random data distribution. For example, in the above example, since the input array is shuffled, the probability of element \\(1\\) appearing at any index is equal, so the algorithm's average number of loops is half the array length \\(n / 2\\), giving an average time complexity of \\(\\Theta(n / 2) = \\Theta(n)\\).</p> <p>But for more complex algorithms, calculating average time complexity is often quite difficult, because it is hard to analyze the overall mathematical expectation under data distribution. In this case, we usually use worst-case time complexity as the criterion for judging algorithm efficiency.</p> <p>Why is the \\(\\Theta\\) symbol rarely seen?</p> <p>This may be because the \\(O\\) symbol is too catchy, so we often use it to represent average time complexity. But strictly speaking, this practice is not standard. In this book and other materials, if you encounter expressions like \"average time complexity \\(O(n)\\)\", please understand it directly as \\(\\Theta(n)\\).</p>","path":["Chapter 2. Complexity Analysis","2.3 &nbsp; Time Complexity"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"Chapter 3.   Data Structures","text":"<p>Abstract</p> <p>Data structure is like a sturdy and diverse framework.</p> <p>It provides a blueprint for the orderly organization of data, upon which algorithms come to life.</p>","path":["Chapter 3. Data Structures","Chapter 3. &nbsp; Data Structures"],"tags":[]},{"location":"chapter_data_structure/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>3.1   Classification of Data Structures</li> <li>3.2   Basic Data Types</li> <li>3.3   Number Encoding *</li> <li>3.4   Character Encoding *</li> <li>3.5   Summary</li> </ul>","path":["Chapter 3. Data Structures","Chapter 3. &nbsp; Data Structures"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   Basic Data Types","text":"<p>When we talk about data in computers, we think of various forms such as text, images, videos, audio, 3D models, and more. Although these data are organized in different ways, they are all composed of various basic data types.</p> <p>Basic data types are types that the CPU can directly operate on, and they are directly used in algorithms, mainly including the following.</p> <ul> <li>Integer types <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>.</li> <li>Floating-point types <code>float</code>, <code>double</code>, used to represent decimal numbers.</li> <li>Character type <code>char</code>, used to represent letters, punctuation marks, and even emojis in various languages.</li> <li>Boolean type <code>bool</code>, used to represent \"yes\" and \"no\" judgments.</li> </ul> <p>Basic data types are stored in binary form in computers. One binary bit is \\(1\\) bit. In most modern operating systems, \\(1\\) byte consists of \\(8\\) bits.</p> <p>The range of values for basic data types depends on the size of the space they occupy. Below is an example using Java.</p> <ul> <li>Integer type <code>byte</code> occupies \\(1\\) byte = \\(8\\) bits, and can represent \\(2^{8}\\) numbers.</li> <li>Integer type <code>int</code> occupies \\(4\\) bytes = \\(32\\) bits, and can represent \\(2^{32}\\) numbers.</li> </ul> <p>The following table lists the space occupied, value ranges, and default values of various basic data types in Java. You don't need to memorize this table; a general understanding is sufficient, and you can refer to it when needed.</p> <p> Table 3-1   Space occupied and value ranges of basic data types </p> Type Symbol Space Occupied Minimum Value Maximum Value Default Value Integer <code>byte</code> 1 byte \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 bytes \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 bytes \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 bytes \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) Float <code>float</code> 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) Character <code>char</code> 2 bytes \\(0\\) \\(2^{16} - 1\\) \\(0\\) Boolean <code>bool</code> 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>Please note that the above table is specific to Java's basic data types. Each programming language has its own data type definitions, and their space occupied, value ranges, and default values may vary.</p> <ul> <li>In Python, the integer type <code>int</code> can be of any size, limited only by available memory; the floating-point type <code>float</code> is double-precision 64-bit; there is no <code>char</code> type, a single character is actually a string <code>str</code> of length 1.</li> <li>C and C++ do not explicitly specify the size of basic data types, which varies by implementation and platform. The above table follows the LP64 data model, which is used in Unix 64-bit operating systems including Linux and macOS.</li> <li>The size of character <code>char</code> is 1 byte in C and C++, and in most programming languages it depends on the specific character encoding method, as detailed in the \"Character Encoding\" section.</li> <li>Even though representing a boolean value requires only 1 bit (\\(0\\) or \\(1\\)), it is usually stored as 1 byte in memory. This is because modern computer CPUs typically use 1 byte as the minimum addressable memory unit.</li> </ul> <p>So, what is the relationship between basic data types and data structures? We know that data structures are ways of organizing and storing data in computers. The subject of this statement is \"structure\", not \"data\".</p> <p>If we want to represent \"a row of numbers\", we naturally think of using an array. This is because the linear structure of an array can represent the adjacency and order relationships of numbers, but the content stored—whether integer <code>int</code>, floating-point <code>float</code>, or character <code>char</code>—is unrelated to the \"data structure\".</p> <p>In other words, basic data types provide the \"content type\" of data, while data structures provide the \"organization method\" of data. For example, in the following code, we use the same data structure (array) to store and represent different basic data types, including <code>int</code>, <code>float</code>, <code>char</code>, <code>bool</code>, etc.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Initialize arrays using various basic data types\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# In Python, characters are actually strings of length 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript arrays can freely store various basic data types and objects\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// Initialize arrays using various basic data types\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E4%BD%BF%E7%94%A8%E5%A4%9A%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20*%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%AD%97%E7%AC%A6%E5%AE%9E%E9%99%85%E4%B8%8A%E6%98%AF%E9%95%BF%E5%BA%A6%E4%B8%BA%201%20%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%0A%20%20%20%20characters%20%3D%20%5B'0'%5D%20*%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%88%97%E8%A1%A8%E5%8F%AF%E4%BB%A5%E8%87%AA%E7%94%B1%E5%AD%98%E5%82%A8%E5%90%84%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%AF%B9%E8%B1%A1%E5%BC%95%E7%94%A8%0A%20%20%20%20data%20%3D%20%5B0,%200.0,%20'a',%20False,%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Chapter 3. Data Structures","3.2 &nbsp; Basic Data Types"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   Character Encoding *","text":"<p>In computers, all data is stored in binary form, and character <code>char</code> is no exception. To represent characters, we need to establish a \"character set\" that defines a one-to-one correspondence between each character and binary numbers. With a character set, computers can convert binary numbers to characters by looking up the table.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii-character-set","level":2,"title":"3.4.1   Ascii Character Set","text":"<p>ASCII code is the earliest character set, with the full name American Standard Code for Information Interchange. It uses 7 binary bits (the lower 7 bits of one byte) to represent a character, and can represent a maximum of 128 different characters. As shown in Figure 3-6, ASCII code includes uppercase and lowercase English letters, numbers 0 ~ 9, some punctuation marks, and some control characters (such as newline and tab).</p> <p></p> <p> Figure 3-6   ASCII code </p> <p>However, ASCII code can only represent English. With the globalization of computers, a character set called EASCII that can represent more languages emerged. It expands from the 7-bit basis of ASCII to 8 bits, and can represent 256 different characters.</p> <p>Worldwide, a batch of EASCII character sets suitable for different regions have appeared successively. The first 128 characters of these character sets are unified as ASCII code, and the last 128 characters are defined differently to adapt to the needs of different languages.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk-character-set","level":2,"title":"3.4.2   Gbk Character Set","text":"<p>Later, people found that EASCII code still cannot meet the character quantity requirements of many languages. For example, there are nearly one hundred thousand Chinese characters, and several thousand are used daily. In 1980, the China National Standardization Administration released the GB2312 character set, which included 6,763 Chinese characters, basically meeting the needs for computer processing of Chinese characters.</p> <p>However, GB2312 cannot handle some rare characters and traditional Chinese characters. The GBK character set is an extension based on GB2312, which includes a total of 21,886 Chinese characters. In the GBK encoding scheme, ASCII characters are represented using one byte, and Chinese characters are represented using two bytes.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode-character-set","level":2,"title":"3.4.3   Unicode Character Set","text":"<p>With the vigorous development of computer technology, character sets and encoding standards flourished, which brought many problems. On the one hand, these character sets generally only define characters for specific languages and cannot work normally in multilingual environments. On the other hand, multiple character set standards exist for the same language, and if two computers use different encoding standards, garbled characters will appear during information transmission.</p> <p>Researchers of that era thought: If a sufficiently complete character set is released that includes all languages and symbols in the world, wouldn't it be possible to solve cross-language environment and garbled character problems? Driven by this idea, a large and comprehensive character set, Unicode, was born.</p> <p>Unicode is called \"统一码\" (Unified Code) in Chinese and can theoretically accommodate over one million characters. It is committed to including characters from around the world into a unified character set, providing a universal character set to handle and display various language texts, reducing garbled character problems caused by different encoding standards.</p> <p>Since its release in 1991, Unicode has continuously expanded to include new languages and characters. As of September 2022, Unicode has included 149,186 characters, including characters, symbols, and even emojis from various languages. In the vast Unicode character set, commonly used characters occupy 2 bytes, and some rare characters occupy 3 bytes or even 4 bytes.</p> <p>Unicode is a universal character set that essentially assigns a number (called a \"code point\") to each character, but it does not specify how to store these character code points in computers. We can't help but ask: when Unicode code points of multiple lengths appear simultaneously in a text, how does the system parse the characters? For example, given an encoding with a length of 2 bytes, how does the system determine whether it is one 2-byte character or two 1-byte characters?</p> <p>For the above problem, a straightforward solution is to store all characters as equal-length encodings. As shown in Figure 3-7, each character in \"Hello\" occupies 1 byte, and each character in \"算法\" (algorithm) occupies 2 bytes. We can encode all characters in \"Hello 算法\" as 2 bytes in length by padding the high bits with 0. In this way, the system can parse one character every 2 bytes and restore the content of this phrase.</p> <p></p> <p> Figure 3-7   Unicode encoding example </p> <p>However, ASCII code has already proven to us that encoding English only requires 1 byte. If the above scheme is adopted, the size of English text will be twice that under ASCII encoding, which is very wasteful of memory space. Therefore, we need a more efficient Unicode encoding method.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8-encoding","level":2,"title":"3.4.4   Utf-8 Encoding","text":"<p>Currently, UTF-8 has become the most widely used Unicode encoding method internationally. It is a variable-length encoding that uses 1 to 4 bytes to represent a character, depending on the complexity of the character. ASCII characters only require 1 byte, Latin and Greek letters require 2 bytes, commonly used Chinese characters require 3 bytes, and some other rare characters require 4 bytes.</p> <p>The encoding rules of UTF-8 are not complicated and can be divided into the following two cases.</p> <ul> <li>For 1-byte characters, set the highest bit to \\(0\\), and set the remaining 7 bits to the Unicode code point. It is worth noting that ASCII characters occupy the first 128 code points in the Unicode character set. That is to say, UTF-8 encoding is backward compatible with ASCII code. This means we can use UTF-8 to parse very old ASCII code text.</li> <li>For characters with a length of \\(n\\) bytes (where \\(n &gt; 1\\)), set the highest \\(n\\) bits of the first byte to \\(1\\), and set the \\((n + 1)\\)-th bit to \\(0\\); starting from the second byte, set the highest 2 bits of each byte to \\(10\\); use all remaining bits to fill in the Unicode code point of the character.</li> </ul> <p>Figure 3-8 shows the UTF-8 encoding corresponding to \"Hello算法\". It can be observed that since the highest \\(n\\) bits are all set to \\(1\\), the system can parse the length of the character as \\(n\\) by reading the number of highest bits that are \\(1\\).</p> <p>But why set the highest 2 bits of all other bytes to \\(10\\)? In fact, this \\(10\\) can serve as a check symbol. Assuming the system starts parsing text from an incorrect byte, the \\(10\\) at the beginning of the byte can help the system quickly determine an anomaly.</p> <p>The reason for using \\(10\\) as a check symbol is that under UTF-8 encoding rules, it is impossible for a character's highest two bits to be \\(10\\). This conclusion can be proven by contradiction: assuming the highest two bits of a character are \\(10\\), it means the length of the character is \\(1\\), corresponding to ASCII code. However, the highest bit of ASCII code should be \\(0\\), which contradicts the assumption.</p> <p></p> <p> Figure 3-8   UTF-8 encoding example </p> <p>In addition to UTF-8, common encoding methods also include the following two.</p> <ul> <li>UTF-16 encoding: Uses 2 or 4 bytes to represent a character. All ASCII characters and commonly used non-English characters are represented with 2 bytes; a few characters need to use 4 bytes. For 2-byte characters, UTF-16 encoding is equal to the Unicode code point.</li> <li>UTF-32 encoding: Every character uses 4 bytes. This means that UTF-32 takes up more space than UTF-8 and UTF-16, especially for text with a high proportion of ASCII characters.</li> </ul> <p>From the perspective of storage space occupation, using UTF-8 to represent English characters is very efficient because it only requires 1 byte; using UTF-16 encoding for some non-English characters (such as Chinese) will be more efficient because it only requires 2 bytes, while UTF-8 may require 3 bytes.</p> <p>From a compatibility perspective, UTF-8 has the best universality, and many tools and libraries support UTF-8 first.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345-character-encoding-in-programming-languages","level":2,"title":"3.4.5   Character Encoding in Programming Languages","text":"<p>For most past programming languages, strings during program execution use fixed-length encodings such as UTF-16 or UTF-32. Under fixed-length encoding, we can treat strings as arrays for processing, and this approach has the following advantages.</p> <ul> <li>Random access: UTF-16 encoded strings can be easily accessed randomly. UTF-8 is a variable-length encoding. To find the \\(i\\)-th character, we need to traverse from the beginning of the string to the \\(i\\)-th character, which requires \\(O(n)\\) time.</li> <li>Character counting: Similar to random access, calculating the length of a UTF-16 encoded string is also an \\(O(1)\\) operation. However, calculating the length of a UTF-8 encoded string requires traversing the entire string.</li> <li>String operations: Many string operations (such as splitting, joining, inserting, deleting, etc.) on UTF-16 encoded strings are easier to perform. Performing these operations on UTF-8 encoded strings usually requires additional calculations to ensure that invalid UTF-8 encoding is not generated.</li> </ul> <p>In fact, the design of character encoding schemes for programming languages is a very interesting topic involving many factors.</p> <ul> <li>Java's <code>String</code> type uses UTF-16 encoding, with each character occupying 2 bytes. This is because at the beginning of Java language design, people believed that 16 bits were sufficient to represent all possible characters. However, this was an incorrect judgment. Later, the Unicode specification expanded beyond 16 bits, so characters in Java may now be represented by a pair of 16-bit values (called \"surrogate pairs\").</li> <li>The strings of JavaScript and TypeScript use UTF-16 encoding for reasons similar to Java. When Netscape first introduced the JavaScript language in 1995, Unicode was still in its early stages of development, and at that time, using 16-bit encoding was sufficient to represent all Unicode characters.</li> <li>C# uses UTF-16 encoding mainly because the .NET platform was designed by Microsoft, and many of Microsoft's technologies (including the Windows operating system) extensively use UTF-16 encoding.</li> </ul> <p>Due to the underestimation of character quantities by the above programming languages, they had to adopt the \"surrogate pair\" method to represent Unicode characters with lengths exceeding 16 bits. This is a reluctant compromise. On the one hand, in strings containing surrogate pairs, one character may occupy 2 bytes or 4 bytes, thus losing the advantage of fixed-length encoding. On the other hand, handling surrogate pairs requires additional code, which increases the complexity and difficulty of debugging in programming.</p> <p>For the above reasons, some programming languages have proposed different encoding schemes.</p> <ul> <li>Python's <code>str</code> uses Unicode encoding and adopts a flexible string representation where the stored character length depends on the largest Unicode code point in the string. If all characters in the string are ASCII characters, each character occupies 1 byte; if there are characters exceeding the ASCII range but all within the Basic Multilingual Plane (BMP), each character occupies 2 bytes; if there are characters exceeding the BMP, each character occupies 4 bytes.</li> <li>Go language's <code>string</code> type uses UTF-8 encoding internally. Go language also provides the <code>rune</code> type, which is used to represent a single Unicode code point.</li> <li>Rust language's <code>str</code> and <code>String</code> types use UTF-8 encoding internally. Rust also provides the <code>char</code> type for representing a single Unicode code point.</li> </ul> <p>It should be noted that the above discussion is about how strings are stored in programming languages, which is different from how strings are stored in files or transmitted over networks. In file storage or network transmission, we usually encode strings into UTF-8 format to achieve optimal compatibility and space efficiency.</p>","path":["Chapter 3. Data Structures","3.4 &nbsp; Character Encoding *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   Classification of Data Structures","text":"<p>Common data structures include arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs. They can be classified from two dimensions: \"logical structure\" and \"physical structure\".</p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311-logical-structure-linear-and-non-linear","level":2,"title":"3.1.1   Logical Structure: Linear and Non-Linear","text":"<p>Logical structure reveals the logical relationships between data elements. In arrays and linked lists, data is arranged in a certain order, embodying the linear relationship between data; while in trees, data is arranged hierarchically from top to bottom, showing the derived relationship between \"ancestors\" and \"descendants\"; graphs are composed of nodes and edges, reflecting complex network relationships.</p> <p>As shown in Figure 3-1, logical structures can be divided into two major categories: \"linear\" and \"non-linear\". Linear structures are more intuitive, indicating that data is linearly arranged in logical relationships; non-linear structures are the opposite, arranged non-linearly.</p> <ul> <li>Linear data structures: Arrays, linked lists, stacks, queues, hash tables, where elements have a one-to-one sequential relationship.</li> <li>Non-linear data structures: Trees, heaps, graphs, hash tables.</li> </ul> <p>Non-linear data structures can be further divided into tree structures and network structures.</p> <ul> <li>Tree structures: Trees, heaps, hash tables, where elements have a one-to-many relationship.</li> <li>Network structures: Graphs, where elements have a many-to-many relationship.</li> </ul> <p></p> <p> Figure 3-1   Linear and non-linear data structures </p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312-physical-structure-contiguous-and-dispersed","level":2,"title":"3.1.2   Physical Structure: Contiguous and Dispersed","text":"<p>When an algorithm program runs, the data being processed is mainly stored in memory. Figure 3-2 shows a computer memory stick, where each black square contains a memory space. We can imagine memory as a huge Excel spreadsheet, where each cell can store a certain amount of data.</p> <p>The system accesses data at the target location through memory addresses. As shown in Figure 3-2, the computer assigns a number to each cell in the spreadsheet according to specific rules, ensuring that each memory space has a unique memory address. With these addresses, the program can access data in memory.</p> <p></p> <p> Figure 3-2   Memory stick, memory space, memory address </p> <p>Tip</p> <p>It is worth noting that comparing memory to an Excel spreadsheet is a simplified analogy. The actual working mechanism of memory is quite complex, involving concepts such as address space, memory management, cache mechanisms, virtual memory, and physical memory.</p> <p>Memory is a shared resource for all programs. When a block of memory is occupied by a program, it usually cannot be used by other programs at the same time. Therefore, in the design of data structures and algorithms, memory resources are an important consideration. For example, the peak memory occupied by an algorithm should not exceed the remaining free memory of the system; if there is a lack of contiguous large memory blocks, then the data structure chosen must be able to be stored in dispersed memory spaces.</p> <p>As shown in Figure 3-3, physical structure reflects the way data is stored in computer memory, and can be divided into contiguous space storage (arrays) and dispersed space storage (linked lists). The two physical structures exhibit complementary characteristics in terms of time efficiency and space efficiency.</p> <p></p> <p> Figure 3-3   Contiguous space storage and dispersed space storage </p> <p>It is worth noting that all data structures are implemented based on arrays, linked lists, or a combination of both. For example, stacks and queues can be implemented using either arrays or linked lists; while the implementation of hash tables may include both arrays and linked lists.</p> <ul> <li>Can be implemented based on arrays: Stacks, queues, hash tables, trees, heaps, graphs, matrices, tensors (arrays with dimensions \\(\\geq 3\\)), etc.</li> <li>Can be implemented based on linked lists: Stacks, queues, hash tables, trees, heaps, graphs, etc.</li> </ul> <p>After initialization, linked lists can still adjust their length during program execution, so they are also called \"dynamic data structures\". After initialization, the length of arrays cannot be changed, so they are also called \"static data structures\". It is worth noting that arrays can achieve length changes by reallocating memory, thus possessing a certain degree of \"dynamism\".</p> <p>Tip</p> <p>If you find it difficult to understand physical structure, it is recommended to read the next chapter first, and then review this section.</p>","path":["Chapter 3. Data Structures","3.1 &nbsp; Classification of Data Structures"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   Number Encoding *","text":"<p>Tip</p> <p>In this book, chapters marked with an asterisk * are optional readings. If you are short on time or find them challenging, you may skip these initially and return to them after completing the essential chapters.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331-sign-magnitude-1s-complement-and-2s-complement","level":2,"title":"3.3.1   Sign-Magnitude, 1's Complement, and 2's Complement","text":"<p>In the table from the previous section, we found that all integer types can represent one more negative number than positive numbers. For example, the <code>byte</code> range is \\([-128, 127]\\). This phenomenon is counterintuitive, and its underlying reason involves knowledge of sign-magnitude, 1's complement, and 2's complement.</p> <p>First, it should be noted that numbers are stored in computers in the form of \"2's complement\". Before analyzing the reasons for this, let's first define these three concepts.</p> <ul> <li>Sign-magnitude: We treat the highest bit of the binary representation of a number as the sign bit, where \\(0\\) represents a positive number and \\(1\\) represents a negative number, and the remaining bits represent the value of the number.</li> <li>1's complement: The 1's complement of a positive number is the same as its sign-magnitude. For a negative number, the 1's complement is obtained by inverting all bits except the sign bit of its sign-magnitude.</li> <li>2's complement: The 2's complement of a positive number is the same as its sign-magnitude. For a negative number, the 2's complement is obtained by adding \\(1\\) to its 1's complement.</li> </ul> <p>Figure 3-4 shows the conversion methods among sign-magnitude, 1's complement, and 2's complement.</p> <p></p> <p> Figure 3-4   Conversions among sign-magnitude, 1's complement, and 2's complement </p> <p>Sign-magnitude, although the most intuitive, has some limitations. On one hand, the sign-magnitude of negative numbers cannot be directly used in operations. For example, calculating \\(1 + (-2)\\) in sign-magnitude yields \\(-3\\), which is clearly incorrect.</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>To solve this problem, computers introduced 1's complement. If we first convert sign-magnitude to 1's complement and calculate \\(1 + (-2)\\) in 1's complement, then convert the result back to sign-magnitude, we can obtain the correct result of \\(-1\\).</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(Sign-magnitude)} + 1000 \\; 0010 \\; \\text{(Sign-magnitude)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(1's complement)} + 1111  \\; 1101 \\; \\text{(1's complement)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(1's complement)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>On the other hand, the sign-magnitude of the number zero has two representations, \\(+0\\) and \\(-0\\). This means that the number zero corresponds to two different binary encodings, which may cause ambiguity. For example, in conditional judgments, if we don't distinguish between positive zero and negative zero, it may lead to incorrect judgment results. If we want to handle the ambiguity of positive and negative zero, we need to introduce additional judgment operations, which may reduce the computational efficiency of the computer.</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>Like sign-magnitude, 1's complement also has the problem of positive and negative zero ambiguity. Therefore, computers further introduced 2's complement. Let's first observe the conversion process of negative zero from sign-magnitude to 1's complement to 2's complement:</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(Sign-magnitude)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(1's complement)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(2's complement)} \\newline \\end{aligned} \\] <p>Adding \\(1\\) to the 1's complement of negative zero produces a carry, but since the <code>byte</code> type has a length of only 8 bits, the \\(1\\) that overflows to the 9<sup>th</sup> bit is discarded. That is to say, the 2's complement of negative zero is \\(0000 \\; 0000\\), which is the same as the 2's complement of positive zero. This means that in 2's complement representation, there is only one zero, and the positive and negative zero ambiguity is thus resolved.</p> <p>One last question remains: the range of the <code>byte</code> type is \\([-128, 127]\\), and how is the extra negative number \\(-128\\) obtained? We notice that all integers in the interval \\([-127, +127]\\) have corresponding sign-magnitude, 1's complement, and 2's complement, and sign-magnitude and 2's complement can be converted to each other.</p> <p>However, the 2's complement \\(1000 \\; 0000\\) is an exception, and it does not have a corresponding sign-magnitude. According to the conversion method, we get that the sign-magnitude of this 2's complement is \\(0000 \\; 0000\\). This is clearly contradictory because this sign-magnitude represents the number \\(0\\), and its 2's complement should be itself. The computer specifies that this special 2's complement \\(1000 \\; 0000\\) represents \\(-128\\). In fact, the result of calculating \\((-1) + (-127)\\) in 2's complement is \\(-128\\).</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(Sign-magnitude)} + 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(1's complement)} + 1111  \\; 1110 \\; \\text{(1's complement)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(2's complement)} + 1111  \\; 1111 \\; \\text{(2's complement)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(2's complement)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>You may have noticed that all the above calculations are addition operations. This hints at an important fact: the hardware circuits inside computers are mainly designed based on addition operations. This is because addition operations are simpler to implement in hardware compared to other operations (such as multiplication, division, and subtraction), easier to parallelize, and have faster operation speeds.</p> <p>Please note that this does not mean that computers can only perform addition. By combining addition with some basic logical operations, computers can implement various other mathematical operations. For example, calculating the subtraction \\(a - b\\) can be converted to calculating the addition \\(a + (-b)\\); calculating multiplication and division can be converted to calculating multiple additions or subtractions.</p> <p>Now we can summarize the reasons why computers use 2's complement: based on 2's complement representation, computers can use the same circuits and operations to handle the addition of positive and negative numbers, without the need to design special hardware circuits to handle subtraction, and without the need to specially handle the ambiguity problem of positive and negative zero. This greatly simplifies hardware design and improves operational efficiency.</p> <p>The design of 2's complement is very ingenious. Due to space limitations, we will stop here. Interested readers are encouraged to explore further.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332-floating-point-number-encoding","level":2,"title":"3.3.2   Floating-Point Number Encoding","text":"<p>Careful readers may have noticed: <code>int</code> and <code>float</code> have the same length, both are 4 bytes, but why does <code>float</code> have a much larger range than <code>int</code>? This is very counterintuitive because it stands to reason that <code>float</code> needs to represent decimals, so the range should be smaller.</p> <p>In fact, this is because floating-point number <code>float</code> uses a different representation method. Let's denote a 32-bit binary number as:</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>According to the IEEE 754 standard, a 32-bit <code>float</code> consists of the following three parts.</p> <ul> <li>Sign bit \\(\\mathrm{S}\\): occupies 1 bit, corresponding to \\(b_{31}\\).</li> <li>Exponent bit \\(\\mathrm{E}\\): occupies 8 bits, corresponding to \\(b_{30} b_{29} \\ldots b_{23}\\).</li> <li>Fraction bit \\(\\mathrm{N}\\): occupies 23 bits, corresponding to \\(b_{22} b_{21} \\ldots b_0\\).</li> </ul> <p>The calculation method for the value corresponding to the binary <code>float</code> is:</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>Converted to decimal, the calculation formula is:</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>The range of each component is:</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> Figure 3-5   Calculation example of float under IEEE 754 standard </p> <p>Observing Figure 3-5, given example data \\(\\mathrm{S} = 0\\), \\(\\mathrm{E} = 124\\), \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\), we have:</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>Now we can answer the initial question: the representation of <code>float</code> includes an exponent bit, resulting in a range far greater than <code>int</code>. According to the above calculation, the maximum positive number that <code>float</code> can represent is \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\), and the minimum negative number can be obtained by switching the sign bit.</p> <p>Although floating-point number <code>float</code> expands the range, its side effect is sacrificing precision. The integer type <code>int</code> uses all 32 bits to represent numbers, and the numbers are evenly distributed; however, due to the existence of the exponent bit, the larger the value of floating-point number <code>float</code>, the larger the difference between two adjacent numbers tends to be.</p> <p>As shown in Table 3-2, exponent bits \\(\\mathrm{E} = 0\\) and \\(\\mathrm{E} = 255\\) have special meanings, used to represent zero, infinity, \\(\\mathrm{NaN}\\), etc.</p> <p> Table 3-2   Meaning of exponent bits </p> Exponent Bit E Fraction Bit \\(\\mathrm{N} = 0\\) Fraction Bit \\(\\mathrm{N} \\ne 0\\) Calculation Formula \\(0\\) \\(\\pm 0\\) Subnormal Number \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Normal Number Normal Number \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>It is worth noting that subnormal numbers significantly improve the precision of floating-point numbers. The smallest positive normal number is \\(2^{-126}\\), and the smallest positive subnormal number is \\(2^{-126} \\times 2^{-23}\\).</p> <p>Double-precision <code>double</code> also uses a representation method similar to <code>float</code>, which will not be elaborated here.</p>","path":["Chapter 3. Data Structures","3.3 &nbsp; Number Encoding *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   Summary","text":"","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_data_structure/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Data structures can be classified from two perspectives: logical structure and physical structure. Logical structure describes the logical relationships between data elements, while physical structure describes how data is stored in computer memory.</li> <li>Common logical structures include linear, tree, and network structures. We typically classify data structures as linear (arrays, linked lists, stacks, queues) and non-linear (trees, graphs, heaps) based on their logical structure. The implementation of hash tables may involve both linear and non-linear data structures.</li> <li>When a program runs, data is stored in computer memory. Each memory space has a corresponding memory address, and the program accesses data through these memory addresses.</li> <li>Physical structures are primarily divided into contiguous space storage (arrays) and dispersed space storage (linked lists). All data structures are implemented using arrays, linked lists, or a combination of both.</li> <li>Basic data types in computers include integers <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, floating-point numbers <code>float</code>, <code>double</code>, characters <code>char</code>, and booleans <code>bool</code>. Their value ranges depend on the size of space they occupy and their representation method.</li> <li>Sign-magnitude, 1's complement, and 2's complement are three methods for encoding numbers in computers, and they can be converted into each other. The most significant bit of sign-magnitude is the sign bit, and the remaining bits represent the value of the number.</li> <li>Integers are stored in computers in 2's complement form. Under 2's complement representation, computers can treat the addition of positive and negative numbers uniformly, without needing to design special hardware circuits for subtraction, and there is no ambiguity of positive and negative zero.</li> <li>The encoding of floating-point numbers consists of 1 sign bit, 8 exponent bits, and 23 fraction bits. Due to the exponent bits, the range of floating-point numbers is much larger than that of integers, at the cost of sacrificing precision.</li> <li>ASCII is the earliest English character set, with a length of 1 byte, containing a total of 127 characters. GBK is a commonly used Chinese character set, containing over 20,000 Chinese characters. Unicode is committed to providing a complete character set standard, collecting characters from various languages around the world, thereby solving the garbled text problem caused by inconsistent character encoding methods.</li> <li>UTF-8 is the most popular Unicode encoding method, with excellent universality. It is a variable-length encoding method with good scalability, effectively improving storage space efficiency. UTF-16 and UTF-32 are fixed-length encoding methods. When encoding Chinese characters, UTF-16 occupies less space than UTF-8. Programming languages such as Java and C# use UTF-16 encoding by default.</li> </ul>","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Why do hash tables contain both linear and non-linear data structures?</p> <p>The underlying structure of a hash table is an array. To resolve hash collisions, we may use \"chaining\" (discussed in the subsequent \"Hash Collision\" section): each bucket in the array points to a linked list, which may be converted to a tree (usually a red-black tree) when the list length exceeds a certain threshold.</p> <p>From a storage perspective, the underlying structure of a hash table is an array, where each bucket slot may contain a value, a linked list, or a tree. Therefore, hash tables may contain both linear data structures (arrays, linked lists) and non-linear data structures (trees).</p> <p>Q: Is the length of the <code>char</code> type 1 byte?</p> <p>The length of the <code>char</code> type is determined by the encoding method used by the programming language. For example, Java, JavaScript, TypeScript, and C# all use UTF-16 encoding (to store Unicode code points), so the <code>char</code> type has a length of 2 bytes.</p> <p>Q: Is there ambiguity in referring to array-based data structures as \"static data structures\"? Stacks can also perform \"dynamic\" operations such as push and pop.</p> <p>Stacks can indeed implement dynamic data operations, but the data structure is still \"static\" (fixed length). Although array-based data structures can dynamically add or remove elements, their capacity is fixed. If the data volume exceeds the pre-allocated size, a new larger array needs to be created, and the contents of the old array must be copied to the new array.</p> <p>Q: When constructing a stack (queue), its size is not specified. Why are they \"static data structures\"?</p> <p>In high-level programming languages, we do not need to manually specify the initial capacity of a stack (queue); this work is automatically completed within the class. For example, the initial capacity of Java's <code>ArrayList</code> is typically 10. Additionally, the expansion operation is also automatically implemented. See the subsequent \"List\" section for details.</p> <p>Q: The method of converting sign-magnitude to 2's complement is \"first negate then add 1\". So converting 2's complement to sign-magnitude should be the inverse operation \"first subtract 1 then negate\". However, 2's complement can also be converted to sign-magnitude through \"first negate then add 1\". Why is this?</p> <p>This is because the mutual conversion between sign-magnitude and 2's complement is actually the process of computing the \"complement\". Let us first define the complement: assuming \\(a + b = c\\), then we say that \\(a\\) is the complement of \\(b\\) to \\(c\\), and conversely, \\(b\\) is the complement of \\(a\\) to \\(c\\).</p> <p>Given an \\(n = 4\\) bit binary number \\(0010\\), if we treat this number as sign-magnitude (ignoring the sign bit), then its 2's complement can be obtained through \"first negate then add 1\":</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>We find that the sum of sign-magnitude and 2's complement is \\(0010 + 1110 = 10000\\), which means the 2's complement \\(1110\\) is the \"complement\" of sign-magnitude \\(0010\\) to \\(10000\\). This means the above \"first negate then add 1\" is actually the process of computing the complement to \\(10000\\).</p> <p>So, what is the \"complement\" of 2's complement \\(1110\\) to \\(10000\\)? We can still use \"first negate then add 1\" to obtain it:</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>In other words, sign-magnitude and 2's complement are each other's \"complement\" to \\(10000\\), so \"sign-magnitude to 2's complement\" and \"2's complement to sign-magnitude\" can be implemented using the same operation (first negate then add 1).</p> <p>Of course, we can also use the inverse operation to find the sign-magnitude of 2's complement \\(1110\\), that is, \"first subtract 1 then negate\":</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>In summary, both \"first negate then add 1\" and \"first subtract 1 then negate\" are computing the complement to \\(10000\\), and they are equivalent.</p> <p>Essentially, the \"negate\" operation is actually finding the complement to \\(1111\\) (because <code>sign-magnitude + 1's complement = 1111</code> always holds); and adding 1 to the 1's complement yields the 2's complement, which is the complement to \\(10000\\).</p> <p>The above uses \\(n = 4\\) as an example, and it can be generalized to binary numbers of any number of bits.</p>","path":["Chapter 3. Data Structures","3.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"Chapter 12.   Divide and Conquer","text":"<p>Abstract</p> <p>Difficult problems are decomposed layer by layer, with each decomposition making them simpler.</p> <p>Divide and conquer reveals an important truth: start with simplicity, and nothing remains complex.</p>","path":["Chapter 12. Divide and Conquer","Chapter 12. &nbsp; Divide and Conquer"],"tags":[]},{"location":"chapter_divide_and_conquer/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>12.1   Divide and Conquer Algorithms</li> <li>12.2   Divide and Conquer Search Strategy</li> <li>12.3   Building a Binary Tree Problem</li> <li>12.4   Hanoi Tower Problem</li> <li>12.5   Summary</li> </ul>","path":["Chapter 12. Divide and Conquer","Chapter 12. &nbsp; Divide and Conquer"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   Divide and Conquer Search Strategy","text":"<p>We have already learned that search algorithms are divided into two major categories.</p> <ul> <li>Brute-force search: Implemented by traversing the data structure, with a time complexity of \\(O(n)\\).</li> <li>Adaptive search: Utilizes unique data organization forms or prior information, with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\).</li> </ul> <p>In fact, search algorithms with time complexity of \\(O(\\log n)\\) are typically implemented based on the divide and conquer strategy, such as binary search and trees.</p> <ul> <li>Each step of binary search divides the problem (searching for a target element in an array) into a smaller problem (searching for the target element in half of the array), continuing until the array is empty or the target element is found.</li> <li>Trees are representative of the divide and conquer idea. In data structures such as binary search trees, AVL trees, and heaps, the time complexity of various operations is \\(O(\\log n)\\).</li> </ul> <p>The divide and conquer strategy of binary search is as follows.</p> <ul> <li>The problem can be decomposed: Binary search recursively decomposes the original problem (searching in an array) into subproblems (searching in half of the array), achieved by comparing the middle element with the target element.</li> <li>Subproblems are independent: In binary search, each round only processes one subproblem, which is not affected by other subproblems.</li> <li>Solutions of subproblems do not need to be merged: Binary search aims to find a specific element, so there is no need to merge the solutions of subproblems. When a subproblem is solved, the original problem is also solved.</li> </ul> <p>Divide and conquer can improve search efficiency because brute-force search can only eliminate one option per round, while divide and conquer search can eliminate half of the options per round.</p>","path":["Chapter 12. Divide and Conquer","12.2 &nbsp; Divide and Conquer Search Strategy"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1-implementing-binary-search-based-on-divide-and-conquer","level":3,"title":"1.   Implementing Binary Search Based on Divide and Conquer","text":"<p>In previous sections, binary search was implemented based on iteration. Now we implement it based on divide and conquer (recursion).</p> <p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\), where all elements are unique, find the element <code>target</code>.</p> <p>From a divide and conquer perspective, we denote the subproblem corresponding to the search interval \\([i, j]\\) as \\(f(i, j)\\).</p> <p>Starting from the original problem \\(f(0, n-1)\\), perform binary search through the following steps.</p> <ol> <li>Calculate the midpoint \\(m\\) of the search interval \\([i, j]\\), and use it to eliminate half of the search interval.</li> <li>Recursively solve the subproblem reduced by half in size, which could be \\(f(i, m-1)\\) or \\(f(m+1, j)\\).</li> <li>Repeat steps <code>1.</code> and <code>2.</code> until <code>target</code> is found or the interval is empty and return.</li> </ol> <p>Figure 12-4 shows the divide and conquer process of binary search for element \\(6\\) in an array.</p> <p></p> <p> Figure 12-4   Divide and conquer process of binary search </p> <p>In the implementation code, we declare a recursive function <code>dfs()</code> to solve the problem \\(f(i, j)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"Binary search: problem f(i, j)\"\"\"\n    # If the interval is empty, it means there is no target element, return -1\n    if i &gt; j:\n        return -1\n    # Calculate the midpoint index m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # Found the target element, return its index\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search\"\"\"\n    n = len(nums)\n    # Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* Binary search: problem f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* Binary search: problem f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* Binary search: problem f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // Solve the problem f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* Binary search: problem f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // If interval is empty, indicating no target element, return -1\n    if i &gt; j {\n        return -1\n    }\n    // Calculate midpoint index\n    m := i + ((j - i) &gt;&gt; 1)\n    // Compare midpoint with target element\n    if nums[m] &lt; target {\n        // If smaller, recurse on right half of array\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // If larger, recurse on left half of array\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // Found the target element, return its index\n        return m\n    }\n}\n\n/* Binary search */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* Binary search: problem f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // If the interval is empty, it means there is no target element, return -1\n    if i &gt; j {\n        return -1\n    }\n    // Calculate the midpoint index m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // Found the target element, return its index\n        return m\n    }\n}\n\n/* Binary search */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Solve the problem f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* Binary search: problem f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* Binary search: problem f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* Binary search: problem f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // If the interval is empty, it means there is no target element, return -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // Calculate the midpoint index m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // Recursion subproblem f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // Recursion subproblem f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // Found the target element, return its index\n    return m;\n  }\n}\n\n/* Binary search */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // Solve the problem f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* Binary search: problem f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // If the interval is empty, it means there is no target element, return -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // Solve the problem f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* Binary search: problem f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Calculate the midpoint index m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Found the target element, return its index\n        return m;\n    }\n}\n\n/* Binary search */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* Binary search: problem f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // If the interval is empty, it means there is no target element, return -1\n    if (i &gt; j) {\n        return -1\n    }\n    // Calculate the midpoint index m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // Recursion subproblem f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // Recursion subproblem f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // Found the target element, return its index\n        m\n    }\n}\n\n/* Binary search */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // Solve the problem f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### Binary search: problem f(i, j) ###\ndef dfs(nums, target, i, j)\n  # If the interval is empty, it means there is no target element, return -1\n  return -1 if i &gt; j\n\n  # Calculate the midpoint index m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # Recursion subproblem f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # Recursion subproblem f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # Found the target element, return its index\n    return m\n  end\nend\n\n### Binary search ###\ndef binary_search(nums, target)\n  n = nums.length\n  # Solve the problem f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre>","path":["Chapter 12. Divide and Conquer","12.2 &nbsp; Divide and Conquer Search Strategy"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   Building a Binary Tree Problem","text":"<p>Question</p> <p>Given the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code> of a binary tree, construct the binary tree and return the root node of the binary tree. Assume there are no duplicate node values in the binary tree (as shown in Figure 12-5).</p> <p></p> <p> Figure 12-5   Example data for building a binary tree </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1-determining-if-it-is-a-divide-and-conquer-problem","level":3,"title":"1.   Determining If It Is a Divide and Conquer Problem","text":"<p>The original problem is defined as constructing a binary tree from <code>preorder</code> and <code>inorder</code>, which is a typical divide and conquer problem.</p> <ul> <li>The problem can be decomposed: From a divide and conquer perspective, we can divide the original problem into two subproblems: constructing the left subtree and constructing the right subtree, plus one operation: initializing the root node. For each subtree (subproblem), we can still reuse the above division method, dividing it into smaller subtrees (subproblems) until the smallest subproblem (empty subtree) is reached.</li> <li>Subproblems are independent: The left and right subtrees are independent of each other; there is no overlap between them. When constructing the left subtree, we only need to focus on the parts of the inorder and preorder traversals corresponding to the left subtree. The same applies to the right subtree.</li> <li>Solutions of subproblems can be merged: Once we have the left and right subtrees (solutions of subproblems), we can link them to the root node to obtain the solution to the original problem.</li> </ul>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2-how-to-divide-subtrees","level":3,"title":"2.   How to Divide Subtrees","text":"<p>Based on the above analysis, this problem can be solved using divide and conquer, but how do we divide the left and right subtrees through the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code>?</p> <p>According to the definition, both <code>preorder</code> and <code>inorder</code> can be divided into three parts.</p> <ul> <li>Preorder traversal: <code>[ Root Node | Left Subtree | Right Subtree ]</code>, for example, the tree in Figure 12-5 corresponds to <code>[ 3 | 9 | 2 1 7 ]</code>.</li> <li>Inorder traversal: <code>[ Left Subtree | Root Node ｜ Right Subtree ]</code>, for example, the tree in Figure 12-5 corresponds to <code>[ 9 | 3 | 1 2 7 ]</code>.</li> </ul> <p>Using the data from the figure above as an example, we can obtain the division results through the steps shown in Figure 12-6.</p> <ol> <li>The first element 3 in the preorder traversal is the value of the root node.</li> <li>Find the index of root node 3 in <code>inorder</code>, and use this index to divide <code>inorder</code> into <code>[ 9 | 3 ｜ 1 2 7 ]</code>.</li> <li>Based on the division result of <code>inorder</code>, it is easy to determine that the left and right subtrees have 1 and 3 nodes respectively, allowing us to divide <code>preorder</code> into <code>[ 3 | 9 | 2 1 7 ]</code>.</li> </ol> <p></p> <p> Figure 12-6   Dividing subtrees in preorder and inorder traversals </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3-describing-subtree-intervals-based-on-variables","level":3,"title":"3.   Describing Subtree Intervals Based on Variables","text":"<p>Based on the above division method, we have obtained the index intervals of the root node, left subtree, and right subtree in <code>preorder</code> and <code>inorder</code>. To describe these index intervals, we need to use several pointer variables.</p> <ul> <li>Denote the index of the current tree's root node in <code>preorder</code> as \\(i\\).</li> <li>Denote the index of the current tree's root node in <code>inorder</code> as \\(m\\).</li> <li>Denote the index interval of the current tree in <code>inorder</code> as \\([l, r]\\).</li> </ul> <p>As shown in Table 12-1, through these variables we can represent the index of the root node in <code>preorder</code> and the index intervals of the subtrees in <code>inorder</code>.</p> <p> Table 12-1   Indices of root node and subtrees in preorder and inorder traversals </p> Root node index in <code>preorder</code> Subtree index interval in <code>inorder</code> Current tree \\(i\\) \\([l, r]\\) Left subtree \\(i + 1\\) \\([l, m-1]\\) Right subtree \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>Please note that \\((m-l)\\) in the right subtree root node index means \"the number of nodes in the left subtree\". It is recommended to understand this in conjunction with Figure 12-7.</p> <p></p> <p> Figure 12-7   Index interval representation of root node and left and right subtrees </p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4-code-implementation","level":3,"title":"4.   Code Implementation","text":"<p>To improve the efficiency of querying \\(m\\), we use a hash table <code>hmap</code> to store the mapping from elements in the <code>inorder</code> array to their indices:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"Build binary tree: divide and conquer\"\"\"\n    # Terminate when the subtree interval is empty\n    if r - l &lt; 0:\n        return None\n    # Initialize the root node\n    root = TreeNode(preorder[i])\n    # Query m to divide the left and right subtrees\n    m = inorder_map[preorder[i]]\n    # Subproblem: build the left subtree\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # Subproblem: build the right subtree\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # Return the root node\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"Build binary tree\"\"\"\n    # Initialize hash map, storing the mapping from inorder elements to indices\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* Build binary tree: divide and conquer */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return NULL;\n    // Initialize the root node\n    TreeNode *root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* Build binary tree: divide and conquer */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return null;\n    // Initialize the root node\n    TreeNode root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* Build binary tree: divide and conquer */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return null;\n    // Initialize the root node\n    TreeNode root = new(preorder[i]);\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* Build binary tree: divide and conquer */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // Terminate when the subtree interval is empty\n    if r-l &lt; 0 {\n        return nil\n    }\n    // Initialize the root node\n    root := NewTreeNode(preorder[i])\n    // Query m to divide the left and right subtrees\n    m := inorderMap[preorder[i]]\n    // Subproblem: build the left subtree\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // Subproblem: build the right subtree\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* Build binary tree: divide and conquer */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // Terminate when the subtree interval is empty\n    if r - l &lt; 0 {\n        return nil\n    }\n    // Initialize the root node\n    let root = TreeNode(x: preorder[i])\n    // Query m to divide the left and right subtrees\n    let m = inorderMap[preorder[i]]!\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* Build binary tree: divide and conquer */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null;\n    // Initialize the root node\n    const root = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    const m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nfunction buildTree(preorder, inorder) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* Build binary tree: divide and conquer */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null;\n    // Initialize the root node\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // Query m to divide the left and right subtrees\n    const m = inorderMap.get(preorder[i]);\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* Build binary tree: divide and conquer */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // Terminate when the subtree interval is empty\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // Initialize the root node\n  TreeNode? root = TreeNode(preorder[i]);\n  // Query m to divide the left and right subtrees\n  int m = inorderMap[preorder[i]]!;\n  // Subproblem: build the left subtree\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // Subproblem: build the right subtree\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // Return the root node\n  return root;\n}\n\n/* Build binary tree */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // Initialize hash map, storing the mapping from inorder elements to indices\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* Build binary tree: divide and conquer */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Terminate when the subtree interval is empty\n    if r - l &lt; 0 {\n        return None;\n    }\n    // Initialize the root node\n    let root = TreeNode::new(preorder[i as usize]);\n    // Query m to divide the left and right subtrees\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // Subproblem: build the left subtree\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // Subproblem: build the right subtree\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // Return the root node\n    Some(root)\n}\n\n/* Build binary tree */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* Build binary tree: divide and conquer */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0)\n        return NULL;\n    // Initialize the root node\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // Query m to divide the left and right subtrees\n    int m = inorderMap[preorder[i]];\n    // Subproblem: build the left subtree\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // Subproblem: build the right subtree\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // Return the root node\n    return root;\n}\n\n/* Build binary tree */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* Build binary tree: divide and conquer */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // Terminate when the subtree interval is empty\n    if (r - l &lt; 0) return null\n    // Initialize the root node\n    val root = TreeNode(preorder[i])\n    // Query m to divide the left and right subtrees\n    val m = inorderMap[preorder[i]]!!\n    // Subproblem: build the left subtree\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // Subproblem: build the right subtree\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // Return the root node\n    return root\n}\n\n/* Build binary tree */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // Initialize hash map, storing the mapping from inorder elements to indices\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### Build binary tree: divide and conquer ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # Terminate when the subtree interval is empty\n  return if r - l &lt; 0\n\n  # Initialize the root node\n  root = TreeNode.new(preorder[i])\n  # Query m to divide the left and right subtrees\n  m = inorder_map[preorder[i]]\n  # Subproblem: build the left subtree\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # Subproblem: build the right subtree\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # Return the root node\n  root\nend\n\n### Build binary tree ###\ndef build_tree(preorder, inorder)\n  # Initialize hash map, storing the mapping from inorder elements to indices\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> <p>Figure 12-8 shows the recursive process of building the binary tree. Each node is established during the downward \"recursion\" process, while each edge (reference) is established during the upward \"return\" process.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 12-8   Recursive process of building a binary tree </p> <p>The division results of the preorder traversal <code>preorder</code> and inorder traversal <code>inorder</code> within each recursive function are shown in Figure 12-9.</p> <p></p> <p> Figure 12-9   Division results in each recursive function </p> <p>Let the number of nodes in the tree be \\(n\\). Initializing each node (executing one recursive function <code>dfs()</code>) takes \\(O(1)\\) time. Therefore, the overall time complexity is \\(O(n)\\).</p> <p>The hash table stores the mapping from <code>inorder</code> elements to their indices, with a space complexity of \\(O(n)\\). In the worst case, when the binary tree degenerates into a linked list, the recursion depth reaches \\(n\\), using \\(O(n)\\) stack frame space. Therefore, the overall space complexity is \\(O(n)\\).</p>","path":["Chapter 12. Divide and Conquer","12.3 &nbsp; Building a Binary Tree Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   Divide and Conquer Algorithms","text":"<p>Divide and conquer is a very important and common algorithm strategy. Divide and conquer is typically implemented based on recursion, consisting of two steps: \"divide\" and \"conquer\".</p> <ol> <li>Divide (partition phase): Recursively divide the original problem into two or more subproblems until the smallest subproblem is reached.</li> <li>Conquer (merge phase): Starting from the smallest subproblems with known solutions, merge the solutions of subproblems from bottom to top to construct the solution to the original problem.</li> </ol> <p>As shown in Figure 12-1, \"merge sort\" is one of the typical applications of the divide and conquer strategy.</p> <ol> <li>Divide: Recursively divide the original array (original problem) into two subarrays (subproblems) until the subarray has only one element (smallest subproblem).</li> <li>Conquer: Merge the sorted subarrays (solutions to subproblems) from bottom to top to obtain a sorted original array (solution to the original problem).</li> </ol> <p></p> <p> Figure 12-1   Divide and conquer strategy of merge sort </p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211-how-to-determine-divide-and-conquer-problems","level":2,"title":"12.1.1   How to Determine Divide and Conquer Problems","text":"<p>Whether a problem is suitable for solving with divide and conquer can usually be determined based on the following criteria.</p> <ol> <li>The problem can be decomposed: The original problem can be divided into smaller, similar subproblems, and can be recursively divided in the same way.</li> <li>Subproblems are independent: There is no overlap between subproblems, they are independent of each other and can be solved independently.</li> <li>Solutions of subproblems can be merged: The solution to the original problem is obtained by merging the solutions of subproblems.</li> </ol> <p>Clearly, merge sort satisfies these three criteria.</p> <ol> <li>The problem can be decomposed: Recursively divide the array (original problem) into two subarrays (subproblems).</li> <li>Subproblems are independent: Each subarray can be sorted independently (subproblems can be solved independently).</li> <li>Solutions of subproblems can be merged: Two sorted subarrays (solutions of subproblems) can be merged into one sorted array (solution of the original problem).</li> </ol>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212-improving-efficiency-through-divide-and-conquer","level":2,"title":"12.1.2   Improving Efficiency Through Divide and Conquer","text":"<p>Divide and conquer can not only effectively solve algorithmic problems but often also improve algorithm efficiency. In sorting algorithms, quick sort, merge sort, and heap sort are faster than selection, bubble, and insertion sort because they apply the divide and conquer strategy.</p> <p>This raises the question: Why can divide and conquer improve algorithm efficiency, and what is the underlying logic? In other words, why is dividing a large problem into multiple subproblems, solving the subproblems, and merging their solutions more efficient than directly solving the original problem? This question can be discussed from two aspects: operation count and parallel computation.</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1-operation-count-optimization","level":3,"title":"1.   Operation Count Optimization","text":"<p>Taking \"bubble sort\" as an example, processing an array of length \\(n\\) requires \\(O(n^2)\\) time. Suppose we divide the array into two subarrays from the midpoint as shown in Figure 12-2, the division requires \\(O(n)\\) time, sorting each subarray requires \\(O((n / 2)^2)\\) time, and merging the two subarrays requires \\(O(n)\\) time, resulting in an overall time complexity of:</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> Figure 12-2   Bubble sort before and after array division </p> <p>Next, we compute the following inequality, where the left and right sides represent the total number of operations before and after division, respectively:</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>This means that when \\(n &gt; 4\\), the number of operations after division is smaller, and sorting efficiency should be higher. Note that the time complexity after division is still quadratic \\(O(n^2)\\), but the constant term in the complexity has become smaller.</p> <p>Going further, what if we continuously divide the subarrays from their midpoints into two subarrays until the subarrays have only one element? This approach is actually \"merge sort\", with a time complexity of \\(O(n \\log n)\\).</p> <p>Thinking further, what if we set multiple division points and evenly divide the original array into \\(k\\) subarrays? This situation is very similar to \"bucket sort\", which is well-suited for sorting massive amounts of data, with a theoretical time complexity of \\(O(n + k)\\).</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2-parallel-computation-optimization","level":3,"title":"2.   Parallel Computation Optimization","text":"<p>We know that the subproblems generated by divide and conquer are independent of each other, so they can typically be solved in parallel. This means divide and conquer can not only reduce the time complexity of algorithms, but also benefits from parallel optimization by operating systems.</p> <p>Parallel optimization is particularly effective in multi-core or multi-processor environments, as the system can simultaneously handle multiple subproblems, making fuller use of computing resources and significantly reducing overall runtime.</p> <p>For example, in the \"bucket sort\" shown in Figure 12-3, we evenly distribute massive data into various buckets, and the sorting tasks for all buckets can be distributed to various computing units. After completion, the results are merged.</p> <p></p> <p> Figure 12-3   Parallel computation in bucket sort </p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213-common-applications-of-divide-and-conquer","level":2,"title":"12.1.3   Common Applications of Divide and Conquer","text":"<p>On one hand, divide and conquer can be used to solve many classic algorithmic problems.</p> <ul> <li>Finding the closest pair of points: This algorithm first divides the point set into two parts, then finds the closest pair of points in each part separately, and finally finds the closest pair of points that spans both parts.</li> <li>Large integer multiplication: For example, the Karatsuba algorithm, which decomposes large integer multiplication into several smaller integer multiplications and additions.</li> <li>Matrix multiplication: For example, the Strassen algorithm, which decomposes large matrix multiplication into multiple small matrix multiplications and additions.</li> <li>Hanota problem: The hanota problem can be solved through recursion, which is a typical application of the divide and conquer strategy.</li> <li>Solving inversion pairs: In a sequence, if a preceding number is greater than a following number, these two numbers form an inversion pair. Solving the inversion pair problem can utilize the divide and conquer approach with the help of merge sort.</li> </ul> <p>On the other hand, divide and conquer is widely applied in the design of algorithms and data structures.</p> <ul> <li>Binary search: Binary search divides a sorted array into two parts from the midpoint index, then decides which half to eliminate based on the comparison result between the target value and the middle element value, and performs the same binary operation on the remaining interval.</li> <li>Merge sort: Already introduced at the beginning of this section, no further elaboration needed.</li> <li>Quick sort: Quick sort selects a pivot value, then divides the array into two subarrays, one with elements smaller than the pivot and the other with elements larger than the pivot, then performs the same division operation on these two parts until the subarrays have only one element.</li> <li>Bucket sort: The basic idea of bucket sort is to scatter data into multiple buckets, then sort the elements within each bucket, and finally extract the elements from each bucket in sequence to obtain a sorted array.</li> <li>Trees: For example, binary search trees, AVL trees, red-black trees, B-trees, B+ trees, etc. Their search, insertion, and deletion operations can all be viewed as applications of the divide and conquer strategy.</li> <li>Heaps: A heap is a special complete binary tree, and its various operations, such as insertion, deletion, and heapify, actually imply the divide and conquer idea.</li> <li>Hash tables: Although hash tables do not directly apply divide and conquer, some hash collision resolution solutions indirectly apply the divide and conquer strategy. For example, long linked lists in chaining may be converted to red-black trees to improve query efficiency.</li> </ul> <p>It can be seen that divide and conquer is a \"subtly pervasive\" algorithmic idea, embedded in various algorithms and data structures.</p>","path":["Chapter 12. Divide and Conquer","12.1 &nbsp; Divide and Conquer Algorithms"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   Hanota Problem","text":"<p>In merge sort and building binary trees, we decompose the original problem into two subproblems, each half the size of the original problem. However, for the hanota problem, we adopt a different decomposition strategy.</p> <p>Question</p> <p>Given three pillars, denoted as <code>A</code>, <code>B</code>, and <code>C</code>. Initially, pillar <code>A</code> has \\(n\\) discs stacked on it, arranged from top to bottom in ascending order of size. Our task is to move these \\(n\\) discs to pillar <code>C</code> while maintaining their original order (as shown in Figure 12-10). The following rules must be followed when moving the discs.</p> <ol> <li>A disc can only be taken from the top of one pillar and placed on top of another pillar.</li> <li>Only one disc can be moved at a time.</li> <li>A smaller disc must always be on top of a larger disc.</li> </ol> <p></p> <p> Figure 12-10   Example of the hanota problem </p> <p>We denote the hanota problem of size \\(i\\) as \\(f(i)\\). For example, \\(f(3)\\) represents moving \\(3\\) discs from <code>A</code> to <code>C</code>.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1-considering-the-base-cases","level":3,"title":"1.   Considering the Base Cases","text":"<p>As shown in Figure 12-11, for problem \\(f(1)\\), when there is only one disc, we can move it directly from <code>A</code> to <code>C</code>.</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> Figure 12-11   Solution for a problem of size 1 </p> <p>As shown in Figure 12-12, for problem \\(f(2)\\), when there are two discs, since we must always keep the smaller disc on top of the larger disc, we need to use <code>B</code> to assist in the move.</p> <ol> <li>First, move the smaller disc from <code>A</code> to <code>B</code>.</li> <li>Then move the larger disc from <code>A</code> to <code>C</code>.</li> <li>Finally, move the smaller disc from <code>B</code> to <code>C</code>.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 12-12   Solution for a problem of size 2 </p> <p>The process of solving problem \\(f(2)\\) can be summarized as: moving two discs from <code>A</code> to <code>C</code> with the help of <code>B</code>. Here, <code>C</code> is called the target pillar, and <code>B</code> is called the buffer pillar.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2-subproblem-decomposition","level":3,"title":"2.   Subproblem Decomposition","text":"<p>For problem \\(f(3)\\), when there are three discs, the situation becomes slightly more complex.</p> <p>Since we already know the solutions to \\(f(1)\\) and \\(f(2)\\), we can think from a divide and conquer perspective, treating the top two discs on <code>A</code> as a whole, and execute the steps shown in Figure 12-13. This successfully moves the three discs from <code>A</code> to <code>C</code>.</p> <ol> <li>Let <code>B</code> be the target pillar and <code>C</code> be the buffer pillar, and move two discs from <code>A</code> to <code>B</code>.</li> <li>Move the remaining disc from <code>A</code> directly to <code>C</code>.</li> <li>Let <code>C</code> be the target pillar and <code>A</code> be the buffer pillar, and move two discs from <code>B</code> to <code>C</code>.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 12-13   Solution for a problem of size 3 </p> <p>Essentially, we divide problem \\(f(3)\\) into two subproblems \\(f(2)\\) and one subproblem \\(f(1)\\). By solving these three subproblems in order, the original problem is solved. This shows that the subproblems are independent and their solutions can be merged.</p> <p>From this, we can summarize the divide and conquer strategy for solving the hanota problem shown in Figure 12-14: divide the original problem \\(f(n)\\) into two subproblems \\(f(n-1)\\) and one subproblem \\(f(1)\\), and solve these three subproblems in the following order.</p> <ol> <li>Move \\(n-1\\) discs from <code>A</code> to <code>B</code> with the help of <code>C</code>.</li> <li>Move the remaining \\(1\\) disc directly from <code>A</code> to <code>C</code>.</li> <li>Move \\(n-1\\) discs from <code>B</code> to <code>C</code> with the help of <code>A</code>.</li> </ol> <p>For these two subproblems \\(f(n-1)\\), we can recursively divide them in the same way until reaching the smallest subproblem \\(f(1)\\). The solution to \\(f(1)\\) is known and requires only one move operation.</p> <p></p> <p> Figure 12-14   Divide and conquer strategy for solving the hanota problem </p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3-code-implementation","level":3,"title":"3.   Code Implementation","text":"<p>In the code, we declare a recursive function <code>dfs(i, src, buf, tar)</code>, whose purpose is to move the top \\(i\\) discs from pillar <code>src</code> to target pillar <code>tar</code> with the help of buffer pillar <code>buf</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"Move a disk\"\"\"\n    # Take out a disk from the top of src\n    pan = src.pop()\n    # Place the disk on top of tar\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"Solve the Tower of Hanoi problem f(i)\"\"\"\n    # If there is only one disk left in src, move it directly to tar\n    if i == 1:\n        move(src, tar)\n        return\n    # Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf)\n    # Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    # Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"Solve the Tower of Hanoi problem\"\"\"\n    n = len(A)\n    # Move the top n disks from A to C using B\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* Move a disk */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // Take out a disk from the top of src\n    int pan = src.back();\n    src.pop_back();\n    // Place the disk on top of tar\n    tar.push_back(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* Move a disk */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // Take out a disk from the top of src\n    Integer pan = src.remove(src.size() - 1);\n    // Place the disk on top of tar\n    tar.add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* Move a disk */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // Take out a disk from the top of src\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // Place the disk on top of tar\n    tar.Add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    DFS(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    Move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    DFS(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // Move the top n disks from A to C using B\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* Move a disk */\nfunc move(src, tar *list.List) {\n    // Take out a disk from the top of src\n    pan := src.Back()\n    // Place the disk on top of tar\n    tar.PushBack(pan.Value)\n    // Remove top disk from src\n    src.Remove(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfsHanota(i-1, src, tar, buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // Move the top n disks from A to C using B\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* Move a disk */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // Take out a disk from the top of src\n    let pan = src.popLast()!\n    // Place the disk on top of tar\n    tar.append(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src: &amp;src, tar: &amp;tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // The tail of the list is the top of the rod\n    // Move top n disks from src to C using B\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* Move a disk */\nfunction move(src, tar) {\n    // Take out a disk from the top of src\n    const pan = src.pop();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunction dfs(i, src, buf, tar) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* Move a disk */\nfunction move(src: number[], tar: number[]): void {\n    // Take out a disk from the top of src\n    const pan = src.pop();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // If there is only one disk left in src, move it directly to tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* Move a disk */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // Take out a disk from the top of src\n  int pan = src.removeLast();\n  // Place the disk on top of tar\n  tar.add(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // If there is only one disk left in src, move it directly to tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n  dfs(i - 1, src, tar, buf);\n  // Subproblem f(1): move the remaining disk from src to tar\n  move(src, tar);\n  // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n  dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // Move the top n disks from A to C using B\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* Move a disk */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Take out a disk from the top of src\n    let pan = src.pop().unwrap();\n    // Place the disk on top of tar\n    tar.push(pan);\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // If there is only one disk left in src, move it directly to tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move_pan(src, tar);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Solve the Tower of Hanoi problem */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* Move a disk */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // Take out a disk from the top of src\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // Place the disk on top of tar\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, srcSize, tar, tarSize);\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* Solve the Tower of Hanoi problem */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // Move the top n disks from A to C using B\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* Move a disk */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Take out a disk from the top of src\n    val pan = src.removeAt(src.size - 1)\n    // Place the disk on top of tar\n    tar.add(pan)\n}\n\n/* Solve the Tower of Hanoi problem f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // If there is only one disk left in src, move it directly to tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n    dfs(i - 1, src, tar, buf)\n    // Subproblem f(1): move the remaining disk from src to tar\n    move(src, tar)\n    // Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n    dfs(i - 1, buf, src, tar)\n}\n\n/* Solve the Tower of Hanoi problem */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // Move the top n disks from A to C using B\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### Move one disk ###\ndef move(src, tar)\n  # Take out a disk from the top of src\n  pan = src.pop\n  # Place the disk on top of tar\n  tar &lt;&lt; pan\nend\n\n### Solve Tower of Hanoi f(i) ###\ndef dfs(i, src, buf, tar)\n  # If there is only one disk left in src, move it directly to tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # Subproblem f(i-1): move the top i-1 disks from src to buf using tar\n  dfs(i - 1, src, tar, buf)\n  # Subproblem f(1): move the remaining disk from src to tar\n  move(src, tar)\n  # Subproblem f(i-1): move the top i-1 disks from buf to tar using src\n  dfs(i - 1, buf, src, tar)\nend\n\n### Solve Tower of Hanoi ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # Move the top n disks from A to C using B\n  dfs(n, _A, _B, _C)\nend\n</code></pre> <p>As shown in Figure 12-15, the hanota problem forms a recursion tree of height \\(n\\), where each node represents a subproblem corresponding to an invocation of the <code>dfs()</code> function, therefore the time complexity is \\(O(2^n)\\) and the space complexity is \\(O(n)\\).</p> <p></p> <p> Figure 12-15   Recursion tree of the hanota problem </p> <p>Quote</p> <p>The hanota problem originates from an ancient legend. In a temple in ancient India, monks had three tall diamond pillars and \\(64\\) golden discs of different sizes. The monks continuously moved the discs, believing that when the last disc was correctly placed, the world would come to an end.</p> <p>However, even if the monks moved one disc per second, it would take approximately \\(2^{64} \\approx 1.84×10^{19}\\) seconds, which is about \\(5850\\) billion years, far exceeding current estimates of the age of the universe. Therefore, if this legend is true, we should not need to worry about the end of the world.</p>","path":["Chapter 12. Divide and Conquer","12.4 &nbsp; Hanota Problem"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   Summary","text":"","path":["Chapter 12. Divide and Conquer","12.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Divide and conquer is a common algorithm design strategy, consisting of two phases: divide (partition) and conquer (merge), typically implemented based on recursion.</li> <li>The criteria for determining whether a problem is a divide and conquer problem include: whether the problem can be decomposed, whether subproblems are independent, and whether subproblems can be merged.</li> <li>Merge sort is a typical application of the divide and conquer strategy. It recursively divides an array into two equal-length subarrays until only one element remains, then merges them layer by layer to complete the sorting.</li> <li>Introducing the divide and conquer strategy can often improve algorithm efficiency. On one hand, the divide and conquer strategy reduces the number of operations; on the other hand, it facilitates parallel optimization of the system after division.</li> <li>Divide and conquer can both solve many algorithmic problems and is widely applied in data structure and algorithm design, appearing everywhere.</li> <li>Compared to brute-force search, adaptive search is more efficient. Search algorithms with time complexity of \\(O(\\log n)\\) are typically implemented based on the divide and conquer strategy.</li> <li>Binary search is another typical application of divide and conquer. It does not include the step of merging solutions of subproblems. We can implement binary search through recursive divide and conquer.</li> <li>In the problem of building a binary tree, building the tree (original problem) can be divided into building the left subtree and right subtree (subproblems), which can be achieved by dividing the index intervals of the preorder and inorder traversals.</li> <li>In the hanota problem, a problem of size \\(n\\) can be divided into two subproblems of size \\(n-1\\) and one subproblem of size \\(1\\). After solving these three subproblems in order, the original problem is solved.</li> </ul>","path":["Chapter 12. Divide and Conquer","12.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"Chapter 14.   Dynamic Programming","text":"<p>Abstract</p> <p>Streams converge into rivers, rivers converge into the sea.</p> <p>Dynamic programming gathers solutions to small problems into answers to large problems, step by step guiding us to the shore of problem-solving.</p>","path":["Chapter 14. Dynamic Programming","Chapter 14. &nbsp; Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>14.1   Introduction to Dynamic Programming</li> <li>14.2   Characteristics of Dynamic Programming Problems</li> <li>14.3   Dynamic Programming Problem-Solving Approach</li> <li>14.4   0-1 Knapsack Problem</li> <li>14.5   Unbounded Knapsack Problem</li> <li>14.6   Edit Distance Problem</li> <li>14.7   Summary</li> </ul>","path":["Chapter 14. Dynamic Programming","Chapter 14. &nbsp; Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   Characteristics of Dynamic Programming Problems","text":"<p>In the previous section, we learned how dynamic programming solves the original problem by decomposing it into subproblems. In fact, subproblem decomposition is a general algorithmic approach, with different emphases in divide and conquer, dynamic programming, and backtracking.</p> <ul> <li>Divide and conquer algorithms recursively divide the original problem into multiple independent subproblems until the smallest subproblems are reached, and merge the solutions to the subproblems during backtracking to ultimately obtain the solution to the original problem.</li> <li>Dynamic programming also recursively decomposes problems, but the main difference from divide and conquer algorithms is that subproblems in dynamic programming are interdependent, and many overlapping subproblems appear during the decomposition process.</li> <li>Backtracking algorithms enumerate all possible solutions through trial and error, and avoid unnecessary search branches through pruning. The solution to the original problem consists of a series of decision steps, and we can regard the subsequence before each decision step as a subproblem.</li> </ul> <p>In fact, dynamic programming is commonly used to solve optimization problems, which not only contain overlapping subproblems but also have two other major characteristics: optimal substructure and no aftereffects.</p>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421-optimal-substructure","level":2,"title":"14.2.1   Optimal Substructure","text":"<p>We make a slight modification to the stair climbing problem to make it more suitable for demonstrating the concept of optimal substructure.</p> <p>Climbing stairs with minimum cost</p> <p>Given a staircase, where you can climb \\(1\\) or \\(2\\) steps at a time, and each step has a non-negative integer representing the cost you need to pay at that step. Given a non-negative integer array \\(cost\\), where \\(cost[i]\\) represents the cost at the \\(i\\)-th step, and \\(cost[0]\\) is the ground (starting point). What is the minimum cost required to reach the top?</p> <p>As shown in Figure 14-6, if the costs of the \\(1\\)st, \\(2\\)nd, and \\(3\\)rd steps are \\(1\\), \\(10\\), and \\(1\\) respectively, then climbing from the ground to the \\(3\\)rd step requires a minimum cost of \\(2\\).</p> <p></p> <p> Figure 14-6   Minimum cost to climb to the 3rd step </p> <p>Let \\(dp[i]\\) be the accumulated cost of climbing to the \\(i\\)-th step. Since the \\(i\\)-th step can only come from the \\(i-1\\)-th or \\(i-2\\)-th step, \\(dp[i]\\) can only equal \\(dp[i-1] + cost[i]\\) or \\(dp[i-2] + cost[i]\\). To minimize the cost, we should choose the smaller of the two:</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>This leads us to the meaning of optimal substructure: the optimal solution to the original problem is constructed from the optimal solutions to the subproblems.</p> <p>This problem clearly has optimal substructure: we select the better one from the optimal solutions to the two subproblems \\(dp[i-1]\\) and \\(dp[i-2]\\), and use it to construct the optimal solution to the original problem \\(dp[i]\\).</p> <p>So, does the stair climbing problem from the previous section have optimal substructure? Its goal is to find the number of ways, which seems to be a counting problem, but if we change the question: \"Find the maximum number of ways\". We surprisingly discover that although the problem before and after modification are equivalent, the optimal substructure has emerged: the maximum number of ways for the \\(n\\)-th step equals the sum of the maximum number of ways for the \\(n-1\\)-th and \\(n-2\\)-th steps. Therefore, the interpretation of optimal substructure is quite flexible and will have different meanings in different problems.</p> <p>According to the state transition equation and the initial states \\(dp[1] = cost[1]\\) and \\(dp[2] = cost[2]\\), we can obtain the dynamic programming code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"Minimum cost climbing stairs: Dynamic programming\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [0] * (n + 1)\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1], dp[2] = cost[1], cost[2]\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;int&gt; dp(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: 0, count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![-1; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Initialize dp table, used to store solutions to subproblems\n    int *dp = calloc(n + 1, sizeof(int));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Minimum cost climbing stairs: Dynamic programming */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = IntArray(n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Minimum cost climbing stairs: DP ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = cost[1], cost[2]\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> <p>Figure 14-7 shows the dynamic programming process for the above code.</p> <p></p> <p> Figure 14-7   Dynamic programming process for climbing stairs with minimum cost </p> <p>This problem can also be space-optimized, compressing from one dimension to zero, reducing the space complexity from \\(O(n)\\) to \\(O(1)\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"Minimum cost climbing stairs: Space-optimized dynamic programming\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Initial state: preset the solution to the smallest subproblem\n    a, b := cost[1], cost[2]\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Minimum cost climbing stairs: Space-optimized dynamic programming */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Minimum cost climbing stairs: DP ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = cost[1], cost[2]\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# Minimum cost climbing stairs: Space-optimized dynamic programming\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422-no-aftereffects","level":2,"title":"14.2.2   No Aftereffects","text":"<p>No aftereffects is one of the important characteristics that enable dynamic programming to solve problems effectively. Its definition is: given a certain state, its future development is only related to the current state and has nothing to do with all past states.</p> <p>Taking the stair climbing problem as an example, given state \\(i\\), it will develop into states \\(i+1\\) and \\(i+2\\), corresponding to jumping \\(1\\) step and jumping \\(2\\) steps, respectively. When making these two choices, we do not need to consider the states before state \\(i\\), as they have no effect on the future of state \\(i\\).</p> <p>However, if we add a constraint to the stair climbing problem, the situation changes.</p> <p>Climbing stairs with constraint</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time, but you cannot jump \\(1\\) step in two consecutive rounds. How many ways are there to climb to the top?</p> <p>As shown in Figure 14-8, there are only \\(2\\) feasible ways to climb to the \\(3\\)rd step. The way of jumping \\(1\\) step three consecutive times does not satisfy the constraint and is therefore discarded.</p> <p></p> <p> Figure 14-8   Number of ways to climb to the 3rd step with constraint </p> <p>In this problem, if the previous round was a jump of \\(1\\) step, then the next round must jump \\(2\\) steps. This means that the next choice cannot be determined solely by the current state (current stair step number), but also depends on the previous state (the stair step number from the previous round).</p> <p>It is not difficult to see that this problem no longer satisfies no aftereffects, and the state transition equation \\(dp[i] = dp[i-1] + dp[i-2]\\) also fails, because \\(dp[i-1]\\) represents jumping \\(1\\) step in this round, but it includes many solutions where \"the previous round was a jump of \\(1\\) step\", which cannot be directly counted in \\(dp[i]\\) to satisfy the constraint.</p> <p>For this reason, we need to expand the state definition: state \\([i, j]\\) represents being on the \\(i\\)-th step with the previous round having jumped \\(j\\) steps, where \\(j \\in \\{1, 2\\}\\). This state definition effectively distinguishes whether the previous round was a jump of \\(1\\) step or \\(2\\) steps, allowing us to determine where the current state came from.</p> <ul> <li>When the previous round jumped \\(1\\) step, the round before that could only choose to jump \\(2\\) steps, i.e., \\(dp[i, 1]\\) can only be transferred from \\(dp[i-1, 2]\\).</li> <li>When the previous round jumped \\(2\\) steps, the round before that could choose to jump \\(1\\) step or \\(2\\) steps, i.e., \\(dp[i, 2]\\) can be transferred from \\(dp[i-2, 1]\\) or \\(dp[i-2, 2]\\).</li> </ul> <p>As shown in Figure 14-9, under this definition, \\(dp[i, j]\\) represents the number of ways for state \\([i, j]\\). The state transition equation is then:</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> Figure 14-9   Recurrence relation considering constraints </p> <p>Finally, return \\(dp[n, 1] + dp[n, 2]\\), where the sum of the two represents the total number of ways to climb to the \\(n\\)-th step:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"Climbing stairs with constraint: Dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int[][] dp = new int[n + 1][3];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int[,] dp = new int[n + 1, 3];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([][3]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* Climbing stairs with constraint: Dynamic programming */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = Array(n + 1) { IntArray(3) }\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### Climbing stairs with constraint: DP ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # State transition: gradually solve larger subproblems from smaller ones\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> <p>In the above case, since we only need to consider one more preceding state, we can still make the problem satisfy no aftereffects by expanding the state definition. However, some problems have very severe \"aftereffects\".</p> <p>Climbing stairs with obstacle generation</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time. It is stipulated that when climbing to the \\(i\\)-th step, the system will automatically place an obstacle on the \\(2i\\)-th step, and thereafter no round is allowed to jump to the \\(2i\\)-th step. For example, if the first two rounds jump to the \\(2\\)nd and \\(3\\)rd steps, then afterwards you cannot jump to the \\(4\\)th and \\(6\\)th steps. How many ways are there to climb to the top?</p> <p>In this problem, the next jump depends on all past states, because each jump places obstacles on higher steps, affecting future jumps. For such problems, dynamic programming is often difficult to solve.</p> <p>In fact, many complex combinatorial optimization problems (such as the traveling salesman problem) do not satisfy no aftereffects. For such problems, we usually choose to use other methods, such as heuristic search, genetic algorithms, reinforcement learning, etc., to obtain usable local optimal solutions within a limited time.</p>","path":["Chapter 14. Dynamic Programming","14.2 &nbsp; Characteristics of Dynamic Programming Problems"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   Dynamic Programming Problem-Solving Approach","text":"<p>The previous two sections introduced the main characteristics of dynamic programming problems. Next, let us explore two more practical issues together.</p> <ol> <li>How to determine whether a problem is a dynamic programming problem?</li> <li>What is the complete process for solving a dynamic programming problem, and where should we start?</li> </ol>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431-problem-determination","level":2,"title":"14.3.1   Problem Determination","text":"<p>Generally speaking, if a problem contains overlapping subproblems, optimal substructure, and satisfies no aftereffects, then it is usually suitable for solving with dynamic programming. However, it is difficult to directly extract these characteristics from the problem description. Therefore, we usually relax the conditions and first observe whether the problem is suitable for solving with backtracking (exhaustive search).</p> <p>Problems suitable for solving with backtracking usually satisfy the \"decision tree model\", which means the problem can be described using a tree structure, where each node represents a decision and each path represents a sequence of decisions.</p> <p>In other words, if a problem contains an explicit concept of decisions, and the solution is generated through a series of decisions, then it satisfies the decision tree model and can usually be solved using backtracking.</p> <p>On this basis, dynamic programming problems also have some \"bonus points\" for determination.</p> <ul> <li>The problem contains descriptions such as maximum (minimum) or most (least), indicating optimization.</li> <li>The problem's state can be represented using a list, multi-dimensional matrix, or tree, and a state has a recurrence relation with its surrounding states.</li> </ul> <p>Correspondingly, there are also some \"penalty points\".</p> <ul> <li>The goal of the problem is to find all possible solutions, rather than finding the optimal solution.</li> <li>The problem description has obvious permutation and combination characteristics, requiring the return of specific multiple solutions.</li> </ul> <p>If a problem satisfies the decision tree model and has relatively obvious \"bonus points\", we can assume it is a dynamic programming problem and verify it during the solving process.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432-problem-solving-steps","level":2,"title":"14.3.2   Problem-Solving Steps","text":"<p>The problem-solving process for dynamic programming varies depending on the nature and difficulty of the problem, but generally follows these steps: describe decisions, define states, establish the \\(dp\\) table, derive state transition equations, determine boundary conditions, etc.</p> <p>To illustrate the problem-solving steps more vividly, we use a classic problem \"minimum path sum\" as an example.</p> <p>Question</p> <p>Given an \\(n \\times m\\) two-dimensional grid <code>grid</code>, where each cell in the grid contains a non-negative integer representing the cost of that cell. A robot starts from the top-left cell and can only move down or right at each step until reaching the bottom-right cell. Return the minimum path sum from the top-left to the bottom-right.</p> <p>Figure 14-10 shows an example where the minimum path sum for the given grid is \\(13\\).</p> <p></p> <p> Figure 14-10   Minimum path sum example data </p> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>The decision in each round of this problem is to move one step down or right from the current cell. Let the row and column indices of the current cell be \\([i, j]\\). After moving down or right, the indices become \\([i+1, j]\\) or \\([i, j+1]\\). Therefore, the state should include two variables, the row index and column index, denoted as \\([i, j]\\).</p> <p>State \\([i, j]\\) corresponds to the subproblem: the minimum path sum from the starting point \\([0, 0]\\) to \\([i, j]\\), denoted as \\(dp[i, j]\\).</p> <p>From this, we obtain the two-dimensional \\(dp\\) matrix shown in Figure 14-11, whose size is the same as the input grid \\(grid\\).</p> <p></p> <p> Figure 14-11   State definition and dp table </p> <p>Note</p> <p>The dynamic programming and backtracking processes can be described as a sequence of decisions, and the state consists of all decision variables. It should contain all variables describing the progress of problem-solving, and should contain sufficient information to derive the next state.</p> <p>Each state corresponds to a subproblem, and we define a \\(dp\\) table to store the solutions to all subproblems. Each independent variable of the state is a dimension of the \\(dp\\) table. Essentially, the \\(dp\\) table is a mapping between states and solutions to subproblems.</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>For state \\([i, j]\\), it can only be transferred from the cell above \\([i-1, j]\\) or the cell to the left \\([i, j-1]\\). Therefore, the optimal substructure is: the minimum path sum to reach \\([i, j]\\) is determined by the smaller of the minimum path sums of \\([i, j-1]\\) and \\([i-1, j]\\).</p> <p>Based on the above analysis, the state transition equation shown in Figure 14-12 can be derived:</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> Figure 14-12   Optimal substructure and state transition equation </p> <p>Note</p> <p>Based on the defined \\(dp\\) table, think about the relationship between the original problem and subproblems, and find the method to construct the optimal solution to the original problem from the optimal solutions to the subproblems, which is the optimal substructure.</p> <p>Once we identify the optimal substructure, we can use it to construct the state transition equation.</p> <p>Step 3: Determine boundary conditions and state transition order</p> <p>In this problem, states in the first row can only come from the state to their left, and states in the first column can only come from the state above them. Therefore, the first row \\(i = 0\\) and first column \\(j = 0\\) are boundary conditions.</p> <p>As shown in Figure 14-13, since each cell is transferred from the cell to its left and the cell above it, we use loops to traverse the matrix, with the outer loop traversing rows and the inner loop traversing columns.</p> <p></p> <p> Figure 14-13   Boundary conditions and state transition order </p> <p>Note</p> <p>Boundary conditions in dynamic programming are used to initialize the \\(dp\\) table, and in search are used for pruning.</p> <p>The core of state transition order is to ensure that when computing the solution to the current problem, all the smaller subproblems it depends on have already been computed correctly.</p> <p>Based on the above analysis, we can directly write the dynamic programming code. However, subproblem decomposition is a top-down approach, so implementing in the order \"brute force search \\(\\rightarrow\\) memoization \\(\\rightarrow\\) dynamic programming\" is more aligned with thinking habits.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-method-1-brute-force-search","level":3,"title":"1.   Method 1: Brute Force Search","text":"<p>Starting from state \\([i, j]\\), continuously decompose into smaller states \\([i-1, j]\\) and \\([i, j-1]\\). The recursive function includes the following elements.</p> <ul> <li>Recursive parameters: state \\([i, j]\\).</li> <li>Return value: minimum path sum from \\([0, 0]\\) to \\([i, j]\\), which is \\(dp[i, j]\\).</li> <li>Termination condition: when \\(i = 0\\) and \\(j = 0\\), return cost \\(grid[0, 0]\\).</li> <li>Pruning: when \\(i &lt; 0\\) or \\(j &lt; 0\\), the index is out of bounds, return cost \\(+\\infty\\), representing infeasibility.</li> </ul> <p>The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"Minimum path sum: Brute-force search\"\"\"\n    # If it's the top-left cell, terminate the search\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Brute-force search */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Brute-force search */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // Return the minimum path cost from top-left to (i, j)\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Brute-force search */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // If it's the top-left cell, terminate the search\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Brute-force search */\nfunction minPathSumDFS(grid, i, j) {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Brute-force search */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // If it's the top-left cell, terminate the search\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // If row or column index is out of bounds, return +∞ cost\n  if (i &lt; 0 || j &lt; 0) {\n    // In Dart, int type is fixed-range integer, no value representing \"infinity\"\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // Return the minimum path cost from top-left to (i, j)\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Brute-force search */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Brute-force search */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Return the minimum path cost from top-left to (i, j)\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Brute-force search */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // Return the minimum path cost from top-left to (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: brute force search ###\ndef min_path_sum_dfs(grid, i, j)\n  # If it's the top-left cell, terminate the search\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # If row or column index is out of bounds, return +∞ cost\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # Return the minimum path cost from top-left to (i, j)\n  [left, up].min + grid[i][j]\nend\n</code></pre> <p>Figure 14-14 shows the recursion tree rooted at \\(dp[2, 1]\\), which includes some overlapping subproblems whose number will increase sharply as the size of grid <code>grid</code> grows.</p> <p>Essentially, the reason for overlapping subproblems is: there are multiple paths from the top-left corner to reach a certain cell.</p> <p></p> <p> Figure 14-14   Brute force search recursion tree </p> <p>Each state has two choices, down and right, so the total number of steps from the top-left corner to the bottom-right corner is \\(m + n - 2\\), giving a worst-case time complexity of \\(O(2^{m + n})\\), where \\(n\\) and \\(m\\) are the number of rows and columns of the grid, respectively. Note that this calculation does not account for situations near the grid boundaries, where only one choice remains when reaching the grid boundary, so the actual number of paths will be somewhat less.</p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-method-2-memoization","level":3,"title":"2.   Method 2: Memoization","text":"<p>We introduce a memo list <code>mem</code> of the same size as grid <code>grid</code> to record the solutions to subproblems and prune overlapping subproblems:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"Minimum path sum: Memoization search\"\"\"\n    # If it's the top-left cell, terminate the search\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # If there's a record, return it directly\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # Minimum path cost for left and upper cells\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Memoization search */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Memoization search */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // If there's a record, return it directly\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Memoization search */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // If it's the top-left cell, terminate the search\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // If there's a record, return it directly\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Memoization search */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Memoization search */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // If it's the top-left cell, terminate the search\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // If it's the top-left cell, terminate the search\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // If row or column index is out of bounds, return +∞ cost\n  if (i &lt; 0 || j &lt; 0) {\n    // In Dart, int type is fixed-range integer, no value representing \"infinity\"\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // If there's a record, return it directly\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // Minimum path cost for left and upper cells\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // Record and return the minimum path cost from top-left to (i, j)\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Memoization search */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // If it's the top-left cell, terminate the search\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // If there's a record, return it directly\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // Minimum path cost for left and upper cells\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Memoization search */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Minimum path cost for left and upper cells\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Memoization search */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // If it's the top-left cell, terminate the search\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // If row or column index is out of bounds, return +∞ cost\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // If there's a record, return it directly\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // Minimum path cost for left and upper cells\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // Record and return the minimum path cost from top-left to (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: memoization search ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # If it's the top-left cell, terminate the search\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # If row or column index is out of bounds, return +∞ cost\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # If there's a record, return it directly\n  return mem[i][j] if mem[i][j] != -1\n  # Minimum path cost for left and upper cells\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # Record and return the minimum path cost from top-left to (i, j)\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> <p>As shown in Figure 14-15, after introducing memoization, all subproblem solutions only need to be computed once, so the time complexity depends on the total number of states, which is the grid size \\(O(nm)\\).</p> <p></p> <p> Figure 14-15   Memoization recursion tree </p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-method-3-dynamic-programming","level":3,"title":"3.   Method 3: Dynamic Programming","text":"<p>Implement the dynamic programming solution based on iteration, as shown in the code below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Minimum path sum: Dynamic programming\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Initialize dp table\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # State transition: first row\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # State transition: first column\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # State transition: rest of the rows and columns\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Initialize dp table\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Dynamic programming */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Initialize dp table\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Dynamic programming */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Initialize dp table\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // State transition: first column\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Dynamic programming */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // State transition: first column\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Dynamic programming */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Dynamic programming */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // State transition: first row\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // State transition: first column\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Dynamic programming */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Initialize dp table\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Dynamic programming */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Initialize dp table\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // State transition: first column\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // Free memory\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Dynamic programming */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Initialize dp table\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // State transition: first row\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // State transition: first column\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: dynamic programming ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # Initialize dp table\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # State transition: first row\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # State transition: first column\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # State transition: rest of the rows and columns\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> <p>Figure 14-16 shows the state transition process for minimum path sum, which traverses the entire grid, thus the time complexity is \\(O(nm)\\).</p> <p>The array <code>dp</code> has size \\(n \\times m\\), thus the space complexity is \\(O(nm)\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-16   Dynamic programming process for minimum path sum </p>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4-space-optimization","level":3,"title":"4.   Space Optimization","text":"<p>Since each cell is only related to the cell to its left and the cell above it, we can use a single-row array to implement the \\(dp\\) table.</p> <p>Note that since the array <code>dp</code> can only represent the state of one row, we cannot initialize the first column state in advance, but rather update it when traversing each row:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Minimum path sum: Space-optimized dynamic programming\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Initialize dp table\n    dp = [0] * m\n    # State transition: first row\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # State transition: rest of the rows\n    for i in range(1, n):\n        # State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        # State transition: rest of the columns\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Initialize dp table\n    int[] dp = new int[m];\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Initialize dp table\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // State transition: first row\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Initialize dp table\n    dp := make([]int, m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt; n; i++ {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // State transition: rest of the rows\n    for i in 1 ..&lt; n {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = new Array(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Initialize dp table\n    const dp = new Array(m);\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // State transition: rest of the rows\n  for (int i = 1; i &lt; n; i++) {\n    // State transition: first column\n    dp[0] = dp[0] + grid[i][0];\n    // State transition: rest of the columns\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Initialize dp table\n    let mut dp = vec![0; m];\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for i in 1..n {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Initialize dp table\n    int *dp = calloc(m, sizeof(int));\n    // State transition: first row\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt; n; i++) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0];\n        // State transition: rest of the columns\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Minimum path sum: Space-optimized dynamic programming */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Initialize dp table\n    val dp = IntArray(m)\n    // State transition: first row\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // State transition: rest of the rows\n    for (i in 1..&lt;n) {\n        // State transition: first column\n        dp[0] = dp[0] + grid[i][0]\n        // State transition: rest of the columns\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Minimum path sum: space-optimized DP ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # Initialize dp table\n  dp = Array.new(m, 0)\n  # State transition: first row\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # State transition: rest of the rows\n  for i in 1...n\n    # State transition: first column\n    dp[0] = dp[0] + grid[i][0]\n    # State transition: rest of the columns\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.3 &nbsp; Dynamic Programming Problem-Solving Approach"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   Edit Distance Problem","text":"<p>Edit distance, also known as Levenshtein distance, refers to the minimum number of edits required to transform one string into another, commonly used in information retrieval and natural language processing to measure the similarity between two sequences.</p> <p>Question</p> <p>Given two strings \\(s\\) and \\(t\\), return the minimum number of edits required to transform \\(s\\) into \\(t\\).</p> <p>You can perform three types of edit operations on a string: insert a character, delete a character, or replace a character with any other character.</p> <p>As shown in Figure 14-27, transforming <code>kitten</code> into <code>sitting</code> requires 3 edits, including 2 replacements and 1 insertion; transforming <code>hello</code> into <code>algo</code> requires 3 steps, including 2 replacements and 1 deletion.</p> <p></p> <p> Figure 14-27   Example data for edit distance </p> <p>The edit distance problem can be naturally explained using the decision tree model. Strings correspond to tree nodes, and a round of decision (one edit operation) corresponds to an edge of the tree.</p> <p>As shown in Figure 14-28, without restricting operations, each node can branch into many edges, with each edge corresponding to one operation, meaning there are many possible paths to transform <code>hello</code> into <code>algo</code>.</p> <p>From the perspective of the decision tree, the goal of this problem is to find the shortest path between node <code>hello</code> and node <code>algo</code>.</p> <p></p> <p> Figure 14-28   Representing edit distance problem based on decision tree model </p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1-dynamic-programming-approach","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>Each round of decision involves performing one edit operation on string \\(s\\).</p> <p>We want the problem scale to gradually decrease during the editing process, which allows us to construct subproblems. Let the lengths of strings \\(s\\) and \\(t\\) be \\(n\\) and \\(m\\) respectively. We first consider the tail characters of the two strings, \\(s[n-1]\\) and \\(t[m-1]\\).</p> <ul> <li>If \\(s[n-1]\\) and \\(t[m-1]\\) are the same, we can skip them and directly consider \\(s[n-2]\\) and \\(t[m-2]\\).</li> <li>If \\(s[n-1]\\) and \\(t[m-1]\\) are different, we need to perform one edit on \\(s\\) (insert, delete, or replace) to make the tail characters of the two strings the same, allowing us to skip them and consider a smaller-scale problem.</li> </ul> <p>In other words, each round of decision (edit operation) we make on string \\(s\\) will change the remaining characters to be matched in \\(s\\) and \\(t\\). Therefore, the state is the \\(i\\)-th and \\(j\\)-th characters currently being considered in \\(s\\) and \\(t\\), denoted as \\([i, j]\\).</p> <p>State \\([i, j]\\) corresponds to the subproblem: the minimum number of edits required to change the first \\(i\\) characters of \\(s\\) into the first \\(j\\) characters of \\(t\\).</p> <p>From this, we obtain a two-dimensional \\(dp\\) table of size \\((i+1) \\times (j+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>Consider subproblem \\(dp[i, j]\\), where the tail characters of the corresponding two strings are \\(s[i-1]\\) and \\(t[j-1]\\), which can be divided into the three cases shown in Figure 14-29 based on different edit operations.</p> <ol> <li>Insert \\(t[j-1]\\) after \\(s[i-1]\\), then the remaining subproblem is \\(dp[i, j-1]\\).</li> <li>Delete \\(s[i-1]\\), then the remaining subproblem is \\(dp[i-1, j]\\).</li> <li>Replace \\(s[i-1]\\) with \\(t[j-1]\\), then the remaining subproblem is \\(dp[i-1, j-1]\\).</li> </ol> <p></p> <p> Figure 14-29   State transition for edit distance </p> <p>Based on the above analysis, the optimal substructure can be obtained: the minimum number of edits for \\(dp[i, j]\\) equals the minimum among the minimum edit steps of \\(dp[i, j-1]\\), \\(dp[i-1, j]\\), and \\(dp[i-1, j-1]\\), plus the edit step \\(1\\) for this time. The corresponding state transition equation is:</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>Please note that when \\(s[i-1]\\) and \\(t[j-1]\\) are the same, no edit is required for the current character, in which case the state transition equation is:</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>Step 3: Determine boundary conditions and state transition order</p> <p>When both strings are empty, the number of edit steps is \\(0\\), i.e., \\(dp[0, 0] = 0\\). When \\(s\\) is empty but \\(t\\) is not, the minimum number of edit steps equals the length of \\(t\\), i.e., the first row \\(dp[0, j] = j\\). When \\(s\\) is not empty but \\(t\\) is empty, the minimum number of edit steps equals the length of \\(s\\), i.e., the first column \\(dp[i, 0] = i\\).</p> <p>Observing the state transition equation, the solution \\(dp[i, j]\\) depends on solutions to the left, above, and upper-left, so the entire \\(dp\\) table can be traversed in order through two nested loops.</p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"Edit distance: Dynamic programming\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # State transition: first row and first column\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # State transition: rest of the rows and columns\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Edit distance: Dynamic programming */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* Edit distance: Dynamic programming */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // State transition: first row and first column\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Edit distance: Dynamic programming */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // State transition: first row and first column\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* Edit distance: Dynamic programming */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // State transition: first row and first column\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Edit distance: Dynamic programming */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // State transition: first row and first column\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // If two characters are equal, skip both characters\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Edit distance: Dynamic programming */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // State transition: first row and first column\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* Edit distance: Dynamic programming */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // State transition: first row and first column\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Edit distance: Dynamic programming */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // State transition: first row and first column\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### Edit distance: dynamic programming ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # State transition: first row and first column\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # State transition: rest of the rows and columns\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # If two characters are equal, skip both characters\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> <p>As shown in Figure 14-30, the state transition process for the edit distance problem is very similar to the knapsack problem and can both be viewed as the process of filling a two-dimensional grid.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-30   Dynamic programming process for edit distance </p>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3-space-optimization","level":3,"title":"3.   Space Optimization","text":"<p>Since \\(dp[i, j]\\) is transferred from the solutions above \\(dp[i-1, j]\\), to the left \\(dp[i, j-1]\\), and to the upper-left \\(dp[i-1, j-1]\\), forward traversal will lose the upper-left solution \\(dp[i-1, j-1]\\), and reverse traversal cannot build \\(dp[i, j-1]\\) in advance, so neither traversal order is feasible.</p> <p>For this reason, we can use a variable <code>leftup</code> to temporarily store the upper-left solution \\(dp[i-1, j-1]\\), so we only need to consider the solutions to the left and above. This situation is the same as the unbounded knapsack problem, allowing for forward traversal. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"Edit distance: Space-optimized dynamic programming\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # State transition: first row\n    for j in range(1, m + 1):\n        dp[j] = j\n    # State transition: rest of the rows\n    for i in range(1, n + 1):\n        # State transition: first column\n        leftup = dp[0]  # Temporarily store dp[i-1, j-1]\n        dp[0] += 1\n        # State transition: rest of the columns\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # If two characters are equal, skip both characters\n                dp[j] = leftup\n            else:\n                # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # Update for next round's dp[i-1, j-1]\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // State transition: first row\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for i := 1; i &lt;= n; i++ {\n        // State transition: first column\n        leftUp := dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // If two characters are equal, skip both characters\n                dp[j] = leftUp\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // State transition: first row\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for i in 1 ... n {\n        // State transition: first column\n        var leftup = dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // State transition: first row\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        let leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // State transition: first row\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (let i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        let leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // State transition: first row\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // State transition: rest of the rows\n  for (int i = 1; i &lt;= n; i++) {\n    // State transition: first column\n    int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n    dp[0] = i;\n    // State transition: rest of the columns\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // If two characters are equal, skip both characters\n        dp[j] = leftup;\n      } else {\n        // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // Update for next round's dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // State transition: first row\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // State transition: rest of the rows\n    for i in 1..=n {\n        // State transition: first column\n        let mut leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i as i32;\n        // State transition: rest of the columns\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* Edit distance: Space-optimized dynamic programming */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // State transition: first row\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // State transition: rest of the rows\n    for (int i = 1; i &lt;= n; i++) {\n        // State transition: first column\n        int leftup = dp[0]; // Temporarily store dp[i-1, j-1]\n        dp[0] = i;\n        // State transition: rest of the columns\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup;\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Update for next round's dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Edit distance: Space-optimized dynamic programming */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // State transition: first row\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // State transition: rest of the rows\n    for (i in 1..n) {\n        // State transition: first column\n        var leftup = dp[0] // Temporarily store dp[i-1, j-1]\n        dp[0] = i\n        // State transition: rest of the columns\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // If two characters are equal, skip both characters\n                dp[j] = leftup\n            } else {\n                // Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Update for next round's dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### Edit distance: space-optimized DP ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # State transition: first row\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # State transition: rest of the rows\n  for i in 1...(n + 1)\n    # State transition: first column\n    leftup = dp.first # Temporarily store dp[i-1, j-1]\n    dp[0] += 1\n    # State transition: rest of the columns\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # If two characters are equal, skip both characters\n        dp[j] = leftup\n      else\n        # Minimum edit steps = minimum edit steps of insert, delete, replace + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # Update for next round's dp[i-1, j-1]\n    end\n  end\n  dp[m]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.6 &nbsp; Edit Distance Problem"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   Introduction to Dynamic Programming","text":"<p>Dynamic programming is an important algorithmic paradigm that decomposes a problem into a series of smaller subproblems and avoids redundant computation by storing the solutions to subproblems, thereby significantly improving time efficiency.</p> <p>In this section, we start with a classic example, first presenting its brute force backtracking solution, observing the overlapping subproblems within it, and then gradually deriving a more efficient dynamic programming solution.</p> <p>Climbing stairs</p> <p>Given a staircase with \\(n\\) steps, where you can climb \\(1\\) or \\(2\\) steps at a time, how many different ways are there to reach the top?</p> <p>As shown in Figure 14-1, for a \\(3\\)-step staircase, there are \\(3\\) different ways to reach the top.</p> <p></p> <p> Figure 14-1   Number of ways to reach the 3rd step </p> <p>The goal of this problem is to find the number of ways, we can consider using backtracking to enumerate all possibilities. Specifically, imagine climbing stairs as a multi-round selection process: starting from the ground, choosing to go up \\(1\\) or \\(2\\) steps in each round, incrementing the count by \\(1\\) whenever the top of the stairs is reached, and pruning when exceeding the top. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"Backtracking\"\"\"\n    # When climbing to the n-th stair, add 1 to the solution count\n    if state == n:\n        res[0] += 1\n    # Traverse all choices\n    for choice in choices:\n        # Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n:\n            continue\n        # Attempt: make a choice, update state\n        backtrack(choices, state + choice, n, res)\n        # Backtrack\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Backtracking\"\"\"\n    choices = [1, 2]  # Can choose to climb up 1 or 2 stairs\n    state = 0  # Start climbing from the 0-th stair\n    res = [0]  # Use res[0] to record the solution count\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* Backtracking */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    for (auto &amp;choice : choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // Can choose to climb up 1 or 2 stairs\n    int state = 0;                // Start climbing from the 0-th stair\n    vector&lt;int&gt; res = {0};        // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* Backtracking */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (Integer choice : choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // Can choose to climb up 1 or 2 stairs\n    int state = 0; // Start climbing from the 0-th stair\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* Backtracking */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    foreach (int choice in choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        Backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    int state = 0; // Start climbing from the 0-th stair\n    List&lt;int&gt; res = [0]; // Use res[0] to record the solution count\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* Backtracking */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // Traverse all choices\n    for _, choice := range choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state+choice &gt; n {\n            continue\n        }\n        // Attempt: make choice, update state\n        backtrack(choices, state+choice, n, res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunc climbingStairsBacktrack(n int) int {\n    // Can choose to climb up 1 or 2 stairs\n    choices := []int{1, 2}\n    // Start climbing from the 0-th stair\n    state := 0\n    res := make([]int, 1)\n    // Use res[0] to record the solution count\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* Backtracking */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] += 1\n    }\n    // Traverse all choices\n    for choice in choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n {\n            continue\n        }\n        // Attempt: make choice, update state\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // Can choose to climb up 1 or 2 stairs\n    let state = 0 // Start climbing from the 0-th stair\n    var res: [Int] = []\n    res.append(0) // Use res[0] to record the solution count\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* Backtracking */\nfunction backtrack(choices, state, n, res) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    const state = 0; // Start climbing from the 0-th stair\n    const res = new Map();\n    res.set(0, 0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* Backtracking */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Traverse all choices\n    for (const choice of choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n    const state = 0; // Start climbing from the 0-th stair\n    const res = new Map();\n    res.set(0, 0); // Use res[0] to record the solution count\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* Backtracking */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // When climbing to the n-th stair, add 1 to the solution count\n  if (state == n) {\n    res[0]++;\n  }\n  // Traverse all choices\n  for (int choice in choices) {\n    // Pruning: not allowed to go beyond the n-th stair\n    if (state + choice &gt; n) continue;\n    // Attempt: make choice, update state\n    backtrack(choices, state + choice, n, res);\n    // Backtrack\n  }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // Can choose to climb up 1 or 2 stairs\n  int state = 0; // Start climbing from the 0-th stair\n  List&lt;int&gt; res = [];\n  res.add(0); // Use res[0] to record the solution count\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* Backtracking */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // Traverse all choices\n    for &amp;choice in choices {\n        // Pruning: not allowed to go beyond the n-th stair\n        if state + choice &gt; n {\n            continue;\n        }\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // Can choose to climb up 1 or 2 stairs\n    let state = 0; // Start climbing from the 0-th stair\n    let mut res = Vec::new();\n    res.push(0); // Use res[0] to record the solution count\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* Backtracking */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0]++;\n    // Traverse all choices\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n)\n            continue;\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res, len);\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // Can choose to climb up 1 or 2 stairs\n    int state = 0;           // Start climbing from the 0-th stair\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // Use res[0] to record the solution count\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* Backtracking */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // When climbing to the n-th stair, add 1 to the solution count\n    if (state == n)\n        res[0] = res[0] + 1\n    // Traverse all choices\n    for (choice in choices) {\n        // Pruning: not allowed to go beyond the n-th stair\n        if (state + choice &gt; n) continue\n        // Attempt: make choice, update state\n        backtrack(choices, state + choice, n, res)\n        // Backtrack\n    }\n}\n\n/* Climbing stairs: Backtracking */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // Can choose to climb up 1 or 2 stairs\n    val state = 0 // Start climbing from the 0-th stair\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // Use res[0] to record the solution count\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### Backtracking ###\ndef backtrack(choices, state, n, res)\n  # When climbing to the n-th stair, add 1 to the solution count\n  res[0] += 1 if state == n\n  # Traverse all choices\n  for choice in choices\n    # Pruning: not allowed to go beyond the n-th stair\n    next if state + choice &gt; n\n\n    # Attempt: make choice, update state\n    backtrack(choices, state + choice, n, res)\n  end\n  # Backtrack\nend\n\n### Climbing stairs: backtracking ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # Can choose to climb up 1 or 2 stairs\n  state = 0 # Start climbing from the 0-th stair\n  res = [0] # Use res[0] to record the solution count\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-method-1-brute-force-search","level":2,"title":"14.1.1   Method 1: Brute Force Search","text":"<p>Backtracking algorithms typically do not explicitly decompose problems, but rather treat solving the problem as a series of decision steps, searching for all possible solutions through trial and pruning.</p> <p>We can try to analyze this problem from the perspective of problem decomposition. Let the number of ways to climb to the \\(i\\)-th step be \\(dp[i]\\), then \\(dp[i]\\) is the original problem, and its subproblems include:</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>Since we can only go up \\(1\\) or \\(2\\) steps in each round, when we stand on the \\(i\\)-th step, we could only have been on the \\(i-1\\)-th or \\(i-2\\)-th step in the previous round. In other words, we can only reach the \\(i\\)-th step from the \\(i-1\\)-th or \\(i-2\\)-th step.</p> <p>This leads to an important conclusion: the number of ways to climb to the \\(i-1\\)-th step plus the number of ways to climb to the \\(i-2\\)-th step equals the number of ways to climb to the \\(i\\)-th step. The formula is as follows:</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>This means that in the stair climbing problem, there exists a recurrence relation among the subproblems, the solution to the original problem can be constructed from the solutions to the subproblems. Figure 14-2 illustrates this recurrence relation.</p> <p></p> <p> Figure 14-2   Recurrence relation for the number of ways </p> <p>We can obtain a brute force search solution based on the recurrence formula. Starting from \\(dp[n]\\), recursively decompose a larger problem into the sum of two smaller problems, until reaching the smallest subproblems \\(dp[1]\\) and \\(dp[2]\\) and returning. Among them, the solutions to the smallest subproblems are known, namely \\(dp[1] = 1\\) and \\(dp[2] = 2\\), representing \\(1\\) and \\(2\\) ways to climb to the \\(1\\)st and \\(2\\)nd steps, respectively.</p> <p>Observe the following code, which, like standard backtracking code, belongs to depth-first search but is more concise:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"Search\"\"\"\n    # Known dp[1] and dp[2], return them\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Search\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* Search */\nint DFS(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* Search */\nfunc dfs(i int) int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* Search */\nfunc dfs(i: Int) -&gt; Int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* Search */\nfunction dfs(i) {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* Search */\nfunction dfs(i: number): number {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* Search */\nint dfs(int i) {\n  // Known dp[1] and dp[2], return them\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* Search */\nfn dfs(i: usize) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* Climbing stairs: Search */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* Search */\nint dfs(int i) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Climbing stairs: Search */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* Search */\nfun dfs(i: Int): Int {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* Climbing stairs: Search */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### Search ###\ndef dfs(i)\n  # Known dp[1] and dp[2], return them\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### Climbing stairs: search ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> <p>Figure 14-3 shows the recursion tree formed by brute force search. For the problem \\(dp[n]\\), the depth of its recursion tree is \\(n\\), with a time complexity of \\(O(2^n)\\). Exponential order represents explosive growth; if we input a relatively large \\(n\\), we will fall into a long wait.</p> <p></p> <p> Figure 14-3   Recursion tree for climbing stairs </p> <p>Observing the above figure, the exponential time complexity is caused by \"overlapping subproblems\". For example, \\(dp[9]\\) is decomposed into \\(dp[8]\\) and \\(dp[7]\\), and \\(dp[8]\\) is decomposed into \\(dp[7]\\) and \\(dp[6]\\), both of which contain the subproblem \\(dp[7]\\).</p> <p>And so on, subproblems contain smaller overlapping subproblems, ad infinitum. The vast majority of computational resources are wasted on these overlapping subproblems.</p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-method-2-memoization","level":2,"title":"14.1.2   Method 2: Memoization","text":"<p>To improve algorithm efficiency, we want all overlapping subproblems to be computed only once. For this purpose, we declare an array <code>mem</code> to record the solution to each subproblem and prune overlapping subproblems during the search process.</p> <ol> <li>When computing \\(dp[i]\\) for the first time, we record it in <code>mem[i]</code> for later use.</li> <li>When we need to compute \\(dp[i]\\) again, we can directly retrieve the result from <code>mem[i]</code>, thereby avoiding redundant computation of that subproblem.</li> </ol> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"Memoization search\"\"\"\n    # Known dp[1] and dp[2], return them\n    if i == 1 or i == 2:\n        return i\n    # If record dp[i] exists, return it directly\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # Record dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Memoization search\"\"\"\n    # mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* Memoization search */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* Memoization search */\nint dfs(int i, int[] mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* Memoization search */\nint DFS(int i, int[] mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* Memoization search */\nfunc dfsMem(i int, mem []int) int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* Memoization search */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* Memoization search */\nfunction dfs(i, mem) {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* Memoization search */\nfunction dfs(i: number, mem: number[]): number {\n    // Known dp[1] and dp[2], return them\n    if (i === 1 || i === 2) return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* Memoization search */\nint dfs(int i, List&lt;int&gt; mem) {\n  // Known dp[1] and dp[2], return them\n  if (i == 1 || i == 2) return i;\n  // If record dp[i] exists, return it directly\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // Record dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n  // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* Memoization search */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // If record dp[i] exists, return it directly\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    count\n}\n\n/* Climbing stairs: Memoization search */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* Memoization search */\nint dfs(int i, int *mem) {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2)\n        return i;\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Record dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Climbing stairs: Memoization search */\nint climbingStairsDFSMem(int n) {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* Memoization search */\nfun dfs(i: Int, mem: IntArray): Int {\n    // Known dp[1] and dp[2], return them\n    if (i == 1 || i == 2) return i\n    // If record dp[i] exists, return it directly\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // Record dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Climbing stairs: Memoization search */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### Memoization search ###\ndef dfs(i, mem)\n  # Known dp[1] and dp[2], return them\n  return i if i == 1 || i == 2\n  # If record dp[i] exists, return it directly\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # Record dp[i]\n  mem[i] = count\nend\n\n### Climbing stairs: memoization search ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] records the total number of solutions to climb to the i-th stair, -1 means no record\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> <p>Observe Figure 14-4, after memoization, all overlapping subproblems only need to be computed once, optimizing the time complexity to \\(O(n)\\), which is a tremendous leap.</p> <p></p> <p> Figure 14-4   Recursion tree with memoization </p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-method-3-dynamic-programming","level":2,"title":"14.1.3   Method 3: Dynamic Programming","text":"<p>Memoization is a \"top-down\" method: we start from the original problem (root node), recursively decompose larger subproblems into smaller ones, until reaching the smallest known subproblems (leaf nodes). Afterward, by backtracking, we collect the solutions to the subproblems layer by layer to construct the solution to the original problem.</p> <p>In contrast, dynamic programming is a \"bottom-up\" method: starting from the solutions to the smallest subproblems, iteratively constructing solutions to larger subproblems until obtaining the solution to the original problem.</p> <p>Since dynamic programming does not include a backtracking process, it only requires loop iteration for implementation and does not need recursion. In the following code, we initialize an array <code>dp</code> to store the solutions to subproblems, which serves the same recording function as the array <code>mem</code> in memoization:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # Initialize dp table, used to store solutions to subproblems\n    dp = [0] * (n + 1)\n    # Initial state: preset the solution to the smallest subproblem\n    dp[1], dp[2] = 1, 2\n    # State transition: gradually solve larger subproblems from smaller ones\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    vector&lt;int&gt; dp(n + 1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Climbing stairs: Dynamic programming */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int[] dp = new int[n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Climbing stairs: Dynamic programming */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    dp := make([]int, n+1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Climbing stairs: Dynamic programming */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    var dp = Array(repeating: 0, count: n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Climbing stairs: Dynamic programming */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1).fill(-1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Climbing stairs: Dynamic programming */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // Initialize dp table, used to store solutions to subproblems\n    const dp = new Array(n + 1).fill(-1);\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // Initialize dp table, used to store solutions to subproblems\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Initial state: preset the solution to the smallest subproblem\n  dp[1] = 1;\n  dp[2] = 2;\n  // State transition: gradually solve larger subproblems from smaller ones\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Climbing stairs: Dynamic programming */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // Known dp[1] and dp[2], return them\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // Initialize dp table, used to store solutions to subproblems\n    let mut dp = vec![-1; n + 1];\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Climbing stairs: Dynamic programming */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Initialize dp table, used to store solutions to subproblems\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1;\n    dp[2] = 2;\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Climbing stairs: Dynamic programming */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // Initialize dp table, used to store solutions to subproblems\n    val dp = IntArray(n + 1)\n    // Initial state: preset the solution to the smallest subproblem\n    dp[1] = 1\n    dp[2] = 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Climbing stairs: dynamic programming ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # Initialize dp table, used to store solutions to subproblems\n  dp = Array.new(n + 1, 0)\n  # Initial state: preset the solution to the smallest subproblem\n  dp[1], dp[2] = 1, 2\n  # State transition: gradually solve larger subproblems from smaller ones\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> <p>Figure 14-5 simulates the execution process of the above code.</p> <p></p> <p> Figure 14-5   Dynamic programming process for climbing stairs </p> <p>Like backtracking algorithms, dynamic programming also uses the \"state\" concept to represent specific stages of problem solving, with each state corresponding to a subproblem and its corresponding local optimal solution. For example, the state in the stair climbing problem is defined as the current stair step number \\(i\\).</p> <p>Based on the above content, we can summarize the commonly used terminology in dynamic programming.</p> <ul> <li>The array <code>dp</code> is called the dp table, where \\(dp[i]\\) represents the solution to the subproblem corresponding to state \\(i\\).</li> <li>The states corresponding to the smallest subproblems (the \\(1\\)st and \\(2\\)nd steps) are called initial states.</li> <li>The recurrence formula \\(dp[i] = dp[i-1] + dp[i-2]\\) is called the state transition equation.</li> </ul>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414-space-optimization","level":2,"title":"14.1.4   Space Optimization","text":"<p>Observant readers may have noticed that since \\(dp[i]\\) is only related to \\(dp[i-1]\\) and \\(dp[i-2]\\), we do not need to use an array <code>dp</code> to store the solutions to all subproblems, but can simply use two variables to roll forward. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"Climbing stairs: Space-optimized dynamic programming\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // State transition: gradually solve larger subproblems from smaller ones\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Climbing stairs: Space-optimized dynamic programming */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Climbing stairs: space-optimized DP ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> <p>Observing the above code, since the space occupied by the array <code>dp</code> is saved, the space complexity is reduced from \\(O(n)\\) to \\(O(1)\\).</p> <p>In dynamic programming problems, the current state often depends only on a limited number of preceding states, allowing us to retain only the necessary states and save memory space through \"dimension reduction\". This space optimization technique is called \"rolling variable\" or \"rolling array\".</p>","path":["Chapter 14. Dynamic Programming","14.1 &nbsp; Introduction to Dynamic Programming"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 Knapsack Problem","text":"<p>The knapsack problem is an excellent introductory problem for dynamic programming and is one of the most common problem forms in dynamic programming. It has many variants, such as the 0-1 knapsack problem, the unbounded knapsack problem, and the multiple knapsack problem.</p> <p>In this section, we will first solve the most common 0-1 knapsack problem.</p> <p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can only be selected once. What is the maximum value that can be placed in the knapsack within the capacity limit?</p> <p>Observe Figure 14-17. Since item number \\(i\\) starts counting from \\(1\\) and array indices start from \\(0\\), item \\(i\\) corresponds to weight \\(wgt[i-1]\\) and value \\(val[i-1]\\).</p> <p></p> <p> Figure 14-17   Example data for 0-1 knapsack </p> <p>We can view the 0-1 knapsack problem as a process consisting of \\(n\\) rounds of decisions, where for each item there are two decisions: not putting it in and putting it in, thus the problem satisfies the decision tree model.</p> <p>The goal of this problem is to find \"the maximum value that can be placed in the knapsack within the capacity limit\", so it is more likely to be a dynamic programming problem.</p> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>For each item, if not placed in the knapsack, the knapsack capacity remains unchanged; if placed in, the knapsack capacity decreases. From this, we can derive the state definition: current item number \\(i\\) and knapsack capacity \\(c\\), denoted as \\([i, c]\\).</p> <p>State \\([i, c]\\) corresponds to the subproblem: the maximum value among the first \\(i\\) items in a knapsack of capacity \\(c\\), denoted as \\(dp[i, c]\\).</p> <p>What we need to find is \\(dp[n, cap]\\), so we need a two-dimensional \\(dp\\) table of size \\((n+1) \\times (cap+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>After making the decision for item \\(i\\), what remains is the subproblem of the first \\(i-1\\) items, which can be divided into the following two cases.</p> <ul> <li>Not putting item \\(i\\): The knapsack capacity remains unchanged, and the state changes to \\([i-1, c]\\).</li> <li>Putting item \\(i\\): The knapsack capacity decreases by \\(wgt[i-1]\\), the value increases by \\(val[i-1]\\), and the state changes to \\([i-1, c-wgt[i-1]]\\).</li> </ul> <p>The above analysis reveals the optimal substructure of this problem: the maximum value \\(dp[i, c]\\) equals the larger value between not putting item \\(i\\) and putting item \\(i\\). From this, the state transition equation can be derived:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>Note that if the weight of the current item \\(wgt[i - 1]\\) exceeds the remaining knapsack capacity \\(c\\), then the only option is not to put it in the knapsack.</p> <p>Step 3: Determine boundary conditions and state transition order</p> <p>When there are no items or the knapsack capacity is \\(0\\), the maximum value is \\(0\\), i.e., the first column \\(dp[i, 0]\\) and the first row \\(dp[0, c]\\) are both equal to \\(0\\).</p> <p>The current state \\([i, c]\\) is transferred from the state above \\([i-1, c]\\) and the state in the upper-left \\([i-1, c-wgt[i-1]]\\), so the entire \\(dp\\) table is traversed in order through two nested loops.</p> <p>Based on the above analysis, we will next implement the brute force search, memoization, and dynamic programming solutions in order.</p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-method-1-brute-force-search","level":3,"title":"1.   Method 1: Brute Force Search","text":"<p>The search code includes the following elements.</p> <ul> <li>Recursive parameters: state \\([i, c]\\).</li> <li>Return value: solution to the subproblem \\(dp[i, c]\\).</li> <li>Termination condition: when the item number is out of bounds \\(i = 0\\) or the remaining knapsack capacity is \\(0\\), terminate recursion and return value \\(0\\).</li> <li>Pruning: if the weight of the current item exceeds the remaining knapsack capacity, only the option of not putting it in is available.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 knapsack: Brute-force search\"\"\"\n    # If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 or c == 0:\n        return 0\n    # If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # Calculate the maximum value of not putting in and putting in item i\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Return the larger value of the two options\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Brute-force search */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Brute-force search */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // Return the larger value of the two options\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Brute-force search */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Return the larger value of the two options\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Brute-force search */\nfunction knapsackDFS(wgt, val, i, c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Brute-force search */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // If all items have been selected or knapsack has no remaining capacity, return value 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // If exceeds knapsack capacity, can only choose not to put it in\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // Calculate the maximum value of not putting in and putting in item i\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Return the larger value of the two options\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Brute-force search */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Return the larger value of the two options\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Brute-force search */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Return the larger value of the two options\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Brute-force search */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Return the larger value of the two options\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: brute force search ###\ndef knapsack_dfs(wgt, val, i, c)\n  # If all items have been selected or knapsack has no remaining capacity, return value 0\n  return 0 if i == 0 || c == 0\n  # If exceeds knapsack capacity, can only choose not to put it in\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # Calculate the maximum value of not putting in and putting in item i\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Return the larger value of the two options\n  [no, yes].max\nend\n</code></pre> <p>As shown in Figure 14-18, since each item generates two search branches of not selecting and selecting, the time complexity is \\(O(2^n)\\).</p> <p>Observing the recursion tree, it is easy to see overlapping subproblems, such as \\(dp[1, 10]\\). When there are many items, large knapsack capacity, and especially many items with the same weight, the number of overlapping subproblems will increase significantly.</p> <p></p> <p> Figure 14-18   Brute force search recursion tree for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-method-2-memoization","level":3,"title":"2.   Method 2: Memoization","text":"<p>To ensure that overlapping subproblems are only computed once, we use a memo list <code>mem</code> to record the solutions to subproblems, where <code>mem[i][c]</code> corresponds to \\(dp[i, c]\\).</p> <p>After introducing memoization, the time complexity depends on the number of subproblems, which is \\(O(n \\times cap)\\). The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 knapsack: Memoization search\"\"\"\n    # If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 or c == 0:\n        return 0\n    # If there's a record, return it directly\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # Calculate the maximum value of not putting in and putting in item i\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Memoization search */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Memoization search */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // Return the larger value of the two options\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Memoization search */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Memoization search */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Memoization search */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // If all items have been selected or knapsack has no remaining capacity, return value 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // If there's a record, return it directly\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // If exceeds knapsack capacity, can only choose not to put it in\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // Calculate the maximum value of not putting in and putting in item i\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Record and return the larger value of the two options\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Memoization search */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Memoization search */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Record and return the larger value of the two options\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Memoization search */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // If all items have been selected or knapsack has no remaining capacity, return value 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // If there's a record, return it directly\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // If exceeds knapsack capacity, can only choose not to put it in\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // Calculate the maximum value of not putting in and putting in item i\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Record and return the larger value of the two options\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: memoization search ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # If all items have been selected or knapsack has no remaining capacity, return value 0\n  return 0 if i == 0 || c == 0\n  # If there's a record, return it directly\n  return mem[i][c] if mem[i][c] != -1\n  # If exceeds knapsack capacity, can only choose not to put it in\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # Calculate the maximum value of not putting in and putting in item i\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Record and return the larger value of the two options\n  mem[i][c] = [no, yes].max\nend\n</code></pre> <p>Figure 14-19 shows the search branches pruned in memoization.</p> <p></p> <p> Figure 14-19   Memoization recursion tree for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-method-3-dynamic-programming","level":3,"title":"3.   Method 3: Dynamic Programming","text":"<p>Dynamic programming is essentially the process of filling the \\(dp\\) table during state transitions. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 knapsack: Dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # State transition\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Dynamic programming */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Dynamic programming */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Dynamic programming */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Dynamic programming */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Dynamic programming */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: dynamic programming ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # State transition\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> <p>As shown in Figure 14-20, both time complexity and space complexity are determined by the size of the array <code>dp</code>, which is \\(O(n \\times cap)\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-20   Dynamic programming process for 0-1 knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4-space-optimization","level":3,"title":"4.   Space Optimization","text":"<p>Since each state is only related to the state in the row above it, we can use two arrays rolling forward to reduce the space complexity from \\(O(n^2)\\) to \\(O(n)\\).</p> <p>Further thinking, can we achieve space optimization using just one array? Observing, we can see that each state is transferred from the cell directly above or the cell in the upper-left. If there is only one array, when we start traversing row \\(i\\), that array still stores the state of row \\(i-1\\).</p> <ul> <li>If using forward traversal, then when traversing to \\(dp[i, j]\\), the values in the upper-left \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) may have already been overwritten, thus preventing correct state transition.</li> <li>If using reverse traversal, there will be no overwriting issue, and state transition can proceed correctly.</li> </ul> <p>Figure 14-21 shows the transition process from row \\(i = 1\\) to row \\(i = 2\\) using a single array. Please consider the difference between forward and reverse traversal.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-21   Space-optimized dynamic programming process for 0-1 knapsack </p> <p>In the code implementation, we simply need to delete the first dimension \\(i\\) of the array <code>dp</code> and change the inner loop to reverse traversal:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 knapsack: Space-optimized dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [0] * (cap + 1)\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in reverse order\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([]int, cap+1)\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in reverse order\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // The larger value between not selecting and selecting item i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: cap + 1)\n    // State transition\n    for i in 1 ... n {\n        // Traverse in reverse order\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(cap + 1).fill(0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array(cap + 1).fill(0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    // Traverse in reverse order\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // The larger value between not selecting and selecting item i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![0; cap + 1];\n    // State transition\n    for i in 1..=n {\n        // Traverse in reverse order\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // The larger value between not selecting and selecting item i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int *dp = calloc(cap + 1, sizeof(int));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        // Traverse in reverse order\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 knapsack: Space-optimized dynamic programming */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = IntArray(cap + 1)\n    // State transition\n    for (i in 1..n) {\n        // Traverse in reverse order\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 knapsack: space-optimized DP ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(cap + 1, 0)\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in reverse order\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.4 &nbsp; 0-1 Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   Summary","text":"","path":["Chapter 14. Dynamic Programming","14.7 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Dynamic programming decomposes problems and avoids redundant computation by storing the solutions to subproblems, thereby significantly improving computational efficiency.</li> <li>Without considering time constraints, all dynamic programming problems can be solved using backtracking (brute force search), but the recursion tree contains a large number of overlapping subproblems, resulting in extremely low efficiency. By introducing a memo list, we can store the solutions to all computed subproblems, ensuring that overlapping subproblems are only computed once.</li> <li>Memoization is a top-down recursive solution, while the corresponding dynamic programming is a bottom-up iterative solution, similar to \"filling in a table\". Since the current state only depends on certain local states, we can eliminate one dimension of the \\(dp\\) table to reduce space complexity.</li> <li>Subproblem decomposition is a general algorithmic approach, with different properties in divide and conquer, dynamic programming, and backtracking.</li> <li>Dynamic programming problems have three major characteristics: overlapping subproblems, optimal substructure, and no aftereffects.</li> <li>If the optimal solution to the original problem can be constructed from the optimal solutions to the subproblems, then it has optimal substructure.</li> <li>No aftereffects means that for a given state, its future development is only related to that state and has nothing to do with all past states. Many combinatorial optimization problems do not have no aftereffects and cannot be quickly solved using dynamic programming.</li> </ul> <p>Knapsack problem</p> <ul> <li>The knapsack problem is one of the most typical dynamic programming problems, with variants such as the 0-1 knapsack, unbounded knapsack, and multiple knapsack.</li> <li>The state definition for the 0-1 knapsack is the maximum value among the first \\(i\\) items in a knapsack of capacity \\(c\\). Based on the two decisions of not putting an item in the knapsack and putting it in, the optimal substructure can be identified and the state transition equation constructed. In space optimization, since each state depends on the state directly above and to the upper-left, the list needs to be traversed in reverse order to avoid overwriting the upper-left state.</li> <li>The unbounded knapsack problem has no limit on the selection quantity of each type of item, so the state transition for choosing to put in an item differs from the 0-1 knapsack problem. Since the state depends on the state directly above and directly to the left, space optimization should use forward traversal.</li> <li>The coin change problem is a variant of the unbounded knapsack problem. It changes from seeking the \"maximum\" value to seeking the \"minimum\" number of coins, so \\(\\max()\\) in the state transition equation should be changed to \\(\\min()\\). It changes from seeking \"not exceeding\" the knapsack capacity to seeking \"exactly\" making up the target amount, so \\(amt + 1\\) is used to represent the invalid solution of \"unable to make up the target amount\".</li> <li>Coin change problem II changes from seeking the \"minimum number of coins\" to seeking the \"number of coin combinations\", so the state transition equation correspondingly changes from \\(\\min()\\) to a summation operator.</li> </ul> <p>Edit distance problem</p> <ul> <li>Edit distance (Levenshtein distance) is used to measure the similarity between two strings, defined as the minimum number of edit steps from one string to another, with edit operations including insert, delete, and replace.</li> <li>The state definition for the edit distance problem is the minimum number of edit steps required to change the first \\(i\\) characters of \\(s\\) into the first \\(j\\) characters of \\(t\\). When \\(s[i] \\ne t[j]\\), there are three decisions: insert, delete, replace, each with corresponding remaining subproblems. From this, the optimal substructure can be identified and the state transition equation constructed. When \\(s[i] = t[j]\\), no edit is required for the current character.</li> <li>In edit distance, the state depends on the state directly above, directly to the left, and to the upper-left, so after space optimization, neither forward nor reverse traversal can correctly perform state transitions. For this reason, we use a variable to temporarily store the upper-left state, thus transforming to a situation equivalent to the unbounded knapsack problem, allowing for forward traversal after space optimization.</li> </ul>","path":["Chapter 14. Dynamic Programming","14.7 &nbsp; Summary"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   Unbounded Knapsack Problem","text":"<p>In this section, we first solve another common knapsack problem: the unbounded knapsack, and then explore a special case of it: the coin change problem.</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451-unbounded-knapsack-problem","level":2,"title":"14.5.1   Unbounded Knapsack Problem","text":"<p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can be selected multiple times. What is the maximum value that can be placed in the knapsack within the capacity limit? An example is shown in Figure 14-22.</p> <p></p> <p> Figure 14-22   Example data for unbounded knapsack problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>The unbounded knapsack problem is very similar to the 0-1 knapsack problem, differing only in that there is no limit on the number of times an item can be selected.</p> <ul> <li>In the 0-1 knapsack problem, there is only one of each type of item, so after placing item \\(i\\) in the knapsack, we can only choose from the first \\(i-1\\) items.</li> <li>In the unbounded knapsack problem, the quantity of each type of item is unlimited, so after placing item \\(i\\) in the knapsack, we can still choose from the first \\(i\\) items.</li> </ul> <p>Under the rules of the unbounded knapsack problem, the changes in state \\([i, c]\\) are divided into two cases.</p> <ul> <li>Not putting item \\(i\\): Same as the 0-1 knapsack problem, transfer to \\([i-1, c]\\).</li> <li>Putting item \\(i\\): Different from the 0-1 knapsack problem, transfer to \\([i, c-wgt[i-1]]\\).</li> </ul> <p>Thus, the state transition equation becomes:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>Comparing the code for the two problems, there is one change in state transition from \\(i-1\\) to \\(i\\), with everything else identical:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Unbounded knapsack: Dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # State transition\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Unbounded knapsack: Dynamic programming */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Unbounded knapsack: Dynamic programming */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Unbounded knapsack: Dynamic programming */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Unbounded knapsack: Dynamic programming */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Unbounded knapsack: Dynamic programming */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Unbounded knapsack: dynamic programming ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # State transition\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization","level":3,"title":"3.   Space Optimization","text":"<p>Since the current state is transferred from states on the left and above, after space optimization, each row in the \\(dp\\) table should be traversed in forward order.</p> <p>This traversal order is exactly opposite to the 0-1 knapsack. Please refer to Figure 14-23 to understand the difference between the two.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-23   Space-optimized dynamic programming process for unbounded knapsack problem </p> <p>The code implementation is relatively simple, just delete the first dimension of the array <code>dp</code>:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Unbounded knapsack: Space-optimized dynamic programming\"\"\"\n    n = len(wgt)\n    # Initialize dp table\n    dp = [0] * (cap + 1)\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            else:\n                # The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Initialize dp table\n    int[] dp = new int[cap + 1];\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Initialize dp table\n    dp := make([]int, cap+1)\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: cap + 1)\n    // State transition\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Initialize dp table\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c];\n      } else {\n        // The larger value between not selecting and selecting item i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Initialize dp table\n    let mut dp = vec![0; cap + 1];\n    // State transition\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Initialize dp table\n    int *dp = calloc(cap + 1, sizeof(int));\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c];\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Unbounded knapsack: Space-optimized dynamic programming */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // Initialize dp table\n    val dp = IntArray(cap + 1)\n    // State transition\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // If exceeds knapsack capacity, don't select item i\n                dp[c] = dp[c]\n            } else {\n                // The larger value between not selecting and selecting item i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Unbounded knapsack: space-optimized DP ###\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Initialize dp table\n  dp = Array.new(cap + 1, 0)\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # If exceeds knapsack capacity, don't select item i\n        dp[c] = dp[c]\n      else\n        # The larger value between not selecting and selecting item i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452-coin-change-problem","level":2,"title":"14.5.2   Coin Change Problem","text":"<p>The knapsack problem represents a large class of dynamic programming problems and has many variants, such as the coin change problem.</p> <p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\). Each type of coin can be selected multiple times. What is the minimum number of coins needed to make up the target amount? If it is impossible to make up the target amount, return \\(-1\\). An example is shown in Figure 14-24.</p> <p></p> <p> Figure 14-24   Example data for coin change problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach_1","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>The coin change problem can be viewed as a special case of the unbounded knapsack problem, with the following connections and differences.</p> <ul> <li>The two problems can be converted to each other: \"item\" corresponds to \"coin\", \"item weight\" corresponds to \"coin denomination\", and \"knapsack capacity\" corresponds to \"target amount\".</li> <li>The optimization goals are opposite: the unbounded knapsack problem aims to maximize item value, while the coin change problem aims to minimize the number of coins.</li> <li>The unbounded knapsack problem seeks solutions \"not exceeding\" the knapsack capacity, while the coin change problem seeks solutions that \"exactly\" make up the target amount.</li> </ul> <p>Step 1: Think about the decisions in each round, define the state, and thus obtain the \\(dp\\) table</p> <p>State \\([i, a]\\) corresponds to the subproblem: the minimum number of coins among the first \\(i\\) types of coins that can make up amount \\(a\\), denoted as \\(dp[i, a]\\).</p> <p>The two-dimensional \\(dp\\) table has size \\((n+1) \\times (amt+1)\\).</p> <p>Step 2: Identify the optimal substructure, and then derive the state transition equation</p> <p>This problem differs from the unbounded knapsack problem in the following two aspects regarding the state transition equation.</p> <ul> <li>This problem seeks the minimum value, so the operator \\(\\max()\\) needs to be changed to \\(\\min()\\).</li> <li>The optimization target is the number of coins rather than item value, so when a coin is selected, simply execute \\(+1\\).</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>Step 3: Determine boundary conditions and state transition order</p> <p>When the target amount is \\(0\\), the minimum number of coins needed to make it up is \\(0\\), so all \\(dp[i, 0]\\) in the first column equal \\(0\\).</p> <p>When there are no coins, it is impossible to make up any amount \\(&gt; 0\\), which is an invalid solution. To enable the \\(\\min()\\) function in the state transition equation to identify and filter out invalid solutions, we consider using \\(+ \\infty\\) to represent them, i.e., set all \\(dp[0, a]\\) in the first row to \\(+ \\infty\\).</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation_1","level":3,"title":"2.   Code Implementation","text":"<p>Most programming languages do not provide a \\(+ \\infty\\) variable, and can only use the maximum value of integer type <code>int</code> as a substitute. However, this can lead to large number overflow: the \\(+ 1\\) operation in the state transition equation may cause overflow.</p> <p>For this reason, we use the number \\(amt + 1\\) to represent invalid solutions, because the maximum number of coins needed to make up \\(amt\\) is at most \\(amt\\). Before returning, check whether \\(dp[n, amt]\\) equals \\(amt + 1\\); if so, return \\(-1\\), indicating that the target amount cannot be made up. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Dynamic programming\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Initialize dp table\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # State transition: first row and first column\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # State transition: rest of the rows and columns\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][amt + 1];\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Coin change: Dynamic programming */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, amt + 1];\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // State transition: first row and first column\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // State transition: first row and first column\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // State transition: rest of the rows and columns\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Coin change: Dynamic programming */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Coin change: Dynamic programming */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // State transition: first row and first column\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // State transition: first row and first column\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // State transition: rest of the rows and columns\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // The smaller value between not selecting and selecting coin i\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Coin change: Dynamic programming */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Initialize dp table\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // State transition: first row and first column\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // State transition: rest of the rows and columns\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Coin change: Dynamic programming */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // State transition: first row and first column\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // State transition: rest of the rows and columns\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Coin change: Dynamic programming */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // State transition: first row and first column\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // State transition: rest of the rows and columns\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Coin change: dynamic programming ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # State transition: first row and first column\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # State transition: rest of the rows and columns\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # The smaller value between not selecting and selecting coin i\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> <p>Figure 14-25 shows the dynamic programming process for coin change, which is very similar to the unbounded knapsack problem.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 14-25   Dynamic programming process for coin change problem </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization_1","level":3,"title":"3.   Space Optimization","text":"<p>The space optimization for the coin change problem is handled in the same way as the unbounded knapsack problem:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Space-optimized dynamic programming\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Initialize dp table\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            else:\n                # The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Initialize dp table\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Coin change: Space-optimized dynamic programming */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Coin change: Dynamic programming */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Initialize dp table\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in forward order\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Initialize dp table\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Coin change: Space-optimized dynamic programming */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[a] = dp[a];\n      } else {\n        // The smaller value between not selecting and selecting coin i\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Coin change: Space-optimized dynamic programming */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Initialize dp table\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Coin change: Space-optimized dynamic programming */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Initialize dp table\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Coin change: Space-optimized dynamic programming */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Initialize dp table\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // The smaller value between not selecting and selecting coin i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Coin change: space-optimized DP ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Initialize dp table\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[a] = dp[a]\n      else\n        # The smaller value between not selecting and selecting coin i\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-coin-change-problem-ii","level":2,"title":"14.5.3   Coin Change Problem Ii","text":"<p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\). Each type of coin can be selected multiple times. What is the number of coin combinations that can make up the target amount? An example is shown in Figure 14-26.</p> <p></p> <p> Figure 14-26   Example data for coin change problem II </p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1-dynamic-programming-approach_2","level":3,"title":"1.   Dynamic Programming Approach","text":"<p>Compared to the previous problem, this problem's goal is to find the number of combinations, so the subproblem becomes: the number of combinations among the first \\(i\\) types of coins that can make up amount \\(a\\). The \\(dp\\) table remains a two-dimensional matrix of size \\((n+1) \\times (amt + 1)\\).</p> <p>The number of combinations for the current state equals the sum of the combinations from not selecting the current coin and selecting the current coin. The state transition equation is:</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>When the target amount is \\(0\\), no coins need to be selected to make up the target amount, so all \\(dp[i, 0]\\) in the first column should be initialized to \\(1\\). When there are no coins, it is impossible to make up any amount \\(&gt;0\\), so all \\(dp[0, a]\\) in the first row equal \\(0\\).</p>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2-code-implementation_2","level":3,"title":"2.   Code Implementation","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change II: Dynamic programming\"\"\"\n    n = len(coins)\n    # Initialize dp table\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Initialize first column\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # State transition\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Initialize dp table\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // Initialize dp table\n    int[][] dp = new int[n + 1][amt + 1];\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Coin change II: Dynamic programming */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // Initialize dp table\n    int[,] dp = new int[n + 1, amt + 1];\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Coin change II: Dynamic programming */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // Initialize dp table\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Initialize first column\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // State transition: rest of the rows and columns\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Coin change II: Dynamic programming */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Initialize dp table\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Initialize first column\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Coin change II: Dynamic programming */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Initialize first column\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Coin change II: Dynamic programming */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Initialize first column\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Initialize dp table\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Initialize first column\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Sum of the two options: not selecting and selecting coin i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Coin change II: Dynamic programming */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Initialize dp table\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Initialize first column\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Coin change II: Dynamic programming */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Initialize dp table\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Initialize first column\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // Free memory\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Coin change II: Dynamic programming */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Initialize dp table\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Initialize first column\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Coin change II: dynamic programming ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # Initialize dp table\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Initialize first column\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # State transition\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Sum of the two options: not selecting and selecting coin i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3-space-optimization_2","level":3,"title":"3.   Space Optimization","text":"<p>The space optimization is handled in the same way, just delete the coin dimension:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change II: Space-optimized dynamic programming\"\"\"\n    n = len(coins)\n    # Initialize dp table\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # State transition\n    for i in range(1, n + 1):\n        # Traverse in forward order\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            else:\n                # Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Initialize dp table\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // Initialize dp table\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // Initialize dp table\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // State transition\n    for i := 1; i &lt;= n; i++ {\n        // Traverse in forward order\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Initialize dp table\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // State transition\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Initialize dp table\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // State transition\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Initialize dp table\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // State transition\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // If exceeds target amount, don't select coin i\n        dp[a] = dp[a];\n      } else {\n        // Sum of the two options: not selecting and selecting coin i\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Initialize dp table\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // State transition\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Coin change II: Space-optimized dynamic programming */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Initialize dp table\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // State transition\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a];\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // Free memory\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Coin change II: Space-optimized dynamic programming */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Initialize dp table\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // State transition\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // If exceeds target amount, don't select coin i\n                dp[a] = dp[a]\n            } else {\n                // Sum of the two options: not selecting and selecting coin i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Coin change II: space-optimized DP ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # Initialize dp table\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # State transition\n  for i in 1...(n + 1)\n    # Traverse in forward order\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # If exceeds target amount, don't select coin i\n        dp[a] = dp[a]\n      else\n        # Sum of the two options: not selecting and selecting coin i\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre>","path":["Chapter 14. Dynamic Programming","14.5 &nbsp; Unbounded Knapsack Problem"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"Chapter 9.   Graph","text":"<p>Abstract</p> <p>In the journey of life, we are like nodes, connected by countless invisible edges.</p> <p>Each encounter and parting leaves a unique mark on this vast network graph.</p>","path":["Chapter 9. Graph","Chapter 9. &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>9.1   Graph</li> <li>9.2   Basic Operations on Graphs</li> <li>9.3   Graph Traversal</li> <li>9.4   Summary</li> </ul>","path":["Chapter 9. Graph","Chapter 9. &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   Graph","text":"<p>A graph is a nonlinear data structure consisting of vertices and edges. We can abstractly represent a graph \\(G\\) as a set of vertices \\(V\\) and a set of edges \\(E\\). The following example shows a graph containing 5 vertices and 7 edges.</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>If we view vertices as nodes and edges as references (pointers) connecting the nodes, we can see graphs as a data structure extended from linked lists. As shown in Figure 9-1, compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.</p> <p></p> <p> Figure 9-1   Relationships among linked lists, trees, and graphs </p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#911-common-types-and-terminology-of-graphs","level":2,"title":"9.1.1   Common Types and Terminology of Graphs","text":"<p>Graphs can be divided into undirected graphs and directed graphs based on whether edges have direction, as shown in Figure 9-2.</p> <ul> <li>In undirected graphs, edges represent a \"bidirectional\" connection between two vertices, such as the \"friend relationship\" on WeChat or QQ.</li> <li>In directed graphs, edges have directionality, meaning edges \\(A \\rightarrow B\\) and \\(A \\leftarrow B\\) are independent of each other, such as the \"follow\" and \"be followed\" relationships on Weibo or TikTok.</li> </ul> <p></p> <p> Figure 9-2   Directed and undirected graphs </p> <p>Graphs can be divided into connected graphs and disconnected graphs based on whether all vertices are connected, as shown in Figure 9-3.</p> <ul> <li>For connected graphs, starting from any vertex, all other vertices can be reached.</li> <li>For disconnected graphs, starting from a certain vertex, at least one vertex cannot be reached.</li> </ul> <p></p> <p> Figure 9-3   Connected and disconnected graphs </p> <p>We can also add a \"weight\" variable to edges, resulting in weighted graphs as shown in Figure 9-4. For example, in mobile games like \"Honor of Kings\", the system calculates the \"intimacy\" between players based on their shared game time, and such intimacy networks can be represented using weighted graphs.</p> <p></p> <p> Figure 9-4   Weighted and unweighted graphs </p> <p>Graph data structures include the following commonly used terms.</p> <ul> <li>Adjacency: When two vertices are connected by an edge, these two vertices are said to be \"adjacent\". In Figure 9-4, the adjacent vertices of vertex 1 are vertices 2, 3, and 5.</li> <li>Path: The sequence of edges from vertex A to vertex B is called a \"path\" from A to B. In Figure 9-4, the edge sequence 1-5-2-4 is a path from vertex 1 to vertex 4.</li> <li>Degree: The number of edges a vertex has. For directed graphs, in-degree indicates how many edges point to the vertex, and out-degree indicates how many edges point out from the vertex.</li> </ul>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#912-representation-of-graphs","level":2,"title":"9.1.2   Representation of Graphs","text":"<p>Common representations of graphs include \"adjacency matrices\" and \"adjacency lists\". The following uses undirected graphs as examples.</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#1-adjacency-matrix","level":3,"title":"1.   Adjacency Matrix","text":"<p>Given a graph with \\(n\\) vertices, an adjacency matrix uses an \\(n \\times n\\) matrix to represent the graph, where each row (column) represents a vertex, and matrix elements represent edges, using \\(1\\) or \\(0\\) to indicate whether an edge exists between two vertices.</p> <p>As shown in Figure 9-5, let the adjacency matrix be \\(M\\) and the vertex list be \\(V\\). Then matrix element \\(M[i, j] = 1\\) indicates that an edge exists between vertex \\(V[i]\\) and vertex \\(V[j]\\), whereas \\(M[i, j] = 0\\) indicates no edge between the two vertices.</p> <p></p> <p> Figure 9-5   Adjacency matrix representation of a graph </p> <p>Adjacency matrices have the following properties.</p> <ul> <li>In simple graphs, vertices cannot connect to themselves, so the elements on the main diagonal of the adjacency matrix are meaningless.</li> <li>For undirected graphs, edges in both directions are equivalent, so the adjacency matrix is symmetric about the main diagonal.</li> <li>Replacing the elements of the adjacency matrix from \\(1\\) and \\(0\\) to weights allows representation of weighted graphs.</li> </ul> <p>When using adjacency matrices to represent graphs, we can directly access matrix elements to obtain edges, resulting in highly efficient addition, deletion, lookup, and modification operations, all with a time complexity of \\(O(1)\\). However, the space complexity of the matrix is \\(O(n^2)\\), which consumes significant memory.</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#2-adjacency-list","level":3,"title":"2.   Adjacency List","text":"<p>An adjacency list uses \\(n\\) linked lists to represent a graph, with linked list nodes representing vertices. The \\(i\\)-th linked list corresponds to vertex \\(i\\) and stores all adjacent vertices of that vertex (vertices connected to that vertex). Figure 9-6 shows an example of a graph stored using an adjacency list.</p> <p></p> <p> Figure 9-6   Adjacency list representation of a graph </p> <p>Adjacency lists only store edges that actually exist, and the total number of edges is typically much less than \\(n^2\\), making them more space-efficient. However, finding edges in an adjacency list requires traversing the linked list, so its time efficiency is inferior to that of adjacency matrices.</p> <p>Observing Figure 9-6, the structure of adjacency lists is very similar to \"chaining\" in hash tables, so we can adopt similar methods to optimize efficiency. For example, when linked lists are long, they can be converted to AVL trees or red-black trees, thereby optimizing time efficiency from \\(O(n)\\) to \\(O(\\log n)\\); linked lists can also be converted to hash tables, thereby reducing time complexity to \\(O(1)\\).</p>","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph/#913-common-applications-of-graphs","level":2,"title":"9.1.3   Common Applications of Graphs","text":"<p>As shown in Table 9-1, many real-world systems can be modeled using graphs, and corresponding problems can be reduced to graph computation problems.</p> <p> Table 9-1   Common graphs in real life </p> Vertices Edges Graph Computation Problem Social network Users Friend relationships Potential friend recommendation Subway lines Stations Connectivity between stations Shortest route recommendation Solar system Celestial bodies Gravitational forces between celestial bodies Planetary orbit calculation","path":["Chapter 9. Graph","9.1 &nbsp; Graph"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   Basic Operations on Graphs","text":"<p>Basic operations on graphs can be divided into operations on \"edges\" and operations on \"vertices\". Under the two representation methods of \"adjacency matrix\" and \"adjacency list\", the implementation methods differ.</p>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#921-implementation-based-on-adjacency-matrix","level":2,"title":"9.2.1   Implementation Based on Adjacency Matrix","text":"<p>Given an undirected graph with \\(n\\) vertices, the various operations are implemented as shown in Figure 9-7.</p> <ul> <li>Adding or removing an edge: Directly modify the specified edge in the adjacency matrix, using \\(O(1)\\) time. Since it is an undirected graph, both directions of the edge need to be updated simultaneously.</li> <li>Adding a vertex: Add a row and a column at the end of the adjacency matrix and fill them all with \\(0\\)s, using \\(O(n)\\) time.</li> <li>Removing a vertex: Delete a row and a column in the adjacency matrix. The worst case occurs when removing the first row and column, requiring \\((n-1)^2\\) elements to be \"moved up and to the left\", thus using \\(O(n^2)\\) time.</li> <li>Initialization: Pass in \\(n\\) vertices, initialize a vertex list <code>vertices</code> of length \\(n\\), using \\(O(n)\\) time; initialize an adjacency matrix <code>adjMat</code> of size \\(n \\times n\\), using \\(O(n^2)\\) time.</li> </ul> Initialize adjacency matrixAdd an edgeRemove an edgeAdd a vertexRemove a vertex <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-7   Initialization, adding and removing edges, adding and removing vertices in adjacency matrix </p> <p>The following is the implementation code for graphs represented using an adjacency matrix:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"Undirected graph class based on adjacency matrix\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"Constructor\"\"\"\n        # Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n        self.vertices: list[int] = []\n        # Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n        self.adj_mat: list[list[int]] = []\n        # Add vertices\n        for val in vertices:\n            self.add_vertex(val)\n        # Add edges\n        # Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Get the number of vertices\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"Add vertex\"\"\"\n        n = self.size()\n        # Add the value of the new vertex to the vertex list\n        self.vertices.append(val)\n        # Add a row to the adjacency matrix\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # Add a column to the adjacency matrix\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"Remove vertex\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # Remove the vertex at index from the vertex list\n        self.vertices.pop(index)\n        # Remove the row at index from the adjacency matrix\n        self.adj_mat.pop(index)\n        # Remove the column at index from the adjacency matrix\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"Add edge\"\"\"\n        # Parameters i, j correspond to the vertices element indices\n        # Handle index out of bounds and equality\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"Remove edge\"\"\"\n        # Parameters i, j correspond to the vertices element indices\n        # Handle index out of bounds and equality\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"Print adjacency matrix\"\"\"\n        print(\"Vertex list =\", self.vertices)\n        print(\"Adjacency matrix =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n  public:\n    /* Constructor */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // Add vertex\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* Add vertex */\n    void addVertex(int val) {\n        int n = size();\n        // Add the value of the new vertex to the vertex list\n        vertices.push_back(val);\n        // Add a row to the adjacency matrix\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // Add a column to the adjacency matrix\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* Remove vertex */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        // Remove the vertex at index from the vertex list\n        vertices.erase(vertices.begin() + index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.erase(adjMat.begin() + index);\n        // Remove the column at index from the adjacency matrix\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    void addEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    void removeEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"Vertex does not exist\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    void print() {\n        cout &lt;&lt; \"Vertex list = \";\n        printVector(vertices);\n        cout &lt;&lt; \"Adjacency matrix =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // Add vertex\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* Add vertex */\n    public void addVertex(int val) {\n        int n = size();\n        // Add the value of the new vertex to the vertex list\n        vertices.add(val);\n        // Add a row to the adjacency matrix\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // Add a column to the adjacency matrix\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* Remove vertex */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // Remove the vertex at index from the vertex list\n        vertices.remove(index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.remove(index);\n        // Remove the column at index from the adjacency matrix\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void addEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void removeEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* Print adjacency matrix */\n    public void print() {\n        System.out.print(\"Vertex list = \");\n        System.out.println(vertices);\n        System.out.println(\"Adjacency matrix =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    List&lt;List&lt;int&gt;&gt; adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* Add vertex */\n    public void AddVertex(int val) {\n        int n = Size();\n        // Add the value of the new vertex to the vertex list\n        vertices.Add(val);\n        // Add a row to the adjacency matrix\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // Add a column to the adjacency matrix\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* Remove vertex */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // Remove the vertex at index from the vertex list\n        vertices.RemoveAt(index);\n        // Remove the row at index from the adjacency matrix\n        adjMat.RemoveAt(index);\n        // Remove the column at index from the adjacency matrix\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void AddEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    public void RemoveEdge(int i, int j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    public void Print() {\n        Console.Write(\"Vertex list = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"Adjacency matrix =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* Undirected graph class based on adjacency matrix */\ntype graphAdjMat struct {\n    // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    vertices []int\n    // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    adjMat [][]int\n}\n\n/* Constructor */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // Add vertex\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // Initialize graph\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // Add edge\n    // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* Get the number of vertices */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* Add vertex */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // Add the value of the new vertex to the vertex list\n    g.vertices = append(g.vertices, val)\n    // Add a row to the adjacency matrix\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // Add a column to the adjacency matrix\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* Remove vertex */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // Remove the vertex at index from the vertex list\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // Remove the row at index from the adjacency matrix\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // Remove the column at index from the adjacency matrix\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* Add edge */\n// Parameters i, j correspond to the vertices element indices\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* Remove edge */\n// Parameters i, j correspond to the vertices element indices\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* Print adjacency matrix */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\tVertex list = %v\\n\", g.vertices)\n    fmt.Printf(\"\\tAdjacency matrix = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    private var vertices: [Int] // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    private var adjMat: [[Int]] // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // Add vertex\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* Add vertex */\n    func addVertex(val: Int) {\n        let n = size()\n        // Add the value of the new vertex to the vertex list\n        vertices.append(val)\n        // Add a row to the adjacency matrix\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // Add a column to the adjacency matrix\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* Remove vertex */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"Out of bounds\")\n        }\n        // Remove the vertex at index from the vertex list\n        vertices.remove(at: index)\n        // Remove the row at index from the adjacency matrix\n        adjMat.remove(at: index)\n        // Remove the column at index from the adjacency matrix\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    func addEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Out of bounds\")\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    func removeEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Out of bounds\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Print adjacency matrix */\n    func print() {\n        Swift.print(\"Vertex list = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"Adjacency matrix =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vertices; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    adjMat; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* Add vertex */\n    addVertex(val) {\n        const n = this.size();\n        // Add the value of the new vertex to the vertex list\n        this.vertices.push(val);\n        // Add a row to the adjacency matrix\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Add a column to the adjacency matrix\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Remove the vertex at index from the vertex list\n        this.vertices.splice(index, 1);\n\n        // Remove the row at index from the adjacency matrix\n        this.adjMat.splice(index, 1);\n        // Remove the column at index from the adjacency matrix\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    addEdge(i, j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // In undirected graph, adjacency matrix is symmetric about main diagonal, i.e., satisfies (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    removeEdge(i, j) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    print() {\n        console.log('Vertex list = ', this.vertices);\n        console.log('Adjacency matrix =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n    vertices: number[]; // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    adjMat: number[][]; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Add vertex\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* Add vertex */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // Add the value of the new vertex to the vertex list\n        this.vertices.push(val);\n        // Add a row to the adjacency matrix\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Add a column to the adjacency matrix\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Remove the vertex at index from the vertex list\n        this.vertices.splice(index, 1);\n\n        // Remove the row at index from the adjacency matrix\n        this.adjMat.splice(index, 1);\n        // Remove the column at index from the adjacency matrix\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    addEdge(i: number, j: number): void {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // In undirected graph, adjacency matrix is symmetric about main diagonal, i.e., satisfies (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    removeEdge(i: number, j: number): void {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    print(): void {\n        console.log('Vertex list = ', this.vertices);\n        console.log('Adjacency matrix =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // Vertex elements, elements represent \"vertex values\", indices represent \"vertex indices\"\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n  /* Constructor */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // Add vertex\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // Add edge\n    // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* Get the number of vertices */\n  int size() {\n    return vertices.length;\n  }\n\n  /* Add vertex */\n  void addVertex(int val) {\n    int n = size();\n    // Add the value of the new vertex to the vertex list\n    vertices.add(val);\n    // Add a row to the adjacency matrix\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // Add a column to the adjacency matrix\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* Remove vertex */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // Remove the vertex at index from the vertex list\n    vertices.removeAt(index);\n    // Remove the row at index from the adjacency matrix\n    adjMat.removeAt(index);\n    // Remove the column at index from the adjacency matrix\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* Add edge */\n  // Parameters i, j correspond to the vertices element indices\n  void addEdge(int i, int j) {\n    // Handle index out of bounds and equality\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* Remove edge */\n  // Parameters i, j correspond to the vertices element indices\n  void removeEdge(int i, int j) {\n    // Handle index out of bounds and equality\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* Print adjacency matrix */\n  void printAdjMat() {\n    print(\"Vertex list = $vertices\");\n    print(\"Adjacency matrix = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* Undirected graph type based on adjacency matrix */\npub struct GraphAdjMat {\n    // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    pub vertices: Vec&lt;i32&gt;,\n    // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* Constructor */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // Add vertex\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* Get the number of vertices */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* Add vertex */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // Add the value of the new vertex to the vertex list\n        self.vertices.push(val);\n        // Add a row to the adjacency matrix\n        self.adj_mat.push(vec![0; n]);\n        // Add a column to the adjacency matrix\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* Remove vertex */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // Remove the vertex at index from the vertex list\n        self.vertices.remove(index);\n        // Remove the row at index from the adjacency matrix\n        self.adj_mat.remove(index);\n        // Remove the column at index from the adjacency matrix\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* Add edge */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // Parameters i, j correspond to the vertices element indices\n        // Handle index out of bounds and equality\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // Parameters i, j correspond to the vertices element indices\n        // Handle index out of bounds and equality\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* Print adjacency matrix */\n    pub fn print(&amp;self) {\n        println!(\"Vertex list = {:?}\", self.vertices);\n        println!(\"Adjacency matrix =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* Undirected graph structure based on adjacency matrix */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* Constructor */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* Destructor */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* Add vertex */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"Graph vertex count has reached maximum\\n\");\n        return;\n    }\n    // Add nth vertex and zero nth row and column\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* Remove vertex */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"Vertex index out of bounds\\n\");\n        return;\n    }\n    // Remove the vertex at index from the vertex list\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // Remove the row at index from the adjacency matrix\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // Remove the column at index from the adjacency matrix\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* Add edge */\n// Parameters i, j correspond to the vertices element indices\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"Edge index out of bounds or equal\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* Remove edge */\n// Parameters i, j correspond to the vertices element indices\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"Edge index out of bounds or equal\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* Print adjacency matrix */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"Vertex list = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"Adjacency matrix =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* Undirected graph class based on adjacency matrix */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n\n    /* Constructor */\n    init {\n        // Add vertex\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // Add edge\n        // Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* Add vertex */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // Add the value of the new vertex to the vertex list\n        vertices.add(_val)\n        // Add a row to the adjacency matrix\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // Add a column to the adjacency matrix\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* Remove vertex */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // Remove the vertex at index from the vertex list\n        vertices.removeAt(index)\n        // Remove the row at index from the adjacency matrix\n        adjMat.removeAt(index)\n        // Remove the column at index from the adjacency matrix\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* Add edge */\n    // Parameters i, j correspond to the vertices element indices\n    fun addEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Remove edge */\n    // Parameters i, j correspond to the vertices element indices\n    fun removeEdge(i: Int, j: Int) {\n        // Handle index out of bounds and equality\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Print adjacency matrix */\n    fun print() {\n        print(\"Vertex list = \")\n        println(vertices)\n        println(\"Adjacency matrix =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### Undirected graph class based on adjacency matrix ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### Constructor ###\n    # Vertex list, where the element represents the \"vertex value\" and the index represents the \"vertex index\"\n    @vertices = []\n    # Adjacency matrix, where the row and column indices correspond to the \"vertex index\"\n    @adj_mat = []\n    # Add vertex\n    vertices.each { |val| add_vertex(val) }\n    # Add edge\n    # Note that the edges elements represent vertex indices, i.e., corresponding to the vertices element indices\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### Get number of vertices ###\n  def size\n    @vertices.length\n  end\n\n  ### Add vertex ###\n  def add_vertex(val)\n    n = size\n    # Add the value of the new vertex to the vertex list\n    @vertices &lt;&lt; val\n    # Add a row to the adjacency matrix\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # Add a column to the adjacency matrix\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### Delete vertex ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # Remove the vertex at index from the vertex list\n    @vertices.delete_at(index)\n    # Remove the row at index from the adjacency matrix\n    @adj_mat.delete_at(index)\n    # Remove the column at index from the adjacency matrix\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### Add edge ###\n  def add_edge(i, j)\n    # Parameters i, j correspond to the vertices element indices\n    # Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # In an undirected graph, the adjacency matrix is symmetric about the main diagonal, i.e., (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### Delete edge ###\n  def remove_edge(i, j)\n    # Parameters i, j correspond to the vertices element indices\n    # Handle index out of bounds and equality\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### Print adjacency matrix ###\n  def __print__\n    puts \"Vertex list = #{@vertices}\"\n    puts 'Adjacency matrix ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#922-implementation-based-on-adjacency-list","level":2,"title":"9.2.2   Implementation Based on Adjacency List","text":"<p>Given an undirected graph with a total of \\(n\\) vertices and \\(m\\) edges, the various operations can be implemented as shown in Figure 9-8.</p> <ul> <li>Adding an edge: Add the edge at the end of the corresponding vertex's linked list, using \\(O(1)\\) time. Since it is an undirected graph, edges in both directions need to be added simultaneously.</li> <li>Removing an edge: Find and remove the specified edge in the corresponding vertex's linked list, using \\(O(m)\\) time. In an undirected graph, edges in both directions need to be removed simultaneously.</li> <li>Adding a vertex: Add a linked list in the adjacency list and set the new vertex as the head node of the list, using \\(O(1)\\) time.</li> <li>Removing a vertex: Traverse the entire adjacency list and remove all edges containing the specified vertex, using \\(O(n + m)\\) time.</li> <li>Initialization: Create \\(n\\) vertices and \\(2m\\) edges in the adjacency list, using \\(O(n + m)\\) time.</li> </ul> Initialize adjacency listAdd an edgeRemove an edgeAdd a vertexRemove a vertex <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-8   Initialization, adding and removing edges, adding and removing vertices in adjacency list </p> <p>The following is the adjacency list code implementation. Compared to Figure 9-8, the actual code has the following differences.</p> <ul> <li>For convenience in adding and removing vertices, and to simplify the code, we use lists (dynamic arrays) instead of linked lists.</li> <li>A hash table is used to store the adjacency list, where <code>key</code> is the vertex instance and <code>value</code> is the list (linked list) of adjacent vertices for that vertex.</li> </ul> <p>Additionally, we use the <code>Vertex</code> class to represent vertices in the adjacency list. The reason for this is: if we used list indices to distinguish different vertices as with adjacency matrices, then to delete the vertex at index \\(i\\), we would need to traverse the entire adjacency list and decrement all indices greater than \\(i\\) by \\(1\\), which is very inefficient. However, if each vertex is a unique <code>Vertex</code> instance, deleting a vertex does not require modifying other vertices.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"Undirected graph class based on adjacency list\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"Constructor\"\"\"\n        # Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # Add all vertices and edges\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Get the number of vertices\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Add edge\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Add edge vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Remove edge\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Remove edge vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"Add vertex\"\"\"\n        if vet in self.adj_list:\n            return\n        # Add a new linked list in the adjacency list\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"Remove vertex\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # Remove the linked list corresponding to vertex vet in the adjacency list\n        self.adj_list.pop(vet)\n        # Traverse the linked lists of other vertices and remove all edges containing vet\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"Print adjacency list\"\"\"\n        print(\"Adjacency list =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n  public:\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* Remove specified node from vector */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* Constructor */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // Add all vertices and edges\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int size() {\n        return adjList.size();\n    }\n\n    /* Add edge */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"Vertex does not exist\");\n        // Add edge vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* Remove edge */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"Vertex does not exist\");\n        // Remove edge vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* Add vertex */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* Remove vertex */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"Vertex does not exist\");\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.erase(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* Print adjacency list */\n    void print() {\n        cout &lt;&lt; \"Adjacency list =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Constructor */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // Add all vertices and edges\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* Add edge */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Add edge vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* Remove edge */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Remove edge vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* Add vertex */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* Remove vertex */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.remove(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* Print adjacency list */\n    public void print() {\n        System.out.println(\"Adjacency list =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Constructor */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // Add all vertices and edges\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* Add edge */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Add edge vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* Remove edge */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Remove edge vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* Add vertex */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // Add a new linked list in the adjacency list\n        adjList.Add(vet, []);\n    }\n\n    /* Remove vertex */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.Remove(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* Print adjacency list */\n    public void Print() {\n        Console.WriteLine(\"Adjacency list =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* Undirected graph class based on adjacency list */\ntype graphAdjList struct {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList map[Vertex][]Vertex\n}\n\n/* Constructor */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // Add all vertices and edges\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* Get the number of vertices */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* Add edge */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Add edge vet1 - vet2, add anonymous struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* Remove edge */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Remove edge vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* Add vertex */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // Add a new linked list in the adjacency list\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* Remove vertex */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    delete(g.adjList, vet)\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* Print adjacency list */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"Adjacency list = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* Constructor */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // Add all vertices and edges\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* Get the number of vertices */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* Add edge */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Invalid parameter\")\n        }\n        // Add edge vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* Remove edge */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Invalid parameter\")\n        }\n        // Remove edge vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* Add vertex */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // Add a new linked list in the adjacency list\n        adjList[vet] = []\n    }\n\n    /* Remove vertex */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"Invalid parameter\")\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.removeValue(forKey: vet)\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* Print adjacency list */\n    public func print() {\n        Swift.print(\"Adjacency list =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList;\n\n    /* Constructor */\n    constructor(edges) {\n        this.adjList = new Map();\n        // Add all vertices and edges\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* Add edge */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Add edge vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Remove edge */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove edge vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Add vertex */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // Add a new linked list in the adjacency list\n        this.adjList.set(vet, []);\n    }\n\n    /* Remove vertex */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        this.adjList.delete(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Print adjacency list */\n    print() {\n        console.log('Adjacency list =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* Constructor */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // Add all vertices and edges\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Get the number of vertices */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* Add edge */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Add edge vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Remove edge */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove edge vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Add vertex */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // Add a new linked list in the adjacency list\n        this.adjList.set(vet, []);\n    }\n\n    /* Remove vertex */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        this.adjList.delete(vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Print adjacency list */\n    print(): void {\n        console.log('Adjacency list =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList {\n  // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* Constructor */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* Get the number of vertices */\n  int size() {\n    return adjList.length;\n  }\n\n  /* Add edge */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Add edge vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* Remove edge */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Remove edge vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* Add vertex */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // Add a new linked list in the adjacency list\n    adjList[vet] = [];\n  }\n\n  /* Remove vertex */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    adjList.remove(vet);\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* Print adjacency list */\n  void printAdjList() {\n    print(\"Adjacency list =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* Undirected graph type based on adjacency list */\npub struct GraphAdjList {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* Constructor */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // Add all vertices and edges\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* Get the number of vertices */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* Add edge */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Add edge vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* Remove edge */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Remove edge vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* Add vertex */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // Add a new linked list in the adjacency list\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* Remove vertex */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        self.adj_list.remove(&amp;vet);\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* Print adjacency list */\n    pub fn print(&amp;self) {\n        println!(\"Adjacency list =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* Node structure */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // Vertex\n    struct AdjListNode *next; // Successor node\n} AdjListNode;\n\n/* Find node corresponding to vertex */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Add edge helper function */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // Head insertion\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* Remove edge helper function */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // Search for node corresponding to vet in list\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // Remove node corresponding to vet from list\n    pre-&gt;next = cur-&gt;next;\n    // Free memory\n    free(cur);\n}\n\n/* Undirected graph class based on adjacency list */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // Node array\n    int size;                     // Node count\n} GraphAdjList;\n\n/* Constructor */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* Destructor */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* Find node corresponding to vertex */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Add edge */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // Add edge vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* Remove edge */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // Remove edge vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* Add vertex */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // Add a new linked list in the adjacency list\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* Remove vertex */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // Remove the linked list corresponding to vertex vet in the adjacency list\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // Traverse the linked lists of other vertices and remove all edges containing vet\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // Move vertices after this vertex forward to fill gap\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* Undirected graph class based on adjacency list */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* Constructor */\n    init {\n        // Add all vertices and edges\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* Get the number of vertices */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* Add edge */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Add edge vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* Remove edge */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Remove edge vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* Add vertex */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // Add a new linked list in the adjacency list\n        adjList[vet] = mutableListOf()\n    }\n\n    /* Remove vertex */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // Remove the linked list corresponding to vertex vet in the adjacency list\n        adjList.remove(vet)\n        // Traverse the linked lists of other vertices and remove all edges containing vet\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* Print adjacency list */\n    fun print() {\n        println(\"Adjacency list =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### Undirected graph class based on adjacency list ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### Constructor ###\n  def initialize(edges)\n    # Adjacency list, key: vertex, value: all adjacent vertices of that vertex\n    @adj_list = {}\n    # Add all vertices and edges\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### Get number of vertices ###\n  def size\n    @adj_list.length\n  end\n\n  ### Add edge ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### Delete edge ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # Remove edge vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### Add vertex ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # Add a new linked list in the adjacency list\n    @adj_list[vet] = []\n  end\n\n  ### Delete vertex ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # Remove the linked list corresponding to vertex vet in the adjacency list\n    @adj_list.delete(vet)\n    # Traverse the linked lists of other vertices and remove all edges containing vet\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### Print adjacency list ###\n  def __print__\n    puts 'Adjacency list ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_operations/#923-efficiency-comparison","level":2,"title":"9.2.3   Efficiency Comparison","text":"<p>Assuming the graph has \\(n\\) vertices and \\(m\\) edges, Table 9-2 compares the time efficiency and space efficiency of adjacency matrices and adjacency lists. Note that the adjacency list (linked list) corresponds to the implementation in this text, while the adjacency list (hash table) refers specifically to the implementation where all linked lists are replaced with hash tables.</p> <p> Table 9-2   Comparison of adjacency matrix and adjacency list </p> Adjacency matrix Adjacency list (linked list) Adjacency list (hash table) Determine adjacency \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Add an edge \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Remove an edge \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Add a vertex \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) Remove a vertex \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) Memory space usage \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>Observing Table 9-2, it appears that the adjacency list (hash table) has the best time efficiency and space efficiency. However, in practice, operating on edges in the adjacency matrix is more efficient, requiring only a single array access or assignment operation. Overall, adjacency matrices embody the principle of \"trading space for time\", while adjacency lists embody \"trading time for space\".</p>","path":["Chapter 9. Graph","9.2 &nbsp; Basic Operations on Graphs"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   Graph Traversal","text":"<p>Trees represent \"one-to-many\" relationships, while graphs have a higher degree of freedom and can represent any \"many-to-many\" relationships. Therefore, we can view trees as a special case of graphs. Clearly, tree traversal operations are also a special case of graph traversal operations.</p> <p>Both graphs and trees require the application of search algorithms to implement traversal operations. Graph traversal methods can also be divided into two types: breadth-first traversal and depth-first traversal.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931-breadth-first-search","level":2,"title":"9.3.1   Breadth-First Search","text":"<p>Breadth-first search is a near-to-far traversal method that, starting from a certain node, always prioritizes visiting the nearest vertices and expands outward layer by layer. As shown in Figure 9-9, starting from the top-left vertex, first traverse all adjacent vertices of that vertex, then traverse all adjacent vertices of the next vertex, and so on, until all vertices have been visited.</p> <p></p> <p> Figure 9-9   Breadth-first search of a graph </p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation","level":3,"title":"1.   Algorithm Implementation","text":"<p>BFS is typically implemented with the help of a queue, as shown in the code below. The queue has a \"first in, first out\" property, which aligns with the BFS idea of \"near to far\".</p> <ol> <li>Add the starting vertex <code>startVet</code> to the queue and begin the loop.</li> <li>In each iteration of the loop, pop the vertex at the front of the queue and record it as visited, then add all adjacent vertices of that vertex to the back of the queue.</li> <li>Repeat step <code>2.</code> until all vertices have been visited.</li> </ol> <p>To prevent revisiting vertices, we use a hash set <code>visited</code> to record which nodes have been visited.</p> <p>Tip</p> <p>A hash set can be viewed as a hash table that stores only <code>key</code> without storing <code>value</code>. It can perform addition, deletion, lookup, and modification operations on <code>key</code> in \\(O(1)\\) time complexity. Based on the uniqueness of <code>key</code>, hash sets are typically used for data deduplication and similar scenarios.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Breadth-first traversal\"\"\"\n    # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n    # Vertex traversal sequence\n    res = []\n    # Hash set for recording vertices that have been visited\n    visited = set[Vertex]([start_vet])\n    # Queue used to implement BFS\n    que = deque[Vertex]([start_vet])\n    # Starting from vertex vet, loop until all vertices are visited\n    while len(que) &gt; 0:\n        vet = que.popleft()  # Dequeue the front vertex\n        res.append(vet)  # Record visited vertex\n        # Traverse all adjacent vertices of this vertex\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # Skip vertices that have been visited\n            que.append(adj_vet)  # Only enqueue unvisited vertices\n            visited.add(adj_vet)  # Mark this vertex as visited\n    # Return vertex traversal sequence\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Vertex traversal sequence\n    vector&lt;Vertex *&gt; res;\n    // Hash set for recording vertices that have been visited\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // Queue used to implement BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // Dequeue the front vertex\n        res.push_back(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // Skip vertices that have been visited\n            que.push(adjVet);        // Only enqueue unvisited vertices\n            visited.emplace(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Hash set for recording vertices that have been visited\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // Dequeue the front vertex\n        res.add(vet);            // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // Skip vertices that have been visited\n            que.offer(adjVet);   // Only enqueue unvisited vertices\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = [];\n    // Hash set for recording vertices that have been visited\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // Queue used to implement BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // Dequeue the front vertex\n        res.Add(vet);               // Record visited vertex\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // Skip vertices that have been visited\n            }\n            que.Enqueue(adjVet);   // Only enqueue unvisited vertices\n            visited.Add(adjVet);   // Mark this vertex as visited\n        }\n    }\n\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Vertex traversal sequence\n    res := make([]Vertex, 0)\n    // Hash set for recording vertices that have been visited\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // Queue used to implement BFS, using slice to simulate queue\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // Starting from vertex vet, loop until all vertices are visited\n    for len(queue) &gt; 0 {\n        // Dequeue the front vertex\n        vet := queue[0]\n        queue = queue[1:]\n        // Record visited vertex\n        res = append(res, vet)\n        // Traverse all adjacent vertices of this vertex\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // Only enqueue unvisited vertices\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Vertex traversal sequence\n    var res: [Vertex] = []\n    // Hash set for recording vertices that have been visited\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // Queue used to implement BFS\n    var que: [Vertex] = [startVet]\n    // Starting from vertex vet, loop until all vertices are visited\n    while !que.isEmpty {\n        let vet = que.removeFirst() // Dequeue the front vertex\n        res.append(vet) // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // Skip vertices that have been visited\n            }\n            que.append(adjVet) // Only enqueue unvisited vertices\n            visited.insert(adjVet) // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphBFS(graph, startVet) {\n    // Vertex traversal sequence\n    const res = [];\n    // Hash set for recording vertices that have been visited\n    const visited = new Set();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    const que = [startVet];\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.length) {\n        const vet = que.shift(); // Dequeue the front vertex\n        res.push(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Skip vertices that have been visited\n            }\n            que.push(adjVet); // Only enqueue unvisited vertices\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Vertex traversal sequence\n    const res: Vertex[] = [];\n    // Hash set for recording vertices that have been visited\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // Queue used to implement BFS\n    const que = [startVet];\n    // Starting from vertex vet, loop until all vertices are visited\n    while (que.length) {\n        const vet = que.shift(); // Dequeue the front vertex\n        res.push(vet); // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Skip vertices that have been visited\n            }\n            que.push(adjVet); // Only enqueue unvisited\n            visited.add(adjVet); // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* Breadth-first traversal */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  // Vertex traversal sequence\n  List&lt;Vertex&gt; res = [];\n  // Hash set for recording vertices that have been visited\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // Queue used to implement BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // Starting from vertex vet, loop until all vertices are visited\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // Dequeue the front vertex\n    res.add(vet); // Record visited vertex\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // Skip vertices that have been visited\n      }\n      que.add(adjVet); // Only enqueue unvisited vertices\n      visited.add(adjVet); // Mark this vertex as visited\n    }\n  }\n  // Return vertex traversal sequence\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Vertex traversal sequence\n    let mut res = vec![];\n    // Hash set for recording vertices that have been visited\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // Queue used to implement BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // Starting from vertex vet, loop until all vertices are visited\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // Record visited vertex\n\n        // Traverse all adjacent vertices of this vertex\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // Skip vertices that have been visited\n                }\n                que.push_back(adj_vet); // Only enqueue unvisited vertices\n                visited.insert(adj_vet); // Mark this vertex as visited\n            }\n        }\n    }\n    // Return vertex traversal sequence\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* Node queue structure */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* Constructor */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* Check if the queue is empty */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* Enqueue operation */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* Dequeue operation */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* Check if vertex has been visited */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // Traverse to find node using O(n) time\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // Queue used to implement BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // Dequeue the front vertex\n        res[(*resSize)++] = vet;      // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // Skip vertices that have been visited\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // Only enqueue unvisited vertices\n                visited[(*visitedSize)++] = node-&gt;vertex; // Mark this vertex as visited\n            }\n            node = node-&gt;next;\n        }\n    }\n    // Free memory\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* Breadth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // Vertex traversal sequence\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Hash set for recording vertices that have been visited\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // Queue used to implement BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // Starting from vertex vet, loop until all vertices are visited\n    while (!que.isEmpty()) {\n        val vet = que.poll() // Dequeue the front vertex\n        res.add(vet)         // Record visited vertex\n        // Traverse all adjacent vertices of this vertex\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // Skip vertices that have been visited\n            que.offer(adjVet)   // Only enqueue unvisited vertices\n            visited.add(adjVet) // Mark this vertex as visited\n        }\n    }\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### Breadth-first traversal ###\ndef graph_bfs(graph, start_vet)\n  # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  # Vertex traversal sequence\n  res = []\n  # Hash set for recording vertices that have been visited\n  visited = Set.new([start_vet])\n  # Queue used to implement BFS\n  que = [start_vet]\n  # Starting from vertex vet, loop until all vertices are visited\n  while que.length &gt; 0\n    vet = que.shift # Dequeue the front vertex\n    res &lt;&lt; vet # Record visited vertex\n    # Traverse all adjacent vertices of this vertex\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # Skip vertices that have been visited\n      que &lt;&lt; adj_vet # Only enqueue unvisited vertices\n      visited.add(adj_vet) # Mark this vertex as visited\n    end\n  end\n  # Return vertex traversal sequence\n  res\nend\n</code></pre> <p>The code is relatively abstract; it is recommended to refer to Figure 9-10 to deepen understanding.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-10   Steps of breadth-first search of a graph </p> <p>Is the breadth-first traversal sequence unique?</p> <p>Not unique. Breadth-first search only requires traversing in a \"near to far\" order, and the traversal order of vertices at the same distance can be arbitrarily shuffled. Taking Figure 9-10 as an example, the visit order of vertices \\(1\\) and \\(3\\) can be swapped, as can the visit order of vertices \\(2\\), \\(4\\), and \\(6\\).</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis","level":3,"title":"2.   Complexity Analysis","text":"<p>Time complexity: All vertices will be enqueued and dequeued once, using \\(O(|V|)\\) time; in the process of traversing adjacent vertices, since it is an undirected graph, all edges will be visited \\(2\\) times, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.</p> <p>Space complexity: The list <code>res</code>, hash set <code>visited</code>, and queue <code>que</code> can contain at most \\(|V|\\) vertices, using \\(O(|V|)\\) space.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932-depth-first-search","level":2,"title":"9.3.2   Depth-First Search","text":"<p>Depth-first search is a traversal method that prioritizes going as far as possible, then backtracks when no path remains. As shown in Figure 9-11, starting from the top-left vertex, visit an adjacent vertex of the current vertex, continuing until reaching a dead end, then return and continue going as far as possible before returning again, and so on, until all vertices have been traversed.</p> <p></p> <p> Figure 9-11   Depth-first search of a graph </p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation_1","level":3,"title":"1.   Algorithm Implementation","text":"<p>This \"go as far as possible then return\" algorithm paradigm is typically implemented using recursion. Similar to breadth-first search, in depth-first search we also need a hash set <code>visited</code> to record visited vertices and avoid revisiting.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"Depth-first traversal helper function\"\"\"\n    res.append(vet)  # Record visited vertex\n    visited.add(vet)  # Mark this vertex as visited\n    # Traverse all adjacent vertices of this vertex\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # Skip vertices that have been visited\n        # Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Depth-first traversal\"\"\"\n    # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n    # Vertex traversal sequence\n    res = []\n    # Hash set for recording vertices that have been visited\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // Record visited vertex\n    visited.emplace(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Vertex traversal sequence\n    vector&lt;Vertex *&gt; res;\n    // Hash set for recording vertices that have been visited\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Hash set for recording vertices that have been visited\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* Depth-first traversal helper function */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // Record visited vertex\n    visited.Add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // Vertex traversal sequence\n    List&lt;Vertex&gt; res = [];\n    // Hash set for recording vertices that have been visited\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* Depth-first traversal helper function */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append operation returns a new reference, must reassign original reference to new slice's reference\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // Traverse all adjacent vertices of this vertex\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // Recursively visit adjacent vertices\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Vertex traversal sequence\n    res := make([]Vertex, 0)\n    // Hash set for recording vertices that have been visited\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // Return vertex traversal sequence\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* Depth-first traversal helper function */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // Record visited vertex\n    visited.insert(vet) // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Vertex traversal sequence\n    var res: [Vertex] = []\n    // Hash set for recording vertices that have been visited\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphDFS(graph, startVet) {\n    // Vertex traversal sequence\n    const res = [];\n    // Hash set for recording vertices that have been visited\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* Depth-first traversal helper function */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // Record visited vertex\n    visited.add(vet); // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Skip vertices that have been visited\n        }\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Vertex traversal sequence\n    const res: Vertex[] = [];\n    // Hash set for recording vertices that have been visited\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* Depth-first traversal helper function */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // Record visited vertex\n  visited.add(vet); // Mark this vertex as visited\n  // Traverse all adjacent vertices of this vertex\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // Skip vertices that have been visited\n    }\n    // Recursively visit adjacent vertices\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* Depth-first traversal */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // Vertex traversal sequence\n  List&lt;Vertex&gt; res = [];\n  // Hash set for recording vertices that have been visited\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* Depth-first traversal helper function */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // Record visited vertex\n    visited.insert(vet); // Mark this vertex as visited\n                         // Traverse all adjacent vertices of this vertex\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // Skip vertices that have been visited\n            }\n            // Recursively visit adjacent vertices\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Vertex traversal sequence\n    let mut res = vec![];\n    // Hash set for recording vertices that have been visited\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* Check if vertex has been visited */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // Traverse to find node using O(n) time\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* Depth-first traversal helper function */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // Record visited vertex\n    res[(*resSize)++] = vet;\n    // Traverse all adjacent vertices of this vertex\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // Skip vertices that have been visited\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // Recursively visit adjacent vertices\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* Depth-first traversal helper function */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // Record visited vertex\n    visited.add(vet) // Mark this vertex as visited\n    // Traverse all adjacent vertices of this vertex\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // Skip vertices that have been visited\n        // Recursively visit adjacent vertices\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* Depth-first traversal */\n// Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // Vertex traversal sequence\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Hash set for recording vertices that have been visited\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### Depth-first traversal helper function ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # Record visited vertex\n  visited.add(vet) # Mark this vertex as visited\n  # Traverse all adjacent vertices of this vertex\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # Skip vertices that have been visited\n    # Recursively visit adjacent vertices\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### Depth-first traversal ###\ndef graph_dfs(graph, start_vet)\n  # Use adjacency list to represent the graph, in order to obtain all adjacent vertices of a specified vertex\n  # Vertex traversal sequence\n  res = []\n  # Hash set for recording vertices that have been visited\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> <p>The algorithm flow of depth-first search is shown in Figure 9-12.</p> <ul> <li>Straight dashed lines represent downward recursion, indicating that a new recursive method has been initiated to visit a new vertex.</li> <li>Curved dashed lines represent upward backtracking, indicating that this recursive method has returned to the position where it was initiated.</li> </ul> <p>To deepen understanding, it is recommended to combine Figure 9-12 with the code to mentally simulate (or draw out) the entire DFS process, including when each recursive method is initiated and when it returns.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 9-12   Steps of depth-first search of a graph </p> <p>Is the depth-first traversal sequence unique?</p> <p>Similar to breadth-first search, the order of depth-first traversal sequences is also not unique. Given a certain vertex, exploring in any direction first is valid, meaning the order of adjacent vertices can be arbitrarily shuffled, all being depth-first search.</p> <p>Taking tree traversal as an example, \"root \\(\\rightarrow\\) left \\(\\rightarrow\\) right\", \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\", and \"left \\(\\rightarrow\\) right \\(\\rightarrow\\) root\" correspond to pre-order, in-order, and post-order traversals, respectively. They represent three different traversal priorities, yet all three belong to depth-first search.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis_1","level":3,"title":"2.   Complexity Analysis","text":"<p>Time complexity: All vertices will be visited \\(1\\) time, using \\(O(|V|)\\) time; all edges will be visited \\(2\\) times, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.</p> <p>Space complexity: The list <code>res</code> and hash set <code>visited</code> can contain at most \\(|V|\\) vertices, and the maximum recursion depth is \\(|V|\\), therefore using \\(O(|V|)\\) space.</p>","path":["Chapter 9. Graph","9.3 &nbsp; Graph Traversal"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   Summary","text":"","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_graph/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Graphs consist of vertices and edges and can be represented as a set of vertices and a set of edges.</li> <li>Compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.</li> <li>Directed graphs have edges with directionality, connected graphs have all vertices reachable from any vertex, and weighted graphs have edges that each contain a weight variable.</li> <li>Adjacency matrices use matrices to represent graphs, where each row (column) represents a vertex, and matrix elements represent edges, using \\(1\\) or \\(0\\) to indicate whether two vertices have an edge or not. Adjacency matrices are highly efficient for addition, deletion, lookup, and modification operations, but consume significant space.</li> <li>Adjacency lists use multiple linked lists to represent graphs, where the \\(i\\)-th linked list corresponds to vertex \\(i\\) and stores all adjacent vertices of that vertex. Adjacency lists are more space-efficient than adjacency matrices, but have lower time efficiency because they require traversing linked lists to find edges.</li> <li>When linked lists in adjacency lists become too long, they can be converted to red-black trees or hash tables, thereby improving lookup efficiency.</li> <li>From an algorithmic perspective, adjacency matrices embody \"trading space for time\", while adjacency lists embody \"trading time for space\".</li> <li>Graphs can be used to model various real-world systems, such as social networks and subway lines.</li> <li>Trees are a special case of graphs, and tree traversal is a special case of graph traversal.</li> <li>Breadth-first search of graphs is a near-to-far, layer-by-layer expansion search method, typically implemented using a queue.</li> <li>Depth-first search of graphs is a search method that prioritizes going as far as possible and backtracks when no path remains, commonly implemented using recursion.</li> </ul>","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is a path defined as a sequence of vertices or a sequence of edges?</p> <p>The definitions in different language versions of Wikipedia are inconsistent: the English version states \"a path is a sequence of edges\", while the Chinese version states \"a path is a sequence of vertices\". The following is the original English text: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>In this text, a path is viewed as a sequence of edges, not a sequence of vertices. This is because there may be multiple edges connecting two vertices, in which case each edge corresponds to a path.</p> <p>Q: In a disconnected graph, will there be unreachable vertices?</p> <p>In a disconnected graph, starting from a certain vertex, at least one vertex cannot be reached. Traversing a disconnected graph requires setting multiple starting points to traverse all connected components of the graph.</p> <p>Q: In an adjacency list, is there a requirement for the order of \"all vertices connected to that vertex\"?</p> <p>It can be in any order. However, in practical applications, it may be necessary to sort according to specified rules, such as the order in which vertices were added, or the order of vertex values, which helps quickly find vertices \"with certain extreme values\".</p>","path":["Chapter 9. Graph","9.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"Chapter 15.   Greedy","text":"<p>Abstract</p> <p>Sunflowers turn toward the sun, constantly pursuing the maximum potential for their own growth.</p> <p>Through rounds of simple choices, greedy strategies gradually lead to the best answer.</p>","path":["Chapter 15. Greedy","Chapter 15. &nbsp; Greedy"],"tags":[]},{"location":"chapter_greedy/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>15.1   Greedy Algorithm</li> <li>15.2   Fractional Knapsack Problem</li> <li>15.3   Maximum Capacity Problem</li> <li>15.4   Maximum Product Cutting Problem</li> <li>15.5   Summary</li> </ul>","path":["Chapter 15. Greedy","Chapter 15. &nbsp; Greedy"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   Fractional Knapsack Problem","text":"<p>Question</p> <p>Given \\(n\\) items, where the weight of the \\(i\\)-th item is \\(wgt[i-1]\\) and its value is \\(val[i-1]\\), and a knapsack with capacity \\(cap\\). Each item can be selected only once, but a portion of an item can be selected, with the value calculated based on the proportion of weight selected, what is the maximum value of items in the knapsack under the limited capacity? An example is shown in Figure 15-3.</p> <p></p> <p> Figure 15-3   Example data for the fractional knapsack problem </p> <p>The fractional knapsack problem is very similar overall to the 0-1 knapsack problem, with states including the current item \\(i\\) and capacity \\(c\\), and the goal being to maximize value under the limited knapsack capacity.</p> <p>The difference is that this problem allows selecting only a portion of an item. As shown in Figure 15-4, we can arbitrarily split items and calculate the corresponding value based on the weight proportion.</p> <ol> <li>For item \\(i\\), its value per unit weight is \\(val[i-1] / wgt[i-1]\\), referred to as unit value.</li> <li>Suppose we put a portion of item \\(i\\) with weight \\(w\\) into the knapsack, then the value added to the knapsack is \\(w \\times val[i-1] / wgt[i-1]\\).</li> </ol> <p></p> <p> Figure 15-4   Value of items per unit weight </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>Maximizing the total value of items in the knapsack is essentially maximizing the value per unit weight of items. From this, we can derive the greedy strategy shown in Figure 15-5.</p> <ol> <li>Sort items by unit value from high to low.</li> <li>Iterate through all items, greedily selecting the item with the highest unit value in each round.</li> <li>If the remaining knapsack capacity is insufficient, use a portion of the current item to fill the knapsack.</li> </ol> <p></p> <p> Figure 15-5   Greedy strategy for the fractional knapsack problem </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>We created an <code>Item</code> class to facilitate sorting items by unit value. We loop to make greedy selections, breaking when the knapsack is full and returning the solution:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"Item\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # Item weight\n        self.v = v  # Item value\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Fractional knapsack: Greedy algorithm\"\"\"\n    # Create item list with two attributes: weight, value\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # Sort by unit value item.v / item.w from high to low\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # Loop for greedy selection\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v\n            cap -= item.w\n        else:\n            # If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap\n            # No remaining capacity, so break out of the loop\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* Item */\nclass Item {\n  public:\n    int w; // Item weight\n    int v; // Item value\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // Create item list with two attributes: weight, value\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // Sort by unit value item.v / item.w from high to low\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // Loop for greedy selection\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double)item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* Item */\nclass Item {\n    int w; // Item weight\n    int v; // Item value\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Create item list with two attributes: weight, value\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Sort by unit value item.v / item.w from high to low\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // Loop for greedy selection\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double) item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* Item */\nclass Item(int w, int v) {\n    public int w = w; // Item weight\n    public int v = v; // Item value\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Create item list with two attributes: weight, value\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Sort by unit value item.v / item.w from high to low\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // Loop for greedy selection\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (double)item.v / item.w * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* Item */\ntype Item struct {\n    w int // Item weight\n    v int // Item value\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // Create item list with two attributes: weight, value\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // Sort by unit value item.v / item.w from high to low\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // Loop for greedy selection\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* Item */\nclass Item {\n    var w: Int // Item weight\n    var v: Int // Item value\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // Create item list with two attributes: weight, value\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // Sort by unit value item.v / item.w from high to low\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // Loop for greedy selection\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* Item */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // Item weight\n        this.v = v; // Item value\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // Create item list with two attributes: weight, value\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Sort by unit value item.v / item.w from high to low\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Loop for greedy selection\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* Item */\nclass Item {\n    w: number; // Item weight\n    v: number; // Item value\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // Create item list with two attributes: weight, value\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Sort by unit value item.v / item.w from high to low\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Loop for greedy selection\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (item.v / item.w) * cap;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* Item */\nclass Item {\n  int w; // Item weight\n  int v; // Item value\n\n  Item(this.w, this.v);\n}\n\n/* Fractional knapsack: Greedy algorithm */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // Create item list with two attributes: weight, value\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // Sort by unit value item.v / item.w from high to low\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // Loop for greedy selection\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // If remaining capacity is sufficient, put the entire current item into the knapsack\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // If remaining capacity is insufficient, put part of the current item into the knapsack\n      res += item.v / item.w * cap;\n      // No remaining capacity, so break out of the loop\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* Item */\nstruct Item {\n    w: i32, // Item weight\n    v: i32, // Item value\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* Fractional knapsack: Greedy algorithm */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // Create item list with two attributes: weight, value\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // Sort by unit value item.v / item.w from high to low\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // Loop for greedy selection\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // No remaining capacity, so break out of the loop\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* Item */\ntypedef struct {\n    int w; // Item weight\n    int v; // Item value\n} Item;\n\n/* Fractional knapsack: Greedy algorithm */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // Create item list with two attributes: weight, value\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // Sort by unit value item.v / item.w from high to low\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // Loop for greedy selection\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* Item */\nclass Item(\n    val w: Int, // Item\n    val v: Int  // Item value\n)\n\n/* Fractional knapsack: Greedy algorithm */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // Create item list with two attributes: weight, value\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // Sort by unit value item.v / item.w from high to low\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // Loop for greedy selection\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // If remaining capacity is sufficient, put the entire current item into the knapsack\n            res += item.v\n            cap -= item.w\n        } else {\n            // If remaining capacity is insufficient, put part of the current item into the knapsack\n            res += item.v.toDouble() / item.w * cap\n            // No remaining capacity, so break out of the loop\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### Item ###\nclass Item\n  attr_accessor :w # Item weight\n  attr_accessor :v # Item value\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### Fractional knapsack: greedy ###\ndef fractional_knapsack(wgt, val, cap)\n  # Create item list with two attributes: weight, value\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # Sort by unit value item.v / item.w from high to low\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # Loop for greedy selection\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # If remaining capacity is sufficient, put the entire current item into the knapsack\n      res += item.v\n      cap -= item.w\n    else\n      # If remaining capacity is insufficient, put part of the current item into the knapsack\n      res += (item.v.to_f / item.w) * cap\n      # No remaining capacity, so break out of the loop\n      break\n    end\n  end\n  res\nend\n</code></pre> <p>The time complexity of built-in sorting algorithms is usually \\(O(\\log n)\\), and the space complexity is usually \\(O(\\log n)\\) or \\(O(n)\\), depending on the specific implementation of the programming language.</p> <p>Apart from sorting, in the worst case the entire item list needs to be traversed, therefore the time complexity is \\(O(n)\\), where \\(n\\) is the number of items.</p> <p>Since an <code>Item</code> object list is initialized, the space complexity is \\(O(n)\\).</p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>Using proof by contradiction. Suppose item \\(x\\) has the highest unit value, and some algorithm yields a maximum value of <code>res</code>, but this solution does not include item \\(x\\).</p> <p>Now remove a unit weight of any item from the knapsack and replace it with a unit weight of item \\(x\\). Since item \\(x\\) has the highest unit value, the total value after replacement will definitely be greater than <code>res</code>. This contradicts the assumption that <code>res</code> is the optimal solution, proving that the optimal solution must include item \\(x\\).</p> <p>For other items in this solution, we can also construct the above contradiction. In summary, items with greater unit value are always better choices, which proves that the greedy strategy is effective.</p> <p>As shown in Figure 15-6, if we view item weight and item unit value as the horizontal and vertical axes of a two-dimensional chart respectively, then the fractional knapsack problem can be transformed into \"finding the maximum area enclosed within a limited horizontal axis range\". This analogy can help us understand the effectiveness of the greedy strategy from a geometric perspective.</p> <p></p> <p> Figure 15-6   Geometric representation of the fractional knapsack problem </p>","path":["Chapter 15. Greedy","15.2 &nbsp; Fractional Knapsack Problem"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   Greedy Algorithm","text":"<p>Greedy algorithm is a common algorithm for solving optimization problems. Its basic idea is to make the seemingly best choice at each decision stage of the problem, that is, to greedily make locally optimal decisions in hopes of obtaining a globally optimal solution. Greedy algorithms are simple and efficient, and are widely applied in many practical problems.</p> <p>Greedy algorithms and dynamic programming are both commonly used to solve optimization problems. They share some similarities, such as both relying on the optimal substructure property, but they work differently.</p> <ul> <li>Dynamic programming considers all previous decisions when making the current decision, and uses solutions to past subproblems to construct the solution to the current subproblem.</li> <li>Greedy algorithms do not consider past decisions, but instead make greedy choices moving forward, continually reducing the problem size until the problem is solved.</li> </ul> <p>We will first understand how greedy algorithms work through the example problem \"coin change\". This problem has already been introduced in the \"Complete Knapsack Problem\" chapter, so I believe you are not unfamiliar with it.</p> <p>Question</p> <p>Given \\(n\\) types of coins, where the denomination of the \\(i\\)-th type of coin is \\(coins[i - 1]\\), and the target amount is \\(amt\\), with each type of coin available for repeated selection, what is the minimum number of coins needed to make up the target amount? If it is impossible to make up the target amount, return \\(-1\\).</p> <p>The greedy strategy adopted for this problem is shown in Figure 15-1. Given a target amount, we greedily select the coin that is not greater than and closest to it, and continuously repeat this step until the target amount is reached.</p> <p></p> <p> Figure 15-1   Greedy strategy for coin change </p> <p>The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Coin change: Greedy algorithm\"\"\"\n    # Assume coins list is sorted\n    i = len(coins) - 1\n    count = 0\n    # Loop to make greedy choices until no remaining amount\n    while amt &gt; 0:\n        # Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # Choose coins[i]\n        amt -= coins[i]\n        count += 1\n    # If no feasible solution is found, return -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.size() - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(int[] coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.length - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* Coin change: Greedy algorithm */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // Assume coins list is sorted\n    int i = coins.Length - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* Coin change: Greedy algorithm */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // Assume coins list is sorted\n    i := len(coins) - 1\n    count := 0\n    // Loop to make greedy choices until no remaining amount\n    for amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // Choose coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // If no feasible solution is found, return -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* Coin change: Greedy algorithm */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // Assume coins list is sorted\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // Loop to make greedy choices until no remaining amount\n    while amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // Choose coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* Coin change: Greedy algorithm */\nfunction coinChangeGreedy(coins, amt) {\n    // Assume coins array is sorted\n    let i = coins.length - 1;\n    let count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* Coin change: Greedy algorithm */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // Assume coins array is sorted\n    let i = coins.length - 1;\n    let count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // Assume coins list is sorted\n  int i = coins.length - 1;\n  int count = 0;\n  // Loop to make greedy choices until no remaining amount\n  while (amt &gt; 0) {\n    // Find the coin that is less than and closest to the remaining amount\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // Choose coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // If no feasible solution is found, return -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* Coin change: Greedy algorithm */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // Assume coins list is sorted\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while amt &gt; 0 {\n        // Find the coin that is less than and closest to the remaining amount\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // If no feasible solution is found, return -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* Coin change: Greedy algorithm */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // Assume coins list is sorted\n    int i = size - 1;\n    int count = 0;\n    // Loop to make greedy choices until no remaining amount\n    while (amt &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Choose coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // If no feasible solution is found, return -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* Coin change: Greedy algorithm */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // Assume coins list is sorted\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // Loop to make greedy choices until no remaining amount\n    while (am &gt; 0) {\n        // Find the coin that is less than and closest to the remaining amount\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // Choose coins[i]\n        am -= coins[i]\n        count++\n    }\n    // If no feasible solution is found, return -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### Coin change: greedy ###\ndef coin_change_greedy(coins, amt)\n  # Assume coins list is sorted\n  i = coins.length - 1\n  count = 0\n  # Loop to make greedy choices until no remaining amount\n  while amt &gt; 0\n    # Find the coin that is less than and closest to the remaining amount\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # Choose coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # Return -1 if no solution found\n  amt == 0 ? count : -1\nend\n</code></pre> <p>You might exclaim: So clean! The greedy algorithm solves the coin change problem in about ten lines of code.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511-advantages-and-limitations-of-greedy-algorithms","level":2,"title":"15.1.1   Advantages and Limitations of Greedy Algorithms","text":"<p>Greedy algorithms are not only straightforward and simple to implement, but are also usually very efficient. In the code above, if the smallest coin denomination is \\(\\min(coins)\\), the greedy choice loops at most \\(amt / \\min(coins)\\) times, giving a time complexity of \\(O(amt / \\min(coins))\\). This is an order of magnitude smaller than the time complexity of the dynamic programming solution \\(O(n \\times amt)\\).</p> <p>However, for certain coin denomination combinations, greedy algorithms cannot find the optimal solution. Figure 15-2 provides two examples.</p> <ul> <li>Positive example \\(coins = [1, 5, 10, 20, 50, 100]\\): With this coin combination, given any \\(amt\\), the greedy algorithm can find the optimal solution.</li> <li>Negative example \\(coins = [1, 20, 50]\\): Suppose \\(amt = 60\\), the greedy algorithm can only find the combination \\(50 + 1 \\times 10\\), totaling \\(11\\) coins, but dynamic programming can find the optimal solution \\(20 + 20 + 20\\), requiring only \\(3\\) coins.</li> <li>Negative example \\(coins = [1, 49, 50]\\): Suppose \\(amt = 98\\), the greedy algorithm can only find the combination \\(50 + 1 \\times 48\\), totaling \\(49\\) coins, but dynamic programming can find the optimal solution \\(49 + 49\\), requiring only \\(2\\) coins.</li> </ul> <p></p> <p> Figure 15-2   Examples where greedy algorithms cannot find the optimal solution </p> <p>In other words, for the coin change problem, greedy algorithms cannot guarantee finding the global optimal solution, and may even find very poor solutions. It is better suited for solving with dynamic programming.</p> <p>Generally, the applicability of greedy algorithms falls into the following two situations.</p> <ol> <li>Can guarantee finding the optimal solution: In this situation, greedy algorithms are often the best choice, because they tend to be more efficient than backtracking and dynamic programming.</li> <li>Can find an approximate optimal solution: Greedy algorithms are also applicable in this situation. For many complex problems, finding the global optimal solution is very difficult, and being able to find a suboptimal solution with high efficiency is also very good.</li> </ol>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512-characteristics-of-greedy-algorithms","level":2,"title":"15.1.2   Characteristics of Greedy Algorithms","text":"<p>So the question arises: what kind of problems are suitable for solving with greedy algorithms? Or in other words, under what conditions can greedy algorithms guarantee finding the optimal solution?</p> <p>Compared to dynamic programming, the conditions for using greedy algorithms are stricter, mainly focusing on two properties of the problem.</p> <ul> <li>Greedy choice property: Only when locally optimal choices can always lead to a globally optimal solution can greedy algorithms guarantee obtaining the optimal solution.</li> <li>Optimal substructure: The optimal solution to the original problem contains the optimal solutions to subproblems.</li> </ul> <p>Optimal substructure has already been introduced in the \"Dynamic Programming\" chapter, so we won't elaborate on it here. It's worth noting that the optimal substructure of some problems is not obvious, but they can still be solved using greedy algorithms.</p> <p>We mainly explore methods for determining the greedy choice property. Although its description seems relatively simple, in practice, for many problems, proving the greedy choice property is not easy.</p> <p>For example, in the coin change problem, although we can easily provide counterexamples to disprove the greedy choice property, proving it is quite difficult. If asked: what conditions must a coin combination satisfy to be solvable using a greedy algorithm? We often can only rely on intuition or examples to give an ambiguous answer, and find it difficult to provide a rigorous mathematical proof.</p> <p>Quote</p> <p>There is a paper that presents an algorithm with \\(O(n^3)\\) time complexity for determining whether a coin combination can use a greedy algorithm to find the optimal solution for any amount.</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513-steps-for-solving-problems-with-greedy-algorithms","level":2,"title":"15.1.3   Steps for Solving Problems with Greedy Algorithms","text":"<p>The problem-solving process for greedy problems can generally be divided into the following three steps.</p> <ol> <li>Problem analysis: Sort out and understand the problem characteristics, including state definition, optimization objectives, and constraints, etc. This step is also involved in backtracking and dynamic programming.</li> <li>Determine the greedy strategy: Determine how to make greedy choices at each step. This strategy should be able to reduce the problem size at each step, ultimately solving the entire problem.</li> <li>Correctness proof: It is usually necessary to prove that the problem has both greedy choice property and optimal substructure. This step may require mathematical proofs, such as mathematical induction or proof by contradiction.</li> </ol> <p>Determining the greedy strategy is the core step in solving the problem, but it may not be easy to implement, mainly for the following reasons.</p> <ul> <li>Greedy strategies differ greatly between different problems. For many problems, the greedy strategy is relatively straightforward, and we can derive it through some general thinking and attempts. However, for some complex problems, the greedy strategy may be very elusive, which really tests one's problem-solving experience and algorithmic ability.</li> <li>Some greedy strategies are highly misleading. When we confidently design a greedy strategy, write the solution code and submit it for testing, we may find that some test cases cannot pass. This is because the designed greedy strategy is only \"partially correct\", as exemplified by the coin change problem discussed above.</li> </ul> <p>To ensure correctness, we should rigorously mathematically prove the greedy strategy, usually using proof by contradiction or mathematical induction.</p> <p>However, correctness proofs may also not be easy. If we have no clue, we usually choose to debug the code based on test cases, step by step modifying and verifying the greedy strategy.</p>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514-typical-problems-solved-by-greedy-algorithms","level":2,"title":"15.1.4   Typical Problems Solved by Greedy Algorithms","text":"<p>Greedy algorithms are often applied to optimization problems that satisfy greedy choice property and optimal substructure. Below are some typical greedy algorithm problems.</p> <ul> <li>Coin change problem: With certain coin combinations, greedy algorithms can always obtain the optimal solution.</li> <li>Interval scheduling problem: Suppose you have some tasks, each taking place during a period of time, and your goal is to complete as many tasks as possible. If you always choose the task that ends earliest, then the greedy algorithm can obtain the optimal solution.</li> <li>Fractional knapsack problem: Given a set of items and a carrying capacity, your goal is to select a set of items such that the total weight does not exceed the carrying capacity and the total value is maximized. If you always choose the item with the highest value-to-weight ratio (value / weight), then the greedy algorithm can obtain the optimal solution in some cases.</li> <li>Stock trading problem: Given a set of historical stock prices, you can make multiple trades, but if you already hold stocks, you cannot buy again before selling, and the goal is to obtain the maximum profit.</li> <li>Huffman coding: Huffman coding is a greedy algorithm used for lossless data compression. By constructing a Huffman tree and always merging the two nodes with the lowest frequency, the resulting Huffman tree has the minimum weighted path length (encoding length).</li> <li>Dijkstra's algorithm: It is a greedy algorithm for solving the shortest path problem from a given source vertex to all other vertices.</li> </ul>","path":["Chapter 15. Greedy","15.1 &nbsp; Greedy Algorithm"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   Max Capacity Problem","text":"<p>Question</p> <p>Input an array \\(ht\\), where each element represents the height of a vertical partition. Any two partitions in the array, along with the space between them, can form a container.</p> <p>The capacity of the container equals the product of height and width (area), where the height is determined by the shorter partition, and the width is the difference in array indices between the two partitions.</p> <p>Please select two partitions in the array such that the capacity of the formed container is maximized, and return the maximum capacity. An example is shown in Figure 15-7.</p> <p></p> <p> Figure 15-7   Example data for the max capacity problem </p> <p>The container is formed by any two partitions, therefore the state of this problem is the indices of two partitions, denoted as \\([i, j]\\).</p> <p>According to the problem description, capacity equals height multiplied by width, where height is determined by the shorter partition, and width is the difference in array indices between the two partitions. Let the capacity be \\(cap[i, j]\\), then the calculation formula is:</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>Let the array length be \\(n\\), then the number of combinations of two partitions (total number of states) is \\(C_n^2 = \\frac{n(n - 1)}{2}\\). Most directly, we can exhaustively enumerate all states to find the maximum capacity, with time complexity \\(O(n^2)\\).</p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>This problem has a more efficient solution. As shown in Figure 15-8, select a state \\([i, j]\\) where index \\(i &lt; j\\) and height \\(ht[i] &lt; ht[j]\\), meaning \\(i\\) is the short partition and \\(j\\) is the long partition.</p> <p></p> <p> Figure 15-8   Initial state </p> <p>As shown in Figure 15-9, if we now move the long partition \\(j\\) closer to the short partition \\(i\\), the capacity will definitely decrease.</p> <p>This is because after moving the long partition \\(j\\), the width \\(j-i\\) definitely decreases; and since height is determined by the short partition, the height can only remain unchanged (\\(i\\) is still the short partition) or decrease (the moved \\(j\\) becomes the short partition).</p> <p></p> <p> Figure 15-9   State after moving the long partition inward </p> <p>Conversely, we can only possibly increase capacity by contracting the short partition \\(i\\) inward. Because although width will definitely decrease, height may increase (the moved short partition \\(i\\) may become taller). For example, in Figure 15-10, the area increases after moving the short partition.</p> <p></p> <p> Figure 15-10   State after moving the short partition inward </p> <p>From this we can derive the greedy strategy for this problem: initialize two pointers at both ends of the container, and in each round contract the pointer corresponding to the short partition inward, until the two pointers meet.</p> <p>Figure 15-11 shows the execution process of the greedy strategy.</p> <ol> <li>In the initial state, pointers \\(i\\) and \\(j\\) are at both ends of the array.</li> <li>Calculate the capacity of the current state \\(cap[i, j]\\), and update the maximum capacity.</li> <li>Compare the heights of partition \\(i\\) and partition \\(j\\), and move the short partition inward by one position.</li> <li>Loop through steps <code>2.</code> and <code>3.</code> until \\(i\\) and \\(j\\) meet.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 15-11   Greedy process for the max capacity problem </p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>The code loops at most \\(n\\) rounds, therefore the time complexity is \\(O(n)\\).</p> <p>Variables \\(i\\), \\(j\\), and \\(res\\) use a constant amount of extra space, therefore the space complexity is \\(O(1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"Max capacity: Greedy algorithm\"\"\"\n    # Initialize i, j to be at both ends of the array\n    i, j = 0, len(ht) - 1\n    # Initial max capacity is 0\n    res = 0\n    # Loop for greedy selection until the two boards meet\n    while i &lt; j:\n        # Update max capacity\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # Move the shorter board inward\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.size() - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(int[] ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.length - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* Max capacity: Greedy algorithm */\nint MaxCapacity(int[] ht) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0, j = ht.Length - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* Max capacity: Greedy algorithm */\nfunc maxCapacity(ht []int) int {\n    // Initialize i, j to be at both ends of the array\n    i, j := 0, len(ht)-1\n    // Initial max capacity is 0\n    res := 0\n    // Loop for greedy selection until the two boards meet\n    for i &lt; j {\n        // Update max capacity\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* Max capacity: Greedy algorithm */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // Initialize i, j to be at both ends of the array\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // Initial max capacity is 0\n    var res = 0\n    // Loop for greedy selection until the two boards meet\n    while i &lt; j {\n        // Update max capacity\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* Max capacity: Greedy algorithm */\nfunction maxCapacity(ht) {\n    // Initialize i, j to be at both ends of the array\n    let i = 0,\n        j = ht.length - 1;\n    // Initial max capacity is 0\n    let res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* Max capacity: Greedy algorithm */\nfunction maxCapacity(ht: number[]): number {\n    // Initialize i, j to be at both ends of the array\n    let i = 0,\n        j = ht.length - 1;\n    // Initial max capacity is 0\n    let res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(List&lt;int&gt; ht) {\n  // Initialize i, j to be at both ends of the array\n  int i = 0, j = ht.length - 1;\n  // Initial max capacity is 0\n  int res = 0;\n  // Loop for greedy selection until the two boards meet\n  while (i &lt; j) {\n    // Update max capacity\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // Move the shorter board inward\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* Max capacity: Greedy algorithm */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // Initialize i, j to be at both ends of the array\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // Initial max capacity is 0\n    let mut res = 0;\n    // Loop for greedy selection until the two boards meet\n    while i &lt; j {\n        // Update max capacity\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // Move the shorter board inward\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* Max capacity: Greedy algorithm */\nint maxCapacity(int ht[], int htLength) {\n    // Initialize i, j to be at both ends of the array\n    int i = 0;\n    int j = htLength - 1;\n    // Initial max capacity is 0\n    int res = 0;\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* Max capacity: Greedy algorithm */\nfun maxCapacity(ht: IntArray): Int {\n    // Initialize i, j to be at both ends of the array\n    var i = 0\n    var j = ht.size - 1\n    // Initial max capacity is 0\n    var res = 0\n    // Loop for greedy selection until the two boards meet\n    while (i &lt; j) {\n        // Update max capacity\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Move the shorter board inward\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### Maximum capacity: greedy ###\ndef max_capacity(ht)\n  # Initialize i, j to be at both ends of the array\n  i, j = 0, ht.length - 1\n  # Initial max capacity is 0\n  res = 0\n\n  # Loop for greedy selection until the two boards meet\n  while i &lt; j\n    # Update max capacity\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # Move the shorter board inward\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>The reason greedy is faster than exhaustive enumeration is that each round of greedy selection \"skips\" some states.</p> <p>For example, in state \\(cap[i, j]\\) where \\(i\\) is the short partition and \\(j\\) is the long partition, if we greedily move the short partition \\(i\\) inward by one position, the states shown in Figure 15-12 will be \"skipped\". This means that the capacities of these states cannot be verified later.</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> Figure 15-12   States skipped by moving the short partition </p> <p>Observing carefully, these skipped states are actually all the states obtained by moving the long partition \\(j\\) inward. We have already proven that moving the long partition inward will definitely decrease capacity. That is, the skipped states cannot possibly be the optimal solution, skipping them will not cause us to miss the optimal solution.</p> <p>The above analysis shows that the operation of moving the short partition is \"safe\", and the greedy strategy is effective.</p>","path":["Chapter 15. Greedy","15.3 &nbsp; Max Capacity Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   Max Product Cutting Problem","text":"<p>Question</p> <p>Given a positive integer \\(n\\), split it into the sum of at least two positive integers, and find the maximum product of all integers after splitting, as shown in Figure 15-13.</p> <p></p> <p> Figure 15-13   Problem definition of max product cutting </p> <p>Suppose we split \\(n\\) into \\(m\\) integer factors, where the \\(i\\)-th factor is denoted as \\(n_i\\), that is</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>The goal of this problem is to find the maximum product of all integer factors, namely</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>We need to think about: how large should the splitting count \\(m\\) be, and what should each \\(n_i\\) be?</p>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1-greedy-strategy-determination","level":3,"title":"1.   Greedy Strategy Determination","text":"<p>Based on experience, the product of two integers is often greater than their sum. Suppose we split out a factor of \\(2\\) from \\(n\\), then their product is \\(2(n-2)\\). We compare this product with \\(n\\):</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>As shown in Figure 15-14, when \\(n \\geq 4\\), splitting out a \\(2\\) will increase the product, which indicates that integers greater than or equal to \\(4\\) should all be split.</p> <p>Greedy strategy one: If the splitting scheme includes factors \\(\\geq 4\\), then they should continue to be split. The final splitting scheme should only contain factors \\(1\\), \\(2\\), and \\(3\\).</p> <p></p> <p> Figure 15-14   Splitting causes product to increase </p> <p>Next, consider which factor is optimal. Among the three factors \\(1\\), \\(2\\), and \\(3\\), clearly \\(1\\) is the worst, because \\(1 \\times (n-1) &lt; n\\) always holds, meaning splitting out \\(1\\) will actually decrease the product.</p> <p>As shown in Figure 15-15, when \\(n = 6\\), we have \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\). This means that splitting out \\(3\\) is better than splitting out \\(2\\).</p> <p>Greedy strategy two: In the splitting scheme, there should be at most two \\(2\\)s. Because three \\(2\\)s can always be replaced by two \\(3\\)s to obtain a larger product.</p> <p></p> <p> Figure 15-15   Optimal splitting factor </p> <p>In summary, the following greedy strategies can be derived.</p> <ol> <li>Input integer \\(n\\), continuously split out factor \\(3\\) until the remainder is \\(0\\), \\(1\\), or \\(2\\).</li> <li>When the remainder is \\(0\\), it means \\(n\\) is a multiple of \\(3\\), so no further action is needed.</li> <li>When the remainder is \\(2\\), do not continue splitting, keep it.</li> <li>When the remainder is \\(1\\), since \\(2 \\times 2 &gt; 1 \\times 3\\), the last \\(3\\) should be replaced with \\(2\\).</li> </ol>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2-code-implementation","level":3,"title":"2.   Code Implementation","text":"<p>As shown in Figure 15-16, we don't need to use loops to split the integer, but can use integer division to get the count of \\(3\\)s as \\(a\\), and modulo operation to get the remainder as \\(b\\), at which point we have:</p> \\[ n = 3 a + b \\] <p>Please note that for the edge case of \\(n \\leq 3\\), a \\(1\\) must be split out, with product \\(1 \\times (n - 1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"Max product cutting: Greedy algorithm\"\"\"\n    # When n &lt;= 3, must cut out a 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # Greedily cut out 3, a is the number of 3s, b is the remainder\n    a, b = n // 3, n % 3\n    if b == 1:\n        # When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # When the remainder is 2, do nothing\n        return int(math.pow(3, a)) * 2\n    # When the remainder is 0, do nothing\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int)pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int) Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* Max product cutting: Greedy algorithm */\nint MaxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* Max product cutting: Greedy algorithm */\nfunc maxProductCutting(n int) int {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // When the remainder is 2, do nothing\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // When the remainder is 0, do nothing\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* Max product cutting: Greedy algorithm */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // When the remainder is 2, do nothing\n        return pow(3, a) * 2\n    }\n    // When the remainder is 0, do nothing\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* Max product cutting: Greedy algorithm */\nfunction maxProductCutting(n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // When the remainder is 2, do nothing\n        return Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* Max product cutting: Greedy algorithm */\nfunction maxProductCutting(n: number): number {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // When the remainder is 2, do nothing\n        return Math.pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n  // When n &lt;= 3, must cut out a 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // Greedily cut out 3, a is the number of 3s, b is the remainder\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // When the remainder is 2, do nothing\n    return (pow(3, a) * 2).toInt();\n  }\n  // When the remainder is 0, do nothing\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* Max product cutting: Greedy algorithm */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // When n &lt;= 3, must cut out a 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // When the remainder is 2, do nothing\n        3_i32.pow(a as u32) * 2\n    } else {\n        // When the remainder is 0, do nothing\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* Max product cutting: Greedy algorithm */\nint maxProductCutting(int n) {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return pow(3, a) * 2;\n    }\n    // When the remainder is 0, do nothing\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* Max product cutting: Greedy algorithm */\nfun maxProductCutting(n: Int): Int {\n    // When n &lt;= 3, must cut out a 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // Greedily cut out 3, a is the number of 3s, b is the remainder\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // When the remainder is 2, do nothing\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // When the remainder is 0, do nothing\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### Maximum cutting product: greedy ###\ndef max_product_cutting(n)\n  # When n &lt;= 3, must cut out a 1\n  return 1 * (n - 1) if n &lt;= 3\n  # Greedily cut out 3, a is the number of 3s, b is the remainder\n  a, b = n / 3, n % 3\n  # When the remainder is 1, convert a pair of 1 * 3 to 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # When the remainder is 2, do nothing\n  return (3.pow(a) * 2).to_i if b == 2\n  # When the remainder is 0, do nothing\n  3.pow(a).to_i\nend\n</code></pre> <p></p> <p> Figure 15-16   Calculation method for max product cutting </p> <p>The time complexity depends on the implementation of the exponentiation operation in the programming language. Taking Python as an example, there are three commonly used power calculation functions.</p> <ul> <li>Both the operator <code>**</code> and the function <code>pow()</code> have time complexity \\(O(\\log⁡ a)\\).</li> <li>The function <code>math.pow()</code> internally calls the C library's <code>pow()</code> function, which performs floating-point exponentiation, with time complexity \\(O(1)\\).</li> </ul> <p>Variables \\(a\\) and \\(b\\) use a constant amount of extra space, therefore the space complexity is \\(O(1)\\).</p>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3-correctness-proof","level":3,"title":"3.   Correctness Proof","text":"<p>Using proof by contradiction, only analyzing the case where \\(n \\geq 4\\).</p> <ol> <li>All factors \\(\\leq 3\\): Suppose the optimal splitting scheme includes a factor \\(x \\geq 4\\), then it can definitely continue to be split into \\(2(x-2)\\) to obtain a larger (or equal) product. This contradicts the assumption.</li> <li>The splitting scheme does not contain \\(1\\): Suppose the optimal splitting scheme includes a factor of \\(1\\), then it can definitely be merged into another factor to obtain a larger product. This contradicts the assumption.</li> <li>The splitting scheme contains at most two \\(2\\)s: Suppose the optimal splitting scheme includes three \\(2\\)s, then they can definitely be replaced by two \\(3\\)s for a larger product. This contradicts the assumption.</li> </ol>","path":["Chapter 15. Greedy","15.4 &nbsp; Max Product Cutting Problem"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   Summary","text":"","path":["Chapter 15. Greedy","15.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_greedy/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Greedy algorithms are typically used to solve optimization problems. The principle is to make locally optimal decisions at each decision stage in hopes of obtaining a globally optimal solution.</li> <li>Greedy algorithms iteratively make one greedy choice after another, transforming the problem into a smaller subproblem in each round, until the problem is solved.</li> <li>Greedy algorithms are not only simple to implement, but also have high problem-solving efficiency. Compared to dynamic programming, greedy algorithms typically have lower time complexity.</li> <li>In the coin change problem, for certain coin combinations, greedy algorithms can guarantee finding the optimal solution; for other coin combinations, however, greedy algorithms may find very poor solutions.</li> <li>Problems suitable for solving with greedy algorithms have two major properties: greedy choice property and optimal substructure. The greedy choice property represents the effectiveness of the greedy strategy.</li> <li>For some complex problems, proving the greedy choice property is not simple. Relatively speaking, disproving it is easier, such as in the coin change problem.</li> <li>Solving greedy problems mainly consists of three steps: problem analysis, determining the greedy strategy, and correctness proof. Among these, determining the greedy strategy is the core step, and correctness proof is often the difficult point.</li> <li>The fractional knapsack problem, based on the 0-1 knapsack problem, allows selecting a portion of items, and therefore can be solved using greedy algorithms. The correctness of the greedy strategy can be proven using proof by contradiction.</li> <li>The max capacity problem can be solved using exhaustive enumeration with time complexity \\(O(n^2)\\). By designing a greedy strategy to move the short partition inward in each round, the time complexity can be optimized to \\(O(n)\\).</li> <li>In the max product cutting problem, we successively derive two greedy strategies: integers \\(\\geq 4\\) should all continue to be split, and the optimal splitting factor is \\(3\\). The code includes exponentiation operations, and the time complexity depends on the implementation method of exponentiation, typically being \\(O(1)\\) or \\(O(\\log n)\\).</li> </ul>","path":["Chapter 15. Greedy","15.5 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"Chapter 6.   Hashing","text":"<p>Abstract</p> <p>In the world of computing, a hash table is like a clever librarian.</p> <p>They know how to calculate call numbers, enabling them to quickly locate the target book.</p>","path":["Chapter 6. Hashing","Chapter 6. &nbsp; Hashing"],"tags":[]},{"location":"chapter_hashing/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>6.1   Hash Table</li> <li>6.2   Hash Collision</li> <li>6.3   Hash Algorithm</li> <li>6.4   Summary</li> </ul>","path":["Chapter 6. Hashing","Chapter 6. &nbsp; Hashing"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   Hash Algorithm","text":"<p>The previous two sections introduced the working principle of hash tables and the methods to handle hash collisions. However, both open addressing and separate chaining can only ensure that the hash table functions normally when hash collisions occur, but cannot reduce the frequency of hash collisions.</p> <p>If hash collisions occur too frequently, the performance of the hash table will deteriorate drastically. As shown in Figure 6-8, for a separate chaining hash table, in the ideal case, the key-value pairs are evenly distributed across the buckets, achieving optimal query efficiency; in the worst case, all key-value pairs are stored in the same bucket, degrading the time complexity to \\(O(n)\\).</p> <p></p> <p> Figure 6-8   Ideal and worst cases of hash collisions </p> <p>The distribution of key-value pairs is determined by the hash function. Recalling the calculation steps of the hash function, first compute the hash value, then take the modulo by the array length:</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Observing the above formula, when the hash table capacity <code>capacity</code> is fixed, the hash algorithm <code>hash()</code> determines the output value, thereby determining the distribution of key-value pairs in the hash table.</p> <p>This means that, to reduce the probability of hash collisions, we should focus on the design of the hash algorithm <code>hash()</code>.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631-goals-of-hash-algorithms","level":2,"title":"6.3.1   Goals of Hash Algorithms","text":"<p>To achieve a \"fast and stable\" hash table data structure, hash algorithms should have the following characteristics:</p> <ul> <li>Determinism: For the same input, the hash algorithm should always produce the same output. Only then can the hash table be reliable.</li> <li>High efficiency: The process of computing the hash value should be fast enough. The smaller the computational overhead, the more practical the hash table.</li> <li>Uniform distribution: The hash algorithm should ensure that key-value pairs are evenly distributed in the hash table. The more uniform the distribution, the lower the probability of hash collisions.</li> </ul> <p>In fact, hash algorithms are not only used to implement hash tables but are also widely applied in other fields.</p> <ul> <li>Password storage: To protect the security of user passwords, systems usually do not store the plaintext passwords but rather the hash values of the passwords. When a user enters a password, the system calculates the hash value of the input and compares it with the stored hash value. If they match, the password is considered correct.</li> <li>Data integrity check: The data sender can calculate the hash value of the data and send it along; the receiver can recalculate the hash value of the received data and compare it with the received hash value. If they match, the data is considered intact.</li> </ul> <p>For cryptographic applications, to prevent reverse engineering such as deducing the original password from the hash value, hash algorithms need higher-level security features.</p> <ul> <li>Unidirectionality: It should be impossible to deduce any information about the input data from the hash value.</li> <li>Collision resistance: It should be extremely difficult to find two different inputs that produce the same hash value.</li> <li>Avalanche effect: Minor changes in the input should lead to significant and unpredictable changes in the output.</li> </ul> <p>Note that \"uniform distribution\" and \"collision resistance\" are two independent concepts. Satisfying uniform distribution does not necessarily mean collision resistance. For example, under random input <code>key</code>, the hash function <code>key % 100</code> can produce a uniformly distributed output. However, this hash algorithm is too simple, and all <code>key</code> with the same last two digits will have the same output, making it easy to deduce a usable <code>key</code> from the hash value, thereby cracking the password.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632-design-of-hash-algorithms","level":2,"title":"6.3.2   Design of Hash Algorithms","text":"<p>The design of hash algorithms is a complex issue that requires consideration of many factors. However, for some less demanding scenarios, we can also design some simple hash algorithms.</p> <ul> <li>Additive hash: Add up the ASCII codes of each character in the input and use the total sum as the hash value.</li> <li>Multiplicative hash: Utilize the non-correlation of multiplication, multiplying each round by a constant, accumulating the ASCII codes of each character into the hash value.</li> <li>XOR hash: Accumulate the hash value by XORing each element of the input data.</li> <li>Rotating hash: Accumulate the ASCII code of each character into a hash value, performing a rotation operation on the hash value before each accumulation.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"Additive hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"Multiplicative hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"Rotational hash\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* Additive hash */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* Additive hash */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* Multiplicative hash */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR hash */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* Additive hash */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* Additive hash */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* Multiplicative hash */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR hash */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* Rotational hash */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* Additive hash */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* Multiplicative hash */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR hash */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* Rotational hash */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* Additive hash */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Multiplicative hash */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR hash */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Rotational hash */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* Additive hash */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Multiplicative hash */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR hash */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Rotational hash */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* Additive hash */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* Multiplicative hash */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR hash */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* Additive hash */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* Multiplicative hash */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR hash */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* Rotational hash */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* Additive hash */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Multiplicative hash */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR hash */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Rotational hash */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* Additive hash */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* Multiplicative hash */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR hash */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* Rotational hash */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### Additive hash ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### Multiplicative hash ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR hash ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### Rotational hash ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> <p>It is observed that the last step of each hash algorithm is to take the modulus of the large prime number \\(1000000007\\) to ensure that the hash value is within an appropriate range. It is worth pondering why emphasis is placed on modulo a prime number, or what are the disadvantages of modulo a composite number? This is an interesting question.</p> <p>To conclude: Using a large prime number as the modulus can maximize the uniform distribution of hash values. Since a prime number does not share common factors with other numbers, it can reduce the periodic patterns caused by the modulo operation, thus avoiding hash collisions.</p> <p>For example, suppose we choose the composite number \\(9\\) as the modulus, which can be divided by \\(3\\), then all <code>key</code> divisible by \\(3\\) will be mapped to hash values \\(0\\), \\(3\\), \\(6\\).</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>If the input <code>key</code> happens to have this kind of arithmetic sequence distribution, then the hash values will cluster, thereby exacerbating hash collisions. Now, suppose we replace <code>modulus</code> with the prime number \\(13\\), since there are no common factors between <code>key</code> and <code>modulus</code>, the uniformity of the output hash values will be significantly improved.</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>It is worth noting that if the <code>key</code> is guaranteed to be randomly and uniformly distributed, then choosing a prime number or a composite number as the modulus can both produce uniformly distributed hash values. However, when the distribution of <code>key</code> has some periodicity, modulo a composite number is more likely to result in clustering.</p> <p>In summary, we usually choose a prime number as the modulus, and this prime number should be large enough to eliminate periodic patterns as much as possible, enhancing the robustness of the hash algorithm.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633-common-hash-algorithms","level":2,"title":"6.3.3   Common Hash Algorithms","text":"<p>It is not hard to see that the simple hash algorithms mentioned above are quite \"fragile\" and far from reaching the design goals of hash algorithms. For example, since addition and XOR obey the commutative law, additive hash and XOR hash cannot distinguish strings with the same content but in different order, which may exacerbate hash collisions and cause security issues.</p> <p>In practice, we usually use some standard hash algorithms, such as MD5, SHA-1, SHA-2, and SHA-3. They can map input data of any length to a fixed-length hash value.</p> <p>Over the past century, hash algorithms have been in a continuous process of upgrading and optimization. Some researchers strive to improve the performance of hash algorithms, while others, including hackers, are dedicated to finding security issues in hash algorithms. Table 6-2 shows hash algorithms commonly used in practical applications.</p> <ul> <li>MD5 and SHA-1 have been successfully attacked multiple times and are thus abandoned in various security applications.</li> <li>SHA-2 series, especially SHA-256, is one of the most secure hash algorithms to date, with no successful attacks reported, hence commonly used in various security applications and protocols.</li> <li>SHA-3 has lower implementation costs and higher computational efficiency compared to SHA-2, but its current usage coverage is not as extensive as the SHA-2 series.</li> </ul> <p> Table 6-2   Common hash algorithms </p> MD5 SHA-1 SHA-2 SHA-3 Release Year 1992 1995 2002 2008 Output Length 128 bit 160 bit 256/512 bit 224/256/384/512 bit Hash Collisions Frequent Frequent Rare Rare Security Level Low, has been successfully attacked Low, has been successfully attacked High High Applications Abandoned, still used for data integrity checks Abandoned Cryptocurrency transaction verification, digital signatures, etc. Can be used to replace SHA-2","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#hash-values-in-data-structures","level":1,"title":"Hash Values in Data Structures","text":"<p>We know that the keys in a hash table can be of various data types such as integers, decimals, or strings. Programming languages usually provide built-in hash algorithms for these data types to calculate the bucket indices in the hash table. Taking Python as an example, we can use the <code>hash()</code> function to compute the hash values for various data types.</p> <ul> <li>The hash values of integers and booleans are their own values.</li> <li>The calculation of hash values for floating-point numbers and strings is more complex, and interested readers are encouraged to study this on their own.</li> <li>The hash value of a tuple is a combination of the hash values of each of its elements, resulting in a single hash value.</li> <li>The hash value of an object is generated based on its memory address. By overriding the hash method of an object, hash values can be generated based on content.</li> </ul> <p>Tip</p> <p>Be aware that the definition and methods of the built-in hash value calculation functions in different programming languages vary.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# Hash value of integer 3 is 3\n\nbol = True\nhash_bol = hash(bol)\n# Hash value of boolean True is 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Hash value of decimal 3.14159 is 326484311674566659\n\nstr = \"Hello 算法\"\nhash_str = hash(str)\n# Hash value of string \"Hello 算法\" is 4617003410720528961\n\ntup = (12836, \"小哈\")\nhash_tup = hash(tup)\n# Hash value of tuple (12836, '小哈') is 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Hash value of ListNode object at 0x1058fd810 is 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// Hash value of integer 3 is 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// Hash value of boolean 1 is 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// Hash value of decimal 3.14159 is 4614256650576692846\n\nstring str = \"Hello 算法\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// Hash value of string \"Hello 算法\" is 15466937326284535026\n\n// In C++, built-in std::hash() only provides hash values for basic data types\n// Hash values for arrays and objects need to be implemented separately\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// Hash value of integer 3 is 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Hash value of decimal 3.14159 is -1340954729\n\nString str = \"Hello 算法\";\nint hashStr = str.hashCode();\n// Hash value of string \"Hello 算法\" is -727081396\n\nObject[] arr = { 12836, \"小哈\" };\nint hashTup = Arrays.hashCode(arr);\n// Hash value of array [12836, 小哈] is 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Hash value of ListNode object utils.ListNode@7dc5e7b4 is 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// Hash value of integer 3 is 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Hash value of boolean true is 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Hash value of decimal 3.14159 is -1340954729;\n\nstring str = \"Hello 算法\";\nint hashStr = str.GetHashCode();\n// Hash value of string \"Hello 算法\" is -586107568;\n\nobject[] arr = [12836, \"小哈\"];\nint hashTup = arr.GetHashCode();\n// Hash value of array [12836, 小哈] is 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Hash value of ListNode object 0 is 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go does not provide built-in hash code functions\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// Hash value of integer 3 is 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Hash value of boolean true is -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Hash value of decimal 3.14159 is -2465384235396674631\n\nlet str = \"Hello 算法\"\nlet hashStr = str.hashValue\n// Hash value of string \"Hello 算法\" is -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"小哈\")]\nlet hashTup = arr.hashValue\n// Hash value of array [AnyHashable(12836), AnyHashable(\"小哈\")] is -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Hash value of ListNode object utils.ListNode is -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript does not provide built-in hash code functions\n</code></pre> built_in_hash.ts<pre><code>// TypeScript does not provide built-in hash code functions\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// Hash value of integer 3 is 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Hash value of decimal 3.14159 is 2570631074981783\n\nString str = \"Hello 算法\";\nint hashStr = str.hashCode;\n// Hash value of string \"Hello 算法\" is 468167534\n\nList arr = [12836, \"小哈\"];\nint hashArr = arr.hashCode;\n// Hash value of array [12836, 小哈] is 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Hash value of ListNode object Instance of 'ListNode' is 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Hash value of integer 3 is 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Hash value of boolean true is 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Hash value of decimal 3.14159 is 2566941990314602357\n\nlet str = \"Hello 算法\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Hash value of string \"Hello 算法\" is 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"小哈\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Hash value of tuple (12836, \"小哈\") is 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// Hash value of ListNode object RefCell { value: ListNode { val: 42, next: None } } is 15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C does not provide built-in hash code functions\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// Hash value of integer 3 is 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// Hash value of boolean true is 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// Hash value of decimal 3.14159 is -1340954729\n\nval str = \"Hello 算法\"\nval hashStr = str.hashCode()\n// Hash value of string \"Hello 算法\" is -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"小哈\")\nval hashTup = arr.hashCode()\n// Hash value of array [12836, 小哈] is 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// Hash value of ListNode object utils.ListNode@1d81eb93 is 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# Hash value of integer 3 is -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# Hash value of boolean true is -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# Hash value of decimal 3.14159 is -1479186995943067893\n\nstr = \"Hello 算法\"\nhash_str = str.hash\n# Hash value of string \"Hello 算法\" is -4075943250025831763\n\ntup = [12836, '小哈']\nhash_tup = tup.hash\n# Hash value of tuple (12836, '小哈') is 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# Hash value of ListNode object #&lt;ListNode:0x000078133140ab70&gt; is 4302940560806366381\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%E6%95%B4%E6%95%B0%203%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%E5%B8%83%E5%B0%94%E9%87%8F%20True%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%E5%B0%8F%E6%95%B0%203.14159%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20%E7%AE%97%E6%B3%95%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%E5%AD%97%E7%AC%A6%E4%B8%B2%E2%80%9CHello%20%E7%AE%97%E6%B3%95%E2%80%9D%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836,%20%22%E5%B0%8F%E5%93%88%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%E5%85%83%E7%BB%84%20%2812836,%20'%E5%B0%8F%E5%93%88'%29%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%AF%B9%E8%B1%A1%20%3CListNode%20object%20at%200x1058fd810%3E%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>In many programming languages, only immutable objects can serve as the <code>key</code> in a hash table. If we use a list (dynamic array) as a <code>key</code>, when the contents of the list change, its hash value also changes, and we would no longer be able to find the original <code>value</code> in the hash table.</p> <p>Although the member variables of a custom object (such as a linked list node) are mutable, it is hashable. This is because the hash value of an object is usually generated based on its memory address, and even if the contents of the object change, the memory address remains the same, so the hash value remains unchanged.</p> <p>You might have noticed that the hash values output in different consoles are different. This is because the Python interpreter adds a random salt to the string hash function each time it starts up. This approach effectively prevents HashDoS attacks and enhances the security of the hash algorithm.</p>","path":["Chapter 6. Hashing","6.3 &nbsp; Hash Algorithm"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   Hash Collision","text":"<p>The previous section mentioned that, in most cases, the input space of a hash function is much larger than the output space, so theoretically, hash collisions are inevitable. For example, if the input space is all integers and the output space is the array capacity size, then multiple integers will inevitably be mapped to the same bucket index.</p> <p>Hash collisions can lead to incorrect query results, severely impacting the usability of the hash table. To address this issue, whenever a hash collision occurs, we can perform hash table expansion until the collision disappears. This approach is simple, straightforward, and effective, but it is very inefficient because hash table expansion involves a large amount of data migration and hash value recalculation. To improve efficiency, we can adopt the following strategies:</p> <ol> <li>Improve the hash table data structure so that the hash table can function normally when hash collisions occur.</li> <li>Only expand when necessary, that is, only when hash collisions are severe.</li> </ol> <p>The main methods for improving the structure of hash tables include \"separate chaining\" and \"open addressing\".</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621-separate-chaining","level":2,"title":"6.2.1   Separate Chaining","text":"<p>In the original hash table, each bucket can store only one key-value pair. Separate chaining converts a single element into a linked list, treating key-value pairs as linked list nodes and storing all colliding key-value pairs in the same linked list. Figure 6-5 shows an example of a separate chaining hash table.</p> <p></p> <p> Figure 6-5   Separate chaining hash table </p> <p>The operations of a hash table implemented with separate chaining have changed as follows:</p> <ul> <li>Querying elements: Input <code>key</code>, obtain the bucket index through the hash function, then access the head node of the linked list, then traverse the linked list and compare <code>key</code> to find the target key-value pair.</li> <li>Adding elements: First access the linked list head node through the hash function, then append the node (key-value pair) to the linked list.</li> <li>Deleting elements: Access the head of the linked list based on the result of the hash function, then traverse the linked list to find the target node and delete it.</li> </ul> <p>Separate chaining has the following limitations:</p> <ul> <li>Increased Space Usage: The linked list contains node pointers, which consume more memory space than arrays.</li> <li>Reduced Query Efficiency: This is because linear traversal of the linked list is required to find the corresponding element.</li> </ul> <p>The code below provides a simple implementation of a separate chaining hash table, with two things to note:</p> <ul> <li>Lists (dynamic arrays) are used instead of linked lists to simplify the code. In this setup, the hash table (array) contains multiple buckets, each of which is a list.</li> <li>This implementation includes a hash table expansion method. When the load factor exceeds \\(\\frac{2}{3}\\), we expand the hash table to \\(2\\) times its original size.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"Hash table with separate chaining\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self.size = 0  # Number of key-value pairs\n        self.capacity = 4  # Hash table capacity\n        self.load_thres = 2.0 / 3.0  # Load factor threshold for triggering expansion\n        self.extend_ratio = 2  # Expansion multiplier\n        self.buckets = [[] for _ in range(self.capacity)]  # Bucket array\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Load factor\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Query operation\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket, if key is found, return corresponding val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # If key is not found, return None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Add operation\"\"\"\n        # When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # If key does not exist, append key-value pair to the end\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Traverse bucket and remove key-value pair from it\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"Expand hash table\"\"\"\n        # Temporarily store the original hash table\n        buckets = self.buckets\n        # Initialize expanded new hash table\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # Move key-value pairs from original hash table to new hash table\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n  private:\n    int size;                       // Number of key-value pairs\n    int capacity;                   // Hash table capacity\n    double loadThres;               // Load factor threshold for triggering expansion\n    int extendRatio;                // Expansion multiplier\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // Bucket array\n\n  public:\n    /* Constructor */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* Destructor */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // Free memory\n                delete pair;\n            }\n        }\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        int index = hashFunc(key);\n        // Traverse bucket, if key is found, return corresponding val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // Return empty string if key not found\n        return \"\";\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // Remove key-value pair from it\n                delete tmp;                       // Free memory\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // Free memory\n                delete pair;\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    int size; // Number of key-value pairs\n    int capacity; // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio; // Expansion multiplier\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n    /* Constructor */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Query operation */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket, if key is found, return corresponding val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    void put(int key, String val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Traverse bucket and remove key-value pair from it\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    int size; // Number of key-value pairs\n    int capacity; // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio; // Expansion multiplier\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n    /* Constructor */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // Traverse bucket, if key is found, return corresponding val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Traverse bucket and remove key-value pair from it\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    void Extend() {\n        // Temporarily store the original hash table\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* Hash table with separate chaining */\ntype hashMapChaining struct {\n    size        int      // Number of key-value pairs\n    capacity    int      // Hash table capacity\n    loadThres   float64  // Load factor threshold for triggering expansion\n    extendRatio int      // Expansion multiplier\n    buckets     [][]pair // Bucket array\n}\n\n/* Constructor */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* Hash function */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* Load factor */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* Query operation */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // Traverse bucket, if key is found, return corresponding val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // Return empty string if key not found\n    return \"\"\n}\n\n/* Add operation */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // When load factor exceeds threshold, perform expansion\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // If key does not exist, append key-value pair to the end\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* Remove operation */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // Traverse bucket and remove key-value pair from it\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // Slice deletion\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* Expand hash table */\nfunc (m *hashMapChaining) extend() {\n    // Temporarily store the original hash table\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // Initialize expanded new hash table\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // Move key-value pairs from original hash table to new hash table\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* Print hash table */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    var loadThres: Double // Load factor threshold for triggering expansion\n    var extendRatio: Int // Expansion multiplier\n    var buckets: [[Pair]] // Bucket array\n\n    /* Constructor */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* Hash function */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Load factor */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket, if key is found, return corresponding val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // Return nil if key not found\n        return nil\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Traverse bucket and remove key-value pair from it\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* Expand hash table */\n    func extend() {\n        // Temporarily store the original hash table\n        let bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    #size; // Number of key-value pairs\n    #capacity; // Hash table capacity\n    #loadThres; // Load factor threshold for triggering expansion\n    #extendRatio; // Expansion multiplier\n    #buckets; // Bucket array\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Query operation */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if key is found, return corresponding val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key, val) {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    #extend() {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    #size: number; // Number of key-value pairs\n    #capacity: number; // Hash table capacity\n    #loadThres: number; // Load factor threshold for triggering expansion\n    #extendRatio: number; // Expansion multiplier\n    #buckets: Pair[][]; // Bucket array\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Hash function */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* Query operation */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if key is found, return corresponding val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // If key is not found, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key: number, val: string): void {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Traverse bucket and remove key-value pair from it\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Expand hash table */\n    #extend(): void {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n  late int size; // Number of key-value pairs\n  late int capacity; // Hash table capacity\n  late double loadThres; // Load factor threshold for triggering expansion\n  late int extendRatio; // Expansion multiplier\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // Bucket array\n\n  /* Constructor */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* Hash function */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* Load factor */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket, if key is found, return corresponding val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // If key is not found, return null\n    return null;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // If key does not exist, append key-value pair to the end\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Traverse bucket and remove key-value pair from it\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* Expand hash table */\n  void extend() {\n    // Temporarily store the original hash table\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // Initialize expanded new hash table\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* Hash table with separate chaining */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* Constructor */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* Load factor */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* Remove operation */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // Traverse bucket and remove key-value pair from it\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // If key is not found, return None\n        None\n    }\n\n    /* Expand hash table */\n    fn extend(&amp;mut self) {\n        // Temporarily store the original hash table\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // Initialize expanded new hash table\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // Move key-value pairs from original hash table to new hash table\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* Add operation */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // If key does not exist, append key-value pair to the end\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* Query operation */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // Traverse bucket, if key is found, return corresponding val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // If key is not found, return None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* Linked list node */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* Hash table with separate chaining */\ntypedef struct {\n    int size;         // Number of key-value pairs\n    int capacity;     // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio;  // Expansion multiplier\n    Node **buckets;   // Bucket array\n} HashMapChaining;\n\n/* Constructor */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* Destructor */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* Hash function */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Load factor */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Query operation */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // Traverse bucket, if key is found, return corresponding val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // Return empty string if key not found\n}\n\n/* Add operation */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // Traverse bucket, if specified key is encountered, update corresponding val and return\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // If specified key is found, update corresponding val and return\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // If key not found, add key-value pair to list head\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* Expand hash table */\nvoid extend(HashMapChaining *hashMap) {\n    // Temporarily store the original hash table\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // Initialize expanded new hash table\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // Free memory\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* Remove operation */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // Remove key-value pair from it\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // Free memory\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* Print hash table */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* Hash table with separate chaining */\nclass HashMapChaining {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    val loadThres: Double // Load factor threshold for triggering expansion\n    val extendRatio: Int // Expansion multiplier\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // Bucket array\n\n    /* Constructor */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Load factor */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket, if key is found, return corresponding val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // If key is not found, return null\n        return null\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket, if specified key is encountered, update corresponding val and return\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // If key does not exist, append key-value pair to the end\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Traverse bucket and remove key-value pair from it\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* Expand hash table */\n    fun extend() {\n        // Temporarily store the original hash table\n        val bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        // mutablelist has no fixed size\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### Hash map with chaining ###\nclass HashMapChaining\n  ### Constructor ###\n  def initialize\n    @size = 0 # Number of key-value pairs\n    @capacity = 4 # Hash table capacity\n    @load_thres = 2.0 / 3.0 # Load factor threshold for triggering expansion\n    @extend_ratio = 2 # Expansion multiplier\n    @buckets = Array.new(@capacity) { [] } # Bucket array\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Load factor ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Query operation ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket, if key is found, return corresponding val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # Return nil if key not found\n    nil\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    # When load factor exceeds threshold, perform expansion\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket, if specified key is encountered, update corresponding val and return\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # If key does not exist, append key-value pair to the end\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Traverse bucket and remove key-value pair from it\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### Expand hash table ###\n  def extend\n    # Temporarily store original hash table\n    buckets = @buckets\n    # Initialize expanded new hash table\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # Move key-value pairs from original hash table to new hash table\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### Print hash table ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> <p>It's worth noting that when the linked list is very long, the query efficiency \\(O(n)\\) is poor. In this case, the list can be converted to an \"AVL tree\" or \"Red-Black tree\" to optimize the time complexity of the query operation to \\(O(\\log n)\\).</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622-open-addressing","level":2,"title":"6.2.2   Open Addressing","text":"<p>Open addressing does not introduce additional data structures but instead handles hash collisions through \"multiple probes\". The probing methods mainly include linear probing, quadratic probing, and double hashing.</p> <p>Let's use linear probing as an example to introduce the mechanism of open addressing hash tables.</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1-linear-probing","level":3,"title":"1.   Linear Probing","text":"<p>Linear probing uses a fixed-step linear search for probing, and its operation method differs from ordinary hash tables.</p> <ul> <li>Inserting elements: Calculate the bucket index using the hash function. If the bucket already contains an element, linearly traverse forward from the conflict position (usually with a step size of \\(1\\)) until an empty bucket is found, then insert the element.</li> <li>Searching for elements: If a hash collision is encountered, use the same step size to linearly traverse forward until the corresponding element is found and return <code>value</code>; if an empty bucket is encountered, it means the target element is not in the hash table, so return <code>None</code>.</li> </ul> <p>Figure 6-6 shows the distribution of key-value pairs in an open addressing (linear probing) hash table. According to this hash function, keys with the same last two digits will be mapped to the same bucket. Through linear probing, they are stored sequentially in that bucket and the buckets below it.</p> <p></p> <p> Figure 6-6   Distribution of key-value pairs in open addressing (linear probing) hash table </p> <p>However, linear probing is prone to create \"clustering\". Specifically, the longer the continuously occupied positions in the array, the greater the probability of hash collisions occurring in these continuous positions, further promoting clustering growth at that position, forming a vicious cycle, and ultimately leading to degraded efficiency of insertion, deletion, query, and update operations.</p> <p>It's important to note that we cannot directly delete elements in an open addressing hash table. Deleting an element creates an empty bucket <code>None</code> in the array. When searching for elements, if linear probing encounters this empty bucket, it will return, making the elements below this empty bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in Figure 6-7.</p> <p></p> <p> Figure 6-7   Query issues caused by deletion in open addressing </p> <p>To solve this problem, we can adopt the lazy deletion mechanism: instead of directly removing elements from the hash table, use a constant <code>TOMBSTONE</code> to mark the bucket. In this mechanism, both <code>None</code> and <code>TOMBSTONE</code> represent empty buckets and can hold key-value pairs. However, when linear probing encounters <code>TOMBSTONE</code>, it should continue traversing since there may still be key-value pairs below it.</p> <p>However, lazy deletion may accelerate the performance degradation of the hash table. Every deletion operation produces a deletion mark, and as <code>TOMBSTONE</code> increases, the search time will also increase because linear probing may need to skip multiple <code>TOMBSTONE</code> to find the target element.</p> <p>To address this, consider recording the index of the first encountered <code>TOMBSTONE</code> during linear probing and swapping the searched target element with that <code>TOMBSTONE</code>. The benefit of doing this is that each time an element is queried or added, the element will be moved to a bucket closer to its ideal position (the starting point of probing), thereby optimizing query efficiency.</p> <p>The code below implements an open addressing (linear probing) hash table with lazy deletion. To make better use of the hash table space, we treat the hash table as a \"circular array\". When going beyond the end of the array, we return to the beginning and continue traversing.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"Hash table with open addressing\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self.size = 0  # Number of key-value pairs\n        self.capacity = 4  # Hash table capacity\n        self.load_thres = 2.0 / 3.0  # Load factor threshold for triggering expansion\n        self.extend_ratio = 2  # Expansion multiplier\n        self.buckets: list[Pair | None] = [None] * self.capacity  # Bucket array\n        self.TOMBSTONE = Pair(-1, \"-1\")  # Removal marker\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Load factor\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"Search for bucket index corresponding to key\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # Linear probing, break when encountering an empty bucket\n        while self.buckets[index] is not None:\n            # If key is encountered, return the corresponding bucket index\n            if self.buckets[index].key == key:\n                # If a removal marker was encountered before, move the key-value pair to that index\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # Return the moved bucket index\n                return index  # Return bucket index\n            # Record the first removal marker encountered\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % self.capacity\n        # If key does not exist, return the index for insertion\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"Query operation\"\"\"\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, return corresponding val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # If key-value pair does not exist, return None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Add operation\"\"\"\n        # When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, overwrite val and return\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # If key-value pair does not exist, add the key-value pair\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        # Search for bucket index corresponding to key\n        index = self.find_bucket(key)\n        # If key-value pair is found, overwrite it with removal marker\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"Expand hash table\"\"\"\n        # Temporarily store the original hash table\n        buckets_tmp = self.buckets\n        # Initialize expanded new hash table\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # Move key-value pairs from original hash table to new hash table\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // Number of key-value pairs\n    int capacity = 4;                     // Hash table capacity\n    const double loadThres = 2.0 / 3.0;     // Load factor threshold for triggering expansion\n    const int extendRatio = 2;            // Expansion multiplier\n    vector&lt;Pair *&gt; buckets;               // Bucket array\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // Removal marker\n\n  public:\n    /* Constructor */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* Destructor */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != nullptr) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index]-&gt;key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // Return empty string if key-value pair does not exist\n        return \"\";\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    void extend() {\n        // Temporarily store the original hash table\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* Print hash table */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private int size; // Number of key-value pairs\n    private int capacity = 4; // Hash table capacity\n    private final double loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n    private final int extendRatio = 2; // Expansion multiplier\n    private Pair[] buckets; // Bucket array\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // Removal marker\n\n    /* Constructor */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Hash function */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index].key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    public String get(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void put(int key, String val) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    public void remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    private void extend() {\n        // Temporarily store the original hash table\n        Pair[] bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    int size; // Number of key-value pairs\n    int capacity = 4; // Hash table capacity\n    double loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n    int extendRatio = 2; // Expansion multiplier\n    Pair[] buckets; // Bucket array\n    Pair TOMBSTONE = new(-1, \"-1\"); // Removal marker\n\n    /* Constructor */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Load factor */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index].key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        // When load factor exceeds threshold, perform expansion\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        // Search for bucket index corresponding to key\n        int index = FindBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Expand hash table */\n    void Extend() {\n        // Temporarily store the original hash table\n        Pair[] bucketsTmp = buckets;\n        // Initialize expanded new hash table\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* Hash table with open addressing */\ntype hashMapOpenAddressing struct {\n    size        int     // Number of key-value pairs\n    capacity    int     // Hash table capacity\n    loadThres   float64 // Load factor threshold for triggering expansion\n    extendRatio int     // Expansion multiplier\n    buckets     []*pair // Bucket array\n    TOMBSTONE   *pair   // Removal marker\n}\n\n/* Constructor */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* Hash function */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // Calculate hash value based on key\n}\n\n/* Load factor */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // Calculate current load factor\n}\n\n/* Search for bucket index corresponding to key */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // Get initial index\n    firstTombstone := -1     // Record position of first TOMBSTONE encountered\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // Return the moved bucket index\n            }\n            return index // Return found index\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // Record position of first deletion marker encountered\n        }\n        index = (index + 1) % h.capacity // Linear probing, wrap around to head if past tail\n    }\n    // If key does not exist, return the index for insertion\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* Query operation */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // If key-value pair is found, return corresponding val\n    }\n    return \"\" // Return \"\" if key-value pair does not exist\n}\n\n/* Add operation */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // When load factor exceeds threshold, perform expansion\n    }\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // If key-value pair does not exist, add the key-value pair\n        h.size++\n    } else {\n        h.buckets[index].val = val // If key-value pair found, overwrite val\n    }\n}\n\n/* Remove operation */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // Search for bucket index corresponding to key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // If key-value pair is found, overwrite it with removal marker\n        h.size--\n    }\n}\n\n/* Expand hash table */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // Temporarily store the original hash table\n    h.capacity *= h.extendRatio           // Update capacity\n    h.buckets = make([]*pair, h.capacity) // Initialize expanded new hash table\n    h.size = 0                            // Reset size\n    // Move key-value pairs from original hash table to new hash table\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* Print hash table */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    var size: Int // Number of key-value pairs\n    var capacity: Int // Hash table capacity\n    var loadThres: Double // Load factor threshold for triggering expansion\n    var extendRatio: Int // Expansion multiplier\n    var buckets: [Pair?] // Bucket array\n    var TOMBSTONE: Pair // Removal marker\n\n    /* Constructor */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* Hash function */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Load factor */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Search for bucket index corresponding to key */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // Linear probing, break when encountering an empty bucket\n        while buckets[index] != nil {\n            // If key is encountered, return the corresponding bucket index\n            if buckets[index]!.key == key {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Return the moved bucket index\n                }\n                return index // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, return corresponding val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // If key-value pair does not exist, return null\n        return nil\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, overwrite val and return\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        // Search for bucket index corresponding to key\n        let index = findBucket(key: key)\n        // If key-value pair is found, overwrite it with removal marker\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* Expand hash table */\n    func extend() {\n        // Temporarily store the original hash table\n        let bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    #size; // Number of key-value pairs\n    #capacity; // Hash table capacity\n    #loadThres; // Load factor threshold for triggering expansion\n    #extendRatio; // Expansion multiplier\n    #buckets; // Bucket array\n    #TOMBSTONE; // Removal marker\n\n    /* Constructor */\n    constructor() {\n        this.#size = 0; // Number of key-value pairs\n        this.#capacity = 4; // Hash table capacity\n        this.#loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n        this.#extendRatio = 2; // Expansion multiplier\n        this.#buckets = Array(this.#capacity).fill(null); // Bucket array\n        this.#TOMBSTONE = new Pair(-1, '-1'); // Removal marker\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Load factor */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (this.#buckets[index] !== null) {\n            // If key is encountered, return the corresponding bucket index\n            if (this.#buckets[index].key === key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % this.#capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    get(key) {\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key, val) {\n        // When load factor exceeds threshold, perform expansion\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* Remove operation */\n    remove(key) {\n        // Search for bucket index corresponding to key\n        const index = this.#findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* Expand hash table */\n    #extend() {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.#buckets;\n        // Initialize expanded new hash table\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private size: number; // Number of key-value pairs\n    private capacity: number; // Hash table capacity\n    private loadThres: number; // Load factor threshold for triggering expansion\n    private extendRatio: number; // Expansion multiplier\n    private buckets: Array&lt;Pair | null&gt;; // Bucket array\n    private TOMBSTONE: Pair; // Removal marker\n\n    /* Constructor */\n    constructor() {\n        this.size = 0; // Number of key-value pairs\n        this.capacity = 4; // Hash table capacity\n        this.loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n        this.extendRatio = 2; // Expansion multiplier\n        this.buckets = Array(this.capacity).fill(null); // Bucket array\n        this.TOMBSTONE = new Pair(-1, '-1'); // Removal marker\n    }\n\n    /* Hash function */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* Load factor */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* Search for bucket index corresponding to key */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while (this.buckets[index] !== null) {\n            // If key is encountered, return the corresponding bucket index\n            if (this.buckets[index]!.key === key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % this.capacity;\n        }\n        // If key does not exist, return the index for insertion\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Query operation */\n    get(key: number): string | null {\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, return corresponding val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // If key-value pair does not exist, return null\n        return null;\n    }\n\n    /* Add operation */\n    put(key: number, val: string): void {\n        // When load factor exceeds threshold, perform expansion\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, overwrite val and return\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* Remove operation */\n    remove(key: number): void {\n        // Search for bucket index corresponding to key\n        const index = this.findBucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* Expand hash table */\n    private extend(): void {\n        // Temporarily store the original hash table\n        const bucketsTmp = this.buckets;\n        // Initialize expanded new hash table\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // Move key-value pairs from original hash table to new hash table\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Print hash table */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n  late int _size; // Number of key-value pairs\n  int _capacity = 4; // Hash table capacity\n  double _loadThres = 2.0 / 3.0; // Load factor threshold for triggering expansion\n  int _extendRatio = 2; // Expansion multiplier\n  late List&lt;Pair?&gt; _buckets; // Bucket array\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // Removal marker\n\n  /* Constructor */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* Hash function */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* Load factor */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* Search for bucket index corresponding to key */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // Linear probing, break when encountering an empty bucket\n    while (_buckets[index] != null) {\n      // If key is encountered, return the corresponding bucket index\n      if (_buckets[index]!.key == key) {\n        // If a removal marker was encountered before, move the key-value pair to that index\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // Return the moved bucket index\n        }\n        return index; // Return bucket index\n      }\n      // Record the first removal marker encountered\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // Calculate bucket index, wrap around to the head if past the tail\n      index = (index + 1) % _capacity;\n    }\n    // If key does not exist, return the index for insertion\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, return corresponding val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // If key-value pair does not exist, return null\n    return null;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, overwrite val and return\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // If key-value pair does not exist, add the key-value pair\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(key);\n    // If key-value pair is found, overwrite it with removal marker\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* Expand hash table */\n  void extend() {\n    // Temporarily store the original hash table\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // Initialize expanded new hash table\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* Hash table with open addressing */\nstruct HashMapOpenAddressing {\n    size: usize,                // Number of key-value pairs\n    capacity: usize,            // Hash table capacity\n    load_thres: f64,            // Load factor threshold for triggering expansion\n    extend_ratio: usize,        // Expansion multiplier\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // Bucket array\n    TOMBSTONE: Option&lt;Pair&gt;,    // Removal marker\n}\n\nimpl HashMapOpenAddressing {\n    /* Constructor */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* Load factor */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* Search for bucket index corresponding to key */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // Linear probing, break when encountering an empty bucket\n        while self.buckets[index].is_some() {\n            // If key is found, return corresponding bucket index\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // If deletion marker was encountered before, move key-value pair to that index\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // Return the moved bucket index\n                }\n                return index; // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % self.capacity;\n        }\n        // If key does not exist, return the index for insertion\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* Query operation */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, return corresponding val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // If key-value pair does not exist, return null\n        None\n    }\n\n    /* Add operation */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, overwrite val and return\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // If key-value pair does not exist, add the key-value pair\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* Remove operation */\n    fn remove(&amp;mut self, key: i32) {\n        // Search for bucket index corresponding to key\n        let index = self.find_bucket(key);\n        // If key-value pair is found, overwrite it with removal marker\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* Expand hash table */\n    fn extend(&amp;mut self) {\n        // Temporarily store the original hash table\n        let buckets_tmp = self.buckets.clone();\n        // Initialize expanded new hash table\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // Move key-value pairs from original hash table to new hash table\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* Print hash table */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* Hash table with open addressing */\ntypedef struct {\n    int size;         // Number of key-value pairs\n    int capacity;     // Hash table capacity\n    double loadThres; // Load factor threshold for triggering expansion\n    int extendRatio;  // Expansion multiplier\n    Pair **buckets;   // Bucket array\n    Pair *TOMBSTONE;  // Removal marker\n} HashMapOpenAddressing;\n\n/* Constructor */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* Destructor */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* Hash function */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Load factor */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Search for bucket index corresponding to key */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // Linear probing, break when encountering an empty bucket\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // If key is encountered, return the corresponding bucket index\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // If a removal marker was encountered before, move the key-value pair to that index\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // Return the moved bucket index\n            }\n            return index; // Return bucket index\n        }\n        // Record the first removal marker encountered\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // Calculate bucket index, wrap around to the head if past the tail\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // If key does not exist, return the index for insertion\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* Query operation */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, return corresponding val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // Return empty string if key-value pair does not exist\n    return \"\";\n}\n\n/* Add operation */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // When load factor exceeds threshold, perform expansion\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, overwrite val and return\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // If key-value pair does not exist, add the key-value pair\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* Remove operation */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // Search for bucket index corresponding to key\n    int index = findBucket(hashMap, key);\n    // If key-value pair is found, overwrite it with removal marker\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* Expand hash table */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // Temporarily store the original hash table\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // Initialize expanded new hash table\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // Move key-value pairs from original hash table to new hash table\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* Print hash table */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* Hash table with open addressing */\nclass HashMapOpenAddressing {\n    private var size: Int               // Number of key-value pairs\n    private var capacity: Int           // Hash table capacity\n    private val loadThres: Double       // Load factor threshold for triggering expansion\n    private val extendRatio: Int        // Expansion multiplier\n    private var buckets: Array&lt;Pair?&gt;   // Bucket array\n    private val TOMBSTONE: Pair         // Removal marker\n\n    /* Constructor */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Load factor */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Search for bucket index corresponding to key */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // Linear probing, break when encountering an empty bucket\n        while (buckets[index] != null) {\n            // If key is encountered, return the corresponding bucket index\n            if (buckets[index]?.key == key) {\n                // If a removal marker was encountered before, move the key-value pair to that index\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Return the moved bucket index\n                }\n                return index // Return bucket index\n            }\n            // Record the first removal marker encountered\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // Calculate bucket index, wrap around to the head if past the tail\n            index = (index + 1) % capacity\n        }\n        // If key does not exist, return the index for insertion\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, return corresponding val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // If key-value pair does not exist, return null\n        return null\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        // When load factor exceeds threshold, perform expansion\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, overwrite val and return\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // If key-value pair does not exist, add the key-value pair\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        // Search for bucket index corresponding to key\n        val index = findBucket(key)\n        // If key-value pair is found, overwrite it with removal marker\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* Expand hash table */\n    fun extend() {\n        // Temporarily store the original hash table\n        val bucketsTmp = buckets\n        // Initialize expanded new hash table\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // Move key-value pairs from original hash table to new hash table\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### Hash map with open addressing ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # Removal marker\n\n  ### Constructor ###\n  def initialize\n    @size = 0 # Number of key-value pairs\n    @capacity = 4 # Hash table capacity\n    @load_thres = 2.0 / 3.0 # Load factor threshold for triggering expansion\n    @extend_ratio = 2 # Expansion multiplier\n    @buckets = Array.new(@capacity) # Bucket array\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Load factor ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Search bucket index for key ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # Linear probing, break when encountering an empty bucket\n    while !@buckets[index].nil?\n      # If key is encountered, return the corresponding bucket index\n      if @buckets[index].key == key\n        # If a removal marker was encountered before, move the key-value pair to that index\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # Return the moved bucket index\n        end\n        return index # Return bucket index\n      end\n      # Record the first removal marker encountered\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # Calculate bucket index, wrap around to the head if past the tail\n      index = (index + 1) % @capacity\n    end\n    # If key does not exist, return the index for insertion\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### Query operation ###\n  def get(key)\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair is found, return corresponding val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # Return nil if key-value pair does not exist\n    nil\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    # When load factor exceeds threshold, perform expansion\n    extend if load_factor &gt; @load_thres\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair found, overwrite val and return\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # If key-value pair does not exist, add the key-value pair\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    # Search for bucket index corresponding to key\n    index = find_bucket(key)\n    # If key-value pair is found, overwrite it with removal marker\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### Expand hash table ###\n  def extend\n    # Temporarily store the original hash table\n    buckets_tmp = @buckets\n    # Initialize expanded new hash table\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # Move key-value pairs from original hash table to new hash table\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### Print hash table ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2-quadratic-probing","level":3,"title":"2.   Quadratic Probing","text":"<p>Quadratic probing is similar to linear probing and is one of the common strategies for open addressing. When a collision occurs, quadratic probing does not simply skip a fixed number of steps but skips a number of steps equal to the \"square of the number of probes\", i.e., \\(1, 4, 9, \\dots\\) steps.</p> <p>Quadratic probing has the following advantages:</p> <ul> <li>Quadratic probing attempts to alleviate the clustering effect of linear probing by skipping distances equal to the square of the probe count.</li> <li>Quadratic probing skips larger distances to find empty positions, which helps to distribute data more evenly.</li> </ul> <p>However, quadratic probing is not perfect:</p> <ul> <li>Clustering still exists, i.e., some positions are more likely to be occupied than others.</li> <li>Due to the growth of squares, quadratic probing may not probe the entire hash table, meaning that even if there are empty buckets in the hash table, quadratic probing may not be able to access them.</li> </ul>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3-double-hashing","level":3,"title":"3.   Double Hashing","text":"<p>As the name suggests, the double hashing method uses multiple hash functions \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) for probing.</p> <ul> <li>Inserting elements: If hash function \\(f_1(x)\\) encounters a conflict, try \\(f_2(x)\\), and so on, until an empty position is found and the element is inserted.</li> <li>Searching for elements: Search in the same order of hash functions until the target element is found and return it; if an empty position is encountered or all hash functions have been tried, it indicates the element is not in the hash table, then return <code>None</code>.</li> </ul> <p>Compared to linear probing, the double hashing method is less prone to clustering, but multiple hash functions introduce additional computational overhead.</p> <p>Tip</p> <p>Please note that open addressing (linear probing, quadratic probing, and double hashing) hash tables all have the problem of \"cannot directly delete elements\".</p>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623-choice-of-programming-languages","level":2,"title":"6.2.3   Choice of Programming Languages","text":"<p>Different programming languages adopt different hash table implementation strategies. Here are a few examples:</p> <ul> <li>Python uses open addressing. The <code>dict</code> dictionary uses pseudo-random numbers for probing.</li> <li>Java uses separate chaining. Since JDK 1.8, when the array length in <code>HashMap</code> reaches 64 and the length of a linked list reaches 8, the linked list is converted to a red-black tree to improve search performance.</li> <li>Go uses separate chaining. Go stipulates that each bucket can store up to 8 key-value pairs, and if the capacity is exceeded, an overflow bucket is linked; when there are too many overflow buckets, a special equal-capacity expansion operation is performed to ensure performance.</li> </ul>","path":["Chapter 6. Hashing","6.2 &nbsp; Hash Collision"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   Hash Table","text":"<p>A hash table, also known as a hash map, establishes a mapping between keys <code>key</code> and values <code>value</code>, enabling efficient element retrieval. Specifically, when we input a key <code>key</code> into a hash table, we can retrieve the corresponding value <code>value</code> in \\(O(1)\\) time.</p> <p>As shown in Figure 6-1, given \\(n\\) students, each with two pieces of data: \"name\" and \"student ID\". If we want to implement a query function that \"inputs a student ID and returns the corresponding name\", we can use the hash table shown below.</p> <p></p> <p> Figure 6-1   Abstract representation of a hash table </p> <p>In addition to hash tables, arrays and linked lists can also implement query functionality. Their efficiency comparison is shown in the following table.</p> <ul> <li>Adding elements: Simply add elements to the end of the array (linked list), using \\(O(1)\\) time.</li> <li>Querying elements: Since the array (linked list) is unordered, all elements need to be traversed, using \\(O(n)\\) time.</li> <li>Deleting elements: The element must first be located, then deleted from the array (linked list), using \\(O(n)\\) time.</li> </ul> <p> Table 6-1   Comparison of element query efficiency </p> Array Linked List Hash Table Find element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Add element \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Delete element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>As observed, the time complexity for insertion, deletion, search, and modification operations in a hash table is \\(O(1)\\), which is very efficient.</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#611-common-hash-table-operations","level":2,"title":"6.1.1   Common Hash Table Operations","text":"<p>Common operations on hash tables include: initialization, query operations, adding key-value pairs, and deleting key-value pairs. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Initialize hash table\nhmap: dict = {}\n\n# Add operation\n# Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n# Query operation\n# Input key into hash table to get value\nname: str = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* Initialize hash table */\nunordered_map&lt;int, string&gt; map;\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\";\nmap[15937] = \"XiaoLuo\";\nmap[16750] = \"XiaoSuan\";\nmap[13276] = \"XiaoFa\";\nmap[10583] = \"XiaoYa\";\n\n/* Query operation */\n// Input key into hash table to get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* Initialize hash table */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.put(12836, \"XiaoHa\");\nmap.put(15937, \"XiaoLuo\");\nmap.put(16750, \"XiaoSuan\");\nmap.put(13276, \"XiaoFa\");\nmap.put(10583, \"XiaoYa\");\n\n/* Query operation */\n// Input key into hash table to get value\nString name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* Initialize hash table */\nDictionary&lt;int, string&gt; map = new() {\n    /* Add operation */\n    // Add key-value pair (key, value) to hash table\n    { 12836, \"XiaoHa\" },\n    { 15937, \"XiaoLuo\" },\n    { 16750, \"XiaoSuan\" },\n    { 13276, \"XiaoFa\" },\n    { 10583, \"XiaoYa\" }\n};\n\n/* Query operation */\n// Input key into hash table to get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* Initialize hash table */\nhmap := make(map[int]string)\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nname := hmap[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* Initialize hash table */\nvar map: [Int: String] = [:]\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\"\nmap[15937] = \"XiaoLuo\"\nmap[16750] = \"XiaoSuan\"\nmap[13276] = \"XiaoFa\"\nmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map[15937]!\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* Initialize hash table */\nconst map = new Map();\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.set(12836, 'XiaoHa');\nmap.set(15937, 'XiaoLuo');\nmap.set(16750, 'XiaoSuan');\nmap.set(13276, 'XiaoFa');\nmap.set(10583, 'XiaoYa');\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* Initialize hash table */\nconst map = new Map&lt;number, string&gt;();\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.set(12836, 'XiaoHa');\nmap.set(15937, 'XiaoLuo');\nmap.set(16750, 'XiaoSuan');\nmap.set(13276, 'XiaoFa');\nmap.set(10583, 'XiaoYa');\nconsole.info('\\nAfter adding, hash table is\\nKey -&gt; Value');\nconsole.info(map);\n\n/* Query operation */\n// Input key into hash table to get value\nlet name = map.get(15937);\nconsole.info('\\nInput student ID 15937, queried name ' + name);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\nconsole.info('\\nAfter deleting 10583, hash table is\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* Initialize hash table */\nMap&lt;int, String&gt; map = {};\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\";\nmap[15937] = \"XiaoLuo\";\nmap[16750] = \"XiaoSuan\";\nmap[13276] = \"XiaoFa\";\nmap[10583] = \"XiaoYa\";\n\n/* Query operation */\n// Input key into hash table to get value\nString name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* Initialize hash table */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap.insert(12836, \"XiaoHa\".to_string());\nmap.insert(15937, \"XiaoLuo\".to_string());\nmap.insert(16750, \"XiaoSuan\".to_string());\nmap.insert(13279, \"XiaoFa\".to_string());\nmap.insert(10583, \"XiaoYa\".to_string());\n\n/* Query operation */\n// Input key into hash table to get value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C does not provide a built-in hash table\n</code></pre> hash_map.kt<pre><code>/* Initialize hash table */\nval map = HashMap&lt;Int,String&gt;()\n\n/* Add operation */\n// Add key-value pair (key, value) to hash table\nmap[12836] = \"XiaoHa\"\nmap[15937] = \"XiaoLuo\"\nmap[16750] = \"XiaoSuan\"\nmap[13276] = \"XiaoFa\"\nmap[10583] = \"XiaoYa\"\n\n/* Query operation */\n// Input key into hash table to get value\nval name = map[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># Initialize hash table\nhmap = {}\n\n# Add operation\n# Add key-value pair (key, value) to hash table\nhmap[12836] = \"XiaoHa\"\nhmap[15937] = \"XiaoLuo\"\nhmap[16750] = \"XiaoSuan\"\nhmap[13276] = \"XiaoFa\"\nhmap[10583] = \"XiaoYa\"\n\n# Query operation\n# Input key into hash table to get value\nname = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.delete(10583)\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%9F%A5%E8%AF%A2%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%90%91%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E8%BE%93%E5%85%A5%E9%94%AE%20key%20%EF%BC%8C%E5%BE%97%E5%88%B0%E5%80%BC%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E5%88%A0%E9%99%A4%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>There are three common ways to traverse a hash table: traversing key-value pairs, traversing keys, and traversing values. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Traverse hash table\n# Traverse key-value pairs key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# Traverse keys only\nfor key in hmap.keys():\n    print(key)\n# Traverse values only\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// Traverse using iterator key-&gt;value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor (Map.Entry&lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// Traverse keys only\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Traverse values only\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// Traverse keys only\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Traverse values only\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// Traverse keys only\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Traverse values only\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// Traverse keys only\nfor key in map.keys {\n    print(key)\n}\n// Traverse values only\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// Traverse keys only\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// Traverse values only\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* Traverse hash table */\n// Traverse key-value pairs Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// Traverse keys only\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// Traverse values only\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C does not provide a built-in hash table\n</code></pre> hash_map.kt<pre><code>/* Traverse hash table */\n// Traverse key-value pairs key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// Traverse keys only\nfor (key in map.keys) {\n    println(key)\n}\n// Traverse values only\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># Traverse hash table\n# Traverse key-value pairs key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# Traverse keys only\nhmap.keys.each { |key| puts key }\n\n# Traverse values only\nhmap.values.each { |val| puts val }\n</code></pre> Visualized Execution <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E9%94%AE%E5%80%BC%E5%AF%B9%20key-%3Evalue%0A%20%20%20%20for%20key,%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key,%20%22-%3E%22,%20value%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E9%94%AE%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E5%80%BC%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#612-simple-hash-table-implementation","level":2,"title":"6.1.2   Simple Hash Table Implementation","text":"<p>Let's first consider the simplest case: implementing a hash table using only an array. In a hash table, each empty position in the array is called a bucket, and each bucket can store a key-value pair. Therefore, the query operation is to find the bucket corresponding to <code>key</code> and retrieve the <code>value</code> from the bucket.</p> <p>So how do we locate the corresponding bucket based on <code>key</code>? This is achieved through a hash function. The role of the hash function is to map a larger input space to a smaller output space. In a hash table, the input space is all <code>key</code>s, and the output space is all buckets (array indices). In other words, given a <code>key</code>, we can use the hash function to obtain the storage location of the key-value pair corresponding to that <code>key</code> in the array.</p> <p>When inputting a <code>key</code>, the hash function's calculation process consists of the following two steps:</p> <ol> <li>Calculate the hash value through a hash algorithm <code>hash()</code>.</li> <li>Take the modulo of the hash value by the number of buckets (array length) <code>capacity</code> to obtain the bucket (array index) <code>index</code> corresponding to that <code>key</code>.</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Subsequently, we can use <code>index</code> to access the corresponding bucket in the hash table and retrieve the <code>value</code>.</p> <p>Assuming the array length is <code>capacity = 100</code> and the hash algorithm is <code>hash(key) = key</code>, the hash function becomes <code>key % 100</code>. Figure 6-2 shows the working principle of the hash function using <code>key</code> as student ID and <code>value</code> as name.</p> <p></p> <p> Figure 6-2   Working principle of hash function </p> <p>The following code implements a simple hash table. Here, we encapsulate <code>key</code> and <code>value</code> into a class <code>Pair</code> to represent a key-value pair.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"Key-value pair\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"Hash table based on array implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        # Initialize array with 100 buckets\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Hash function\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Query operation\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"Add and update operation\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"Remove operation\"\"\"\n        index: int = self.hash_func(key)\n        # Set to None to represent removal\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"Get all key-value pairs\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"Get all keys\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"Get all values\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"Print hash table\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* Key-value pair */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // Free memory\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* Hash function */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* Add operation */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Remove operation */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // Free memory and set to nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* Get all key-value pairs */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* Key-value pair */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* Hash function */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* Remove operation */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // Set to null to represent deletion\n        buckets.set(index, null);\n    }\n\n    /* Get all key-value pairs */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* Key-value pair int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // Initialize array with 100 buckets\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* Hash function */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Query operation */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Remove operation */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Set to null to represent deletion\n        buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Get all keys */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Get all values */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Print hash table */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* Key-value pair */\ntype pair struct {\n    key int\n    val string\n}\n\n/* Hash table based on array implementation */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* Initialize hash table */\nfunc newArrayHashMap() *arrayHashMap {\n    // Initialize array with 100 buckets\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* Hash function */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* Query operation */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* Add operation */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* Remove operation */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // Set to nil to delete\n    a.buckets[index] = nil\n}\n\n/* Get all key pairs */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* Get all keys */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* Get all values */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* Print hash table */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* Key-value pair */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // Initialize array with 100 buckets\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* Hash function */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* Query operation */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* Add operation */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* Remove operation */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // Set to nil to delete\n        buckets[index] = nil\n    }\n\n    /* Get all key-value pairs */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* Get all keys */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* Get all values */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* Print hash table */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* Key-value pair Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // Initialize array with 100 buckets\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* Hash function */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* Query operation */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* Remove operation */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // Set to null to represent deletion\n        this.#buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all keys */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all values */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Print hash table */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* Key-value pair Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // Initialize array with 100 buckets\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* Hash function */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* Query operation */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Add operation */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* Remove operation */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // Set to null to represent deletion\n        this.buckets[index] = null;\n    }\n\n    /* Get all key-value pairs */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all keys */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Get all values */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Print hash table */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* Key-value pair */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // Initialize array with 100 buckets\n    _buckets = List.filled(100, null);\n  }\n\n  /* Hash function */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* Query operation */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* Add operation */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* Remove operation */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* Get all key-value pairs */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* Get all keys */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* Get all values */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* Print hash table */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* Key-value pair */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* Hash table based on array implementation */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // Initialize array with 100 buckets\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* Hash function */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* Query operation */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* Add operation */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* Remove operation */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // Set to None to represent removal\n        self.buckets[index] = None;\n    }\n\n    /* Get all key-value pairs */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* Get all keys */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* Get all values */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* Print hash table */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* Key-value pair int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* Hash table based on array implementation */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* Constructor */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* Destructor */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* Add operation */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* Remove operation */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* Get all key-value pairs */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* Get all keys */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* Get all values */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Count valid key-value pairs */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* Print hash table */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* Key-value pair */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* Hash table based on array implementation */\nclass ArrayHashMap {\n    // Initialize array with 100 buckets\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* Hash function */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* Query operation */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* Add operation */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* Remove operation */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // Set to null to represent deletion\n        buckets[index] = null\n    }\n\n    /* Get all key-value pairs */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* Get all keys */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* Get all values */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* Print hash table */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### Key-value pair ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### Hash map based on array ###\nclass ArrayHashMap\n  ### Constructor ###\n  def initialize\n    # Initialize array with 100 buckets\n    @buckets = Array.new(100)\n  end\n\n  ### Hash function ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### Query operation ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### Add operation ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### Delete operation ###\n  def remove(key)\n    index = hash_func(key)\n    # Set to nil to delete\n    @buckets[index] = nil\n  end\n\n  ### Get all key-value pairs ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### Get all keys ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### Get all values ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### Print hash table ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/hash_map/#613-hash-collision-and-resizing","level":2,"title":"6.1.3   Hash Collision and Resizing","text":"<p>Fundamentally, the role of a hash function is to map the input space consisting of all <code>key</code>s to the output space consisting of all array indices, and the input space is often much larger than the output space. Therefore, theoretically there must be cases where \"multiple inputs correspond to the same output\".</p> <p>For the hash function in the above example, when the input <code>key</code>s have the same last two digits, the hash function produces the same output. For example, when querying two students with IDs 12836 and 20336, we get:</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>As shown in Figure 6-3, two student IDs point to the same name, which is obviously incorrect. We call this situation where multiple inputs correspond to the same output a hash collision.</p> <p></p> <p> Figure 6-3   Hash collision example </p> <p>It's easy to see that the larger the hash table capacity \\(n\\), the lower the probability that multiple <code>key</code>s will be assigned to the same bucket, and the fewer collisions. Therefore, we can reduce hash collisions by expanding the hash table.</p> <p>As shown in Figure 6-4, before expansion, the key-value pairs <code>(136, A)</code> and <code>(236, D)</code> collided, but after expansion, the collision disappears.</p> <p></p> <p> Figure 6-4   Hash table resizing </p> <p>Similar to array expansion, hash table expansion requires migrating all key-value pairs from the original hash table to the new hash table, which is very time-consuming. Moreover, since the hash table capacity <code>capacity</code> changes, we need to recalculate the storage locations of all key-value pairs through the hash function, further increasing the computational overhead of the expansion process. For this reason, programming languages typically reserve a sufficiently large hash table capacity to prevent frequent expansion.</p> <p>The load factor is an important concept for hash tables. It is defined as the number of elements in the hash table divided by the number of buckets, and is used to measure the severity of hash collisions. It is also commonly used as a trigger condition for hash table expansion. For example, in Java, when the load factor exceeds \\(0.75\\), the system will expand the hash table to \\(2\\) times its original size.</p>","path":["Chapter 6. Hashing","6.1 &nbsp; Hash Table"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   Summary","text":"","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Given an input <code>key</code>, a hash table can retrieve the corresponding <code>value</code> in \\(O(1)\\) time, which is highly efficient.</li> <li>Common hash table operations include querying, adding key-value pairs, deleting key-value pairs, and traversing the hash table.</li> <li>The hash function maps a <code>key</code> to an array index, allowing access to the corresponding bucket and retrieval of the <code>value</code>.</li> <li>Two different keys may end up with the same array index after hashing, leading to erroneous query results. This phenomenon is known as hash collision.</li> <li>The larger the capacity of the hash table, the lower the probability of hash collisions. Therefore, hash table expansion can mitigate hash collisions. Similar to array expansion, hash table expansion is costly.</li> <li>The load factor, defined as the number of elements divided by the number of buckets, reflects the severity of hash collisions and is often used as a condition to trigger hash table expansion.</li> <li>Separate chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same linked list. However, excessively long linked lists can reduce query efficiency, which can be improved by converting the linked lists into red-black trees.</li> <li>Open addressing handles hash collisions through multiple probing. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Double hashing uses multiple hash functions for probing, which reduces clustering compared to linear probing but increases computational overhead.</li> <li>Different programming languages adopt various hash table implementations. For example, Java's <code>HashMap</code> uses separate chaining, while Python's <code>dict</code> employs open addressing.</li> <li>In hash tables, we desire hash algorithms with determinism, high efficiency, and uniform distribution. In cryptography, hash algorithms should also possess collision resistance and the avalanche effect.</li> <li>Hash algorithms typically use large prime numbers as moduli to maximize the uniform distribution of hash values and reduce hash collisions.</li> <li>Common hash algorithms include MD5, SHA-1, SHA-2, and SHA-3. MD5 is often used for file integrity checks, while SHA-2 is commonly used in secure applications and protocols.</li> <li>Programming languages usually provide built-in hash algorithms for data types to calculate bucket indices in hash tables. Generally, only immutable objects are hashable.</li> </ul>","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: When does the time complexity of a hash table degrade to \\(O(n)\\)?</p> <p>The time complexity of a hash table can degrade to \\(O(n)\\) when hash collisions are severe. When the hash function is well-designed, the capacity is set appropriately, and collisions are evenly distributed, the time complexity is \\(O(1)\\). We usually consider the time complexity to be \\(O(1)\\) when using built-in hash tables in programming languages.</p> <p>Q: Why not use the hash function \\(f(x) = x\\)? This would eliminate collisions.</p> <p>Under the hash function \\(f(x) = x\\), each element corresponds to a unique bucket index, which is equivalent to an array. However, the input space is usually much larger than the output space (array length), so the last step of a hash function is often to take the modulo of the array length. In other words, the goal of a hash table is to map a larger state space to a smaller one while providing \\(O(1)\\) query efficiency.</p> <p>Q: Why can hash tables be more efficient than arrays, linked lists, or binary trees, even though hash tables are implemented using these structures?</p> <p>Firstly, hash tables have higher time efficiency but lower space efficiency. A significant portion of memory in hash tables remains unused.</p> <p>Secondly, hash tables are only more time-efficient in specific use cases. If a feature can be implemented with the same time complexity using an array or a linked list, it's usually faster than using a hash table. This is because the computation of the hash function incurs overhead, making the constant factor in the time complexity larger.</p> <p>Lastly, the time complexity of hash tables can degrade. For example, in separate chaining, we perform search operations in a linked list or red-black tree, which still risks degrading to \\(O(n)\\) time.</p> <p>Q: Does double hashing also have the flaw of not being able to delete elements directly? Can space marked as deleted be reused?</p> <p>Double hashing is a form of open addressing, and all open addressing methods have the drawback of not being able to delete elements directly; they require marking elements as deleted. Marked spaces can be reused. When inserting new elements into the hash table, and the hash function points to a position marked as deleted, that position can be used by the new element. This maintains the probing sequence of the hash table while ensuring efficient use of space.</p> <p>Q: Why do hash collisions occur during the search process in linear probing?</p> <p>During the search process, the hash function points to the corresponding bucket and key-value pair. If the <code>key</code> doesn't match, it indicates a hash collision. Therefore, linear probing will search downward at a predetermined step size until the correct key-value pair is found or the search fails.</p> <p>Q: Why can expanding a hash table alleviate hash collisions?</p> <p>The last step of a hash function often involves taking the modulo of the array length \\(n\\), to keep the output within the array index range. When expanding, the array length \\(n\\) changes, and the indices corresponding to the keys may also change. Keys that were previously mapped to the same bucket might be distributed across multiple buckets after expansion, thereby mitigating hash collisions.</p>","path":["Chapter 6. Hashing","6.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"Chapter 8.   Heap","text":"<p>Abstract</p> <p>Heaps are like mountain peaks, layered and undulating, each with its unique form.</p> <p>The peaks rise and fall at varying heights, yet the tallest peak always catches the eye first.</p>","path":["Chapter 8. Heap","Chapter 8. &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>8.1   Heap</li> <li>8.2   Building a Heap</li> <li>8.3   Top-K Problem</li> <li>8.4   Summary</li> </ul>","path":["Chapter 8. Heap","Chapter 8. &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   Heap Construction Operation","text":"<p>In some cases, we want to build a heap using all elements of a list, and this process is called \"heap construction operation.\"</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#821-implementing-with-element-insertion","level":2,"title":"8.2.1   Implementing with Element Insertion","text":"<p>We first create an empty heap, then iterate through the list, performing the \"element insertion operation\" on each element in sequence. This means adding the element to the bottom of the heap and then performing \"bottom-to-top\" heapify on that element.</p> <p>Each time an element is inserted into the heap, the heap's length increases by one. Since nodes are added to the binary tree sequentially from top to bottom, the heap is constructed \"from top to bottom.\"</p> <p>Given \\(n\\) elements, each element's insertion operation takes \\(O(\\log{n})\\) time, so the time complexity of this heap construction method is \\(O(n \\log n)\\).</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#822-implementing-through-heapify-traversal","level":2,"title":"8.2.2   Implementing Through Heapify Traversal","text":"<p>In fact, we can implement a more efficient heap construction method in two steps.</p> <ol> <li>Add all elements of the list as-is to the heap, at which point the heap property is not yet satisfied.</li> <li>Traverse the heap in reverse order (reverse of level-order traversal), performing \"top-to-bottom heapify\" on each non-leaf node in sequence.</li> </ol> <p>After heapifying a node, the subtree rooted at that node becomes a valid sub-heap. Since we traverse in reverse order, the heap is constructed \"from bottom to top.\"</p> <p>The reason for choosing reverse order traversal is that it ensures the subtree below the current node is already a valid sub-heap, making the heapification of the current node effective.</p> <p>It's worth noting that since leaf nodes have no children, they are naturally valid sub-heaps and do not require heapification. As shown in the code below, the last non-leaf node is the parent of the last node; we start from it and traverse in reverse order to perform heapification:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"Constructor, build heap based on input list\"\"\"\n    # Add list elements to heap as is\n    self.max_heap = nums\n    # Heapify all nodes except leaf nodes\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(vector&lt;int&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = nums;\n    // Heapify all nodes except leaf nodes\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // Heapify all nodes except leaf nodes\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Constructor, build heap from input list */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // Add list elements to heap as is\n    maxHeap = new List&lt;int&gt;(nums);\n    // Heapify all nodes except leaf nodes\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Constructor, build heap from slice */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // Add list elements to heap as is\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // Heapify all nodes except leaf nodes\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* Constructor, build heap based on input list */\ninit(nums: [Int]) {\n    // Add list elements to heap as is\n    maxHeap = nums\n    // Heapify all nodes except leaf nodes\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Constructor, build empty heap or build heap from input list */\nconstructor(nums) {\n    // Add list elements to heap as is\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // Heapify all nodes except leaf nodes\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Constructor, build empty heap or build heap from input list */\nconstructor(nums?: number[]) {\n    // Add list elements to heap as is\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // Heapify all nodes except leaf nodes\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Constructor, build heap based on input list */\nMaxHeap(List&lt;int&gt; nums) {\n  // Add list elements to heap as is\n  _maxHeap = nums;\n  // Heapify all nodes except leaf nodes\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Constructor, build heap based on input list */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // Add list elements to heap as is\n    let mut heap = MaxHeap { max_heap: nums };\n    // Heapify all nodes except leaf nodes\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* Constructor, build heap from slice */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // Push all elements to heap\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // Heapify all nodes except leaf nodes\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* Max heap */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // Use list instead of array, no need to consider capacity expansion\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* Constructor, build heap based on input list */\n    init {\n        // Add list elements to heap as is\n        maxHeap.addAll(nums!!)\n        // Heapify all nodes except leaf nodes\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* Get index of left child node */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Get index of right child node */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Get index of parent node */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // Floor division\n    }\n\n    /* Swap elements */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* Get heap size */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* Check if heap is empty */\n    fun isEmpty(): Boolean {\n        /* Check if heap is empty */\n        return size() == 0\n    }\n\n    /* Access top element */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* Element enters heap */\n    fun push(_val: Int) {\n        // Add node\n        maxHeap.add(_val)\n        // Heapify from bottom to top\n        siftUp(size() - 1)\n    }\n\n    /* Starting from node i, heapify from bottom to top */\n    private fun siftUp(it: Int) {\n        // Kotlin function parameters are immutable, so create temporary variable\n        var i = it\n        while (true) {\n            // Get parent node of node i\n            val p = parent(i)\n            // When \"crossing root node\" or \"node needs no repair\", end heapify\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // Swap two nodes\n            swap(i, p)\n            // Loop upward heapify\n            i = p\n        }\n    }\n\n    /* Element exits heap */\n    fun pop(): Int {\n        // Handle empty case\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Delete node\n        swap(0, size() - 1)\n        // Remove node\n        val _val = maxHeap.removeAt(size() - 1)\n        // Return top element\n        siftDown(0)\n        // Return heap top element\n        return _val\n    }\n\n    /* Starting from node i, heapify from top to bottom */\n    private fun siftDown(it: Int) {\n        // Kotlin function parameters are immutable, so create temporary variable\n        var i = it\n        while (true) {\n            // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // Swap two nodes\n            if (ma == i) break\n            // Swap two nodes\n            swap(i, ma)\n            // Loop downwards heapification\n            i = ma\n        }\n    }\n\n    /* Driver Code */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Constructor, build heap from input list ###\ndef initialize(nums)\n  # Add list elements to heap as is\n  @max_heap = nums\n  # Heapify all nodes except leaf nodes\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/build_heap/#823-complexity-analysis","level":2,"title":"8.2.3   Complexity Analysis","text":"<p>Next, let's attempt to derive the time complexity of this second heap construction method.</p> <ul> <li>Assuming the complete binary tree has \\(n\\) nodes, then the number of leaf nodes is \\((n + 1) / 2\\), where \\(/\\) is floor division. Therefore, the number of nodes that need heapification is \\((n - 1) / 2\\).</li> <li>In the top-to-bottom heapify process, each node is heapified at most to the leaf nodes, so the maximum number of iterations is the binary tree height \\(\\log n\\).</li> </ul> <p>Multiplying these two together, we get a time complexity of \\(O(n \\log n)\\) for the heap construction process. However, this estimate is not accurate because it doesn't account for the property that binary trees have far more nodes at lower levels than at upper levels.</p> <p>Let's perform a more accurate calculation. To reduce calculation difficulty, assume a \"perfect binary tree\" with \\(n\\) nodes and height \\(h\\); this assumption does not affect the correctness of the result.</p> <p></p> <p> Figure 8-5   Node count at each level of a perfect binary tree </p> <p>As shown in Figure 8-5, the maximum number of iterations for a node's \"top-to-bottom heapify\" equals the distance from that node to the leaf nodes, which is precisely the \"node height.\" Therefore, we can sum the \"number of nodes \\(\\times\\) node height\" at each level to obtain the total number of heapify iterations for all nodes.</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>To simplify the above expression, we need to use sequence knowledge from high school. First, multiply \\(T(h)\\) by \\(2\\) to get:</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>Using the method of differences, subtract the first equation \\(T(h)\\) from the second equation \\(2 T(h)\\) to get:</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>Observing the above expression, we find that \\(T(h)\\) is a geometric series, which can be calculated directly using the sum formula, yielding a time complexity of:</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>Furthermore, a perfect binary tree with height \\(h\\) has \\(n = 2^{h+1} - 1\\) nodes, so the complexity is \\(O(2^h) = O(n)\\). This derivation shows that the time complexity of building a heap from an input list is \\(O(n)\\), which is highly efficient.</p>","path":["Chapter 8. Heap","8.2 &nbsp; Heap Construction Operation"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   Heap","text":"<p>A heap is a complete binary tree that satisfies specific conditions and can be mainly categorized into two types, as shown in Figure 8-1.</p> <ul> <li>min heap: The value of any node \\(\\leq\\) the values of its child nodes.</li> <li>max heap: The value of any node \\(\\geq\\) the values of its child nodes.</li> </ul> <p></p> <p> Figure 8-1   Min heap and max heap </p> <p>As a special case of a complete binary tree, heaps have the following characteristics.</p> <ul> <li>The bottom layer nodes are filled from left to right, and nodes in other layers are fully filled.</li> <li>We call the root node of the binary tree the \"heap top\" and the bottom-rightmost node the \"heap bottom.\"</li> <li>For max heaps (min heaps), the value of the heap top element (root node) is the largest (smallest).</li> </ul>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#811-common-heap-operations","level":2,"title":"8.1.1   Common Heap Operations","text":"<p>It should be noted that many programming languages provide a priority queue, which is an abstract data structure defined as a queue with priority sorting.</p> <p>In fact, heaps are typically used to implement priority queues, with max heaps corresponding to priority queues where elements are dequeued in descending order. From a usage perspective, we can regard \"priority queue\" and \"heap\" as equivalent data structures. Therefore, this book does not make a special distinction between the two and uniformly refers to them as \"heap.\"</p> <p>Common heap operations are shown in Table 8-1, and method names need to be determined based on the programming language.</p> <p> Table 8-1   Efficiency of Heap Operations </p> Method name Description Time complexity <code>push()</code> Insert an element into the heap \\(O(\\log n)\\) <code>pop()</code> Remove the heap top element \\(O(\\log n)\\) <code>peek()</code> Access the heap top element (max/min value for max/min heap) \\(O(1)\\) <code>size()</code> Get the number of elements in the heap \\(O(1)\\) <code>isEmpty()</code> Check if the heap is empty \\(O(1)\\) <p>In practical applications, we can directly use the heap class (or priority queue class) provided by programming languages.</p> <p>Similar to \"ascending order\" and \"descending order\" in sorting algorithms, we can implement conversion between \"min heap\" and \"max heap\" by setting a <code>flag</code> or modifying the <code>Comparator</code>. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># Initialize a min heap\nmin_heap, flag = [], 1\n# Initialize a max heap\nmax_heap, flag = [], -1\n\n# Python's heapq module implements a min heap by default\n# Consider negating elements before pushing them to the heap, which inverts the size relationship and thus implements a max heap\n# In this example, flag = 1 corresponds to a min heap, flag = -1 corresponds to a max heap\n\n# Push elements into the heap\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# Get the heap top element\npeek: int = flag * max_heap[0] # 5\n\n# Remove the heap top element\n# The removed elements will form a descending sequence\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# Get the heap size\nsize: int = len(max_heap)\n\n# Check if the heap is empty\nis_empty: bool = not max_heap\n\n# Build a heap from an input list\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* Initialize a heap */\n// Initialize a min heap\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// Initialize a max heap\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* Push elements into the heap */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* Get the heap top element */\nint peek = maxHeap.top(); // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* Get the heap size */\nint size = maxHeap.size();\n\n/* Check if the heap is empty */\nbool isEmpty = maxHeap.empty();\n\n/* Build a heap from an input list */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* Initialize a heap */\n// Initialize a min heap\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// Initialize a max heap (use lambda expression to modify Comparator)\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* Push elements into the heap */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* Get the heap top element */\nint peek = maxHeap.peek(); // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* Get the heap size */\nint size = maxHeap.size();\n\n/* Check if the heap is empty */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* Build a heap from an input list */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* Initialize a heap */\n// Initialize a min heap\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// Initialize a max heap (use lambda expression to modify Comparer)\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* Push elements into the heap */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* Get the heap top element */\nint peek = maxHeap.Peek();//5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* Get the heap size */\nint size = maxHeap.Count;\n\n/* Check if the heap is empty */\nbool isEmpty = maxHeap.Count == 0;\n\n/* Build a heap from an input list */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// In Go, we can construct a max heap of integers by implementing heap.Interface\n// Implementing heap.Interface also requires implementing sort.Interface\ntype intHeap []any\n\n// Push implements the heap.Interface method for pushing an element into the heap\nfunc (h *intHeap) Push(x any) {\n    // Push and Pop use pointer receiver as parameters\n    // because they not only adjust the slice contents but also modify the slice length\n    *h = append(*h, x.(int))\n}\n\n// Pop implements the heap.Interface method for popping the heap top element\nfunc (h *intHeap) Pop() any {\n    // The element to be removed is stored at the end\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len is a sort.Interface method\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less is a sort.Interface method\nfunc (h *intHeap) Less(i, j int) bool {\n    // To implement a min heap, change this to a less-than sign\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap is a sort.Interface method\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top gets the heap top element\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* Initialize a heap */\n    // Initialize a max heap\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* Push elements into the heap */\n    // Call heap.Interface methods to add elements\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* Get the heap top element */\n    top := maxHeap.Top()\n    fmt.Printf(\"Heap top element is %d\\n\", top)\n\n    /* Remove the heap top element */\n    // Call heap.Interface methods to remove elements\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* Get the heap size */\n    size := len(*maxHeap)\n    fmt.Printf(\"Number of heap elements is %d\\n\", size)\n\n    /* Check if the heap is empty */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"Is the heap empty? %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* Initialize a heap */\n// Swift's Heap type supports both max heaps and min heaps, and requires importing swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* Push elements into the heap */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* Get the heap top element */\nvar peek = heap.max()!\n\n/* Remove the heap top element */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* Get the heap size */\nlet size = heap.count\n\n/* Check if the heap is empty */\nlet isEmpty = heap.isEmpty\n\n/* Build a heap from an input list */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript does not provide a built-in Heap class\n</code></pre> heap.ts<pre><code>// TypeScript does not provide a built-in Heap class\n</code></pre> heap.dart<pre><code>// Dart does not provide a built-in Heap class\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* Initialize a heap */\n// Initialize a min heap\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// Initialize a max heap\nlet mut max_heap = BinaryHeap::new();\n\n/* Push elements into the heap */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* Get the heap top element */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* Get the heap size */\nlet size = max_heap.len();\n\n/* Check if the heap is empty */\nlet is_empty = max_heap.is_empty();\n\n/* Build a heap from an input list */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C does not provide a built-in Heap class\n</code></pre> heap.kt<pre><code>/* Initialize a heap */\n// Initialize a min heap\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// Initialize a max heap (use lambda expression to modify Comparator)\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* Push elements into the heap */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* Get the heap top element */\nvar peek = maxHeap.peek() // 5\n\n/* Remove the heap top element */\n// The removed elements will form a descending sequence\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* Get the heap size */\nval size = maxHeap.size\n\n/* Check if the heap is empty */\nval isEmpty = maxHeap.isEmpty()\n\n/* Build a heap from an input list */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby does not provide a built-in Heap class\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#812-implementation-of-the-heap","level":2,"title":"8.1.2   Implementation of the Heap","text":"<p>The following implementation is of a max heap. To convert it to a min heap, simply invert all size logic comparisons (for example, replace \\(\\geq\\) with \\(\\leq\\)). Interested readers are encouraged to implement this on their own.</p>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#1-heap-storage-and-representation","level":3,"title":"1.   Heap Storage and Representation","text":"<p>As mentioned in the \"Binary Tree\" chapter, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, we will use arrays to store heaps.</p> <p>When representing a binary tree with an array, elements represent node values, and indexes represent node positions in the binary tree. Node pointers are implemented through index mapping formulas.</p> <p>As shown in Figure 8-2, given an index \\(i\\), the index of its left child is \\(2i + 1\\), the index of its right child is \\(2i + 2\\), and the index of its parent is \\((i - 1) / 2\\) (floor division). When an index is out of bounds, it indicates a null node or that the node does not exist.</p> <p></p> <p> Figure 8-2   Representation and storage of heaps </p> <p>We can encapsulate the index mapping formula into functions for convenient subsequent use:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"Get index of left child node\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"Get index of right child node\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"Get index of parent node\"\"\"\n    return (i - 1) // 2  # Floor division\n</code></pre> my_heap.cpp<pre><code>/* Get index of left child node */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.java<pre><code>/* Get index of left child node */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.cs<pre><code>/* Get index of left child node */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint Parent(int i) {\n    return (i - 1) / 2; // Floor division\n}\n</code></pre> my_heap.go<pre><code>/* Get index of left child node */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* Get index of right child node */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* Get index of parent node */\nfunc (h *maxHeap) parent(i int) int {\n    // Floor division\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* Get index of left child node */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* Get index of right child node */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* Get index of parent node */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.js<pre><code>/* Get index of left child node */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // Floor division\n}\n</code></pre> my_heap.ts<pre><code>/* Get index of left child node */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // Floor division\n}\n</code></pre> my_heap.dart<pre><code>/* Get index of left child node */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // Floor division\n}\n</code></pre> my_heap.rs<pre><code>/* Get index of left child node */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* Get index of right child node */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* Get index of parent node */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.c<pre><code>/* Get index of left child node */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* Get index of right child node */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* Get index of parent node */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // Round down\n}\n</code></pre> my_heap.kt<pre><code>/* Get index of left child node */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* Get index of right child node */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* Get index of parent node */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // Floor division\n}\n</code></pre> my_heap.rb<pre><code>### Get left child index ###\ndef left(i)\n  2 * i + 1\nend\n\n### Get right child index ###\ndef right(i)\n  2 * i + 2\nend\n\n### Get parent node index ###\ndef parent(i)\n  (i - 1) / 2     # Floor division\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#2-accessing-the-heap-top-element","level":3,"title":"2.   Accessing the Heap Top Element","text":"<p>The heap top element is the root node of the binary tree, which is also the first element of the list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"Access top element\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* Access top element */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* Access top element */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* Access top element */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* Access top element */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* Access top element */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* Access top element */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* Access top element */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* Access top element */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* Access top element */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* Access top element */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* Access top element */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### Access heap top element ###\ndef peek\n  @max_heap[0]\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#3-inserting-an-element-into-the-heap","level":3,"title":"3.   Inserting an Element Into the Heap","text":"<p>Given an element <code>val</code>, we first add it to the bottom of the heap. After addition, since <code>val</code> may be larger than other elements in the heap, the heap's property may be violated. Therefore, it's necessary to repair the path from the inserted node to the root node. This operation is called heapify.</p> <p>Starting from the inserted node, perform heapify from bottom to top. As shown in Figure 8-3, we compare the inserted node with its parent node, and if the inserted node is larger, swap them. Then continue this operation, repairing nodes in the heap from bottom to top until we pass the root node or encounter a node that does not need swapping.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-3   Steps of inserting an element into the heap </p> <p>Given a total of \\(n\\) nodes, the tree height is \\(O(\\log n)\\). Thus, the number of loop iterations in the heapify operation is at most \\(O(\\log n)\\), making the time complexity of the element insertion operation \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"Element enters heap\"\"\"\n    # Add node\n    self.max_heap.append(val)\n    # Heapify from bottom to top\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"Starting from node i, heapify from bottom to top\"\"\"\n    while True:\n        # Get parent node of node i\n        p = self.parent(i)\n        # When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # Swap two nodes\n        self.swap(i, p)\n        # Loop upward heapify\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* Element enters heap */\nvoid push(int val) {\n    // Add node\n    maxHeap.push_back(val);\n    // Heapify from bottom to top\n    siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Swap two nodes\n        swap(maxHeap[i], maxHeap[p]);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Element enters heap */\nvoid push(int val) {\n    // Add node\n    maxHeap.add(val);\n    // Heapify from bottom to top\n    siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // Swap two nodes\n        swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Element enters heap */\nvoid Push(int val) {\n    // Add node\n    maxHeap.Add(val);\n    // Heapify from bottom to top\n    SiftUp(Size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid SiftUp(int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = Parent(i);\n        // If 'past root node' or 'node needs no repair', end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Swap two nodes\n        Swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Element enters heap */\nfunc (h *maxHeap) push(val any) {\n    // Add node\n    h.data = append(h.data, val)\n    // Heapify from bottom to top\n    h.siftUp(len(h.data) - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // Get parent node of node i\n        p := h.parent(i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // Swap two nodes\n        h.swap(i, p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Element enters heap */\nfunc push(val: Int) {\n    // Add node\n    maxHeap.append(val)\n    // Heapify from bottom to top\n    siftUp(i: size() - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // Get parent node of node i\n        let p = parent(i: i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // Swap two nodes\n        swap(i: i, j: p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Element enters heap */\npush(val) {\n    // Add node\n    this.#maxHeap.push(val);\n    // Heapify from bottom to top\n    this.#siftUp(this.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\n#siftUp(i) {\n    while (true) {\n        // Get parent node of node i\n        const p = this.#parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // Swap two nodes\n        this.#swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Element enters heap */\npush(val: number): void {\n    // Add node\n    this.maxHeap.push(val);\n    // Heapify from bottom to top\n    this.siftUp(this.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nsiftUp(i: number): void {\n    while (true) {\n        // Get parent node of node i\n        const p = this.parent(i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // Swap two nodes\n        this.swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Element enters heap */\nvoid push(int val) {\n  // Add node\n  _maxHeap.add(val);\n  // Heapify from bottom to top\n  siftUp(size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(int i) {\n  while (true) {\n    // Get parent node of node i\n    int p = _parent(i);\n    // When \"crossing root node\" or \"node needs no repair\", end heapify\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // Swap two nodes\n    _swap(i, p);\n    // Loop upward heapify\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Element enters heap */\nfn push(&amp;mut self, val: i32) {\n    // Add node\n    self.max_heap.push(val);\n    // Heapify from bottom to top\n    self.sift_up(self.size() - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // Node i is already the heap root, end heapification\n        if i == 0 {\n            break;\n        }\n        // Get parent node of node i\n        let p = Self::parent(i);\n        // When \"node needs no repair\", end heapification\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // Swap two nodes\n        self.swap(i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Element enters heap */\nvoid push(MaxHeap *maxHeap, int val) {\n    // By default, should not add this many nodes\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // Add node\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // Heapify from bottom to top\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* Starting from node i, heapify from bottom to top */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Get parent node of node i\n        int p = parent(maxHeap, i);\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // Swap two nodes\n        swap(maxHeap, i, p);\n        // Loop upward heapify\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Element enters heap */\nfun push(_val: Int) {\n    // Add node\n    maxHeap.add(_val)\n    // Heapify from bottom to top\n    siftUp(size() - 1)\n}\n\n/* Starting from node i, heapify from bottom to top */\nfun siftUp(it: Int) {\n    // Kotlin function parameters are immutable, so create temporary variable\n    var i = it\n    while (true) {\n        // Get parent node of node i\n        val p = parent(i)\n        // When \"crossing root node\" or \"node needs no repair\", end heapify\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // Swap two nodes\n        swap(i, p)\n        // Loop upward heapify\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Push element to heap ###\ndef push(val)\n  # Add node\n  @max_heap &lt;&lt; val\n  # Heapify from bottom to top\n  sift_up(size - 1)\nend\n\n### Heapify from node i, bottom to top ###\ndef sift_up(i)\n  loop do\n    # Get parent node of node i\n    p = parent(i)\n    # When \"crossing root node\" or \"node needs no repair\", end heapify\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # Swap two nodes\n    swap(i, p)\n    # Loop upward heapify\n    i = p\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#4-removing-the-heap-top-element","level":3,"title":"4.   Removing the Heap Top Element","text":"<p>The heap top element is the root node of the binary tree, which is the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making subsequent repair with heapify difficult. To minimize changes in element indexes, we use the following steps.</p> <ol> <li>Swap the heap top element with the heap bottom element (swap the root node with the rightmost leaf node).</li> <li>After swapping, remove the heap bottom from the list (note that since we've swapped, we're actually removing the original heap top element).</li> <li>Starting from the root node, perform heapify from top to bottom.</li> </ol> <p>As shown in Figure 8-4, the direction of \"top-to-bottom heapify\" is opposite to \"bottom-to-top heapify\". We compare the root node's value with its two children and swap it with the largest child. Then loop this operation until we pass a leaf node or encounter a node that doesn't need swapping.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-4   Steps of removing the heap top element </p> <p>Similar to the element insertion operation, the time complexity of the heap top element removal operation is also \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"Element exits heap\"\"\"\n    # Handle empty case\n    if self.is_empty():\n        raise IndexError(\"Heap is empty\")\n    # Swap root node with rightmost leaf node (swap first element with last element)\n    self.swap(0, self.size() - 1)\n    # Delete node\n    val = self.max_heap.pop()\n    # Heapify from top to bottom\n    self.sift_down(0)\n    # Return top element\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"Starting from node i, heapify from top to bottom\"\"\"\n    while True:\n        # Find node with largest value among i, l, r, denoted as ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        if ma == i:\n            break\n        # Swap two nodes\n        self.swap(i, ma)\n        # Loop downward heapify\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* Element exits heap */\nvoid pop() {\n    // Handle empty case\n    if (isEmpty()) {\n        throw out_of_range(\"Heap is empty\");\n    }\n    // Delete node\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // Remove node\n    maxHeap.pop_back();\n    // Return top element\n    siftDown(0);\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Element exits heap */\nint pop() {\n    // Handle empty case\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // Delete node\n    swap(0, size() - 1);\n    // Remove node\n    int val = maxHeap.remove(size() - 1);\n    // Return top element\n    siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Element exits heap */\nint Pop() {\n    // Handle empty case\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // Delete node\n    Swap(0, Size() - 1);\n    // Remove node\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // Return top element\n    SiftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid SiftDown(int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // If 'node i is largest' or 'past leaf node', end heapify\n        if (ma == i) break;\n        // Swap two nodes\n        Swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Element exits heap */\nfunc (h *maxHeap) pop() any {\n    // Handle empty case\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // Delete node\n    h.swap(0, h.size()-1)\n    // Remove node\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // Return top element\n    h.siftDown(0)\n\n    // Return heap top element\n    return val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // Find node with maximum value among nodes i, l, r, denoted as max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // Swap two nodes\n        if max == i {\n            break\n        }\n        // Swap two nodes\n        h.swap(i, max)\n        // Loop downwards heapification\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Element exits heap */\nfunc pop() -&gt; Int {\n    // Handle empty case\n    if isEmpty() {\n        fatalError(\"Heap is empty\")\n    }\n    // Delete node\n    swap(i: 0, j: size() - 1)\n    // Remove node\n    let val = maxHeap.remove(at: size() - 1)\n    // Return top element\n    siftDown(i: 0)\n    // Return heap top element\n    return val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        swap(i: i, j: ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Element exits heap */\npop() {\n    // Handle empty case\n    if (this.isEmpty()) throw new Error('Heap is empty');\n    // Delete node\n    this.#swap(0, this.size() - 1);\n    // Remove node\n    const val = this.#maxHeap.pop();\n    // Return top element\n    this.#siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\n#siftDown(i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // Swap two nodes\n        if (ma === i) break;\n        // Swap two nodes\n        this.#swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Element exits heap */\npop(): number {\n    // Handle empty case\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // Delete node\n    this.swap(0, this.size() - 1);\n    // Remove node\n    const val = this.maxHeap.pop();\n    // Return top element\n    this.siftDown(0);\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nsiftDown(i: number): void {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // Swap two nodes\n        if (ma === i) break;\n        // Swap two nodes\n        this.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Element exits heap */\nint pop() {\n  // Handle empty case\n  if (isEmpty()) throw Exception('Heap is empty');\n  // Delete node\n  _swap(0, size() - 1);\n  // Remove node\n  int val = _maxHeap.removeLast();\n  // Return top element\n  siftDown(0);\n  // Return heap top element\n  return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(int i) {\n  while (true) {\n    // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // Swap two nodes\n    if (ma == i) break;\n    // Swap two nodes\n    _swap(i, ma);\n    // Loop downwards heapification\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Element exits heap */\nfn pop(&amp;mut self) -&gt; i32 {\n    // Handle empty case\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // Delete node\n    self.swap(0, self.size() - 1);\n    // Remove node\n    let val = self.max_heap.pop().unwrap();\n    // Return top element\n    self.sift_down(0);\n    // Return heap top element\n    val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // Swap two nodes\n        if ma == i {\n            break;\n        }\n        // Swap two nodes\n        self.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Element exits heap */\nint pop(MaxHeap *maxHeap) {\n    // Handle empty case\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // Delete node\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // Remove node\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // Return top element\n    siftDown(maxHeap, 0);\n\n    // Return heap top element\n    return val;\n}\n\n/* Starting from node i, heapify from top to bottom */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Find node with maximum value among nodes i, l, r, denoted as max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // Swap two nodes\n        if (max == i) {\n            break;\n        }\n        // Swap two nodes\n        swap(maxHeap, i, max);\n        // Loop downwards heapification\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Element exits heap */\nfun pop(): Int {\n    // Handle empty case\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // Delete node\n    swap(0, size() - 1)\n    // Remove node\n    val _val = maxHeap.removeAt(size() - 1)\n    // Return top element\n    siftDown(0)\n    // Return heap top element\n    return _val\n}\n\n/* Starting from node i, heapify from top to bottom */\nfun siftDown(it: Int) {\n    // Kotlin function parameters are immutable, so create temporary variable\n    var i = it\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // Swap two nodes\n        if (ma == i) break\n        // Swap two nodes\n        swap(i, ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Pop element from heap ###\ndef pop\n  # Handle empty case\n  raise IndexError, \"Heap is empty\" if is_empty?\n  # Delete node\n  swap(0, size - 1)\n  # Remove node\n  val = @max_heap.pop\n  # Return top element\n  sift_down(0)\n  # Return heap top element\n  val\nend\n\n### Heapify from node i, top to bottom ###\ndef sift_down(i)\n  loop do\n    # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # Swap two nodes\n    break if ma == i\n\n    # Swap two nodes\n    swap(i, ma)\n    # Loop downwards heapification\n    i = ma\n  end\nend\n</code></pre>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/heap/#813-common-applications-of-heaps","level":2,"title":"8.1.3   Common Applications of Heaps","text":"<ul> <li>Priority queue: Heaps are typically the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of \\(O(\\log n)\\), and the heap construction operation having \\(O(n)\\), all of which are highly efficient.</li> <li>Heap sort: Given a set of data, we can build a heap with them and then continuously perform element removal operations to obtain sorted data. However, we usually use a more elegant approach to implement heap sort, as detailed in the \"Heap Sort\" chapter.</li> <li>Getting the largest \\(k\\) elements: This is a classic algorithm problem and also a typical application, such as selecting the top 10 trending news for Weibo hot search, selecting the top 10 best-selling products, etc.</li> </ul>","path":["Chapter 8. Heap","8.1 &nbsp; Heap"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   Summary","text":"","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A heap is a complete binary tree that can be categorized as a max heap or min heap based on its property. The heap top element of a max heap (min heap) is the largest (smallest).</li> <li>A priority queue is defined as a queue with priority sorting, typically implemented using heaps.</li> <li>Common heap operations and their corresponding time complexities include: element insertion \\(O(\\log n)\\), heap top element removal \\(O(\\log n)\\), and accessing the heap top element \\(O(1)\\).</li> <li>Complete binary trees are well-suited for array representation, so we typically use arrays to store heaps.</li> <li>Heapify operations are used to maintain the heap property and are employed in both element insertion and removal operations.</li> <li>The time complexity of building a heap with \\(n\\) input elements can be optimized to \\(O(n)\\), which is highly efficient.</li> <li>Top-k is a classic algorithm problem that can be efficiently solved using the heap data structure, with a time complexity of \\(O(n \\log k)\\).</li> </ul>","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Are the \"heap\" in data structures and the \"heap\" in memory management the same concept?</p> <p>The two are not the same concept; they just happen to share the name \"heap.\" The heap in computer system memory is part of dynamic memory allocation, where programs can use it to store data during runtime. Programs can request a certain amount of heap memory to store complex structures such as objects and arrays. When this data is no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, heap memory management and usage require more caution, as improper use can lead to issues such as memory leaks and dangling pointers.</p>","path":["Chapter 8. Heap","8.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-K Problem","text":"<p>Question</p> <p>Given an unordered array <code>nums</code> of length \\(n\\), return the largest \\(k\\) elements in the array.</p> <p>For this problem, we'll first introduce two solutions with relatively straightforward approaches, then introduce a more efficient heap-based solution.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#831-method-1-iterative-selection","level":2,"title":"8.3.1   Method 1: Iterative Selection","text":"<p>We can perform \\(k\\) rounds of traversal as shown in Figure 8-6, extracting the \\(1^{st}\\), \\(2^{nd}\\), \\(\\dots\\), \\(k^{th}\\) largest elements in each round, with a time complexity of \\(O(nk)\\).</p> <p>This method is only suitable when \\(k \\ll n\\), because when \\(k\\) is close to \\(n\\), the time complexity approaches \\(O(n^2)\\), which is very time-consuming.</p> <p></p> <p> Figure 8-6   Traversing to find the largest k elements </p> <p>Tip</p> <p>When \\(k = n\\), we can obtain a complete sorted sequence, which is equivalent to the \"selection sort\" algorithm.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#832-method-2-sorting","level":2,"title":"8.3.2   Method 2: Sorting","text":"<p>As shown in Figure 8-7, we can first sort the array <code>nums</code>, then return the rightmost \\(k\\) elements, with a time complexity of \\(O(n \\log n)\\).</p> <p>Clearly, this method \"overachieves\" the task, as we only need to find the largest \\(k\\) elements, without needing to sort the other elements.</p> <p></p> <p> Figure 8-7   Sorting to find the largest k elements </p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_heap/top_k/#833-method-3-heap","level":2,"title":"8.3.3   Method 3: Heap","text":"<p>We can solve the Top-k problem more efficiently using heaps, with the process shown in Figure 8-8.</p> <ol> <li>Initialize a min heap, where the heap top element is the smallest.</li> <li>First, insert the first \\(k\\) elements of the array into the heap in sequence.</li> <li>Starting from the \\((k + 1)^{th}\\) element, if the current element is greater than the heap top element, remove the heap top element and insert the current element into the heap.</li> <li>After traversal is complete, the heap contains the largest \\(k\\) elements.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 8-8   Finding the largest k elements using a heap </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"Find the largest k elements in array based on heap\"\"\"\n    # Initialize min heap\n    heap = []\n    # Enter the first k elements of array into heap\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # Starting from the (k+1)th element, maintain heap length as k\n    for i in range(k, len(nums)):\n        # If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* Find the largest k elements in array based on heap */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // Python's heapq module implements min heap by default\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* Find the largest k elements in array based on heap */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // Python's heapq module implements min heap by default\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* Find the largest k elements in array based on heap */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // Python's heapq module implements min heap by default\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* Find the largest k elements in array based on heap */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // Python's heapq module implements min heap by default\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // Enter the first k elements of array into heap\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for i := k; i &lt; len(nums); i++ {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* Find the largest k elements in array based on heap */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // Initialize min heap and build heap with first k elements\n    var heap = Heap(nums.prefix(k))\n    // Starting from the (k+1)th element, maintain heap length as k\n    for i in nums.indices.dropFirst(k) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* Element enters heap */\nfunction pushMinHeap(maxHeap, val) {\n    // Negate element\n    maxHeap.push(-val);\n}\n\n/* Element exits heap */\nfunction popMinHeap(maxHeap) {\n    // Negate element\n    return -maxHeap.pop();\n}\n\n/* Access top element */\nfunction peekMinHeap(maxHeap) {\n    // Negate element\n    return -maxHeap.peek();\n}\n\n/* Extract elements from heap */\nfunction getMinHeap(maxHeap) {\n    // Negate element\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* Find the largest k elements in array based on heap */\nfunction topKHeap(nums, k) {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    const maxHeap = new MaxHeap([]);\n    // Enter the first k elements of array into heap\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (let i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Return elements in heap\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* Element enters heap */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // Negate element\n    maxHeap.push(-val);\n}\n\n/* Element exits heap */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // Negate element\n    return -maxHeap.pop();\n}\n\n/* Access top element */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // Negate element\n    return -maxHeap.peek();\n}\n\n/* Extract elements from heap */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // Negate element\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* Find the largest k elements in array based on heap */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    const maxHeap = new MaxHeap([]);\n    // Enter the first k elements of array into heap\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (let i = k; i &lt; nums.length; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Return elements in heap\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* Find the largest k elements in array based on heap */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // Initialize min heap, push first k elements of array to heap\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // Starting from the (k+1)th element, maintain heap length as k\n  for (int i = k; i &lt; nums.length; i++) {\n    // If current element is greater than top element, top element exits heap, current element enters heap\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* Find the largest k elements in array based on heap */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap is a max heap, use Reverse to negate elements to implement min heap\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // Enter the first k elements of array into heap\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for &amp;num in nums.iter().skip(k) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* Element enters heap */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // Negate element\n    push(maxHeap, -val);\n}\n\n/* Element exits heap */\nint popMinHeap(MaxHeap *maxHeap) {\n    // Negate element\n    return -pop(maxHeap);\n}\n\n/* Access top element */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // Negate element\n    return -peek(maxHeap);\n}\n\n/* Extract elements from heap */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Negate all heap elements and store in res array\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* Extract elements from heap */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Negate all heap elements and store in res array\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// Function to find k largest elements in array using heap\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // Python's heapq module implements min heap by default\n    // Note: We negate all heap elements to simulate min heap using max heap\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // Enter the first k elements of array into heap\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // Free memory\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* Find the largest k elements in array based on heap */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // Python's heapq module implements min heap by default\n    val heap = PriorityQueue&lt;Int&gt;()\n    // Enter the first k elements of array into heap\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // Starting from the (k+1)th element, maintain heap length as k\n    for (i in k..&lt;nums.size) {\n        // If current element is greater than top element, top element exits heap, current element enters heap\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### Find largest k elements in array using heap ###\ndef top_k_heap(nums, k)\n  # Python's heapq module implements min heap by default\n  # Note: We negate all heap elements to simulate min heap using max heap\n  max_heap = MaxHeap.new([])\n\n  # Enter the first k elements of array into heap\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # Starting from the (k+1)th element, maintain heap length as k\n  for i in k...nums.length\n    # If current element is greater than top element, top element exits heap, current element enters heap\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> <p>A total of \\(n\\) rounds of heap insertions and removals are performed, with the heap's maximum length being \\(k\\), so the time complexity is \\(O(n \\log k)\\). This method is very efficient; when \\(k\\) is small, the time complexity approaches \\(O(n)\\); when \\(k\\) is large, the time complexity does not exceed \\(O(n \\log n)\\).</p> <p>Additionally, this method is suitable for dynamic data stream scenarios. By continuously adding data, we can maintain the elements in the heap, thus achieving dynamic updates of the largest \\(k\\) elements.</p>","path":["Chapter 8. Heap","8.3 &nbsp; Top-K Problem"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"Before Starting","text":"<p>A few years ago, I shared the \"Sword for Offer\" problem solutions on LeetCode, receiving encouragement and support from many readers. During interactions with readers, the most frequently asked question I encountered was \"how to get started with algorithms.\" Gradually, I developed a keen interest in this question.</p> <p>Diving straight into problem-solving seems to be the most popular approach—it's simple, direct, and effective. However, problem-solving is like playing Minesweeper: those with strong self-learning abilities can successfully defuse the mines one by one, while those with insufficient foundations may end up bruised and battered, retreating step by step in frustration. Reading through textbooks is also a common practice, but for job seekers, graduation theses, resume submissions, and preparations for written tests and interviews have already consumed most of their energy, making working through thick books an arduous challenge.</p> <p>If you're facing similar struggles, then it's fortunate that this book has \"found\" you. This book is my answer to this question—even if it may not be the optimal solution, it is at least a positive attempt. While this book alone won't directly land you a job offer, it will guide you to explore the \"knowledge map\" of data structures and algorithms, help you understand the shapes, sizes, and distributions of different \"mines,\" and enable you to master various \"mine-clearing methods.\" With these skills, I believe you can tackle problems and read technical literature more confidently, gradually building a complete knowledge system.</p> <p>I deeply agree with Professor Feynman's words: \"Knowledge isn't free. You have to pay attention.\" In this sense, this book is not entirely \"free.\" In order to live up to the precious \"attention\" you invest in this book, I will do my utmost and devote my greatest \"attention\" to completing this work.</p> <p>I'm acutely aware of my limited knowledge and shallow expertise. Although the content of this book has been refined over a period of time, there are certainly still many errors, and I sincerely welcome critiques and corrections from teachers and fellow students.</p> <p></p> Hello, Algorithms! <p>The advent of computers has brought tremendous changes to the world. With their high-speed computing capabilities and excellent programmability, they have become the ideal medium for executing algorithms and processing data. Whether it's the realistic graphics in video games, the intelligent decision-making in autonomous driving, AlphaGo's brilliant Go matches, or ChatGPT's natural interactions, these applications are all exquisite interpretations of algorithms on computers.</p> <p>In fact, before the advent of computers, algorithms and data structures already existed in every corner of the world. Early algorithms were relatively simple, such as ancient counting methods and tool-making procedures. As civilization progressed, algorithms gradually became more refined and complex. From the ingenious craftsmanship of master artisans, to industrial products that liberate productive forces, to the scientific laws governing the operation of the universe, behind almost every ordinary or astonishing thing lies ingenious algorithmic thinking.</p> <p>Similarly, data structures are everywhere: from large-scale social networks to small subway systems, many systems can be modeled as \"graphs\"; from a nation to a family, the primary organizational forms of society exhibit characteristics of \"trees\"; winter clothing is like a \"stack,\" where the first item put on is the last to be taken off; a badminton tube is like a \"queue,\" with items inserted at one end and retrieved from the other; a dictionary is like a \"hash table,\" enabling quick lookup of target entries.</p> <p>This book aims to help readers understand the core concepts of algorithms and data structures through clear and accessible animated illustrations and runnable code examples, and to implement them through programming. Building on this foundation, the book endeavors to reveal the vivid manifestations of algorithms in the complex world and showcase the beauty of algorithms. I hope this book can be of help to you!</p>","path":["Before Starting"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"Chapter 1.   Encounter with Algorithms","text":"<p>Abstract</p> <p>A young girl dances gracefully, intertwined with data, her skirt flowing with the melody of algorithms.</p> <p>She invites you to dance with her. Follow her steps closely and enter the world of algorithms, full of logic and beauty.</p>","path":["Chapter 1. Encounter With Algorithms","Chapter 1. &nbsp; Encounter with Algorithms"],"tags":[]},{"location":"chapter_introduction/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>1.1   Algorithms Are Everywhere</li> <li>1.2   What Is an Algorithm</li> <li>1.3   Summary</li> </ul>","path":["Chapter 1. Encounter With Algorithms","Chapter 1. &nbsp; Encounter with Algorithms"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   Algorithms Are Everywhere","text":"<p>When we hear the term \"algorithm,\" we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives.</p> <p>Before we start discussing about algorithms officially, there's an interesting fact worth sharing: you've learned many algorithms unconsciously and are used to applying them in your daily life. Here, I will give a few specific examples to prove this point.</p> <p>Example 1: Looking Up a Dictionary. In an English dictionary, words are listed alphabetically. Assuming we're searching for a word that starts with the letter \\(r\\), this is typically done in the following way:</p> <ol> <li>Open the dictionary to about halfway and check the first vocabulary of the page, let's say the letter starts with \\(m\\).</li> <li>Since \\(r\\) comes after \\(m\\) in the alphabet, the first half can be ignored and the search space is narrowed down to the second half.</li> <li>Repeat steps <code>1.</code> and <code>2.</code> until you find the page where the word starts with \\(r\\).</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 1-1   Process of looking up a dictionary </p> <p>Looking up a dictionary, an essential skill for elementary school students is actually the famous \"Binary Search\" algorithm. From a data structure perspective, we can consider the dictionary as a sorted \"array\"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as the algorithm \"Binary Search.\"</p> <p>Example 2: Organizing Card Deck. When playing cards, we need to arrange the cards in our hands in ascending order, as shown in the following process.</p> <ol> <li>Divide the playing cards into \"ordered\" and \"unordered\" sections, assuming initially the leftmost card is already in order.</li> <li>Take out a card from the unordered section and insert it into the correct position in the ordered section; after this, the leftmost two cards are in order.</li> <li>Repeat step <code>2</code> until all cards are in order.</li> </ol> <p></p> <p> Figure 1-2   Process of sorting a deck of cards </p> <p>The above method of organizing playing cards is practically the \"Insertion Sort\" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort.</p> <p>Example 3: Making Change. Assume making a purchase of \\(69\\) at a supermarket. If you give the cashier \\(100\\), they will need to provide you with \\(31\\) in change. This process can be clearly understood as illustrated in Figure 1-3.</p> <ol> <li>The options are currencies valued below \\(31\\), including \\(1\\), \\(5\\), \\(10\\), and \\(20\\).</li> <li>Take out the largest \\(20\\) from the options, leaving \\(31 - 20 = 11\\).</li> <li>Take out the largest \\(10\\) from the remaining options, leaving \\(11 - 10 = 1\\).</li> <li>Take out the largest \\(1\\) from the remaining options, leaving \\(1 - 1 = 0\\).</li> <li>Complete change-making, the solution is \\(20 + 10 + 1 = 31\\).</li> </ol> <p></p> <p> Figure 1-3   Process of making change </p> <p>In the steps described, we choose the best option at each stage by utilizing the largest denomination available, which leads to an effective change-making strategy. From a data structures and algorithms perspective, this approach is known as a \"Greedy\" algorithm.</p> <p>From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers and solve various complex issues in a more efficient way.</p> <p>Tip</p> <p>If you are still confused about concepts like data structures, algorithms, arrays, and binary searches, I encourage you to keep reading. This book will gently guide you into the realm of understanding data structures and algorithms.</p>","path":["Chapter 1. Encounter With Algorithms","1.1 &nbsp; Algorithms Are Everywhere"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   Summary","text":"","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Algorithms are ubiquitous in daily life and are not distant, esoteric knowledge. In fact, we have already learned many algorithms unconsciously and use them to solve problems big and small in life.</li> <li>The principle of looking up a dictionary is consistent with the binary search algorithm. Binary search embodies the important algorithmic idea of divide and conquer.</li> <li>The process of organizing playing cards is very similar to the insertion sort algorithm. Insertion sort is suitable for sorting small datasets.</li> <li>The steps of making change are essentially a greedy algorithm, where the best choice is made at each step based on the current situation.</li> <li>An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time, while a data structure is the way computers organize and store data.</li> <li>Data structures and algorithms are closely connected. Data structures are the foundation of algorithms, and algorithms breathe life into data structures.</li> <li>We can compare data structures and algorithms to assembling building blocks. The blocks represent data, the shape and connection method of the blocks represent the data structure, and the steps to assemble the blocks correspond to the algorithm.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: As a programmer, I have never used algorithms to solve problems in my daily work. Common algorithms are already encapsulated by programming languages and can be used directly. Does this mean that the problems in our work have not yet reached the level where algorithms are needed?</p> <p>If we compare specific work skills to \"techniques\" in martial arts, then fundamental subjects should be more like \"internal skills\".</p> <p>I believe the significance of learning algorithms (and other fundamental subjects) is not to implement them from scratch at work, but rather to be able to make professional reactions and judgments when solving problems based on the knowledge learned, thereby improving the overall quality of work. Here is a simple example. Every programming language has a built-in sorting function:</p> <ul> <li>If we have not studied data structures and algorithms, we might simply feed any given data to this sorting function. It runs smoothly with good performance, and there doesn't seem to be any problem.</li> <li>But if we have studied algorithms, we would know that the time complexity of the built-in sorting function is \\(O(n \\log n)\\). However, if the given data consists of integers with a fixed number of digits (such as student IDs), we can use the more efficient \"radix sort\", reducing the time complexity to \\(O(nk)\\), where \\(k\\) is the number of digits. When the data volume is very large, the saved running time can create significant value (reduced costs, improved experience, etc.).</li> </ul> <p>In the field of engineering, a large number of problems are difficult to reach optimal solutions, and many problems are only solved \"approximately\". The difficulty of a problem depends on one hand on the nature of the problem itself, and on the other hand on the knowledge reserve of the person observing the problem. The more complete a person's knowledge and the more experience they have, the deeper their analysis of the problem will be, and the more elegantly the problem can be solved.</p>","path":["Chapter 1. Encounter With Algorithms","1.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   What Is an Algorithm","text":"","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121-algorithm-definition","level":2,"title":"1.2.1   Algorithm Definition","text":"<p>An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time. It has the following characteristics.</p> <ul> <li>The problem is well-defined, with clear input and output definitions.</li> <li>It is feasible and can be completed within a finite number of steps, time, and memory space.</li> <li>Each step has a definite meaning, and under the same input and operating conditions, the output is always the same.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122-data-structure-definition","level":2,"title":"1.2.2   Data Structure Definition","text":"<p>A data structure is a way of organizing and storing data, covering the data content, relationships between data, and methods for data operations. It has the following design objectives.</p> <ul> <li>Occupy as little space as possible to save computer memory.</li> <li>Data operations should be as fast as possible, covering data access, addition, deletion, update, etc.</li> <li>Provide a concise data representation and logical information so that algorithms can run efficiently.</li> </ul> <p>Data structure design is a process full of trade-offs. If we want to achieve improvements in one aspect, we often need to make compromises in another aspect. Here are two examples.</p> <ul> <li>Compared to arrays, linked lists are more convenient for data addition and deletion operations but sacrifice data access speed.</li> <li>Compared to linked lists, graphs provide richer logical information but require larger memory space.</li> </ul>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123-the-relationship-between-data-structures-and-algorithms","level":2,"title":"1.2.3   The Relationship Between Data Structures and Algorithms","text":"<p>As shown in Figure 1-4, data structures and algorithms are highly related and tightly coupled, specifically manifested in the following three aspects.</p> <ul> <li>Data structures are the foundation of algorithms. Data structures provide algorithms with structured storage of data and methods for operating on data.</li> <li>Algorithms breathe life into data structures. Data structures themselves only store data information; combined with algorithms, they can solve specific problems.</li> <li>Algorithms can usually be implemented based on different data structures, but execution efficiency may vary greatly. Choosing the appropriate data structure is key.</li> </ul> <p></p> <p> Figure 1-4   The relationship between data structures and algorithms </p> <p>Data structures and algorithms are like assembling building blocks as shown in Figure 1-5. A set of building blocks, in addition to containing many parts, also comes with detailed assembly instructions. By following the instructions step by step, we can assemble an exquisite building block model.</p> <p></p> <p> Figure 1-5   Assembling blocks </p> <p>The detailed correspondence between the two is shown in Table 1-1.</p> <p> Table 1-1   Comparing data structures and algorithms to assembling building blocks </p> Data structures and algorithms Assembling building blocks Input data Unassembled building blocks Data structure Organization form of building blocks, including shape, size, connection method, etc. Algorithm A series of operational steps to assemble the blocks into the target form Output data Building block model <p>It is worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations based on multiple programming languages.</p> <p>Conventional abbreviation</p> <p>In actual discussions, we usually abbreviate \"data structures and algorithms\" as \"algorithms\". For example, the well-known LeetCode algorithm problems actually examine knowledge of both data structures and algorithms.</p>","path":["Chapter 1. Encounter With Algorithms","1.2 &nbsp; What Is an Algorithm"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"Chapter 0.   Preface","text":"<p>Abstract</p> <p>Algorithms are like a beautiful symphony, each line of code flows like a melody.</p> <p>May this book gently resonate in your mind, leaving a unique and profound melody.</p>","path":["Chapter 0. Preface","Chapter 0. &nbsp; Preface"],"tags":[]},{"location":"chapter_preface/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>0.1   About This Book</li> <li>0.2   How to Use This Book</li> <li>0.3   Summary</li> </ul>","path":["Chapter 0. Preface","Chapter 0. &nbsp; Preface"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   About This Book","text":"<p>This project aims to create an open-source, free, beginner-friendly introductory tutorial on data structures and algorithms.</p> <ul> <li>The entire book uses animated illustrations, with clear and easy-to-understand content and a smooth learning curve, guiding beginners to explore the knowledge map of data structures and algorithms.</li> <li>The source code can be run with one click, helping readers improve their programming skills through practice and understand how algorithms work and the underlying implementation of data structures.</li> <li>We encourage readers to learn from each other, and everyone is welcome to ask questions and share insights in the comments section, making progress together through discussion and exchange.</li> </ul>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#011-target-audience","level":2,"title":"0.1.1   Target Audience","text":"<p>If you are an algorithm beginner who has never been exposed to algorithms, or if you already have some problem-solving experience and have a vague understanding of data structures and algorithms, oscillating between knowing and not knowing, then this book is tailor-made for you!</p> <p>If you have already accumulated a certain amount of problem-solving experience and are familiar with most question types, this book can help you review and organize your algorithm knowledge system, and the repository's source code can be used as a \"problem-solving toolkit\" or \"algorithm dictionary.\"</p> <p>If you are an algorithm \"expert,\" we look forward to receiving your valuable suggestions, or participating in creation together.</p> <p>Prerequisites</p> <p>You need to have at least a programming foundation in any language, and be able to read and write simple code.</p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#012-content-structure","level":2,"title":"0.1.2   Content Structure","text":"<p>The main content of this book is shown in Figure 0-1.</p> <ul> <li>Complexity analysis: Evaluation dimensions and methods for data structures and algorithms. Methods for calculating time complexity and space complexity, common types, examples, etc.</li> <li>Data structures: Classification methods for basic data types and data structures. The definition, advantages and disadvantages, common operations, common types, typical applications, implementation methods, etc. of data structures such as arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs.</li> <li>Algorithms: The definition, advantages and disadvantages, efficiency, application scenarios, problem-solving steps, and example problems of algorithms such as searching, sorting, divide and conquer, backtracking, dynamic programming, and greedy algorithms.</li> </ul> <p></p> <p> Figure 0-1   Main content of this book </p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/about_the_book/#013-acknowledgements","level":2,"title":"0.1.3   Acknowledgements","text":"<p>This book has been continuously improved through the joint efforts of many contributors in the open-source community. Thanks to every contributor who invested time and effort, they are (in the order automatically generated by GitHub): krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, rongyi, msk397, gvenusleo, khoaxuantu, rivertwilight, K3v123, gyt95, zhuoqinyue, yuelinxin, Zuoxun, mingXta, Phoenix0415, FangYuan33, GN-Yu, longsizhuo, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, pengchzn, QiLOL, magentaqin, hello-ikun, JoseHung, qualifier1024, thomasq0, sunshinesDL, L-Super, Guanngxu, Transmigration-zhou, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, Shyam-Chen, theNefelibatas, longranger2, codeberg-user, xiongsp, JeffersonHuang, prinpal, seven1240, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, SamJin98, hongyun-robot, nanlei, XiaChuerwu, yd-j, iron-irax, mgisr, steventimes, junminhong, heshuyue, danny900714, MolDuM, Nigh, Dr-XYZ, XC-Zero, reeswell, PXG-XPG, NI-SW, Horbin-Magician, Enlightenus, YangXuanyi, beatrix-chan, DullSword, xjr7670, jiaxianhua, qq909244296, iStig, boloboloda, hts0000, gledfish, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, linyejoe2, liuxjerry, llql1211, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, ZhongGuanbin, hezhizhen, linzeyan, ZJKung, luluxia, xb534, ztkuaikuai, yw-1021, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yanedie, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, lyl625760, lucaswangdev, 0130w, shanghai-Jerry, EJackYang, Javesun99, eltociear, lipusheng, KNChiu, BlindTerran, ShiMaRing, lovelock, FreddieLi, FloranceYeh, fanchenggang, gltianwen, goerll, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, Asashishi, Asa0oo0o0o, fanenr, eagleanurag, akshiterate, 52coder, foursevenlove, KorsChen, GaochaoZhu, hopkings2008, yang-le, realwujing, Evilrabbit520, Umer-Jahangir, Turing-1024-Lee, Suremotoo, paoxiaomooo, Chieko-Seren, Allen-Scai, ymmmas, Risuntsy, Richard-Zhang1019, RafaelCaso, qingpeng9802, primexiao, Urbaner3, zhongfq, nidhoggfgg, MwumLi, CreatorMetaSky, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai, and KawaiiAsh.</p> <p>The code review work for this book was completed by coderonion, curtishd, Gonglja, gvenusleo, hpstory, justin-tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon and rongyi (in alphabetical order). Thanks to them for the time and effort they put in, it is they who ensure the standardization and unity of code in various languages.</p> <p>The Traditional Chinese version of this book was reviewed by Shyam-Chen and Dr-XYZ, the English version was reviewed by yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0 and magentaqin, and the Japanese edition was reviewed by eltociear. It is because of their continuous contributions that this book can serve a wider readership, and we thank them.</p> <p>The ePub ebook generation tool for this book was developed by zhongfq. We thank him for his contribution, which provides readers with a more flexible way to read.</p> <p>During the creation of this book, I received help from many people.</p> <ul> <li>Thanks to my mentor at the company, Dr. Li Xi, who encouraged me to \"take action quickly\" during a conversation, strengthening my determination to write this book;</li> <li>Thanks to my girlfriend Bubble as the first reader of this book, who provided many valuable suggestions from the perspective of an algorithm beginner, making this book more suitable for novices to read;</li> <li>Thanks to Tengbao, Qibao, and Feibao for coming up with a creative name for this book, evoking everyone's fond memories of writing their first line of code \"Hello World!\";</li> <li>Thanks to Xiaoquan for providing professional help in intellectual property rights, which played an important role in the improvement of this open-source book;</li> <li>Thanks to Sutong for designing the beautiful cover and logo for this book, and for patiently making revisions multiple times driven by my obsessive-compulsive disorder;</li> <li>Thanks to @squidfunk for the typesetting suggestions, as well as for developing the open-source documentation theme Material-for-MkDocs.</li> </ul> <p>During the writing process, I read many textbooks and articles on data structures and algorithms. These works provided excellent examples for this book and ensured the accuracy and quality of the book's content. I would like to thank all the teachers and predecessors for their outstanding contributions!</p> <p>This book advocates a learning method that combines hands and brain, and in this regard I was deeply inspired by Dive into Deep Learning. I highly recommend this excellent work to all readers.</p> <p>Heartfelt thanks to my parents, it is your support and encouragement that has given me the opportunity to do this interesting thing.</p>","path":["Chapter 0. Preface","0.1 &nbsp; About This Book"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   How to Use This Book","text":"<p>Tip</p> <p>For the best reading experience, it is recommended that you read through this section.</p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#021-writing-style-conventions","level":2,"title":"0.2.1   Writing Style Conventions","text":"<ul> <li>Titles marked with <code>*</code> are optional sections with relatively difficult content. If you have limited time, you can skip them first.</li> <li>Technical terms will be in bold (in paper and PDF versions) or underlined (in web versions), such as array. It is recommended to memorize them for reading literature.</li> <li>Key content and summary statements will be bolded, and such text deserves special attention.</li> <li>Words and phrases with specific meanings will be marked with \"quotation marks\" to avoid ambiguity.</li> <li>When it comes to nouns that are inconsistent between programming languages, this book uses Python as the standard, for example, using <code>None</code> to represent \"null\".</li> <li>This book partially abandons the comment conventions of programming languages in favor of more compact content layout. Comments are mainly divided into three types: title comments, content comments, and multi-line comments.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"Title comment, used to label functions, classes, test cases, etc.\"\"\"\n\n# Content comment, used to explain code in detail\n\n\"\"\"\nMulti-line\ncomment\n\"\"\"\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n// Multi-line\n// comment\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>/* Title comment, used to label functions, classes, test cases, etc. */\n\n// Content comment, used to explain code in detail\n\n/**\n * Multi-line\n * comment\n */\n</code></pre> <pre><code>### Title comment, used to label functions, classes, test cases, etc. ###\n\n# Content comment, used to explain code in detail\n\n# Multi-line\n# comment\n</code></pre>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#022-learning-efficiently-with-animated-illustrations","level":2,"title":"0.2.2   Learning Efficiently with Animated Illustrations","text":"<p>Compared to text, videos and images have higher information density and structural organization, making them easier to understand. In this book, key and difficult knowledge will mainly be presented in the form of animated illustrations, with text serving as explanation and supplement.</p> <p>If you find that a section of content provides animated illustrations as shown in Figure 0-2 while reading this book, please focus on the illustrations first, with text as a supplement, and combine the two to understand the content.</p> <p></p> <p> Figure 0-2   Example of animated illustrations </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#023-deepening-understanding-through-code-practice","level":2,"title":"0.2.3   Deepening Understanding Through Code Practice","text":"<p>The accompanying code for this book is hosted in the GitHub repository. As shown in Figure 0-3, the source code comes with test cases and can be run with one click.</p> <p>If time permits, it is recommended that you type out the code yourself. If you have limited study time, please at least read through and run all the code.</p> <p>Compared to reading code, the process of writing code often brings more rewards. Learning by doing is the real learning.</p> <p></p> <p> Figure 0-3   Example of running code </p> <p>The preliminary work for running code is mainly divided into three steps.</p> <p>Step 1: Install the local programming environment. Please follow the tutorial shown in the appendix for installation. If already installed, you can skip this step.</p> <p>Step 2: Clone or download the code repository. Visit the GitHub repository. If you have already installed Git, you can clone this repository with the following command:</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>Of course, you can also click the \"Download ZIP\" button at the location shown in Figure 0-4 to directly download the code compressed package, and then extract it locally.</p> <p></p> <p> Figure 0-4   Clone repository and download code </p> <p>Step 3: Run the source code. As shown in Figure 0-5, for code blocks with file names at the top, we can find the corresponding source code files in the <code>codes</code> folder of the repository. The source code files can be run with one click, which will help you save unnecessary debugging time and allow you to focus on learning content.</p> <p></p> <p> Figure 0-5   Code blocks and corresponding source code files </p> <p>In addition to running code locally, the web version also supports visual running of Python code (implemented based on pythontutor). As shown in Figure 0-6, you can click \"Visual Run\" below the code block to expand the view and observe the execution process of the algorithm code; you can also click \"Full Screen View\" for a better viewing experience.</p> <p></p> <p> Figure 0-6   Visual running of Python code </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#024-growing-together-through-questions-and-discussions","level":2,"title":"0.2.4   Growing Together Through Questions and Discussions","text":"<p>When reading this book, please do not easily skip knowledge points that you have not learned well. Feel free to ask your questions in the comments section, and my friends and I will do our best to answer you, and generally reply within two days.</p> <p>As shown in Figure 0-7, the web version has a comments section at the bottom of each chapter. I hope you will pay more attention to the content of the comments section. On the one hand, you can learn about the problems that everyone encounters, thus checking for omissions and stimulating deeper thinking. On the other hand, I hope you can generously answer other friends' questions, share your insights, and help others progress.</p> <p></p> <p> Figure 0-7   Example of comments section </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/suggestions/#025-algorithm-learning-roadmap","level":2,"title":"0.2.5   Algorithm Learning Roadmap","text":"<p>From an overall perspective, we can divide the process of learning data structures and algorithms into three stages.</p> <ol> <li>Stage 1: Algorithm introduction. We need to familiarize ourselves with the characteristics and usage of various data structures, and learn the principles, processes, uses, and efficiency of different algorithms.</li> <li>Stage 2: Practice algorithm problems. It is recommended to start with popular problems, and accumulate at least 100 problems first, to familiarize yourself with mainstream algorithm problems. When first practicing problems, \"knowledge forgetting\" may be a challenge, but rest assured, this is very normal. We can review problems according to the \"Ebbinghaus forgetting curve\", and usually after 3-5 rounds of repetition, we can firmly remember them. For recommended problem lists and practice plans, please see this GitHub repository.</li> <li>Stage 3: Building a knowledge system. In terms of learning, we can read algorithm column articles, problem-solving frameworks, and algorithm textbooks to continuously enrich our knowledge system. In terms of practicing problems, we can try advanced problem-solving strategies, such as categorization by topic, one problem multiple solutions, one solution multiple problems, etc. Related problem-solving insights can be found in various communities.</li> </ol> <p>As shown in Figure 0-8, the content of this book mainly covers \"Stage 1\", aiming to help you more efficiently carry out Stage 2 and Stage 3 learning.</p> <p></p> <p> Figure 0-8   Algorithm learning roadmap </p>","path":["Chapter 0. Preface","0.2 &nbsp; How to Use This Book"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   Summary","text":"","path":["Chapter 0. Preface","0.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_preface/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>The main audience of this book is algorithm beginners. If you already have a certain foundation, this book can help you systematically review algorithm knowledge, and the source code in the book can also be used as a \"problem-solving toolkit.\"</li> <li>The content of the book mainly includes three parts: complexity analysis, data structures, and algorithms, covering most topics in this field.</li> <li>For algorithm novices, reading an introductory book during the initial learning stage is crucial, as it can help you avoid many detours.</li> <li>The animated illustrations in the book are usually used to introduce key and difficult knowledge. When reading this book, you should pay more attention to these contents.</li> <li>Practice is the best way to learn programming. It is strongly recommended to run the source code and type the code yourself.</li> <li>The web version of this book has a comments section for each chapter, where you are welcome to share your questions and insights at any time.</li> </ul>","path":["Chapter 0. Preface","0.3 &nbsp; Summary"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"References","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] Yan Weimin. Data Structures (C Language Version).</p> <p>[5] Deng Junhui. Data Structures (C++ Language Version, Third Edition).</p> <p>[6] Mark Allen Weiss, translated by Chen Yue. Data Structures and Algorithm Analysis in Java (Third Edition).</p> <p>[7] Cheng Jie. Conversational Data Structures.</p> <p>[8] Wang Zheng. The Beauty of Data Structures and Algorithms.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["References"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"Chapter 10.   Searching","text":"<p>Abstract</p> <p>Searching is an adventure into the unknown, where we may need to traverse every corner of the mysterious space, or we may be able to quickly lock onto the target.</p> <p>In this journey of discovery, each exploration may yield an unexpected answer.</p>","path":["Chapter 10. Searching","Chapter 10. &nbsp; Searching"],"tags":[]},{"location":"chapter_searching/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>10.1   Binary Search</li> <li>10.2   Binary Search Insertion</li> <li>10.3   Binary Search Edge Cases</li> <li>10.4   Hash Optimization Strategy</li> <li>10.5   Search Algorithms Revisited</li> <li>10.6   Summary</li> </ul>","path":["Chapter 10. Searching","Chapter 10. &nbsp; Searching"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   Binary Search","text":"<p>Binary search is an efficient searching algorithm based on the divide-and-conquer strategy. It leverages the orderliness of data to reduce the search range by half in each round until the target element is found or the search interval becomes empty.</p> <p>Question</p> <p>Given an array <code>nums</code> of length \\(n\\) with elements arranged in ascending order and no duplicates, search for and return the index of element <code>target</code> in the array. If the array does not contain the element, return \\(-1\\). An example is shown in Figure 10-1.</p> <p></p> <p> Figure 10-1   Binary search example data </p> <p>As shown in Figure 10-2, we first initialize pointers \\(i = 0\\) and \\(j = n - 1\\), pointing to the first and last elements of the array respectively, representing the search interval \\([0, n - 1]\\). Note that square brackets denote a closed interval, which includes the boundary values themselves.</p> <p>Next, perform the following two steps in a loop:</p> <ol> <li>Calculate the midpoint index \\(m = \\lfloor {(i + j) / 2} \\rfloor\\), where \\(\\lfloor \\: \\rfloor\\) denotes the floor operation.</li> <li>Compare <code>nums[m]</code> and <code>target</code>, which results in three cases:<ol> <li>When <code>nums[m] &lt; target</code>, it indicates that <code>target</code> is in the interval \\([m + 1, j]\\), so execute \\(i = m + 1\\).</li> <li>When <code>nums[m] &gt; target</code>, it indicates that <code>target</code> is in the interval \\([i, m - 1]\\), so execute \\(j = m - 1\\).</li> <li>When <code>nums[m] = target</code>, it indicates that <code>target</code> has been found, so return index \\(m\\).</li> </ol> </li> </ol> <p>If the array does not contain the target element, the search interval will eventually shrink to empty. In this case, return \\(-1\\).</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 10-2   Binary search process </p> <p>It's worth noting that since both \\(i\\) and \\(j\\) are of <code>int</code> type, \\(i + j\\) may exceed the range of the <code>int</code> type. To avoid large number overflow, we typically use the formula \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) to calculate the midpoint.</p> <p>The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search (closed interval)\"\"\"\n    # Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    i, j = 0, len(nums) - 1\n    # Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j:\n        # In theory, Python numbers can be infinitely large (depending on memory size), no need to consider large number overflow\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # This means target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # This means target is in the interval [i, m-1]\n        else:\n            return m  # Found the target element, return its index\n    return -1  # Target element not found, return -1\n</code></pre> binary_search.cpp<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.size() - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(int[] nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Binary search (closed interval on both sides) */\nint BinarySearch(int[] nums, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = nums.Length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // Calculate the midpoint index m\n        if (nums[m] &lt; target)      // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else                       // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Binary search (closed interval on both sides) */\nfunc binarySearch(nums []int, target int) int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    i, j := 0, len(nums)-1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    for i &lt;= j {\n        m := i + (j-i)/2      // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m-1]\n            j = m - 1\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Binary search (closed interval on both sides) */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m-1]\n            j = m - 1\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Binary search (closed interval on both sides) */\nfunction binarySearch(nums, target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let i = 0,\n        j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        // Calculate midpoint index m, use parseInt() to round down\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else return m; // Found the target element, return its index\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Binary search (closed interval on both sides) */\nfunction binarySearch(nums: number[], target: number): number {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let i = 0,\n        j = nums.length - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        // Calculate the midpoint index m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    return -1; // Target element not found, return -1\n}\n</code></pre> binary_search.dart<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n  int i = 0, j = nums.length - 1;\n  // Loop, exit when the search interval is empty (empty when i &gt; j)\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      // This means target is in the interval [m+1, j]\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // This means target is in the interval [i, m-1]\n      j = m - 1;\n    } else {\n      // Found the target element, return its index\n      return m;\n    }\n  }\n  // Target element not found, return -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Binary search (closed interval on both sides) */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            // This means target is in the interval [m+1, j]\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // This means target is in the interval [i, m-1]\n            j = m - 1;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Binary search (closed interval on both sides) */\nint binarySearch(int *nums, int len, int target) {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    int i = 0, j = len - 1;\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Binary search (closed interval on both sides) */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n    var i = 0\n    var j = nums.size - 1\n    // Loop, exit when the search interval is empty (empty when i &gt; j)\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j]\n            i = m + 1\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m-1]\n            j = m - 1\n        else  // Found the target element, return its index\n            return m\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Binary search (closed interval) ###\ndef binary_search(nums, target)\n  # Initialize closed interval [0, n-1], i.e., i, j point to the first and last elements of the array\n  i, j = 0, nums.length - 1\n\n  # Loop, exit when the search interval is empty (empty when i &gt; j)\n  while i &lt;= j\n    # In theory, Ruby numbers can be infinitely large (limited by memory), no need to consider overflow\n    m = (i + j) / 2   # Calculate the midpoint index m\n\n    if nums[m] &lt; target\n      i = m + 1 # This means target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # This means target is in the interval [i, m-1]\n    else\n      return m  # Found the target element, return its index\n    end\n  end\n\n  -1  # Target element not found, return -1\nend\n</code></pre> <p>Time complexity is \\(O(\\log n)\\): In the binary loop, the interval is reduced by half each round, so the number of loops is \\(\\log_2 n\\).</p> <p>Space complexity is \\(O(1)\\): Pointers \\(i\\) and \\(j\\) use constant-size space.</p>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search/#1011-interval-representation-methods","level":2,"title":"10.1.1   Interval Representation Methods","text":"<p>In addition to the closed interval mentioned above, another common interval representation is the \"left-closed right-open\" interval, defined as \\([0, n)\\), meaning the left boundary includes itself while the right boundary does not. Under this representation, the interval \\([i, j)\\) is empty when \\(i = j\\).</p> <p>We can implement a binary search algorithm with the same functionality based on this representation:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search (left-closed right-open interval)\"\"\"\n    # Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    i, j = 0, len(nums)\n    # Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # This means target is in the interval [m+1, j)\n        elif nums[m] &gt; target:\n            j = m  # This means target is in the interval [i, m)\n        else:\n            return m  # Found the target element, return its index\n    return -1  # Target element not found, return -1\n</code></pre> binary_search.cpp<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.size();\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(int[] nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Binary search (left-closed right-open interval) */\nint BinarySearchLCRO(int[] nums, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = nums.Length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // Calculate the midpoint index m\n        if (nums[m] &lt; target)      // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else                       // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Binary search (left-closed right-open interval) */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    i, j := 0, len(nums)\n    // Loop, exit when the search interval is empty (empty when i = j)\n    for i &lt; j {\n        m := i + (j-i)/2      // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m)\n            j = m\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Binary search (left-closed right-open interval) */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target { // This means target is in the interval [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // This means target is in the interval [i, m)\n            j = m\n        } else { // Found the target element, return its index\n            return m\n        }\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Binary search (left-closed right-open interval) */\nfunction binarySearchLCRO(nums, target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let i = 0,\n        j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        // Calculate midpoint index m, use parseInt() to round down\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // This means target is in the interval [i, m)\n            j = m;\n        // Found the target element, return its index\n        else return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Binary search (left-closed right-open interval) */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let i = 0,\n        j = nums.length;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        // Calculate the midpoint index m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // This means target is in the interval [i, m)\n            j = m;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    return -1; // Target element not found, return -1\n}\n</code></pre> binary_search.dart<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n  int i = 0, j = nums.length;\n  // Loop, exit when the search interval is empty (empty when i = j)\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      // This means target is in the interval [m+1, j)\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // This means target is in the interval [i, m)\n      j = m;\n    } else {\n      // Found the target element, return its index\n      return m;\n    }\n  }\n  // Target element not found, return -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Binary search (left-closed right-open interval) */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while i &lt; j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            // This means target is in the interval [m+1, j)\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // This means target is in the interval [i, m)\n            j = m;\n        } else {\n            // Found the target element, return its index\n            return m;\n        }\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Binary search (left-closed right-open interval) */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    int i = 0, j = len;\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target)    // This means target is in the interval [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m;\n        else // Found the target element, return its index\n            return m;\n    }\n    // Target element not found, return -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Binary search (left-closed right-open interval) */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n    var i = 0\n    var j = nums.size\n    // Loop, exit when the search interval is empty (empty when i = j)\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) // This means target is in the interval [m+1, j)\n            i = m + 1\n        else if (nums[m] &gt; target) // This means target is in the interval [i, m)\n            j = m\n        else  // Found the target element, return its index\n            return m\n    }\n    // Target element not found, return -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Binary search (left-closed right-open interval) ###\ndef binary_search_lcro(nums, target)\n  # Initialize left-closed right-open interval [0, n), i.e., i, j point to the first element and last element+1\n  i, j = 0, nums.length\n\n  # Loop, exit when the search interval is empty (empty when i = j)\n  while i &lt; j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # This means target is in the interval [m+1, j)\n    elsif nums[m] &gt; target\n      j = m - 1 # This means target is in the interval [i, m)\n    else\n      return m  # Found the target element, return its index\n    end\n  end\n\n  -1  # Target element not found, return -1\nend\n</code></pre> <p>As shown in Figure 10-3, under the two interval representations, the initialization, loop condition, and interval narrowing operations of the binary search algorithm are all different.</p> <p>Since both the left and right boundaries in the \"closed interval\" representation are defined as closed, the operations to narrow the interval through pointers \\(i\\) and \\(j\\) are also symmetric. This makes it less error-prone, so the \"closed interval\" approach is generally recommended.</p> <p></p> <p> Figure 10-3   Two interval definitions </p>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search/#1012-advantages-and-limitations","level":2,"title":"10.1.2   Advantages and Limitations","text":"<p>Binary search performs well in both time and space aspects.</p> <ul> <li>Binary search has high time efficiency. With large data volumes, the logarithmic time complexity has significant advantages. For example, when the data size \\(n = 2^{20}\\), linear search requires \\(2^{20} = 1048576\\) loop rounds, while binary search only needs \\(\\log_2 2^{20} = 20\\) rounds.</li> <li>Binary search requires no extra space. Compared to searching algorithms that require additional space (such as hash-based search), binary search is more space-efficient.</li> </ul> <p>However, binary search is not suitable for all situations, mainly for the following reasons:</p> <ul> <li>Binary search is only applicable to sorted data. If the input data is unsorted, sorting specifically to use binary search would be counterproductive, as sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), which is higher than both linear search and binary search. For scenarios with frequent element insertions, maintaining array orderliness requires inserting elements at specific positions with a time complexity of \\(O(n)\\), which is also very expensive.</li> <li>Binary search is only applicable to arrays. Binary search requires jump-style (non-contiguous) element access, and jump-style access has low efficiency in linked lists, making it unsuitable for linked lists or data structures based on linked list implementations.</li> <li>For small data volumes, linear search performs better. In linear search, each round requires only 1 comparison operation; while in binary search, it requires 1 addition, 1 division, 1-3 comparison operations, and 1 addition (subtraction), totaling 4-6 unit operations. Therefore, when the data volume \\(n\\) is small, linear search is actually faster than binary search.</li> </ul>","path":["Chapter 10. Searching","10.1 &nbsp; Binary Search"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   Binary Search Edge Cases","text":"","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031-finding-the-left-boundary","level":2,"title":"10.3.1   Finding the Left Boundary","text":"<p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\) that may contain duplicate elements, return the index of the leftmost element <code>target</code> in the array. If the array does not contain the element, return \\(-1\\).</p> <p>Recall the method for finding the insertion point with binary search. After the search completes, \\(i\\) points to the leftmost <code>target</code>, so finding the insertion point is essentially finding the index of the leftmost <code>target</code>.</p> <p>Consider implementing the left boundary search using the insertion point finding function. Note that the array may not contain <code>target</code>, which could result in the following two cases:</p> <ul> <li>The insertion point index \\(i\\) is out of bounds.</li> <li>The element <code>nums[i]</code> is not equal to <code>target</code>.</li> </ul> <p>When either of these situations occurs, simply return \\(-1\\). The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for the leftmost target\"\"\"\n    # Equivalent to finding the insertion point of target\n    i = binary_search_insertion(nums, target)\n    # Target not found, return -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # Found target, return index i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Binary search for the leftmost target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Binary search for the leftmost target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // Equivalent to finding the insertion point of target\n    i := binarySearchInsertion(nums, target)\n    // Target not found, return -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Binary search for the leftmost target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // Equivalent to finding the insertion point of target\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // Target not found, return -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* Binary search for the leftmost target */\nfunction binarySearchLeftEdge(nums, target) {\n    // Equivalent to finding the insertion point of target\n    const i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Binary search for the leftmost target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Equivalent to finding the insertion point of target\n    const i = binarySearchInsertion(nums, target);\n    // Target not found, return -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // Equivalent to finding the insertion point of target\n  int i = binarySearchInsertion(nums, target);\n  // Target not found, return -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // Found target, return index i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Binary search for the leftmost target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Equivalent to finding the insertion point of target\n    let i = binary_search_insertion(nums, target);\n    // Target not found, return -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // Found target, return index i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* Binary search for the leftmost target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // Equivalent to finding the insertion point of target\n    int i = binarySearchInsertion(nums, numSize, target);\n    // Target not found, return -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // Found target, return index i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Binary search for the leftmost target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // Equivalent to finding the insertion point of target\n    val i = binarySearchInsertion(nums, target)\n    // Target not found, return -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // Found target, return index i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### Binary search leftmost target ###\ndef binary_search_left_edge(nums, target)\n  # Equivalent to finding the insertion point of target\n  i = binary_search_insertion(nums, target)\n\n  # Target not found, return -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # Found target, return index i\nend\n</code></pre>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032-finding-the-right-boundary","level":2,"title":"10.3.2   Finding the Right Boundary","text":"<p>So how do we find the rightmost <code>target</code>? The most direct approach is to modify the code and replace the pointer shrinking operation in the <code>nums[m] == target</code> case. The code is omitted here; interested readers can implement it themselves.</p> <p>Below we introduce two more clever methods.</p>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1-reusing-left-boundary-search","level":3,"title":"1.   Reusing Left Boundary Search","text":"<p>In fact, we can use the function for finding the leftmost element to find the rightmost element. The specific method is: Convert finding the rightmost <code>target</code> into finding the leftmost <code>target + 1</code>.</p> <p>As shown in Figure 10-7, after the search completes, pointer \\(i\\) points to the leftmost <code>target + 1</code> (if it exists), while \\(j\\) points to the rightmost <code>target</code>, so we can simply return \\(j\\).</p> <p></p> <p> Figure 10-7   Converting right boundary search to left boundary search </p> <p>Note that the returned insertion point is \\(i\\), so we need to subtract \\(1\\) from it to obtain \\(j\\):</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for the rightmost target\"\"\"\n    # Convert to finding the leftmost target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j points to the rightmost target, i points to the first element greater than target\n    j = i - 1\n    # Target not found, return -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # Found target, return index j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Binary search for the rightmost target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Binary search for the rightmost target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // Convert to finding the leftmost target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j points to the rightmost target, i points to the first element greater than target\n    j := i - 1\n    // Target not found, return -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Binary search for the rightmost target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // Convert to finding the leftmost target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j points to the rightmost target, i points to the first element greater than target\n    let j = i - 1\n    // Target not found, return -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* Binary search for the rightmost target */\nfunction binarySearchRightEdge(nums, target) {\n    // Convert to finding the leftmost target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    const j = i - 1;\n    // Target not found, return -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Binary search for the rightmost target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Convert to finding the leftmost target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    const j = i - 1;\n    // Target not found, return -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // Convert to finding the leftmost target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j points to the rightmost target, i points to the first element greater than target\n  int j = i - 1;\n  // Target not found, return -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // Found target, return index j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Binary search for the rightmost target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Convert to finding the leftmost target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    let j = i - 1;\n    // Target not found, return -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // Found target, return index j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* Binary search for the rightmost target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // Convert to finding the leftmost target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j points to the rightmost target, i points to the first element greater than target\n    int j = i - 1;\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Found target, return index j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Binary search for the rightmost target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // Convert to finding the leftmost target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j points to the rightmost target, i points to the first element greater than target\n    val j = i - 1\n    // Target not found, return -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // Found target, return index j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### Binary search rightmost target ###\ndef binary_search_right_edge(nums, target)\n  # Convert to finding the leftmost target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j points to the rightmost target, i points to the first element greater than target\n  j = i - 1\n\n  # Target not found, return -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # Found target, return index j\nend\n</code></pre>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2-converting-to-element-search","level":3,"title":"2.   Converting to Element Search","text":"<p>We know that when the array does not contain <code>target</code>, \\(i\\) and \\(j\\) will eventually point to the first elements greater than and less than <code>target</code>, respectively.</p> <p>Therefore, as shown in Figure 10-8, we can construct an element that does not exist in the array to find the left and right boundaries.</p> <ul> <li>Finding the leftmost <code>target</code>: Can be converted to finding <code>target - 0.5</code> and returning pointer \\(i\\).</li> <li>Finding the rightmost <code>target</code>: Can be converted to finding <code>target + 0.5</code> and returning pointer \\(j\\).</li> </ul> <p></p> <p> Figure 10-8   Converting boundary search to element search </p> <p>The code is omitted here, but the following two points are worth noting:</p> <ul> <li>Since the given array does not contain decimals, we don't need to worry about how to handle equal cases.</li> <li>Because this method introduces decimals, the variable <code>target</code> in the function needs to be changed to a floating-point type (Python does not require this change).</li> </ul>","path":["Chapter 10. Searching","10.3 &nbsp; Binary Search Edge Cases"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   Binary Search Insertion Point","text":"<p>Binary search can not only be used to search for target elements but also to solve many variant problems, such as searching for the insertion position of a target element.</p>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021-case-without-duplicate-elements","level":2,"title":"10.2.1   Case Without Duplicate Elements","text":"<p>Question</p> <p>Given a sorted array <code>nums</code> of length \\(n\\) and an element <code>target</code>, where the array contains no duplicate elements. Insert <code>target</code> into the array <code>nums</code> while maintaining its sorted order. If the array already contains the element <code>target</code>, insert it to its left. Return the index of <code>target</code> in the array after insertion. An example is shown in Figure 10-4.</p> <p></p> <p> Figure 10-4   Binary search insertion point example data </p> <p>If we want to reuse the binary search code from the previous section, we need to answer the following two questions.</p> <p>Question 1: When the array contains <code>target</code>, is the insertion point index the same as that element's index?</p> <p>The problem requires inserting <code>target</code> to the left of equal elements, which means the newly inserted <code>target</code> replaces the position of the original <code>target</code>. In other words, when the array contains <code>target</code>, the insertion point index is the index of that <code>target</code>.</p> <p>Question 2: When the array does not contain <code>target</code>, what is the insertion point index?</p> <p>Further consider the binary search process: When <code>nums[m] &lt; target</code>, \\(i\\) moves, which means pointer \\(i\\) is approaching elements greater than or equal to <code>target</code>. Similarly, pointer \\(j\\) is always approaching elements less than or equal to <code>target</code>.</p> <p>Therefore, when the binary search ends, we must have: \\(i\\) points to the first element greater than <code>target</code>, and \\(j\\) points to the first element less than <code>target</code>. It's easy to see that when the array does not contain <code>target</code>, the insertion index is \\(i\\). The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for insertion point (no duplicate elements)\"\"\"\n    i, j = 0, len(nums) - 1  # Initialize closed interval [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target is in the interval [i, m-1]\n        else:\n            return m  # Found target, return insertion point m\n    # Target not found, return insertion point i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // Initialize closed interval [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Calculate the midpoint index m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target is in the interval [i, m-1]\n            j = m - 1\n        } else {\n            // Found target, return insertion point m\n            return m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            return m // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target is in the interval [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target is in the interval [i, m-1]\n    } else {\n      return m; // Found target, return insertion point m\n    }\n  }\n  // Target not found, return insertion point i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Initialize closed interval [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m;\n        }\n    }\n    // Target not found, return insertion point i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Binary search for insertion point (no duplicate elements) */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            return m; // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Binary search for insertion point (no duplicate elements) */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            return m // Found target, return insertion point m\n        }\n    }\n    // Target not found, return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Binary search insertion point (no duplicates) ###\ndef binary_search_insertion_simple(nums, target)\n  # Initialize closed interval [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target is in the interval [i, m-1]\n    else\n      return m  # Found target, return insertion point m\n    end\n  end\n\n  i # Target not found, return insertion point i\nend\n</code></pre>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022-case-with-duplicate-elements","level":2,"title":"10.2.2   Case with Duplicate Elements","text":"<p>Question</p> <p>Based on the previous problem, assume the array may contain duplicate elements, with everything else remaining the same.</p> <p>Suppose there are multiple <code>target</code> elements in the array. Ordinary binary search can only return the index of one <code>target</code>, and cannot determine how many <code>target</code> elements are to the left and right of that element.</p> <p>The problem requires inserting the target element at the leftmost position, so we need to find the index of the leftmost <code>target</code> in the array. Initially, consider implementing this through the steps shown in Figure 10-5:</p> <ol> <li>Perform binary search to obtain the index of any <code>target</code>, denoted as \\(k\\).</li> <li>Starting from index \\(k\\), perform linear traversal to the left, and return when the leftmost <code>target</code> is found.</li> </ol> <p></p> <p> Figure 10-5   Linear search for insertion point of duplicate elements </p> <p>Although this method works, it includes linear search, resulting in a time complexity of \\(O(n)\\). When the array contains many duplicate <code>target</code> elements, this method is very inefficient.</p> <p>Now consider extending the binary search code. As shown in Figure 10-6, the overall process remains unchanged: calculate the midpoint index \\(m\\) in each round, then compare <code>target</code> with <code>nums[m]</code>, divided into the following cases:</p> <ul> <li>When <code>nums[m] &lt; target</code> or <code>nums[m] &gt; target</code>, it means <code>target</code> has not been found yet, so use the ordinary binary search interval narrowing operation to make pointers \\(i\\) and \\(j\\) approach <code>target</code>.</li> <li>When <code>nums[m] == target</code>, it means elements less than <code>target</code> are in the interval \\([i, m - 1]\\), so use \\(j = m - 1\\) to narrow the interval, thereby making pointer \\(j\\) approach elements less than <code>target</code>.</li> </ul> <p>After the loop completes, \\(i\\) points to the leftmost <code>target</code>, and \\(j\\) points to the first element less than <code>target</code>, so index \\(i\\) is the insertion point.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 10-6   Steps for binary search insertion point of duplicate elements </p> <p>Observe the following code: the operations for branches <code>nums[m] &gt; target</code> and <code>nums[m] == target</code> are the same, so the two can be merged.</p> <p>Even so, we can still keep the conditional branches expanded, as the logic is clearer and more readable.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"Binary search for insertion point (with duplicate elements)\"\"\"\n    i, j = 0, len(nums) - 1  # Initialize closed interval [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Calculate midpoint index m\n        if nums[m] &lt; target:\n            i = m + 1  # target is in the interval [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target is in the interval [i, m-1]\n        else:\n            j = m - 1  # The first element less than target is in the interval [i, m-1]\n    # Return insertion point i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // Initialize closed interval [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Calculate the midpoint index m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target is in the interval [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target is in the interval [i, m-1]\n            j = m - 1\n        } else {\n            // The first element less than target is in the interval [i, m-1]\n            j = m - 1\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // Initialize closed interval [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Calculate the midpoint index m\n        if nums[m] &lt; target {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            j = m - 1 // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Calculate midpoint index m, use Math.floor() to round down\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Initialize closed interval [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Calculate the midpoint index m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target is in the interval [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target is in the interval [i, m-1]\n    } else {\n      j = m - 1; // The first element less than target is in the interval [i, m-1]\n    }\n  }\n  // Return insertion point i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Binary search for insertion point (with duplicate elements) */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Initialize closed interval [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Calculate the midpoint index m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Binary search for insertion point (with duplicate elements) */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target is in the interval [i, m-1]\n        } else {\n            j = m - 1; // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Binary search for insertion point (with duplicate elements) */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Initialize closed interval [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Calculate the midpoint index m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target is in the interval [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target is in the interval [i, m-1]\n        } else {\n            j = m - 1 // The first element less than target is in the interval [i, m-1]\n        }\n    }\n    // Return insertion point i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Binary search insertion point (with duplicates) ###\ndef binary_search_insertion(nums, target)\n  # Initialize closed interval [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Calculate the midpoint index m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target is in the interval [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target is in the interval [i, m-1]\n    else\n      j = m - 1 # The first element less than target is in the interval [i, m-1]\n    end\n  end\n\n  i # Return insertion point i\nend\n</code></pre> <p>Tip</p> <p>The code in this section all uses the \"closed interval\" approach. Interested readers can implement the \"left-closed right-open\" approach themselves.</p> <p>Overall, binary search is simply about setting search targets for pointers \\(i\\) and \\(j\\) separately. The target could be a specific element (such as <code>target</code>) or a range of elements (such as elements less than <code>target</code>).</p> <p>Through continuous binary iterations, both pointers \\(i\\) and \\(j\\) gradually approach their preset targets. Ultimately, they either successfully find the answer or stop after crossing the boundaries.</p>","path":["Chapter 10. Searching","10.2 &nbsp; Binary Search Insertion Point"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   Hash Optimization Strategy","text":"<p>In algorithm problems, we often reduce the time complexity of algorithms by replacing linear search with hash-based search. Let's use an algorithm problem to deepen our understanding.</p> <p>Question</p> <p>Given an integer array <code>nums</code> and a target element <code>target</code>, search for two elements in the array whose \"sum\" equals <code>target</code>, and return their array indices. Any solution will do.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041-linear-search-trading-time-for-space","level":2,"title":"10.4.1   Linear Search: Trading Time for Space","text":"<p>Consider directly traversing all possible combinations. As shown in Figure 10-9, we open a two-layer loop and judge in each round whether the sum of two integers equals <code>target</code>. If so, return their indices.</p> <p></p> <p> Figure 10-9   Linear search solution for two sum </p> <p>The code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Method 1: Brute force enumeration\"\"\"\n    # Two nested loops, time complexity is O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Method 1: Brute force enumeration */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Method 1: Brute force enumeration */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Method 1: Brute force enumeration */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // Two nested loops, time complexity is O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Method 1: Brute force enumeration */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // Two nested loops, time complexity is O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Method 1: Brute force enumeration */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // Two nested loops, time complexity is O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Method 1: Brute force enumeration */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Method 1: Brute force enumeration */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // Two nested loops, time complexity is O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Method 1: Brute force enumeration */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Two nested loops, time complexity is O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Method 1: Brute force enumeration */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // Two nested loops, time complexity is O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Method 1: Brute force enumeration */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Method 1: Brute force enumeration */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Two nested loops, time complexity is O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Method 1: Brute force enumeration ###\ndef two_sum_brute_force(nums, target)\n  # Two nested loops, time complexity is O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> <p>This method has a time complexity of \\(O(n^2)\\) and a space complexity of \\(O(1)\\), which is very time-consuming with large data volumes.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042-hash-based-search-trading-space-for-time","level":2,"title":"10.4.2   Hash-Based Search: Trading Space for Time","text":"<p>Consider using a hash table where key-value pairs are array elements and element indices respectively. Loop through the array, performing the steps shown in Figure 10-10 in each round:</p> <ol> <li>Check if the number <code>target - nums[i]</code> is in the hash table. If so, directly return the indices of these two elements.</li> <li>Add the key-value pair <code>nums[i]</code> and index <code>i</code> to the hash table.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> Figure 10-10   Hash table solution for two sum </p> <p>The implementation code is shown below, requiring only a single loop:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Method 2: Auxiliary hash table\"\"\"\n    # Auxiliary hash table, space complexity is O(n)\n    dic = {}\n    # Single loop, time complexity is O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Method 2: Auxiliary hash table */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Auxiliary hash table, space complexity is O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Method 2: Auxiliary hash table */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // Auxiliary hash table, space complexity is O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Method 2: Auxiliary hash table */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // Auxiliary hash table, space complexity is O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // Single loop, time complexity is O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Method 2: Auxiliary hash table */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // Auxiliary hash table, space complexity is O(n)\n    hashTable := map[int]int{}\n    // Single loop, time complexity is O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Method 2: Auxiliary hash table */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // Auxiliary hash table, space complexity is O(n)\n    var dic: [Int: Int] = [:]\n    // Single loop, time complexity is O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Method 2: Auxiliary hash table */\nfunction twoSumHashTable(nums, target) {\n    // Auxiliary hash table, space complexity is O(n)\n    let m = {};\n    // Single loop, time complexity is O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Method 2: Auxiliary hash table */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // Auxiliary hash table, space complexity is O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // Single loop, time complexity is O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Method 2: Auxiliary hash table */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Auxiliary hash table, space complexity is O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // Single loop, time complexity is O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Method 2: Auxiliary hash table */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // Auxiliary hash table, space complexity is O(n)\n    let mut dic = HashMap::new();\n    // Single loop, time complexity is O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Hash table */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Implemented using uthash.h\n} HashTable;\n\n/* Hash table lookup */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* Hash table element insertion */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* Method 2: Auxiliary hash table */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Method 2: Auxiliary hash table */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Auxiliary hash table, space complexity is O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // Single loop, time complexity is O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Method 2: Auxiliary hash table ###\ndef two_sum_hash_table(nums, target)\n  # Auxiliary hash table, space complexity is O(n)\n  dic = {}\n  # Single loop, time complexity is O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> <p>This method reduces the time complexity from \\(O(n^2)\\) to \\(O(n)\\) through hash-based search, greatly improving runtime efficiency.</p> <p>Since an additional hash table needs to be maintained, the space complexity is \\(O(n)\\). Nevertheless, this method achieves a more balanced overall time-space efficiency, making it the optimal solution for this problem.</p>","path":["Chapter 10. Searching","10.4 &nbsp; Hash Optimization Strategy"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   Searching Algorithms Revisited","text":"<p>Searching algorithms are used to search for one or a group of elements that meet specific conditions in data structures (such as arrays, linked lists, trees, or graphs).</p> <p>Searching algorithms can be divided into the following two categories based on their implementation approach:</p> <ul> <li>Locating target elements by traversing the data structure, such as traversing arrays, linked lists, trees, and graphs.</li> <li>Achieving efficient element search by utilizing data organization structure or prior information contained in the data, such as binary search, hash-based search, and binary search tree search.</li> </ul> <p>It's not hard to see that these topics have all been covered in previous chapters, so searching algorithms are not unfamiliar to us. In this section, we will approach from a more systematic perspective and re-examine searching algorithms.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051-brute-force-search","level":2,"title":"10.5.1   Brute-Force Search","text":"<p>Brute-force search locates target elements by traversing each element of the data structure.</p> <ul> <li>\"Linear search\" is applicable to linear data structures such as arrays and linked lists. It starts from one end of the data structure and accesses elements one by one until the target element is found or the other end is reached without finding the target element.</li> <li>\"Breadth-first search\" and \"depth-first search\" are two traversal strategies for graphs and trees. Breadth-first search starts from the initial node and searches layer by layer, visiting nodes from near to far. Depth-first search starts from the initial node, follows a path to the end, then backtracks and tries other paths until the entire data structure is traversed.</li> </ul> <p>The advantage of brute-force search is that it is simple and has good generality, requiring no data preprocessing or additional data structures.</p> <p>However, the time complexity of such algorithms is \\(O(n)\\), where \\(n\\) is the number of elements, so performance is poor when dealing with large amounts of data.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052-adaptive-search","level":2,"title":"10.5.2   Adaptive Search","text":"<p>Adaptive search utilizes the unique properties of data (such as orderliness) to optimize the search process, thereby locating target elements more efficiently.</p> <ul> <li>\"Binary search\" uses the orderliness of data to achieve efficient searching, applicable only to arrays.</li> <li>\"Hash-based search\" uses hash tables to establish key-value pair mappings between search data and target data, thereby achieving query operations.</li> <li>\"Tree search\" in specific tree structures (such as binary search trees), quickly eliminates nodes based on comparing node values to locate target elements.</li> </ul> <p>The advantage of such algorithms is high efficiency, with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\).</p> <p>However, using these algorithms often requires data preprocessing. For example, binary search requires pre-sorting the array, while hash-based search and tree search both require additional data structures, and maintaining these data structures also requires extra time and space overhead.</p> <p>Tip</p> <p>Adaptive search algorithms are often called lookup algorithms, mainly used to quickly retrieve target elements in specific data structures.</p>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053-search-method-selection","level":2,"title":"10.5.3   Search Method Selection","text":"<p>Given a dataset of size \\(n\\), we can use linear search, binary search, tree search, hash-based search, and other methods to search for the target element. The working principles of each method are shown in Figure 10-11.</p> <p></p> <p> Figure 10-11   Multiple search strategies </p> <p>The operational efficiency and characteristics of the above methods are as follows:</p> <p> Table 10-1   Comparison of search algorithm efficiency </p> Linear search Binary search Tree search Hash-based search Search element \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) Insert element \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Delete element \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Extra space \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) Data preprocessing / Sorting \\(O(n \\log n)\\) Tree building \\(O(n \\log n)\\) Hash table building \\(O(n)\\) Data ordered Unordered Ordered Ordered Unordered <p>The choice of search algorithm also depends on data volume, search performance requirements, data query and update frequency, etc.</p> <p>Linear search</p> <ul> <li>Good generality, requiring no data preprocessing operations. If we only need to query the data once, the data preprocessing time for the other three methods would be longer than linear search.</li> <li>Suitable for small data volumes, where time complexity has less impact on efficiency.</li> <li>Suitable for scenarios with high data update frequency, as this method does not require any additional data maintenance.</li> </ul> <p>Binary search</p> <ul> <li>Suitable for large data volumes with stable efficiency performance, worst-case time complexity of \\(O(\\log n)\\).</li> <li>Data volume cannot be too large, as storing arrays requires contiguous memory space.</li> <li>Not suitable for scenarios with frequent data insertion and deletion, as maintaining a sorted array has high overhead.</li> </ul> <p>Hash-based search</p> <ul> <li>Suitable for scenarios with high query performance requirements, with an average time complexity of \\(O(1)\\).</li> <li>Not suitable for scenarios requiring ordered data or range searches, as hash tables cannot maintain data orderliness.</li> <li>High dependence on hash functions and hash collision handling strategies, with significant risk of performance degradation.</li> <li>Not suitable for excessively large data volumes, as hash tables require extra space to minimize collisions and thus provide good query performance.</li> </ul> <p>Tree search</p> <ul> <li>Suitable for massive data, as tree nodes are stored dispersedly in memory.</li> <li>Suitable for scenarios requiring maintained ordered data or range searches.</li> <li>During continuous node insertion and deletion, binary search trees may become skewed, degrading time complexity to \\(O(n)\\).</li> <li>If using AVL trees or red-black trees, all operations can run stably at \\(O(\\log n)\\) efficiency, but operations to maintain tree balance add extra overhead.</li> </ul>","path":["Chapter 10. Searching","10.5 &nbsp; Searching Algorithms Revisited"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   Summary","text":"","path":["Chapter 10. Searching","10.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_searching/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Binary search relies on data orderliness and progressively reduces the search interval by half through loops. It requires input data to be sorted and is only applicable to arrays or data structures based on array implementations.</li> <li>Brute-force search locates data by traversing the data structure. Linear search is applicable to arrays and linked lists, while breadth-first search and depth-first search are applicable to graphs and trees. Such algorithms have good generality and require no data preprocessing, but have a relatively high time complexity of \\(O(n)\\).</li> <li>Hash-based search, tree search, and binary search are efficient search methods that can quickly locate target elements in specific data structures. Such algorithms are highly efficient with time complexity reaching \\(O(\\log n)\\) or even \\(O(1)\\), but typically require additional data structures.</li> <li>In practice, we need to analyze factors such as data scale, search performance requirements, and data query and update frequency to choose the appropriate search method.</li> <li>Linear search is suitable for small-scale or frequently updated data; binary search is suitable for large-scale, sorted data; hash-based search is suitable for data with high query efficiency requirements and no need for range queries; tree search is suitable for large-scale dynamic data that needs to maintain order and support range queries.</li> <li>Replacing linear search with hash-based search is a commonly used strategy to optimize runtime, reducing time complexity from \\(O(n)\\) to \\(O(1)\\).</li> </ul>","path":["Chapter 10. Searching","10.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"Chapter 11.   Sorting","text":"<p>Abstract</p> <p>Sorting is like a magic key that transforms chaos into order, enabling us to understand and process data more efficiently.</p> <p>Whether it's simple ascending order or complex categorized arrangements, sorting demonstrates the harmonious beauty of data.</p>","path":["Chapter 11. Sorting","Chapter 11. &nbsp; Sorting"],"tags":[]},{"location":"chapter_sorting/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>11.1   Sorting Algorithms</li> <li>11.2   Selection Sort</li> <li>11.3   Bubble Sort</li> <li>11.4   Insertion Sort</li> <li>11.5   Quick Sort</li> <li>11.6   Merge Sort</li> <li>11.7   Heap Sort</li> <li>11.8   Bucket Sort</li> <li>11.9   Counting Sort</li> <li>11.10   Radix Sort</li> <li>11.11   Summary</li> </ul>","path":["Chapter 11. Sorting","Chapter 11. &nbsp; Sorting"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   Bubble Sort","text":"<p>Bubble sort (bubble sort) achieves sorting by continuously comparing and swapping adjacent elements. This process is like bubbles rising from the bottom to the top, hence the name bubble sort.</p> <p>As shown in Figure 11-4, the bubbling process can be simulated using element swap operations: starting from the leftmost end of the array and traversing to the right, compare the size of adjacent elements, and if \"left element &gt; right element\", swap them. After completing the traversal, the largest element will be moved to the rightmost end of the array.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-4   Simulating bubble using element swap operation </p>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131-algorithm-flow","level":2,"title":"11.3.1   Algorithm Flow","text":"<p>Assume the array has length \\(n\\). The steps of bubble sort are shown in Figure 11-5.</p> <ol> <li>First, perform \"bubbling\" on \\(n\\) elements, swapping the largest element of the array to its correct position.</li> <li>Next, perform \"bubbling\" on the remaining \\(n - 1\\) elements, swapping the second largest element to its correct position.</li> <li>And so on. After \\(n - 1\\) rounds of \"bubbling\", the largest \\(n - 1\\) elements have all been swapped to their correct positions.</li> <li>The only remaining element must be the smallest element, requiring no sorting, so the array sorting is complete.</li> </ol> <p></p> <p> Figure 11-5   Bubble sort flow </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"Bubble sort\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [0, i]\n    for i in range(n - 1, 0, -1):\n        # Inner loop: swap the largest element in the unsorted interval [0, i] to the rightmost end of the interval\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* Bubble sort */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                // Using std::swap() function here\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Bubble sort */\nvoid bubbleSort(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Bubble sort */\nvoid BubbleSort(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Bubble sort */\nfunc bubbleSort(nums []int) {\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Bubble sort */\nfunc bubbleSort(nums: inout [Int]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Bubble sort */\nfunction bubbleSort(nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Bubble sort */\nfunction bubbleSort(nums: number[]): void {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Bubble sort */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // Outer loop: unsorted range is [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Bubble sort */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Bubble sort */\nvoid bubbleSort(int nums[], int size) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Bubble sort */\nfun bubbleSort(nums: IntArray) {\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Bubble sort ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Outer loop: unsorted range is [0, i]\n  for i in (n - 1).downto(1)\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132-efficiency-optimization","level":2,"title":"11.3.2   Efficiency Optimization","text":"<p>We notice that if no swap operations are performed during a certain round of \"bubbling\", it means the array has already completed sorting and can directly return the result. Therefore, we can add a flag <code>flag</code> to monitor this situation and return immediately once it occurs.</p> <p>After optimization, the worst-case time complexity and average time complexity of bubble sort remain \\(O(n^2)\\); but when the input array is completely ordered, the best-case time complexity can reach \\(O(n)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"Bubble sort (flag optimization)\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # Initialize flag\n        # Inner loop: swap the largest element in the unsorted interval [0, i] to the rightmost end of the interval\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Swap nums[j] and nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # Record element swap\n        if not flag:\n            break  # No elements were swapped in this round of \"bubbling\", exit directly\n</code></pre> bubble_sort.cpp<pre><code>/* Bubble sort (flag optimization)*/\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                // Using std::swap() function here\n                swap(nums[j], nums[j + 1]);\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag)\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag)\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Bubble sort (flag optimization) */\nvoid BubbleSortWithFlag(int[] nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // Record element swap\n            }\n        }\n        if (!flag) break;     // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Bubble sort (flag optimization) */\nfunc bubbleSortWithFlag(nums []int) {\n    // Outer loop: unsorted range is [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Swap nums[j] and nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // Record element swap\n            }\n        }\n        if flag == false { // No elements were swapped in this round of \"bubbling\", exit directly\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Bubble sort (flag optimization) */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // Initialize flag\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // Record element swap\n            }\n        }\n        if !flag { // No elements were swapped in this round of \"bubbling\", exit directly\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Bubble sort (flag optimization) */\nfunction bubbleSortWithFlag(nums) {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Bubble sort (flag optimization) */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // Outer loop: unsorted range is [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Record element swap\n            }\n        }\n        if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // Outer loop: unsorted range is [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // Initialize flag\n    // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Swap nums[j] and nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // Record element swap\n      }\n    }\n    if (!flag) break; // No elements were swapped in this round of \"bubbling\", exit directly\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Bubble sort (flag optimization) */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // Outer loop: unsorted range is [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Swap nums[j] and nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // Record element swap\n            }\n        }\n        if !flag {\n            break; // No elements were swapped in this round of \"bubbling\", exit directly\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Bubble sort (flag optimization) */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // Outer loop: unsorted range is [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Bubble sort (flag optimization) */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // Outer loop: unsorted range is [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // Initialize flag\n        // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Swap nums[j] and nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // Record element swap\n            }\n        }\n        if (!flag) break // No elements were swapped in this round of \"bubbling\", exit directly\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Bubble sort (flag optimization) ###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # Outer loop: unsorted range is [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # Initialize flag\n\n    # Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Swap nums[j] and nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # Record element swap\n      end\n    end\n\n    break unless flag # No elements were swapped in this round of \"bubbling\", exit directly\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133-algorithm-characteristics","level":2,"title":"11.3.3   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), adaptive sorting: The array lengths traversed in each round of \"bubbling\" are \\(n - 1\\), \\(n - 2\\), \\(\\dots\\), \\(2\\), \\(1\\), totaling \\((n - 1) n / 2\\). After introducing the <code>flag</code> optimization, the best-case time complexity can reach \\(O(n)\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Stable sorting: Since equal elements are not swapped during \"bubbling\".</li> </ul>","path":["Chapter 11. Sorting","11.3 &nbsp; Bubble Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   Bucket Sort","text":"<p>The several sorting algorithms mentioned earlier all belong to \"comparison-based sorting algorithms\", which achieve sorting by comparing the size of elements. The time complexity of such sorting algorithms cannot exceed \\(O(n \\log n)\\). Next, we will explore several \"non-comparison sorting algorithms\", whose time complexity can reach linear order.</p> <p>Bucket sort (bucket sort) is a typical application of the divide-and-conquer strategy. It works by setting up buckets with size order, each bucket corresponding to a data range, evenly distributing data to each bucket; then, sorting within each bucket separately; finally, merging all data in the order of the buckets.</p>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181-algorithm-flow","level":2,"title":"11.8.1   Algorithm Flow","text":"<p>Consider an array of length \\(n\\), whose elements are floating-point numbers in the range \\([0, 1)\\). The flow of bucket sort is shown in Figure 11-13.</p> <ol> <li>Initialize \\(k\\) buckets and distribute the \\(n\\) elements into the \\(k\\) buckets.</li> <li>Sort each bucket separately (here we use the built-in sorting function of the programming language).</li> <li>Merge the results in order from smallest to largest bucket.</li> </ol> <p></p> <p> Figure 11-13   Bucket sort algorithm flow </p> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"Bucket sort\"\"\"\n    # Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. Distribute array elements into various buckets\n    for num in nums:\n        # Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        i = int(num * k)\n        # Add num to bucket i\n        buckets[i].append(num)\n    # 2. Sort each bucket\n    for bucket in buckets:\n        # Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort()\n    # 3. Traverse buckets to merge results\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* Bucket sort */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. Distribute array elements into various buckets\n    for (float num : nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = num * k;\n        // Add num to bucket bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. Sort each bucket\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. Traverse buckets to merge results\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* Bucket sort */\nvoid bucketSort(float[] nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. Distribute array elements into various buckets\n    for (float num : nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = (int) (num * k);\n        // Add num to bucket i\n        buckets.get(i).add(num);\n    }\n    // 2. Sort each bucket\n    for (List&lt;Float&gt; bucket : buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        Collections.sort(bucket);\n    }\n    // 3. Traverse buckets to merge results\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* Bucket sort */\nvoid BucketSort(float[] nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. Distribute array elements into various buckets\n    foreach (float num in nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        int i = (int)(num * k);\n        // Add num to bucket i\n        buckets[i].Add(num);\n    }\n    // 2. Sort each bucket\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.Sort();\n    }\n    // 3. Traverse buckets to merge results\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* Bucket sort */\nfunc bucketSort(nums []float64) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. Distribute array elements into various buckets\n    for _, num := range nums {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        i := int(num * float64(k))\n        // Add num to bucket i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. Sort each bucket\n    for i := 0; i &lt; k; i++ {\n        // Use built-in slice sorting function, can also be replaced with other sorting algorithms\n        sort.Float64s(buckets[i])\n    }\n    // 3. Traverse buckets to merge results\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* Bucket sort */\nfunc bucketSort(nums: inout [Double]) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. Distribute array elements into various buckets\n    for num in nums {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        let i = Int(num * Double(k))\n        // Add num to bucket i\n        buckets[i].append(num)\n    }\n    // 2. Sort each bucket\n    for i in buckets.indices {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        buckets[i].sort()\n    }\n    // 3. Traverse buckets to merge results\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* Bucket sort */\nfunction bucketSort(nums) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Distribute array elements into various buckets\n    for (const num of nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        const i = Math.floor(num * k);\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for (const bucket of buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Traverse buckets to merge results\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* Bucket sort */\nfunction bucketSort(nums: number[]): void {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Distribute array elements into various buckets\n    for (const num of nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        const i = Math.floor(num * k);\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for (const bucket of buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Traverse buckets to merge results\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* Bucket sort */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. Distribute array elements into various buckets\n  for (double _num in nums) {\n    // Input data range is [0, 1), use _num * k to map to index range [0, k-1]\n    int i = (_num * k).toInt();\n    // Add _num to bucket bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. Sort each bucket\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. Traverse buckets to merge results\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* Bucket sort */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. Distribute array elements into various buckets\n    for &amp;num in nums.iter() {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        let i = (num * k as f64) as usize;\n        // Add num to bucket i\n        buckets[i].push(num);\n    }\n    // 2. Sort each bucket\n    for bucket in &amp;mut buckets {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. Traverse buckets to merge results\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* Bucket sort */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // Initialize k = n/2 buckets\n    int *sizes = malloc(k * sizeof(int));          // Record each bucket's size\n    float **buckets = malloc(k * sizeof(float *)); // Array of dynamic arrays (buckets)\n    // Pre-allocate sufficient space for each bucket\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. Distribute array elements into various buckets\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. Sort each bucket\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. Merge sorted buckets\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // Free memory\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* Bucket sort */\nfun bucketSort(nums: FloatArray) {\n    // Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. Distribute array elements into various buckets\n    for (num in nums) {\n        // Input data range is [0, 1), use num * k to map to index range [0, k-1]\n        val i = (num * k).toInt()\n        // Add num to bucket i\n        buckets[i].add(num)\n    }\n    // 2. Sort each bucket\n    for (bucket in buckets) {\n        // Use built-in sorting function, can also replace with other sorting algorithms\n        bucket.sort()\n    }\n    // 3. Traverse buckets to merge results\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### Bucket sort ###\ndef bucket_sort(nums)\n  # Initialize k = n/2 buckets, expected to allocate 2 elements per bucket\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. Distribute array elements into various buckets\n  nums.each do |num|\n    # Input data range is [0, 1), use num * k to map to index range [0, k-1]\n    i = (num * k).to_i\n    # Add num to bucket i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. Sort each bucket\n  buckets.each do |bucket|\n    # Use built-in sorting function, can also replace with other sorting algorithms\n    bucket.sort!\n  end\n\n  # 3. Traverse buckets to merge results\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182-algorithm-characteristics","level":2,"title":"11.8.2   Algorithm Characteristics","text":"<p>Bucket sort is suitable for processing very large data volumes. For example, if the input data contains 1 million elements and system memory cannot load all the data at once, the data can be divided into 1000 buckets, each bucket sorted separately, and then the results merged.</p> <ul> <li>Time complexity of \\(O(n + k)\\): Assuming the elements are evenly distributed among the buckets, then the number of elements in each bucket is \\(\\frac{n}{k}\\). Assuming sorting a single bucket uses \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) time, then sorting all buckets uses \\(O(n \\log\\frac{n}{k})\\) time. When the number of buckets \\(k\\) is relatively large, the time complexity approaches \\(O(n)\\). Merging results requires traversing all buckets and elements, taking \\(O(n + k)\\) time. In the worst case, all data is distributed into one bucket, and sorting that bucket uses \\(O(n^2)\\) time.</li> <li>Space complexity of \\(O(n + k)\\), non-in-place sorting: Additional space is required for \\(k\\) buckets and a total of \\(n\\) elements.</li> <li>Whether bucket sort is stable depends on whether the algorithm for sorting elements within buckets is stable.</li> </ul>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183-how-to-achieve-even-distribution","level":2,"title":"11.8.3   How to Achieve Even Distribution","text":"<p>Theoretically, bucket sort can achieve \\(O(n)\\) time complexity. The key is to evenly distribute elements to each bucket, because real data is often not evenly distributed. For example, if we want to evenly distribute all products on Taobao into 10 buckets by price range, there may be very many products below 100 yuan and very few above 1000 yuan. If the price intervals are evenly divided into 10, the difference in the number of products in each bucket will be very large.</p> <p>To achieve even distribution, we can first set an approximate dividing line to roughly divide the data into 3 buckets. After distribution is complete, continue dividing buckets with more products into 3 buckets until the number of elements in all buckets is roughly equal.</p> <p>As shown in Figure 11-14, this method essentially creates a recursion tree, with the goal of making the values of leaf nodes as even as possible. Of course, it is not necessary to divide the data into 3 buckets every round; the specific division method can be flexibly chosen according to data characteristics.</p> <p></p> <p> Figure 11-14   Recursively dividing buckets </p> <p>If we know the probability distribution of product prices in advance, we can set the price dividing line for each bucket based on the data probability distribution. It is worth noting that the data distribution does not necessarily need to be specifically calculated, but can also be approximated using a certain probability model based on data characteristics.</p> <p>As shown in Figure 11-15, we assume that product prices follow a normal distribution, which allows us to reasonably set price intervals to evenly distribute products to each bucket.</p> <p></p> <p> Figure 11-15   Dividing buckets based on probability distribution </p>","path":["Chapter 11. Sorting","11.8 &nbsp; Bucket Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   Counting Sort","text":"<p>Counting sort (counting sort) achieves sorting by counting the number of elements, typically applied to integer arrays.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191-simple-implementation","level":2,"title":"11.9.1   Simple Implementation","text":"<p>Let's start with a simple example. Given an array <code>nums</code> of length \\(n\\), where the elements are all \"non-negative integers\", the overall flow of counting sort is shown in Figure 11-16.</p> <ol> <li>Traverse the array to find the largest number, denoted as \\(m\\), and then create an auxiliary array <code>counter</code> of length \\(m + 1\\).</li> <li>Use <code>counter</code> to count the number of occurrences of each number in <code>nums</code>, where <code>counter[num]</code> corresponds to the number of occurrences of the number <code>num</code>. The counting method is simple: just traverse <code>nums</code> (let the current number be <code>num</code>), and increase <code>counter[num]</code> by \\(1\\) in each round.</li> <li>Since each index of <code>counter</code> is naturally ordered, this is equivalent to all numbers being sorted. Next, we traverse <code>counter</code> and fill in <code>nums</code> in ascending order based on the number of occurrences of each number.</li> </ol> <p></p> <p> Figure 11-16   Counting sort flow </p> <p>The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"Counting sort\"\"\"\n    # Simple implementation, cannot be used for sorting objects\n    # 1. Count the maximum element m in the array\n    m = 0\n    for num in nums:\n        m = max(m, num)\n    # 2. Count the occurrence of each number\n    # counter[num] represents the occurrence of num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Traverse counter, filling each element back into the original array nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid CountingSortNaive(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunc countingSortNaive(nums []int) {\n    // 1. Count the maximum element m in the array\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. Count the maximum element m in the array\n    let m = nums.max()!\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunction countingSortNaive(nums) {\n    // 1. Count the maximum element m in the array\n    let m = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfunction countingSortNaive(nums: number[]): void {\n    // 1. Count the maximum element m in the array\n    let m: number = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. Count the maximum element m in the array\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Count the occurrence of each number\n  // counter[_num] represents occurrence count of _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Traverse counter, filling each element back into the original array nums\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. Count the maximum element m in the array\n    let m = *nums.iter().max().unwrap();\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nvoid countingSortNaive(int nums[], int size) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. Free memory\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Counting sort */\n// Simple implementation, cannot be used for sorting objects\nfun countingSortNaive(nums: IntArray) {\n    // 1. Count the maximum element m in the array\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Traverse counter, filling each element back into the original array nums\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Counting sort ###\ndef counting_sort_naive(nums)\n  # Simple implementation, cannot be used for sorting objects\n  # 1. Count the maximum element m in the array\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. Count the occurrence of each number\n  # counter[num] represents the occurrence of num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Traverse counter, filling each element back into the original array nums\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> <p>Connection between counting sort and bucket sort</p> <p>From the perspective of bucket sort, we can regard each index of the counting array <code>counter</code> in counting sort as a bucket, and the process of counting quantities as distributing each element to the corresponding bucket. Essentially, counting sort is a special case of bucket sort for integer data.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192-complete-implementation","level":2,"title":"11.9.2   Complete Implementation","text":"<p>Observant readers may have noticed that if the input data is objects, step <code>3.</code> above becomes invalid. Suppose the input data is product objects, and we want to sort the products by price (a member variable of the class), but the above algorithm can only give the sorting result of prices.</p> <p>So how can we obtain the sorting result of the original data? We first calculate the \"prefix sum\" of <code>counter</code>. As the name suggests, the prefix sum at index <code>i</code>, <code>prefix[i]</code>, equals the sum of the first <code>i</code> elements of the array:</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>The prefix sum has a clear meaning: <code>prefix[num] - 1</code> represents the index of the last occurrence of element <code>num</code> in the result array <code>res</code>. This information is very critical because it tells us where each element should appear in the result array. Next, we traverse each element <code>num</code> of the original array <code>nums</code> in reverse order, performing the following two steps in each iteration.</p> <ol> <li>Fill <code>num</code> into the array <code>res</code> at index <code>prefix[num] - 1</code>.</li> <li>Decrease the prefix sum <code>prefix[num]</code> by \\(1\\) to get the index for the next placement of <code>num</code>.</li> </ol> <p>After the traversal is complete, the array <code>res</code> contains the sorted result, and finally <code>res</code> is used to overwrite the original array <code>nums</code>. The complete counting sort flow is shown in Figure 11-17.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-17   Counting sort steps </p> <p>The implementation code of counting sort is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"Counting sort\"\"\"\n    # Complete implementation, can sort objects and is a stable sort\n    # 1. Count the maximum element m in the array\n    m = max(nums)\n    # 2. Count the occurrence of each number\n    # counter[num] represents the occurrence of num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    # counter[num]-1 is the last index where num appears in res\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. Traverse nums in reverse order, placing each element into the result array res\n    # Initialize the array res to record results\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # Place num at the corresponding index\n        counter[num] -= 1  # Decrement the prefix sum by 1, getting the next index to place num\n    # Use result array res to overwrite the original array nums\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--;              // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid CountingSort(int[] nums) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunc countingSort(nums []int) {\n    // 1. Count the maximum element m in the array\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // Place num at the corresponding index\n        res[counter[num]-1] = num\n        // Decrement the prefix sum by 1, getting the next index to place num\n        counter[num]--\n    }\n    // Use result array res to overwrite the original array nums\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunc countingSort(nums: inout [Int]) {\n    // 1. Count the maximum element m in the array\n    let m = nums.max()!\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // Place num at the corresponding index\n        counter[num] -= 1 // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunction countingSort(nums) {\n    // 1. Count the maximum element m in the array\n    let m = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfunction countingSort(nums: number[]): void {\n    // 1. Count the maximum element m in the array\n    let m: number = Math.max(...nums);\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. Count the maximum element m in the array\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Count the occurrence of each number\n  // counter[_num] represents occurrence count of _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n  // That is, counter[_num]-1 is the last occurrence index of _num in res\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. Traverse nums in reverse order, placing each element into the result array res\n  // Initialize the array res to record results\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // Place _num at corresponding index\n    counter[_num]--; // Decrement prefix sum by 1 to get next placement index for _num\n  }\n  // Use result array res to overwrite the original array nums\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. Count the maximum element m in the array\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // Place num at the corresponding index\n        counter[num as usize] -= 1; // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nvoid countingSort(int nums[], int size) {\n    // 1. Count the maximum element m in the array\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Place num at the corresponding index\n        counter[num]--;              // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    memcpy(nums, res, size * sizeof(int));\n    // 5. Free memory\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Counting sort */\n// Complete implementation, can sort objects and is a stable sort\nfun countingSort(nums: IntArray) {\n    // 1. Count the maximum element m in the array\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Count the occurrence of each number\n    // counter[num] represents the occurrence of num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n    // counter[num]-1 is the last index where num appears in res\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Traverse nums in reverse order, placing each element into the result array res\n    // Initialize the array res to record results\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // Place num at the corresponding index\n        counter[num]-- // Decrement the prefix sum by 1, getting the next index to place num\n    }\n    // Use result array res to overwrite the original array nums\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Counting sort ###\ndef counting_sort(nums)\n  # Complete implementation, can sort objects and is a stable sort\n  # 1. Count the maximum element m in the array\n  m = nums.max\n  # 2. Count the occurrence of each number\n  # counter[num] represents the occurrence of num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Calculate the prefix sum of counter, converting \"occurrence count\" to \"tail index\"\n  # counter[num]-1 is the last index where num appears in res\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. Traverse nums in reverse, fill elements into result array res\n  # Initialize the array res to record results\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # Place num at the corresponding index\n    counter[num] -= 1 # Decrement the prefix sum by 1, getting the next index to place num\n  end\n  # Use result array res to overwrite the original array nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193-algorithm-characteristics","level":2,"title":"11.9.3   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n + m)\\), non-adaptive sorting: Involves traversing <code>nums</code> and traversing <code>counter</code>, both using linear time. Generally, \\(n \\gg m\\), and time complexity tends toward \\(O(n)\\).</li> <li>Space complexity of \\(O(n + m)\\), non-in-place sorting: Uses arrays <code>res</code> and <code>counter</code> of lengths \\(n\\) and \\(m\\) respectively.</li> <li>Stable sorting: Since elements are filled into <code>res</code> in a \"right-to-left\" order, traversing <code>nums</code> in reverse can avoid changing the relative positions of equal elements, thereby achieving stable sorting. In fact, traversing <code>nums</code> in forward order can also yield correct sorting results, but the result would be unstable.</li> </ul>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194-limitations","level":2,"title":"11.9.4   Limitations","text":"<p>By this point, you might think counting sort is very clever, as it can achieve efficient sorting just by counting quantities. However, the prerequisites for using counting sort are relatively strict.</p> <p>Counting sort is only suitable for non-negative integers. If you want to apply it to other types of data, you need to ensure that the data can be converted to non-negative integers without changing the relative size relationships between elements. For example, for an integer array containing negative numbers, you can first add a constant to all numbers to convert them all to positive numbers, and then convert them back after sorting is complete.</p> <p>Counting sort is suitable for situations where the data volume is large but the data range is small. For example, in the above example, \\(m\\) cannot be too large, otherwise it will occupy too much space. And when \\(n \\ll m\\), counting sort uses \\(O(m)\\) time, which may be slower than \\(O(n \\log n)\\) sorting algorithms.</p>","path":["Chapter 11. Sorting","11.9 &nbsp; Counting Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   Heap Sort","text":"<p>Tip</p> <p>Before reading this section, please ensure you have completed the \"Heap\" chapter.</p> <p>Heap sort (heap sort) is an efficient sorting algorithm based on the heap data structure. We can use the \"build heap operation\" and \"element out-heap operation\" that we have already learned to implement heap sort.</p> <ol> <li>Input the array and build a min-heap, at which point the smallest element is at the heap top.</li> <li>Continuously perform the out-heap operation, record the out-heap elements in sequence, and an ascending sorted sequence can be obtained.</li> </ol> <p>Although the above method is feasible, it requires an additional array to save the popped elements, which is quite wasteful of space. In practice, we usually use a more elegant implementation method.</p>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171-algorithm-flow","level":2,"title":"11.7.1   Algorithm Flow","text":"<p>Assume the array length is \\(n\\). The flow of heap sort is shown in Figure 11-12.</p> <ol> <li>Input the array and build a max-heap. After completion, the largest element is at the heap top.</li> <li>Swap the heap top element (first element) with the heap bottom element (last element). After the swap is complete, reduce the heap length by \\(1\\) and increase the count of sorted elements by \\(1\\).</li> <li>Starting from the heap top element, perform top-to-bottom heapify operation (sift down). After heapify is complete, the heap property is restored.</li> <li>Loop through steps <code>2.</code> and <code>3.</code> After looping \\(n - 1\\) rounds, the array sorting can be completed.</li> </ol> <p>Tip</p> <p>In fact, the element out-heap operation also includes steps <code>2.</code> and <code>3.</code>, with just an additional step to pop the element.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-12   Heap sort steps </p> <p>In the code implementation, we use the same top-to-bottom heapify function <code>sift_down()</code> from the \"Heap\" chapter. It is worth noting that since the heap length will decrease as the largest element is extracted, we need to add a length parameter \\(n\\) to the <code>sift_down()</code> function to specify the current effective length of the heap. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"Heap length is n, start heapifying node i, from top to bottom\"\"\"\n    while True:\n        # Determine the largest node among i, l, r, noted as ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # If node i is the largest or indices l, r are out of bounds, no further heapification needed, break\n        if ma == i:\n            break\n        # Swap two nodes\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # Loop downwards heapification\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"Heap sort\"\"\"\n    # Build heap operation: heapify all nodes except leaves\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # Extract the largest element from the heap and repeat for n-1 rounds\n    for i in range(len(nums) - 1, 0, -1):\n        # Swap the root node with the rightmost leaf node (swap the first element with the last element)\n        nums[0], nums[i] = nums[i], nums[0]\n        # Start heapifying the root node, from top to bottom\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i) {\n            break;\n        }\n        // Swap two nodes\n        swap(nums[i], nums[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // Delete node\n        swap(nums[0], nums[i]);\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(int[] nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i)\n            break;\n        // Swap two nodes\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid HeapSort(int[] nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Delete node\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // Start heapifying the root node, from top to bottom\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfunc heapSort(nums *[]int) {\n    // Build heap operation: heapify all nodes except leaves\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // Delete node\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // Swap two nodes\n        if ma == i {\n            break\n        }\n        // Swap two nodes\n        nums.swapAt(i, ma)\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfunc heapSort(nums: inout [Int]) {\n    // Build heap operation: heapify all nodes except leaves\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i in nums.indices.dropFirst().reversed() {\n        // Delete node\n        nums.swapAt(0, i)\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Swap two nodes\n        if (ma === i) {\n            break;\n        }\n        // Swap two nodes\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfunction heapSort(nums) {\n    // Build heap operation: heapify all nodes except leaves\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Swap two nodes\n        if (ma === i) {\n            break;\n        }\n        // Swap two nodes\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfunction heapSort(nums: number[]): void {\n    // Build heap operation: heapify all nodes except leaves\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Delete node\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // Swap two nodes\n    if (ma == i) break;\n    // Swap two nodes\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // Loop downwards heapification\n    i = ma;\n  }\n}\n\n/* Heap sort */\nvoid heapSort(List&lt;int&gt; nums) {\n  // Build heap operation: heapify all nodes except leaves\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // Extract the largest element from the heap and repeat for n-1 rounds\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Delete node\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // Start heapifying the root node, from top to bottom\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // Swap two nodes\n        if ma == i {\n            break;\n        }\n        // Swap two nodes\n        nums.swap(i, ma);\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // Build heap operation: heapify all nodes except leaves\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for i in (1..nums.len()).rev() {\n        // Delete node\n        nums.swap(0, i);\n        // Start heapifying the root node, from top to bottom\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Swap two nodes\n        if (ma == i) {\n            break;\n        }\n        // Swap two nodes\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Loop downwards heapification\n        i = ma;\n    }\n}\n\n/* Heap sort */\nvoid heapSort(int nums[], int n) {\n    // Build heap operation: heapify all nodes except leaves\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (int i = n - 1; i &gt; 0; --i) {\n        // Delete node\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* Heap length is n, start heapifying node i, from top to bottom */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // Swap two nodes\n        if (ma == i) \n            break\n        // Swap two nodes\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // Loop downwards heapification\n        i = ma\n    }\n}\n\n/* Heap sort */\nfun heapSort(nums: IntArray) {\n    // Build heap operation: heapify all nodes except leaves\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // Extract the largest element from the heap and repeat for n-1 rounds\n    for (i in nums.size - 1 downTo 1) {\n        // Delete node\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // Start heapifying the root node, from top to bottom\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### Heap length is n, heapify from node i, top to bottom ###\ndef sift_down(nums, n, i)\n  while true\n    # If node i is largest or indices l, r are out of bounds, no need to continue heapify, break\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # Swap two nodes\n    break if ma == i\n    # Swap two nodes\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # Loop downwards heapification\n    i = ma\n  end\nend\n\n### Heap sort ###\ndef heap_sort(nums)\n  # Build heap operation: heapify all nodes except leaves\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # Extract the largest element from the heap and repeat for n-1 rounds\n  (nums.length - 1).downto(1) do |i|\n    # Delete node\n    nums[0], nums[i] = nums[i], nums[0]\n    # Start heapifying the root node, from top to bottom\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172-algorithm-characteristics","level":2,"title":"11.7.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: The build heap operation uses \\(O(n)\\) time. Extracting the largest element from the heap has a time complexity of \\(O(\\log n)\\), looping a total of \\(n - 1\\) rounds.</li> <li>Space complexity of \\(O(1)\\), in-place sorting: A few pointer variables use \\(O(1)\\) space. Element swapping and heapify operations are both performed on the original array.</li> <li>Non-stable sorting: When swapping the heap top element and heap bottom element, the relative positions of equal elements may change.</li> </ul>","path":["Chapter 11. Sorting","11.7 &nbsp; Heap Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   Insertion Sort","text":"<p>Insertion sort (insertion sort) is a simple sorting algorithm that works very similarly to the process of manually organizing a deck of cards.</p> <p>Specifically, we select a base element from the unsorted interval, compare the element with elements in the sorted interval to its left one by one, and insert the element into the correct position.</p> <p>Figure 11-6 shows the operation flow of inserting an element into the array. Let the base element be <code>base</code>. We need to move all elements from the target index to <code>base</code> one position to the right, and then assign <code>base</code> to the target index.</p> <p></p> <p> Figure 11-6   Single insertion operation </p>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141-algorithm-flow","level":2,"title":"11.4.1   Algorithm Flow","text":"<p>The overall flow of insertion sort is shown in Figure 11-7.</p> <ol> <li>Initially, the first element of the array has completed sorting.</li> <li>Select the second element of the array as <code>base</code>, and after inserting it into the correct position, the first 2 elements of the array are sorted.</li> <li>Select the third element as <code>base</code>, and after inserting it into the correct position, the first 3 elements of the array are sorted.</li> <li>And so on. In the last round, select the last element as <code>base</code>, and after inserting it into the correct position, all elements are sorted.</li> </ol> <p></p> <p> Figure 11-7   Insertion sort flow </p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"Insertion sort\"\"\"\n    # Outer loop: sorted interval is [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # Move nums[j] to the right by one position\n            j -= 1\n        nums[j + 1] = base  # Assign base to the correct position\n</code></pre> insertion_sort.cpp<pre><code>/* Insertion sort */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* Insertion sort */\nvoid insertionSort(int[] nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base;        // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* Insertion sort */\nvoid InsertionSort(int[] nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = bas;         // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* Insertion sort */\nfunc insertionSort(nums []int) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // Move nums[j] to the right by one position\n            j--\n        }\n        nums[j+1] = base // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* Insertion sort */\nfunc insertionSort(nums: inout [Int]) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // Move nums[j] to the right by one position\n            j -= 1\n        }\n        nums[j + 1] = base // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* Insertion sort */\nfunction insertionSort(nums) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* Insertion sort */\nfunction insertionSort(nums: number[]): void {\n    // Outer loop: sorted interval is [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n            j--;\n        }\n        nums[j + 1] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* Insertion sort */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // Outer loop: sorted interval is [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // Move nums[j] to the right by one position\n      j--;\n    }\n    nums[j + 1] = base; // Assign base to the correct position\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* Insertion sort */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // Outer loop: sorted interval is [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // Move nums[j] to the right by one position\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* Insertion sort */\nvoid insertionSort(int nums[], int size) {\n    // Outer loop: sorted interval is [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // Move nums[j] to the right by one position\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // Assign base to the correct position\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* Insertion sort */\nfun insertionSort(nums: IntArray) {\n    // Outer loop: sorted elements are 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // Move nums[j] to the right by one position\n            j--\n        }\n        nums[j + 1] = base        // Assign base to the correct position\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### Insertion sort ###\ndef insertion_sort(nums)\n  n = nums.length\n  # Outer loop: sorted interval is [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # Inner loop: insert base into the correct position within the sorted interval [0, i-1]\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # Move nums[j] to the right by one position\n      j -= 1\n    end\n    nums[j + 1] = base # Assign base to the correct position\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142-algorithm-characteristics","level":2,"title":"11.4.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), adaptive sorting: In the worst case, each insertion operation requires loops of \\(n - 1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\), summing to \\((n - 1) n / 2\\), so the time complexity is \\(O(n^2)\\). When encountering ordered data, the insertion operation will terminate early. When the input array is completely ordered, insertion sort achieves the best-case time complexity of \\(O(n)\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Stable sorting: During the insertion operation process, we insert elements to the right of equal elements, without changing their order.</li> </ul>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143-advantages-of-insertion-sort","level":2,"title":"11.4.3   Advantages of Insertion Sort","text":"<p>The time complexity of insertion sort is \\(O(n^2)\\), while the time complexity of quick sort, which we will learn about next, is \\(O(n \\log n)\\). Although insertion sort has a higher time complexity, insertion sort is usually faster for smaller data volumes.</p> <p>This conclusion is similar to the applicable situations of linear search and binary search. Algorithms like quick sort with \\(O(n \\log n)\\) complexity are sorting algorithms based on divide-and-conquer strategy and often contain more unit computation operations. When the data volume is small, \\(n^2\\) and \\(n \\log n\\) are numerically close, and complexity does not dominate; the number of unit operations per round plays a decisive role.</p> <p>In fact, the built-in sorting functions in many programming languages (such as Java) adopt insertion sort. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategy, such as quick sort; for short arrays, directly use insertion sort.</p> <p>Although bubble sort, selection sort, and insertion sort all have a time complexity of \\(O(n^2)\\), in actual situations, insertion sort is used significantly more frequently than bubble sort and selection sort, mainly for the following reasons.</p> <ul> <li>Bubble sort is based on element swapping, requiring the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, the computational overhead of bubble sort is usually higher than that of insertion sort.</li> <li>Selection sort has a time complexity of \\(O(n^2)\\) in any case. If given a set of partially ordered data, insertion sort is usually more efficient than selection sort.</li> <li>Selection sort is unstable and cannot be applied to multi-level sorting.</li> </ul>","path":["Chapter 11. Sorting","11.4 &nbsp; Insertion Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   Merge Sort","text":"<p>Merge sort (merge sort) is a sorting algorithm based on the divide-and-conquer strategy, which includes the \"divide\" and \"merge\" phases shown in Figure 11-10.</p> <ol> <li>Divide phase: Recursively split the array from the midpoint, transforming the sorting problem of a long array into the sorting problems of shorter arrays.</li> <li>Merge phase: When the sub-array length is 1, terminate the division and start merging, continuously merging two shorter sorted arrays into one longer sorted array until the process is complete.</li> </ol> <p></p> <p> Figure 11-10   Divide and merge phases of merge sort </p>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161-algorithm-flow","level":2,"title":"11.6.1   Algorithm Flow","text":"<p>As shown in Figure 11-11, the \"divide phase\" recursively splits the array from the midpoint into two sub-arrays from top to bottom.</p> <ol> <li>Calculate the array midpoint <code>mid</code>, recursively divide the left sub-array (interval <code>[left, mid]</code>) and right sub-array (interval <code>[mid + 1, right]</code>).</li> <li>Recursively execute step <code>1.</code> until the sub-array interval length is 1, then terminate.</li> </ol> <p>The \"merge phase\" merges the left sub-array and right sub-array into a sorted array from bottom to top. Note that merging starts from sub-arrays of length 1, and each sub-array in the merge phase is sorted.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-11   Merge sort steps </p> <p>It can be observed that the recursive order of merge sort is consistent with the post-order traversal of a binary tree.</p> <ul> <li>Post-order traversal: First recursively traverse the left subtree, then recursively traverse the right subtree, and finally process the root node.</li> <li>Merge sort: First recursively process the left sub-array, then recursively process the right sub-array, and finally perform the merge.</li> </ul> <p>The implementation of merge sort is shown in the code below. Note that the interval to be merged in <code>nums</code> is <code>[left, right]</code>, while the corresponding interval in <code>tmp</code> is <code>[0, right - left]</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"Merge left subarray and right subarray\"\"\"\n    # Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    # Create a temporary array tmp to store the merged results\n    tmp = [0] * (right - left + 1)\n    # Initialize the start indices of the left and right subarrays\n    i, j, k = left, mid + 1, 0\n    # While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"Merge sort\"\"\"\n    # Termination condition\n    if left &gt;= right:\n        return  # Terminate recursion when subarray length is 1\n    # Divide and conquer stage\n    mid = (left + right) // 2  # Calculate midpoint\n    merge_sort(nums, left, mid)  # Recursively process the left subarray\n    merge_sort(nums, mid + 1, right)  # Recursively process the right subarray\n    # Merge stage\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* Merge left subarray and right subarray */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    vector&lt;int&gt; tmp(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    mergeSort(nums, left, mid);      // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* Merge left subarray and right subarray */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int[] tmp = new int[right - left + 1];\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid mergeSort(int[] nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2; // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* Merge left subarray and right subarray */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int[] tmp = new int[right - left + 1];\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nvoid MergeSort(int[] nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right) return;       // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    MergeSort(nums, left, mid);      // Recursively process the left subarray\n    MergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* Merge left subarray and right subarray */\nfunc merge(nums []int, left, mid, right int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    tmp := make([]int, right-left+1)\n    // Initialize the start indices of the left and right subarrays\n    i, j, k := left, mid+1, 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* Merge sort */\nfunc mergeSort(nums []int, left, right int) {\n    // Termination condition\n    if left &gt;= right {\n        return\n    }\n    // Divide and conquer stage\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // Merge stage\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* Merge left subarray and right subarray */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // Initialize the start indices of the left and right subarrays\n    var i = left, j = mid + 1, k = 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* Merge sort */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // Termination condition\n    if left &gt;= right { // Terminate recursion when subarray length is 1\n        return\n    }\n    // Divide and conquer stage\n    let mid = left + (right - left) / 2 // Calculate midpoint\n    mergeSort(nums: &amp;nums, left: left, right: mid) // Recursively process the left subarray\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // Recursively process the right subarray\n    // Merge stage\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* Merge left subarray and right subarray */\nfunction merge(nums, left, mid, right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    const tmp = new Array(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfunction mergeSort(nums, left, right) {\n    // Termination condition\n    if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    let mid = Math.floor(left + (right - left) / 2); // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* Merge left subarray and right subarray */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    const tmp = new Array(right - left + 1);\n    // Initialize the start indices of the left and right subarrays\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // Termination condition\n    if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    let mid = Math.floor(left + (right - left) / 2); // Calculate midpoint\n    mergeSort(nums, left, mid); // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* Merge left subarray and right subarray */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n  // Create a temporary array tmp to store the merged results\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // Initialize the start indices of the left and right subarrays\n  int i = left, j = mid + 1, k = 0;\n  // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // Copy the remaining elements of the left and right subarrays into the temporary array\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* Merge sort */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // Termination condition\n  if (left &gt;= right) return; // Terminate recursion when subarray length is 1\n  // Divide and conquer stage\n  int mid = left + (right - left) ~/ 2; // Calculate midpoint\n  mergeSort(nums, left, mid); // Recursively process the left subarray\n  mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n  // Merge stage\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* Merge left subarray and right subarray */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // Initialize the start indices of the left and right subarrays\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Merge sort */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // Termination condition\n    if left &gt;= right {\n        return; // Terminate recursion when subarray length is 1\n    }\n\n    // Divide and conquer stage\n    let mid = left + (right - left) / 2; // Calculate midpoint\n    merge_sort(nums, left, mid); // Recursively process the left subarray\n    merge_sort(nums, mid + 1, right); // Recursively process the right subarray\n\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* Merge left subarray and right subarray */\nvoid merge(int *nums, int left, int mid, int right) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // Initialize the start indices of the left and right subarrays\n    int i = left, j = mid + 1, k = 0;\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // Free memory\n    free(tmp);\n}\n\n/* Merge sort */\nvoid mergeSort(int *nums, int left, int right) {\n    // Termination condition\n    if (left &gt;= right)\n        return; // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    int mid = left + (right - left) / 2;    // Calculate midpoint\n    mergeSort(nums, left, mid);      // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right); // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* Merge left subarray and right subarray */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n    // Create a temporary array tmp to store the merged results\n    val tmp = IntArray(right - left + 1)\n    // Initialize the start indices of the left and right subarrays\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // While both subarrays still have elements, compare and copy the smaller element into the temporary array\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // Copy the remaining elements of the left and right subarrays into the temporary array\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* Merge sort */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // Termination condition\n    if (left &gt;= right) return  // Terminate recursion when subarray length is 1\n    // Divide and conquer stage\n    val mid = left + (right - left) / 2 // Calculate midpoint\n    mergeSort(nums, left, mid) // Recursively process the left subarray\n    mergeSort(nums, mid + 1, right) // Recursively process the right subarray\n    // Merge stage\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### Merge left and right subarrays ###\ndef merge(nums, left, mid, right)\n  # Left subarray interval is [left, mid], right subarray interval is [mid+1, right]\n  # Create temporary array tmp to store merged result\n  tmp = Array.new(right - left + 1, 0)\n  # Initialize the start indices of the left and right subarrays\n  i, j, k = left, mid + 1, 0\n  # While both subarrays still have elements, compare and copy the smaller element into the temporary array\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # Copy the remaining elements of the left and right subarrays into the temporary array\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # Copy the elements from the temporary array tmp back to the original array nums at the corresponding interval\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### Merge sort ###\ndef merge_sort(nums, left, right)\n  # Termination condition\n  # Terminate recursion when subarray length is 1\n  return if left &gt;= right\n  # Divide and conquer stage\n  mid = left + (right - left) / 2 # Calculate midpoint\n  merge_sort(nums, left, mid) # Recursively process the left subarray\n  merge_sort(nums, mid + 1, right) # Recursively process the right subarray\n  # Merge stage\n  merge(nums, left, mid, right)\nend\n</code></pre>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162-algorithm-characteristics","level":2,"title":"11.6.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: The division produces a recursion tree of height \\(\\log n\\), and the total number of merge operations at each level is \\(n\\), so the overall time complexity is \\(O(n \\log n)\\).</li> <li>Space complexity of \\(O(n)\\), non-in-place sorting: The recursion depth is \\(\\log n\\), using \\(O(\\log n)\\) size of stack frame space. The merge operation requires the aid of an auxiliary array, using \\(O(n)\\) size of additional space.</li> <li>Stable sorting: In the merge process, the order of equal elements remains unchanged.</li> </ul>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163-linked-list-sorting","level":2,"title":"11.6.3   Linked List Sorting","text":"<p>For linked lists, merge sort has significant advantages over other sorting algorithms, and can optimize the space complexity of linked list sorting tasks to \\(O(1)\\).</p> <ul> <li>Divide phase: \"Iteration\" can be used instead of \"recursion\" to implement linked list division work, thus saving the stack frame space used by recursion.</li> <li>Merge phase: In linked lists, node insertion and deletion operations can be achieved by just changing references (pointers), so there is no need to create additional linked lists during the merge phase (merging two short ordered linked lists into one long ordered linked list).</li> </ul> <p>The specific implementation details are quite complex, and interested readers can consult related materials for learning.</p>","path":["Chapter 11. Sorting","11.6 &nbsp; Merge Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   Quick Sort","text":"<p>Quick sort (quick sort) is a sorting algorithm based on the divide-and-conquer strategy, which operates efficiently and is widely applied.</p> <p>The core operation of quick sort is \"sentinel partitioning\", which aims to: select a certain element in the array as the \"pivot\", move all elements smaller than the pivot to its left, and move elements larger than the pivot to its right. Specifically, the flow of sentinel partitioning is shown in Figure 11-8.</p> <ol> <li>Select the leftmost element of the array as the pivot, and initialize two pointers <code>i</code> and <code>j</code> pointing to the two ends of the array.</li> <li>Set up a loop in which <code>i</code> (<code>j</code>) is used in each round to find the first element larger (smaller) than the pivot, and then swap these two elements.</li> <li>Loop through step <code>2.</code> until <code>i</code> and <code>j</code> meet, and finally swap the pivot to the boundary line of the two sub-arrays.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-8   Sentinel partitioning steps </p> <p>After sentinel partitioning is complete, the original array is divided into three parts: left sub-array, pivot, right sub-array, satisfying \"any element in left sub-array \\(\\leq\\) pivot \\(\\leq\\) any element in right sub-array\". Therefore, we next only need to sort these two sub-arrays.</p> <p>Divide-and-conquer strategy of quick sort</p> <p>The essence of sentinel partitioning is to simplify the sorting problem of a longer array into the sorting problems of two shorter arrays.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Sentinel partition\"\"\"\n    # Use nums[left] as the pivot\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Search from right to left for the first element smaller than the pivot\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Search from left to right for the first element greater than the pivot\n        # Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    # Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Return the index of the pivot\n</code></pre> quick_sort.cpp<pre><code>/* Sentinel partition */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Search from left to right for the first element greater than the pivot\n        swap(nums[i], nums[j]); // Swap these two elements\n    }\n    swap(nums[i], nums[left]);  // Swap the pivot to the boundary between the two subarrays\n    return i;                   // Return the index of the pivot\n}\n</code></pre> quick_sort.java<pre><code>/* Swap elements */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint partition(int[] nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.cs<pre><code>/* Swap elements */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* Sentinel partition */\nint Partition(int[] nums, int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        Swap(nums, i, j); // Swap these two elements\n    }\n    Swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.go<pre><code>/* Sentinel partition */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // Use nums[left] as the pivot\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Search from right to left for the first element smaller than the pivot\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.swift<pre><code>/* Sentinel partition */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // Search from left to right for the first element greater than the pivot\n        }\n        nums.swapAt(i, j) // Swap these two elements\n    }\n    nums.swapAt(i, left) // Swap the pivot to the boundary between the two subarrays\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.js<pre><code>/* Swap elements */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\npartition(nums, left, right) {\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.ts<pre><code>/* Swap elements */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\npartition(nums: number[], left: number, right: number): number {\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.dart<pre><code>/* Swap elements */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Use nums[left] as the pivot\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n    _swap(nums, i, j); // Swap these two elements\n  }\n  _swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n  return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.rs<pre><code>/* Sentinel partition */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Use nums[left] as the pivot\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        nums.swap(i, j); // Swap these two elements\n    }\n    nums.swap(i, left); // Swap the pivot to the boundary between the two subarrays\n    i // Return the index of the pivot\n}\n</code></pre> quick_sort.c<pre><code>/* Swap elements */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Sentinel partition */\nint partition(int nums[], int left, int right) {\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Search from left to right for the first element greater than the pivot\n        }\n        // Swap these two elements\n        swap(nums, i, j);\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    swap(nums, i, left);\n    // Return the index of the pivot\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* Swap elements */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* Sentinel partition */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j)  // Swap these two elements\n    }\n    swap(nums, i, left)   // Swap the pivot to the boundary between the two subarrays\n    return i              // Return the index of the pivot\n}\n</code></pre> quick_sort.rb<pre><code>### Sentinel partition ###\ndef partition(nums, left, right)\n  # Use nums[left] as the pivot\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Search from right to left for the first element smaller than the pivot\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Search from left to right for the first element greater than the pivot\n    end\n    # Swap elements\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Swap the pivot to the boundary between the two subarrays\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Return the index of the pivot\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151-algorithm-flow","level":2,"title":"11.5.1   Algorithm Flow","text":"<p>The overall flow of quick sort is shown in Figure 11-9.</p> <ol> <li>First, perform one \"sentinel partitioning\" on the original array to obtain the unsorted left sub-array and right sub-array.</li> <li>Then, recursively perform \"sentinel partitioning\" on the left sub-array and right sub-array respectively.</li> <li>Continue recursively until the sub-array length is 1, at which point sorting of the entire array is complete.</li> </ol> <p></p> <p> Figure 11-9   Quick sort flow </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Quick sort\"\"\"\n    # Terminate recursion when subarray length is 1\n    if left &gt;= right:\n        return\n    # Sentinel partition\n    pivot = self.partition(nums, left, right)\n    # Recursively process the left subarray and right subarray\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* Quick sort */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* Quick sort */\nvoid quickSort(int[] nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* Quick sort */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right)\n        return;\n    // Sentinel partition\n    int pivot = Partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* Quick sort */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return\n    }\n    // Sentinel partition\n    pivot := q.partition(nums, left, right)\n    // Recursively process the left subarray and right subarray\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* Quick sort */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return\n    }\n    // Sentinel partition\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // Recursively process the left subarray and right subarray\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Quick sort */\nquickSort(nums, left, right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) return;\n    // Sentinel partition\n    const pivot = this.partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* Quick sort */\nquickSort(nums: number[], left: number, right: number): void {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Sentinel partition\n    const pivot = this.partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* Quick sort */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Terminate recursion when subarray length is 1\n  if (left &gt;= right) return;\n  // Sentinel partition\n  int pivot = _partition(nums, left, right);\n  // Recursively process the left subarray and right subarray\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* Quick sort */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // Terminate recursion when subarray length is 1\n    if left &gt;= right {\n        return;\n    }\n    // Sentinel partition\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // Recursively process the left subarray and right subarray\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* Quick sort */\nvoid quickSort(int nums[], int left, int right) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Sentinel partition\n    int pivot = partition(nums, left, right);\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* Quick sort */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // Terminate recursion when subarray length is 1\n    if (left &gt;= right) return\n    // Sentinel partition\n    val pivot = partition(nums, left, right)\n    // Recursively process the left subarray and right subarray\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### Quick sort class ###\ndef quick_sort(nums, left, right)\n  # Recurse when subarray length is not 1\n  if left &lt; right\n    # Sentinel partition\n    pivot = partition(nums, left, right)\n    # Recursively process the left subarray and right subarray\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152-algorithm-characteristics","level":2,"title":"11.5.2   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n \\log n)\\), non-adaptive sorting: In the average case, the number of recursive levels of sentinel partitioning is \\(\\log n\\), and the total number of loops at each level is \\(n\\), using \\(O(n \\log n)\\) time overall. In the worst case, each round of sentinel partitioning divides an array of length \\(n\\) into two sub-arrays of length \\(0\\) and \\(n - 1\\), at which point the number of recursive levels reaches \\(n\\), the number of loops at each level is \\(n\\), and the total time used is \\(O(n^2)\\).</li> <li>Space complexity of \\(O(n)\\), in-place sorting: In the case where the input array is completely reversed, the worst recursive depth reaches \\(n\\), using \\(O(n)\\) stack frame space. The sorting operation is performed on the original array without the aid of an additional array.</li> <li>Non-stable sorting: In the last step of sentinel partitioning, the pivot may be swapped to the right of equal elements.</li> </ul>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153-why-is-quick-sort-fast","level":2,"title":"11.5.3   Why Is Quick Sort Fast","text":"<p>From the name, we can see that quick sort should have certain advantages in terms of efficiency. Although the average time complexity of quick sort is the same as \"merge sort\" and \"heap sort\", quick sort is usually more efficient, mainly for the following reasons.</p> <ul> <li>The probability of the worst case occurring is very low: Although the worst-case time complexity of quick sort is \\(O(n^2)\\), which is not as stable as merge sort, in the vast majority of cases, quick sort can run with a time complexity of \\(O(n \\log n)\\).</li> <li>High cache utilization: When performing sentinel partitioning operations, the system can load the entire sub-array into the cache, so element access efficiency is relatively high. Algorithms like \"heap sort\" require jump-style access to elements, thus lacking this characteristic.</li> <li>Small constant coefficient of complexity: Among the three algorithms mentioned above, quick sort has the smallest total number of operations such as comparisons, assignments, and swaps. This is similar to the reason why \"insertion sort\" is faster than \"bubble sort\".</li> </ul>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154-pivot-optimization","level":2,"title":"11.5.4   Pivot Optimization","text":"<p>Quick sort may have reduced time efficiency for certain inputs. Take an extreme example: suppose the input array is completely reversed. Since we select the leftmost element as the pivot, after sentinel partitioning is complete, the pivot is swapped to the rightmost end of the array, causing the left sub-array length to be \\(n - 1\\) and the right sub-array length to be \\(0\\). If we recurse down like this, each round of sentinel partitioning will have a sub-array length of \\(0\\), the divide-and-conquer strategy fails, and quick sort degrades to a form approximate to \"bubble sort\".</p> <p>To avoid this situation as much as possible, we can optimize the pivot selection strategy in sentinel partitioning. For example, we can randomly select an element as the pivot. However, if luck is not good and we select a non-ideal pivot every time, efficiency is still not satisfactory.</p> <p>It should be noted that programming languages usually generate \"pseudo-random numbers\". If we construct a specific test case for a pseudo-random number sequence, the efficiency of quick sort may still degrade.</p> <p>For further improvement, we can select three candidate elements in the array (usually the first, last, and middle elements of the array), and use the median of these three candidate elements as the pivot. In this way, the probability that the pivot is \"neither too small nor too large\" will be greatly increased. Of course, we can also select more candidate elements to further improve the robustness of the algorithm. After adopting this method, the probability of time complexity degrading to \\(O(n^2)\\) is greatly reduced.</p> <p>Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"Select the median of three candidate elements\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m is between l and r\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l is between m and r\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Sentinel partition (median of three)\"\"\"\n    # Use nums[left] as the pivot\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # Swap the median to the array's leftmost position\n    nums[left], nums[med] = nums[med], nums[left]\n    # Use nums[left] as the pivot\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Search from right to left for the first element smaller than the pivot\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Search from left to right for the first element greater than the pivot\n        # Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    # Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Return the index of the pivot\n</code></pre> quick_sort.cpp<pre><code>/* Select the median of three candidate elements */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums[left], nums[med]);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Search from left to right for the first element greater than the pivot\n        swap(nums[i], nums[j]); // Swap these two elements\n    }\n    swap(nums[i], nums[left]);  // Swap the pivot to the boundary between the two subarrays\n    return i;                   // Return the index of the pivot\n}\n</code></pre> quick_sort.java<pre><code>/* Select the median of three candidate elements */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partition(int[] nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.cs<pre><code>/* Select the median of three candidate elements */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint Partition(int[] nums, int left, int right) {\n    // Select the median of three candidate elements\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    Swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        Swap(nums, i, j); // Swap these two elements\n    }\n    Swap(nums, i, left);  // Swap the pivot to the boundary between the two subarrays\n    return i;             // Return the index of the pivot\n}\n</code></pre> quick_sort.go<pre><code>/* Select the median of three candidate elements */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l is between m and r\n    }\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // Use nums[left] as the pivot\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // Swap the median to the array's leftmost position\n    nums[left], nums[med] = nums[med], nums[left]\n    // Use nums[left] as the pivot\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Search from right to left for the first element smaller than the pivot\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Search from left to right for the first element greater than the pivot\n        }\n        // Swap elements\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Swap the pivot to the boundary between the two subarrays\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Return the index of the pivot\n}\n</code></pre> quick_sort.swift<pre><code>/* Select the median of three candidate elements */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l is between m and r\n    }\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Select the median of three candidate elements\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // Swap the median to the array's leftmost position\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Select the median of three candidate elements */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m is between l and r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l is between m and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Sentinel partition (median of three) */\npartition(nums, left, right) {\n    // Select the median of three candidate elements\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Swap the median to the array's leftmost position\n    this.swap(nums, left, med);\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.ts<pre><code>/* Select the median of three candidate elements */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m is between l and r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l is between m and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Sentinel partition (median of three) */\npartition(nums: number[], left: number, right: number): number {\n    // Select the median of three candidate elements\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Swap the median to the array's leftmost position\n    this.swap(nums, left, med);\n    // Use nums[left] as the pivot\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Search from right to left for the first element smaller than the pivot\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Search from left to right for the first element greater than the pivot\n        }\n        this.swap(nums, i, j); // Swap these two elements\n    }\n    this.swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.dart<pre><code>/* Select the median of three candidate elements */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m is between l and r\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l is between m and r\n  return right;\n}\n\n/* Sentinel partition (median of three) */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Select the median of three candidate elements\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // Swap the median to the array's leftmost position\n  _swap(nums, left, med);\n  // Use nums[left] as the pivot\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Search from right to left for the first element smaller than the pivot\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Search from left to right for the first element greater than the pivot\n    _swap(nums, i, j); // Swap these two elements\n  }\n  _swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n  return i; // Return the index of the pivot\n}\n</code></pre> quick_sort.rs<pre><code>/* Select the median of three candidate elements */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m is between l and r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l is between m and r\n    }\n    right\n}\n\n/* Sentinel partition (median of three) */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Select the median of three candidate elements\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    nums.swap(left, med);\n    // Use nums[left] as the pivot\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Search from right to left for the first element smaller than the pivot\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Search from left to right for the first element greater than the pivot\n        }\n        nums.swap(i, j); // Swap these two elements\n    }\n    nums.swap(i, left); // Swap the pivot to the boundary between the two subarrays\n    i // Return the index of the pivot\n}\n</code></pre> quick_sort.c<pre><code>/* Select the median of three candidate elements */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m is between l and r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l is between m and r\n    return right;\n}\n\n/* Sentinel partition (median of three) */\nint partitionMedian(int nums[], int left, int right) {\n    // Select the median of three candidate elements\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med);\n    // Use nums[left] as the pivot\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j); // Swap these two elements\n    }\n    swap(nums, i, left); // Swap the pivot to the boundary between the two subarrays\n    return i;            // Return the index of the pivot\n}\n</code></pre> quick_sort.kt<pre><code>/* Select the median of three candidate elements */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m is between l and r\n    if ((l in m..r) || (l in r..m))\n        return left // l is between m and r\n    return right\n}\n\n/* Sentinel partition (median of three) */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // Select the median of three candidate elements\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // Swap the median to the array's leftmost position\n    swap(nums, left, med)\n    // Use nums[left] as the pivot\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // Search from right to left for the first element smaller than the pivot\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // Search from left to right for the first element greater than the pivot\n        swap(nums, i, j)             // Swap these two elements\n    }\n    swap(nums, i, left)              // Swap the pivot to the boundary between the two subarrays\n    return i                         // Return the index of the pivot\n}\n</code></pre> quick_sort.rb<pre><code>### Select median of three candidate elements ###\ndef median_three(nums, left, mid, right)\n  # Select the median of three candidate elements\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m is between l and r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l is between m and r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### Sentinel partition (median of three) ###\ndef partition(nums, left, right)\n  ### Use nums[left] as pivot\n  med = median_three(nums, left, (left + right) / 2, right)\n  # Swap median to leftmost position of array\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Search from right to left for the first element smaller than the pivot\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Search from left to right for the first element greater than the pivot\n    end\n    # Swap elements\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Swap the pivot to the boundary between the two subarrays\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Return the index of the pivot\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155-recursive-depth-optimization","level":2,"title":"11.5.5   Recursive Depth Optimization","text":"<p>For certain inputs, quick sort may occupy more space. Taking a completely ordered input array as an example, let the length of the sub-array in recursion be \\(m\\). Each round of sentinel partitioning will produce a left sub-array of length \\(0\\) and a right sub-array of length \\(m - 1\\), which means that the problem scale reduced per recursive call is very small (only one element is reduced), and the height of the recursion tree will reach \\(n - 1\\), at which point \\(O(n)\\) size of stack frame space is required.</p> <p>To prevent the accumulation of stack frame space, we can compare the lengths of the two sub-arrays after each round of sentinel sorting is complete, and only recurse on the shorter sub-array. Since the length of the shorter sub-array will not exceed \\(n / 2\\), this method can ensure that the recursion depth does not exceed \\(\\log n\\), thus optimizing the worst-case space complexity to \\(O(\\log n)\\). The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Quick sort (recursion depth optimization)\"\"\"\n    # Terminate when subarray length is 1\n    while left &lt; right:\n        # Sentinel partition operation\n        pivot = self.partition(nums, left, right)\n        # Perform quick sort on the shorter of the two subarrays\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # Recursively sort the left subarray\n            left = pivot + 1  # Remaining unsorted interval is [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # Recursively sort the right subarray\n            right = pivot - 1  # Remaining unsorted interval is [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1;                 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1;                 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(int[] nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* Quick sort (recursion depth optimization) */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = Partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // Recursively sort the left subarray\n            left = pivot + 1;  // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* Quick sort (recursion depth optimization) */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // Terminate when subarray length is 1\n    for left &lt; right {\n        // Sentinel partition operation\n        pivot := q.partition(nums, left, right)\n        // Perform quick sort on the shorter of the two subarrays\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // Recursively sort the left subarray\n            left = pivot + 1                 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // Recursively sort the right subarray\n            right = pivot - 1                 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* Quick sort (recursion depth optimization) */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // Terminate when subarray length is 1\n    while left &lt; right {\n        // Sentinel partition operation\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // Recursively sort the left subarray\n            left = pivot + 1 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // Recursively sort the right subarray\n            right = pivot - 1 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* Quick sort (recursion depth optimization) */\nquickSort(nums, left, right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        let pivot = this.partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* Quick sort (recursion depth optimization) */\nquickSort(nums: number[], left: number, right: number): void {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        let pivot = this.partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Terminate when subarray length is 1\n  while (left &lt; right) {\n    // Sentinel partition operation\n    int pivot = _partition(nums, left, right);\n    // Perform quick sort on the shorter of the two subarrays\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // Recursively sort the left subarray\n      left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // Recursively sort the right subarray\n      right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* Quick sort (recursion depth optimization) */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // Terminate when subarray length is 1\n    while left &lt; right {\n        // Sentinel partition operation\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // Perform quick sort on the shorter of the two subarrays\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // Recursively sort the left subarray\n            left = pivot + 1; // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // Recursively sort the right subarray\n            right = pivot - 1; // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* Quick sort (recursion depth optimization) */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // Terminate when subarray length is 1\n    while (left &lt; right) {\n        // Sentinel partition operation\n        int pivot = partition(nums, left, right);\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - left &lt; right - pivot) {\n            // Recursively sort the left subarray\n            quickSortTailCall(nums, left, pivot - 1);\n            // Remaining unsorted interval is [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // Recursively sort the right subarray\n            quickSortTailCall(nums, pivot + 1, right);\n            // Remaining unsorted interval is [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* Quick sort (recursion depth optimization) */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // Terminate when subarray length is 1\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // Sentinel partition operation\n        val pivot = partition(nums, l, r)\n        // Perform quick sort on the shorter of the two subarrays\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // Recursively sort the left subarray\n            l = pivot + 1 // Remaining unsorted interval is [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // Recursively sort the right subarray\n            r = pivot - 1 // Remaining unsorted interval is [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### Quick sort (recursion depth optimization) ###\ndef quick_sort(nums, left, right)\n  # Recurse when subarray length is not 1\n  while left &lt; right\n    # Sentinel partition\n    pivot = partition(nums, left, right)\n    # Perform quick sort on the shorter of the two subarrays\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # Remaining unsorted interval is [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # Remaining unsorted interval is [left, pivot - 1]\n    end\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.5 &nbsp; Quick Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   Radix Sort","text":"<p>The previous section introduced counting sort, which is suitable for situations where the data volume \\(n\\) is large but the data range \\(m\\) is small. Suppose we need to sort \\(n = 10^6\\) student IDs, and the student ID is an 8-digit number, which means the data range \\(m = 10^8\\) is very large. Using counting sort would require allocating a large amount of memory space, whereas radix sort can avoid this situation.</p> <p>Radix sort (radix sort) has a core idea consistent with counting sort, which also achieves sorting by counting quantities. Building on this, radix sort utilizes the progressive relationship between the digits of numbers, sorting each digit in turn to obtain the final sorting result.</p>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101-algorithm-flow","level":2,"title":"11.10.1   Algorithm Flow","text":"<p>Taking student ID data as an example, assume the lowest digit is the \\(1\\)st digit and the highest digit is the \\(8\\)th digit. The flow of radix sort is shown in Figure 11-18.</p> <ol> <li>Initialize the digit \\(k = 1\\).</li> <li>Perform \"counting sort\" on the \\(k\\)th digit of the student IDs. After completion, the data will be sorted from smallest to largest according to the \\(k\\)th digit.</li> <li>Increase \\(k\\) by \\(1\\), then return to step <code>2.</code> and continue iterating until all digits are sorted, at which point the process ends.</li> </ol> <p></p> <p> Figure 11-18   Radix sort algorithm flow </p> <p>Below we analyze the code implementation. For a \\(d\\)-base number \\(x\\), to get its \\(k\\)th digit \\(x_k\\), the following calculation formula can be used:</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>Where \\(\\lfloor a \\rfloor\\) denotes rounding down the floating-point number \\(a\\), and \\(\\bmod \\: d\\) denotes taking the modulo (remainder) with respect to \\(d\\). For student ID data, \\(d = 10\\) and \\(k \\in [1, 8]\\).</p> <p>Additionally, we need to slightly modify the counting sort code to make it sort based on the \\(k\\)th digit of the number:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"Get the k-th digit of element num, where exp = 10^(k-1)\"\"\"\n    # Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"Counting sort (based on nums k-th digit)\"\"\"\n    # Decimal digit range is 0~9, therefore need a bucket array of length 10\n    counter = [0] * 10\n    n = len(nums)\n    # Count the occurrence of digits 0~9\n    for i in range(n):\n        d = digit(nums[i], exp)  # Get the k-th digit of nums[i], noted as d\n        counter[d] += 1  # Count the occurrence of digit d\n    # Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # Traverse in reverse, based on bucket statistics, place each element into res\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # Get the index j for d in the array\n        res[j] = nums[i]  # Place the current element at index j\n        counter[d] -= 1  # Decrease the count of d by 1\n    # Use result to overwrite the original array nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"Radix sort\"\"\"\n    # Get the maximum element of the array, used to determine the maximum number of digits\n    m = max(nums)\n    # Traverse from the lowest to the highest digit\n    exp = 1\n    while exp &lt;= m:\n        # Perform counting sort on the k-th digit of array elements\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # i.e., exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = *max_element(nums.begin(), nums.end());\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(int[] nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int[] counter = new int[10];\n    int n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(int[] nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++;                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nvoid RadixSort(int[] nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunc countingSortDigit(nums []int, exp int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    counter := make([]int, 10)\n    n := len(nums)\n    // Count the occurrence of digits 0~9\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // Get the k-th digit of nums[i], noted as d\n        counter[d]++             // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i]    // Place the current element at index j\n        counter[d]--        // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* Radix sort */\nfunc radixSort(nums []int) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    var counter = Array(repeating: 0, count: 10)\n    // Count the occurrence of digits 0~9\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // Get the k-th digit of nums[i], noted as d\n        counter[d] += 1 // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i] // Place the current element at index j\n        counter[d] -= 1 // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* Radix sort */\nfunc radixSort(nums: inout [Int]) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return Math.floor(num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunction countingSortDigit(nums, exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d]--; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nfunction radixSort(nums) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m = Math.max(... nums);\n    // Traverse from the lowest to the highest digit\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return Math.floor(num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Count the occurrence of digits 0~9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d]++; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d]--; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Radix sort */\nfunction radixSort(nums: number[]): void {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m: number = Math.max(... nums);\n    // Traverse from the lowest to the highest digit\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* Get k-th digit of element _num, where exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // Passing exp instead of k can avoid repeated expensive exponentiation here\n  return (_num ~/ exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // Decimal digit range is 0~9, therefore need a bucket array of length 10\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // Count the occurrence of digits 0~9\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n    counter[d]++; // Count the occurrence of digit d\n  }\n  // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // Traverse in reverse, based on bucket statistics, place each element into res\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // Get the index j for d in the array\n    res[j] = nums[i]; // Place the current element at index j\n    counter[d]--; // Decrease the count of d by 1\n  }\n  // Use result to overwrite the original array nums\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* Radix sort */\nvoid radixSort(List&lt;int&gt; nums) {\n  // Get the maximum element of the array, used to determine the maximum number of digits\n  // In Dart, int length is 64 bits\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // Traverse from the lowest to the highest digit\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // Perform counting sort on the k-th digit of array elements\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // i.e., exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return ((num / exp) % 10) as usize;\n}\n\n/* Counting sort (based on nums k-th digit) */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // Count the occurrence of digits 0~9\n    for i in 0..n {\n        let d = digit(nums[i], exp); // Get the k-th digit of nums[i], noted as d\n        counter[d] += 1; // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i]; // Place the current element at index j\n        counter[d] -= 1; // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    nums.copy_from_slice(&amp;res);\n}\n\n/* Radix sort */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    let m = *nums.into_iter().max().unwrap();\n    // Traverse from the lowest to the highest digit\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10;\n}\n\n/* Counting sort (based on nums k-th digit) */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // Initialize to 0 to support subsequent memory release\n    // Count the occurrence of digits 0~9\n    for (int i = 0; i &lt; size; i++) {\n        // Get the k-th digit of nums[i], noted as d\n        int d = digit(nums[i], exp);\n        // Count the occurrence of digit d\n        counter[d]++;\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Get the index j for d in the array\n        res[j] = nums[i];       // Place the current element at index j\n        counter[d]--;           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // Free memory\n    free(res);\n    free(counter);\n}\n\n/* Radix sort */\nvoid radixSort(int nums[], int size) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // Traverse from the lowest to the highest digit\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* Get the k-th digit of element num, where exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // Passing exp instead of k can avoid repeated expensive exponentiation here\n    return (num / exp) % 10\n}\n\n/* Counting sort (based on nums k-th digit) */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // Decimal digit range is 0~9, therefore need a bucket array of length 10\n    val counter = IntArray(10)\n    val n = nums.size\n    // Count the occurrence of digits 0~9\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // Get the k-th digit of nums[i], noted as d\n        counter[d]++                // Count the occurrence of digit d\n    }\n    // Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // Traverse in reverse, based on bucket statistics, place each element into res\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // Get the index j for d in the array\n        res[j] = nums[i]       // Place the current element at index j\n        counter[d]--           // Decrease the count of d by 1\n    }\n    // Use result to overwrite the original array nums\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* Radix sort */\nfun radixSort(nums: IntArray) {\n    // Get the maximum element of the array, used to determine the maximum number of digits\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // Traverse from the lowest to the highest digit\n    while (exp &lt;= m) {\n        // Perform counting sort on the k-th digit of array elements\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // i.e., exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### Get k-th digit of element num, where exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Passing exp instead of k avoids expensive exponentiation calculations\n  (num / exp) % 10\nend\n\n### Counting sort (sort by k-th digit of nums) ###\ndef counting_sort_digit(nums, exp)\n  # Decimal digit range is 0~9, therefore need a bucket array of length 10\n  counter = Array.new(10, 0)\n  n = nums.length\n  # Count the occurrence of digits 0~9\n  for i in 0...n\n    d = digit(nums[i], exp) # Get the k-th digit of nums[i], noted as d\n    counter[d] += 1 # Count the occurrence of digit d\n  end\n  # Calculate prefix sum, converting \"occurrence count\" into \"array index\"\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # Traverse in reverse, based on bucket statistics, place each element into res\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # Get the index j for d in the array\n    res[j] = nums[i] # Place the current element at index j\n    counter[d] -= 1 # Decrease the count of d by 1\n  end\n  # Use result to overwrite the original array nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### Radix sort ###\ndef radix_sort(nums)\n  # Get the maximum element of the array, used to determine the maximum number of digits\n  m = nums.max\n  # Traverse from the lowest to the highest digit\n  exp = 1\n  while exp &lt;= m\n    # Perform counting sort on the k-th digit of array elements\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # i.e., exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> <p>Why start sorting from the lowest digit?</p> <p>In successive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the first round result is \\(a &lt; b\\), while the second round result is \\(a &gt; b\\), then the second round's result will replace the first round's result. Since higher-order digits have higher priority than lower-order digits, we should sort the lower digits first and then sort the higher digits.</p>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102-algorithm-characteristics","level":2,"title":"11.10.2   Algorithm Characteristics","text":"<p>Compared to counting sort, radix sort is suitable for larger numerical ranges, but the prerequisite is that the data must be representable in a fixed number of digits, and the number of digits should not be too large. For example, floating-point numbers are not suitable for radix sort because their number of digits \\(k\\) may be too large, potentially leading to time complexity \\(O(nk) \\gg O(n^2)\\).</p> <ul> <li>Time complexity of \\(O(nk)\\), non-adaptive sorting: Let the data volume be \\(n\\), the data be in base \\(d\\), and the maximum number of digits be \\(k\\). Then performing counting sort on a certain digit uses \\(O(n + d)\\) time, and sorting all \\(k\\) digits uses \\(O((n + d)k)\\) time. Typically, both \\(d\\) and \\(k\\) are relatively small, and the time complexity approaches \\(O(n)\\).</li> <li>Space complexity of \\(O(n + d)\\), non-in-place sorting: Same as counting sort, radix sort requires auxiliary arrays <code>res</code> and <code>counter</code> of lengths \\(n\\) and \\(d\\).</li> <li>Stable sorting: When counting sort is stable, radix sort is also stable; when counting sort is unstable, radix sort cannot guarantee obtaining correct sorting results.</li> </ul>","path":["Chapter 11. Sorting","11.10 &nbsp; Radix Sort"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   Selection Sort","text":"<p>Selection sort (selection sort) works very simply: it opens a loop, and in each round, selects the smallest element from the unsorted interval and places it at the end of the sorted interval.</p> <p>Assume the array has length \\(n\\). The algorithm flow of selection sort is shown in Figure 11-2.</p> <ol> <li>Initially, all elements are unsorted, i.e., the unsorted (index) interval is \\([0, n-1]\\).</li> <li>Select the smallest element in the interval \\([0, n-1]\\) and swap it with the element at index \\(0\\). After completion, the first element of the array is sorted.</li> <li>Select the smallest element in the interval \\([1, n-1]\\) and swap it with the element at index \\(1\\). After completion, the first 2 elements of the array are sorted.</li> <li>And so on. After \\(n - 1\\) rounds of selection and swapping, the first \\(n - 1\\) elements of the array are sorted.</li> <li>The only remaining element must be the largest element, requiring no sorting, so the array sorting is complete.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 11-2   Selection sort steps </p> <p>In the code, we use \\(k\\) to record the smallest element within the unsorted interval:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"Selection sort\"\"\"\n    n = len(nums)\n    # Outer loop: unsorted interval is [i, n-1]\n    for i in range(n - 1):\n        # Inner loop: find the smallest element within the unsorted interval\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # Record the index of the smallest element\n        # Swap the smallest element with the first element of the unsorted interval\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* Selection sort */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* Selection sort */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* Selection sort */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* Selection sort */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // Outer loop: unsorted interval is [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // Inner loop: find the smallest element within the unsorted interval\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // Record the index of the smallest element\n                k = j\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* Selection sort */\nfunc selectionSort(nums: inout [Int]) {\n    // Outer loop: unsorted interval is [i, n-1]\n    for i in nums.indices.dropLast() {\n        // Inner loop: find the smallest element within the unsorted interval\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* Selection sort */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* Selection sort */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // Outer loop: unsorted interval is [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* Selection sort */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // Outer loop: unsorted interval is [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // Inner loop: find the smallest element within the unsorted interval\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // Record the index of the smallest element\n    }\n    // Swap the smallest element with the first element of the unsorted interval\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* Selection sort */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // Outer loop: unsorted interval is [i, n-1]\n    for i in 0..n - 1 {\n        // Inner loop: find the smallest element within the unsorted interval\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // Record the index of the smallest element\n            }\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* Selection sort */\nvoid selectionSort(int nums[], int n) {\n    // Outer loop: unsorted interval is [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Inner loop: find the smallest element within the unsorted interval\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* Selection sort */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // Outer loop: unsorted interval is [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // Inner loop: find the smallest element within the unsorted interval\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // Record the index of the smallest element\n        }\n        // Swap the smallest element with the first element of the unsorted interval\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### Selection sort ###\ndef selection_sort(nums)\n  n = nums.length\n  # Outer loop: unsorted interval is [i, n-1]\n  for i in 0...(n - 1)\n    # Inner loop: find the smallest element within the unsorted interval\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # Record the index of the smallest element\n      end\n    end\n    # Swap the smallest element with the first element of the unsorted interval\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre>","path":["Chapter 11. Sorting","11.2 &nbsp; Selection Sort"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121-algorithm-characteristics","level":2,"title":"11.2.1   Algorithm Characteristics","text":"<ul> <li>Time complexity of \\(O(n^2)\\), non-adaptive sorting: The outer loop has \\(n - 1\\) rounds in total. The length of the unsorted interval in the first round is \\(n\\), and the length of the unsorted interval in the last round is \\(2\\). That is, each round of the outer loop contains \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(3\\), \\(2\\) inner loop iterations, summing to \\(\\frac{(n - 1)(n + 2)}{2}\\).</li> <li>Space complexity of \\(O(1)\\), in-place sorting: Pointers \\(i\\) and \\(j\\) use a constant amount of extra space.</li> <li>Non-stable sorting: As shown in Figure 11-3, element <code>nums[i]</code> may be swapped to the right of an element equal to it, causing a change in their relative order.</li> </ul> <p> Figure 11-3   Selection sort non-stability example </p>","path":["Chapter 11. Sorting","11.2 &nbsp; Selection Sort"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   Sorting Algorithm","text":"<p>Sorting algorithm (sorting algorithm) is used to arrange a group of data in a specific order. Sorting algorithms have extensive applications because ordered data can usually be searched, analyzed, and processed more efficiently.</p> <p>As shown in Figure 11-1, data types in sorting algorithms can be integers, floating-point numbers, characters, or strings, etc. The sorting criterion can be set according to requirements, such as numerical size, character ASCII code order, or custom rules.</p> <p></p> <p> Figure 11-1   Data type and criterion examples </p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111-evaluation-dimensions","level":2,"title":"11.1.1   Evaluation Dimensions","text":"<p>Execution efficiency: We expect the time complexity of sorting algorithms to be as low as possible, with a smaller total number of operations (reducing the constant factor in time complexity). For large data volumes, execution efficiency is particularly important.</p> <p>In-place property: As the name implies, in-place sorting achieves sorting by operating directly on the original array without requiring additional auxiliary arrays, thus saving memory. Typically, in-place sorting involves fewer data movement operations and runs faster.</p> <p>Stability: Stable sorting ensures that the relative order of equal elements in the array does not change after sorting is completed.</p> <p>Stable sorting is a necessary condition for multi-level sorting scenarios. Suppose we have a table storing student information, where column 1 and column 2 are name and age, respectively. In this case, unstable sorting may cause the ordered nature of the input data to be lost:</p> <pre><code># Input Data Is Sorted by Name\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# Assuming We Use an Unstable Sorting Algorithm to Sort the List by Age,\n# In the Result, the Relative Positions of ('D', 19) and ('A', 19) Are Changed,\n# And the Property That the Input Data Is Sorted by Name Is Lost\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>Adaptability: Adaptive sorting can utilize the existing order information in the input data to reduce the amount of computation, achieving better time efficiency. The best-case time complexity of adaptive sorting algorithms is typically better than the average time complexity.</p> <p>Comparison-based or not: Comparison-based sorting relies on comparison operators (\\(&lt;\\), \\(=\\), \\(&gt;\\)) to determine the relative order of elements, thereby sorting the entire array, with a theoretical optimal time complexity of \\(O(n \\log n)\\). Non-comparison sorting does not use comparison operators and can achieve a time complexity of \\(O(n)\\), but its versatility is relatively limited.</p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112-ideal-sorting-algorithm","level":2,"title":"11.1.2   Ideal Sorting Algorithm","text":"<p>Fast execution, in-place, stable, adaptive, good versatility. Clearly, no sorting algorithm has been discovered to date that combines all of these characteristics. Therefore, when selecting a sorting algorithm, it is necessary to decide based on the specific characteristics of the data and the requirements of the problem.</p> <p>Next, we will learn about various sorting algorithms together and analyze the advantages and disadvantages of each sorting algorithm based on the above evaluation dimensions.</p>","path":["Chapter 11. Sorting","11.1 &nbsp; Sorting Algorithm"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   Summary","text":"","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>Bubble sort achieves sorting by swapping adjacent elements. By adding a flag to enable early return, we can optimize the best-case time complexity of bubble sort to \\(O(n)\\).</li> <li>Insertion sort completes sorting by inserting elements from the unsorted interval into the correct position in the sorted interval each round. Although the time complexity of insertion sort is \\(O(n^2)\\), it is very popular in small data volume sorting tasks because it involves relatively few unit operations.</li> <li>Quick sort is implemented based on sentinel partitioning operations. In sentinel partitioning, it is possible to select the worst pivot every time, causing the time complexity to degrade to \\(O(n^2)\\). Introducing median pivot or random pivot can reduce the probability of such degradation. By preferentially recursing on the shorter sub-interval, the recursion depth can be effectively reduced, optimizing the space complexity to \\(O(\\log n)\\).</li> <li>Merge sort includes two phases: divide and merge, which typically embody the divide-and-conquer strategy. In merge sort, sorting an array requires creating auxiliary arrays, with a space complexity of \\(O(n)\\); however, the space complexity of sorting a linked list can be optimized to \\(O(1)\\).</li> <li>Bucket sort consists of three steps: distributing data into buckets, sorting within buckets, and merging results. It also embodies the divide-and-conquer strategy and is suitable for very large data volumes. The key to bucket sort is distributing data evenly.</li> <li>Counting sort is a special case of bucket sort, which achieves sorting by counting the number of occurrences of data. Counting sort is suitable for situations where the data volume is large but the data range is limited, and requires that data can be converted to positive integers.</li> <li>Radix sort achieves data sorting by sorting digit by digit, requiring that data can be represented as fixed-digit numbers.</li> <li>Overall, we hope to find a sorting algorithm that is efficient, stable, in-place, and adaptive, with good versatility. However, just like other data structures and algorithms, no sorting algorithm has been found so far that simultaneously possesses all these characteristics. In practical applications, we need to select the appropriate sorting algorithm based on the specific characteristics of the data.</li> <li>Figure 11-19 compares mainstream sorting algorithms in terms of efficiency, stability, in-place property, and adaptability.</li> </ul> <p> Figure 11-19   Sorting algorithm comparison </p>","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: In what situations is the stability of sorting algorithms necessary?</p> <p>In reality, we may sort based on a certain attribute of objects. For example, students have two attributes: name and height. We want to implement multi-level sorting: first sort by name to get <code>(A, 180) (B, 185) (C, 170) (D, 170)</code>; then sort by height. Because the sorting algorithm is unstable, we may get <code>(D, 170) (C, 170) (A, 180) (B, 185)</code>.</p> <p>It can be seen that the positions of students D and C have been swapped, and the orderliness of names has been disrupted, which is something we don't want to see.</p> <p>Q: Can the order of \"searching from right to left\" and \"searching from left to right\" in sentinel partitioning be swapped?</p> <p>No. When we use the leftmost element as the pivot, we must first \"search from right to left\" and then \"search from left to right\". This conclusion is somewhat counterintuitive; let's analyze the reason.</p> <p>The last step of sentinel partitioning <code>partition()</code> is to swap <code>nums[left]</code> and <code>nums[i]</code>. After the swap is complete, the elements to the left of the pivot are all <code>&lt;=</code> the pivot, which requires that <code>nums[left] &gt;= nums[i]</code> must hold before the last swap. Suppose we first \"search from left to right\", then if we cannot find an element larger than the pivot, we will exit the loop when <code>i == j</code>, at which point it may be that <code>nums[j] == nums[i] &gt; nums[left]</code>. In other words, the last swap operation will swap an element larger than the pivot to the leftmost end of the array, causing sentinel partitioning to fail.</p> <p>For example, given the array <code>[0, 0, 0, 0, 1]</code>, if we first \"search from left to right\", the array after sentinel partitioning is <code>[1, 0, 0, 0, 0]</code>, which is incorrect.</p> <p>Thinking deeper, if we select <code>nums[right]</code> as the pivot, then it's exactly the opposite - we must first \"search from left to right\".</p> <p>Q: Regarding the optimization of recursion depth in quick sort, why can selecting the shorter array ensure that the recursion depth does not exceed \\(\\log n\\)?</p> <p>The recursion depth is the number of currently unreturned recursive methods. Each round of sentinel partitioning divides the original array into two sub-arrays. After recursion depth optimization, the length of the sub-array to be recursively processed is at most half of the original array length. Assuming the worst case is always half the length, the final recursion depth will be \\(\\log n\\).</p> <p>Reviewing the original quick sort, we may continuously recurse on the longer array. In the worst case, it would be \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(2\\), \\(1\\), with a recursion depth of \\(n\\). Recursion depth optimization can avoid this situation.</p> <p>Q: When all elements in the array are equal, is the time complexity of quick sort \\(O(n^2)\\)? How should this degenerate case be handled?</p> <p>Yes. For this situation, consider partitioning the array into three parts through sentinel partitioning: less than, equal to, and greater than the pivot. Only recursively process the less than and greater than parts. Under this method, an array where all input elements are equal can complete sorting in just one round of sentinel partitioning.</p> <p>Q: Why is the worst-case time complexity of bucket sort \\(O(n^2)\\)?</p> <p>In the worst case, all elements are distributed into the same bucket. If we use an \\(O(n^2)\\) algorithm to sort these elements, the time complexity will be \\(O(n^2)\\).</p>","path":["Chapter 11. Sorting","11.11 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"Chapter 5.   Stack and Queue","text":"<p>Abstract</p> <p>Stacks are like stacking cats, while queues are like cats lining up.</p> <p>They represent LIFO (Last In First Out) and FIFO (First In First Out) logic, respectively.</p>","path":["Chapter 5. Stack and Queue","Chapter 5. &nbsp; Stack and Queue"],"tags":[]},{"location":"chapter_stack_and_queue/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>5.1   Stack</li> <li>5.2   Queue</li> <li>5.3   Double-Ended Queue</li> <li>5.4   Summary</li> </ul>","path":["Chapter 5. Stack and Queue","Chapter 5. &nbsp; Stack and Queue"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   Deque","text":"<p>In a queue, we can only remove elements from the front or add elements at the rear. As shown in Figure 5-7, a double-ended queue (deque) provides greater flexibility, allowing the addition or removal of elements at both the front and rear.</p> <p></p> <p> Figure 5-7   Operations of deque </p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531-common-deque-operations","level":2,"title":"5.3.1   Common Deque Operations","text":"<p>The common operations on a deque are shown in Table 5-3. The specific method names depend on the programming language used.</p> <p> Table 5-3   Efficiency of Deque Operations </p> Method Description Time Complexity <code>push_first()</code> Add element to front \\(O(1)\\) <code>push_last()</code> Add element to rear \\(O(1)\\) <code>pop_first()</code> Remove front element \\(O(1)\\) <code>pop_last()</code> Remove rear element \\(O(1)\\) <code>peek_first()</code> Access front element \\(O(1)\\) <code>peek_last()</code> Access rear element \\(O(1)\\) <p>Similarly, we can directly use the deque classes already implemented in programming languages:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# Initialize deque\ndeq: deque[int] = deque()\n\n# Enqueue elements\ndeq.append(2)      # Add to rear\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # Add to front\ndeq.appendleft(1)\n\n# Access elements\nfront: int = deq[0]  # Front element\nrear: int = deq[-1]  # Rear element\n\n# Dequeue elements\npop_front: int = deq.popleft()  # Front element dequeue\npop_rear: int = deq.pop()       # Rear element dequeue\n\n# Get deque length\nsize: int = len(deq)\n\n# Check if deque is empty\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* Initialize deque */\ndeque&lt;int&gt; deque;\n\n/* Enqueue elements */\ndeque.push_back(2);   // Add to rear\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Add to front\ndeque.push_front(1);\n\n/* Access elements */\nint front = deque.front(); // Front element\nint back = deque.back();   // Rear element\n\n/* Dequeue elements */\ndeque.pop_front();  // Front element dequeue\ndeque.pop_back();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.size();\n\n/* Check if deque is empty */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* Initialize deque */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* Enqueue elements */\ndeque.offerLast(2);   // Add to rear\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Add to front\ndeque.offerFirst(1);\n\n/* Access elements */\nint peekFirst = deque.peekFirst();  // Front element\nint peekLast = deque.peekLast();    // Rear element\n\n/* Dequeue elements */\nint popFirst = deque.pollFirst();  // Front element dequeue\nint popLast = deque.pollLast();    // Rear element dequeue\n\n/* Get deque length */\nint size = deque.size();\n\n/* Check if deque is empty */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* Initialize deque */\n// In C#, use LinkedList as a deque\nLinkedList&lt;int&gt; deque = new();\n\n/* Enqueue elements */\ndeque.AddLast(2);   // Add to rear\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Add to front\ndeque.AddFirst(1);\n\n/* Access elements */\nint peekFirst = deque.First.Value;  // Front element\nint peekLast = deque.Last.Value;    // Rear element\n\n/* Dequeue elements */\ndeque.RemoveFirst();  // Front element dequeue\ndeque.RemoveLast();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.Count;\n\n/* Check if deque is empty */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* Initialize deque */\n// In Go, use list as a deque\ndeque := list.New()\n\n/* Enqueue elements */\ndeque.PushBack(2)      // Add to rear\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Add to front\ndeque.PushFront(1)\n\n/* Access elements */\nfront := deque.Front() // Front element\nrear := deque.Back()   // Rear element\n\n/* Dequeue elements */\ndeque.Remove(front)    // Front element dequeue\ndeque.Remove(rear)     // Rear element dequeue\n\n/* Get deque length */\nsize := deque.Len()\n\n/* Check if deque is empty */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* Initialize deque */\n// Swift does not have a built-in deque class, can use Array as a deque\nvar deque: [Int] = []\n\n/* Enqueue elements */\ndeque.append(2) // Add to rear\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Add to front\ndeque.insert(1, at: 0)\n\n/* Access elements */\nlet peekFirst = deque.first! // Front element\nlet peekLast = deque.last! // Rear element\n\n/* Dequeue elements */\n// When using Array simulation, popFirst has O(n) complexity\nlet popFirst = deque.removeFirst() // Front element dequeue\nlet popLast = deque.removeLast() // Rear element dequeue\n\n/* Get deque length */\nlet size = deque.count\n\n/* Check if deque is empty */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* Initialize deque */\n// JavaScript does not have a built-in deque, can only use Array as a deque\nconst deque = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Please note that since it's an array, unshift() has O(n) time complexity\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* Dequeue elements */\n// Please note that since it's an array, shift() has O(n) time complexity\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* Get deque length */\nconst size = deque.length;\n\n/* Check if deque is empty */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* Initialize deque */\n// TypeScript does not have a built-in deque, can only use Array as a deque\nconst deque: number[] = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Please note that since it's an array, unshift() has O(n) time complexity\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* Dequeue elements */\n// Please note that since it's an array, shift() has O(n) time complexity\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* Get deque length */\nconst size: number = deque.length;\n\n/* Check if deque is empty */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* Initialize deque */\n// In Dart, Queue is defined as a deque\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* Enqueue elements */\ndeque.addLast(2);  // Add to rear\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Add to front\ndeque.addFirst(1);\n\n/* Access elements */\nint peekFirst = deque.first; // Front element\nint peekLast = deque.last;   // Rear element\n\n/* Dequeue elements */\nint popFirst = deque.removeFirst(); // Front element dequeue\nint popLast = deque.removeLast();   // Rear element dequeue\n\n/* Get deque length */\nint size = deque.length;\n\n/* Check if deque is empty */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* Initialize deque */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(2);  // Add to rear\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Add to front\ndeque.push_front(1);\n\n/* Access elements */\nif let Some(front) = deque.front() { // Front element\n}\nif let Some(rear) = deque.back() {   // Rear element\n}\n\n/* Dequeue elements */\nif let Some(pop_front) = deque.pop_front() { // Front element dequeue\n}\nif let Some(pop_rear) = deque.pop_back() {   // Rear element dequeue\n}\n\n/* Get deque length */\nlet size = deque.len();\n\n/* Check if deque is empty */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C does not provide a built-in deque\n</code></pre> deque.kt<pre><code>/* Initialize deque */\nval deque = LinkedList&lt;Int&gt;()\n\n/* Enqueue elements */\ndeque.offerLast(2)  // Add to rear\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // Add to front\ndeque.offerFirst(1)\n\n/* Access elements */\nval peekFirst = deque.peekFirst() // Front element\nval peekLast = deque.peekLast()   // Rear element\n\n/* Dequeue elements */\nval popFirst = deque.pollFirst() // Front element dequeue\nval popLast = deque.pollLast()   // Rear element dequeue\n\n/* Get deque length */\nval size = deque.size\n\n/* Check if deque is empty */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># Initialize deque\n# Ruby does not have a built-in deque, can only use Array as a deque\ndeque = []\n\n# Enqueue elements\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# Please note that since it's an array, Array#unshift has O(n) time complexity\ndeque.unshift(3)\ndeque.unshift(1)\n\n# Access elements\npeek_first = deque.first\npeek_last = deque.last\n\n# Dequeue elements\n# Please note that since it's an array, Array#shift has O(n) time complexity\npop_front = deque.shift\npop_back = deque.pop\n\n# Get deque length\nsize = deque.length\n\n# Check if deque is empty\nis_empty = size.zero?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532-deque-implementation","level":2,"title":"5.3.2   Deque Implementation *","text":"<p>The implementation of a deque is similar to that of a queue. You can choose either a linked list or an array as the underlying data structure.</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1-doubly-linked-list-implementation","level":3,"title":"1.   Doubly Linked List Implementation","text":"<p>Reviewing the previous section, we used a regular singly linked list to implement a queue because it conveniently allows deleting the head node (corresponding to dequeue) and adding new nodes after the tail node (corresponding to enqueue).</p> <p>For a deque, both the front and rear can perform enqueue and dequeue operations. In other words, a deque needs to implement operations in the opposite direction as well. For this reason, we use a \"doubly linked list\" as the underlying data structure for the deque.</p> <p>As shown in Figure 5-8, we treat the head and tail nodes of the doubly linked list as the front and rear of the deque, implementing functionality to add and remove nodes at both ends.</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 5-8   Enqueue and dequeue operations in linked list implementation of deque </p> <p>The implementation code is shown below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"Doubly linked list node\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"Constructor\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # Successor node reference\n        self.prev: ListNode | None = None  # Predecessor node reference\n\nclass LinkedListDeque:\n    \"\"\"Double-ended queue based on doubly linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._front: ListNode | None = None  # Head node front\n        self._rear: ListNode | None = None  # Tail node rear\n        self._size: int = 0  # Length of the double-ended queue\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the double-ended queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the double-ended queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"Enqueue operation\"\"\"\n        node = ListNode(num)\n        # If the linked list is empty, make both front and rear point to node\n        if self.is_empty():\n            self._front = self._rear = node\n        # Front of the queue enqueue operation\n        elif is_front:\n            # Add node to the head of the linked list\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # Update head node\n        # Rear of the queue enqueue operation\n        else:\n            # Add node to the tail of the linked list\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # Update tail node\n        self._size += 1  # Update queue length\n\n    def push_first(self, num: int):\n        \"\"\"Front of the queue enqueue\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"Rear of the queue enqueue\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"Dequeue operation\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        # Front of the queue dequeue operation\n        if is_front:\n            val: int = self._front.val  # Temporarily store head node value\n            # Delete head node\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # Update head node\n        # Rear of the queue dequeue operation\n        else:\n            val: int = self._rear.val  # Temporarily store tail node value\n            # Delete tail node\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # Update tail node\n        self._size -= 1  # Update queue length\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Front of the queue dequeue\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Rear of the queue dequeue\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Access rear of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return array for printing\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* Doubly linked list node */\nstruct DoublyListNode {\n    int val;              // Node value\n    DoublyListNode *next; // Successor node pointer\n    DoublyListNode *prev; // Predecessor node pointer\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // Head node front, tail node rear\n    int queSize = 0;              // Length of the double-ended queue\n\n  public:\n    /* Constructor */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* Destructor */\n    ~LinkedListDeque() {\n        // Traverse linked list to delete nodes and free memory\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* Get the length of the double-ended queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue operation */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty())\n            front = rear = node;\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // Update head node\n        // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // Update tail node\n        }\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Dequeue operation */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"Queue is empty\");\n        int val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front-&gt;val; // Delete head node\n            // Delete head node\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // Update head node\n        // Temporarily store tail node value\n        } else {\n            val = rear-&gt;val; // Delete tail node\n            // Update tail node\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // Update tail node\n        }\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* Access rear of the queue element */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* Return list for printing */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return front-&gt;val;\n    }\n\n    /* Driver Code */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return rear-&gt;val;\n    }\n\n    /* Return array for printing */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* Doubly linked list node */\nclass ListNode {\n    int val; // Node value\n    ListNode next; // Successor node reference\n    ListNode prev; // Predecessor node reference\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private ListNode front, rear; // Head node front, tail node rear\n    private int queSize = 0; // Length of the double-ended queue\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue operation */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty())\n            front = rear = node;\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front.prev = node;\n            node.next = front;\n            front = node; // Update head node\n        // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // Update tail node\n        }\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Dequeue operation */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front.val; // Delete head node\n            // Delete head node\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // Update head node\n        // Temporarily store tail node value\n        } else {\n            val = rear.val; // Delete tail node\n            // Update tail node\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // Update tail node\n        }\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* Access rear of the queue element */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* Return list for printing */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Driver Code */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* Return array for printing */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* Doubly linked list node */\nclass ListNode(int val) {\n    public int val = val;       // Node value\n    public ListNode? next = null; // Successor node reference\n    public ListNode? prev = null; // Predecessor node reference\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    ListNode? front, rear; // Head node front, tail node rear\n    int queSize = 0;      // Length of the double-ended queue\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Enqueue operation */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // If the linked list is empty, make both front and rear point to node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // Front of the queue enqueue operation\n        else if (isFront) {\n            // Add node to the head of the linked list\n            front!.prev = node;\n            node.next = front;\n            front = node; // Update head node\n        }\n        // Rear of the queue enqueue operation\n        else {\n            // Add node to the tail of the linked list\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // Update tail node\n        }\n\n        queSize++; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* Dequeue operation */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // Temporarily store head node value\n        if (isFront) {\n            val = front?.val; // Delete head node\n            // Delete head node\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // Update head node\n        }\n        // Temporarily store tail node value\n        else {\n            val = rear?.val;  // Delete tail node\n            // Update tail node\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // Update tail node\n        }\n\n        queSize--; // Update queue length\n        return val;\n    }\n\n    /* Rear of the queue dequeue */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* Access rear of the queue element */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* Return list for printing */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* Driver Code */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* Return array for printing */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* Double-ended queue based on doubly linked list implementation */\ntype linkedListDeque struct {\n    // Use built-in package list\n    data *list.List\n}\n\n/* Initialize deque */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* Front element enqueue */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* Rear element enqueue */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* Check if the double-ended queue is empty */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Rear element dequeue */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Driver Code */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Get the length of the queue */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* Check if the queue is empty */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* Doubly linked list node */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Successor node reference\n    weak var prev: ListNode? // Predecessor node reference\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private var front: ListNode? // Head node front\n    private var rear: ListNode? // Tail node rear\n    private var _size: Int // Length of the double-ended queue\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the double-ended queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the double-ended queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue operation */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // If the linked list is empty, make both front and rear point to node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // Front of the queue enqueue operation\n        else if isFront {\n            // Add node to the head of the linked list\n            front?.prev = node\n            node.next = front\n            front = node // Update head node\n        }\n        // Rear of the queue enqueue operation\n        else {\n            // Add node to the tail of the linked list\n            rear?.next = node\n            node.prev = rear\n            rear = node // Update tail node\n        }\n        _size += 1 // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* Rear of the queue enqueue */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* Dequeue operation */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        let val: Int\n        // Temporarily store head node value\n        if isFront {\n            val = front!.val // Delete head node\n            // Delete head node\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // Update head node\n        }\n        // Temporarily store tail node value\n        else {\n            val = rear!.val // Delete tail node\n            // Update tail node\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // Update tail node\n        }\n        _size -= 1 // Update queue length\n        return val\n    }\n\n    /* Rear of the queue dequeue */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* Access rear of the queue element */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* Return list for printing */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return front!.val\n    }\n\n    /* Driver Code */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return rear!.val\n    }\n\n    /* Return array for printing */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* Doubly linked list node */\nclass ListNode {\n    prev; // Predecessor node reference (pointer)\n    next; // Successor node reference (pointer)\n    val; // Node value\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    #front; // Head node front\n    #rear; // Tail node rear\n    #queSize; // Length of the double-ended queue\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* Rear of the queue enqueue operation */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Add node to the tail of the linked list\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // Update tail node\n        }\n        this.#queSize++;\n    }\n\n    /* Front of the queue enqueue operation */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Add node to the head of the linked list\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // Update head node\n        }\n        this.#queSize++;\n    }\n\n    /* Temporarily store tail node value */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // Store tail node value\n        // Update tail node\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // Update tail node\n        this.#queSize--;\n        return value;\n    }\n\n    /* Temporarily store head node value */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // Store tail node value\n        // Delete head node\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // Update head node\n        this.#queSize--;\n        return value;\n    }\n\n    /* Driver Code */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* Return list for printing */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* Get the length of the double-ended queue */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Print deque */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* Doubly linked list node */\nclass ListNode {\n    prev: ListNode; // Predecessor node reference (pointer)\n    next: ListNode; // Successor node reference (pointer)\n    val: number; // Node value\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private front: ListNode; // Head node front\n    private rear: ListNode; // Tail node rear\n    private queSize: number; // Length of the double-ended queue\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* Rear of the queue enqueue operation */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Add node to the tail of the linked list\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // Update tail node\n        }\n        this.queSize++;\n    }\n\n    /* Front of the queue enqueue operation */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // If the linked list is empty, make both front and rear point to node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Add node to the head of the linked list\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // Update head node\n        }\n        this.queSize++;\n    }\n\n    /* Temporarily store tail node value */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // Store tail node value\n        // Update tail node\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // Update tail node\n        this.queSize--;\n        return value;\n    }\n\n    /* Temporarily store head node value */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // Store tail node value\n        // Delete head node\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // Update head node\n        this.queSize--;\n        return value;\n    }\n\n    /* Driver Code */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* Return list for printing */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* Get the length of the double-ended queue */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Print deque */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* Doubly linked list node */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Successor node reference\n  ListNode? prev; // Predecessor node reference\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* Deque implemented based on doubly linked list */\nclass LinkedListDeque {\n  late ListNode? _front; // Head node _front\n  late ListNode? _rear; // Tail node _rear\n  int _queSize = 0; // Length of the double-ended queue\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* Get deque length */\n  int size() {\n    return this._queSize;\n  }\n\n  /* Check if the double-ended queue is empty */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* Enqueue operation */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // If list is empty, let both _front and _rear point to node\n      _front = _rear = node;\n    } else if (isFront) {\n      // Front of the queue enqueue operation\n      // Add node to the head of the linked list\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // Update head node\n    } else {\n      // Rear of the queue enqueue operation\n      // Add node to the tail of the linked list\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // Update tail node\n    }\n    _queSize++; // Update queue length\n  }\n\n  /* Front of the queue enqueue */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* Rear of the queue enqueue */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* Dequeue operation */\n  int? pop(bool isFront) {\n    // If queue is empty, return null directly\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // Temporarily store head node value\n      val = _front!.val; // Delete head node\n      // Delete head node\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // Update head node\n    } else {\n      // Temporarily store tail node value\n      val = _rear!.val; // Delete tail node\n      // Update tail node\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // Update tail node\n    }\n    _queSize--; // Update queue length\n    return val;\n  }\n\n  /* Rear of the queue dequeue */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* Access rear of the queue element */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* Return list for printing */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* Driver Code */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* Return array for printing */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* Doubly linked list node */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // Node value\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Successor node pointer\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Predecessor node pointer\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* Double-ended queue based on doubly linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Head node front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Tail node rear\n    que_size: usize,                         // Length of the double-ended queue\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Get the length of the double-ended queue */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Check if the double-ended queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Enqueue operation */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // Front of the queue enqueue operation\n        if is_front {\n            match self.front.take() {\n                // If the linked list is empty, make both front and rear point to node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // Add node to the head of the linked list\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // Update head node\n                }\n            }\n        }\n        // Rear of the queue enqueue operation\n        else {\n            match self.rear.take() {\n                // If the linked list is empty, make both front and rear point to node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // Add node to the tail of the linked list\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // Update tail node\n                }\n            }\n        }\n        self.que_size += 1; // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* Rear of the queue enqueue */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* Dequeue operation */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // If queue is empty, return None directly\n        if self.is_empty() {\n            return None;\n        };\n        // Temporarily store head node value\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // Update head node\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // Update queue length\n                old_front.borrow().val\n            })\n        }\n        // Temporarily store tail node value\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // Update tail node\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // Update queue length\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* Rear of the queue dequeue */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* Access rear of the queue element */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* Return list for printing */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Driver Code */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* Return array for printing */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* Doubly linked list node */\ntypedef struct DoublyListNode {\n    int val;                     // Node value\n    struct DoublyListNode *next; // Successor node\n    struct DoublyListNode *prev; // Predecessor node\n} DoublyListNode;\n\n/* Constructor */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* Destructor */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* Double-ended queue based on doubly linked list implementation */\ntypedef struct {\n    DoublyListNode *front, *rear; // Head node front, tail node rear\n    int queSize;                  // Length of the double-ended queue\n} LinkedListDeque;\n\n/* Constructor */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Destructor */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // Free all nodes\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Free deque structure\n    free(deque);\n}\n\n/* Get the length of the queue */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* Enqueue */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // If list is empty, set both front and rear to node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // Front of the queue enqueue operation\n    else if (isFront) {\n        // Add node to the head of the linked list\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // Update head node\n    }\n    // Rear of the queue enqueue operation\n    else {\n        // Add node to the tail of the linked list\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // Update queue length\n}\n\n/* Front of the queue enqueue */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* Rear of the queue enqueue */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* Return list for printing */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* Driver Code */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* Dequeue */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // Temporarily store head node value\n    if (isFront) {\n        val = peekFirst(deque); // Delete head node\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // Update head node\n    }\n    // Temporarily store tail node value\n    else {\n        val = peekLast(deque); // Delete tail node\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // Update tail node\n    }\n    deque-&gt;queSize--; // Update queue length\n    return val;\n}\n\n/* Rear of the queue dequeue */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* Access rear of the queue element */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* Print queue */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // Copy data from list to array\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* Doubly linked list node */\nclass ListNode(var _val: Int) {\n    // Node value\n    var next: ListNode? = null // Successor node reference\n    var prev: ListNode? = null // Predecessor node reference\n}\n\n/* Double-ended queue based on doubly linked list implementation */\nclass LinkedListDeque {\n    private var front: ListNode? = null // Head node front\n    private var rear: ListNode? = null // Tail node rear\n    private var queSize: Int = 0 // Length of the double-ended queue\n\n    /* Get the length of the double-ended queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the double-ended queue is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Enqueue operation */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // If the linked list is empty, make both front and rear point to node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // Front of the queue enqueue operation\n        } else if (isFront) {\n            // Add node to the head of the linked list\n            front?.prev = node\n            node.next = front\n            front = node // Update head node\n            // Rear of the queue enqueue operation\n        } else {\n            // Add node to the tail of the linked list\n            rear?.next = node\n            node.prev = rear\n            rear = node // Update tail node\n        }\n        queSize++ // Update queue length\n    }\n\n    /* Front of the queue enqueue */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* Rear of the queue enqueue */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* Dequeue operation */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // Temporarily store head node value\n        if (isFront) {\n            _val = front!!._val // Delete head node\n            // Delete head node\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // Update head node\n            // Temporarily store tail node value\n        } else {\n            _val = rear!!._val // Delete tail node\n            // Update tail node\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // Update tail node\n        }\n        queSize-- // Update queue length\n        return _val\n    }\n\n    /* Rear of the queue dequeue */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* Access rear of the queue element */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* Return list for printing */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Driver Code */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* Return array for printing */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n### Doubly linked list node\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # Successor node reference\n  attr_accessor :prev # Predecessor node reference\n\n  ### Constructor ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### Deque based on doubly linked list ###\nclass LinkedListDeque\n  ### Get deque length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @front = nil  # Head node front\n    @rear = nil   # Tail node rear\n    @size = 0     # Length of the double-ended queue\n  end\n\n  ### Check if deque is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue operation ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # If list is empty, set both front and rear to node\n    if is_empty?\n      @front = @rear = node\n    # Front of the queue enqueue operation\n    elsif is_front\n      # Add node to the head of the linked list\n      @front.prev = node\n      node.next = @front\n      @front = node # Update head node\n    # Rear of the queue enqueue operation\n    else\n      # Add node to the tail of the linked list\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # Update tail node\n    end\n    @size += 1 # Update queue length\n  end\n\n  ### Enqueue at front ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### Enqueue at rear ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### Dequeue operation ###\n  def pop(is_front)\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    # Temporarily store head node value\n    if is_front\n      val = @front.val # Delete head node\n      # Delete head node\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # Update head node\n    # Temporarily store tail node value\n    else\n      val = @rear.val # Delete tail node\n      # Update tail node\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # Update tail node\n    end\n    @size -= 1 # Update queue length\n\n    val\n  end\n\n  ### Dequeue from front ###\n  def pop_first\n    pop(true)\n  end\n\n  ### Dequeue from front ###\n  def pop_last\n    pop(false)\n  end\n\n  ### Access front element ###\n  def peek_first\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @front.val\n  end\n\n  ### Access rear element ###\n  def peek_last\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @rear.val\n  end\n\n  ### Return array for printing ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>As shown in Figure 5-9, similar to implementing a queue based on an array, we can also use a circular array to implement a deque.</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 5-9   Enqueue and dequeue operations in array implementation of deque </p> <p>Based on the queue implementation, we only need to add methods for \"enqueue at front\" and \"dequeue from rear\":</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"Double-ended queue based on circular array implementation\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"Constructor\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get the capacity of the double-ended queue\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the double-ended queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the double-ended queue is empty\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"Calculate circular array index\"\"\"\n        # Use modulo operation to wrap the array head and tail together\n        # When i passes the tail of the array, return to the head\n        # When i passes the head of the array, return to the tail\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"Front of the queue enqueue\"\"\"\n        if self._size == self.capacity():\n            print(\"Double-ended queue is full\")\n            return\n        # Front pointer moves one position to the left\n        # Use modulo operation to wrap front around to the tail after passing the head of the array\n        self._front = self.index(self._front - 1)\n        # Add num to the front of the queue\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"Rear of the queue enqueue\"\"\"\n        if self._size == self.capacity():\n            print(\"Double-ended queue is full\")\n            return\n        # Calculate rear pointer, points to rear index + 1\n        rear = self.index(self._front + self._size)\n        # Add num to the rear of the queue\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Front of the queue dequeue\"\"\"\n        num = self.peek_first()\n        # Front pointer moves one position backward\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Rear of the queue dequeue\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Access rear of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Double-ended queue is empty\")\n        # Calculate tail element index\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Return array for printing\"\"\"\n        # Only convert list elements within the valid length range\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // Array for storing double-ended queue elements\n    int front;        // Front pointer, points to the front of the queue element\n    int queSize;      // Double-ended queue length\n\n  public:\n    /* Constructor */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* Get the length of the double-ended queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    int index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity();\n    }\n\n    /* Front of the queue enqueue */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Double-ended queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Double-ended queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    int popFirst() {\n        int num = peekFirst();\n        // Move front pointer backward by one position\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        return nums[front];\n    }\n\n    /* Driver Code */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"Deque is empty\");\n        // Initialize double-ended queue\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private int[] nums; // Array for storing double-ended queue elements\n    private int front; // Front pointer, points to the front of the queue element\n    private int queSize; // Double-ended queue length\n\n    /* Constructor */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    private int index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity();\n    }\n\n    /* Front of the queue enqueue */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    public int popFirst() {\n        int num = peekFirst();\n        // Move front pointer backward by one position\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Driver Code */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // Initialize double-ended queue\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    public int[] toArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    int[] nums;  // Array for storing double-ended queue elements\n    int front;   // Front pointer, points to the front of the queue element\n    int queSize; // Double-ended queue length\n\n    /* Constructor */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Get the length of the double-ended queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Calculate circular array index */\n    int Index(int i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* Front of the queue enqueue */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = Index(front - 1);\n        // Add num to front of queue\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        int rear = Index(front + queSize);\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // Move front pointer backward by one position\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* Driver Code */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // Initialize double-ended queue\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Return array for printing */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* Double-ended queue based on circular array implementation */\ntype arrayDeque struct {\n    nums        []int // Array for storing double-ended queue elements\n    front       int   // Front pointer, points to the front of the queue element\n    queSize     int   // Double-ended queue length\n    queCapacity int   // Queue capacity (maximum number of elements)\n}\n\n/* Access front of the queue element */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Get the length of the double-ended queue */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* Check if the double-ended queue is empty */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Calculate circular array index */\nfunc (q *arrayDeque) index(i int) int {\n    // Use modulo operation to wrap the array head and tail together\n    // When i passes the tail of the array, return to the head\n    // When i passes the head of the array, return to the tail\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* Front of the queue enqueue */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Double-ended queue is full\")\n        return\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Add num to the front of the queue\n    q.front = q.index(q.front - 1)\n    // Add num to front of queue\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* Rear of the queue enqueue */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Double-ended queue is full\")\n        return\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    rear := q.index(q.front + q.queSize)\n    // Front pointer moves one position backward\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Rear of the queue dequeue */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // Move front pointer backward by one position\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* Access rear of the queue element */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* Return list for printing */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Driver Code */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // Initialize double-ended queue\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* Get Slice for printing */\nfunc (q *arrayDeque) toSlice() []int {\n    // Elements enqueue\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private var nums: [Int] // Array for storing double-ended queue elements\n    private var front: Int // Front pointer, points to the front of the queue element\n    private var _size: Int // Double-ended queue length\n\n    /* Constructor */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Get the capacity of the double-ended queue */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Get the length of the double-ended queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the double-ended queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Calculate circular array index */\n    private func index(i: Int) -&gt; Int {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        (i + capacity()) % capacity()\n    }\n\n    /* Front of the queue enqueue */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(i: front - 1)\n        // Add num to front of queue\n        nums[front] = num\n        _size += 1\n    }\n\n    /* Rear of the queue enqueue */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        let rear = index(i: front + size())\n        // Front pointer moves one position backward\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Rear of the queue dequeue */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // Move front pointer backward by one position\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* Access rear of the queue element */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        return nums[front]\n    }\n\n    /* Driver Code */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Deque is empty\")\n        }\n        // Initialize double-ended queue\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* Return array for printing */\n    func toArray() -&gt; [Int] {\n        // Elements enqueue\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    #nums; // Array for storing double-ended queue elements\n    #front; // Front pointer, points to the front of the queue element\n    #queSize; // Double-ended queue length\n\n    /* Constructor */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Calculate circular array index */\n    index(i) {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Front of the queue enqueue */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        this.#front = this.index(this.#front - 1);\n        // Add num to front of queue\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        const rear = this.index(this.#front + this.#queSize);\n        // Front pointer moves one position backward\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    popFirst() {\n        const num = this.peekFirst();\n        // Move front pointer backward by one position\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* Driver Code */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Initialize double-ended queue\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* Return array for printing */\n    toArray() {\n        // Elements enqueue\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n    private nums: number[]; // Array for storing double-ended queue elements\n    private front: number; // Front pointer, points to the front of the queue element\n    private queSize: number; // Double-ended queue length\n\n    /* Constructor */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* Get the capacity of the double-ended queue */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Get the length of the double-ended queue */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the double-ended queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Calculate circular array index */\n    index(i: number): number {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Front of the queue enqueue */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        this.front = this.index(this.front - 1);\n        // Add num to front of queue\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* Rear of the queue enqueue */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Double-ended queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        const rear: number = this.index(this.front + this.queSize);\n        // Front pointer moves one position backward\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Rear of the queue dequeue */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // Move front pointer backward by one position\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* Access rear of the queue element */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* Driver Code */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Initialize double-ended queue\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* Return array for printing */\n    toArray(): number[] {\n        // Elements enqueue\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* Double-ended queue based on circular array implementation */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // Array for storing double-ended queue elements\n  late int _front; // Front pointer, points to the front of the queue element\n  late int _queSize; // Double-ended queue length\n\n  /* Constructor */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* Get the capacity of the double-ended queue */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* Get the length of the double-ended queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the double-ended queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Calculate circular array index */\n  int index(int i) {\n    // Use modulo operation to wrap the array head and tail together\n    // When i passes the tail of the array, return to the head\n    // When i passes the head of the array, return to the tail\n    return (i + capacity()) % capacity();\n  }\n\n  /* Front of the queue enqueue */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Double-ended queue is full\");\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Use modulo operation to wrap _front from array head back to tail\n    _front = index(_front - 1);\n    // Add _num to queue front\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* Rear of the queue enqueue */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Double-ended queue is full\");\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    int rear = index(_front + _queSize);\n    // Add _num to queue rear\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Rear of the queue dequeue */\n  int popFirst() {\n    int _num = peekFirst();\n    // Move front pointer right by one\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* Access rear of the queue element */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"Deque is empty\");\n    }\n    return _nums[_front];\n  }\n\n  /* Driver Code */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"Deque is empty\");\n    }\n    // Initialize double-ended queue\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* Return array for printing */\n  List&lt;int&gt; toArray() {\n    // Elements enqueue\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* Double-ended queue based on circular array implementation */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // Array for storing double-ended queue elements\n    front: usize,    // Front pointer, points to the front of the queue element\n    que_size: usize, // Double-ended queue length\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* Constructor */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* Get the capacity of the double-ended queue */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* Get the length of the double-ended queue */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* Check if the double-ended queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Calculate circular array index */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* Front of the queue enqueue */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        self.front = self.index(self.front as i32 - 1);\n        // Add num to front of queue\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* Rear of the queue enqueue */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Double-ended queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // Front pointer moves one position backward\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* Rear of the queue dequeue */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // Move front pointer backward by one position\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* Access rear of the queue element */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* Return list for printing */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"Deque is empty\")\n        };\n        self.nums[self.front]\n    }\n\n    /* Driver Code */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"Deque is empty\")\n        };\n        // Initialize double-ended queue\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* Return array for printing */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // Elements enqueue\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* Double-ended queue based on circular array implementation */\ntypedef struct {\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Rear pointer, points to rear + 1\n    int queCapacity; // Queue capacity\n} ArrayDeque;\n\n/* Constructor */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // Initialize array\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Destructor */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* Get the capacity of the double-ended queue */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* Get the length of the double-ended queue */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Check if the double-ended queue is empty */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* Calculate circular array index */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // Use modulo operation to wrap the array head and tail together\n    // When i exceeds array end, wrap to head\n    // When i passes the head of the array, return to the tail\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* Front of the queue enqueue */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Deque is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap front around to the tail after passing the head of the array\n    // Use modulo to wrap front from array head to rear\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // Add num to queue front\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* Rear of the queue enqueue */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Deque is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // Front pointer moves one position backward\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* Return list for printing */\nint peekFirst(ArrayDeque *deque) {\n    // Access error: Deque is empty\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* Driver Code */\nint peekLast(ArrayDeque *deque) {\n    // Access error: Deque is empty\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* Rear of the queue dequeue */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // Move front pointer backward by one position\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Access rear of the queue element */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Return array for printing */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* Constructor */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // Array for storing double-ended queue elements\n    private var front: Int = 0 // Front pointer, points to the front of the queue element\n    private var queSize: Int = 0 // Double-ended queue length\n\n    /* Get the capacity of the double-ended queue */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Get the length of the double-ended queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the double-ended queue is empty */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Calculate circular array index */\n    private fun index(i: Int): Int {\n        // Use modulo operation to wrap the array head and tail together\n        // When i passes the tail of the array, return to the head\n        // When i passes the head of the array, return to the tail\n        return (i + capacity()) % capacity()\n    }\n\n    /* Front of the queue enqueue */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap front around to the tail after passing the head of the array\n        // Add num to the front of the queue\n        front = index(front - 1)\n        // Add num to front of queue\n        nums[front] = num\n        queSize++\n    }\n\n    /* Rear of the queue enqueue */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Double-ended queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        val rear = index(front + queSize)\n        // Front pointer moves one position backward\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Rear of the queue dequeue */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // Move front pointer backward by one position\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* Access rear of the queue element */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Driver Code */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Initialize double-ended queue\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* Return array for printing */\n    fun toArray(): IntArray {\n        // Elements enqueue\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### Deque based on circular array ###\nclass ArrayDeque\n  ### Get deque length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### Get deque capacity ###\n  def capacity\n    @nums.length\n  end\n\n  ### Check if deque is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue at front ###\n  def push_first(num)\n    if size == capacity\n      puts 'Double-ended queue is full'\n      return\n    end\n\n    # Use modulo operation to wrap front around to the tail after passing the head of the array\n    # Add num to the front of the queue\n    @front = index(@front - 1)\n    # Add num to front of queue\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### Enqueue at rear ###\n  def push_last(num)\n    if size == capacity\n      puts 'Double-ended queue is full'\n      return\n    end\n\n    # Use modulo operation to wrap rear around to the head after passing the tail of the array\n    rear = index(@front + size)\n    # Front pointer moves one position backward\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Dequeue from front ###\n  def pop_first\n    num = peek_first\n    # Move front pointer backward by one position\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### Dequeue from rear ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek_first\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Access rear element ###\n  def peek_last\n    raise IndexError, 'Deque is empty' if is_empty?\n\n    # Initialize double-ended queue\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### Return array for printing ###\n  def to_array\n    # Elements enqueue\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### Calculate circular array index ###\n  def index(i)\n    # Use modulo operation to wrap the array head and tail together\n    # When i passes the tail of the array, return to the head\n    # When i passes the head of the array, return to the tail\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533-deque-applications","level":2,"title":"5.3.3   Deque Applications","text":"<p>A deque combines the logic of both stacks and queues. Therefore, it can implement all application scenarios of both, while providing greater flexibility.</p> <p>We know that the \"undo\" function in software is typically implemented using a stack: the system pushes each change operation onto the stack and then implements undo through pop. However, considering system resource limitations, software usually limits the number of undo steps (for example, only allowing 50 steps to be saved). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (front of the queue). But a stack cannot implement this functionality, so a deque is needed to replace the stack. Note that the core logic of \"undo\" still follows the LIFO principle of a stack; it's just that the deque can more flexibly implement some additional logic.</p>","path":["Chapter 5. Stack and Queue","5.3 &nbsp; Deque"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   Queue","text":"<p>A queue is a linear data structure that follows the First In First Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers continuously join the end of the queue, while people at the front of the queue leave one by one.</p> <p>As shown in Figure 5-4, we call the front of the queue the \"front\" and the end the \"rear.\" The operation of adding an element to the rear is called \"enqueue,\" and the operation of removing the front element is called \"dequeue.\"</p> <p></p> <p> Figure 5-4   FIFO rule of queue </p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521-common-queue-operations","level":2,"title":"5.2.1   Common Queue Operations","text":"<p>The common operations on a queue are shown in Table 5-2. Note that method names may vary across different programming languages. We adopt the same naming convention as for stacks here.</p> <p> Table 5-2   Efficiency of Queue Operations </p> Method Description Time Complexity <code>push()</code> Enqueue element, add element to rear \\(O(1)\\) <code>pop()</code> Dequeue front element \\(O(1)\\) <code>peek()</code> Access front element \\(O(1)\\) <p>We can directly use the ready-made queue classes in programming languages:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# Initialize queue\n# In Python, we generally use the deque class as a queue\n# Although queue.Queue() is a pure queue class, it is not very user-friendly, so it is not recommended\nque: deque[int] = deque()\n\n# Enqueue elements\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Access front element\nfront: int = que[0]\n\n# Dequeue element\npop: int = que.popleft()\n\n# Get queue length\nsize: int = len(que)\n\n# Check if queue is empty\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* Initialize queue */\nqueue&lt;int&gt; queue;\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nint front = queue.front();\n\n/* Dequeue element */\nqueue.pop();\n\n/* Get queue length */\nint size = queue.size();\n\n/* Check if queue is empty */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* Initialize queue */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* Enqueue elements */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Access front element */\nint peek = queue.peek();\n\n/* Dequeue element */\nint pop = queue.poll();\n\n/* Get queue length */\nint size = queue.size();\n\n/* Check if queue is empty */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* Initialize queue */\nQueue&lt;int&gt; queue = new();\n\n/* Enqueue elements */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Access front element */\nint peek = queue.Peek();\n\n/* Dequeue element */\nint pop = queue.Dequeue();\n\n/* Get queue length */\nint size = queue.Count;\n\n/* Check if queue is empty */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* Initialize queue */\n// In Go, use list as a queue\nqueue := list.New()\n\n/* Enqueue elements */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Access front element */\npeek := queue.Front()\n\n/* Dequeue element */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Get queue length */\nsize := queue.Len()\n\n/* Check if queue is empty */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* Initialize queue */\n// Swift does not have a built-in queue class, can use Array as a queue\nvar queue: [Int] = []\n\n/* Enqueue elements */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Access front element */\nlet peek = queue.first!\n\n/* Dequeue element */\n// Since it's an array, removeFirst has O(n) complexity\nlet pool = queue.removeFirst()\n\n/* Get queue length */\nlet size = queue.count\n\n/* Check if queue is empty */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* Initialize queue */\n// JavaScript does not have a built-in queue, can use Array as a queue\nconst queue = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nconst peek = queue[0];\n\n/* Dequeue element */\n// The underlying structure is an array, so shift() has O(n) time complexity\nconst pop = queue.shift();\n\n/* Get queue length */\nconst size = queue.length;\n\n/* Check if queue is empty */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* Initialize queue */\n// TypeScript does not have a built-in queue, can use Array as a queue\nconst queue: number[] = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access front element */\nconst peek = queue[0];\n\n/* Dequeue element */\n// The underlying structure is an array, so shift() has O(n) time complexity\nconst pop = queue.shift();\n\n/* Get queue length */\nconst size = queue.length;\n\n/* Check if queue is empty */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* Initialize queue */\n// In Dart, the Queue class is a deque and can also be used as a queue\nQueue&lt;int&gt; queue = Queue();\n\n/* Enqueue elements */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Access front element */\nint peek = queue.first;\n\n/* Dequeue element */\nint pop = queue.removeFirst();\n\n/* Get queue length */\nint size = queue.length;\n\n/* Check if queue is empty */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* Initialize deque */\n// In Rust, use deque as a regular queue\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Access front element */\nif let Some(front) = deque.front() {\n}\n\n/* Dequeue element */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Get queue length */\nlet size = deque.len();\n\n/* Check if queue is empty */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C does not provide a built-in queue\n</code></pre> queue.kt<pre><code>/* Initialize queue */\nval queue = LinkedList&lt;Int&gt;()\n\n/* Enqueue elements */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* Access front element */\nval peek = queue.peek()\n\n/* Dequeue element */\nval pop = queue.poll()\n\n/* Get queue length */\nval size = queue.size\n\n/* Check if queue is empty */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># Initialize queue\n# Ruby's built-in queue (Thread::Queue) does not have peek and traversal methods, can use Array as a queue\nqueue = []\n\n# Enqueue elements\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# Access front element\npeek = queue.first\n\n# Dequeue element\n# Please note that since it's an array, Array#shift has O(n) time complexity\npop = queue.shift\n\n# Get queue length\nsize = queue.length\n\n# Check if queue is empty\nis_empty = queue.empty?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522-queue-implementation","level":2,"title":"5.2.2   Queue Implementation","text":"<p>To implement a queue, we need a data structure that allows adding elements at one end and removing elements at the other end. Both linked lists and arrays meet this requirement.</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1-linked-list-implementation","level":3,"title":"1.   Linked List Implementation","text":"<p>As shown in Figure 5-5, we can treat the \"head node\" and \"tail node\" of a linked list as the \"front\" and \"rear\" of the queue, respectively, with the rule that nodes can only be added at the rear and removed from the front.</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> Figure 5-5   Enqueue and dequeue operations in linked list implementation of queue </p> <p>Below is the code for implementing a queue using a linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"Queue based on linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._front: ListNode | None = None  # Head node front\n        self._rear: ListNode | None = None  # Tail node rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Enqueue\"\"\"\n        # Add num after the tail node\n        node = ListNode(num)\n        # If the queue is empty, make both front and rear point to the node\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # If the queue is not empty, add the node after the tail node\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Dequeue\"\"\"\n        num = self.peek()\n        # Delete head node\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Queue is empty\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Convert to list for printing\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // Head node front, tail node rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // Traverse linked list to delete nodes and free memory\n        freeMemoryLinkedList(front);\n    }\n\n    /* Get the length of the queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    void push(int num) {\n        // Add num after the tail node\n        ListNode *node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // If the queue is not empty, add the node after the tail node\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    int pop() {\n        int num = peek();\n        // Delete head node\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // Free memory\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"Queue is empty\");\n        return front-&gt;val;\n    }\n\n    /* Convert linked list to Vector and return */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private ListNode front, rear; // Head node front, tail node rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue */\n    public void push(int num) {\n        // Add num after the tail node\n        ListNode node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node;\n            rear = node;\n        // If the queue is not empty, add the node after the tail node\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int pop() {\n        int num = peek();\n        // Delete head node\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Convert linked list to Array and return */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    ListNode? front, rear;  // Head node front, tail node rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Get the length of the queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Enqueue */\n    public void Push(int num) {\n        // Add num after the tail node\n        ListNode node = new(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node;\n            rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int Pop() {\n        int num = Peek();\n        // Delete head node\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* Convert linked list to Array and return */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* Queue based on linked list implementation */\ntype linkedListQueue struct {\n    // Use built-in package list to implement queue\n    data *list.List\n}\n\n/* Access front of the queue element */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* Enqueue */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* Dequeue */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Get the length of the queue */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* Check if the queue is empty */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private var front: ListNode? // Head node\n    private var rear: ListNode? // Tail node\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue */\n    func push(num: Int) {\n        // Add num after the tail node\n        let node = ListNode(x: num)\n        // If the queue is empty, make both front and rear point to the node\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // If the queue is not empty, add the node after the tail node\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* Dequeue */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Delete head node\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Queue is empty\")\n        }\n        return front!.val\n    }\n\n    /* Convert linked list to Array and return */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    #front; // Front node #front\n    #rear; // Rear node #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* Get the length of the queue */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Enqueue */\n    push(num) {\n        // Add num after the tail node\n        const node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* Dequeue */\n    pop() {\n        const num = this.peek();\n        // Delete head node\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (this.size === 0) throw new Error('Queue is empty');\n        return this.#front.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n    private front: ListNode | null; // Head node front\n    private rear: ListNode | null; // Tail node rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* Get the length of the queue */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Enqueue */\n    push(num: number): void {\n        // Add num after the tail node\n        const node = new ListNode(num);\n        // If the queue is empty, make both front and rear point to the node\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* Dequeue */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('Queue is empty');\n        // Delete head node\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (this.size === 0) throw new Error('Queue is empty');\n        return this.front!.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue {\n  ListNode? _front; // Head node _front\n  ListNode? _rear; // Tail node _rear\n  int _queSize = 0; // Queue length\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* Get the length of the queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Enqueue */\n  void push(int _num) {\n    // Add _num after tail node\n    final node = ListNode(_num);\n    // If the queue is empty, make both front and rear point to the node\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // If the queue is not empty, add the node after the tail node\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* Dequeue */\n  int pop() {\n    final int _num = peek();\n    // Delete head node\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('Queue is empty');\n    }\n    return _front!.val;\n  }\n\n  /* Convert linked list to Array and return */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* Queue based on linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Head node front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Tail node rear\n    que_size: usize,                         // Queue length\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Get the length of the queue */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Check if the queue is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Enqueue */\n    pub fn push(&amp;mut self, num: T) {\n        // Add num after the tail node\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // If the queue is not empty, add the node after the tail node\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // If the queue is empty, make both front and rear point to the node\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* Dequeue */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* Return list for printing */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Convert linked list to Array and return */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* Queue based on linked list implementation */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* Constructor */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Destructor */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // Free all nodes\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Free queue structure\n    free(queue);\n}\n\n/* Get the length of the queue */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* Enqueue */\nvoid push(LinkedListQueue *queue, int num) {\n    // Add node at tail\n    ListNode *node = newListNode(num);\n    // If the queue is empty, make both front and rear point to the node\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // If the queue is not empty, add the node after the tail node\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* Return list for printing */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* Dequeue */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Print queue */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // Copy data from list to array\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* Queue based on linked list implementation */\nclass LinkedListQueue(\n    // Head node front, tail node rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* Get the length of the queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the queue is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Enqueue */\n    fun push(num: Int) {\n        // Add num after the tail node\n        val node = ListNode(num)\n        // If the queue is empty, make both front and rear point to the node\n        if (front == null) {\n            front = node\n            rear = node\n            // If the queue is not empty, add the node after the tail node\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* Dequeue */\n    fun pop(): Int {\n        val num = peek()\n        // Delete head node\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Convert linked list to Array and return */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### Queue based on linked list ###\nclass LinkedListQueue\n  ### Get queue length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @front = nil  # Head node front\n    @rear = nil   # Tail node rear\n    @size = 0\n  end\n\n  ### Check if queue is empty ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### Enqueue ###\n  def push(num)\n    # Add num after the tail node\n    node = ListNode.new(num)\n\n    # If queue is empty, set both front and rear to this node\n    if @front.nil?\n      @front = node\n      @rear = node\n    # If queue is not empty, add this node after rear\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### Dequeue ###\n  def pop\n    num = peek\n    # Delete head node\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek\n    raise IndexError, 'Queue is empty' if is_empty?\n\n    @front.val\n  end\n\n  ### Convert linked list to Array and return ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>Deleting the first element in an array has a time complexity of \\(O(n)\\), which would make the dequeue operation inefficient. However, we can use the following clever method to avoid this problem.</p> <p>We can use a variable <code>front</code> to point to the index of the front element and maintain a variable <code>size</code> to record the queue length. We define <code>rear = front + size</code>, which calculates the position right after the rear element.</p> <p>Based on this design, the valid interval containing elements in the array is <code>[front, rear - 1]</code>. The implementation methods for various operations are shown in Figure 5-6:</p> <ul> <li>Enqueue operation: Assign the input element to the <code>rear</code> index and increase <code>size</code> by 1.</li> <li>Dequeue operation: Simply increase <code>front</code> by 1 and decrease <code>size</code> by 1.</li> </ul> <p>As you can see, both enqueue and dequeue operations require only one operation, with a time complexity of \\(O(1)\\).</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> Figure 5-6   Enqueue and dequeue operations in array implementation of queue </p> <p>You may notice a problem: as we continuously enqueue and dequeue, both <code>front</code> and <code>rear</code> move to the right. When they reach the end of the array, they cannot continue moving. To solve this problem, we can treat the array as a \"circular array\" with head and tail connected.</p> <p>For a circular array, we need to let <code>front</code> or <code>rear</code> wrap around to the beginning of the array when they cross the end. This periodic pattern can be implemented using the \"modulo operation,\" as shown in the code below:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"Queue based on circular array implementation\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"Constructor\"\"\"\n        self._nums: list[int] = [0] * size  # Array for storing queue elements\n        self._front: int = 0  # Front pointer, points to the front of the queue element\n        self._size: int = 0  # Queue length\n\n    def capacity(self) -&gt; int:\n        \"\"\"Get the capacity of the queue\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the queue\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the queue is empty\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Enqueue\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"Queue is full\")\n        # Calculate rear pointer, points to rear index + 1\n        # Use modulo operation to wrap rear around to the head after passing the tail of the array\n        rear: int = (self._front + self._size) % self.capacity()\n        # Add num to the rear of the queue\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Dequeue\"\"\"\n        num: int = self.peek()\n        # Front pointer moves one position backward, if it passes the tail, return to the head of the array\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access front of the queue element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Queue is empty\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Return list for printing\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n  private:\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Queue length\n    int queCapacity; // Queue capacity\n\n  public:\n    ArrayQueue(int capacity) {\n        // Initialize array\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* Get the capacity of the queue */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* Get the length of the queue */\n    int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Enqueue */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"Queue is full\" &lt;&lt; endl;\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % queCapacity;\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    int pop() {\n        int num = peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"Queue is empty\");\n        return nums[front];\n    }\n\n    /* Convert array to Vector and return */\n    vector&lt;int&gt; toVector() {\n        // Elements enqueue\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private int[] nums; // Array for storing queue elements\n    private int front; // Front pointer, points to the front of the queue element\n    private int queSize; // Queue length\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Get the length of the queue */\n    public int size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % capacity();\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int pop() {\n        int num = peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Return array */\n    public int[] toArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    int[] nums;  // Array for storing queue elements\n    int front;   // Front pointer, points to the front of the queue element\n    int queSize; // Queue length\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Get the length of the queue */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Check if the queue is empty */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Enqueue */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        int rear = (front + queSize) % Capacity();\n        // Front pointer moves one position backward\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Dequeue */\n    public int Pop() {\n        int num = Peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* Return array */\n    public int[] ToArray() {\n        // Elements enqueue\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* Queue based on circular array implementation */\ntype arrayQueue struct {\n    nums        []int // Array for storing queue elements\n    front       int   // Front pointer, points to the front of the queue element\n    queSize     int   // Queue length\n    queCapacity int   // Queue capacity (maximum number of elements)\n}\n\n/* Access front of the queue element */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Get the length of the queue */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* Check if the queue is empty */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Enqueue */\nfunc (q *arrayQueue) push(num int) {\n    // When rear == queCapacity, queue is full\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    rear := (q.front + q.queSize) % q.queCapacity\n    // Front pointer moves one position backward\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Dequeue */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* Return list for printing */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Get Slice for printing */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private var nums: [Int] // Array for storing queue elements\n    private var front: Int // Front pointer, points to the front of the queue element\n    private var _size: Int // Queue length\n\n    init(capacity: Int) {\n        // Initialize array\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Get the capacity of the queue */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Get the length of the queue */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the queue is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Enqueue */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"Queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        let rear = (front + size()) % capacity()\n        // Front pointer moves one position backward\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Dequeue */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Queue is empty\")\n        }\n        return nums[front]\n    }\n\n    /* Return array */\n    func toArray() -&gt; [Int] {\n        // Elements enqueue\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    #nums; // Array for storing queue elements\n    #front = 0; // Front pointer, points to the front of the queue element\n    #queSize = 0; // Queue length\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* Get the capacity of the queue */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* Get the length of the queue */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Enqueue */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('Queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        const rear = (this.#front + this.size) % this.capacity;\n        // Front pointer moves one position backward\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Dequeue */\n    pop() {\n        const num = this.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (this.isEmpty()) throw new Error('Queue is empty');\n        return this.#nums[this.#front];\n    }\n\n    /* Return Array */\n    toArray() {\n        // Elements enqueue\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n    private nums: number[]; // Array for storing queue elements\n    private front: number; // Front pointer, points to the front of the queue element\n    private queSize: number; // Queue length\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* Get the capacity of the queue */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Get the length of the queue */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Check if the queue is empty */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Enqueue */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('Queue is full');\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        const rear = (this.front + this.queSize) % this.capacity;\n        // Front pointer moves one position backward\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Dequeue */\n    pop(): number {\n        const num = this.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('Queue is empty');\n        return this.nums[this.front];\n    }\n\n    /* Return Array */\n    toArray(): number[] {\n        // Elements enqueue\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // Array for storing queue elements\n  late int _front; // Front pointer, points to the front of the queue element\n  late int _queSize; // Queue length\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* Get the capacity of the queue */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* Get the length of the queue */\n  int size() {\n    return _queSize;\n  }\n\n  /* Check if the queue is empty */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Enqueue */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"Queue is full\");\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    int rear = (_front + _queSize) % capaCity();\n    // Add _num to queue rear\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Dequeue */\n  int pop() {\n    int _num = peek();\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"Queue is empty\");\n    }\n    return _nums[_front];\n  }\n\n  /* Return Array */\n  List&lt;int&gt; toArray() {\n    // Elements enqueue\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* Queue based on circular array implementation */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // Array for storing queue elements\n    front: i32,        // Front pointer, points to the front of the queue element\n    que_size: i32,     // Queue length\n    que_capacity: i32, // Queue capacity\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* Constructor */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* Get the capacity of the queue */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* Get the length of the queue */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* Check if the queue is empty */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Enqueue */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Queue is full\");\n            return;\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // Front pointer moves one position backward\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* Dequeue */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* Return list for printing */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* Return array */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* Queue based on circular array implementation */\ntypedef struct {\n    int *nums;       // Array for storing queue elements\n    int front;       // Front pointer, points to the front of the queue element\n    int queSize;     // Current number of elements in the queue\n    int queCapacity; // Queue capacity\n} ArrayQueue;\n\n/* Constructor */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // Initialize array\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Destructor */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* Get the capacity of the queue */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* Get the length of the queue */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Check if the queue is empty */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* Return list for printing */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* Enqueue */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"Queue is full\\r\\n\");\n        return;\n    }\n    // Use modulo operation to wrap rear around to the head after passing the tail of the array\n    // Add num to the rear of the queue\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // Front pointer moves one position backward\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* Dequeue */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // Move front pointer backward by one position, if it passes the tail, return to array head\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Return array for printing */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* Queue based on circular array implementation */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // Array for storing queue elements\n    private var front: Int = 0 // Front pointer, points to the front of the queue element\n    private var queSize: Int = 0 // Queue length\n\n    /* Get the capacity of the queue */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Get the length of the queue */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Check if the queue is empty */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Enqueue */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Queue is full\")\n            return\n        }\n        // Use modulo operation to wrap rear around to the head after passing the tail of the array\n        // Add num to the rear of the queue\n        val rear = (front + queSize) % capacity()\n        // Front pointer moves one position backward\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Dequeue */\n    fun pop(): Int {\n        val num = peek()\n        // Move front pointer backward by one position, if it passes the tail, return to array head\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Return array */\n    fun toArray(): IntArray {\n        // Elements enqueue\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### Queue based on circular array ###\nclass ArrayQueue\n  ### Get queue length ###\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # Array for storing queue elements\n    @front = 0 # Front pointer, points to the front of the queue element\n    @size = 0 # Queue length\n  end\n\n  ### Get queue capacity ###\n  def capacity\n    @nums.length\n  end\n\n  ### Check if queue is empty ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Enqueue ###\n  def push(num)\n    raise IndexError, 'Queue is full' if size == capacity\n\n    # Use modulo operation to wrap rear around to the head after passing the tail of the array\n    # Add num to the rear of the queue\n    rear = (@front + size) % capacity\n    # Front pointer moves one position backward\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Dequeue ###\n  def pop\n    num = peek\n    # Move front pointer backward by one position, if it passes the tail, return to array head\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### Access front element ###\n  def peek\n    raise IndexError, 'Queue is empty' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Return list for printing ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> <p>The queue implemented above still has limitations: its length is immutable. However, this problem is not difficult to solve. We can replace the array with a dynamic array to introduce an expansion mechanism. Interested readers can try to implement this themselves.</p> <p>The comparison conclusions for the two implementations are consistent with those for stacks and will not be repeated here.</p>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523-typical-applications-of-queue","level":2,"title":"5.2.3   Typical Applications of Queue","text":"<ul> <li>Taobao orders. After shoppers place orders, the orders are added to a queue, and the system subsequently processes the orders in the queue according to their sequence. During Double Eleven, massive orders are generated in a short time, and high concurrency becomes a key challenge that engineers need to tackle.</li> <li>Various to-do tasks. Any scenario that needs to implement \"first come, first served\" functionality, such as a printer's task queue or a restaurant's order queue, can effectively maintain the processing order using queues.</li> </ul>","path":["Chapter 5. Stack and Queue","5.2 &nbsp; Queue"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   Stack","text":"<p>A stack is a linear data structure that follows the Last In First Out (LIFO) logic.</p> <p>We can compare a stack to a pile of plates on a table. If we specify that only one plate can be moved at a time, then to get the bottom plate, we must first remove the plates above it one by one. If we replace the plates with various types of elements (such as integers, characters, objects, etc.), we get the stack data structure.</p> <p>As shown in Figure 5-1, we call the top of the stacked elements the \"top\" and the bottom the \"base.\" The operation of adding an element to the top is called \"push,\" and the operation of removing the top element is called \"pop.\"</p> <p></p> <p> Figure 5-1   LIFO rule of stack </p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511-common-stack-operations","level":2,"title":"5.1.1   Common Stack Operations","text":"<p>The common operations on a stack are shown in Table 5-1. The specific method names depend on the programming language used. Here, we use the common naming convention of <code>push()</code>, <code>pop()</code>, and <code>peek()</code>.</p> <p> Table 5-1   Efficiency of Stack Operations </p> Method Description Time Complexity <code>push()</code> Push element onto stack (add to top) \\(O(1)\\) <code>pop()</code> Pop top element from stack \\(O(1)\\) <code>peek()</code> Access top element \\(O(1)\\) <p>Typically, we can directly use the built-in stack class provided by the programming language. However, some languages may not provide a dedicated stack class. In these cases, we can use the language's \"array\" or \"linked list\" as a stack and ignore operations unrelated to the stack in the program logic.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># Initialize stack\n# Python does not have a built-in stack class, can use list as a stack\nstack: list[int] = []\n\n# Push elements\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Access top element\npeek: int = stack[-1]\n\n# Pop element\npop: int = stack.pop()\n\n# Get stack length\nsize: int = len(stack)\n\n# Check if empty\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* Initialize stack */\nstack&lt;int&gt; stack;\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nint top = stack.top();\n\n/* Pop element */\nstack.pop(); // No return value\n\n/* Get stack length */\nint size = stack.size();\n\n/* Check if empty */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* Initialize stack */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nint peek = stack.peek();\n\n/* Pop element */\nint pop = stack.pop();\n\n/* Get stack length */\nint size = stack.size();\n\n/* Check if empty */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* Initialize stack */\nStack&lt;int&gt; stack = new();\n\n/* Push elements */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Access top element */\nint peek = stack.Peek();\n\n/* Pop element */\nint pop = stack.Pop();\n\n/* Get stack length */\nint size = stack.Count;\n\n/* Check if empty */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* Initialize stack */\n// In Go, it is recommended to use Slice as a stack\nvar stack []int\n\n/* Push elements */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Access top element */\npeek := stack[len(stack)-1]\n\n/* Pop element */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Get stack length */\nsize := len(stack)\n\n/* Check if empty */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* Initialize stack */\n// Swift does not have a built-in stack class, can use Array as a stack\nvar stack: [Int] = []\n\n/* Push elements */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Access top element */\nlet peek = stack.last!\n\n/* Pop element */\nlet pop = stack.removeLast()\n\n/* Get stack length */\nlet size = stack.count\n\n/* Check if empty */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* Initialize stack */\n// JavaScript does not have a built-in stack class, can use Array as a stack\nconst stack = [];\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nconst peek = stack[stack.length-1];\n\n/* Pop element */\nconst pop = stack.pop();\n\n/* Get stack length */\nconst size = stack.length;\n\n/* Check if empty */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* Initialize stack */\n// TypeScript does not have a built-in stack class, can use Array as a stack\nconst stack: number[] = [];\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nconst peek = stack[stack.length - 1];\n\n/* Pop element */\nconst pop = stack.pop();\n\n/* Get stack length */\nconst size = stack.length;\n\n/* Check if empty */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* Initialize stack */\n// Dart does not have a built-in stack class, can use List as a stack\nList&lt;int&gt; stack = [];\n\n/* Push elements */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Access top element */\nint peek = stack.last;\n\n/* Pop element */\nint pop = stack.removeLast();\n\n/* Get stack length */\nint size = stack.length;\n\n/* Check if empty */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* Initialize stack */\n// Use Vec as a stack\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* Push elements */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access top element */\nlet top = stack.last().unwrap();\n\n/* Pop element */\nlet pop = stack.pop().unwrap();\n\n/* Get stack length */\nlet size = stack.len();\n\n/* Check if empty */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C does not provide a built-in stack\n</code></pre> stack.kt<pre><code>/* Initialize stack */\nval stack = Stack&lt;Int&gt;()\n\n/* Push elements */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* Access top element */\nval peek = stack.peek()\n\n/* Pop element */\nval pop = stack.pop()\n\n/* Get stack length */\nval size = stack.size\n\n/* Check if empty */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># Initialize stack\n# Ruby does not have a built-in stack class, can use Array as a stack\nstack = []\n\n# Push elements\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# Access top element\npeek = stack.last\n\n# Pop element\npop = stack.pop\n\n# Get stack length\nsize = stack.length\n\n# Check if empty\nis_empty = stack.empty?\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512-stack-implementation","level":2,"title":"5.1.2   Stack Implementation","text":"<p>To gain a deeper understanding of how a stack operates, let's try implementing a stack class ourselves.</p> <p>A stack follows the LIFO principle, so we can only add or remove elements at the top. However, both arrays and linked lists allow adding and removing elements at any position. Therefore, a stack can be viewed as a restricted array or linked list. In other words, we can \"shield\" some irrelevant operations of arrays or linked lists so that their external logic conforms to the characteristics of a stack.</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1-linked-list-implementation","level":3,"title":"1.   Linked List Implementation","text":"<p>When implementing a stack using a linked list, we can treat the head node of the linked list as the top of the stack and the tail node as the base.</p> <p>As shown in Figure 5-2, for the push operation, we simply insert an element at the head of the linked list. This node insertion method is called the \"head insertion method.\" For the pop operation, we just need to remove the head node from the linked list.</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> Figure 5-2   Push and pop operations in linked list implementation of stack </p> <p>Below is sample code for implementing a stack based on a linked list:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"Stack based on linked list implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the stack\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the stack is empty\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"Push\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Pop\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Access top of the stack element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Convert to list for printing\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // Use head node as stack top\n    int stkSize;        // Stack length\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // Traverse linked list to delete nodes and free memory\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* Get the length of the stack */\n    int size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // Free memory\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"Stack is empty\");\n        return stackTop-&gt;val;\n    }\n\n    /* Convert List to Array and return */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private ListNode stackPeek; // Use head node as stack top\n    private int stkSize = 0; // Stack length\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    public int size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* Convert List to Array and return */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    ListNode? stackPeek;  // Use head node as stack top\n    int stkSize = 0;   // Stack length\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* Check if the stack is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Push */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Pop */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* Convert List to Array and return */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* Stack based on linked list implementation */\ntype linkedListStack struct {\n    // Use built-in package list to implement stack\n    data *list.List\n}\n\n/* Access top of the stack element */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* Push */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* Pop */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Return list for printing */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Get the length of the stack */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* Check if the stack is empty */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Get List for printing */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private var _peek: ListNode? // Use head node as stack top\n    private var _size: Int // Stack length\n\n    init() {\n        _size = 0\n    }\n\n    /* Get the length of the stack */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Check if the stack is empty */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Push */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* Pop */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return _peek!.val\n    }\n\n    /* Convert List to Array and return */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    #stackPeek; // Use head node as stack top\n    #stkSize = 0; // Stack length\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Push */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* Pop */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek() {\n        if (!this.#stackPeek) throw new Error('Stack is empty');\n        return this.#stackPeek.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // Use head node as stack top\n    private stkSize: number = 0; // Stack length\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* Get the length of the stack */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Push */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* Pop */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('Stack is empty');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* Return list for printing */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('Stack is empty');\n        return this.stackPeek.val;\n    }\n\n    /* Convert linked list to Array and return */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* Stack implemented based on linked list class */\nclass LinkedListStack {\n  ListNode? _stackPeek; // Use head node as stack top\n  int _stkSize = 0; // Stack length\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* Get the length of the stack */\n  int size() {\n    return _stkSize;\n  }\n\n  /* Check if the stack is empty */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* Push */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* Pop */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* Convert linked list to List and return */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* Stack based on linked list implementation */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Use head node as stack top\n    stk_size: usize,                              // Stack length\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* Get the length of the stack */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* Check if the stack is empty */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* Push */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* Pop */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* Return list for printing */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* Convert List to Array and return */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* Stack based on linked list implementation */\ntypedef struct {\n    ListNode *top; // Use head node as stack top\n    int size;      // Stack length\n} LinkedListStack;\n\n/* Constructor */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* Destructor */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* Get the length of the stack */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* Check if the stack is empty */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* Push */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // Update new node's pointer field\n    node-&gt;val = num;     // Update new node's data field\n    s-&gt;top = node;       // Update stack top\n    s-&gt;size++;           // Update stack size\n}\n\n/* Return list for printing */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"Stack is empty\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* Pop */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // Free memory\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* Stack based on linked list implementation */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // Use head node as stack top\n    private var stkSize: Int = 0 // Stack length\n) {\n\n    /* Get the length of the stack */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* Check if the stack is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Push */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* Pop */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* Return list for printing */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* Convert List to Array and return */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### Stack based on linked list ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### Constructor ###\n  def initialize\n    @size = 0\n  end\n\n  ### Check if stack is empty ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### Push ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### Pop ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### Access top element ###\n  def peek\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @peek.val\n  end\n\n  ### Convert linked list to Array and return ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2-array-implementation","level":3,"title":"2.   Array Implementation","text":"<p>When implementing a stack using an array, we can treat the end of the array as the top of the stack. As shown in Figure 5-3, push and pop operations correspond to adding and removing elements at the end of the array, both with a time complexity of \\(O(1)\\).</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> Figure 5-3   Push and pop operations in array implementation of stack </p> <p>Since elements pushed onto the stack may increase continuously, we can use a dynamic array, which eliminates the need to handle array expansion ourselves. Here is the sample code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"Stack based on array implementation\"\"\"\n\n    def __init__(self):\n        \"\"\"Constructor\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"Get the length of the stack\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the stack is empty\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"Push\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"Pop\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"Access top of the stack element\"\"\"\n        if self.is_empty():\n            raise IndexError(\"Stack is empty\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Return list for printing\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* Get the length of the stack */\n    int size() {\n        return stack.size();\n    }\n\n    /* Check if the stack is empty */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* Push */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* Pop */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* Return list for printing */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"Stack is empty\");\n        return stack.back();\n    }\n\n    /* Return Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // Initialize list (dynamic array)\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* Get the length of the stack */\n    public int size() {\n        return stack.size();\n    }\n\n    /* Check if the stack is empty */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Push */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* Pop */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* Return list for printing */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* Convert List to Array and return */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // Initialize list (dynamic array)\n        stack = [];\n    }\n\n    /* Get the length of the stack */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* Check if the stack is empty */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Push */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* Pop */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* Return list for printing */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* Convert List to Array and return */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* Stack based on array implementation */\ntype arrayStack struct {\n    data []int // Data\n}\n\n/* Access top of the stack element */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // Set stack length to 0, capacity to 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* Stack length */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* Is stack empty */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* Push */\nfunc (s *arrayStack) push(v int) {\n    // Slice will automatically expand\n    s.data = append(s.data, v)\n}\n\n/* Pop */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* Get stack top element */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* Get Slice for printing */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // Initialize list (dynamic array)\n        stack = []\n    }\n\n    /* Get the length of the stack */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* Check if the stack is empty */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* Push */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* Pop */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return stack.removeLast()\n    }\n\n    /* Return list for printing */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"Stack is empty\")\n        }\n        return stack.last!\n    }\n\n    /* Convert List to Array and return */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* Get the length of the stack */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* Push */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* Pop */\n    pop() {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.#stack.pop();\n    }\n\n    /* Return list for printing */\n    top() {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Return Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* Get the length of the stack */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* Check if the stack is empty */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* Push */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* Pop */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.stack.pop();\n    }\n\n    /* Return list for printing */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('Stack is empty');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Return Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* Get the length of the stack */\n  int size() {\n    return _stack.length;\n  }\n\n  /* Check if the stack is empty */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* Push */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* Pop */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* Return list for printing */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"Stack is empty\");\n    }\n    return _stack.last;\n  }\n\n  /* Convert stack to Array and return */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* Stack based on array implementation */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* Access top of the stack element */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* Get the length of the stack */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* Check if the stack is empty */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* Push */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* Pop */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* Return list for printing */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"Stack is empty\")\n        };\n        self.stack.last()\n    }\n\n    /* Return &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* Stack based on array implementation */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* Constructor */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // Initialize with large capacity to avoid expansion\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* Destructor */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* Get the length of the stack */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* Check if the stack is empty */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* Push */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"Stack is full\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* Return list for printing */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"Stack is empty\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* Pop */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* Stack based on array implementation */\nclass ArrayStack {\n    // Initialize list (dynamic array)\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* Get the length of the stack */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* Check if the stack is empty */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Push */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* Pop */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* Return list for printing */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* Convert List to Array and return */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### Stack based on array ###\nclass ArrayStack\n  ### Constructor ###\n  def initialize\n    @stack = []\n  end\n\n  ### Get stack length ###\n  def size\n    @stack.length\n  end\n\n  ### Check if stack is empty ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### Push ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### Pop ###\n  def pop\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @stack.pop\n  end\n\n  ### Access top element ###\n  def peek\n    raise IndexError, 'Stack is empty' if is_empty?\n\n    @stack.last\n  end\n\n  ### Return list for printing ###\n  def to_array\n    @stack\n  end\nend\n</code></pre>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513-comparison-of-the-two-implementations","level":2,"title":"5.1.3   Comparison of the Two Implementations","text":"<p>Supported Operations</p> <p>Both implementations support all operations defined by the stack. The array implementation additionally supports random access, but this goes beyond the stack definition and is generally not used.</p> <p>Time Efficiency</p> <p>In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and is therefore more efficient. However, if pushing exceeds the array capacity, it triggers an expansion mechanism, causing the time complexity of that particular push operation to become \\(O(n)\\).</p> <p>In the linked list-based implementation, list expansion is very flexible, and there is no issue of reduced efficiency due to array expansion. However, the push operation requires initializing a node object and modifying pointers, so it is relatively less efficient. Nevertheless, if the pushed elements are already node objects, the initialization step can be omitted, thereby improving efficiency.</p> <p>In summary, when the elements pushed and popped are basic data types such as <code>int</code> or <code>double</code>, we can draw the following conclusions:</p> <ul> <li>The array-based stack implementation has reduced efficiency when expansion is triggered, but since expansion is an infrequent operation, the average efficiency is higher.</li> <li>The linked list-based stack implementation can provide more stable efficiency performance.</li> </ul> <p>Space Efficiency</p> <p>When initializing a list, the system allocates an \"initial capacity\" that may exceed the actual need. Additionally, the expansion mechanism typically expands at a specific ratio (e.g., 2x), and the capacity after expansion may also exceed actual needs. Therefore, the array-based stack implementation may cause some space wastage.</p> <p>However, since linked list nodes need to store additional pointers, the space occupied by linked list nodes is relatively large.</p> <p>In summary, we cannot simply determine which implementation is more memory-efficient and need to analyze the specific situation.</p>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514-typical-applications-of-stack","level":2,"title":"5.1.4   Typical Applications of Stack","text":"<ul> <li>Back and forward in browsers, undo and redo in software. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to return to the previous page via the back operation. The back operation is essentially performing a pop. To support both back and forward, two stacks are needed to work together.</li> <li>Program memory management. Each time a function is called, the system adds a stack frame to the top of the stack to record the function's context information. During recursion, the downward recursive phase continuously performs push operations, while the upward backtracking phase continuously performs pop operations.</li> </ul>","path":["Chapter 5. Stack and Queue","5.1 &nbsp; Stack"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   Summary","text":"","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A stack is a data structure that follows the LIFO principle and can be implemented using arrays or linked lists.</li> <li>In terms of time efficiency, the array implementation of a stack has higher average efficiency, but during expansion, the time complexity of a single push operation degrades to \\(O(n)\\). In contrast, the linked list implementation of a stack provides more stable efficiency performance.</li> <li>In terms of space efficiency, the array implementation of a stack may lead to some degree of space wastage. However, it should be noted that the memory space occupied by linked list nodes is larger than that of array elements.</li> <li>A queue is a data structure that follows the FIFO principle and can also be implemented using arrays or linked lists. The conclusions regarding time efficiency and space efficiency comparisons for queues are similar to those for stacks mentioned above.</li> <li>A deque is a queue with greater flexibility that allows adding and removing elements at both ends.</li> </ul>","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Is the browser's forward and backward functionality implemented with a doubly linked list?</p> <p>The forward and backward functionality of a browser is essentially a manifestation of a \"stack.\" When a user visits a new page, that page is added to the top of the stack; when the user clicks the back button, that page is popped from the top of the stack. Using a deque can conveniently implement some additional operations, as mentioned in the \"Deque\" section.</p> <p>Q: After popping from the stack, do we need to free the memory of the popped node?</p> <p>If the popped node will still be needed later, then memory does not need to be freed. If it won't be used afterward, languages like Java and Python have automatic garbage collection, so manual memory deallocation is not required; in C and C++, manual memory deallocation is necessary.</p> <p>Q: A deque seems like two stacks joined together. What is its purpose?</p> <p>A deque is like a combination of a stack and a queue, or two stacks joined together. It exhibits the logic of both stack and queue, so it can implement all applications of stacks and queues, and is more flexible.</p> <p>Q: How are undo and redo specifically implemented?</p> <p>Use two stacks: stack <code>A</code> for undo and stack <code>B</code> for redo.</p> <ol> <li>Whenever the user performs an operation, push this operation onto stack <code>A</code> and clear stack <code>B</code>.</li> <li>When the user performs \"undo,\" pop the most recent operation from stack <code>A</code> and push it onto stack <code>B</code>.</li> <li>When the user performs \"redo,\" pop the most recent operation from stack <code>B</code> and push it onto stack <code>A</code>.</li> </ol>","path":["Chapter 5. Stack and Queue","5.4 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"Chapter 7.   Tree","text":"<p>Abstract</p> <p>Towering trees are full of vitality, with deep roots and lush leaves, spreading branches and flourishing.</p> <p>They show us the vivid form of divide and conquer in data.</p>","path":["Chapter 7. Tree","Chapter 7. &nbsp; Tree"],"tags":[]},{"location":"chapter_tree/#chapter-contents","level":2,"title":"Chapter contents","text":"<ul> <li>7.1   Binary Tree</li> <li>7.2   Binary Tree Traversal</li> <li>7.3   Array Representation of Tree</li> <li>7.4   Binary Search Tree</li> <li>7.5   AVL Tree *</li> <li>7.6   Summary</li> </ul>","path":["Chapter 7. Tree","Chapter 7. &nbsp; Tree"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   Array Representation of Binary Trees","text":"<p>Under the linked list representation, the storage unit of a binary tree is a node <code>TreeNode</code>, and nodes are connected by pointers. The previous section introduced the basic operations of binary trees under the linked list representation.</p> <p>So, can we use an array to represent a binary tree? The answer is yes.</p>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731-representing-perfect-binary-trees","level":2,"title":"7.3.1   Representing Perfect Binary Trees","text":"<p>Let's analyze a simple case first. Given a perfect binary tree, we store all nodes in an array according to the order of level-order traversal, where each node corresponds to a unique array index.</p> <p>Based on the characteristics of level-order traversal, we can derive a \"mapping formula\" between parent node index and child node indices: If a node's index is \\(i\\), then its left child index is \\(2i + 1\\) and its right child index is \\(2i + 2\\). Figure 7-12 shows the mapping relationships between various node indices.</p> <p></p> <p> Figure 7-12   Array representation of a perfect binary tree </p> <p>The mapping formula plays a role similar to the node references (pointers) in linked lists. Given any node in the array, we can access its left (right) child node using the mapping formula.</p>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732-representing-any-binary-tree","level":2,"title":"7.3.2   Representing Any Binary Tree","text":"<p>Perfect binary trees are a special case; in the middle levels of a binary tree, there are typically many <code>None</code> values. Since the level-order traversal sequence does not include these <code>None</code> values, we cannot infer the number and distribution of <code>None</code> values based on this sequence alone. This means multiple binary tree structures can correspond to the same level-order traversal sequence.</p> <p>As shown in Figure 7-13, given a non-perfect binary tree, the above method of array representation fails.</p> <p></p> <p> Figure 7-13   Level-order traversal sequence corresponds to multiple binary tree possibilities </p> <p>To solve this problem, we can consider explicitly writing out all <code>None</code> values in the level-order traversal sequence. As shown in Figure 7-14, after this treatment, the level-order traversal sequence can uniquely represent a binary tree. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Array representation of a binary tree\n# Using None to represent empty slots\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the maximum integer value INT_MAX to mark empty slots\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the Integer wrapper class allows for using null to mark empty slots\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using an any type slice, allowing for nil to mark empty slots\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using optional Int (Int?) allows for using nil to mark empty slots\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using None to mark empty slots\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using the maximum int value to mark empty slots, therefore, node values must not be INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Array representation of a binary tree */\n// Using null to represent empty slots\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### Array representation of a binary tree ###\n# Using nil to represent empty slots\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> Figure 7-14   Array representation of any type of binary tree </p> <p>It's worth noting that complete binary trees are very well-suited for array representation. Recalling the definition of a complete binary tree, <code>None</code> only appears at the bottom level and towards the right, meaning all <code>None</code> values must appear at the end of the level-order traversal sequence.</p> <p>This means that when using an array to represent a complete binary tree, it's possible to omit storing all <code>None</code> values, which is very convenient. Figure 7-15 gives an example.</p> <p></p> <p> Figure 7-15   Array representation of a complete binary tree </p> <p>The following code implements a binary tree based on array representation, including the following operations:</p> <ul> <li>Given a certain node, obtain its value, left (right) child node, and parent node.</li> <li>Obtain the preorder, inorder, postorder, and level-order traversal sequences.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"Binary tree class represented by array\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"Constructor\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"List capacity\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"Get value of node at index i\"\"\"\n        # If index is out of bounds, return None, representing empty position\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"Get index of left child node of node at index i\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"Get index of right child node of node at index i\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"Get index of parent node of node at index i\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"Level-order traversal\"\"\"\n        self.res = []\n        # Traverse array directly\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"Depth-first traversal\"\"\"\n        if self.val(i) is None:\n            return\n        # Preorder traversal\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # Inorder traversal\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # Postorder traversal\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"Preorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"Inorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"Postorder traversal\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n  public:\n    /* Constructor */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* List capacity */\n    int size() {\n        return tree.size();\n    }\n\n    /* Get value of node at index i */\n    int val(int i) {\n        // Return INT_MAX if index out of bounds, representing empty position\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // Traverse array directly\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* Preorder traversal */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* Depth-first traversal */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // If empty position, return\n        if (val(i) == INT_MAX)\n            return;\n        // Preorder traversal\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // Inorder traversal\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // Postorder traversal\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* Constructor */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* List capacity */\n    public int size() {\n        return tree.size();\n    }\n\n    /* Get value of node at index i */\n    public Integer val(int i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* Get index of left child node of node at index i */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // Traverse array directly\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // If empty position, return\n        if (val(i) == null)\n            return;\n        // Preorder traversal\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // Inorder traversal\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // Postorder traversal\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* Preorder traversal */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* List capacity */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* Get value of node at index i */\n    public int? Val(int i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Level-order traversal */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // Traverse array directly\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // If empty position, return\n        if (!Val(i).HasValue)\n            return;\n        // Preorder traversal\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // Inorder traversal\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // Postorder traversal\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* Preorder traversal */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* Binary tree class represented by array */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* Constructor */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* List capacity */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* Get value of node at index i */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // If index out of bounds, return null to represent empty position\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* Get index of left child node of node at index i */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* Get index of right child node of node at index i */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* Get index of parent node of node at index i */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* Level-order traversal */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // Traverse array directly\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* Depth-first traversal */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // If empty position, return\n    if abt.val(i) == nil {\n        return\n    }\n    // Preorder traversal\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // Inorder traversal\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // Postorder traversal\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* Preorder traversal */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* Inorder traversal */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* Postorder traversal */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* Constructor */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* List capacity */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* Get value of node at index i */\n    func val(i: Int) -&gt; Int? {\n        // If index out of bounds, return null to represent empty position\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* Get index of left child node of node at index i */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // Traverse array directly\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* Depth-first traversal */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // If empty position, return\n        guard let val = val(i: i) else {\n            return\n        }\n        // Preorder traversal\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // Inorder traversal\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // Postorder traversal\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* Preorder traversal */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* Inorder traversal */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* Postorder traversal */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* Constructor */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* List capacity */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* Get value of node at index i */\n    val(i) {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // Floor division\n    }\n\n    /* Level-order traversal */\n    levelOrder() {\n        let res = [];\n        // Traverse array directly\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    #dfs(i, order, res) {\n        // If empty position, return\n        if (this.val(i) === null) return;\n        // Preorder traversal\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Inorder traversal\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Postorder traversal\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Preorder traversal */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* Constructor */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* List capacity */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* Get value of node at index i */\n    val(i: number): number | null {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Get index of left child node of node at index i */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* Get index of right child node of node at index i */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* Get index of parent node of node at index i */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // Floor division\n    }\n\n    /* Level-order traversal */\n    levelOrder(): number[] {\n        let res = [];\n        // Traverse array directly\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Depth-first traversal */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // If empty position, return\n        if (this.val(i) === null) return;\n        // Preorder traversal\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Inorder traversal\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Postorder traversal\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Preorder traversal */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Inorder traversal */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Postorder traversal */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* Constructor */\n  ArrayBinaryTree(this._tree);\n\n  /* List capacity */\n  int size() {\n    return _tree.length;\n  }\n\n  /* Get value of node at index i */\n  int? val(int i) {\n    // If index out of bounds, return null to represent empty position\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* Get index of left child node of node at index i */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* Get index of right child node of node at index i */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* Get index of parent node of node at index i */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* Level-order traversal */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* Depth-first traversal */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // If empty position, return\n    if (val(i) == null) {\n      return;\n    }\n    // Preorder traversal\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // Inorder traversal\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // Postorder traversal\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* Preorder traversal */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* Inorder traversal */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* Postorder traversal */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* Binary tree class represented by array */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* Constructor */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* List capacity */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* Get value of node at index i */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // If index is out of bounds, return None, representing empty position\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* Get index of left child node of node at index i */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* Depth-first traversal */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // Preorder traversal\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // Inorder traversal\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // Postorder traversal\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* Preorder traversal */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* Inorder traversal */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* Postorder traversal */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* Binary tree structure in array representation */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* Constructor */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* Destructor */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* List capacity */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* Get value of node at index i */\nint val(ArrayBinaryTree *abt, int i) {\n    // Return INT_MAX if index out of bounds, representing empty position\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* Level-order traversal */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // Traverse array directly\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* Depth-first traversal */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // If empty position, return\n    if (val(abt, i) == INT_MAX)\n        return;\n    // Preorder traversal\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // Inorder traversal\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // Postorder traversal\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* Preorder traversal */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Inorder traversal */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Postorder traversal */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* Binary tree class represented by array */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* List capacity */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* Get value of node at index i */\n    fun _val(i: Int): Int? {\n        // If index out of bounds, return null to represent empty position\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* Get index of left child node of node at index i */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Get index of right child node of node at index i */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Get index of parent node of node at index i */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* Level-order traversal */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // Traverse array directly\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* Depth-first traversal */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // If empty position, return\n        if (_val(i) == null)\n            return\n        // Preorder traversal\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // Inorder traversal\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // Postorder traversal\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* Preorder traversal */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* Inorder traversal */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* Postorder traversal */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### Array representation of binary tree class ###\nclass ArrayBinaryTree\n  ### Constructor ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### List capacity ###\n  def size\n    @tree.length\n  end\n\n  ### Get value of node at index i ###\n  def val(i)\n    # Return nil if index out of bounds, representing empty position\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### Get left child index of node at index i ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### Get right child index of node at index i ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### Get parent node index of node at index i ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### Level-order traversal ###\n  def level_order\n    @res = []\n\n    # Traverse array directly\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### Depth-first traversal ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # Preorder traversal\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # Inorder traversal\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # Postorder traversal\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### Pre-order traversal ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### In-order traversal ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### Post-order traversal ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733-advantages-and-limitations","level":2,"title":"7.3.3   Advantages and Limitations","text":"<p>The array representation of binary trees has the following advantages:</p> <ul> <li>Arrays are stored in contiguous memory space, which is cache-friendly, allowing faster access and traversal.</li> <li>It does not require storing pointers, which saves space.</li> <li>It allows random access to nodes.</li> </ul> <p>However, the array representation also has some limitations:</p> <ul> <li>Array storage requires contiguous memory space, so it is not suitable for storing trees with a large amount of data.</li> <li>Adding or removing nodes requires array insertion and deletion operations, which have lower efficiency.</li> <li>When there are many <code>None</code> values in the binary tree, the proportion of node data contained in the array is low, leading to lower space utilization.</li> </ul>","path":["Chapter 7. Tree","7.3 &nbsp; Array Representation of Binary Trees"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   Avl Tree *","text":"<p>In the \"Binary Search Tree\" section, we mentioned that after multiple insertion and removal operations, a binary search tree may degenerate into a linked list. In this case, the time complexity of all operations degrades from \\(O(\\log n)\\) to \\(O(n)\\).</p> <p>As shown in Figure 7-24, after two node removal operations, this binary search tree will degrade into a linked list.</p> <p></p> <p> Figure 7-24   Degradation of an AVL tree after removing nodes </p> <p>For example, in the perfect binary tree shown in Figure 7-25, after inserting two nodes, the tree will lean heavily to the left, and the time complexity of search operations will also degrade.</p> <p></p> <p> Figure 7-25   Degradation of an AVL tree after inserting nodes </p> <p>In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the AVL tree in their paper \"An algorithm for the organization of information\". The paper described in detail a series of operations ensuring that after continuously adding and removing nodes, the AVL tree does not degenerate, thus keeping the time complexity of various operations at the \\(O(\\log n)\\) level. In other words, in scenarios requiring frequent insertions, deletions, searches, and modifications, the AVL tree can always maintain efficient data operation performance, making it very valuable in applications.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-common-terminology-in-avl-trees","level":2,"title":"7.5.1   Common Terminology in Avl Trees","text":"<p>An AVL tree is both a binary search tree and a balanced binary tree, simultaneously satisfying all the properties of these two types of binary trees, hence it is a balanced binary search tree.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-node-height","level":3,"title":"1.   Node Height","text":"<p>Since the operations related to AVL trees require obtaining node heights, we need to add a <code>height</code> variable to the node class:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # Node value\n        self.height: int = 0                # Node height\n        self.left: TreeNode | None = None   # Left child reference\n        self.right: TreeNode | None = None  # Right child reference\n</code></pre> <pre><code>/* AVL tree node */\nstruct TreeNode {\n    int val{};          // Node value\n    int height = 0;     // Node height\n    TreeNode *left{};   // Left child\n    TreeNode *right{};  // Right child\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    public int val;        // Node value\n    public int height;     // Node height\n    public TreeNode left;  // Left child\n    public TreeNode right; // Right child\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public int height;      // Node height\n    public TreeNode? left;  // Left child reference\n    public TreeNode? right; // Right child reference\n}\n</code></pre> <pre><code>/* AVL tree node */\ntype TreeNode struct {\n    Val    int       // Node value\n    Height int       // Node height\n    Left   *TreeNode // Left child reference\n    Right  *TreeNode // Right child reference\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var height: Int // Node height\n    var left: TreeNode? // Left child\n    var right: TreeNode? // Right child\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    val; // Node value\n    height; // Node height\n    left; // Left child pointer\n    right; // Right child pointer\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n    val: number;            // Node value\n    height: number;         // Node height\n    left: TreeNode | null;  // Left child pointer\n    right: TreeNode | null; // Right child pointer\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height; \n        this.left = left === undefined ? null : left; \n        this.right = right === undefined ? null : right; \n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode {\n  int val;         // Node value\n  int height;      // Node height\n  TreeNode? left;  // Left child\n  TreeNode? right; // Right child\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    height: i32,                            // Node height\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Left child\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Right child\n}\n\nimpl TreeNode {\n    /* Constructor */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL tree node */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* Constructor */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val height: Int = 0          // Node height\n    val left: TreeNode? = null   // Left child\n    val right: TreeNode? = null  // Right child\n}\n</code></pre> <pre><code>### AVL tree node class ###\nclass TreeNode\n  attr_accessor :val    # Node value\n  attr_accessor :height # Node height\n  attr_accessor :left   # Left child reference\n  attr_accessor :right  # Right child reference\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>The \"node height\" refers to the distance from that node to its farthest leaf node, i.e., the number of \"edges\" passed. It is important to note that the height of a leaf node is \\(0\\), and the height of a null node is \\(-1\\). We will create two utility functions for getting and updating the height of a node:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Get node height\"\"\"\n    # Empty node height is -1, leaf node height is 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"Update node height\"\"\"\n    # Node height equals the height of the tallest subtree + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* Get node height */\nint height(TreeNode *node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode *node) {\n    // Node height equals the height of the tallest subtree + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* Get node height */\nint height(TreeNode node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* Get node height */\nint Height(TreeNode? node) {\n    // Empty node height is -1, leaf node height is 0\n    return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid UpdateHeight(TreeNode node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* Get node height */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // Empty node height is -1, leaf node height is 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* Update node height */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // Node height equals the height of the tallest subtree + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* Get node height */\nfunc height(node: TreeNode?) -&gt; Int {\n    // Empty node height is -1, leaf node height is 0\n    node?.height ?? -1\n}\n\n/* Update node height */\nfunc updateHeight(node: TreeNode?) {\n    // Node height equals the height of the tallest subtree + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* Get node height */\nheight(node) {\n    // Empty node height is -1, leaf node height is 0\n    return node === null ? -1 : node.height;\n}\n\n/* Update node height */\n#updateHeight(node) {\n    // Node height equals the height of the tallest subtree + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* Get node height */\nheight(node: TreeNode): number {\n    // Empty node height is -1, leaf node height is 0\n    return node === null ? -1 : node.height;\n}\n\n/* Update node height */\nupdateHeight(node: TreeNode): void {\n    // Node height equals the height of the tallest subtree + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* Get node height */\nint height(TreeNode? node) {\n  // Empty node height is -1, leaf node height is 0\n  return node == null ? -1 : node.height;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode? node) {\n  // Node height equals the height of the tallest subtree + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* Get node height */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // Empty node height is -1, leaf node height is 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* Update node height */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // Node height equals the height of the tallest subtree + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Get node height */\nint height(TreeNode *node) {\n    // Empty node height is -1, leaf node height is 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* Update node height */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // Node height equals the height of the tallest subtree + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* Get node height */\nfun height(node: TreeNode?): Int {\n    // Empty node height is -1, leaf node height is 0\n    return node?.height ?: -1\n}\n\n/* Update node height */\nfun updateHeight(node: TreeNode?) {\n    // Node height equals the height of the tallest subtree + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### Get node height ###\ndef height(node)\n  # Empty node height is -1, leaf node height is 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### Update node height ###\ndef update_height(node)\n  # Node height equals the height of the tallest subtree + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-node-balance-factor","level":3,"title":"2.   Node Balance Factor","text":"<p>The balance factor of a node is defined as the height of the node's left subtree minus the height of its right subtree, and the balance factor of a null node is defined as \\(0\\). We also encapsulate the function to obtain the node's balance factor for convenient subsequent use:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Get balance factor\"\"\"\n    # Empty node balance factor is 0\n    if node is None:\n        return 0\n    # Node balance factor = left subtree height - right subtree height\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode *node) {\n    // Empty node balance factor is 0\n    if (node == nullptr)\n        return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode node) {\n    // Empty node balance factor is 0\n    if (node == null)\n        return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* Get balance factor */\nint BalanceFactor(TreeNode? node) {\n    // Empty node balance factor is 0\n    if (node == null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* Get balance factor */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // Empty node balance factor is 0\n    if node == nil {\n        return 0\n    }\n    // Node balance factor = left subtree height - right subtree height\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* Get balance factor */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // Empty node balance factor is 0\n    guard let node = node else { return 0 }\n    // Node balance factor = left subtree height - right subtree height\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* Get balance factor */\nbalanceFactor(node) {\n    // Empty node balance factor is 0\n    if (node === null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* Get balance factor */\nbalanceFactor(node: TreeNode): number {\n    // Empty node balance factor is 0\n    if (node === null) return 0;\n    // Node balance factor = left subtree height - right subtree height\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode? node) {\n  // Empty node balance factor is 0\n  if (node == null) return 0;\n  // Node balance factor = left subtree height - right subtree height\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* Get balance factor */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // Empty node balance factor is 0\n        None =&gt; 0,\n        // Node balance factor = left subtree height - right subtree height\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Get balance factor */\nint balanceFactor(TreeNode *node) {\n    // Empty node balance factor is 0\n    if (node == NULL) {\n        return 0;\n    }\n    // Node balance factor = left subtree height - right subtree height\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* Get balance factor */\nfun balanceFactor(node: TreeNode?): Int {\n    // Empty node balance factor is 0\n    if (node == null) return 0\n    // Node balance factor = left subtree height - right subtree height\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### Get balance factor ###\ndef balance_factor(node)\n  # Empty node balance factor is 0\n  return 0 if node.nil?\n\n  # Node balance factor = left subtree height - right subtree height\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>Let the balance factor be \\(f\\), then the balance factor of any node in an AVL tree satisfies \\(-1 \\le f \\le 1\\).</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-rotations-in-avl-trees","level":2,"title":"7.5.2   Rotations in Avl Trees","text":"<p>The characteristic of AVL trees lies in the \"rotation\" operation, which can restore balance to unbalanced nodes without affecting the inorder traversal sequence of the binary tree. In other words, rotation operations can both maintain the property of a \"binary search tree\" and make the tree return to a \"balanced binary tree\".</p> <p>We call nodes with a balance factor absolute value \\(&gt; 1\\) \"unbalanced nodes\". Depending on the imbalance situation, rotation operations are divided into four types: right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. Below we describe these rotation operations in detail.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-right-rotation","level":3,"title":"1.   Right Rotation","text":"<p>As shown in Figure 7-26, the value below the node is the balance factor. From bottom to top, the first unbalanced node in the binary tree is \"node 3\". We focus on the subtree with this unbalanced node as the root, denoting the node as <code>node</code> and its left child as <code>child</code>, and perform a \"right rotation\" operation. After the right rotation is completed, the subtree regains balance and still maintains the properties of a binary search tree.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-26   Steps of right rotation </p> <p>As shown in Figure 7-27, when the <code>child</code> node has a right child (denoted as <code>grand_child</code>), a step needs to be added in the right rotation: set <code>grand_child</code> as the left child of <code>node</code>.</p> <p></p> <p> Figure 7-27   Right rotation with grand_child </p> <p>\"Right rotation\" is a figurative term; in practice, it is achieved by modifying node pointers, as shown in the following code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Right rotation operation\"\"\"\n    child = node.left\n    grand_child = child.right\n    # Using child as pivot, rotate node to the right\n    child.right = node\n    node.left = grand_child\n    # Update node height\n    self.update_height(node)\n    self.update_height(child)\n    # Return root node of subtree after rotation\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Right rotation operation */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // Using child as pivot, rotate node to the right\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Right rotation operation */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Right rotation operation */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Right rotation operation */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // Using child as pivot, rotate node to the right\n    child.Right = node\n    node.Left = grandChild\n    // Update node height\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Right rotation operation */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // Using child as pivot, rotate node to the right\n    child?.right = node\n    node?.left = grandChild\n    // Update node height\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Right rotation operation */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Right rotation operation */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // Using child as pivot, rotate node to the right\n    child.right = node;\n    node.left = grandChild;\n    // Update node height\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Right rotation operation */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // Using child as pivot, rotate node to the right\n  child.right = node;\n  node.left = grandChild;\n  // Update node height\n  updateHeight(node);\n  updateHeight(child);\n  // Return root node of subtree after rotation\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Right rotation operation */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // Using child as pivot, rotate node to the right\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // Update node height\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Return root node of subtree after rotation\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Right rotation operation */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // Using child as pivot, rotate node to the right\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Right rotation operation */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // Using child as pivot, rotate node to the right\n    child.right = node\n    node.left = grandChild\n    // Update node height\n    updateHeight(node)\n    updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Right rotation ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # Using child as pivot, rotate node to the right\n  child.right = node\n  node.left = grand_child\n  # Update node height\n  update_height(node)\n  update_height(child)\n  # Return root node of subtree after rotation\n  child\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-left-rotation","level":3,"title":"2.   Left Rotation","text":"<p>Correspondingly, if considering the \"mirror\" of the above unbalanced binary tree, the \"left rotation\" operation shown in Figure 7-28 needs to be performed.</p> <p></p> <p> Figure 7-28   Left rotation operation </p> <p>Similarly, as shown in Figure 7-29, when the <code>child</code> node has a left child (denoted as <code>grand_child</code>), a step needs to be added in the left rotation: set <code>grand_child</code> as the right child of <code>node</code>.</p> <p></p> <p> Figure 7-29   Left rotation with grand_child </p> <p>It can be observed that right rotation and left rotation operations are mirror symmetric in logic, and the two imbalance cases they solve are also symmetric. Based on symmetry, we only need to replace all <code>left</code> in the right rotation implementation code with <code>right</code>, and all <code>right</code> with <code>left</code>, to obtain the left rotation implementation code:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Left rotation operation\"\"\"\n    child = node.right\n    grand_child = child.left\n    # Using child as pivot, rotate node to the left\n    child.left = node\n    node.right = grand_child\n    # Update node height\n    self.update_height(node)\n    self.update_height(child)\n    # Return root node of subtree after rotation\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Left rotation operation */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // Using child as pivot, rotate node to the left\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Left rotation operation */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Left rotation operation */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Left rotation operation */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // Using child as pivot, rotate node to the left\n    child.Left = node\n    node.Right = grandChild\n    // Update node height\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Left rotation operation */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // Using child as pivot, rotate node to the left\n    child?.left = node\n    node?.right = grandChild\n    // Update node height\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Left rotation operation */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Left rotation operation */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // Using child as pivot, rotate node to the left\n    child.left = node;\n    node.right = grandChild;\n    // Update node height\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Left rotation operation */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // Using child as pivot, rotate node to the left\n  child.left = node;\n  node.right = grandChild;\n  // Update node height\n  updateHeight(node);\n  updateHeight(child);\n  // Return root node of subtree after rotation\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Left rotation operation */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // Using child as pivot, rotate node to the left\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // Update node height\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Return root node of subtree after rotation\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Left rotation operation */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // Using child as pivot, rotate node to the left\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Update node height\n    updateHeight(node);\n    updateHeight(child);\n    // Return root node of subtree after rotation\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Left rotation operation */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // Using child as pivot, rotate node to the left\n    child.left = node\n    node.right = grandChild\n    // Update node height\n    updateHeight(node)\n    updateHeight(child)\n    // Return root node of subtree after rotation\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Left rotation ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # Using child as pivot, rotate node to the left\n  child.left = node\n  node.right = grand_child\n  # Update node height\n  update_height(node)\n  update_height(child)\n  # Return root node of subtree after rotation\n  child\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3-left-rotation-then-right-rotation","level":3,"title":"3.   Left Rotation Then Right Rotation","text":"<p>For the unbalanced node 3 in Figure 7-30, using either left rotation or right rotation alone cannot restore the subtree to balance. In this case, a \"left rotation\" needs to be performed on <code>child</code> first, followed by a \"right rotation\" on <code>node</code>.</p> <p></p> <p> Figure 7-30   Left-right rotation </p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4-right-rotation-then-left-rotation","level":3,"title":"4.   Right Rotation Then Left Rotation","text":"<p>As shown in Figure 7-31, for the mirror case of the above unbalanced binary tree, a \"right rotation\" needs to be performed on <code>child</code> first, then a \"left rotation\" on <code>node</code>.</p> <p></p> <p> Figure 7-31   Right-left rotation </p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5-choice-of-rotation","level":3,"title":"5.   Choice of Rotation","text":"<p>The four imbalances shown in Figure 7-32 correspond one-to-one with the above cases, requiring right rotation, left rotation then right rotation, right rotation then left rotation, and left rotation operations respectively.</p> <p></p> <p> Figure 7-32   The four rotation cases of AVL tree </p> <p>As shown in Table 7-3, we determine which case the unbalanced node belongs to by judging the signs of the balance factor of the unbalanced node and the balance factor of its taller-side child node.</p> <p> Table 7-3   Conditions for Choosing Among the Four Rotation Cases </p> Balance factor of the unbalanced node Balance factor of the child node Rotation method to apply \\(&gt; 1\\) (left-leaning tree) \\(\\geq 0\\) Right rotation \\(&gt; 1\\) (left-leaning tree) \\(&lt;0\\) Left rotation then right rotation \\(&lt; -1\\) (right-leaning tree) \\(\\leq 0\\) Left rotation \\(&lt; -1\\) (right-leaning tree) \\(&gt;0\\) Right rotation then left rotation <p>For ease of use, we encapsulate the rotation operations into a function. With this function, we can perform rotations for various imbalance situations, restoring balance to unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Perform rotation operation to restore balance to this subtree\"\"\"\n    # Get balance factor of node\n    balance_factor = self.balance_factor(node)\n    # Left-leaning tree\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # Right rotation\n            return self.right_rotate(node)\n        else:\n            # First left rotation then right rotation\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # Right-leaning tree\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # Left rotation\n            return self.left_rotate(node)\n        else:\n            # First right rotation then left rotation\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # Balanced tree, no rotation needed, return directly\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode *rotate(TreeNode *node) {\n    // Get balance factor of node\n    int _balanceFactor = balanceFactor(node);\n    // Left-leaning tree\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode rotate(TreeNode node) {\n    // Get balance factor of node\n    int balanceFactor = balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode? Rotate(TreeNode? node) {\n    // Get balance factor of node\n    int balanceFactorInt = BalanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // Right rotation\n            return RightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // Left rotation\n            return LeftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // Get balance factor of node\n    // Go recommends short variables, here bf refers to t.balanceFactor\n    bf := t.balanceFactor(node)\n    // Left-leaning tree\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // Right rotation\n            return t.rightRotate(node)\n        } else {\n            // First left rotation then right rotation\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // Right-leaning tree\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // Left rotation\n            return t.leftRotate(node)\n        } else {\n            // First right rotation then left rotation\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // Get balance factor of node\n    let balanceFactor = balanceFactor(node: node)\n    // Left-leaning tree\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // Right rotation\n            return rightRotate(node: node)\n        } else {\n            // First left rotation then right rotation\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // Right-leaning tree\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // Left rotation\n            return leftRotate(node: node)\n        } else {\n            // First right rotation then left rotation\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Perform rotation operation to restore balance to this subtree */\n#rotate(node) {\n    // Get balance factor of node\n    const balanceFactor = this.balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return this.#rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return this.#leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Perform rotation operation to restore balance to this subtree */\nrotate(node: TreeNode): TreeNode {\n    // Get balance factor of node\n    const balanceFactor = this.balanceFactor(node);\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return this.rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return this.leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode? rotate(TreeNode? node) {\n  // Get balance factor of node\n  int factor = balanceFactor(node);\n  // Left-leaning tree\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // Right rotation\n      return rightRotate(node);\n    } else {\n      // First left rotation then right rotation\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // Right-leaning tree\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // Left rotation\n      return leftRotate(node);\n    } else {\n      // First right rotation then left rotation\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // Balanced tree, no rotation needed, return directly\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // Get balance factor of node\n    let balance_factor = Self::balance_factor(node.clone());\n    // Left-leaning tree\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // Right rotation\n            Self::right_rotate(Some(node))\n        } else {\n            // First left rotation then right rotation\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // Right-leaning tree\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // Left rotation\n            Self::left_rotate(Some(node))\n        } else {\n            // First right rotation then left rotation\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // Balanced tree, no rotation needed, return directly\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Perform rotation operation to restore balance to this subtree */\nTreeNode *rotate(TreeNode *node) {\n    // Get balance factor of node\n    int bf = balanceFactor(node);\n    // Left-leaning tree\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node);\n        } else {\n            // First left rotation then right rotation\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Right-leaning tree\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node);\n        } else {\n            // First right rotation then left rotation\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Perform rotation operation to restore balance to this subtree */\nfun rotate(node: TreeNode): TreeNode {\n    // Get balance factor of node\n    val balanceFactor = balanceFactor(node)\n    // Left-leaning tree\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Right rotation\n            return rightRotate(node)\n        } else {\n            // First left rotation then right rotation\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // Right-leaning tree\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Left rotation\n            return leftRotate(node)\n        } else {\n            // First right rotation then left rotation\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // Balanced tree, no rotation needed, return directly\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Perform rotation to rebalance subtree ###\ndef rotate(node)\n  # Get balance factor of node\n  balance_factor = balance_factor(node)\n  # Left-heavy tree\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # Right rotation\n      return right_rotate(node)\n    else\n      # First left rotation then right rotation\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # Right-heavy tree\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # Left rotation\n      return left_rotate(node)\n    else\n      # First right rotation then left rotation\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # Balanced tree, no rotation needed, return directly\n  node\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-common-operations-in-avl-trees","level":2,"title":"7.5.3   Common Operations in Avl Trees","text":"","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1-node-insertion","level":3,"title":"1.   Node Insertion","text":"<p>The node insertion operation in AVL trees is similar in principle to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear on the path from that node to the root. Therefore, we need to start from this node and perform rotation operations from bottom to top, restoring balance to all unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"Insert node\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"Recursively insert node (helper method)\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. Find insertion position and insert node\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # Duplicate node not inserted, return directly\n        return node\n    # Update node height\n    self.update_height(node)\n    # 2. Perform rotation operation to restore balance to this subtree\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Insert node */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // Duplicate node not inserted, return directly\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Insert node */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // Duplicate node not inserted, return directly\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Insert node */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // Duplicate node not inserted, return directly\n    UpdateHeight(node);  // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = Rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Insert node */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* Recursively insert node (helper function) */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. Find insertion position and insert node */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // Duplicate node not inserted, return directly\n        return node\n    }\n    // Update node height\n    t.updateHeight(node)\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = t.rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Insert node */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* Recursively insert node (helper method) */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. Find insertion position and insert node */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // Duplicate node not inserted, return directly\n    }\n    updateHeight(node: node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node: node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Insert node */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* Recursively insert node (helper method) */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // Duplicate node not inserted, return directly\n    this.#updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.#rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Insert node */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* Recursively insert node (helper method) */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // Duplicate node not inserted, return directly\n    }\n    this.updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Insert node */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* Recursively insert node (helper method) */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. Find insertion position and insert node */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // Duplicate node not inserted, return directly\n  updateHeight(node); // Update node height\n  /* 2. Perform rotation operation to restore balance to this subtree */\n  node = rotate(node);\n  // Return root node of subtree\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Insert node */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* Recursively insert node (helper method) */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Find insertion position and insert node */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // Duplicate node not inserted, return directly\n                }\n            }\n            Self::update_height(Some(node.clone())); // Update node height\n\n            /* 2. Perform rotation operation to restore balance to this subtree */\n            node = Self::rotate(Some(node)).unwrap();\n            // Return root node of subtree\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Insert node */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* Recursively insert node (helper function) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. Find insertion position and insert node */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // Duplicate node not inserted, return directly\n        return node;\n    }\n    // Update node height\n    updateHeight(node);\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Insert node */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* Recursively insert node (helper method) */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. Find insertion position and insert node */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // Duplicate node not inserted, return directly\n    updateHeight(node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Insert node ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### Recursively insert node (helper method) ###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. Find insertion position and insert node\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # Duplicate node not inserted, return directly\n    return node\n  end\n  # Update node height\n  update_height(node)\n  # 2. Perform rotation operation to restore balance to this subtree\n  rotate(node)\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-node-removal","level":3,"title":"2.   Node Removal","text":"<p>Similarly, on the basis of the binary search tree's node removal method, rotation operations need to be performed from bottom to top to restore balance to all unbalanced nodes. The code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"Delete node\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"Recursively delete node (helper method)\"\"\"\n    if node is None:\n        return None\n    # 1. Find node and delete\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # Number of child nodes = 0, delete node directly and return\n            if child is None:\n                return None\n            # Number of child nodes = 1, delete node directly\n            else:\n                node = child\n        else:\n            # Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # Update node height\n    self.update_height(node)\n    # 2. Perform rotation operation to restore balance to this subtree\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Remove node */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. Find node and delete */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // Number of child nodes = 1, delete node directly\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Remove node */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null;\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Remove node */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null;\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = Rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Remove node */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* Recursively remove node (helper function) */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. Find node and delete */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // Number of child nodes = 0, delete node directly and return\n                return nil\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // Update node height\n    t.updateHeight(node)\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = t.rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Remove node */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* Recursively delete node (helper method) */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. Find node and delete */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // Number of child nodes = 0, delete node directly and return\n            if child == nil {\n                return nil\n            }\n            // Number of child nodes = 1, delete node directly\n            else {\n                node = child\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node: node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Remove node */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* Recursively delete node (helper method) */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child === null) return null;\n            // Number of child nodes = 1, delete node directly\n            else node = child;\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.#rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Remove node */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* Recursively delete node (helper method) */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. Find node and delete */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Number of child nodes = 0, delete node directly and return\n            if (child === null) {\n                return null;\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = this.rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Remove node */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* Recursively delete node (helper method) */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. Find node and delete */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // Number of child nodes = 0, delete node directly and return\n      if (child == null)\n        return null;\n      // Number of child nodes = 1, delete node directly\n      else\n        node = child;\n    } else {\n      // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // Update node height\n  /* 2. Perform rotation operation to restore balance to this subtree */\n  node = rotate(node);\n  // Return root node of subtree\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Remove node */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* Recursively delete node (helper method) */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Find node and delete */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // Number of child nodes = 0, delete node directly and return\n                    None =&gt; {\n                        return None;\n                    }\n                    // Number of child nodes = 1, delete node directly\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // Update node height\n\n            /* 2. Perform rotation operation to restore balance to this subtree */\n            node = Self::rotate(Some(node)).unwrap();\n            // Return root node of subtree\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Remove node */\n// Cannot use remove keyword here due to stdio.h inclusion\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* Recursively remove node (helper function) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. Find node and delete */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // Number of child nodes = 0, delete node directly and return\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // Number of child nodes = 1, delete node directly\n                node = child;\n            }\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // Update node height\n    updateHeight(node);\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node);\n    // Return root node of subtree\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Remove node */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* Recursively delete node (helper method) */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. Find node and delete */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // Number of child nodes = 0, delete node directly and return\n            if (child == null)\n                return null\n            // Number of child nodes = 1, delete node directly\n            else\n                node = child\n        } else {\n            // Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // Update node height\n    /* 2. Perform rotation operation to restore balance to this subtree */\n    node = rotate(node)\n    // Return root node of subtree\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Delete node ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### Recursively delete node (helper method) ###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. Find node and delete\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # Number of child nodes = 0, delete node directly and return\n      return if child.nil?\n      # Number of child nodes = 1, delete node directly\n      node = child\n    else\n      # Number of child nodes = 2, delete the next node in inorder traversal and replace current node with it\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # Update node height\n  update_height(node)\n  # 2. Perform rotation operation to restore balance to this subtree\n  rotate(node)\nend\n</code></pre>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3-node-search","level":3,"title":"3.   Node Search","text":"<p>The node search operation in AVL trees is consistent with that in binary search trees, and will not be elaborated here.</p>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-typical-applications-of-avl-trees","level":2,"title":"7.5.4   Typical Applications of Avl Trees","text":"<ul> <li>Organizing and storing large-scale data, suitable for scenarios with high-frequency searches and low-frequency insertions and deletions.</li> <li>Used to build index systems in databases.</li> <li>Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balance conditions, require fewer rotation operations for node insertion and deletion, and have higher average efficiency for node addition and deletion operations.</li> </ul>","path":["Chapter 7. Tree","7.5 &nbsp; Avl Tree *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   Binary Search Tree","text":"<p>As shown in Figure 7-16, a binary search tree satisfies the following conditions.</p> <ol> <li>For the root node, the value of all nodes in the left subtree \\(&lt;\\) the value of the root node \\(&lt;\\) the value of all nodes in the right subtree.</li> <li>The left and right subtrees of any node are also binary search trees, i.e., they satisfy condition <code>1.</code> as well.</li> </ol> <p></p> <p> Figure 7-16   Binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741-operations-on-a-binary-search-tree","level":2,"title":"7.4.1   Operations on a Binary Search Tree","text":"<p>We encapsulate the binary search tree as a class <code>BinarySearchTree</code> and declare a member variable <code>root</code> pointing to the tree's root node.</p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1-searching-for-a-node","level":3,"title":"1.   Searching for a Node","text":"<p>Given a target node value <code>num</code>, we can search according to the properties of the binary search tree. As shown in Figure 7-17, we declare a node <code>cur</code> and start from the binary tree's root node <code>root</code>, looping to compare the node value <code>cur.val</code> with <code>num</code>.</p> <ul> <li>If <code>cur.val &lt; num</code>, it means the target node is in <code>cur</code>'s right subtree, thus execute <code>cur = cur.right</code>.</li> <li>If <code>cur.val &gt; num</code>, it means the target node is in <code>cur</code>'s left subtree, thus execute <code>cur = cur.left</code>.</li> <li>If <code>cur.val = num</code>, it means the target node is found, exit the loop, and return the node.</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-17   Example of searching for a node in a binary search tree </p> <p>The search operation in a binary search tree works on the same principle as the binary search algorithm, both eliminating half of the cases in each round. The number of loop iterations is at most the height of the binary tree. When the binary tree is balanced, it uses \\(O(\\log n)\\) time. The example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"Search node\"\"\"\n    cur = self._root\n    # Loop search, exit after passing leaf node\n    while cur is not None:\n        # Target node is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Target node is in cur's left subtree\n        elif cur.val &gt; num:\n            cur = cur.left\n        # Found target node, exit loop\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* Search node */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Target node is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Target node is in cur's left subtree\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Search node */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Search node */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Found target node, exit loop\n        else\n            break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* Search node */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // Loop search, exit after passing leaf node\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // Target node is in cur's right subtree\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // Target node is in cur's left subtree\n            node = node.Left\n        } else {\n            // Found target node, exit loop\n            break\n        }\n    }\n    // Return target node\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Search node */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Target node is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Target node is in cur's left subtree\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // Found target node, exit loop\n        else {\n            break\n        }\n    }\n    // Return target node\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* Search node */\nsearch(num) {\n    let cur = this.root;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num) cur = cur.left;\n        // Found target node, exit loop\n        else break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Search node */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Target node is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Target node is in cur's left subtree\n        else if (cur.val &gt; num) cur = cur.left;\n        // Found target node, exit loop\n        else break;\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Search node */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Target node is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Target node is in cur's left subtree\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // Found target node, exit loop\n    else\n      break;\n  }\n  // Return target node\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Search node */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Target node is in cur's right subtree\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // Target node is in cur's left subtree\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // Found target node, exit loop\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // Return target node\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* Search node */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // Target node is in cur's right subtree\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // Target node is in cur's left subtree\n            cur = cur-&gt;left;\n        } else {\n            // Found target node, exit loop\n            break;\n        }\n    }\n    // Return target node\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Search node */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Target node is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Target node is in cur's left subtree\n        else if (cur._val &gt; num)\n            cur.left\n        // Found target node, exit loop\n        else\n            break\n    }\n    // Return target node\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### Search node ###\ndef search(num)\n  cur = @root\n\n  # Loop search, exit after passing leaf node\n  while !cur.nil?\n    # Target node is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Target node is in cur's left subtree\n    elsif cur.val &gt; num\n      cur = cur.left\n    # Found target node, exit loop\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2-inserting-a-node","level":3,"title":"2.   Inserting a Node","text":"<p>Given an element <code>num</code> to be inserted, in order to maintain the property of the binary search tree \"left subtree &lt; root node &lt; right subtree,\" the insertion process is as shown in Figure 7-18.</p> <ol> <li>Finding the insertion position: Similar to the search operation, start from the root node and loop downward searching according to the size relationship between the current node value and <code>num</code>, until passing the leaf node (traversing to <code>None</code>) and then exit the loop.</li> <li>Insert the node at that position: Initialize node <code>num</code> and place it at the <code>None</code> position.</li> </ol> <p></p> <p> Figure 7-18   Inserting a node into a binary search tree </p> <p>In the code implementation, note the following two points:</p> <ul> <li>Binary search trees do not allow duplicate nodes; otherwise, it would violate its definition. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed and it returns directly.</li> <li>To implement the node insertion, we need to use node <code>pre</code> to save the node from the previous loop iteration. This way, when traversing to <code>None</code>, we can obtain its parent node, thereby completing the node insertion operation.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"Insert node\"\"\"\n    # If tree is empty, initialize root node\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # Loop search, exit after passing leaf node\n    cur, pre = self._root, None\n    while cur is not None:\n        # Found duplicate node, return directly\n        if cur.val == num:\n            return\n        pre = cur\n        # Insertion position is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Insertion position is in cur's left subtree\n        else:\n            cur = cur.left\n    # Insert node\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* Insert node */\nvoid insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Found duplicate node, return directly\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur-&gt;left;\n    }\n    // Insert node\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Insert node */\nvoid insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // Insert node\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Insert node */\nvoid Insert(int num) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n\n    // Insert node\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Insert node */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // If tree is empty, initialize root node\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // Node position before the node to be inserted\n    var pre *TreeNode = nil\n    // Loop search, exit after passing leaf node\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // Insert node\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Insert node */\nfunc insert(num: Int) {\n    // If tree is empty, initialize root node\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Found duplicate node, return directly\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // Insertion position is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Insertion position is in cur's left subtree\n        else {\n            cur = cur?.left\n        }\n    }\n    // Insert node\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Insert node */\ninsert(num) {\n    // If tree is empty, initialize root node\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found duplicate node, return directly\n        if (cur.val === num) return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else cur = cur.left;\n    }\n    // Insert node\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Insert node */\ninsert(num: number): void {\n    // If tree is empty, initialize root node\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found duplicate node, return directly\n        if (cur.val === num) return;\n        pre = cur;\n        // Insertion position is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Insertion position is in cur's left subtree\n        else cur = cur.left;\n    }\n    // Insert node\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Insert node */\nvoid insert(int _num) {\n  // If tree is empty, initialize root node\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Found duplicate node, return directly\n    if (cur.val == _num) return;\n    pre = cur;\n    // Insertion position is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Insertion position is in cur's left subtree\n    else\n      cur = cur.left;\n  }\n  // Insert node\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Insert node */\npub fn insert(&amp;mut self, num: i32) {\n    // If tree is empty, initialize root node\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Found duplicate node, return directly\n            Ordering::Equal =&gt; return,\n            // Insertion position is in cur's right subtree\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Insertion position is in cur's left subtree\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Insert node\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Insert node */\nvoid insert(BinarySearchTree *bst, int num) {\n    // If tree is empty, initialize root node\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        // Found duplicate node, return directly\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Insertion position is in cur's right subtree\n            cur = cur-&gt;right;\n        } else {\n            // Insertion position is in cur's left subtree\n            cur = cur-&gt;left;\n        }\n    }\n    // Insert node\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Insert node */\nfun insert(num: Int) {\n    // If tree is empty, initialize root node\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found duplicate node, return directly\n        if (cur._val == num)\n            return\n        pre = cur\n        // Insertion position is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Insertion position is in cur's left subtree\n        else\n            cur.left\n    }\n    // Insert node\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### Insert node ###\ndef insert(num)\n  # If tree is empty, initialize root node\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # Loop search, exit after passing leaf node\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Found duplicate node, return directly\n    return if cur.val == num\n\n    pre = cur\n    # Insertion position is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Insertion position is in cur's left subtree\n    else\n      cur = cur.left\n    end\n  end\n\n  # Insert node\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> <p>Similar to searching for a node, inserting a node uses \\(O(\\log n)\\) time.</p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3-removing-a-node","level":3,"title":"3.   Removing a Node","text":"<p>First, find the target node in the binary tree, then remove it. Similar to node insertion, we need to ensure that after the removal operation is completed, the binary search tree's property of \"left subtree \\(&lt;\\) root node \\(&lt;\\) right subtree\" is still maintained. Therefore, depending on the number of child nodes the target node has, we divide it into 0, 1, and 2 three cases, and execute the corresponding node removal operations.</p> <p>As shown in Figure 7-19, when the degree of the node to be removed is \\(0\\), it means the node is a leaf node and can be directly removed.</p> <p></p> <p> Figure 7-19   Removing a node in a binary search tree (degree 0) </p> <p>As shown in Figure 7-20, when the degree of the node to be removed is \\(1\\), replacing the node to be removed with its child node is sufficient.</p> <p></p> <p> Figure 7-20   Removing a node in a binary search tree (degree 1) </p> <p>When the degree of the node to be removed is \\(2\\), we cannot directly remove it; instead, we need to use a node to replace it. To maintain the binary search tree's property of \"left subtree \\(&lt;\\) root node \\(&lt;\\) right subtree,\" this node can be either the smallest node in the right subtree or the largest node in the left subtree.</p> <p>Assuming we choose the smallest node in the right subtree (the next node in the inorder traversal), the removal process is as shown in Figure 7-21.</p> <ol> <li>Find the next node of the node to be removed in the \"inorder traversal sequence,\" denoted as <code>tmp</code>.</li> <li>Replace the value of the node to be removed with the value of <code>tmp</code>, and recursively remove node <code>tmp</code> in the tree.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Figure 7-21   Removing a node in a binary search tree (degree 2) </p> <p>The node removal operation also uses \\(O(\\log n)\\) time, where finding the node to be removed requires \\(O(\\log n)\\) time, and obtaining the inorder successor node requires \\(O(\\log n)\\) time. Example code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"Delete node\"\"\"\n    # If tree is empty, return directly\n    if self._root is None:\n        return\n    # Loop search, exit after passing leaf node\n    cur, pre = self._root, None\n    while cur is not None:\n        # Found node to delete, exit loop\n        if cur.val == num:\n            break\n        pre = cur\n        # Node to delete is in cur's right subtree\n        if cur.val &lt; num:\n            cur = cur.right\n        # Node to delete is in cur's left subtree\n        else:\n            cur = cur.left\n    # If no node to delete, return directly\n    if cur is None:\n        return\n\n    # Number of child nodes = 0 or 1\n    if cur.left is None or cur.right is None:\n        # When number of child nodes = 0 / 1, child = null / that child node\n        child = cur.left or cur.right\n        # Delete node cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # If deleted node is root node, reassign root node\n            self._root = child\n    # Number of child nodes = 2\n    else:\n        # Get next node of cur in inorder traversal\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # Recursively delete node tmp\n        self.remove(tmp.val)\n        # Replace cur with tmp\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* Remove node */\nvoid remove(int num) {\n    // If tree is empty, return directly\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // Loop search, exit after passing leaf node\n    while (cur != nullptr) {\n        // Found node to delete, exit loop\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur-&gt;left;\n    }\n    // If no node to delete, return directly\n    if (cur == nullptr)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // When number of child nodes = 0 / 1, child = nullptr / that child node\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n        // Free memory\n        delete cur;\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Recursively delete node tmp\n        remove(tmp-&gt;val);\n        // Replace cur with tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* Remove node */\nvoid remove(int num) {\n    // If tree is empty, return directly\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        remove(tmp.val);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Remove node */\nvoid Remove(int num) {\n    // If tree is empty, return directly\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else\n            cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return;\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        TreeNode? child = cur.left ?? cur.right;\n        // Delete node cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        Remove(tmp.val!.Value);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Remove node */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // If tree is empty, return directly\n    if cur == nil {\n        return\n    }\n    // Node position before the node to be removed\n    var pre *TreeNode = nil\n    // Loop search, exit after passing leaf node\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // Node to be removed is in right subtree\n            cur = cur.Right\n        } else {\n            // Node to be removed is in left subtree\n            cur = cur.Left\n        }\n    }\n    // If no node to delete, return directly\n    if cur == nil {\n        return\n    }\n    // Number of child nodes is 0 or 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // Get child node of node to be removed\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // Delete node cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // If deleted node is root node, reassign root node\n            bst.root = child\n        }\n        // Number of child nodes is 2\n    } else {\n        // Get next node of node cur to be removed in in-order traversal\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // Recursively delete node tmp\n        bst.remove(tmp.Val.(int))\n        // Replace cur with tmp\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Remove node */\nfunc remove(num: Int) {\n    // If tree is empty, return directly\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Loop search, exit after passing leaf node\n    while cur != nil {\n        // Found node to delete, exit loop\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // Node to delete is in cur's right subtree\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Node to delete is in cur's left subtree\n        else {\n            cur = cur?.left\n        }\n    }\n    // If no node to delete, return directly\n    if cur == nil {\n        return\n    }\n    // Number of child nodes = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        let child = cur?.left ?? cur?.right\n        // Delete node cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // Recursively delete node tmp\n        remove(num: tmp!.val)\n        // Replace cur with tmp\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Remove node */\nremove(num) {\n    // If tree is empty, return directly\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found node to delete, exit loop\n        if (cur.val === num) break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur === null) return;\n    // Number of child nodes = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        const child = cur.left !== null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            this.root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // Recursively delete node tmp\n        this.remove(tmp.val);\n        // Replace cur with tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Remove node */\nremove(num: number): void {\n    // If tree is empty, return directly\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Loop search, exit after passing leaf node\n    while (cur !== null) {\n        // Found node to delete, exit loop\n        if (cur.val === num) break;\n        pre = cur;\n        // Node to delete is in cur's right subtree\n        if (cur.val &lt; num) cur = cur.right;\n        // Node to delete is in cur's left subtree\n        else cur = cur.left;\n    }\n    // If no node to delete, return directly\n    if (cur === null) return;\n    // Number of child nodes = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // Delete node cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // If deleted node is root node, reassign root node\n            this.root = child;\n        }\n    }\n    // Number of child nodes = 2\n    else {\n        // Get next node of cur in inorder traversal\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // Recursively delete node tmp\n        this.remove(tmp!.val);\n        // Replace cur with tmp\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Remove node */\nvoid remove(int _num) {\n  // If tree is empty, return directly\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Loop search, exit after passing leaf node\n  while (cur != null) {\n    // Found node to delete, exit loop\n    if (cur.val == _num) break;\n    pre = cur;\n    // Node to delete is in cur's right subtree\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Node to delete is in cur's left subtree\n    else\n      cur = cur.left;\n  }\n  // If no node to delete, return directly\n  if (cur == null) return;\n  // Number of child nodes = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // When number of child nodes = 0 / 1, child = null / that child node\n    TreeNode? child = cur.left ?? cur.right;\n    // Delete node cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // If deleted node is root node, reassign root node\n      _root = child;\n    }\n  } else {\n    // Number of child nodes = 2\n    // Get next node of cur in inorder traversal\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // Recursively delete node tmp\n    remove(tmp.val);\n    // Replace cur with tmp\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Remove node */\npub fn remove(&amp;mut self, num: i32) {\n    // If tree is empty, return directly\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Loop search, exit after passing leaf node\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Found node to delete, exit loop\n            Ordering::Equal =&gt; break,\n            // Node to delete is in cur's right subtree\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Node to delete is in cur's left subtree\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // If no node to delete, return directly\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // Number of child nodes = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // When number of child nodes = 0 / 1, child = nullptr / that child node\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // Delete node cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // If deleted node is root node, reassign root node\n                self.root = child;\n            }\n        }\n        // Number of child nodes = 2\n        (Some(_), Some(_)) =&gt; {\n            // Get next node of cur in inorder traversal\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // Recursively delete node tmp\n            self.remove(tmp_val);\n            // Replace cur with tmp\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Remove node */\n// Cannot use remove keyword here due to stdio.h inclusion\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // If tree is empty, return directly\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Loop search, exit after passing leaf node\n    while (cur != NULL) {\n        // Found node to delete, exit loop\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Node to delete is in right subtree of root\n            cur = cur-&gt;right;\n        } else {\n            // Node to delete is in left subtree of root\n            cur = cur-&gt;left;\n        }\n    }\n    // If no node to delete, return directly\n    if (cur == NULL)\n        return;\n    // Check if node to delete has children\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* Number of child nodes = 0 or 1 */\n        // When number of child nodes = 0 / 1, child = nullptr / that child node\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // Delete node cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // Free memory\n        free(cur);\n    } else {\n        /* Number of child nodes = 2 */\n        // Get next node of cur in inorder traversal\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Recursively delete node tmp\n        removeItem(bst, tmp-&gt;val);\n        // Replace cur with tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Remove node */\nfun remove(num: Int) {\n    // If tree is empty, return directly\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // Loop search, exit after passing leaf node\n    while (cur != null) {\n        // Found node to delete, exit loop\n        if (cur._val == num)\n            break\n        pre = cur\n        // Node to delete is in cur's right subtree\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Node to delete is in cur's left subtree\n        else\n            cur.left\n    }\n    // If no node to delete, return directly\n    if (cur == null)\n        return\n    // Number of child nodes = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // When number of child nodes = 0 / 1, child = null / that child node\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // Delete node cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // If deleted node is root node, reassign root node\n            root = child\n        }\n        // Number of child nodes = 2\n    } else {\n        // Get next node of cur in inorder traversal\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // Recursively delete node tmp\n        remove(tmp._val)\n        // Replace cur with tmp\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### Delete node ###\ndef remove(num)\n  # If tree is empty, return directly\n  return if @root.nil?\n\n  # Loop search, exit after passing leaf node\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Found node to delete, exit loop\n    break if cur.val == num\n\n    pre = cur\n    # Node to delete is in cur's right subtree\n    if cur.val &lt; num\n      cur = cur.right\n    # Node to delete is in cur's left subtree\n    else\n      cur = cur.left\n    end\n  end\n  # If no node to delete, return directly\n  return if cur.nil?\n\n  # Number of child nodes = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # When number of child nodes = 0 / 1, child = null / that child node\n    child = cur.left || cur.right\n    # Delete node cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # If deleted node is root node, reassign root node\n      @root = child\n    end\n  # Number of child nodes = 2\n  else\n    # Get next node of cur in inorder traversal\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # Recursively delete node tmp\n    remove(tmp.val)\n    # Replace cur with tmp\n    cur.val = tmp.val\n  end\nend\n</code></pre>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4-inorder-traversal-is-ordered","level":3,"title":"4.   Inorder Traversal Is Ordered","text":"<p>As shown in Figure 7-22, the inorder traversal of a binary tree follows the \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\" traversal order, while the binary search tree satisfies the \"left child node \\(&lt;\\) root node \\(&lt;\\) right child node\" size relationship.</p> <p>This means that when performing an inorder traversal in a binary search tree, the next smallest node is always traversed first, thus yielding an important property: The inorder traversal sequence of a binary search tree is ascending.</p> <p>Using the property of inorder traversal being ascending, we can obtain ordered data in a binary search tree in only \\(O(n)\\) time, without the need for additional sorting operations, which is very efficient.</p> <p></p> <p> Figure 7-22   Inorder traversal sequence of a binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742-efficiency-of-binary-search-trees","level":2,"title":"7.4.2   Efficiency of Binary Search Trees","text":"<p>Given a set of data, we consider using an array or a binary search tree for storage. Observing Table 7-2, all operations in a binary search tree have logarithmic time complexity, providing stable and efficient performance. Arrays are more efficient than binary search trees only in scenarios with high-frequency additions and low-frequency searches and deletions.</p> <p> Table 7-2   Efficiency comparison between arrays and search trees </p> Unsorted array Binary search tree Search element \\(O(n)\\) \\(O(\\log n)\\) Insert element \\(O(1)\\) \\(O(\\log n)\\) Remove element \\(O(n)\\) \\(O(\\log n)\\) <p>In the ideal case, a binary search tree is \"balanced,\" such that any node can be found within \\(\\log n\\) loop iterations.</p> <p>However, if we continuously insert and remove nodes in a binary search tree, it may degenerate into a linked list as shown in Figure 7-23, where the time complexity of various operations also degrades to \\(O(n)\\).</p> <p></p> <p> Figure 7-23   Degradation of a binary search tree </p>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743-common-applications-of-binary-search-trees","level":2,"title":"7.4.3   Common Applications of Binary Search Trees","text":"<ul> <li>Used as multi-level indexes in systems to implement efficient search, insertion, and removal operations.</li> <li>Serves as the underlying data structure for certain search algorithms.</li> <li>Used to store data streams to maintain their ordered state.</li> </ul>","path":["Chapter 7. Tree","7.4 &nbsp; Binary Search Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   Binary Tree","text":"<p>A binary tree is a non-linear data structure that represents the derivation relationship between \"ancestors\" and \"descendants\" and embodies the divide-and-conquer logic of \"one divides into two\". Similar to a linked list, the basic unit of a binary tree is a node, and each node contains a value, a reference to its left child node, and a reference to its right child node.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Binary tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.left: TreeNode | None = None  # Reference to left child node\n        self.right: TreeNode | None = None # Reference to right child node\n</code></pre> <pre><code>/* Binary tree node */\nstruct TreeNode {\n    int val;          // Node value\n    TreeNode *left;   // Pointer to left child node\n    TreeNode *right;  // Pointer to right child node\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    int val;         // Node value\n    TreeNode left;   // Reference to left child node\n    TreeNode right;  // Reference to right child node\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public TreeNode? left;  // Reference to left child node\n    public TreeNode? right; // Reference to right child node\n}\n</code></pre> <pre><code>/* Binary tree node */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* Constructor */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // Pointer to left child node\n        Right: nil, // Pointer to right child node\n        Val:   v,   // Node value\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var left: TreeNode? // Reference to left child node\n    var right: TreeNode? // Reference to right child node\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    val; // Node value\n    left; // Pointer to left child node\n    right; // Pointer to right child node\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.left = left === undefined ? null : left; // Reference to left child node\n        this.right = right === undefined ? null : right; // Reference to right child node\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode {\n  int val;         // Node value\n  TreeNode? left;  // Reference to left child node\n  TreeNode? right; // Reference to right child node\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Binary tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Reference to left child node\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Reference to right child node\n}\n\nimpl TreeNode {\n    /* Constructor */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Binary tree node */\ntypedef struct TreeNode {\n    int val;                // Node value\n    int height;             // Node height\n    struct TreeNode *left;  // Pointer to left child node\n    struct TreeNode *right; // Pointer to right child node\n} TreeNode;\n\n/* Constructor */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Binary tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val left: TreeNode? = null   // Reference to left child node\n    val right: TreeNode? = null  // Reference to right child node\n}\n</code></pre> <pre><code>### Binary tree node class ###\nclass TreeNode\n  attr_accessor :val    # Node value\n  attr_accessor :left   # Reference to left child node\n  attr_accessor :right  # Reference to right child node\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>Each node has two references (pointers), pointing respectively to the left-child node and right-child node. This node is called the parent node of these two child nodes. When given a node of a binary tree, we call the tree formed by this node's left child and all nodes below it the left subtree of this node. Similarly, the right subtree can be defined.</p> <p>In a binary tree, except leaf nodes, all other nodes contain child nodes and non-empty subtrees. As shown in Figure 7-1, if \"Node 2\" is regarded as a parent node, its left and right child nodes are \"Node 4\" and \"Node 5\" respectively. The left subtree is formed by \"Node 4\" and all nodes beneath it, while the right subtree is formed by \"Node 5\" and all nodes beneath it.</p> <p></p> <p> Figure 7-1   Parent Node, child Node, subtree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#711-common-terminology-of-binary-trees","level":2,"title":"7.1.1   Common Terminology of Binary Trees","text":"<p>The commonly used terminology of binary trees is shown in Figure 7-2.</p> <ul> <li>Root node: The node at the top level of a binary tree, which does not have a parent node.</li> <li>Leaf node: A node that does not have any child nodes, with both of its pointers pointing to <code>None</code>.</li> <li>Edge: A line segment that connects two nodes, representing a reference (pointer) between the nodes.</li> <li>The level of a node: It increases from top to bottom, with the root node being at level 1.</li> <li>The degree of a node: The number of child nodes that a node has. In a binary tree, the degree can be 0, 1, or 2.</li> <li>The height of a binary tree: The number of edges from the root node to the farthest leaf node.</li> <li>The depth of a node: The number of edges from the root node to the node.</li> <li>The height of a node: The number of edges from the farthest leaf node to the node.</li> </ul> <p></p> <p> Figure 7-2   Common Terminology of Binary Trees </p> <p>Tip</p> <p>Please note that we usually define \"height\" and \"depth\" as \"the number of edges traversed\", but some questions or textbooks may define them as \"the number of nodes traversed\". In this case, both height and depth need to be incremented by 1.</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#712-basic-operations-of-binary-trees","level":2,"title":"7.1.2   Basic Operations of Binary Trees","text":"","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#1-initializing-a-binary-tree","level":3,"title":"1.   Initializing a Binary Tree","text":"<p>Similar to a linked list, the initialization of a binary tree involves first creating the nodes and then establishing the references (pointers) between them.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Initializing a binary tree\n# Initializing nodes\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// Initializing nodes\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// Linking references (pointers) between nodes\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// Initializing nodes\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// Initializing nodes\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// Linking references (pointers) between nodes\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* Initializing a binary tree */\n// Initializing nodes\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// Linking references (pointers) between nodes\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// Initializing nodes\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># Initializing a binary tree\n# Initializing nodes\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> Code Visualization <p> Full Screen &gt;</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#2-inserting-and-removing-nodes","level":3,"title":"2.   Inserting and Removing Nodes","text":"<p>Similar to a linked list, inserting and removing nodes in a binary tree can be achieved by modifying pointers. Figure 7-3 provides an example.</p> <p></p> <p> Figure 7-3   Inserting and removing nodes in a binary tree </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Inserting and removing nodes\np = TreeNode(0)\n# Inserting node P between n1 -&gt; n2\nn1.left = p\np.left = n2\n# Removing node P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* Inserting and removing nodes */\nTreeNode* P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Removing node P\nn1-&gt;left = n2;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* Inserting and removing nodes */\nTreeNode P = new(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* Inserting and removing nodes */\n// Inserting node P between n1 and n2\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// Removing node P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* Inserting and removing nodes */\nlet P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* Inserting and removing nodes */\nconst P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* Inserting and removing nodes */\nTreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// Inserting node P between n1 and n2\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// Removing node P\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* Inserting and removing nodes */\nTreeNode *P = newTreeNode(0);\n// Inserting node P between n1 and n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Removing node P\nn1-&gt;left = n2;\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># Inserting and removing nodes\n_p = TreeNode.new(0)\n# Inserting node _p between n1 and n2\nn1.left = _p\n_p.left = n2\n# Removing node _p\nn1.left = n2\n</code></pre> Code Visualization <p> Full Screen &gt;</p> <p>Tip</p> <p>It should be noted that inserting nodes may change the original logical structure of the binary tree, while removing nodes typically involves removing the node and all its subtrees. Therefore, in a binary tree, insertion and removal are usually performed through a set of operations to achieve meaningful outcomes.</p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#713-common-types-of-binary-trees","level":2,"title":"7.1.3   Common Types of Binary Trees","text":"","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#1-perfect-binary-tree","level":3,"title":"1.   Perfect Binary Tree","text":"<p>As shown in Figure 7-4, a perfect binary tree has all levels completely filled with nodes. In a perfect binary tree, leaf nodes have a degree of \\(0\\), while all other nodes have a degree of \\(2\\). If the tree height is \\(h\\), the total number of nodes is \\(2^{h+1} - 1\\), exhibiting a standard exponential relationship that reflects the common phenomenon of cell division in nature.</p> <p>Tip</p> <p>Please note that in the Chinese community, a perfect binary tree is often referred to as a full binary tree.</p> <p></p> <p> Figure 7-4   Perfect binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#2-complete-binary-tree","level":3,"title":"2.   Complete Binary Tree","text":"<p>As shown in Figure 7-5, a complete binary tree only allows the bottom level to be incompletely filled, and the nodes at the bottom level must be filled continuously from left to right. Note that a perfect binary tree is also a complete binary tree.</p> <p></p> <p> Figure 7-5   Complete binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#3-full-binary-tree","level":3,"title":"3.   Full Binary Tree","text":"<p>As shown in Figure 7-6, in a full binary tree, all nodes except leaf nodes have two child nodes.</p> <p></p> <p> Figure 7-6   Full binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#4-balanced-binary-tree","level":3,"title":"4.   Balanced Binary Tree","text":"<p>As shown in Figure 7-7, in a balanced binary tree, the absolute difference between the height of the left and right subtrees of any node does not exceed 1.</p> <p></p> <p> Figure 7-7   Balanced binary tree </p>","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree/#714-degeneration-of-binary-trees","level":2,"title":"7.1.4   Degeneration of Binary Trees","text":"<p>Figure 7-8 shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the \"perfect binary tree\" state; when all nodes are biased toward one side, the binary tree degenerates into a \"linked list\".</p> <ul> <li>A perfect binary tree is the ideal case, fully leveraging the \"divide and conquer\" advantage of binary trees.</li> <li>A linked list represents the other extreme, where all operations become linear operations with time complexity degrading to \\(O(n)\\).</li> </ul> <p></p> <p> Figure 7-8   The Best and Worst Structures of Binary Trees </p> <p>As shown in Table 7-1, in the best and worst structures, the binary tree achieves either maximum or minimum values for leaf node count, total number of nodes, and height.</p> <p> Table 7-1   The Best and Worst Structures of Binary Trees </p> Perfect binary tree Linked list Number of nodes at level \\(i\\) \\(2^{i-1}\\) \\(1\\) Number of leaf nodes in a tree with height \\(h\\) \\(2^h\\) \\(1\\) Total number of nodes in a tree with height \\(h\\) \\(2^{h+1} - 1\\) \\(h + 1\\) Height of a tree with \\(n\\) total nodes \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["Chapter 7. Tree","7.1 &nbsp; Binary Tree"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   Binary Tree Traversal","text":"<p>From a physical structure perspective, a tree is a data structure based on linked lists. Hence, its traversal method involves accessing nodes one by one through pointers. However, a tree is a non-linear data structure, which makes traversing a tree more complex than traversing a linked list, requiring the assistance of search algorithms.</p> <p>The common traversal methods for binary trees include level-order traversal, pre-order traversal, in-order traversal, and post-order traversal.</p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721-level-order-traversal","level":2,"title":"7.2.1   Level-Order Traversal","text":"<p>As shown in Figure 7-9, level-order traversal traverses the binary tree from top to bottom, layer by layer. Within each level, it visits nodes from left to right.</p> <p>Level-order traversal is essentially breadth-first traversal, also known as breadth-first search (BFS), which embodies a \"expanding outward circle by circle\" layer-by-layer traversal method.</p> <p></p> <p> Figure 7-9   Level-order traversal of a binary tree </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation","level":3,"title":"1.   Code Implementation","text":"<p>Breadth-first traversal is typically implemented with the help of a \"queue\". The queue follows the \"first in, first out\" rule, while breadth-first traversal follows the \"layer-by-layer progression\" rule; the underlying ideas of the two are consistent. The implementation code is as follows:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"Level-order traversal\"\"\"\n    # Initialize queue, add root node\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # Initialize a list to save the traversal sequence\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # Dequeue\n        res.append(node.val)  # Save node value\n        if node.left is not None:\n            queue.append(node.left)  # Left child node enqueue\n        if node.right is not None:\n            queue.append(node.right)  # Right child node enqueue\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* Level-order traversal */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // Initialize queue, add root node\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // Initialize a list to save the traversal sequence\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // Dequeue\n        vec.push_back(node-&gt;val); // Save node value\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // Left child node enqueue\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // Right child node enqueue\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* Level-order traversal */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // Initialize queue, add root node\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // Initialize a list to save the traversal sequence\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // Dequeue\n        list.add(node.val);           // Save node value\n        if (node.left != null)\n            queue.offer(node.left);   // Left child node enqueue\n        if (node.right != null)\n            queue.offer(node.right);  // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* Level-order traversal */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // Initialize queue, add root node\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // Initialize a list to save the traversal sequence\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // Dequeue\n        list.Add(node.val!.Value);       // Save node value\n        if (node.left != null)\n            queue.Enqueue(node.left);    // Left child node enqueue\n        if (node.right != null)\n            queue.Enqueue(node.right);   // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* Level-order traversal */\nfunc levelOrder(root *TreeNode) []any {\n    // Initialize queue, add root node\n    queue := list.New()\n    queue.PushBack(root)\n    // Initialize a slice to save traversal sequence\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // Dequeue\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // Save node value\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // Left child node enqueue\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // Right child node enqueue\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* Level-order traversal */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // Initialize queue, add root node\n    var queue: [TreeNode] = [root]\n    // Initialize a list to save the traversal sequence\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // Dequeue\n        list.append(node.val) // Save node value\n        if let left = node.left {\n            queue.append(left) // Left child node enqueue\n        }\n        if let right = node.right {\n            queue.append(right) // Right child node enqueue\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* Level-order traversal */\nfunction levelOrder(root) {\n    // Initialize queue, add root node\n    const queue = [root];\n    // Initialize a list to save the traversal sequence\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // Dequeue\n        list.push(node.val); // Save node value\n        if (node.left) queue.push(node.left); // Left child node enqueue\n        if (node.right) queue.push(node.right); // Right child node enqueue\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* Level-order traversal */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // Initialize queue, add root node\n    const queue = [root];\n    // Initialize a list to save the traversal sequence\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // Dequeue\n        list.push(node.val); // Save node value\n        if (node.left) {\n            queue.push(node.left); // Left child node enqueue\n        }\n        if (node.right) {\n            queue.push(node.right); // Right child node enqueue\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* Level-order traversal */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // Initialize queue, add root node\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // Initialize a list to save the traversal sequence\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // Dequeue\n    res.add(node!.val); // Save node value\n    if (node.left != null) queue.add(node.left); // Left child node enqueue\n    if (node.right != null) queue.add(node.right); // Right child node enqueue\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* Level-order traversal */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // Initialize queue, add root node\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // Initialize a list to save the traversal sequence\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // Dequeue\n        vec.push(node.borrow().val); // Save node value\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // Left child node enqueue\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // Right child node enqueue\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* Level-order traversal */\nint *levelOrder(TreeNode *root, int *size) {\n    /* Auxiliary queue */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* Auxiliary queue */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // Queue pointer\n    front = 0, rear = 0;\n    // Add root node\n    queue[rear++] = root;\n    // Initialize a list to save the traversal sequence\n    /* Auxiliary array */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // Array pointer\n    index = 0;\n    while (front &lt; rear) {\n        // Dequeue\n        node = queue[front++];\n        // Save node value\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // Left child node enqueue\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // Right child node enqueue\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // Update array length value\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // Free auxiliary array space\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* Level-order traversal */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // Initialize queue, add root node\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // Initialize a list to save the traversal sequence\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // Dequeue\n        list.add(node?._val!!)       // Save node value\n        if (node.left != null)\n            queue.offer(node.left)   // Left child node enqueue\n        if (node.right != null)\n            queue.offer(node.right)  // Right child node enqueue\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### Level-order traversal ###\ndef level_order(root)\n  # Initialize queue, add root node\n  queue = [root]\n  # Initialize a list to save the traversal sequence\n  res = []\n  while !queue.empty?\n    node = queue.shift # Dequeue\n    res &lt;&lt; node.val # Save node value\n    queue &lt;&lt; node.left unless node.left.nil? # Left child node enqueue\n    queue &lt;&lt; node.right unless node.right.nil? # Right child node enqueue\n  end\n  res\nend\n</code></pre>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis","level":3,"title":"2.   Complexity Analysis","text":"<ul> <li>Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time, where \\(n\\) is the number of nodes.</li> <li>Space complexity is \\(O(n)\\): In the worst case, i.e., a full binary tree, before traversing to the bottom level, the queue contains at most \\((n + 1) / 2\\) nodes simultaneously, occupying \\(O(n)\\) space.</li> </ul>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722-preorder-inorder-and-postorder-traversal","level":2,"title":"7.2.2   Preorder, Inorder, and Postorder Traversal","text":"<p>Correspondingly, preorder, inorder, and postorder traversals all belong to depth-first traversal, also known as depth-first search (DFS), which embodies a \"first go to the end, then backtrack and continue\" traversal method.</p> <p>Figure 7-10 shows how depth-first traversal works on a binary tree. Depth-first traversal is like \"walking\" around the perimeter of the entire binary tree, encountering three positions at each node, corresponding to preorder, inorder, and postorder traversal.</p> <p></p> <p> Figure 7-10   Preorder, inorder, and postorder traversal of a binary tree </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation_1","level":3,"title":"1.   Code Implementation","text":"<p>Depth-first search is usually implemented based on recursion:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"Preorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: root node -&gt; left subtree -&gt; right subtree\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"Inorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: left subtree -&gt; root node -&gt; right subtree\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"Postorder traversal\"\"\"\n    if root is None:\n        return\n    # Visit priority: left subtree -&gt; right subtree -&gt; root node\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* Preorder traversal */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* Inorder traversal */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* Postorder traversal */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* Preorder traversal */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* Inorder traversal */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* Postorder traversal */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* Preorder traversal */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* Inorder traversal */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* Postorder traversal */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* Preorder traversal */\nfunction preOrder(root) {\n    if (root === null) return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nfunction inOrder(root) {\n    if (root === null) return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nfunction postOrder(root) {\n    if (root === null) return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* Preorder traversal */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Inorder traversal */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Postorder traversal */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: root node -&gt; left subtree -&gt; right subtree\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: left subtree -&gt; root node -&gt; right subtree\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // Visit priority: left subtree -&gt; right subtree -&gt; root node\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* Preorder traversal */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: root node -&gt; left subtree -&gt; right subtree\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Inorder traversal */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: left subtree -&gt; root node -&gt; right subtree\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Postorder traversal */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Visit priority: left subtree -&gt; right subtree -&gt; root node\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* Preorder traversal */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* Inorder traversal */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* Postorder traversal */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* Preorder traversal */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: root node -&gt; left subtree -&gt; right subtree\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* Inorder traversal */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: left subtree -&gt; root node -&gt; right subtree\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* Postorder traversal */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // Visit priority: left subtree -&gt; right subtree -&gt; root node\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### Pre-order traversal ###\ndef pre_order(root)\n  return if root.nil?\n\n  # Visit priority: root node -&gt; left subtree -&gt; right subtree\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### In-order traversal ###\ndef in_order(root)\n  return if root.nil?\n\n  # Visit priority: left subtree -&gt; root node -&gt; right subtree\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### Post-order traversal ###\ndef post_order(root)\n  return if root.nil?\n\n  # Visit priority: left subtree -&gt; right subtree -&gt; root node\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> <p>Tip</p> <p>Depth-first search can also be implemented based on iteration, interested readers can study this on their own.</p> <p>Figure 7-11 shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite parts: \"recursion\" and \"return\".</p> <ol> <li>\"Recursion\" means opening a new method, where the program accesses the next node in this process.</li> <li>\"Return\" means the function returns, indicating that the current node has been fully visited.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Figure 7-11   The recursive process of preorder traversal </p>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis_1","level":3,"title":"2.   Complexity Analysis","text":"<ul> <li>Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time.</li> <li>Space complexity is \\(O(n)\\): In the worst case, i.e., the tree degenerates into a linked list, the recursion depth reaches \\(n\\), and the system occupies \\(O(n)\\) stack frame space.</li> </ul>","path":["Chapter 7. Tree","7.2 &nbsp; Binary Tree Traversal"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   Summary","text":"","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/summary/#1-key-review","level":3,"title":"1.   Key Review","text":"<ul> <li>A binary tree is a non-linear data structure that embodies the divide-and-conquer logic of \"one divides into two\". Each binary tree node contains a value and two pointers, which respectively point to its left and right child nodes.</li> <li>For a certain node in a binary tree, the tree formed by its left (right) child node and all nodes below is called the left (right) subtree of that node.</li> <li>Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth.</li> <li>The initialization, node insertion, and node removal operations of binary trees are similar to those of linked lists.</li> <li>Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree is the ideal state, while the linked list is the worst state after degradation.</li> <li>A binary tree can be represented using an array by arranging node values and empty slots in level-order traversal sequence, and implementing pointers based on the index mapping relationship between parent and child nodes.</li> <li>Level-order traversal of a binary tree is a breadth-first search method, embodying a layer-by-layer traversal approach of \"expanding outward circle by circle\", typically implemented using a queue.</li> <li>Preorder, inorder, and postorder traversals all belong to depth-first search, embodying a traversal approach of \"first go to the end, then backtrack and continue\", typically implemented using recursion.</li> <li>A binary search tree is an efficient data structure for element searching, with search, insertion, and removal operations all having time complexity of \\(O(\\log n)\\). When a binary search tree degenerates into a linked list, all time complexities degrade to \\(O(n)\\).</li> <li>An AVL tree, also known as a balanced binary search tree, ensures the tree remains balanced after continuous node insertions and removals through rotation operations.</li> <li>Rotation operations in AVL trees include right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. After inserting or removing nodes, AVL trees perform rotation operations from bottom to top to restore the tree to balance.</li> </ul>","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: For a binary tree with only one node, are both the height of the tree and the depth of the root node \\(0\\)?</p> <p>Yes, because height and depth are typically defined as \"the number of edges passed.\"</p> <p>Q: The insertion and removal in a binary tree are generally accomplished by a set of operations. What does \"a set of operations\" refer to here? Does it imply releasing the resources of the child nodes?</p> <p>Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.</p> <p>Q: Why does DFS traversal of binary trees have three orders: preorder, inorder, and postorder, and what are their uses?</p> <p>Similar to forward and reverse traversal of arrays, preorder, inorder, and postorder traversals are three methods of binary tree traversal that allow us to obtain a traversal result in a specific order. For example, in a binary search tree, since nodes satisfy the relationship <code>left child node value &lt; root node value &lt; right child node value</code>, we only need to traverse the tree with the priority of \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\" to obtain an ordered node sequence.</p> <p>Q: In a right rotation operation handling the relationship between unbalanced nodes <code>node</code>, <code>child</code>, and <code>grand_child</code>, doesn't the connection between <code>node</code> and its parent node get lost after the right rotation?</p> <p>We need to view this problem from a recursive perspective. The right rotation operation <code>right_rotate(root)</code> passes in the root node of the subtree and eventually returns the root node of the subtree after rotation with <code>return child</code>. The connection between the subtree's root node and its parent node is completed after the function returns, which is not within the maintenance scope of the right rotation operation.</p> <p>Q: In C++, functions are divided into <code>private</code> and <code>public</code> sections. What considerations are there for this? Why are the <code>height()</code> function and the <code>updateHeight()</code> function placed in <code>public</code> and <code>private</code>, respectively?</p> <p>It mainly depends on the method's usage scope. If a method is only used within the class, then it is designed as <code>private</code>. For example, calling <code>updateHeight()</code> alone by the user makes no sense, as it is only a step in insertion or removal operations. However, <code>height()</code> is used to access node height, similar to <code>vector.size()</code>, so it is set to <code>public</code> for ease of use.</p> <p>Q: How do you build a binary search tree from a set of input data? Is the choice of root node very important?</p> <p>Yes, the method for building a tree is provided in the <code>build_tree()</code> method in the binary search tree code. As for the choice of root node, we typically sort the input data, then select the middle element as the root node, and recursively build the left and right subtrees. This approach maximizes the tree's balance.</p> <p>Q: In Java, do you always have to use the <code>equals()</code> method for string comparison?</p> <p>In Java, for primitive data types, <code>==</code> is used to compare whether the values of two variables are equal. For reference types, the working principles of the two symbols are different.</p> <ul> <li><code>==</code>: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.</li> <li><code>equals()</code>: Used to compare whether the values of two objects are equal.</li> </ul> <p>Therefore, if we want to compare values, we should use <code>equals()</code>. However, strings initialized via <code>String a = \"hi\"; String b = \"hi\";</code> are stored in the string constant pool and point to the same object, so <code>a == b</code> can also be used to compare the contents of the two strings.</p> <p>Q: Before reaching the bottom level, is the number of nodes in the queue \\(2^h\\) in breadth-first traversal?</p> <p>Yes, for example, a full binary tree with height \\(h = 2\\) has a total of \\(n = 7\\) nodes, then the bottom level has \\(4 = 2^h = (n + 1) / 2\\) nodes.</p>","path":["Chapter 7. Tree","7.6 &nbsp; Summary"],"tags":[]}]}
\ No newline at end of file
diff --git a/en/stylesheets/extra.css b/en/stylesheets/extra.css
index 57becd0d3..00a71c3b1 100644
--- a/en/stylesheets/extra.css
+++ b/en/stylesheets/extra.css
@@ -1,4 +1,4 @@
-/* Color Settings */
+/* Theme tokens */
 /* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
 /* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
 :root>* {
@@ -14,21 +14,23 @@
   --md-code-fg-color: #1d1d20;
   --md-code-bg-color: #f5f5f5;
 
-  --md-accent-fg-color: #999;
-
   --md-typeset-color: #1d1d20;
   --md-typeset-a-color: #349890;
 
+  --md-accent-fg-color: var(--md-typeset-a-color);
+
   --md-typeset-btn-color: #55aea6;
   --md-typeset-btn-hover-color: #52bbb1;
 
   --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
-  --md-admonition-pythontutor-color: #eee;
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+
+  --hello-algo-sidebar-width: 13rem;
 }
 
 [data-md-color-scheme="slate"] {
-  --theme-dark-base: #1E1E1E;
-  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-base: #1e1e1e;
+  --theme-dark-mantle: #1a1a1a;
   --theme-dark-crust: #171717;
   --hero-starfield-bg-color: var(--theme-dark-base);
 
@@ -37,25 +39,25 @@
 
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: var(--theme-dark-base);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
 
-  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-body-bg-color: var(--md-default-bg-color);
   --md-header-bg-color: rgba(26, 26, 26, 0.8);
 
   --md-code-fg-color: #adbac7;
   --md-code-bg-color: var(--theme-dark-crust);
 
-  --md-accent-fg-color: #aaa;
-
-  --md-footer-fg-color: #adbac7;
-  --md-footer-bg-color: var(--theme-dark-mantle);
-
   --md-typeset-color: #adbac7;
   --md-typeset-a-color: #52bbb1;
+  --md-accent-fg-color: var(--md-typeset-a-color);
 
   --md-typeset-btn-color: #52bbb1;
   --md-typeset-btn-hover-color: #55aea6;
 
-  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
 }
 
 [data-md-color-scheme="slate"][data-md-color-primary="black"],
@@ -63,24 +65,82 @@
   --md-typeset-a-color: #52bbb1;
 }
 
+/* Base layout */
+body {
+  background-color: var(--md-default-bg-color);
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Banner and footer */
+.md-banner {
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
 [data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner {
-  background-color: var(--theme-dark-mantle);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer-meta {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer__link {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
 [data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--theme-dark-base);
+  color: var(--md-footer-fg-color);
 }
 
 [data-md-color-scheme="slate"] .md-footer__title,
@@ -93,40 +153,31 @@
   color: var(--md-footer-fg-color);
 }
 
-/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
-.md-nav__link[for] {
-  color: var(--md-default-fg-color) !important;
-}
-
-/* Figure class */
+/* Shared content elements */
 .animation-figure {
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Cover image class */
 .cover-image {
   width: 28rem;
   height: auto;
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Center Markdown Tables (requires md_in_html extension) */
 .center-table {
   text-align: center;
 }
 
-/* Reset alignment for table cells */
 .md-typeset .center-table :is(td, th):not([align]) {
   text-align: initial;
 }
 
-/* Font size */
 .md-typeset {
   font-size: 0.75rem;
   line-height: 1.5;
@@ -136,7 +187,6 @@
   font-size: 0.95em;
 }
 
-/* Markdown Header */
 /* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
 .md-typeset h1 {
   font-weight: 400;
@@ -155,11 +205,6 @@
   text-transform: none;
 }
 
-.md-typeset a:hover {
-  color: var(--md-typeset-a-color);
-  text-decoration: underline;
-}
-
 .md-typeset code {
   border-radius: 0.2rem;
 }
@@ -168,21 +213,11 @@
   font-weight: normal;
 }
 
-/* font-family setting for Win10 */
-body {
-  --md-text-font-family: -apple-system, BlinkMacSystemFont,
-    var(--md-text-font, _), Helvetica, Arial, sans-serif;
-  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
-    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
-}
-
-/* max height of code block */
 /* https://github.com/squidfunk/mkdocs-material/issues/3444 */
 .md-typeset pre>code {
   max-height: 25rem;
 }
 
-/* Keep code block scrollbar hover neutral instead of accent-colored */
 .md-typeset pre>code:hover {
   scrollbar-color: var(--md-default-fg-color--lighter) transparent;
 }
@@ -191,29 +226,48 @@ body {
   background-color: var(--md-default-fg-color--lighter);
 }
 
-/* Make the picture not glare in dark theme */
 [data-md-color-scheme="slate"] .md-typeset img,
 [data-md-color-scheme="slate"] .md-typeset svg,
 [data-md-color-scheme="slate"] .md-typeset video {
   filter: brightness(0.85) invert(0.05);
 }
 
-/* landing page */
-.header-img-div {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0 auto;
-  width: 100%;
-  /* Default to full width */
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+/* Admonitions and tabs */
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
 }
 
-/* Admonition for python tutor */
 .md-typeset .admonition.pythontutor,
 .md-typeset details.pythontutor {
   border-color: var(--md-default-fg-color--lightest);
   margin-top: 0;
   margin-bottom: 1.5625em;
+  background-color: var(--md-code-bg-color);
 }
 
 .md-typeset .pythontutor>.admonition-title,
@@ -228,26 +282,18 @@ body {
   mask-image: var(--md-admonition-icon--pythontutor);
 }
 
-/* code block tabs */
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
 .md-typeset .tabbed-labels>label {
   font-size: 0.61rem;
 }
 
 .md-typeset .tabbed-labels--linked>label>a {
-  padding: .78125em 1.0em .625em;
-}
-
-/* header banner */
-.md-banner {
-  background-color: var(--md-code-bg-color);
-  color: var(--md-default-fg-color);
-  font-size: 0.75rem;
-}
-
-.md-banner .banner-svg svg {
-  margin-right: 0.3rem;
-  height: 0.63rem;
-  fill: var(--md-default-fg-color);
+  padding: 0.78125em 1em 0.625em;
 }
 
 .pythontutor-iframe {
@@ -260,115 +306,55 @@ body {
   border: none;
 }
 
-/* landing page container */
+/* Landing page layout */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+}
+
 .home-div {
   width: 100%;
   height: auto;
   display: flex;
   justify-content: center;
   align-items: center;
+  padding: 3em 2em;
   background-color: var(--md-default-bg-color);
   color: var(--md-default-fg-color);
   font-size: 0.9rem;
-  padding: 3em 2em;
   text-align: center;
 }
 
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6,
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
 .section-content {
   width: 100%;
   height: auto;
   max-width: 70vw;
 }
 
-/* rounded button */
-.rounded-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 10em;
-  margin: 0 0.1em;
-  padding: 0.6em 1.3em;
-  border: none;
-  background-color: var(--md-typeset-btn-color);
-  color: var(--md-primary-fg-color) !important;
-  text-align: center;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.rounded-button:hover {
-  background-color: var(--md-typeset-btn-hover-color);
-}
-
-.rounded-button span {
-  margin: 0;
-  margin-bottom: 0.07em;
-  white-space: nowrap;
-}
-
-.rounded-button svg {
-  fill: var(--md-primary-fg-color);
-  width: auto;
-  height: 1.2em;
-  margin-right: 0.5em;
-}
-
-/* device image */
-.device-on-hover {
-  width: auto;
-  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
-}
-
-a:hover .device-on-hover {
-  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
-  transform: scale(1.01);
-}
-
-/* text button */
-.reading-media {
-  display: flex;
-  justify-content: center;
-  align-items: flex-end;
-  height: 32vw;
-}
-
-.media-block {
-  height: 100%;
-  margin: 0 0.2em;
-}
-
-.text-button {
-  width: auto;
-  color: var(--md-typeset-btn-color);
-  text-decoration: none;
-  text-align: center;
-  margin: 2.7em auto;
-}
-
-.text-button span {
-  white-space: nowrap;
-}
-
-.text-button svg {
-  display: inline-block;
-  fill: var(--md-typeset-btn-color);
-  width: auto;
-  height: 0.9em;
-  background-size: cover;
-  padding-top: 0.17em;
-  margin-left: 0.15em;
-}
-
-a:hover .text-button span {
-  text-decoration: underline;
-}
-
-/* hero image */
 .hero-div {
   height: min(84vh, 75vw);
   width: min(112vh, 100vw);
-  margin: 0 auto;
-  margin-top: -2.4rem;
+  margin: -2.4rem auto 0;
   padding: 0;
   position: relative;
   font-size: min(1.8vh, 2.5vw);
@@ -384,13 +370,12 @@ a:hover .text-button span {
 }
 
 .hero-bg {
-  height: 100%;
   width: 100%;
+  height: 100%;
   object-fit: cover;
   position: absolute;
 }
 
-/* hover on the planets */
 .hero-div>a>img {
   width: auto;
   position: absolute;
@@ -402,7 +387,6 @@ a:hover .text-button span {
   position: absolute;
   transform: translateX(-50%) translateY(-50%);
   white-space: nowrap;
-  /* prevent line breaks */
   color: white;
 }
 
@@ -412,21 +396,105 @@ a:hover .text-button span {
 }
 
 .hero-div>a:hover>span {
-  text-decoration: underline;
   color: var(--md-typeset-btn-color);
+  text-decoration: underline;
 }
 
 .heading-div {
   width: 100%;
   position: absolute;
-  transform: translateX(-50%);
   left: 50%;
   bottom: min(2vh, 3vw);
+  transform: translateX(-50%);
   pointer-events: none;
   color: #fff;
 }
 
-/* code badge */
+/* Landing page CTAs */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  border-radius: 10em;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0 0 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+  fill: var(--md-primary-fg-color);
+}
+
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  margin: 2.7em auto;
+  color: var(--md-typeset-btn-color);
+  text-align: center;
+  text-decoration: none;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  width: auto;
+  height: 0.9em;
+  margin-left: 0.15em;
+  padding-top: 0.17em;
+  fill: var(--md-typeset-btn-color);
+  background-size: cover;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* Landing page content blocks */
 .code-badge {
   width: 100%;
   height: auto;
@@ -434,11 +502,10 @@ a:hover .text-button span {
 }
 
 .code-badge img {
-  height: 1.07em;
   width: auto;
+  height: 1.07em;
 }
 
-/* brief intro */
 .intro-container {
   display: flex;
   align-items: center;
@@ -455,14 +522,13 @@ a:hover .text-button span {
 
 .intro-text {
   flex-grow: 1;
-  /* fill the space */
   display: flex;
   flex-direction: column;
   justify-content: center;
-  text-align: left;
   align-items: flex-start;
   width: fit-content;
   margin: 2em;
+  text-align: left;
 }
 
 .intro-text>div {
@@ -471,6 +537,10 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
+.intro-text svg path {
+  fill: #3b3b3b;
+}
+
 .endor-text {
   width: 50%;
 }
@@ -480,7 +550,10 @@ a:hover .text-button span {
   font-weight: bold;
 }
 
-/* contributors table */
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
 .profile-div {
   display: flex;
   flex-wrap: wrap;
@@ -495,6 +568,11 @@ a:hover .text-button span {
   text-align: center;
 }
 
+.profile-cell a:hover b,
+.profile-cell a:focus-visible b {
+  text-decoration: underline;
+}
+
 .profile-img {
   width: 5em;
   border-radius: 50%;
@@ -517,7 +595,37 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
-/* Hide navigation */
+/* Embedded media */
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Responsive adjustments */
 @media screen and (max-width: 76.25em) {
   .section-content {
     max-width: 95vw;
@@ -532,7 +640,6 @@ a:hover .text-button span {
   }
 }
 
-/* mobile devices */
 @media screen and (max-width: 60em) {
   .home-div {
     font-size: 0.75rem;
@@ -571,209 +678,4 @@ a:hover .text-button span {
     flex: 1 1 30%;
   }
 }
-
-.video-container {
-  position: relative;
-  padding-bottom: 56.25%;
-  /* 16:9 */
-  height: 0;
-}
-
-.video-container iframe {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-/* starfield */
-.starfield {
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  z-index: 0;
-  background-color: var(--hero-starfield-bg-color, transparent);
-}
-
-.starfield-origin {
-  position: absolute;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-}
-
-/* Zensical-specific adjustments merged into the main stylesheet. */
-:root>* {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --hello-algo-sidebar-width: 13rem;
-}
-
-[data-md-color-scheme="slate"] {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --md-body-bg-color: var(--md-default-bg-color);
-  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
-}
-
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
-  background-color: #f5f5f5;
-  color: #1d1d20;
-}
-
-body {
-  background-color: var(--md-default-bg-color);
-}
-
-html:has(body[data-md-color-scheme="slate"]) {
-  background-color: #1e1e1e;
-}
-
-html:has(body[data-md-color-scheme="default"]) {
-  background-color: #ffffff;
-}
-
-.home-div[data-md-color-scheme="default"],
-.home-div[data-md-color-scheme="default"] h1,
-.home-div[data-md-color-scheme="default"] h2,
-.home-div[data-md-color-scheme="default"] h3,
-.home-div[data-md-color-scheme="default"] h4,
-.home-div[data-md-color-scheme="default"] h5,
-.home-div[data-md-color-scheme="default"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div[data-md-color-scheme="slate"],
-.home-div[data-md-color-scheme="slate"] h1,
-.home-div[data-md-color-scheme="slate"] h2,
-.home-div[data-md-color-scheme="slate"] h3,
-.home-div[data-md-color-scheme="slate"] h4,
-.home-div[data-md-color-scheme="slate"] h5,
-.home-div[data-md-color-scheme="slate"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div .intro-quote {
-  color: var(--md-default-fg-color--light) !important;
-}
-
-.reading-media+p {
-  margin-top: 1em !important;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before,
-.md-typeset summary:after {
-  top: 50%;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before {
-  transform: translateY(-50%);
-}
-
-.md-typeset summary:after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open]>summary:after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-nav__link[for] {
-  color: inherit !important;
-}
-
-.md-nav__link[for].md-nav__link--active {
-  color: var(--md-accent-fg-color) !important;
-}
-
-@media screen and (min-width: 76.25em) {
-  .md-grid {
-    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
-  }
-
-  .md-sidebar--primary,
-  .md-sidebar--secondary {
-    width: var(--hello-algo-sidebar-width);
-  }
-
-  [dir="ltr"] .md-sidebar__inner {
-    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-
-  [dir="rtl"] .md-sidebar__inner {
-    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap {
-  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
-  background-color: var(--md-default-fg-color--lighter);
-}
-
-.md-footer,
-.md-footer__inner,
-.md-footer-meta,
-.md-footer__link,
-.md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-footer {
-  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
-}
-
-[data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner,
-[data-md-color-scheme="slate"] .md-footer-meta,
-[data-md-color-scheme="slate"] .md-footer__link,
-[data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-banner {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .admonition.pythontutor,
-.md-typeset details.pythontutor,
-.md-typeset .pythontutor>.admonition-title,
-.md-typeset .pythontutor>summary {
-  background-color: var(--md-code-bg-color);
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before,
-.md-typeset .pythontutor>summary::after {
-  top: 50%;
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before {
-  transform: translateY(-50%);
-}
-
-.md-typeset .pythontutor>summary::after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open].pythontutor>summary::after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-typeset a:not(.md-button) {
-  text-decoration: none;
-}
-
-.md-typeset a:not(.md-button):hover,
-.md-typeset a:not(.md-button):focus-visible {
-  text-decoration: underline;
-}
-/*! update cache: 20260331044513 */
+/*! update cache: 20260331053206 */
diff --git a/ja/assets/covers/chapter_appendix.jpg b/ja/assets/covers/chapter_appendix.jpg
index 01e4dd552..1c4cacacb 100644
Binary files a/ja/assets/covers/chapter_appendix.jpg and b/ja/assets/covers/chapter_appendix.jpg differ
diff --git a/ja/assets/covers/chapter_array_and_linkedlist.jpg b/ja/assets/covers/chapter_array_and_linkedlist.jpg
index 4cf13ceb3..5174b2035 100644
Binary files a/ja/assets/covers/chapter_array_and_linkedlist.jpg and b/ja/assets/covers/chapter_array_and_linkedlist.jpg differ
diff --git a/ja/assets/covers/chapter_backtracking.jpg b/ja/assets/covers/chapter_backtracking.jpg
index 6aa3208d2..4ea0ffc10 100644
Binary files a/ja/assets/covers/chapter_backtracking.jpg and b/ja/assets/covers/chapter_backtracking.jpg differ
diff --git a/ja/assets/covers/chapter_complexity_analysis.jpg b/ja/assets/covers/chapter_complexity_analysis.jpg
index 8c5a9d2e9..d78da9bea 100644
Binary files a/ja/assets/covers/chapter_complexity_analysis.jpg and b/ja/assets/covers/chapter_complexity_analysis.jpg differ
diff --git a/ja/assets/covers/chapter_data_structure.jpg b/ja/assets/covers/chapter_data_structure.jpg
index 7c1a4a69c..5e4751531 100644
Binary files a/ja/assets/covers/chapter_data_structure.jpg and b/ja/assets/covers/chapter_data_structure.jpg differ
diff --git a/ja/assets/covers/chapter_divide_and_conquer.jpg b/ja/assets/covers/chapter_divide_and_conquer.jpg
index 0b3b90eea..e95d52aec 100644
Binary files a/ja/assets/covers/chapter_divide_and_conquer.jpg and b/ja/assets/covers/chapter_divide_and_conquer.jpg differ
diff --git a/ja/assets/covers/chapter_dynamic_programming.jpg b/ja/assets/covers/chapter_dynamic_programming.jpg
index 98db1e161..69f0977b4 100644
Binary files a/ja/assets/covers/chapter_dynamic_programming.jpg and b/ja/assets/covers/chapter_dynamic_programming.jpg differ
diff --git a/ja/assets/covers/chapter_graph.jpg b/ja/assets/covers/chapter_graph.jpg
index 0062d7b4c..4b5fef52b 100644
Binary files a/ja/assets/covers/chapter_graph.jpg and b/ja/assets/covers/chapter_graph.jpg differ
diff --git a/ja/assets/covers/chapter_greedy.jpg b/ja/assets/covers/chapter_greedy.jpg
index 4508d88e6..7f72a307a 100644
Binary files a/ja/assets/covers/chapter_greedy.jpg and b/ja/assets/covers/chapter_greedy.jpg differ
diff --git a/ja/assets/covers/chapter_hashing.jpg b/ja/assets/covers/chapter_hashing.jpg
index 7fedeea75..18077867f 100644
Binary files a/ja/assets/covers/chapter_hashing.jpg and b/ja/assets/covers/chapter_hashing.jpg differ
diff --git a/ja/assets/covers/chapter_heap.jpg b/ja/assets/covers/chapter_heap.jpg
index 57e2c6c92..8484ab2b1 100644
Binary files a/ja/assets/covers/chapter_heap.jpg and b/ja/assets/covers/chapter_heap.jpg differ
diff --git a/ja/assets/covers/chapter_introduction.jpg b/ja/assets/covers/chapter_introduction.jpg
index d3dea8d22..6949c4115 100644
Binary files a/ja/assets/covers/chapter_introduction.jpg and b/ja/assets/covers/chapter_introduction.jpg differ
diff --git a/ja/assets/covers/chapter_preface.jpg b/ja/assets/covers/chapter_preface.jpg
index 9a89f9e09..22227fc9b 100644
Binary files a/ja/assets/covers/chapter_preface.jpg and b/ja/assets/covers/chapter_preface.jpg differ
diff --git a/ja/assets/covers/chapter_searching.jpg b/ja/assets/covers/chapter_searching.jpg
index 60e2bfe47..151e91079 100644
Binary files a/ja/assets/covers/chapter_searching.jpg and b/ja/assets/covers/chapter_searching.jpg differ
diff --git a/ja/assets/covers/chapter_sorting.jpg b/ja/assets/covers/chapter_sorting.jpg
index eadf95d40..b7539856a 100644
Binary files a/ja/assets/covers/chapter_sorting.jpg and b/ja/assets/covers/chapter_sorting.jpg differ
diff --git a/ja/assets/covers/chapter_stack_and_queue.jpg b/ja/assets/covers/chapter_stack_and_queue.jpg
index 7b164e31f..ca6e24fb1 100644
Binary files a/ja/assets/covers/chapter_stack_and_queue.jpg and b/ja/assets/covers/chapter_stack_and_queue.jpg differ
diff --git a/ja/assets/covers/chapter_tree.jpg b/ja/assets/covers/chapter_tree.jpg
index 78fc852c9..e47306dbb 100644
Binary files a/ja/assets/covers/chapter_tree.jpg and b/ja/assets/covers/chapter_tree.jpg differ
diff --git a/ja/assets/javascripts/bundle.c2b142ea.min.js b/ja/assets/javascripts/bundle.c2b142ea.min.js
index 8fa527bf3..9a524e732 100644
--- a/ja/assets/javascripts/bundle.c2b142ea.min.js
+++ b/ja/assets/javascripts/bundle.c2b142ea.min.js
@@ -1,4 +1,4 @@
 "use strict";(()=>{var xc=Object.create;var kn=Object.defineProperty,wc=Object.defineProperties,Ec=Object.getOwnPropertyDescriptor,Tc=Object.getOwnPropertyDescriptors,Sc=Object.getOwnPropertyNames,Dr=Object.getOwnPropertySymbols,Oc=Object.getPrototypeOf,An=Object.prototype.hasOwnProperty,Fo=Object.prototype.propertyIsEnumerable;var jo=(e,t,r)=>t in e?kn(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,H=(e,t)=>{for(var r in t||(t={}))An.call(t,r)&&jo(e,r,t[r]);if(Dr)for(var r of Dr(t))Fo.call(t,r)&&jo(e,r,t[r]);return e},He=(e,t)=>wc(e,Tc(t));var gr=(e,t)=>{var r={};for(var n in e)An.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&Dr)for(var n of Dr(e))t.indexOf(n)<0&&Fo.call(e,n)&&(r[n]=e[n]);return r};var Cn=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Lc=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Sc(t))!An.call(e,o)&&o!==r&&kn(e,o,{get:()=>t[o],enumerable:!(n=Ec(t,o))||n.enumerable});return e};var _r=(e,t,r)=>(r=e!=null?xc(Oc(e)):{},Lc(t||!e||!e.__esModule?kn(r,"default",{value:e,enumerable:!0}):r,e));var Uo=(e,t,r)=>new Promise((n,o)=>{var i=c=>{try{s(r.next(c))}catch(l){o(l)}},a=c=>{try{s(r.throw(c))}catch(l){o(l)}},s=c=>c.done?n(c.value):Promise.resolve(c.value).then(i,a);s((r=r.apply(e,t)).next())});var Do=Cn((Hn,No)=>{(function(e,t){typeof Hn=="object"&&typeof No!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(Hn,(function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(_){return!!(_&&_!==document&&_.nodeName!=="HTML"&&_.nodeName!=="BODY"&&"classList"in _&&"contains"in _.classList)}function c(_){var de=_.type,be=_.tagName;return!!(be==="INPUT"&&a[de]&&!_.readOnly||be==="TEXTAREA"&&!_.readOnly||_.isContentEditable)}function l(_){_.classList.contains("focus-visible")||(_.classList.add("focus-visible"),_.setAttribute("data-focus-visible-added",""))}function u(_){_.hasAttribute("data-focus-visible-added")&&(_.classList.remove("focus-visible"),_.removeAttribute("data-focus-visible-added"))}function p(_){_.metaKey||_.altKey||_.ctrlKey||(s(r.activeElement)&&l(r.activeElement),n=!0)}function d(_){n=!1}function m(_){s(_.target)&&(n||c(_.target))&&l(_.target)}function h(_){s(_.target)&&(_.target.classList.contains("focus-visible")||_.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(_.target))}function v(_){document.visibilityState==="hidden"&&(o&&(n=!0),x())}function x(){document.addEventListener("mousemove",E),document.addEventListener("mousedown",E),document.addEventListener("mouseup",E),document.addEventListener("pointermove",E),document.addEventListener("pointerdown",E),document.addEventListener("pointerup",E),document.addEventListener("touchmove",E),document.addEventListener("touchstart",E),document.addEventListener("touchend",E)}function w(){document.removeEventListener("mousemove",E),document.removeEventListener("mousedown",E),document.removeEventListener("mouseup",E),document.removeEventListener("pointermove",E),document.removeEventListener("pointerdown",E),document.removeEventListener("pointerup",E),document.removeEventListener("touchmove",E),document.removeEventListener("touchstart",E),document.removeEventListener("touchend",E)}function E(_){_.target.nodeName&&_.target.nodeName.toLowerCase()==="html"||(n=!1,w())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",d,!0),document.addEventListener("pointerdown",d,!0),document.addEventListener("touchstart",d,!0),document.addEventListener("visibilitychange",v,!0),x(),r.addEventListener("focus",m,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)}))});var So=Cn((M0,vs)=>{"use strict";var Gu=/["'&<>]/;vs.exports=Ju;function Ju(e){var t=""+e,r=Gu.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i<t.length;i++){switch(t.charCodeAt(i)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}a!==i&&(o+=t.substring(a,i)),a=i+1,o+=n}return a!==i?o+t.substring(a,i):o}});var Mo=Cn((jr,Lo)=>{(function(t,r){typeof jr=="object"&&typeof Lo=="object"?Lo.exports=r():typeof define=="function"&&define.amd?define([],r):typeof jr=="object"?jr.ClipboardJS=r():t.ClipboardJS=r()})(jr,function(){return(function(){var e={686:(function(n,o,i){"use strict";i.d(o,{default:function(){return vr}});var a=i(279),s=i.n(a),c=i(370),l=i.n(c),u=i(817),p=i.n(u);function d(B){try{return document.execCommand(B)}catch(C){return!1}}var m=function(C){var k=p()(C);return d("cut"),k},h=m;function v(B){var C=document.documentElement.getAttribute("dir")==="rtl",k=document.createElement("textarea");k.style.fontSize="12pt",k.style.border="0",k.style.padding="0",k.style.margin="0",k.style.position="absolute",k.style[C?"right":"left"]="-9999px";var D=window.pageYOffset||document.documentElement.scrollTop;return k.style.top="".concat(D,"px"),k.setAttribute("readonly",""),k.value=B,k}var x=function(C,k){var D=v(C);k.container.appendChild(D);var W=p()(D);return d("copy"),D.remove(),W},w=function(C){var k=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},D="";return typeof C=="string"?D=x(C,k):C instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(C==null?void 0:C.type)?D=x(C.value,k):(D=p()(C),d("copy")),D},E=w;function _(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?_=function(k){return typeof k}:_=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},_(B)}var de=function(){var C=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},k=C.action,D=k===void 0?"copy":k,W=C.container,Z=C.target,We=C.text;if(D!=="copy"&&D!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(Z!==void 0)if(Z&&_(Z)==="object"&&Z.nodeType===1){if(D==="copy"&&Z.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(D==="cut"&&(Z.hasAttribute("readonly")||Z.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(We)return E(We,{container:W});if(Z)return D==="cut"?h(Z):E(Z,{container:W})},be=de;function M(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?M=function(k){return typeof k}:M=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},M(B)}function O(B,C){if(!(B instanceof C))throw new TypeError("Cannot call a class as a function")}function N(B,C){for(var k=0;k<C.length;k++){var D=C[k];D.enumerable=D.enumerable||!1,D.configurable=!0,"value"in D&&(D.writable=!0),Object.defineProperty(B,D.key,D)}}function ee(B,C,k){return C&&N(B.prototype,C),k&&N(B,k),B}function le(B,C){if(typeof C!="function"&&C!==null)throw new TypeError("Super expression must either be null or a function");B.prototype=Object.create(C&&C.prototype,{constructor:{value:B,writable:!0,configurable:!0}}),C&&ce(B,C)}function ce(B,C){return ce=Object.setPrototypeOf||function(D,W){return D.__proto__=W,D},ce(B,C)}function Ne(B){var C=st();return function(){var D=tt(B),W;if(C){var Z=tt(this).constructor;W=Reflect.construct(D,arguments,Z)}else W=D.apply(this,arguments);return bt(this,W)}}function bt(B,C){return C&&(M(C)==="object"||typeof C=="function")?C:De(B)}function De(B){if(B===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return B}function st(){if(typeof Reflect=="undefined"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(B){return!1}}function tt(B){return tt=Object.setPrototypeOf?Object.getPrototypeOf:function(k){return k.__proto__||Object.getPrototypeOf(k)},tt(B)}function Yt(B,C){var k="data-clipboard-".concat(B);if(C.hasAttribute(k))return C.getAttribute(k)}var Mt=(function(B){le(k,B);var C=Ne(k);function k(D,W){var Z;return O(this,k),Z=C.call(this),Z.resolveOptions(W),Z.listenClick(D),Z}return ee(k,[{key:"resolveOptions",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof W.action=="function"?W.action:this.defaultAction,this.target=typeof W.target=="function"?W.target:this.defaultTarget,this.text=typeof W.text=="function"?W.text:this.defaultText,this.container=M(W.container)==="object"?W.container:document.body}},{key:"listenClick",value:function(W){var Z=this;this.listener=l()(W,"click",function(We){return Z.onClick(We)})}},{key:"onClick",value:function(W){var Z=W.delegateTarget||W.currentTarget,We=this.action(Z)||"copy",Gt=be({action:We,container:this.container,target:this.target(Z),text:this.text(Z)});this.emit(Gt?"success":"error",{action:We,text:Gt,trigger:Z,clearSelection:function(){Z&&Z.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(W){return Yt("action",W)}},{key:"defaultTarget",value:function(W){var Z=Yt("target",W);if(Z)return document.querySelector(Z)}},{key:"defaultText",value:function(W){return Yt("text",W)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(W){var Z=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return E(W,Z)}},{key:"cut",value:function(W){return h(W)}},{key:"isSupported",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],Z=typeof W=="string"?[W]:W,We=!!document.queryCommandSupported;return Z.forEach(function(Gt){We=We&&!!document.queryCommandSupported(Gt)}),We}}]),k})(s()),vr=Mt}),828:(function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,c){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(c))return s;s=s.parentNode}}n.exports=a}),438:(function(n,o,i){var a=i(828);function s(u,p,d,m,h){var v=l.apply(this,arguments);return u.addEventListener(d,v,h),{destroy:function(){u.removeEventListener(d,v,h)}}}function c(u,p,d,m,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof d=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,d,m,h)}))}function l(u,p,d,m){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&m.call(u,h)}}n.exports=c}),879:(function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}}),370:(function(n,o,i){var a=i(879),s=i(438);function c(d,m,h){if(!d&&!m&&!h)throw new Error("Missing required arguments");if(!a.string(m))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(d))return l(d,m,h);if(a.nodeList(d))return u(d,m,h);if(a.string(d))return p(d,m,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function l(d,m,h){return d.addEventListener(m,h),{destroy:function(){d.removeEventListener(m,h)}}}function u(d,m,h){return Array.prototype.forEach.call(d,function(v){v.addEventListener(m,h)}),{destroy:function(){Array.prototype.forEach.call(d,function(v){v.removeEventListener(m,h)})}}}function p(d,m,h){return s(document.body,d,m,h)}n.exports=c}),817:(function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var c=window.getSelection(),l=document.createRange();l.selectNodeContents(i),c.removeAllRanges(),c.addRange(l),a=c.toString()}return a}n.exports=o}),279:(function(n){function o(){}o.prototype={on:function(i,a,s){var c=this.e||(this.e={});return(c[i]||(c[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var c=this;function l(){c.off(i,l),a.apply(s,arguments)}return l._=a,this.on(i,l,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),c=0,l=s.length;for(c;c<l;c++)s[c].fn.apply(s[c].ctx,a);return this},off:function(i,a){var s=this.e||(this.e={}),c=s[i],l=[];if(c&&a)for(var u=0,p=c.length;u<p;u++)c[u].fn!==a&&c[u].fn._!==a&&l.push(c[u]);return l.length?s[i]=l:delete s[i],this}},n.exports=o,n.exports.TinyEmitter=o})},t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}return(function(){r.n=function(n){var o=n&&n.__esModule?function(){return n.default}:function(){return n};return r.d(o,{a:o}),o}})(),(function(){r.d=function(n,o){for(var i in o)r.o(o,i)&&!r.o(n,i)&&Object.defineProperty(n,i,{enumerable:!0,get:o[i]})}})(),(function(){r.o=function(n,o){return Object.prototype.hasOwnProperty.call(n,o)}})(),r(686)})().default})});var LM=_r(Do());var $n=function(e,t){return $n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,n){r.__proto__=n}||function(r,n){for(var o in n)Object.prototype.hasOwnProperty.call(n,o)&&(r[o]=n[o])},$n(e,t)};function ue(e,t){if(typeof t!="function"&&t!==null)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");$n(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function Wo(e,t,r,n){function o(i){return i instanceof r?i:new r(function(a){a(i)})}return new(r||(r=Promise))(function(i,a){function s(u){try{l(n.next(u))}catch(p){a(p)}}function c(u){try{l(n.throw(u))}catch(p){a(p)}}function l(u){u.done?i(u.value):o(u.value).then(s,c)}l((n=n.apply(e,t||[])).next())})}function Wr(e,t){var r={label:0,sent:function(){if(i[0]&1)throw i[1];return i[1]},trys:[],ops:[]},n,o,i,a=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return a.next=s(0),a.throw=s(1),a.return=s(2),typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(l){return function(u){return c([l,u])}}function c(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(r=0)),r;)try{if(n=1,o&&(i=l[0]&2?o.return:l[0]?o.throw||((i=o.return)&&i.call(o),0):o.next)&&!(i=i.call(o,l[1])).done)return i;switch(o=0,i&&(l=[l[0]&2,i.value]),l[0]){case 0:case 1:i=l;break;case 4:return r.label++,{value:l[1],done:!1};case 5:r.label++,o=l[1],l=[0];continue;case 7:l=r.ops.pop(),r.trys.pop();continue;default:if(i=r.trys,!(i=i.length>0&&i[i.length-1])&&(l[0]===6||l[0]===2)){r=0;continue}if(l[0]===3&&(!i||l[1]>i[0]&&l[1]<i[3])){r.label=l[1];break}if(l[0]===6&&r.label<i[1]){r.label=i[1],i=l;break}if(i&&r.label<i[2]){r.label=i[2],r.ops.push(l);break}i[2]&&r.ops.pop(),r.trys.pop();continue}l=t.call(e,r)}catch(u){l=[6,u],o=0}finally{n=i=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}function $e(e){var t=typeof Symbol=="function"&&Symbol.iterator,r=t&&e[t],n=0;if(r)return r.call(e);if(e&&typeof e.length=="number")return{next:function(){return e&&n>=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function te(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function ne(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n<o;n++)(i||!(n in t))&&(i||(i=Array.prototype.slice.call(t,0,n)),i[n]=t[n]);return e.concat(i||Array.prototype.slice.call(t))}function kt(e){return this instanceof kt?(this.v=e,this):new kt(e)}function Vo(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),o,i=[];return o=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",a),o[Symbol.asyncIterator]=function(){return this},o;function a(m){return function(h){return Promise.resolve(h).then(m,p)}}function s(m,h){n[m]&&(o[m]=function(v){return new Promise(function(x,w){i.push([m,v,x,w])>1||c(m,v)})},h&&(o[m]=h(o[m])))}function c(m,h){try{l(n[m](h))}catch(v){d(i[0][3],v)}}function l(m){m.value instanceof kt?Promise.resolve(m.value.v).then(u,p):d(i[0][2],m)}function u(m){c("next",m)}function p(m){c("throw",m)}function d(m,h){m(h),i.shift(),i.length&&c(i[0][0],i[0][1])}}function zo(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof $e=="function"?$e(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,c){a=e[i](a),o(s,c,a.done,a.value)})}}function o(i,a,s,c){Promise.resolve(c).then(function(l){i({value:l,done:s})},a)}}function F(e){return typeof e=="function"}function Jt(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var Vr=Jt(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription:
 `+r.map(function(n,o){return o+1+") "+n.toString()}).join(`
   `):"",this.name="UnsubscriptionError",this.errors=r}});function ct(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var rt=(function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=$e(a),c=s.next();!c.done;c=s.next()){var l=c.value;l.remove(this)}}catch(v){t={error:v}}finally{try{c&&!c.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(F(u))try{u()}catch(v){i=v instanceof Vr?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var d=$e(p),m=d.next();!m.done;m=d.next()){var h=m.value;try{qo(h)}catch(v){i=i!=null?i:[],v instanceof Vr?i=ne(ne([],te(i)),te(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{m&&!m.done&&(o=d.return)&&o.call(d)}finally{if(n)throw n.error}}}if(i)throw new Vr(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)qo(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&ct(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&ct(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=(function(){var t=new e;return t.closed=!0,t})(),e})();var Pn=rt.EMPTY;function zr(e){return e instanceof rt||e&&"closed"in e&&F(e.remove)&&F(e.add)&&F(e.unsubscribe)}function qo(e){F(e)?e():e.unsubscribe()}var Je={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var Xt={setTimeout:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Xt.delegate;return o!=null&&o.setTimeout?o.setTimeout.apply(o,ne([e,t],te(r))):setTimeout.apply(void 0,ne([e,t],te(r)))},clearTimeout:function(e){var t=Xt.delegate;return((t==null?void 0:t.clearTimeout)||clearTimeout)(e)},delegate:void 0};function qr(e){Xt.setTimeout(function(){var t=Je.onUnhandledError;if(t)t(e);else throw e})}function Pe(){}var Ko=(function(){return In("C",void 0,void 0)})();function Bo(e){return In("E",void 0,e)}function Yo(e){return In("N",e,void 0)}function In(e,t,r){return{kind:e,value:t,error:r}}var At=null;function Zt(e){if(Je.useDeprecatedSynchronousErrorHandling){var t=!At;if(t&&(At={errorThrown:!1,error:null}),e(),t){var r=At,n=r.errorThrown,o=r.error;if(At=null,n)throw o}}else e()}function Go(e){Je.useDeprecatedSynchronousErrorHandling&&At&&(At.errorThrown=!0,At.error=e)}var yr=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n.isStopped=!1,r?(n.destination=r,zr(r)&&r.add(n)):n.destination=Cc,n}return t.create=function(r,n,o){return new Ct(r,n,o)},t.prototype.next=function(r){this.isStopped?jn(Yo(r),this):this._next(r)},t.prototype.error=function(r){this.isStopped?jn(Bo(r),this):(this.isStopped=!0,this._error(r))},t.prototype.complete=function(){this.isStopped?jn(Ko,this):(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.closed||(this.isStopped=!0,e.prototype.unsubscribe.call(this),this.destination=null)},t.prototype._next=function(r){this.destination.next(r)},t.prototype._error=function(r){try{this.destination.error(r)}finally{this.unsubscribe()}},t.prototype._complete=function(){try{this.destination.complete()}finally{this.unsubscribe()}},t})(rt);var Mc=Function.prototype.bind;function Rn(e,t){return Mc.call(e,t)}var kc=(function(){function e(t){this.partialObserver=t}return e.prototype.next=function(t){var r=this.partialObserver;if(r.next)try{r.next(t)}catch(n){Kr(n)}},e.prototype.error=function(t){var r=this.partialObserver;if(r.error)try{r.error(t)}catch(n){Kr(n)}else Kr(t)},e.prototype.complete=function(){var t=this.partialObserver;if(t.complete)try{t.complete()}catch(r){Kr(r)}},e})(),Ct=(function(e){ue(t,e);function t(r,n,o){var i=e.call(this)||this,a;if(F(r)||!r)a={next:r!=null?r:void 0,error:n!=null?n:void 0,complete:o!=null?o:void 0};else{var s;i&&Je.useDeprecatedNextContext?(s=Object.create(r),s.unsubscribe=function(){return i.unsubscribe()},a={next:r.next&&Rn(r.next,s),error:r.error&&Rn(r.error,s),complete:r.complete&&Rn(r.complete,s)}):a=r}return i.destination=new kc(a),i}return t})(yr);function Kr(e){Je.useDeprecatedSynchronousErrorHandling?Go(e):qr(e)}function Ac(e){throw e}function jn(e,t){var r=Je.onStoppedNotification;r&&Xt.setTimeout(function(){return r(e,t)})}var Cc={closed:!0,next:Pe,error:Ac,complete:Pe};var Qt=(function(){return typeof Symbol=="function"&&Symbol.observable||"@@observable"})();function Oe(e){return e}function Jo(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Fn(e)}function Fn(e){return e.length===0?Oe:e.length===1?e[0]:function(r){return e.reduce(function(n,o){return o(n)},r)}}var U=(function(){function e(t){t&&(this._subscribe=t)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(t,r,n){var o=this,i=$c(t)?t:new Ct(t,r,n);return Zt(function(){var a=o,s=a.operator,c=a.source;i.add(s?s.call(i,c):c?o._subscribe(i):o._trySubscribe(i))}),i},e.prototype._trySubscribe=function(t){try{return this._subscribe(t)}catch(r){t.error(r)}},e.prototype.forEach=function(t,r){var n=this;return r=Xo(r),new r(function(o,i){var a=new Ct({next:function(s){try{t(s)}catch(c){i(c),a.unsubscribe()}},error:i,complete:o});n.subscribe(a)})},e.prototype._subscribe=function(t){var r;return(r=this.source)===null||r===void 0?void 0:r.subscribe(t)},e.prototype[Qt]=function(){return this},e.prototype.pipe=function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return Fn(t)(this)},e.prototype.toPromise=function(t){var r=this;return t=Xo(t),new t(function(n,o){var i;r.subscribe(function(a){return i=a},function(a){return o(a)},function(){return n(i)})})},e.create=function(t){return new e(t)},e})();function Xo(e){var t;return(t=e!=null?e:Je.Promise)!==null&&t!==void 0?t:Promise}function Hc(e){return e&&F(e.next)&&F(e.error)&&F(e.complete)}function $c(e){return e&&e instanceof yr||Hc(e)&&zr(e)}function Pc(e){return F(e==null?void 0:e.lift)}function S(e){return function(t){if(Pc(t))return t.lift(function(r){try{return e(r,this)}catch(n){this.error(n)}});throw new TypeError("Unable to lift unknown Observable type")}}function T(e,t,r,n,o){return new Ic(e,t,r,n,o)}var Ic=(function(e){ue(t,e);function t(r,n,o,i,a,s){var c=e.call(this,r)||this;return c.onFinalize=a,c.shouldUnsubscribe=s,c._next=n?function(l){try{n(l)}catch(u){r.error(u)}}:e.prototype._next,c._error=i?function(l){try{i(l)}catch(u){r.error(u)}finally{this.unsubscribe()}}:e.prototype._error,c._complete=o?function(){try{o()}catch(l){r.error(l)}finally{this.unsubscribe()}}:e.prototype._complete,c}return t.prototype.unsubscribe=function(){var r;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){var n=this.closed;e.prototype.unsubscribe.call(this),!n&&((r=this.onFinalize)===null||r===void 0||r.call(this))}},t})(yr);var er={schedule:function(e){var t=requestAnimationFrame,r=cancelAnimationFrame,n=er.delegate;n&&(t=n.requestAnimationFrame,r=n.cancelAnimationFrame);var o=t(function(i){r=void 0,e(i)});return new rt(function(){return r==null?void 0:r(o)})},requestAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.requestAnimationFrame)||requestAnimationFrame).apply(void 0,ne([],te(e)))},cancelAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.cancelAnimationFrame)||cancelAnimationFrame).apply(void 0,ne([],te(e)))},delegate:void 0};var Zo=Jt(function(e){return function(){e(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}});var I=(function(e){ue(t,e);function t(){var r=e.call(this)||this;return r.closed=!1,r.currentObservers=null,r.observers=[],r.isStopped=!1,r.hasError=!1,r.thrownError=null,r}return t.prototype.lift=function(r){var n=new Qo(this,this);return n.operator=r,n},t.prototype._throwIfClosed=function(){if(this.closed)throw new Zo},t.prototype.next=function(r){var n=this;Zt(function(){var o,i;if(n._throwIfClosed(),!n.isStopped){n.currentObservers||(n.currentObservers=Array.from(n.observers));try{for(var a=$e(n.currentObservers),s=a.next();!s.done;s=a.next()){var c=s.value;c.next(r)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}}})},t.prototype.error=function(r){var n=this;Zt(function(){if(n._throwIfClosed(),!n.isStopped){n.hasError=n.isStopped=!0,n.thrownError=r;for(var o=n.observers;o.length;)o.shift().error(r)}})},t.prototype.complete=function(){var r=this;Zt(function(){if(r._throwIfClosed(),!r.isStopped){r.isStopped=!0;for(var n=r.observers;n.length;)n.shift().complete()}})},t.prototype.unsubscribe=function(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null},Object.defineProperty(t.prototype,"observed",{get:function(){var r;return((r=this.observers)===null||r===void 0?void 0:r.length)>0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Pn:(this.currentObservers=null,s.push(r),new rt(function(){n.currentObservers=null,ct(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new Qo(r,n)},t})(U);var Qo=(function(e){ue(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Pn},t})(I);var Un=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n._value=r,n}return Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!1,configurable:!0}),t.prototype._subscribe=function(r){var n=e.prototype._subscribe.call(this,r);return!n.closed&&r.next(this._value),n},t.prototype.getValue=function(){var r=this,n=r.hasError,o=r.thrownError,i=r._value;if(n)throw o;return this._throwIfClosed(),i},t.prototype.next=function(r){e.prototype.next.call(this,this._value=r)},t})(I);var xr={now:function(){return(xr.delegate||Date).now()},delegate:void 0};var wr=(function(e){ue(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=xr);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,c=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+c)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),c=0;c<s.length&&!r.closed;c+=i?1:2)r.next(s[c]);return this._checkFinalizedStatuses(r),n},t.prototype._trimBuffer=function(){var r=this,n=r._bufferSize,o=r._timestampProvider,i=r._buffer,a=r._infiniteTimeWindow,s=(a?1:2)*n;if(n<1/0&&s<i.length&&i.splice(0,i.length-s),!a){for(var c=o.now(),l=0,u=1;u<i.length&&i[u]<=c;u+=2)l=u;l&&i.splice(0,l+1)}},t})(I);var ei=(function(e){ue(t,e);function t(r,n){return e.call(this)||this}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),this},t})(rt);var Er={setInterval:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Er.delegate;return o!=null&&o.setInterval?o.setInterval.apply(o,ne([e,t],te(r))):setInterval.apply(void 0,ne([e,t],te(r)))},clearInterval:function(e){var t=Er.delegate;return((t==null?void 0:t.clearInterval)||clearInterval)(e)},delegate:void 0};var tr=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o.pending=!1,o}return t.prototype.schedule=function(r,n){var o;if(n===void 0&&(n=0),this.closed)return this;this.state=r;var i=this.id,a=this.scheduler;return i!=null&&(this.id=this.recycleAsyncId(a,i,n)),this.pending=!0,this.delay=n,this.id=(o=this.id)!==null&&o!==void 0?o:this.requestAsyncId(a,this.id,n),this},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),Er.setInterval(r.flush.bind(r,this),o)},t.prototype.recycleAsyncId=function(r,n,o){if(o===void 0&&(o=0),o!=null&&this.delay===o&&this.pending===!1)return n;n!=null&&Er.clearInterval(n)},t.prototype.execute=function(r,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;var o=this._execute(r,n);if(o)return o;this.pending===!1&&this.id!=null&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))},t.prototype._execute=function(r,n){var o=!1,i;try{this.work(r)}catch(a){o=!0,i=a||new Error("Scheduled action threw falsy error")}if(o)return this.unsubscribe(),i},t.prototype.unsubscribe=function(){if(!this.closed){var r=this,n=r.id,o=r.scheduler,i=o.actions;this.work=this.state=this.scheduler=null,this.pending=!1,ct(i,this),n!=null&&(this.id=this.recycleAsyncId(o,n,null)),this.delay=null,e.prototype.unsubscribe.call(this)}},t})(ei);var Nn=(function(){function e(t,r){r===void 0&&(r=e.now),this.schedulerActionCtor=t,this.now=r}return e.prototype.schedule=function(t,r,n){return r===void 0&&(r=0),new this.schedulerActionCtor(this,t).schedule(n,r)},e.now=xr.now,e})();var rr=(function(e){ue(t,e);function t(r,n){n===void 0&&(n=Nn.now);var o=e.call(this,r,n)||this;return o.actions=[],o._active=!1,o}return t.prototype.flush=function(r){var n=this.actions;if(this._active){n.push(r);return}var o;this._active=!0;do if(o=r.execute(r.state,r.delay))break;while(r=n.shift());if(this._active=!1,o){for(;r=n.shift();)r.unsubscribe();throw o}},t})(Nn);var ge=new rr(tr),Dn=ge;var ti=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),n>0?e.prototype.schedule.call(this,r,n):(this.delay=n,this.state=r,this.scheduler.flush(this),this)},t.prototype.execute=function(r,n){return n>0||this.closed?e.prototype.execute.call(this,r,n):this._execute(r,n)},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!=null&&o>0||o==null&&this.delay>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.flush(this),0)},t})(tr);var ri=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t})(rr);var Wn=new ri(ti);var ni=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!==null&&o>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=er.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&n===r._scheduled&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(er.cancelAnimationFrame(n),r._scheduled=void 0)},t})(tr);var oi=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n;r?n=r.id:(n=this._scheduled,this._scheduled=void 0);var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t})(rr);var je=new oi(ni);var y=new U(function(e){return e.complete()});function Br(e){return e&&F(e.schedule)}function Vn(e){return e[e.length-1]}function _t(e){return F(Vn(e))?e.pop():void 0}function qe(e){return Br(Vn(e))?e.pop():void 0}function Yr(e,t){return typeof Vn(e)=="number"?e.pop():t}var nr=(function(e){return e&&typeof e.length=="number"&&typeof e!="function"});function Gr(e){return F(e==null?void 0:e.then)}function Jr(e){return F(e[Qt])}function Xr(e){return Symbol.asyncIterator&&F(e==null?void 0:e[Symbol.asyncIterator])}function Zr(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Rc(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qr=Rc();function en(e){return F(e==null?void 0:e[Qr])}function tn(e){return Vo(this,arguments,function(){var r,n,o,i;return Wr(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,kt(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,kt(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,kt(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function rn(e){return F(e==null?void 0:e.getReader)}function q(e){if(e instanceof U)return e;if(e!=null){if(Jr(e))return jc(e);if(nr(e))return Fc(e);if(Gr(e))return Uc(e);if(Xr(e))return ii(e);if(en(e))return Nc(e);if(rn(e))return Dc(e)}throw Zr(e)}function jc(e){return new U(function(t){var r=e[Qt]();if(F(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Fc(e){return new U(function(t){for(var r=0;r<e.length&&!t.closed;r++)t.next(e[r]);t.complete()})}function Uc(e){return new U(function(t){e.then(function(r){t.closed||(t.next(r),t.complete())},function(r){return t.error(r)}).then(null,qr)})}function Nc(e){return new U(function(t){var r,n;try{for(var o=$e(e),i=o.next();!i.done;i=o.next()){var a=i.value;if(t.next(a),t.closed)return}}catch(s){r={error:s}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}t.complete()})}function ii(e){return new U(function(t){Wc(e,t).catch(function(r){return t.error(r)})})}function Dc(e){return ii(tn(e))}function Wc(e,t){var r,n,o,i;return Wo(this,void 0,void 0,function(){var a,s;return Wr(this,function(c){switch(c.label){case 0:c.trys.push([0,5,6,11]),r=zo(e),c.label=1;case 1:return[4,r.next()];case 2:if(n=c.sent(),!!n.done)return[3,4];if(a=n.value,t.next(a),t.closed)return[2];c.label=3;case 3:return[3,1];case 4:return[3,11];case 5:return s=c.sent(),o={error:s},[3,11];case 6:return c.trys.push([6,,9,10]),n&&!n.done&&(i=r.return)?[4,i.call(r)]:[3,8];case 7:c.sent(),c.label=8;case 8:return[3,10];case 9:if(o)throw o.error;return[7];case 10:return[7];case 11:return t.complete(),[2]}})})}function Fe(e,t,r,n,o){n===void 0&&(n=0),o===void 0&&(o=!1);var i=t.schedule(function(){r(),o?e.add(this.schedule(null,n)):this.unsubscribe()},n);if(e.add(i),!o)return i}function Ie(e,t){return t===void 0&&(t=0),S(function(r,n){r.subscribe(T(n,function(o){return Fe(n,e,function(){return n.next(o)},t)},function(){return Fe(n,e,function(){return n.complete()},t)},function(o){return Fe(n,e,function(){return n.error(o)},t)}))})}function Ht(e,t){return t===void 0&&(t=0),S(function(r,n){n.add(e.schedule(function(){return r.subscribe(n)},t))})}function ai(e,t){return q(e).pipe(Ht(t),Ie(t))}function si(e,t){return q(e).pipe(Ht(t),Ie(t))}function ci(e,t){return new U(function(r){var n=0;return t.schedule(function(){n===e.length?r.complete():(r.next(e[n++]),r.closed||this.schedule())})})}function li(e,t){return new U(function(r){var n;return Fe(r,t,function(){n=e[Qr](),Fe(r,t,function(){var o,i,a;try{o=n.next(),i=o.value,a=o.done}catch(s){r.error(s);return}a?r.complete():r.next(i)},0,!0)}),function(){return F(n==null?void 0:n.return)&&n.return()}})}function nn(e,t){if(!e)throw new Error("Iterable cannot be null");return new U(function(r){Fe(r,t,function(){var n=e[Symbol.asyncIterator]();Fe(r,t,function(){n.next().then(function(o){o.done?r.complete():r.next(o.value)})},0,!0)})})}function ui(e,t){return nn(tn(e),t)}function pi(e,t){if(e!=null){if(Jr(e))return ai(e,t);if(nr(e))return ci(e,t);if(Gr(e))return si(e,t);if(Xr(e))return nn(e,t);if(en(e))return li(e,t);if(rn(e))return ui(e,t)}throw Zr(e)}function me(e,t){return t?pi(e,t):q(e)}function Y(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return me(e,r)}function zn(e,t){var r=F(e)?e:function(){return e},n=function(o){return o.error(r())};return new U(t?function(o){return t.schedule(n,0,o)}:n)}var on=Jt(function(e){return function(){e(this),this.name="EmptyError",this.message="no elements in sequence"}});function fi(e){return e instanceof Date&&!isNaN(e)}function f(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){n.next(e.call(t,i,o++))}))})}var Vc=Array.isArray;function zc(e,t){return Vc(t)?e.apply(void 0,ne([],te(t))):e(t)}function yt(e){return f(function(t){return zc(e,t)})}var qc=Array.isArray,Kc=Object.getPrototypeOf,Bc=Object.prototype,Yc=Object.keys;function mi(e){if(e.length===1){var t=e[0];if(qc(t))return{args:t,keys:null};if(Gc(t)){var r=Yc(t);return{args:r.map(function(n){return t[n]}),keys:r}}}return{args:e,keys:null}}function Gc(e){return e&&typeof e=="object"&&Kc(e)===Bc}function di(e,t){return e.reduce(function(r,n,o){return r[n]=t[o],r},{})}function re(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=_t(e),o=mi(e),i=o.args,a=o.keys;if(i.length===0)return me([],r);var s=new U(qn(i,r,a?function(c){return di(a,c)}:Oe));return n?s.pipe(yt(n)):s}function qn(e,t,r){return r===void 0&&(r=Oe),function(n){hi(t,function(){for(var o=e.length,i=new Array(o),a=o,s=o,c=function(u){hi(t,function(){var p=me(e[u],t),d=!1;p.subscribe(T(n,function(m){i[u]=m,d||(d=!0,s--),s||n.next(r(i.slice()))},function(){--a||n.complete()}))},n)},l=0;l<o;l++)c(l)},n)}}function hi(e,t,r){e?Fe(r,e,t):t()}function vi(e,t,r,n,o,i,a,s){var c=[],l=0,u=0,p=!1,d=function(){p&&!c.length&&!l&&t.complete()},m=function(v){return l<n?h(v):c.push(v)},h=function(v){i&&t.next(v),l++;var x=!1;q(r(v,u++)).subscribe(T(t,function(w){o==null||o(w),i?m(w):t.next(w)},function(){x=!0},void 0,function(){if(x)try{l--;for(var w=function(){var E=c.shift();a?Fe(t,a,function(){return h(E)}):h(E)};c.length&&l<n;)w();d()}catch(E){t.error(E)}}))};return e.subscribe(T(t,m,function(){p=!0,d()})),function(){s==null||s()}}function oe(e,t,r){return r===void 0&&(r=1/0),F(t)?oe(function(n,o){return f(function(i,a){return t(n,i,o,a)})(q(e(n,o)))},r):(typeof t=="number"&&(r=t),S(function(n,o){return vi(n,o,e,r)}))}function or(e){return e===void 0&&(e=1/0),oe(Oe,e)}function bi(){return or(1)}function nt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return bi()(me(e,qe(e)))}function j(e){return new U(function(t){q(e()).subscribe(t)})}var Jc=["addListener","removeListener"],Xc=["addEventListener","removeEventListener"],Zc=["on","off"];function b(e,t,r,n){if(F(r)&&(n=r,r=void 0),n)return b(e,t,r).pipe(yt(n));var o=te(tl(e)?Xc.map(function(s){return function(c){return e[s](t,c,r)}}):Qc(e)?Jc.map(gi(e,t)):el(e)?Zc.map(gi(e,t)):[],2),i=o[0],a=o[1];if(!i&&nr(e))return oe(function(s){return b(s,t,r)})(q(e));if(!i)throw new TypeError("Invalid event target");return new U(function(s){var c=function(){for(var l=[],u=0;u<arguments.length;u++)l[u]=arguments[u];return s.next(1<l.length?l:l[0])};return i(c),function(){return a(c)}})}function gi(e,t){return function(r){return function(n){return e[r](t,n)}}}function Qc(e){return F(e.addListener)&&F(e.removeListener)}function el(e){return F(e.on)&&F(e.off)}function tl(e){return F(e.addEventListener)&&F(e.removeEventListener)}function an(e,t,r){return r?an(e,t).pipe(yt(r)):new U(function(n){var o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];return n.next(a.length===1?a[0]:a)},i=e(o);return F(t)?function(){return t(o,i)}:void 0})}function Ve(e,t,r){e===void 0&&(e=0),r===void 0&&(r=Dn);var n=-1;return t!=null&&(Br(t)?r=t:n=t),new U(function(o){var i=fi(e)?+e-r.now():e;i<0&&(i=0);var a=0;return r.schedule(function(){o.closed||(o.next(a++),0<=n?this.schedule(void 0,n):o.complete())},i)})}function R(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0),o=e;return o.length?o.length===1?q(o[0]):or(n)(me(o,r)):y}var Ke=new U(Pe);var rl=Array.isArray;function sn(e){return e.length===1&&rl(e[0])?e[0]:e}function L(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){return e.call(t,i,o++)&&n.next(i)}))})}function $t(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e),n=sn(e);return n.length?new U(function(o){var i=n.map(function(){return[]}),a=n.map(function(){return!1});o.add(function(){i=a=null});for(var s=function(l){q(n[l]).subscribe(T(o,function(u){if(i[l].push(u),i.every(function(d){return d.length})){var p=i.map(function(d){return d.shift()});o.next(r?r.apply(void 0,ne([],te(p))):p),i.some(function(d,m){return!d.length&&a[m]})&&o.complete()}},function(){a[l]=!0,!i[l].length&&o.complete()}))},c=0;!o.closed&&c<n.length;c++)s(c);return function(){i=a=null}}):y}function _i(e){return S(function(t,r){var n=!1,o=null,i=null,a=!1,s=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var l=o;o=null,r.next(l)}a&&r.complete()},c=function(){i=null,a&&r.complete()};t.subscribe(T(r,function(l){n=!0,o=l,i||q(e(l)).subscribe(i=T(r,s,c))},function(){a=!0,(!n||!i||i.closed)&&r.complete()}))})}function Xe(e,t){return t===void 0&&(t=ge),_i(function(){return Ve(e,t)})}function Pt(e,t){return t===void 0&&(t=null),t=t!=null?t:e,S(function(r,n){var o=[],i=0;r.subscribe(T(n,function(a){var s,c,l,u,p=null;i++%t===0&&o.push([]);try{for(var d=$e(o),m=d.next();!m.done;m=d.next()){var h=m.value;h.push(a),e<=h.length&&(p=p!=null?p:[],p.push(h))}}catch(w){s={error:w}}finally{try{m&&!m.done&&(c=d.return)&&c.call(d)}finally{if(s)throw s.error}}if(p)try{for(var v=$e(p),x=v.next();!x.done;x=v.next()){var h=x.value;ct(o,h),n.next(h)}}catch(w){l={error:w}}finally{try{x&&!x.done&&(u=v.return)&&u.call(v)}finally{if(l)throw l.error}}},function(){var a,s;try{for(var c=$e(o),l=c.next();!l.done;l=c.next()){var u=l.value;n.next(u)}}catch(p){a={error:p}}finally{try{l&&!l.done&&(s=c.return)&&s.call(c)}finally{if(a)throw a.error}}n.complete()},void 0,function(){o=null}))})}function _e(e){return S(function(t,r){var n=null,o=!1,i;n=t.subscribe(T(r,void 0,void 0,function(a){i=q(e(a,_e(e)(t))),n?(n.unsubscribe(),n=null,i.subscribe(r)):o=!0})),o&&(n.unsubscribe(),n=null,i.subscribe(r))})}function yi(e,t,r,n,o){return function(i,a){var s=r,c=t,l=0;i.subscribe(T(a,function(u){var p=l++;c=s?e(c,u,p):(s=!0,u),n&&a.next(c)},o&&(function(){s&&a.next(c),a.complete()})))}}function Kn(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return r?Jo(Kn.apply(void 0,ne([],te(e))),yt(r)):S(function(n,o){qn(ne([n],te(sn(e))))(o)})}function Ze(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Kn.apply(void 0,ne([],te(e)))}function Tr(e){return S(function(t,r){var n=!1,o=null,i=null,a=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var s=o;o=null,r.next(s)}};t.subscribe(T(r,function(s){i==null||i.unsubscribe(),n=!0,o=s,i=T(r,a,Pe),q(e(s)).subscribe(i)},function(){a(),r.complete()},void 0,function(){o=i=null}))})}function Be(e,t){return t===void 0&&(t=ge),S(function(r,n){var o=null,i=null,a=null,s=function(){if(o){o.unsubscribe(),o=null;var l=i;i=null,n.next(l)}};function c(){var l=a+e,u=t.now();if(u<l){o=this.schedule(void 0,l-u),n.add(o);return}s()}r.subscribe(T(n,function(l){i=l,a=t.now(),o||(o=t.schedule(c,e),n.add(o))},function(){s(),n.complete()},void 0,function(){i=o=null}))})}function ot(e){return S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){n||r.next(e),r.complete()}))})}function Me(e){return e<=0?function(){return y}:S(function(t,r){var n=0;t.subscribe(T(r,function(o){++n<=e&&(r.next(o),e<=n&&r.complete())}))})}function he(){return S(function(e,t){e.subscribe(T(t,Pe))})}function xi(e){return f(function(){return e})}function Bn(e,t){return t?function(r){return nt(t.pipe(Me(1),he()),r.pipe(Bn(e)))}:oe(function(r,n){return q(e(r,n)).pipe(Me(1),xi(r))})}function It(e,t){t===void 0&&(t=ge);var r=Ve(e,t);return Bn(function(){return r})}function Yn(e,t){return S(function(r,n){var o=new Set;r.subscribe(T(n,function(i){var a=e?e(i):i;o.has(a)||(o.add(a),n.next(i))})),t&&q(t).subscribe(T(n,function(){return o.clear()},Pe))})}function ie(e,t){return t===void 0&&(t=Oe),e=e!=null?e:nl,S(function(r,n){var o,i=!0;r.subscribe(T(n,function(a){var s=t(a);(i||!e(o,s))&&(i=!1,o=s,n.next(a))}))})}function nl(e,t){return e===t}function fe(e,t){return ie(function(r,n){return t?t(r[e],n[e]):r[e]===n[e]})}function wi(e){return e===void 0&&(e=ol),S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){return n?r.complete():r.error(e())}))})}function ol(){return new on}function ye(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return function(r){return nt(r,Y.apply(void 0,ne([],te(e))))}}function cn(e,t){return t?function(r){return r.pipe(cn(function(n,o){return q(e(n,o)).pipe(f(function(i,a){return t(n,i,o,a)}))}))}:S(function(r,n){var o=0,i=null,a=!1;r.subscribe(T(n,function(s){i||(i=T(n,void 0,function(){i=null,a&&n.complete()}),q(e(s,o++)).subscribe(i))},function(){a=!0,!i&&n.complete()}))})}function V(e){return S(function(t,r){try{t.subscribe(r)}finally{r.add(e)}})}function Sr(e,t){var r=arguments.length>=2;return function(n){return n.pipe(e?L(function(o,i){return e(o,i,n)}):Oe,Me(1),r?ot(t):wi(function(){return new on}))}}function Gn(e){return e<=0?function(){return y}:S(function(t,r){var n=[];t.subscribe(T(r,function(o){n.push(o),e<n.length&&n.shift()},function(){var o,i;try{for(var a=$e(n),s=a.next();!s.done;s=a.next()){var c=s.value;r.next(c)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}r.complete()},void 0,function(){n=null}))})}function Ei(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0);return S(function(o,i){or(n)(me(ne([o],te(e)),r)).subscribe(i)})}function Rt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Ei.apply(void 0,ne([],te(e)))}function jt(e){var t,r=1/0,n;return e!=null&&(typeof e=="object"?(t=e.count,r=t===void 0?1/0:t,n=e.delay):r=e),r<=0?function(){return y}:S(function(o,i){var a=0,s,c=function(){if(s==null||s.unsubscribe(),s=null,n!=null){var u=typeof n=="number"?Ve(n):q(n(a)),p=T(i,function(){p.unsubscribe(),l()});u.subscribe(p)}else l()},l=function(){var u=!1;s=o.subscribe(T(i,void 0,function(){++a<r?s?c():u=!0:i.complete()})),u&&c()};l()})}function Or(e,t){return S(yi(e,t,arguments.length>=2,!0))}function xe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new I}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,c=s===void 0?!0:s;return function(l){var u,p,d,m=0,h=!1,v=!1,x=function(){p==null||p.unsubscribe(),p=void 0},w=function(){x(),u=d=void 0,h=v=!1},E=function(){var _=u;w(),_==null||_.unsubscribe()};return S(function(_,de){m++,!v&&!h&&x();var be=d=d!=null?d:r();de.add(function(){m--,m===0&&!v&&!h&&(p=Jn(E,c))}),be.subscribe(de),!u&&m>0&&(u=new Ct({next:function(M){return be.next(M)},error:function(M){v=!0,x(),p=Jn(w,o,M),be.error(M)},complete:function(){h=!0,x(),p=Jn(w,a),be.complete()}}),q(_).subscribe(u))})(l)}}function Jn(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];if(t===!0){e();return}if(t!==!1){var o=new Ct({next:function(){o.unsubscribe(),e()}});return q(t.apply(void 0,ne([],te(r)))).subscribe(o)}}function se(e,t,r){var n,o,i,a,s=!1;return e&&typeof e=="object"?(n=e.bufferSize,a=n===void 0?1/0:n,o=e.windowTime,t=o===void 0?1/0:o,i=e.refCount,s=i===void 0?!1:i,r=e.scheduler):a=e!=null?e:1/0,xe({connector:function(){return new wr(a,t,r)},resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:s})}function ke(e){return L(function(t,r){return e<=r})}function J(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return S(function(n,o){(r?nt(e,n,r):nt(e,n)).subscribe(o)})}function g(e,t){return S(function(r,n){var o=null,i=0,a=!1,s=function(){return a&&!o&&n.complete()};r.subscribe(T(n,function(c){o==null||o.unsubscribe();var l=0,u=i++;q(e(c,u)).subscribe(o=T(n,function(p){return n.next(t?t(c,p,u,l++):p)},function(){o=null,s()}))},function(){a=!0,s()}))})}function Q(e){return S(function(t,r){q(e).subscribe(T(r,function(){return r.complete()},Pe)),!r.closed&&t.subscribe(r)})}function Xn(e,t){return t===void 0&&(t=!1),S(function(r,n){var o=0;r.subscribe(T(n,function(i){var a=e(i,o++);(a||t)&&n.next(i),!a&&n.complete()}))})}function $(e,t,r){var n=F(e)||t||r?{next:e,error:t,complete:r}:e;return n?S(function(o,i){var a;(a=n.subscribe)===null||a===void 0||a.call(n);var s=!0;o.subscribe(T(i,function(c){var l;(l=n.next)===null||l===void 0||l.call(n,c),i.next(c)},function(){var c;s=!1,(c=n.complete)===null||c===void 0||c.call(n),i.complete()},function(c){var l;s=!1,(l=n.error)===null||l===void 0||l.call(n,c),i.error(c)},function(){var c,l;s&&((c=n.unsubscribe)===null||c===void 0||c.call(n)),(l=n.finalize)===null||l===void 0||l.call(n)}))}):Oe}function Ti(e,t){return S(function(r,n){var o=t!=null?t:{},i=o.leading,a=i===void 0?!0:i,s=o.trailing,c=s===void 0?!1:s,l=!1,u=null,p=null,d=!1,m=function(){p==null||p.unsubscribe(),p=null,c&&(x(),d&&n.complete())},h=function(){p=null,d&&n.complete()},v=function(w){return p=q(e(w)).subscribe(T(n,m,h))},x=function(){if(l){l=!1;var w=u;u=null,n.next(w),!d&&v(w)}};r.subscribe(T(n,function(w){l=!0,u=w,!(p&&!p.closed)&&(a?x():v(w))},function(){d=!0,!(c&&l&&p&&!p.closed)&&n.complete()}))})}function Lr(e,t,r){t===void 0&&(t=ge);var n=Ve(e,t);return Ti(function(){return n},r)}function pe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return S(function(n,o){for(var i=e.length,a=new Array(i),s=e.map(function(){return!1}),c=!1,l=function(p){q(e[p]).subscribe(T(o,function(d){a[p]=d,!c&&!s[p]&&(s[p]=!0,(c=s.every(Oe))&&(s=null))},Pe))},u=0;u<i;u++)l(u);n.subscribe(T(o,function(p){if(c){var d=ne([p],te(a));o.next(r?r.apply(void 0,ne([],te(d))):d)}}))})}function Si(){let e=new wr(1);return b(document,"DOMContentLoaded",{once:!0}).subscribe(()=>e.next(document)),e}function P(e,t=document){return Array.from(t.querySelectorAll(e))}function G(e,t=document){let r=Le(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function Le(e,t=document){return t.querySelector(e)||void 0}function xt(){var e,t,r,n;return(n=(r=(t=(e=document.activeElement)==null?void 0:e.shadowRoot)==null?void 0:t.activeElement)!=null?r:document.activeElement)!=null?n:void 0}var il=R(b(document.body,"focusin"),b(document.body,"focusout")).pipe(Be(1),J(void 0),f(()=>xt()||document.body),se(1));function ir(e){return il.pipe(f(t=>e.contains(t)),ie())}function Ft(e,t){let{matches:r}=matchMedia("(hover)");return j(()=>(r?R(b(e,"mouseenter").pipe(f(()=>!0)),b(e,"mouseleave").pipe(f(()=>!1))):R(b(e,"touchstart").pipe(f(()=>!0)),b(e,"touchend").pipe(f(()=>!1)),b(e,"touchcancel").pipe(f(()=>!1)))).pipe(t?Tr(o=>Ve(+!o*t)):Oe,J(!0,e.matches(":hover"))))}function Oi(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)Oi(e,r)}function A(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)Oi(n,o);return n}function Li(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function ar(e){let t=A("script",{src:e});return j(()=>(document.head.appendChild(t),R(b(t,"load"),b(t,"error").pipe(g(()=>zn(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(f(()=>{}),V(()=>document.head.removeChild(t)),Me(1))))}var Mi=new I,al=j(()=>typeof ResizeObserver=="undefined"?ar("https://unpkg.com/resize-observer-polyfill"):Y(void 0)).pipe(f(()=>new ResizeObserver(e=>e.forEach(t=>Mi.next(t)))),g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Ae(e){return{width:e.offsetWidth,height:e.offsetHeight}}function Re(e){let t=e;for(;t.clientWidth===0&&t.parentElement;)t=t.parentElement;return al.pipe($(r=>r.observe(t)),g(r=>Mi.pipe(L(n=>n.target===t),V(()=>r.unobserve(t)))),f(()=>Ae(e)),J(Ae(e)))}function Mr(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ki(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}function Ai(e){let t=[],r=e.parentElement;for(;r;)(e.clientWidth>r.clientWidth||e.clientHeight>r.clientHeight)&&t.push(r),r=(e=r).parentElement;return t.length===0&&t.push(document.documentElement),t}function wt(e){return{x:e.offsetLeft,y:e.offsetTop}}function Ci(e){let t=e.getBoundingClientRect();return{x:t.x+window.scrollX,y:t.y+window.scrollY}}function Hi(e){return R(b(window,"load"),b(window,"resize")).pipe(Xe(0,je),f(()=>wt(e)),J(wt(e)))}function ln(e){return{x:e.scrollLeft,y:e.scrollTop}}function Ut(e){return R(b(e,"scroll"),b(window,"scroll"),b(window,"resize")).pipe(Xe(0,je),f(()=>ln(e)),J(ln(e)))}var $i=new I,sl=j(()=>Y(new IntersectionObserver(e=>{for(let t of e)$i.next(t)},{threshold:0}))).pipe(g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Et(e){return sl.pipe($(t=>t.observe(e)),g(t=>$i.pipe(L(({target:r})=>r===e),V(()=>t.unobserve(e)),f(({isIntersecting:r})=>r))))}var cl=Object.create,la=Object.defineProperty,ll=Object.getOwnPropertyDescriptor,ul=Object.getOwnPropertyNames,pl=Object.getPrototypeOf,fl=Object.prototype.hasOwnProperty,ml=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),dl=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of ul(t))!fl.call(e,o)&&o!==r&&la(e,o,{get:()=>t[o],enumerable:!(n=ll(t,o))||n.enumerable});return e},hl=(e,t,r)=>(r=e!=null?cl(pl(e)):{},dl(t||!e||!e.__esModule?la(r,"default",{value:e,enumerable:!0}):r,e)),vl=ml((e,t)=>{var r="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,c=/^0o[0-7]+$/i,l=parseInt,u=typeof global=="object"&&global&&global.Object===Object&&global,p=typeof self=="object"&&self&&self.Object===Object&&self,d=u||p||Function("return this")(),m=Object.prototype,h=m.toString,v=Math.max,x=Math.min,w=function(){return d.Date.now()};function E(O,N,ee){var le,ce,Ne,bt,De,st,tt=0,Yt=!1,Mt=!1,vr=!0;if(typeof O!="function")throw new TypeError(r);N=M(N)||0,_(ee)&&(Yt=!!ee.leading,Mt="maxWait"in ee,Ne=Mt?v(M(ee.maxWait)||0,N):Ne,vr="trailing"in ee?!!ee.trailing:vr);function B(Te){var gt=le,br=ce;return le=ce=void 0,tt=Te,bt=O.apply(br,gt),bt}function C(Te){return tt=Te,De=setTimeout(W,N),Yt?B(Te):bt}function k(Te){var gt=Te-st,br=Te-tt,Ro=N-gt;return Mt?x(Ro,Ne-br):Ro}function D(Te){var gt=Te-st,br=Te-tt;return st===void 0||gt>=N||gt<0||Mt&&br>=Ne}function W(){var Te=w();if(D(Te))return Z(Te);De=setTimeout(W,k(Te))}function Z(Te){return De=void 0,vr&&le?B(Te):(le=ce=void 0,bt)}function We(){De!==void 0&&clearTimeout(De),tt=0,le=st=ce=De=void 0}function Gt(){return De===void 0?bt:Z(w())}function Nr(){var Te=w(),gt=D(Te);if(le=arguments,ce=this,st=Te,gt){if(De===void 0)return C(st);if(Mt)return De=setTimeout(W,N),B(st)}return De===void 0&&(De=setTimeout(W,N)),bt}return Nr.cancel=We,Nr.flush=Gt,Nr}function _(O){var N=typeof O;return!!O&&(N=="object"||N=="function")}function de(O){return!!O&&typeof O=="object"}function be(O){return typeof O=="symbol"||de(O)&&h.call(O)==o}function M(O){if(typeof O=="number")return O;if(be(O))return n;if(_(O)){var N=typeof O.valueOf=="function"?O.valueOf():O;O=_(N)?N+"":N}if(typeof O!="string")return O===0?O:+O;O=O.replace(i,"");var ee=s.test(O);return ee||c.test(O)?l(O.slice(2),ee?2:8):a.test(O)?n:+O}t.exports=E}),yn,K,ua,pa,Nt,Pi,fa,ma,da,lo,to,ro,bl,Ar={},ha=[],gl=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Pr=Array.isArray;function pt(e,t){for(var r in t)e[r]=t[r];return e}function uo(e){e&&e.parentNode&&e.parentNode.removeChild(e)}function Wt(e,t,r){var n,o,i,a={};for(i in t)i=="key"?n=t[i]:i=="ref"?o=t[i]:a[i]=t[i];if(arguments.length>2&&(a.children=arguments.length>3?yn.call(arguments,2):r),typeof e=="function"&&e.defaultProps!=null)for(i in e.defaultProps)a[i]===void 0&&(a[i]=e.defaultProps[i]);return fn(e,a,n,o,null)}function fn(e,t,r,n,o){var i={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:o!=null?o:++ua,__i:-1,__u:0};return o==null&&K.vnode!=null&&K.vnode(i),i}function ft(e){return e.children}function at(e,t){this.props=e,this.context=t}function cr(e,t){if(t==null)return e.__?cr(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null)return r.__e;return typeof e.type=="function"?cr(e):null}function va(e){var t,r;if((e=e.__)!=null&&e.__c!=null){for(e.__e=e.__c.base=null,t=0;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null){e.__e=e.__c.base=r.__e;break}return va(e)}}function Ii(e){(!e.__d&&(e.__d=!0)&&Nt.push(e)&&!vn.__r++||Pi!=K.debounceRendering)&&((Pi=K.debounceRendering)||fa)(vn)}function vn(){for(var e,t,r,n,o,i,a,s=1;Nt.length;)Nt.length>s&&Nt.sort(ma),e=Nt.shift(),s=Nt.length,e.__d&&(r=void 0,n=void 0,o=(n=(t=e).__v).__e,i=[],a=[],t.__P&&((r=pt({},n)).__v=n.__v+1,K.vnode&&K.vnode(r),po(t.__P,r,n,t.__n,t.__P.namespaceURI,32&n.__u?[o]:null,i,o!=null?o:cr(n),!!(32&n.__u),a),r.__v=n.__v,r.__.__k[r.__i]=r,_a(i,r,a),n.__e=n.__=null,r.__e!=o&&va(r)));vn.__r=0}function ba(e,t,r,n,o,i,a,s,c,l,u){var p,d,m,h,v,x,w,E=n&&n.__k||ha,_=t.length;for(c=_l(r,t,E,c,_),p=0;p<_;p++)(m=r.__k[p])!=null&&(d=m.__i==-1?Ar:E[m.__i]||Ar,m.__i=p,x=po(e,m,d,o,i,a,s,c,l,u),h=m.__e,m.ref&&d.ref!=m.ref&&(d.ref&&fo(d.ref,null,m),u.push(m.ref,m.__c||h,m)),v==null&&h!=null&&(v=h),(w=!!(4&m.__u))||d.__k===m.__k?c=ga(m,c,e,w):typeof m.type=="function"&&x!==void 0?c=x:h&&(c=h.nextSibling),m.__u&=-7);return r.__e=v,c}function _l(e,t,r,n,o){var i,a,s,c,l,u=r.length,p=u,d=0;for(e.__k=new Array(o),i=0;i<o;i++)(a=t[i])!=null&&typeof a!="boolean"&&typeof a!="function"?(c=i+d,(a=e.__k[i]=typeof a=="string"||typeof a=="number"||typeof a=="bigint"||a.constructor==String?fn(null,a,null,null,null):Pr(a)?fn(ft,{children:a},null,null,null):a.constructor==null&&a.__b>0?fn(a.type,a.props,a.key,a.ref?a.ref:null,a.__v):a).__=e,a.__b=e.__b+1,s=null,(l=a.__i=yl(a,r,c,p))!=-1&&(p--,(s=r[l])&&(s.__u|=2)),s==null||s.__v==null?(l==-1&&(o>u?d--:o<u&&d++),typeof a.type!="function"&&(a.__u|=4)):l!=c&&(l==c-1?d--:l==c+1?d++:(l>c?d--:d++,a.__u|=4))):e.__k[i]=null;if(p)for(i=0;i<u;i++)(s=r[i])!=null&&!(2&s.__u)&&(s.__e==n&&(n=cr(s)),xa(s,s));return n}function ga(e,t,r,n){var o,i;if(typeof e.type=="function"){for(o=e.__k,i=0;o&&i<o.length;i++)o[i]&&(o[i].__=e,t=ga(o[i],t,r,n));return t}e.__e!=t&&(n&&(t&&e.type&&!t.parentNode&&(t=cr(e)),r.insertBefore(e.__e,t||null)),t=e.__e);do t=t&&t.nextSibling;while(t!=null&&t.nodeType==8);return t}function Cr(e,t){return t=t||[],e==null||typeof e=="boolean"||(Pr(e)?e.some(function(r){Cr(r,t)}):t.push(e)),t}function yl(e,t,r,n){var o,i,a,s=e.key,c=e.type,l=t[r],u=l!=null&&(2&l.__u)==0;if(l===null&&e.key==null||u&&s==l.key&&c==l.type)return r;if(n>(u?1:0)){for(o=r-1,i=r+1;o>=0||i<t.length;)if((l=t[a=o>=0?o--:i++])!=null&&!(2&l.__u)&&s==l.key&&c==l.type)return a}return-1}function Ri(e,t,r){t[0]=="-"?e.setProperty(t,r!=null?r:""):e[t]=r==null?"":typeof r!="number"||gl.test(t)?r:r+"px"}function un(e,t,r,n,o){var i,a;e:if(t=="style")if(typeof r=="string")e.style.cssText=r;else{if(typeof n=="string"&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||Ri(e.style,t,"");if(r)for(t in r)n&&r[t]==n[t]||Ri(e.style,t,r[t])}else if(t[0]=="o"&&t[1]=="n")i=t!=(t=t.replace(da,"$1")),a=t.toLowerCase(),t=a in e||t=="onFocusOut"||t=="onFocusIn"?a.slice(2):t.slice(2),e.l||(e.l={}),e.l[t+i]=r,r?n?r.u=n.u:(r.u=lo,e.addEventListener(t,i?ro:to,i)):e.removeEventListener(t,i?ro:to,i);else{if(o=="http://www.w3.org/2000/svg")t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(t!="width"&&t!="height"&&t!="href"&&t!="list"&&t!="form"&&t!="tabIndex"&&t!="download"&&t!="rowSpan"&&t!="colSpan"&&t!="role"&&t!="popover"&&t in e)try{e[t]=r!=null?r:"";break e}catch(s){}typeof r=="function"||(r==null||r===!1&&t[4]!="-"?e.removeAttribute(t):e.setAttribute(t,t=="popover"&&r==1?"":r))}}function ji(e){return function(t){if(this.l){var r=this.l[t.type+e];if(t.t==null)t.t=lo++;else if(t.t<r.u)return;return r(K.event?K.event(t):t)}}}function po(e,t,r,n,o,i,a,s,c,l){var u,p,d,m,h,v,x,w,E,_,de,be,M,O,N,ee,le,ce=t.type;if(t.constructor!=null)return null;128&r.__u&&(c=!!(32&r.__u),i=[s=t.__e=r.__e]),(u=K.__b)&&u(t);e:if(typeof ce=="function")try{if(w=t.props,E="prototype"in ce&&ce.prototype.render,_=(u=ce.contextType)&&n[u.__c],de=u?_?_.props.value:u.__:n,r.__c?x=(p=t.__c=r.__c).__=p.__E:(E?t.__c=p=new ce(w,de):(t.__c=p=new at(w,de),p.constructor=ce,p.render=wl),_&&_.sub(p),p.props=w,p.state||(p.state={}),p.context=de,p.__n=n,d=p.__d=!0,p.__h=[],p._sb=[]),E&&p.__s==null&&(p.__s=p.state),E&&ce.getDerivedStateFromProps!=null&&(p.__s==p.state&&(p.__s=pt({},p.__s)),pt(p.__s,ce.getDerivedStateFromProps(w,p.__s))),m=p.props,h=p.state,p.__v=t,d)E&&ce.getDerivedStateFromProps==null&&p.componentWillMount!=null&&p.componentWillMount(),E&&p.componentDidMount!=null&&p.__h.push(p.componentDidMount);else{if(E&&ce.getDerivedStateFromProps==null&&w!==m&&p.componentWillReceiveProps!=null&&p.componentWillReceiveProps(w,de),!p.__e&&p.shouldComponentUpdate!=null&&p.shouldComponentUpdate(w,p.__s,de)===!1||t.__v==r.__v){for(t.__v!=r.__v&&(p.props=w,p.state=p.__s,p.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.some(function(Ne){Ne&&(Ne.__=t)}),be=0;be<p._sb.length;be++)p.__h.push(p._sb[be]);p._sb=[],p.__h.length&&a.push(p);break e}p.componentWillUpdate!=null&&p.componentWillUpdate(w,p.__s,de),E&&p.componentDidUpdate!=null&&p.__h.push(function(){p.componentDidUpdate(m,h,v)})}if(p.context=de,p.props=w,p.__P=e,p.__e=!1,M=K.__r,O=0,E){for(p.state=p.__s,p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),N=0;N<p._sb.length;N++)p.__h.push(p._sb[N]);p._sb=[]}else do p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),p.state=p.__s;while(p.__d&&++O<25);p.state=p.__s,p.getChildContext!=null&&(n=pt(pt({},n),p.getChildContext())),E&&!d&&p.getSnapshotBeforeUpdate!=null&&(v=p.getSnapshotBeforeUpdate(m,h)),ee=u,u!=null&&u.type===ft&&u.key==null&&(ee=ya(u.props.children)),s=ba(e,Pr(ee)?ee:[ee],t,r,n,o,i,a,s,c,l),p.base=t.__e,t.__u&=-161,p.__h.length&&a.push(p),x&&(p.__E=p.__=null)}catch(Ne){if(t.__v=null,c||i!=null)if(Ne.then){for(t.__u|=c?160:128;s&&s.nodeType==8&&s.nextSibling;)s=s.nextSibling;i[i.indexOf(s)]=null,t.__e=s}else{for(le=i.length;le--;)uo(i[le]);no(t)}else t.__e=r.__e,t.__k=r.__k,Ne.then||no(t);K.__e(Ne,t,r)}else i==null&&t.__v==r.__v?(t.__k=r.__k,t.__e=r.__e):s=t.__e=xl(r.__e,t,r,n,o,i,a,c,l);return(u=K.diffed)&&u(t),128&t.__u?void 0:s}function no(e){e&&e.__c&&(e.__c.__e=!0),e&&e.__k&&e.__k.forEach(no)}function _a(e,t,r){for(var n=0;n<r.length;n++)fo(r[n],r[++n],r[++n]);K.__c&&K.__c(t,e),e.some(function(o){try{e=o.__h,o.__h=[],e.some(function(i){i.call(o)})}catch(i){K.__e(i,o.__v)}})}function ya(e){return typeof e!="object"||e==null||e.__b&&e.__b>0?e:Pr(e)?e.map(ya):pt({},e)}function xl(e,t,r,n,o,i,a,s,c){var l,u,p,d,m,h,v,x=r.props,w=t.props,E=t.type;if(E=="svg"?o="http://www.w3.org/2000/svg":E=="math"?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),i!=null){for(l=0;l<i.length;l++)if((m=i[l])&&"setAttribute"in m==!!E&&(E?m.localName==E:m.nodeType==3)){e=m,i[l]=null;break}}if(e==null){if(E==null)return document.createTextNode(w);e=document.createElementNS(o,E,w.is&&w),s&&(K.__m&&K.__m(t,i),s=!1),i=null}if(E==null)x===w||s&&e.data==w||(e.data=w);else{if(i=i&&yn.call(e.childNodes),x=r.props||Ar,!s&&i!=null)for(x={},l=0;l<e.attributes.length;l++)x[(m=e.attributes[l]).name]=m.value;for(l in x)if(m=x[l],l!="children"){if(l=="dangerouslySetInnerHTML")p=m;else if(!(l in w)){if(l=="value"&&"defaultValue"in w||l=="checked"&&"defaultChecked"in w)continue;un(e,l,null,m,o)}}for(l in w)m=w[l],l=="children"?d=m:l=="dangerouslySetInnerHTML"?u=m:l=="value"?h=m:l=="checked"?v=m:s&&typeof m!="function"||x[l]===m||un(e,l,m,x[l],o);if(u)s||p&&(u.__html==p.__html||u.__html==e.innerHTML)||(e.innerHTML=u.__html),t.__k=[];else if(p&&(e.innerHTML=""),ba(t.type=="template"?e.content:e,Pr(d)?d:[d],t,r,n,E=="foreignObject"?"http://www.w3.org/1999/xhtml":o,i,a,i?i[0]:r.__k&&cr(r,0),s,c),i!=null)for(l=i.length;l--;)uo(i[l]);s||(l="value",E=="progress"&&h==null?e.removeAttribute("value"):h!=null&&(h!==e[l]||E=="progress"&&!h||E=="option"&&h!=x[l])&&un(e,l,h,x[l],o),l="checked",v!=null&&v!=e[l]&&un(e,l,v,x[l],o))}return e}function fo(e,t,r){try{if(typeof e=="function"){var n=typeof e.__u=="function";n&&e.__u(),n&&t==null||(e.__u=e(t))}else e.current=t}catch(o){K.__e(o,r)}}function xa(e,t,r){var n,o;if(K.unmount&&K.unmount(e),(n=e.ref)&&(n.current&&n.current!=e.__e||fo(n,null,t)),(n=e.__c)!=null){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(i){K.__e(i,t)}n.base=n.__P=null}if(n=e.__k)for(o=0;o<n.length;o++)n[o]&&xa(n[o],t,r||typeof e.type!="function");r||uo(e.__e),e.__c=e.__=e.__e=void 0}function wl(e,t,r){return this.constructor(e,r)}function El(e,t,r){var n,o,i,a;t==document&&(t=document.documentElement),K.__&&K.__(e,t),o=(n=typeof r=="function")?null:r&&r.__k||t.__k,i=[],a=[],po(t,e=(!n&&r||t).__k=Wt(ft,null,[e]),o||Ar,Ar,t.namespaceURI,!n&&r?[r]:o?null:t.firstChild?yn.call(t.childNodes):null,i,!n&&r?r:o?o.__e:t.firstChild,n,a),_a(i,e,a)}yn=ha.slice,K={__e:function(e,t,r,n){for(var o,i,a;t=t.__;)if((o=t.__c)&&!o.__)try{if((i=o.constructor)&&i.getDerivedStateFromError!=null&&(o.setState(i.getDerivedStateFromError(e)),a=o.__d),o.componentDidCatch!=null&&(o.componentDidCatch(e,n||{}),a=o.__d),a)return o.__E=o}catch(s){e=s}throw e}},ua=0,pa=function(e){return e!=null&&e.constructor==null},at.prototype.setState=function(e,t){var r;r=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=pt({},this.state),typeof e=="function"&&(e=e(pt({},r),this.props)),e&&pt(r,e),e!=null&&this.__v&&(t&&this._sb.push(t),Ii(this))},at.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),Ii(this))},at.prototype.render=ft,Nt=[],fa=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,ma=function(e,t){return e.__v.__b-t.__v.__b},vn.__r=0,da=/(PointerCapture)$|Capture$/i,lo=0,to=ji(!1),ro=ji(!0),bl=0;var Hr,ve,Zn,Fi,$r=0,wa=[],we=K,Ui=we.__b,Ni=we.__r,Di=we.diffed,Wi=we.__c,Vi=we.unmount,zi=we.__;function mo(e,t){we.__h&&we.__h(ve,e,$r||t),$r=0;var r=ve.__H||(ve.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({}),r.__[e]}function bn(e){return $r=1,Tl(Ta,e)}function Tl(e,t,r){var n=mo(Hr++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):Ta(void 0,t),function(s){var c=n.__N?n.__N[0]:n.__[0],l=n.t(c,s);c!==l&&(n.__N=[l,n.__[1]],n.__c.setState({}))}],n.__c=ve,!ve.__f)){var o=function(s,c,l){if(!n.__c.__H)return!0;var u=n.__c.__H.__.filter(function(d){return!!d.__c});if(u.every(function(d){return!d.__N}))return!i||i.call(this,s,c,l);var p=n.__c.props!==s;return u.forEach(function(d){if(d.__N){var m=d.__[0];d.__=d.__N,d.__N=void 0,m!==d.__[0]&&(p=!0)}}),i&&i.call(this,s,c,l)||p};ve.__f=!0;var i=ve.shouldComponentUpdate,a=ve.componentWillUpdate;ve.componentWillUpdate=function(s,c,l){if(this.__e){var u=i;i=void 0,o(s,c,l),i=u}a&&a.call(this,s,c,l)},ve.shouldComponentUpdate=o}return n.__N||n.__}function mt(e,t){var r=mo(Hr++,3);!we.__s&&Ea(r.__H,t)&&(r.__=e,r.u=t,ve.__H.__h.push(r))}function Vt(e){return $r=5,ur(function(){return{current:e}},[])}function ur(e,t){var r=mo(Hr++,7);return Ea(r.__H,t)&&(r.__=e(),r.__H=t,r.__h=e),r.__}function Sl(e,t){return $r=8,ur(function(){return e},t)}function Ol(){for(var e;e=wa.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(mn),e.__H.__h.forEach(oo),e.__H.__h=[]}catch(t){e.__H.__h=[],we.__e(t,e.__v)}}we.__b=function(e){ve=null,Ui&&Ui(e)},we.__=function(e,t){e&&t.__k&&t.__k.__m&&(e.__m=t.__k.__m),zi&&zi(e,t)},we.__r=function(e){Ni&&Ni(e),Hr=0;var t=(ve=e.__c).__H;t&&(Zn===ve?(t.__h=[],ve.__h=[],t.__.forEach(function(r){r.__N&&(r.__=r.__N),r.u=r.__N=void 0})):(t.__h.forEach(mn),t.__h.forEach(oo),t.__h=[],Hr=0)),Zn=ve},we.diffed=function(e){Di&&Di(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(wa.push(t)!==1&&Fi===we.requestAnimationFrame||((Fi=we.requestAnimationFrame)||Ll)(Ol)),t.__H.__.forEach(function(r){r.u&&(r.__H=r.u),r.u=void 0})),Zn=ve=null},we.__c=function(e,t){t.some(function(r){try{r.__h.forEach(mn),r.__h=r.__h.filter(function(n){return!n.__||oo(n)})}catch(n){t.some(function(o){o.__h&&(o.__h=[])}),t=[],we.__e(n,r.__v)}}),Wi&&Wi(e,t)},we.unmount=function(e){Vi&&Vi(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{mn(n)}catch(o){t=o}}),r.__H=void 0,t&&we.__e(t,r.__v))};var qi=typeof requestAnimationFrame=="function";function Ll(e){var t,r=function(){clearTimeout(n),qi&&cancelAnimationFrame(t),setTimeout(e)},n=setTimeout(r,35);qi&&(t=requestAnimationFrame(r))}function mn(e){var t=ve,r=e.__c;typeof r=="function"&&(e.__c=void 0,r()),ve=t}function oo(e){var t=ve;e.__c=e.__(),ve=t}function Ea(e,t){return!e||e.length!==t.length||t.some(function(r,n){return r!==e[n]})}function Ta(e,t){return typeof t=="function"?t(e):t}function Ml(e,t){for(var r in t)e[r]=t[r];return e}function Ki(e,t){for(var r in e)if(r!=="__source"&&!(r in t))return!0;for(var n in t)if(n!=="__source"&&e[n]!==t[n])return!0;return!1}function Bi(e,t){this.props=e,this.context=t}(Bi.prototype=new at).isPureReactComponent=!0,Bi.prototype.shouldComponentUpdate=function(e,t){return Ki(this.props,e)||Ki(this.state,t)};var Yi=K.__b;K.__b=function(e){e.type&&e.type.__f&&e.ref&&(e.props.ref=e.ref,e.ref=null),Yi&&Yi(e)};var Yx=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911,kl=K.__e;K.__e=function(e,t,r,n){if(e.then){for(var o,i=t;i=i.__;)if((o=i.__c)&&o.__c)return t.__e==null&&(t.__e=r.__e,t.__k=r.__k),o.__c(e,t)}kl(e,t,r,n)};var Gi=K.unmount;function Sa(e,t,r){return e&&(e.__c&&e.__c.__H&&(e.__c.__H.__.forEach(function(n){typeof n.__c=="function"&&n.__c()}),e.__c.__H=null),(e=Ml({},e)).__c!=null&&(e.__c.__P===r&&(e.__c.__P=t),e.__c.__e=!0,e.__c=null),e.__k=e.__k&&e.__k.map(function(n){return Sa(n,t,r)})),e}function Oa(e,t,r){return e&&r&&(e.__v=null,e.__k=e.__k&&e.__k.map(function(n){return Oa(n,t,r)}),e.__c&&e.__c.__P===t&&(e.__e&&r.appendChild(e.__e),e.__c.__e=!0,e.__c.__P=r)),e}function Qn(){this.__u=0,this.o=null,this.__b=null}function La(e){var t=e.__.__c;return t&&t.__a&&t.__a(e)}function pn(){this.i=null,this.l=null}K.unmount=function(e){var t=e.__c;t&&t.__R&&t.__R(),t&&32&e.__u&&(e.type=null),Gi&&Gi(e)},(Qn.prototype=new at).__c=function(e,t){var r=t.__c,n=this;n.o==null&&(n.o=[]),n.o.push(r);var o=La(n.__v),i=!1,a=function(){i||(i=!0,r.__R=null,o?o(s):s())};r.__R=a;var s=function(){if(!--n.__u){if(n.state.__a){var c=n.state.__a;n.__v.__k[0]=Oa(c,c.__c.__P,c.__c.__O)}var l;for(n.setState({__a:n.__b=null});l=n.o.pop();)l.forceUpdate()}};n.__u++||32&t.__u||n.setState({__a:n.__b=n.__v.__k[0]}),e.then(a,a)},Qn.prototype.componentWillUnmount=function(){this.o=[]},Qn.prototype.render=function(e,t){if(this.__b){if(this.__v.__k){var r=document.createElement("div"),n=this.__v.__k[0].__c;this.__v.__k[0]=Sa(this.__b,r,n.__O=n.__P)}this.__b=null}var o=t.__a&&Wt(ft,null,e.fallback);return o&&(o.__u&=-33),[Wt(ft,null,t.__a?null:e.children),o]};var Ji=function(e,t,r){if(++r[1]===r[0]&&e.l.delete(t),e.props.revealOrder&&(e.props.revealOrder[0]!=="t"||!e.l.size))for(r=e.i;r;){for(;r.length>3;)r.pop()();if(r[1]<r[0])break;e.i=r=r[2]}};(pn.prototype=new at).__a=function(e){var t=this,r=La(t.__v),n=t.l.get(e);return n[0]++,function(o){var i=function(){t.props.revealOrder?(n.push(o),Ji(t,e,n)):o()};r?r(i):i()}},pn.prototype.render=function(e){this.i=null,this.l=new Map;var t=Cr(e.children);e.revealOrder&&e.revealOrder[0]==="b"&&t.reverse();for(var r=t.length;r--;)this.l.set(t[r],this.i=[1,0,this.i]);return e.children},pn.prototype.componentDidUpdate=pn.prototype.componentDidMount=function(){var e=this;this.l.forEach(function(t,r){Ji(e,r,t)})};var Al=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,Cl=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,Hl=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,$l=/[A-Z0-9]/g,Pl=typeof document<"u",Il=function(e){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(e)};at.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(e){Object.defineProperty(at.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})});var Xi=K.event;function Rl(){}function jl(){return this.cancelBubble}function Fl(){return this.defaultPrevented}K.event=function(e){return Xi&&(e=Xi(e)),e.persist=Rl,e.isPropagationStopped=jl,e.isDefaultPrevented=Fl,e.nativeEvent=e};var Ma,Ul={enumerable:!1,configurable:!0,get:function(){return this.class}},Zi=K.vnode;K.vnode=function(e){typeof e.type=="string"&&(function(t){var r=t.props,n=t.type,o={},i=n.indexOf("-")===-1;for(var a in r){var s=r[a];if(!(a==="value"&&"defaultValue"in r&&s==null||Pl&&a==="children"&&n==="noscript"||a==="class"||a==="className")){var c=a.toLowerCase();a==="defaultValue"&&"value"in r&&r.value==null?a="value":a==="download"&&s===!0?s="":c==="translate"&&s==="no"?s=!1:c[0]==="o"&&c[1]==="n"?c==="ondoubleclick"?a="ondblclick":c!=="onchange"||n!=="input"&&n!=="textarea"||Il(r.type)?c==="onfocus"?a="onfocusin":c==="onblur"?a="onfocusout":Hl.test(a)&&(a=c):c=a="oninput":i&&Cl.test(a)?a=a.replace($l,"-$&").toLowerCase():s===null&&(s=void 0),c==="oninput"&&o[a=c]&&(a="oninputCapture"),o[a]=s}}n=="select"&&o.multiple&&Array.isArray(o.value)&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.value.indexOf(l.props.value)!=-1})),n=="select"&&o.defaultValue!=null&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.multiple?o.defaultValue.indexOf(l.props.value)!=-1:o.defaultValue==l.props.value})),r.class&&!r.className?(o.class=r.class,Object.defineProperty(o,"className",Ul)):(r.className&&!r.class||r.class&&r.className)&&(o.class=o.className=r.className),t.props=o})(e),e.$$typeof=Al,Zi&&Zi(e)};var Qi=K.__r;K.__r=function(e){Qi&&Qi(e),Ma=e.__c};var ea=K.diffed;K.diffed=function(e){ea&&ea(e);var t=e.props,r=e.__e;r!=null&&e.type==="textarea"&&"value"in t&&t.value!==r.value&&(r.value=t.value==null?"":t.value),Ma=null};function ka(e){let t=Vt(e);return t.current=e,ur(()=>Object.freeze({get current(){return t.current}}),[])}var Nl=typeof globalThis<"u"&&typeof navigator<"u"&&typeof document<"u";function Dl(e,...t){var r;(r=e==null?void 0:e.addEventListener)==null||r.call(e,...t)}function Wl(e,...t){var r;(r=e==null?void 0:e.removeEventListener)==null||r.call(e,...t)}var Vl=(e,t)=>Object.hasOwn(e,t),zl=()=>!0,ql=()=>!1;function Kl(e=!1){let t=Vt(e),r=Sl(()=>t.current,[]);return mt(()=>(t.current=!0,()=>{t.current=!1}),[]),r}function Bl(e,...t){let r=Kl(),n=ka(t[1]),o=ur(()=>function(...i){r()&&(typeof n.current=="function"?n.current.apply(this,i):typeof n.current.handleEvent=="function"&&n.current.handleEvent.apply(this,i))},[]);mt(()=>{let i=Yl(e)?e.current:e;if(!i)return;let a=t.slice(2);return Dl(i,t[0],o,...a),()=>{Wl(i,t[0],o,...a)}},[e,t[0]])}function Yl(e){return e!==null&&typeof e=="object"&&Vl(e,"current")}var Gl=e=>typeof e=="function"?e:typeof e=="string"?t=>t.key===e:e?zl:ql,Jl=Nl?globalThis:null;function Aa(e,t,r=[],n={}){let{event:o="keydown",target:i=Jl,eventOptions:a}=n,s=ka(t),c=ur(()=>{let l=Gl(e);return function(u){l(u)&&s.current.call(this,u)}},r);Bl(i,o,c,a)}function Ca(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(r=Ca(e[t]))&&(n&&(n+=" "),n+=r)}else for(r in e)e[r]&&(n&&(n+=" "),n+=r);return n}function Xl(){for(var e,t,r=0,n="",o=arguments.length;r<o;r++)(e=arguments[r])&&(t=Ca(e))&&(n&&(n+=" "),n+=t);return n}var zt=Xl,Zl=Symbol.for("preact-signals");function xn(){if(St>1)St--;else{for(var e,t=!1;kr!==void 0;){var r=kr;for(kr=void 0,io++;r!==void 0;){var n=r.o;if(r.o=void 0,r.f&=-3,!(8&r.f)&&Pa(r))try{r.c()}catch(o){t||(e=o,t=!0)}r=n}}if(io=0,St--,t)throw e}}function Ql(e){if(St>0)return e();St++;try{return e()}finally{xn()}}var ae=void 0;function Ha(e){var t=ae;ae=void 0;try{return e()}finally{ae=t}}var kr=void 0,St=0,io=0,gn=0;function $a(e){if(ae!==void 0){var t=e.n;if(t===void 0||t.t!==ae)return t={i:0,S:e,p:ae.s,n:void 0,t:ae,e:void 0,x:void 0,r:t},ae.s!==void 0&&(ae.s.n=t),ae.s=t,e.n=t,32&ae.f&&e.S(t),t;if(t.i===-1)return t.i=0,t.n!==void 0&&(t.n.p=t.p,t.p!==void 0&&(t.p.n=t.n),t.p=ae.s,t.n=void 0,ae.s.n=t,ae.s=t),t}}function Ce(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Ce.prototype.brand=Zl;Ce.prototype.h=function(){return!0};Ce.prototype.S=function(e){var t=this,r=this.t;r!==e&&e.e===void 0&&(e.x=r,this.t=e,r!==void 0?r.e=e:Ha(function(){var n;(n=t.W)==null||n.call(t)}))};Ce.prototype.U=function(e){var t=this;if(this.t!==void 0){var r=e.e,n=e.x;r!==void 0&&(r.x=n,e.e=void 0),n!==void 0&&(n.e=r,e.x=void 0),e===this.t&&(this.t=n,n===void 0&&Ha(function(){var o;(o=t.Z)==null||o.call(t)}))}};Ce.prototype.subscribe=function(e){var t=this;return qt(function(){var r=t.value,n=ae;ae=void 0;try{e(r)}finally{ae=n}},{name:"sub"})};Ce.prototype.valueOf=function(){return this.value};Ce.prototype.toString=function(){return this.value+""};Ce.prototype.toJSON=function(){return this.value};Ce.prototype.peek=function(){var e=ae;ae=void 0;try{return this.value}finally{ae=e}};Object.defineProperty(Ce.prototype,"value",{get:function(){var e=$a(this);return e!==void 0&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(io>100)throw new Error("Cycle detected");this.v=e,this.i++,gn++,St++;try{for(var t=this.t;t!==void 0;t=t.x)t.t.N()}finally{xn()}}}});function Ot(e,t){return new Ce(e,t)}function Pa(e){for(var t=e.s;t!==void 0;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function Ia(e){for(var t=e.s;t!==void 0;t=t.n){var r=t.S.n;if(r!==void 0&&(t.r=r),t.S.n=t,t.i=-1,t.n===void 0){e.s=t;break}}}function Ra(e){for(var t=e.s,r=void 0;t!==void 0;){var n=t.p;t.i===-1?(t.S.U(t),n!==void 0&&(n.n=t.n),t.n!==void 0&&(t.n.p=n)):r=t,t.S.n=t.r,t.r!==void 0&&(t.r=void 0),t=n}e.s=r}function Kt(e,t){Ce.call(this,void 0),this.x=e,this.s=void 0,this.g=gn-1,this.f=4,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Kt.prototype=new Ce;Kt.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if((36&this.f)==32||(this.f&=-5,this.g===gn))return!0;if(this.g=gn,this.f|=1,this.i>0&&!Pa(this))return this.f&=-2,!0;var e=ae;try{Ia(this),ae=this;var t=this.x();(16&this.f||this.v!==t||this.i===0)&&(this.v=t,this.f&=-17,this.i++)}catch(r){this.v=r,this.f|=16,this.i++}return ae=e,Ra(this),this.f&=-2,!0};Kt.prototype.S=function(e){if(this.t===void 0){this.f|=36;for(var t=this.s;t!==void 0;t=t.n)t.S.S(t)}Ce.prototype.S.call(this,e)};Kt.prototype.U=function(e){if(this.t!==void 0&&(Ce.prototype.U.call(this,e),this.t===void 0)){this.f&=-33;for(var t=this.s;t!==void 0;t=t.n)t.S.U(t)}};Kt.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;e!==void 0;e=e.x)e.t.N()}};Object.defineProperty(Kt.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var e=$a(this);if(this.h(),e!==void 0&&(e.i=this.i),16&this.f)throw this.v;return this.v}});function ta(e,t){return new Kt(e,t)}function ja(e){var t=e.u;if(e.u=void 0,typeof t=="function"){St++;var r=ae;ae=void 0;try{t()}catch(n){throw e.f&=-2,e.f|=8,ho(e),n}finally{ae=r,xn()}}}function ho(e){for(var t=e.s;t!==void 0;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,ja(e)}function eu(e){if(ae!==this)throw new Error("Out-of-order effect");Ra(this),ae=e,this.f&=-2,8&this.f&&ho(this),xn()}function pr(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=t==null?void 0:t.name}pr.prototype.c=function(){var e=this.S();try{if(8&this.f||this.x===void 0)return;var t=this.x();typeof t=="function"&&(this.u=t)}finally{e()}};pr.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1,this.f&=-9,ja(this),Ia(this),St++;var e=ae;return ae=this,eu.bind(this,e)};pr.prototype.N=function(){2&this.f||(this.f|=2,this.o=kr,kr=this)};pr.prototype.d=function(){this.f|=8,1&this.f||ho(this)};pr.prototype.dispose=function(){this.d()};function qt(e,t){var r=new pr(e,t);try{r.c()}catch(o){throw r.d(),o}var n=r.d.bind(r);return n[Symbol.dispose]=n,n}var Fa,vo,eo,Ua=[];qt(function(){Fa=this.N})();function fr(e,t){K[e]=t.bind(null,K[e]||function(){})}function _n(e){eo&&eo(),eo=e&&e.S()}function Na(e){var t=this,r=e.data,n=ru(r);n.value=r;var o=ur(function(){for(var s=t,c=t.__v;c=c.__;)if(c.__c){c.__c.__$f|=4;break}var l=ta(function(){var m=n.value.value;return m===0?0:m===!0?"":m||""}),u=ta(function(){return!Array.isArray(l.value)&&!pa(l.value)}),p=qt(function(){if(this.N=Da,u.value){var m=l.value;s.__v&&s.__v.__e&&s.__v.__e.nodeType===3&&(s.__v.__e.data=m)}}),d=t.__$u.d;return t.__$u.d=function(){p(),d.call(this)},[u,l]},[]),i=o[0],a=o[1];return i.value?a.peek():a.value}Na.displayName="ReactiveTextNode";Object.defineProperties(Ce.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:Na},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});fr("__b",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),typeof t.type=="string"){var r,n=t.props;for(var o in n)if(o!=="children"){var i=n[o];i instanceof Ce&&(r||(t.__np=r={}),r[o]=i,n[o]=i.peek())}}e(t)});fr("__r",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.enterComponent(t),t.type!==ft){_n();var r,n=t.__c;n&&(n.__$f&=-2,(r=n.__$u)===void 0&&(n.__$u=r=(function(o){var i;return qt(function(){i=this}),i.c=function(){n.__$f|=1,n.setState({})},i})())),vo=n,_n(r)}e(t)});fr("__e",function(e,t,r,n){typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0,e(t,r,n)});fr("diffed",function(e,t){typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0;var r;if(typeof t.type=="string"&&(r=t.__e)){var n=t.__np,o=t.props;if(n){var i=r.U;if(i)for(var a in i){var s=i[a];s!==void 0&&!(a in n)&&(s.d(),i[a]=void 0)}else i={},r.U=i;for(var c in n){var l=i[c],u=n[c];l===void 0?(l=tu(r,c,u,o),i[c]=l):l.o(u,o)}}}e(t)});function tu(e,t,r,n){var o=t in e&&e.ownerSVGElement===void 0,i=Ot(r);return{o:function(a,s){i.value=a,n=s},d:qt(function(){this.N=Da;var a=i.value.value;n[t]!==a&&(n[t]=a,o?e[t]=a:a?e.setAttribute(t,a):e.removeAttribute(t))})}}fr("unmount",function(e,t){if(typeof t.type=="string"){var r=t.__e;if(r){var n=r.U;if(n){r.U=void 0;for(var o in n){var i=n[o];i&&i.d()}}}}else{var a=t.__c;if(a){var s=a.__$u;s&&(a.__$u=void 0,s.d())}}e(t)});fr("__h",function(e,t,r,n){(n<3||n===9)&&(t.__$f|=2),e(t,r,n)});at.prototype.shouldComponentUpdate=function(e,t){var r=this.__$u,n=r&&r.s!==void 0;for(var o in t)return!0;if(this.__f||typeof this.u=="boolean"&&this.u===!0){var i=2&this.__$f;if(!(n||i||4&this.__$f)||1&this.__$f)return!0}else if(!(n||4&this.__$f)||3&this.__$f)return!0;for(var a in e)if(a!=="__source"&&e[a]!==this.props[a])return!0;for(var s in this.props)if(!(s in e))return!0;return!1};function ru(e,t){return bn(function(){return Ot(e,t)})[0]}var nu=function(e){queueMicrotask(function(){queueMicrotask(e)})};function ou(){Ql(function(){for(var e;e=Ua.shift();)Fa.call(e)})}function Da(){Ua.push(this)===1&&(K.requestAnimationFrame||nu)(ou)}var ao=[0];for(let e=0;e<32;e++)ao.push(ao[e]|1<<e);function iu(e){return new Uint32Array(e)}var ra=class{constructor(e,t=iu(Math.ceil(e/32))){this.size=e,this.data=t}get(e){return this.data[e>>>5]>>>e&1}set(e){this.data[e>>>5]|=1<<(e&31)}forEach(e){let t=this.size&31;for(let r=0;r<this.data.length;r++){if(this.data[r]===0)continue;let n=this.data[r];t&&r===this.data.length-1&&(n=n&ao[t]);for(let o=0,i=32-Math.clz32(n);o<i;o++)n&1<<o&&e((r<<5)+o)}}};function au(e){lr.value=e,e.items.find(t=>{var r;return(r=t.tags)==null?void 0:r.length})&&(matchMedia("(max-width: 768px)").matches||Wa())}function Dt(){Qe.value=He(H({},Qe.value),{hideSearch:!Qe.value.hideSearch})}function Wa(){Qe.value=He(H({},Qe.value),{hideFilters:!Qe.value.hideFilters})}function dn(){return Qe.value.selectedItem}function so(e){Qe.value=He(H({},Qe.value),{selectedItem:e})}function su(){var e,t;return(t=(e=lr.value)==null?void 0:e.items)!=null?t:[]}function wn(){return typeof Se.value.input=="string"?Se.value.input:""}function Va(e){let t=za();e.length&&!t.length?Se.value=He(H({},Se.value),{page:void 0,input:e}):!e.length&&t.length?Se.value=He(H({},Se.value),{page:void 0,input:{type:"operator",data:{operator:"not",operands:[]}}}):Se.value=He(H({},Se.value),{page:void 0,input:e})}function cu(){typeof it.value.pagination.next<"u"&&(Se.value=He(H({},Se.value),{page:it.value.pagination.next}))}function lu(e){let t=Se.value.filter.input;if("type"in t&&t.type==="operator"){for(let r of t.data.operands)if("type"in r&&r.type==="value"&&typeof r.data.value=="string"&&r.data.value===e)return!0}return!1}function za(){let e=Se.value.filter.input,t=[];if("type"in e&&e.type==="operator")for(let r of e.data.operands)"type"in r&&r.type==="value"&&typeof r.data.value=="string"&&t.push(r.data.value);return t}function uu(e){let t=Se.value.filter.input,r=[];if("type"in t&&t.type==="operator")for(let n of t.data.operands)"type"in n&&n.type==="value"&&typeof n.data.value=="string"&&r.push(n.data.value);if(r.includes(e)){let n=r.indexOf(e);n>-1&&r.splice(n,1)}else r.push(e);Se.value=He(H({},Se.value),{page:void 0,filter:He(H({},Se.value.filter),{input:{type:"operator",data:{operator:"and",operands:r.map(n=>({type:"value",data:{field:"tags",value:n}}))}}})}),Va(wn())}function pu(){return it.value.items}function fu(){return it.value.total}function mu(){var e;for(let t of(e=it.value.aggregations)!=null?e:[])if(t.type==="term")return t.data.value;return[]}function sr(){return Qe.value.hideSearch}function du(){return Qe.value.hideFilters}function qa(){var e;return(e=Ka.value.highlight)!=null?e:!1}var Qe=Ot({hideSearch:!0,hideFilters:!0,selectedItem:0}),Ka=Ot({}),lr=Ot(),na=Ot(),Se=Ot({input:"",filter:{input:{type:"operator",data:{operator:"and",operands:[]}},aggregation:{input:[{type:"term",data:{field:"tags"}}]}}}),it=Ot({items:[],query:{select:{documents:new ra(0),terms:new ra(0)},values:[]},pagination:{total:0}});function hu(e,t,r){for(let n=0;t<r;){switch(n=n<<8^32|e.charCodeAt(++t),n){case 97:case 98:case 99:case 101:case 104:case 105:case 108:case 109:case 112:case 115:case 116:case 119:case 24946:case 25185:case 25455:case 25965:case 26989:case 26990:case 27753:case 28005:case 28769:case 29551:case 29810:case 30562:case 6386277:case 6447475:case 6647138:case 6909552:case 7104878:case 7169396:case 7364978:case 7565173:case 7631457:case 1701667429:case 1768845429:case 1869967971:case 1885434465:case 1936684402:case 1953653091:continue;case 25202:case 26738:case 6516588:case 6909287:case 7823986:case 1634885997:case 1634887009:case 1650553701:case 1818848875:case 1835165028:case 1835365473:case 1852863860:case 1918985067:case 1970430821:switch(e.charCodeAt(++t)){case 9:case 10:case 32:case 47:case 62:return!0}}break}return!1}function vu(e,t,r=0,n=e.length){let o=0,i=r;for(let a=0;i<n;i++)switch(a=e.charCodeAt(i),a){case 60:i>r&&t(0,o,r,r=i);continue;case 62:e.charCodeAt(r+1)===47?t(2,--o,r,r=i+1):hu(e,r,n)?t(3,o,r,r=i+1):t(1,o++,r,r=i+1)}i>r&&t(0,o,r,i)}function bu(e,t=0,r=e.length){let n=++t;e:for(let l=0;n<r;n++)switch(l=e.charCodeAt(n),l){case 9:case 10:case 32:case 62:break e}let o=e.slice(t,t=n),i=[],a=0,s=0,c=0;for(let l=0;n<r;n++){let u=e.charCodeAt(n);switch(a){case 0:switch(u){case 9:case 10:case 32:t===n?t++:(s=1,a=1);break;case 61:s=1,a=2;break;case 47:t++;case 62:t<n&&(s=1);break}break;case 1:switch(u){case 9:case 10:case 32:continue;case 61:a=2,t=n+1;continue;default:a=0,t=n,l++}continue;case 2:switch(u){case 9:case 10:case 32:t===n?t++:c===0&&(s=2,a=0);break;case 34:case 39:switch(c){case 0:c=u,t=n+1;continue;case u:s=2,a=0,c=0}break;case 62:t<n&&(s=2);break}}switch(s){case 1:i[l]=[e.slice(t,n),""],s=0,t=n+1;break;case 2:i[l++][1]=e.slice(t,n),s=0,t=n+1;break}}return{tag:o,attrs:i.length?Object.fromEntries(i):null}}function gu(e,t,r){return e.slice(t,r)}function _u(e){return(t,r,n,o)=>{let i=[],a=[],{onElement:s,onText:c=gu}=typeof r=="function"?{onElement:r}:r,l=0,u=0;return e(t,(p,d,m,h)=>{if(p===0)i[l++]=c(t,m,h),a[u++]={value:null,depth:d};else if(p&1&&(a[u++]={value:bu(t,m,h),depth:d}),p&2)for(let v=0;u>=0;v++){let{value:x,depth:w}=a[--u];if(w>d)continue;let E=i.slice(l-=v,l+v);i[l++]=s(x,E),u++;break}},n,o),i.slice(0,l)}}function yu(e){return e.replace(/[&<>]/g,t=>{switch(t.charCodeAt(0)){case 38:return"&amp;";case 60:return"&lt;";case 62:return"&gt;"}})}function hn(e){return e.replace(/&(amp|[lg]t);/g,t=>{switch(t.charCodeAt(1)){case 97:return"&";case 108:return"<";case 103:return">"}})}function xu(e,t){return{start:e.start+t,end:e.end+t,value:e.value}}function wu(e,t,r){return e.slice(t,r)}function Eu(e){let{onHighlight:t,onText:r=wu}=typeof e=="function"?{onHighlight:e}:e;return(n,o,i=0,a=n.length)=>{var l;let s=[],c=(l=o==null?void 0:o.ranges)!=null?l:[];for(let u=0,p=i;u<c.length;u++){let d=c[u].start;if(d>a)break;let m=c[u].end;if(m<p)continue;d=Math.max(d,i),m=Math.min(m,a),d>i&&s.push(r(n,i,d));let{value:h}=c[u];s.push(t(n,{start:d,end:i=m,value:h}))}return i<a&&s.push(r(n,i,a)),s}}var Tu={fuzzy:"v"},Su=0;function z(e,t,r,n,o,i){t||(t={});var a,s,c=t;if("ref"in c)for(s in c={},t)s=="ref"?a=t[s]:c[s]=t[s];var l={type:e,props:c,key:r,ref:a,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--Su,__i:-1,__u:0,__source:o,__self:i};if(typeof e=="function"&&(a=e.defaultProps))for(s in a)c[s]===void 0&&(c[s]=a[s]);return K.vnode&&K.vnode(l),l}var Ou=_u(vu),Lu=Eu({onText(e,t,r){return hn(e.slice(t,r))},onHighlight(e,{start:t,end:r,value:n}){let o=Math.min(r,t+n);return t===r?null:(n===-1&&(o=r),z("mark",{className:zt({[Tu.fuzzy]:n===-1}),children:[z("u",{children:hn(e.slice(t,o))}),hn(e.slice(o,r))]}))}});function Ba(e,t){let r=Ou(e,{onElement(n,o){return Wt(n.tag,n.attrs,...o)},onText(n,o,i){return Lu(n,t==null?void 0:t.value.highlight,o,i)}});return z(ft,{children:r})}function Mu(e,t){var n;let r=[];for(let o=0,i=0;o<e.length;o++){let a=[];if((n=t==null?void 0:t.value.highlight)!=null&&n.ranges)for(let s of t.value.highlight.ranges)a.push(xu(s,-i));r.push(Ba(e[o],He(H({},t),{value:He(H({},t==null?void 0:t.value),{highlight:{ranges:a}})}))),i+=e[o].length}return r}function Ya(e,t={highlight:!0}){Ka.value=t;let r=new Worker(e);r.onmessage=n=>{let o=n.data;switch(o.type){case 1:na.value=!0;break;case 3:typeof o.data.pagination.prev<"u"?it.value=He(H({},it.value),{pagination:o.data.pagination,items:[...it.value.items,...o.data.items]}):(it.value=o.data,so(0));break}},qt(()=>{lr.value&&r.postMessage({type:0,data:lr.value})}),qt(()=>{na.value&&r.postMessage({type:2,data:Se.value})})}var oa={container:"p",hidden:"m"};function ku(e){return z("div",{class:zt(oa.container,{[oa.hidden]:e.hidden}),onClick:()=>Dt()})}var ia={container:"r",disabled:"c"};function co(e){return z("button",{class:zt(ia.container,{[ia.disabled]:!e.onClick}),onClick:e.onClick,children:e.children})}var aa=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),Au=e=>e.replace(/^([A-Z])|[\s-_]+(\w)/g,(t,r,n)=>n?n.toUpperCase():r.toLowerCase()),sa=e=>{let t=Au(e);return t.charAt(0).toUpperCase()+t.slice(1)},Cu=(...e)=>e.filter((t,r,n)=>!!t&&t.trim()!==""&&n.indexOf(t)===r).join(" ").trim(),Hu={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},$u=c=>{var l=c,{color:e="currentColor",size:t=24,strokeWidth:r=2,absoluteStrokeWidth:n,children:o,iconNode:i,class:a=""}=l,s=gr(l,["color","size","strokeWidth","absoluteStrokeWidth","children","iconNode","class"]);return Wt("svg",H(He(H({},Hu),{width:String(t),height:t,stroke:e,"stroke-width":n?Number(r)*24/Number(t):r,class:["lucide",a].join(" ")}),s),[...i.map(([u,p])=>Wt(u,p)),...Cr(o)])},bo=(e,t)=>{let r=a=>{var s=a,{class:n="",children:o}=s,i=gr(s,["class","children"]);return Wt($u,He(H({},i),{iconNode:t,class:Cu(`lucide-${aa(sa(e))}`,`lucide-${aa(e)}`,n)}),o)};return r.displayName=sa(e),r},Pu=bo("corner-down-left",[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4",key:"6o5b7l"}],["path",{d:"m9 10-5 5 5 5",key:"1kshq7"}]]),Iu=bo("list-filter",[["path",{d:"M2 5h20",key:"1fs1ex"}],["path",{d:"M6 12h12",key:"8npq4p"}],["path",{d:"M9 19h6",key:"456am0"}]]),Ru=bo("search",[["path",{d:"m21 21-4.34-4.34",key:"14j7rj"}],["circle",{cx:"11",cy:"11",r:"8",key:"4ej97u"}]]),Gx=hl(vl(),1);function ju({threshold:e=0,root:t=null,rootMargin:r="0%",freezeOnceVisible:n=!1,initialIsIntersecting:o=!1,onChange:i}={}){var a;let[s,c]=bn(null),[l,u]=bn(()=>({isIntersecting:o,entry:void 0})),p=Vt();p.current=i;let d=((a=l.entry)==null?void 0:a.isIntersecting)&&n;mt(()=>{if(!s||!("IntersectionObserver"in window)||d)return;let v,x=new IntersectionObserver(w=>{let E=Array.isArray(x.thresholds)?x.thresholds:[x.thresholds];w.forEach(_=>{let de=_.isIntersecting&&E.some(be=>_.intersectionRatio>=be);u({isIntersecting:de,entry:_}),p.current&&p.current(de,_),de&&n&&v&&(v(),v=void 0)})},{threshold:e,root:t,rootMargin:r});return x.observe(s),()=>{x.disconnect()}},[s,JSON.stringify(e),t,r,d,n]);let m=Vt(null);mt(()=>{var v;!s&&(v=l.entry)!=null&&v.target&&!n&&!d&&m.current!==l.entry.target&&(m.current=l.entry.target,u({isIntersecting:o,entry:void 0}))},[s,l.entry,n,d,o]);let h=[c,!!l.isIntersecting,l.entry];return h.ref=h[0],h.isIntersecting=h[1],h.entry=h[2],h}var lt={container:"n",hidden:"l",content:"u",pop:"d",badge:"y",sidebar:"i",controls:"w",results:"k",loadmore:"z"};function Fu(e){let{isIntersecting:t,ref:r}=ju({threshold:0});mt(()=>{t&&cu()},[t]);let n=Vt(null);mt(()=>{n.current&&typeof Se.value.page>"u"&&n.current.scrollTo({top:0,behavior:"smooth"})},[Se.value]);let o=za();return z("div",{class:zt(lt.container,{[lt.hidden]:e.hidden}),children:[z("div",{class:lt.content,children:[z("div",{class:lt.controls,children:[z(co,{onClick:Dt,children:z(Ru,{})}),z(Nu,{focus:!e.hidden}),z(co,{onClick:Wa,children:[z(Iu,{}),o.length>0&&z("span",{class:lt.badge,children:o.length})]})]}),z("div",{class:lt.results,ref:n,children:[z(Du,{keyboard:!e.hidden}),z("div",{class:lt.loadmore,ref:r})]})]}),z("div",{class:zt(lt.sidebar,{[lt.hidden]:du()}),children:z(Uu,{})})]})}var Tt={container:"X",list:"j",heading:"F",title:"I",item:"o",active:"g",value:"R",count:"q"};function Uu(e){let t=mu();return t.sort((r,n)=>n.node.count-r.node.count),z("div",{class:Tt.container,children:[z("h3",{class:Tt.heading,children:"Filters"}),z("h4",{class:Tt.title,children:"Tags"}),z("ol",{class:Tt.list,children:t.map(r=>z("li",{class:zt(Tt.item,{[Tt.active]:lu(r.node.value)}),onClick:()=>uu(r.node.value),children:[z("span",{class:Tt.value,children:r.node.value}),z("span",{class:Tt.count,children:r.node.count})]}))})]})}var ca={container:"f"};function Nu(e){let t=Vt(null);return mt(()=>{var r,n;e.focus?(r=t.current)==null||r.focus():(n=t.current)==null||n.blur()},[e.focus]),z("div",{class:ca.container,children:z("input",{ref:t,type:"text",class:ca.content,value:hn(wn()),onInput:r=>Va(yu(r.currentTarget.value)),autocapitalize:"off",autocomplete:"off",autocorrect:"off",placeholder:"Search",spellcheck:!1,role:"combobox"})})}var ut={container:"b",heading:"A",item:"a",active:"h",wrapper:"B",actions:"s",title:"x",path:"t"};function Ga(){let[e,t]=bn(!1);return mt(()=>{let r=()=>t(!0),n=()=>t(!1);return document.addEventListener("compositionstart",r),document.addEventListener("compositionend",n),()=>{document.removeEventListener("compositionstart",r),document.removeEventListener("compositionend",n)}},[]),e}function Du(e){var s;let t=su(),r=pu(),n=dn(),o=Vt([]),i=Ga();mt(()=>{let c=o.current[n];c&&c.scrollIntoView({block:"center",behavior:"smooth"})},[n]),Aa(e.keyboard,c=>{if(i)return;let l=dn();c.key==="ArrowDown"?(c.preventDefault(),so(Math.min(l+1,r.length-1))):c.key==="ArrowUp"&&(c.preventDefault(),so(Math.max(l-1,0)))},[e.keyboard,i]);let a=(s=fu())!=null?s:0;return z(ft,{children:[r.length>0&&z("h3",{class:ut.heading,children:[z("span",{class:ut.bubble,children:new Intl.NumberFormat("en-US").format(a)})," ","results"]}),z("ol",{class:ut.container,children:r.map((c,l)=>{var m;let u=Ba(t[c.id].title,c.matches.find(({field:h})=>h==="title")),p=Mu((m=t[c.id].path)!=null?m:[],c.matches.find(({field:h})=>h==="path")),d=t[c.id].location;if(qa()){let h=encodeURIComponent(wn()),[v,x]=d.split("#",2);d=`${v}?h=${h.replace(/%20/g,"+")}`,typeof x<"u"&&(d+=`#${x}`)}return z("li",{children:z("a",{ref:h=>{o.current[l]=h},href:d,onClick:()=>Dt(),class:zt(ut.item,{[ut.active]:l===dn()}),children:[z("div",{class:ut.wrapper,children:[z("h2",{class:ut.title,children:u}),z("menu",{class:ut.path,children:p.map(h=>z("li",{children:h}))})]}),z("nav",{class:ut.actions,children:z(co,{children:z(Pu,{})})})]})})})})]})}var Wu={container:"e"};function Vu(e){let t=Ga();return Aa(!0,r=>{var n,o,i,a,s;if(!t)if((r.metaKey||r.ctrlKey)&&r.key==="k")r.preventDefault(),Dt();else if((r.metaKey||r.ctrlKey)&&r.key==="j")document.body.classList.toggle("dark");else if(r.key==="Enter"&&!sr()){r.preventDefault();let c=dn(),l=(o=(n=it.value)==null?void 0:n.items[c])==null?void 0:o.id;if((a=(i=lr.value)==null?void 0:i.items[l])!=null&&a.location){Dt();let u=(s=lr.value)==null?void 0:s.items[l].location;if(qa()){let p=encodeURIComponent(wn()),[d,m]=u.split("#",2);u=`${d}?h=${p.replace(/%20/g,"+")}`,typeof m<"u"&&(u+=`#${m}`)}window.location.href=u}}else r.key==="Escape"&&!sr()&&(r.preventDefault(),Dt())},[t]),z("div",{class:Wu.container,children:[z(ku,{hidden:sr()}),z(Fu,{hidden:sr()})]})}function Ja(e,t){au(e),El(z(Vu,{}),t)}function go(){Dt()}function zu(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function qu(){return R(b(window,"compositionstart").pipe(f(()=>!0)),b(window,"compositionend").pipe(f(()=>!1))).pipe(J(!1))}function Xa(){let e=b(window,"keydown").pipe(f(t=>({mode:sr()?"global":"search",type:t.key,meta:t.ctrlKey||t.metaKey,claim(){t.preventDefault(),t.stopPropagation()}})),L(({mode:t,type:r})=>{if(t==="global"){let n=xt();if(typeof n!="undefined")return!zu(n,r)}return!0}),xe());return qu().pipe(g(t=>t?y:e))}function Ye(){return new URL(location.href)}function dt(e,t=!1){if(X("navigation.instant")&&!t){let r=A("a",{href:e.href});document.body.appendChild(r),r.click(),r.remove()}else location.href=e.href}function Za(){return new I}function Qa(){return location.hash.slice(1)}function es(e){let t=A("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function _o(e){return R(b(window,"hashchange"),e).pipe(f(Qa),J(Qa()),L(t=>t.length>0),se(1))}function ts(e){return _o(e).pipe(f(t=>Le(`[id="${t}"]`)),L(t=>typeof t!="undefined"))}function Ir(e){let t=matchMedia(e);return an(r=>t.addListener(()=>r(t.matches))).pipe(J(t.matches))}function rs(){let e=matchMedia("print");return R(b(window,"beforeprint").pipe(f(()=>!0)),b(window,"afterprint").pipe(f(()=>!1))).pipe(J(e.matches))}function yo(e,t){return e.pipe(g(r=>r?t():y))}function xo(e,t){return new U(r=>{let n=new XMLHttpRequest;return n.open("GET",`${e}`),n.responseType="blob",n.addEventListener("load",()=>{n.status>=200&&n.status<300?(r.next(n.response),r.complete()):r.error(new Error(n.statusText))}),n.addEventListener("error",()=>{r.error(new Error("Network error"))}),n.addEventListener("abort",()=>{r.complete()}),typeof(t==null?void 0:t.progress$)!="undefined"&&(n.addEventListener("progress",o=>{var i;if(o.lengthComputable)t.progress$.next(o.loaded/o.total*100);else{let a=(i=n.getResponseHeader("Content-Length"))!=null?i:0;t.progress$.next(o.loaded/+a*100)}}),t.progress$.next(5)),n.send(),()=>n.abort()})}function et(e,t){return xo(e,t).pipe(g(r=>r.text()),f(r=>JSON.parse(r)),se(1))}function En(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/html")),se(1))}function ns(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/xml")),se(1))}var wo={drawer:G("[data-md-toggle=drawer]"),search:G("[data-md-toggle=search]")};function Eo(e,t){wo[e].checked!==t&&wo[e].click()}function Tn(e){let t=wo[e];return b(t,"change").pipe(f(()=>t.checked),J(t.checked))}function os(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function is(){return R(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(f(os),J(os()))}function as(){return{width:innerWidth,height:innerHeight}}function ss(){return b(window,"resize",{passive:!0}).pipe(f(as),J(as()))}function cs(){return re([is(),ss()]).pipe(f(([e,t])=>({offset:e,size:t})),se(1))}function Sn(e,{viewport$:t,header$:r}){let n=t.pipe(fe("size")),o=re([n,r]).pipe(f(()=>wt(e)));return re([r,t,o]).pipe(f(([{height:i},{offset:a,size:s},{x:c,y:l}])=>({offset:{x:a.x-c,y:a.y-l+i},size:s})))}var Ku=G("#__config"),mr=JSON.parse(Ku.textContent);mr.base=`${new URL(mr.base,Ye())}`;function Ue(){return mr}function X(e){return mr.features.includes(e)}function Bt(e,t){return typeof t!="undefined"?mr.translations[e].replace("#",t.toString()):mr.translations[e]}function ht(e,t=document){return G(`[data-md-component=${e}]`,t)}function Ee(e,t=document){return P(`[data-md-component=${e}]`,t)}function Bu(e){let t=G(".md-typeset > :first-child",e);return b(t,"click",{once:!0}).pipe(f(()=>G(".md-typeset",e)),f(r=>({hash:__md_hash(r.innerHTML)})))}function ls(e){if(!X("announce.dismiss")||!e.childElementCount)return y;if(!e.hidden){let t=G(".md-typeset",e);__md_hash(t.innerHTML)===__md_get("__announce")&&(e.hidden=!0)}return j(()=>{let t=new I;return t.subscribe(({hash:r})=>{e.hidden=!0,__md_set("__announce",r)}),Bu(e).pipe($(r=>t.next(r)),V(()=>t.complete()),f(r=>H({ref:e},r)))})}function Yu(e,{target$:t}){return t.pipe(f(r=>({hidden:r!==e})))}function us(e,t){let r=new I;return r.subscribe(({hidden:n})=>{e.hidden=n}),Yu(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))}function To(e,t){return t==="inline"?A("div",{class:"md-tooltip md-tooltip--inline",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"})):A("div",{class:"md-tooltip",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"}))}function On(...e){return A("div",{class:"md-tooltip2",role:"dialog"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function ps(...e){return A("div",{class:"md-tooltip2",role:"tooltip"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function fs(e,t){if(t=t?`${t}_annotation_${e}`:void 0,t){let r=t?`#${t}`:void 0;return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("a",{href:r,class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}else return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("span",{class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}function ms(e){return A("button",{class:"md-code__button",title:Bt("clipboard.copy"),"data-clipboard-target":`#${e} > code`,"data-md-type":"copy"})}function ds(){return A("button",{class:"md-code__button",title:"Toggle line selection","data-md-type":"select"})}function hs(){return A("nav",{class:"md-code__nav"})}var Xu=_r(So());function bs(e){return A("ul",{class:"md-source__facts"},Object.entries(e).map(([t,r])=>A("li",{class:`md-source__fact md-source__fact--${t}`},typeof r=="number"?Li(r):r)))}function Oo(e){let t=`tabbed-control tabbed-control--${e}`;return A("div",{class:t,hidden:!0},A("button",{class:"tabbed-button",tabIndex:-1,"aria-hidden":"true"}))}function gs(e){return A("div",{class:"md-typeset__scrollwrap"},A("div",{class:"md-typeset__table"},e))}function Zu(e){var n;let t=Ue(),r=new URL(`../${e.version}/`,t.base);return A("li",{class:"md-version__item"},A("a",{href:`${r}`,class:"md-version__link"},e.title,((n=t.version)==null?void 0:n.alias)&&e.aliases.length>0&&A("span",{class:"md-version__alias"},e.aliases[0])))}function _s(e,t){var n;let r=Ue();return e=e.filter(o=>{var i;return!((i=o.properties)!=null&&i.hidden)}),A("div",{class:"md-version"},A("button",{class:"md-version__current","aria-label":Bt("select.version")},t.title,((n=r.version)==null?void 0:n.alias)&&t.aliases.length>0&&A("span",{class:"md-version__alias"},t.aliases[0])),A("ul",{class:"md-version__list"},e.map(Zu)))}var Qu=0;function ep(e,t=250){let r=re([ir(e),Ft(e,t)]).pipe(f(([o,i])=>o||i),ie()),n=j(()=>Ai(e)).pipe(oe(Ut),Lr(1),Ze(r),f(()=>Ci(e)));return r.pipe(Sr(o=>o),g(()=>re([r,n])),f(([o,i])=>({active:o,offset:i})),xe())}function Rr(e,t,r=250){let{content$:n,viewport$:o}=t,i=`__tooltip2_${Qu++}`;return j(()=>{let a=new I,s=new Un(!1);a.pipe(he(),ye(!1)).subscribe(s);let c=s.pipe(Tr(u=>Ve(+!u*250,Wn)),ie(),g(u=>u?n:y),$(u=>u.id=i),xe());re([a.pipe(f(({active:u})=>u)),c.pipe(g(u=>Ft(u,250)),J(!1))]).pipe(f(u=>u.some(p=>p))).subscribe(s);let l=s.pipe(L(u=>u),pe(c,o),f(([u,p,{size:d}])=>{let m=e.getBoundingClientRect(),h=m.width/2;if(p.role==="tooltip")return{x:h,y:8+m.height};if(m.y>=d.height/2){let{height:v}=Ae(p);return{x:h,y:-16-v}}else return{x:h,y:16+m.height}}));return re([c,a,l]).subscribe(([u,{offset:p},d])=>{u.style.setProperty("--md-tooltip-host-x",`${p.x}px`),u.style.setProperty("--md-tooltip-host-y",`${p.y}px`),u.style.setProperty("--md-tooltip-x",`${d.x}px`),u.style.setProperty("--md-tooltip-y",`${d.y}px`),u.classList.toggle("md-tooltip2--top",d.y<0),u.classList.toggle("md-tooltip2--bottom",d.y>=0)}),s.pipe(L(u=>u),pe(c,(u,p)=>p),L(u=>u.role==="tooltip")).subscribe(u=>{let p=Ae(G(":scope > *",u));u.style.setProperty("--md-tooltip-width",`${p.width}px`),u.style.setProperty("--md-tooltip-tail","0px")}),s.pipe(ie(),Ie(je),pe(c)).subscribe(([u,p])=>{p.classList.toggle("md-tooltip2--active",u)}),re([s.pipe(L(u=>u)),c]).subscribe(([u,p])=>{p.role==="dialog"?(e.setAttribute("aria-controls",i),e.setAttribute("aria-haspopup","dialog")):e.setAttribute("aria-describedby",i)}),s.pipe(L(u=>!u)).subscribe(()=>{e.removeAttribute("aria-controls"),e.removeAttribute("aria-describedby"),e.removeAttribute("aria-haspopup")}),ep(e,r).pipe($(u=>a.next(u)),V(()=>a.complete()),f(u=>H({ref:e},u)))})}function Ge(e,{viewport$:t},r=document.body){return Rr(e,{content$:new U(n=>{let o=e.title,i=ps(o);return n.next(i),e.removeAttribute("title"),r.append(i),()=>{i.remove(),e.setAttribute("title",o)}}),viewport$:t},0)}function tp(e,t){let r=j(()=>re([Hi(e),Ut(t)])).pipe(f(([{x:n,y:o},i])=>{let{width:a,height:s}=Ae(e);return{x:n-i.x+a/2,y:o-i.y+s/2}}));return ir(e).pipe(g(n=>r.pipe(f(o=>({active:n,offset:o})),Me(+!n||1/0))))}function ys(e,t,{target$:r}){let[n,o]=Array.from(e.children);return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({offset:s}){e.style.setProperty("--md-tooltip-x",`${s.x}px`),e.style.setProperty("--md-tooltip-y",`${s.y}px`)},complete(){e.style.removeProperty("--md-tooltip-x"),e.style.removeProperty("--md-tooltip-y")}}),Et(e).pipe(Q(a)).subscribe(s=>{e.toggleAttribute("data-md-visible",s)}),R(i.pipe(L(({active:s})=>s)),i.pipe(Be(250),L(({active:s})=>!s))).subscribe({next({active:s}){s?e.prepend(n):n.remove()},complete(){e.prepend(n)}}),i.pipe(Xe(16,je)).subscribe(({active:s})=>{n.classList.toggle("md-tooltip--active",s)}),i.pipe(Lr(125,je),L(()=>!!e.offsetParent),f(()=>e.offsetParent.getBoundingClientRect()),f(({x:s})=>s)).subscribe({next(s){s?e.style.setProperty("--md-tooltip-0",`${-s}px`):e.style.removeProperty("--md-tooltip-0")},complete(){e.style.removeProperty("--md-tooltip-0")}}),b(o,"click").pipe(Q(a),L(s=>!(s.metaKey||s.ctrlKey))).subscribe(s=>{s.stopPropagation(),s.preventDefault()}),b(o,"mousedown").pipe(Q(a),pe(i)).subscribe(([s,{active:c}])=>{var l;if(s.button!==0||s.metaKey||s.ctrlKey)s.preventDefault();else if(c){s.preventDefault();let u=e.parentElement.closest(".md-annotation");u instanceof HTMLElement?u.focus():(l=xt())==null||l.blur()}}),r.pipe(Q(a),L(s=>s===n),It(125)).subscribe(()=>e.focus()),tp(e,t).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function rp(e){let t=Ue();if(e.tagName!=="CODE")return[e];let r=[".c",".c1",".cm"];if(t.annotate){let n=e.closest("[class|=language]");if(n)for(let o of Array.from(n.classList)){if(!o.startsWith("language-"))continue;let[,i]=o.split("-");i in t.annotate&&r.push(...t.annotate[i])}}return P(r.join(", "),e)}function np(e){let t=[];for(let r of rp(e)){let n=[],o=document.createNodeIterator(r,NodeFilter.SHOW_TEXT);for(let i=o.nextNode();i;i=o.nextNode())n.push(i);for(let i of n){let a;for(;a=/(\(\d+\))(!)?/.exec(i.textContent);){let[,s,c]=a;if(typeof c=="undefined"){let l=i.splitText(a.index);i=l.splitText(s.length),t.push(l)}else{i.textContent=s,t.push(i);break}}}}return t}function xs(e,t){t.append(...Array.from(e.childNodes))}function Ln(e,t,{target$:r,print$:n}){let o=t.closest("[id]"),i=o==null?void 0:o.id,a=new Map;for(let s of np(t)){let[,c]=s.textContent.match(/\((\d+)\)/);Le(`:scope > li:nth-child(${c})`,e)&&(a.set(c,fs(c,i)),s.replaceWith(a.get(c)))}return a.size===0?y:j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=[];for(let[u,p]of a)l.push([G(".md-typeset",p),G(`:scope > li:nth-child(${u})`,e)]);return n.pipe(Q(c)).subscribe(u=>{e.hidden=!u,e.classList.toggle("md-annotation-list",u);for(let[p,d]of l)u?xs(p,d):xs(d,p)}),R(...[...a].map(([,u])=>ys(u,t,{target$:r}))).pipe(V(()=>s.complete()),xe())})}function ws(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return ws(t)}}function Es(e,t){return j(()=>{let r=ws(e);return typeof r!="undefined"?Ln(r,e,t):y})}var Ss=_r(Mo());var op=0,Ts=R(b(window,"keydown").pipe(f(()=>!0)),R(b(window,"keyup"),b(window,"contextmenu")).pipe(f(()=>!1))).pipe(J(!1),se(1));function Os(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return Os(t)}}function ip(e){return Re(e).pipe(f(({width:t})=>({scrollable:Mr(e).width>t})),fe("scrollable"))}function Ls(e,t){let{matches:r}=matchMedia("(hover)"),n=j(()=>{let o=new I,i=o.pipe(Gn(1));o.subscribe(({scrollable:m})=>{m&&r?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")});let a=[],s=e.closest("pre"),c=s.closest("[id]"),l=c?c.id:op++;s.id=`__code_${l}`;let u=[],p=e.closest(".highlight");if(p instanceof HTMLElement){let m=Os(p);if(typeof m!="undefined"&&(p.classList.contains("annotate")||X("content.code.annotate"))){let h=Ln(m,e,t);u.push(Re(p).pipe(Q(i),f(({width:v,height:x})=>v&&x),ie(),g(v=>v?h:y)))}}let d=P(":scope > span[id]",e);if(d.length&&(e.classList.add("md-code__content"),e.closest(".select")||X("content.code.select")&&!e.closest(".no-select"))){let m=+d[0].id.split("-").pop(),h=ds();a.push(h),X("content.tooltips")&&u.push(Ge(h,{viewport$}));let v=b(h,"click").pipe(Or(M=>!M,!1),$(()=>h.blur()),xe());v.subscribe(M=>{h.classList.toggle("md-code__button--active",M)});let x=me(d).pipe(oe(M=>Ft(M).pipe(f(O=>[M,O]))));v.pipe(g(M=>M?x:y)).subscribe(([M,O])=>{let N=Le(".hll.select",M);if(N&&!O)N.replaceWith(...Array.from(N.childNodes));else if(!N&&O){let ee=document.createElement("span");ee.className="hll select",ee.append(...Array.from(M.childNodes).slice(1)),M.append(ee)}});let w=me(d).pipe(oe(M=>b(M,"mousedown").pipe($(O=>O.preventDefault()),f(()=>M)))),E=v.pipe(g(M=>M?w:y),pe(Ts),f(([M,O])=>{var ee;let N=d.indexOf(M)+m;if(O===!1)return[N,N];{let le=P(".hll",e).map(ce=>d.indexOf(ce.parentElement)+m);return(ee=window.getSelection())==null||ee.removeAllRanges(),[Math.min(N,...le),Math.max(N,...le)]}})),_=_o(y).pipe(L(M=>M.startsWith(`__codelineno-${l}-`)));_.subscribe(M=>{let[,,O]=M.split("-"),N=O.split(":").map(le=>+le-m+1);N.length===1&&N.push(N[0]);for(let le of P(".hll:not(.select)",e))le.replaceWith(...Array.from(le.childNodes));let ee=d.slice(N[0]-1,N[1]);for(let le of ee){let ce=document.createElement("span");ce.className="hll",ce.append(...Array.from(le.childNodes).slice(1)),le.append(ce)}}),_.pipe(Me(1),Ie(ge)).subscribe(M=>{if(M.includes(":")){let O=document.getElementById(M.split(":")[0]);O&&setTimeout(()=>{let N=O,ee=-64;for(;N!==document.body;)ee+=N.offsetTop,N=N.offsetParent;window.scrollTo({top:ee})},1)}});let be=me(P('a[href^="#__codelineno"]',p)).pipe(oe(M=>b(M,"click").pipe($(O=>O.preventDefault()),f(()=>M)))).pipe(Q(i),pe(Ts),f(([M,O])=>{let ee=+G(`[id="${M.hash.slice(1)}"]`).parentElement.id.split("-").pop();if(O===!1)return[ee,ee];{let le=P(".hll",e).map(ce=>+ce.parentElement.id.split("-").pop());return[Math.min(ee,...le),Math.max(ee,...le)]}}));R(E,be).subscribe(M=>{let O=`#__codelineno-${l}-`;M[0]===M[1]?O+=M[0]:O+=`${M[0]}:${M[1]}`,history.replaceState({},"",O),window.dispatchEvent(new HashChangeEvent("hashchange",{newURL:window.location.origin+window.location.pathname+O,oldURL:window.location.href}))})}if(Ss.default.isSupported()&&(e.closest(".copy")||X("content.code.copy")&&!e.closest(".no-copy"))){let m=ms(s.id);a.push(m),X("content.tooltips")&&u.push(Ge(m,{viewport$}))}if(a.length){let m=hs();m.append(...a),s.insertBefore(m,e)}return ip(e).pipe($(m=>o.next(m)),V(()=>o.complete()),f(m=>H({ref:e},m)),Rt(R(...u).pipe(Q(i))))});return X("content.lazy")?Et(e).pipe(L(o=>o),Me(1),g(()=>n)):n}function ap(e,{target$:t,print$:r}){let n=!0;return R(t.pipe(f(o=>o.closest("details:not([open])")),L(o=>e===o),f(()=>({action:"open",reveal:!0}))),r.pipe(L(o=>o||!n),$(()=>n=e.open),f(o=>({action:o?"open":"close"}))))}function Ms(e,t){return j(()=>{let r=new I;return r.subscribe(({action:n,reveal:o})=>{e.toggleAttribute("open",n==="open"),o&&e.scrollIntoView()}),ap(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}var ks=0,As=new Map;function sp(e){let t=document.createElement("h3");t.innerHTML=e.innerHTML;let r=[t],n=e.nextElementSibling;for(;n&&!(n instanceof HTMLHeadingElement);)r.push(n.cloneNode(!0)),n=n.nextElementSibling;return r}function cp(e,t){for(let r of P("[href], [src]",e))for(let n of["href","src"]){let o=r.getAttribute(n);if(o&&!/^(?:[a-z]+:)?\/\//i.test(o)){r[n]=new URL(r.getAttribute(n),t).toString();break}}for(let r of P("[name^=__], [for]",e))for(let n of["id","for","name"]){let o=r.getAttribute(n);o&&r.setAttribute(n,`${o}$preview_${ks}`)}return ks++,Y(e)}function lp(e){let t=As.get(e.toString());return t?Y(t):En(e).pipe(g(r=>cp(r,e)),f(r=>(As.set(e.toString(),r),r)))}function Cs(e,t){let{sitemap$:r}=t;if(!(e instanceof HTMLAnchorElement))return y;if(!(X("navigation.instant.preview")||e.hasAttribute("data-preview")))return y;e.removeAttribute("title");let n=re([ir(e),Ft(e).pipe(ke(1))]).pipe(f(([i,a])=>i||a),ie(),L(i=>i));return $t([r,n]).pipe(g(([i])=>{let a=new URL(e.href);return a.search=a.hash="",i.has(`${a}`)?Y(a):y}),g(i=>lp(i)),g(i=>{let a=e.hash?`article [id="${decodeURIComponent(e.hash.slice(1))}"]`:"article h1",s=Le(a,i);return typeof s=="undefined"?y:Y(sp(s))})).pipe(g(i=>{let a=new U(s=>{let c=On(...i);return s.next(c),document.body.append(c),()=>c.remove()});return Rr(e,H({content$:a},t))}))}var Hs=".node circle,.node ellipse,.node path,.node polygon,.node rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}marker{fill:var(--md-mermaid-edge-color)!important}.edgeLabel .label rect{fill:#0000}.flowchartTitleText{fill:var(--md-mermaid-label-fg-color)}.label{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.label foreignObject{line-height:normal;overflow:visible}.label div .edgeLabel{color:var(--md-mermaid-label-fg-color)}.edgeLabel,.edgeLabel p,.label div .edgeLabel{background-color:var(--md-mermaid-label-bg-color)}.edgeLabel,.edgeLabel p{fill:var(--md-mermaid-label-bg-color);color:var(--md-mermaid-edge-color)}.edgePath .path,.flowchart-link{stroke:var(--md-mermaid-edge-color)}.edgePath .arrowheadPath{fill:var(--md-mermaid-edge-color);stroke:none}.cluster rect{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}.cluster span{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}g #flowchart-circleEnd,g #flowchart-circleStart,g #flowchart-crossEnd,g #flowchart-crossStart,g #flowchart-pointEnd,g #flowchart-pointStart{stroke:none}.classDiagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.classGroup line,g.classGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.classGroup text{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.classLabel .box{fill:var(--md-mermaid-label-bg-color);background-color:var(--md-mermaid-label-bg-color);opacity:1}.classLabel .label{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.node .divider{stroke:var(--md-mermaid-node-fg-color)}.relation{stroke:var(--md-mermaid-edge-color)}.cardinality{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.cardinality text{fill:inherit!important}defs marker.marker.composition.class path,defs marker.marker.dependency.class path,defs marker.marker.extension.class path{fill:var(--md-mermaid-edge-color)!important;stroke:var(--md-mermaid-edge-color)!important}defs marker.marker.aggregation.class path{fill:var(--md-mermaid-label-bg-color)!important;stroke:var(--md-mermaid-edge-color)!important}.statediagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.stateGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.stateGroup .state-title{fill:var(--md-mermaid-label-fg-color)!important;font-family:var(--md-mermaid-font-family)}g.stateGroup .composit{fill:var(--md-mermaid-label-bg-color)}.nodeLabel,.nodeLabel p{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}a .nodeLabel{text-decoration:underline}.node circle.state-end,.node circle.state-start,.start-state{fill:var(--md-mermaid-edge-color);stroke:none}.end-state-inner,.end-state-outer{fill:var(--md-mermaid-edge-color)}.end-state-inner,.node circle.state-end{stroke:var(--md-mermaid-label-bg-color)}.transition{stroke:var(--md-mermaid-edge-color)}[id^=state-fork] rect,[id^=state-join] rect{fill:var(--md-mermaid-edge-color)!important;stroke:none!important}.statediagram-cluster.statediagram-cluster .inner{fill:var(--md-default-bg-color)}.statediagram-cluster rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}.statediagram-state rect.divider{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}defs #statediagram-barbEnd{stroke:var(--md-mermaid-edge-color)}[id^=entity] path,[id^=entity] rect{fill:var(--md-default-bg-color)}.relationshipLine{stroke:var(--md-mermaid-edge-color)}defs .marker.oneOrMore.er *,defs .marker.onlyOne.er *,defs .marker.zeroOrMore.er *,defs .marker.zeroOrOne.er *{stroke:var(--md-mermaid-edge-color)!important}text:not([class]):last-child{fill:var(--md-mermaid-label-fg-color)}.actor{fill:var(--md-mermaid-sequence-actor-bg-color);stroke:var(--md-mermaid-sequence-actor-border-color)}text.actor>tspan{fill:var(--md-mermaid-sequence-actor-fg-color);font-family:var(--md-mermaid-font-family)}line{stroke:var(--md-mermaid-sequence-actor-line-color)}.actor-man circle,.actor-man line{fill:var(--md-mermaid-sequence-actorman-bg-color);stroke:var(--md-mermaid-sequence-actorman-line-color)}.messageLine0,.messageLine1{stroke:var(--md-mermaid-sequence-message-line-color)}.note{fill:var(--md-mermaid-sequence-note-bg-color);stroke:var(--md-mermaid-sequence-note-border-color)}.loopText,.loopText>tspan,.messageText,.noteText>tspan{stroke:none;font-family:var(--md-mermaid-font-family)!important}.messageText{fill:var(--md-mermaid-sequence-message-fg-color)}.loopText,.loopText>tspan{fill:var(--md-mermaid-sequence-loop-fg-color)}.noteText>tspan{fill:var(--md-mermaid-sequence-note-fg-color)}#arrowhead path{fill:var(--md-mermaid-sequence-message-line-color);stroke:none}.loopLine{fill:var(--md-mermaid-sequence-loop-bg-color);stroke:var(--md-mermaid-sequence-loop-border-color)}.labelBox{fill:var(--md-mermaid-sequence-label-bg-color);stroke:none}.labelText,.labelText>span{fill:var(--md-mermaid-sequence-label-fg-color);font-family:var(--md-mermaid-font-family)}.sequenceNumber{fill:var(--md-mermaid-sequence-number-fg-color)}rect.rect{fill:var(--md-mermaid-sequence-box-bg-color);stroke:none}rect.rect+text.text{fill:var(--md-mermaid-sequence-box-fg-color)}defs #sequencenumber{fill:var(--md-mermaid-sequence-number-bg-color)!important}";var ko,pp=0;function fp(){return typeof mermaid=="undefined"||mermaid instanceof Element?ar("https://unpkg.com/mermaid@11/dist/mermaid.min.js"):Y(void 0)}function $s(e){return e.classList.remove("mermaid"),ko||(ko=fp().pipe($(()=>mermaid.initialize({startOnLoad:!1,themeCSS:Hs,sequence:{actorFontSize:"16px",messageFontSize:"16px",noteFontSize:"16px"}})),f(()=>{}),se(1))),ko.subscribe(()=>Uo(null,null,function*(){e.classList.add("mermaid");let t=`__mermaid_${pp++}`,r=A("div",{class:"mermaid"}),n=e.textContent,{svg:o,fn:i}=yield mermaid.render(t,n),a=r.attachShadow({mode:"closed"});a.innerHTML=o,e.replaceWith(r),i==null||i(a)})),ko.pipe(f(()=>({ref:e})))}var Ps=A("table");function Is(e){return e.replaceWith(Ps),Ps.replaceWith(gs(e)),Y({ref:e})}function mp(e){let t=e.find(r=>r.checked)||e[0];return R(...e.map(r=>b(r,"change").pipe(f(()=>G(`label[for="${r.id}"]`))))).pipe(J(G(`label[for="${t.id}"]`)),f(r=>({active:r})))}function Rs(e,{viewport$:t,target$:r}){let n=G(".tabbed-labels",e),o=P(":scope > input",e),i=Oo("prev");e.append(i);let a=Oo("next");return e.append(a),j(()=>{let s=new I,c=s.pipe(he(),ye(!0));re([s,Re(e),Et(e)]).pipe(Q(c),Xe(1,je)).subscribe({next([{active:l},u]){let p=wt(l),{width:d}=Ae(l);e.style.setProperty("--md-indicator-x",`${p.x}px`),e.style.setProperty("--md-indicator-width",`${d}px`);let m=ln(n);(p.x<m.x||p.x+d>m.x+u.width)&&n.scrollTo({left:Math.max(0,p.x-16),behavior:"smooth"})},complete(){e.style.removeProperty("--md-indicator-x"),e.style.removeProperty("--md-indicator-width")}}),re([Ut(n),Re(n)]).pipe(Q(c)).subscribe(([l,u])=>{let p=Mr(n);i.hidden=l.x<16,a.hidden=l.x>p.width-u.width-16}),R(b(i,"click").pipe(f(()=>-1)),b(a,"click").pipe(f(()=>1))).pipe(Q(c)).subscribe(l=>{let{width:u}=Ae(n);n.scrollBy({left:u*l,behavior:"smooth"})}),r.pipe(Q(c),L(l=>o.includes(l))).subscribe(l=>l.click()),n.classList.add("tabbed-labels--linked");for(let l of o){let u=G(`label[for="${l.id}"]`);u.replaceChildren(A("a",{href:`#${u.htmlFor}`,tabIndex:-1},...Array.from(u.childNodes))),b(u.firstElementChild,"click").pipe(Q(c),L(p=>!(p.metaKey||p.ctrlKey)),$(p=>{p.preventDefault(),p.stopPropagation()})).subscribe(()=>{history.replaceState({},"",`#${u.htmlFor}`),u.click()})}return X("content.tabs.link")&&s.pipe(ke(1),pe(t)).subscribe(([{active:l},{offset:u}])=>{let p=l.innerText.trim();if(l.hasAttribute("data-md-switching"))l.removeAttribute("data-md-switching");else{let d=e.offsetTop-u.y;for(let h of P("[data-tabs]"))for(let v of P(":scope > input",h)){let x=G(`label[for="${v.id}"]`);if(x!==l&&x.innerText.trim()===p){x.setAttribute("data-md-switching",""),v.click();break}}window.scrollTo({top:e.offsetTop-d});let m=__md_get("__tabs")||[];__md_set("__tabs",[...new Set([p,...m])])}}),s.pipe(Q(c)).subscribe(()=>{for(let l of P("audio, video",e))l.offsetWidth&&l.autoplay?l.play().catch(()=>{}):l.pause()}),mp(o).pipe($(l=>s.next(l)),V(()=>s.complete()),f(l=>H({ref:e},l)))}).pipe(Ht(ge))}function js(e,t){let{viewport$:r,target$:n,print$:o}=t;return R(...P(".annotate:not(.highlight)",e).map(i=>Es(i,{target$:n,print$:o})),...P("pre:not(.mermaid) > code",e).map(i=>Ls(i,{target$:n,print$:o})),...P("a",e).map(i=>Cs(i,t)),...P("pre.mermaid",e).map(i=>$s(i)),...P("table:not([class])",e).map(i=>Is(i)),...P("details",e).map(i=>Ms(i,{target$:n,print$:o})),...P("[data-tabs]",e).map(i=>Rs(i,{viewport$:r,target$:n})),...P("[title]:not([data-preview])",e).filter(()=>X("content.tooltips")).map(i=>Ge(i,{viewport$:r})),...P(".footnote-ref",e).filter(()=>X("content.footnote.tooltips")).map(i=>Rr(i,{content$:new U(a=>{let s=new URL(i.href).hash.slice(1),c=Array.from(document.getElementById(s).cloneNode(!0).children),l=On(...c);return a.next(l),document.body.append(l),()=>l.remove()}),viewport$:r})))}function dp(e,{alert$:t}){return t.pipe(g(r=>R(Y(!0),Y(!1).pipe(It(2e3))).pipe(f(n=>({message:r,active:n})))))}function Fs(e,t){let r=G(".md-typeset",e);return j(()=>{let n=new I;return n.subscribe(({message:o,active:i})=>{e.classList.toggle("md-dialog--active",i),r.textContent=o}),dp(e,t).pipe($(o=>n.next(o)),V(()=>n.complete()),f(o=>H({ref:e},o)))})}function hp({viewport$:e}){if(!X("header.autohide"))return Y(!1);let t=e.pipe(f(({offset:{y:o}})=>o),Pt(2,1),f(([o,i])=>[o<i,i]),fe(0)),r=re([e,t]).pipe(L(([{offset:o},[,i]])=>Math.abs(i-o.y)>100),f(([,[o]])=>o),ie()),n=Tn("search");return re([e,n]).pipe(f(([{offset:o},i])=>o.y>400&&!i),ie(),g(o=>o?r:Y(!1)),J(!1))}function Us(e,t){return j(()=>re([Re(e),hp(t)])).pipe(f(([{height:r},n])=>({height:r,hidden:n})),ie((r,n)=>r.height===n.height&&r.hidden===n.hidden),se(1))}function Ns(e,{viewport$:t,header$:r,main$:n}){return j(()=>{let o=new I,i=o.pipe(he(),ye(!0));o.pipe(fe("active"),Ze(r)).subscribe(([{active:s},{hidden:c}])=>{e.classList.toggle("md-header--shadow",s&&!c),e.hidden=c});let a=me(P("[title]",e)).pipe(L(()=>X("content.tooltips")),oe(s=>Ge(s,{viewport$:t})));return n.subscribe(o),r.pipe(Q(i),f(s=>H({ref:e},s)),Rt(a.pipe(Q(i))))})}function vp(e,{viewport$:t,header$:r}){return Sn(e,{viewport$:t,header$:r}).pipe(f(({offset:{y:n}})=>{let{height:o}=Ae(e);return{active:o>0&&n>=o}}),fe("active"))}function Ds(e,t){return j(()=>{let r=new I;r.subscribe({next({active:o}){e.classList.toggle("md-header__title--active",o)},complete(){e.classList.remove("md-header__title--active")}});let n=Le(".md-content h1");return typeof n=="undefined"?y:vp(n,t).pipe($(o=>r.next(o)),V(()=>r.complete()),f(o=>H({ref:e},o)))})}function Ws(e,{viewport$:t,header$:r}){let n=r.pipe(f(({height:i})=>i),ie()),o=n.pipe(g(()=>Re(e).pipe(f(({height:i})=>({top:e.offsetTop,bottom:e.offsetTop+i})),fe("bottom"))));return re([n,o,t]).pipe(f(([i,{top:a,bottom:s},{offset:{y:c},size:{height:l}}])=>(l=Math.max(0,l-Math.max(0,a-c,i)-Math.max(0,l+c-s)),{offset:a-i,height:l,active:a-i<=c})),ie((i,a)=>i.offset===a.offset&&i.height===a.height&&i.active===a.active))}function bp(e){let t=__md_get("__palette")||{index:e.findIndex(n=>matchMedia(n.getAttribute("data-md-color-media")).matches)},r=Math.max(0,Math.min(t.index,e.length-1));return Y(...e).pipe(oe(n=>b(n,"change").pipe(f(()=>n))),J(e[r]),f(n=>({index:e.indexOf(n),color:{media:n.getAttribute("data-md-color-media"),scheme:n.getAttribute("data-md-color-scheme"),primary:n.getAttribute("data-md-color-primary"),accent:n.getAttribute("data-md-color-accent")}})),se(1))}function Vs(e){let t=P("input",e),r=A("meta",{name:"theme-color"});document.head.appendChild(r);let n=A("meta",{name:"color-scheme"});document.head.appendChild(n);let o=Ir("(prefers-color-scheme: light)");return j(()=>{let i=new I;return i.subscribe(a=>{if(document.body.setAttribute("data-md-color-switching",""),a.color.media==="(prefers-color-scheme)"){let s=matchMedia("(prefers-color-scheme: light)"),c=document.querySelector(s.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");a.color.scheme=c.getAttribute("data-md-color-scheme"),a.color.primary=c.getAttribute("data-md-color-primary"),a.color.accent=c.getAttribute("data-md-color-accent")}for(let[s,c]of Object.entries(a.color))document.body.setAttribute(`data-md-color-${s}`,c);for(let s=0;s<t.length;s++){let c=t[s].nextElementSibling;c instanceof HTMLElement&&(c.hidden=a.index!==s)}__md_set("__palette",a)}),b(e,"keydown").pipe(L(a=>a.key==="Enter"),pe(i,(a,s)=>s)).subscribe(({index:a})=>{a=(a+1)%t.length,t[a].click(),t[a].focus()}),i.pipe(f(()=>{let a=ht("header"),s=window.getComputedStyle(a);return n.content=s.colorScheme,s.backgroundColor.match(/\d+/g).map(c=>(+c).toString(16).padStart(2,"0")).join("")})).subscribe(a=>r.content=`#${a}`),i.pipe(Ie(ge)).subscribe(()=>{document.body.removeAttribute("data-md-color-switching")}),bp(t).pipe(Q(o.pipe(ke(1))),jt(),$(a=>i.next(a)),V(()=>i.complete()),f(a=>H({ref:e},a)))})}function zs(e,{progress$:t}){return j(()=>{let r=new I;return r.subscribe(({value:n})=>{e.style.setProperty("--md-progress-value",`${n}`)}),t.pipe($(n=>r.next({value:n})),V(()=>r.complete()),f(n=>({ref:e,value:n})))})}var qs='.v u{text-decoration:underline!important;text-decoration-style:wavy!important;text-decoration-thickness:1px!important}.p{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-backdrop)/var(--alpha-lighter));cursor:pointer;height:100%;pointer-events:auto;position:absolute;transition:opacity .25s;width:100%}.p.m{opacity:0;pointer-events:none;transition:opacity .35s}.r{align-items:center;background-color:initial;border:none;border-radius:var(--space-2);cursor:pointer;display:flex;flex-shrink:0;font-family:var(--font-family);height:36px;justify-content:center;outline:none;padding:0;position:relative;transition:background-color .25s,color .25s;width:36px;z-index:1}.r svg{stroke:rgb(var(--color-foreground));height:18px;opacity:.5;width:18px}.r:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.r:hover:before{opacity:1;transform:scale(1)}.r.c{cursor:auto}.r.c:before{display:none}.n{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background)/var(--alpha-light));border-radius:var(--space-3);box-shadow:0 0 60px #0000000d;display:flex;height:480px;overflow:hidden;pointer-events:auto;position:absolute;transition:transform .25s cubic-bezier(.16,1,.3,1),opacity .25s;width:640px}.n.l{opacity:0;pointer-events:none;transform:scale(1.1);transition:transform .25s .15s,opacity .15s}@media (max-width:680px){.n{border-radius:0;height:100%;width:100%}}.u{display:flex;flex-basis:min-content;flex-direction:column;flex-grow:1;flex-shrink:0}@keyframes d{0%{transform:scale(0)}50%{transform:scale(1.2)}to{transform:scale(1)}}.y{animation:d .25s ease-in-out;background:var(--color-highlight);border-radius:100%;color:#fff;font-size:8px;font-weight:700;height:12px;padding-top:1px;position:absolute;right:4px;top:4px;width:12px}.i{background-color:rgb(var(--color-background-subtle)/var(--alpha-lighter));flex-shrink:0;overflow:scroll;position:relative;transition:width .35s cubic-bezier(.16,1,.3,1),opacity .25s;width:200px}.i>*{transform:translate(0);transition:transform .25s cubic-bezier(.16,1,.3,1)}.i.l{opacity:0;width:0}.i.l>*{transform:translate(-48px)}@media (max-width:680px){.i{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background-subtle)/var(--alpha-light));box-shadow:0 0 60px #00000026;height:100%;position:absolute;right:0;top:0}}.w{border-bottom:1px solid rgb(var(--color-foreground)/var(--alpha-lightest));display:flex;gap:var(--space-1);padding:var(--space-2)}.k{-webkit-overflow-scrolling:touch;overflow:auto;overscroll-behavior:contain}.z{padding:8px 10px}.X{color:rgb(var(--color-foreground)/var(--alpha-light));padding:var(--space-2);position:absolute;width:200px}.X,.j{display:flex;flex-direction:column}.j{gap:2px;list-style:none;padding:0}.F,.j{margin:0}.F{font-size:16px;font-weight:400}.F,.I{padding:8px}.I{font-size:14px;margin:4px 0 0;opacity:.5}.I,.o{font-size:12px}.o{cursor:pointer;display:flex;padding:4px 8px;position:relative}.o:before{background-color:var(--color-highlight-transparent);border-radius:var(--space-1);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.o.g:before,.o:hover:before{opacity:1;transform:scale(1)}.o.g,.o:hover{color:var(--color-highlight)}.R{flex-grow:1}.R,.q{position:relative}.q{font-weight:700}.f{flex-grow:1}.f input{background:#0000;border:none;color:rgb(var(--color-foreground));font-family:var(--font-family);font-size:16px;height:100%;letter-spacing:-.25px;outline:none;width:100%}.b{color:rgb(var(--color-foreground)/var(--alpha-light));display:flex;flex-direction:column;gap:2px;line-height:1.3;list-style:none;margin:var(--space-2);margin-top:0;padding:0}.A,.b li{margin:0}.A{color:rgb(var(--color-foreground)/var(--alpha-lighter));font-size:12px;margin-top:var(--space-2);padding:0 18px}.a{border-radius:var(--space-2);color:inherit;cursor:pointer;display:flex;flex-direction:row;flex-grow:1;padding:8px 10px;position:relative;text-decoration:none}.a:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";display:block;inset:0;opacity:0;position:absolute;transform:scale(.9);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.a.h:before,.a:hover:before{opacity:1;transform:scale(1)}}.a mark{background:#0000;color:var(--color-highlight)}.a u{background-color:var(--color-highlight-transparent);border-radius:2px;box-shadow:0 0 0 1px var(--color-highlight-transparent);text-decoration:none}.B{flex-grow:1}.s{margin-right:-8px;opacity:0;position:relative;transform:translate(-2px);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.h>.s,:hover>.s{opacity:1;transform:none}}.x{font-size:14px;margin:0;position:relative}.x code{background:rgb(var(--color-background-subtle));border-radius:var(--space-1);font-size:13px;padding:2px 4px}.t{color:rgb(var(--color-foreground)/var(--alpha-lighter));display:inline-flex;flex-wrap:wrap;font-size:12px;gap:var(--space-1);list-style:none;margin:0;padding:0;position:relative}.t li{white-space:nowrap}.t li:after{content:"/";display:inline;margin-left:var(--space-1)}.t li:last-child:after{content:"";display:none}.e{--space-1:4px;--space-2:calc(var(--space-1)*2);--space-3:calc(var(--space-2)*2);--space-4:calc(var(--space-3)*2);--space-5:calc(var(--space-4)*2);--alpha-light:.7;--alpha-lighter:.54;--alpha-lightest:.1;--color-highlight:var(--md-accent-fg-color,#526cfe);--color-highlight-transparent:var(--md-accent-fg-color--transparent,#526cfe1a);--border-radius-1:var(--space-1);--border-radius-2:var(--space-2);--border-radius-3:calc(var(--space-1) + var(--space-2));--font-family:var(--md-text-font-family,Inter,Roboto Flex,system-ui,sans-serif);--font-size:16px;--line-height:1.5;--letter-spacing:-.5px;-webkit-font-smoothing:antialiased;align-items:center;display:flex;font-family:var(--font-family);font-size:var(--font-size);height:100vh;justify-content:center;letter-spacing:var(--letter-spacing);line-height:var(--line-height);pointer-events:none;position:absolute;width:100vw}@media (pointer:coarse){.e{height:-webkit-fill-available}}.e *,.e :after,.e :before{box-sizing:border-box}';function Ks(e,{index$:t}){let r=Ue(),n=document.createElement("div");document.body.appendChild(n),n.style.position="fixed",n.style.height="100%",n.style.top="0",n.style.zIndex="4";let o=n.attachShadow({mode:"open"});o.appendChild(A("style",{},qs.toString()));try{Ya(r.search,{highlight:r.features.includes("search.highlight")}),me(t).subscribe(i=>{for(let a of i.items)a.location=new URL(a.location,r.base).toString();Ja(i,o)}),b(e,"click").subscribe(()=>{go()}),Tn("search").pipe(ke(1)).subscribe(()=>go())}catch(i){e.hidden=!0;let a=G("label[for=__search]");a.hidden=!0}return Ke}var Bs=_r(So());function Ys(e,{index$:t,location$:r}){return re([t,r.pipe(J(Ye()),L(n=>!!n.searchParams.get("h")))]).pipe(f(([n,o])=>_p(n.config)(o.searchParams.get("h"))),f(n=>{var a;let o=new Map,i=document.createNodeIterator(e,NodeFilter.SHOW_TEXT);for(let s=i.nextNode();s;s=i.nextNode())if((a=s.parentElement)!=null&&a.offsetHeight){let c=s.textContent,l=n(c);l.length>c.length&&o.set(s,l)}for(let[s,c]of o){let{childNodes:l}=A("span",null,c);s.replaceWith(...Array.from(l))}return{ref:e,nodes:o}}))}function _p(e){let t=e.separator.split("|").map(o=>o.replace(/(\(\?[!=<][^)]+\))/g,"").length===0?"\uFFFD":o).join("|"),r=new RegExp(t,"img"),n=(o,i,a)=>`${i}<mark data-md-highlight>${a}</mark>`;return o=>{o=o.replace(/\s+/g," ").replace(/&/g,"&amp;").trim();let i=new RegExp(`(^|${e.separator}|)(${o.split(r).map(a=>a.replace(/[|\\{}()[\]^$+*?.-]/g,"\\$&")).filter(a=>a.length>0).join("|")})`,"img");return a=>(0,Bs.default)(a).replace(i,n).replace(/<\/mark>(\s+)<mark[^>]*>/img,"$1")}}function yp(e,{viewport$:t,main$:r}){let n=e.closest(".md-grid"),o=n.offsetTop-n.parentElement.offsetTop;return re([r,t]).pipe(f(([{offset:i,height:a},{offset:{y:s}}])=>(a=a+Math.min(o,Math.max(0,s-i))-o,{height:a,locked:s>=i+o})),ie((i,a)=>i.height===a.height&&i.locked===a.locked))}function Ao(e,n){var o=n,{header$:t}=o,r=gr(o,["header$"]);let i=G(".md-sidebar__scrollwrap",e),{y:a}=wt(i);return j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=s.pipe(Xe(0,je));return l.pipe(pe(t)).subscribe({next([{height:u},{height:p}]){i.style.height=`${u-2*a}px`,e.style.top=`${p}px`},complete(){i.style.height="",e.style.top=""}}),l.pipe(Sr()).subscribe(()=>{for(let u of P(".md-nav__link--active[href]",e)){if(!u.clientHeight)continue;let p=u.closest(".md-sidebar__scrollwrap");if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2})}}}),me(P("label[tabindex]",e)).pipe(oe(u=>b(u,"click").pipe(Ie(ge),f(()=>u),Q(c)))).subscribe(u=>{let p=G(`[id="${u.htmlFor}"]`);G(`[aria-labelledby="${u.id}"]`).setAttribute("aria-expanded",`${p.checked}`)}),X("content.tooltips")&&me(P("abbr[title]",e)).pipe(oe(u=>Ge(u,{viewport$})),Q(c)).subscribe(),yp(e,r).pipe($(u=>s.next(u)),V(()=>s.complete()),f(u=>H({ref:e},u)))})}function Gs(e,t){if(typeof t!="undefined"){let r=`https://api.github.com/repos/${e}/${t}`;return $t(et(`${r}/releases/latest`).pipe(_e(()=>y),f(n=>({version:n.tag_name})),ot({})),et(r).pipe(_e(()=>y),f(n=>({stars:n.stargazers_count,forks:n.forks_count})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}else{let r=`https://api.github.com/users/${e}`;return et(r).pipe(f(n=>({repositories:n.public_repos})),ot({}))}}function Js(e,t){let r=`https://${e}/api/v4/projects/${encodeURIComponent(t)}`;return $t(et(`${r}/releases/permalink/latest`).pipe(_e(()=>y),f(({tag_name:n})=>({version:n})),ot({})),et(r).pipe(_e(()=>y),f(({star_count:n,forks_count:o})=>({stars:n,forks:o})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}function Xs(e){let t=e.match(/^.+github\.com\/([^/]+)\/?([^/]+)?/i);if(t){let[,r,n]=t;return Gs(r,n)}if(t=e.match(/^.+?([^/]*gitlab[^/]+)\/(.+?)\/?$/i),t){let[,r,n]=t;return Js(r,n)}return y}var xp;function wp(e){return xp||(xp=j(()=>{let t=__md_get("__source",sessionStorage);if(t)return Y(t);if(Ee("consent").length){let n=__md_get("__consent");if(!(n&&n.github))return y}return Xs(e.href).pipe($(n=>__md_set("__source",n,sessionStorage)))}).pipe(_e(()=>y),L(t=>Object.keys(t).length>0),f(t=>({facts:t})),se(1)))}function Zs(e){let t=G(":scope > :last-child",e);return j(()=>{let r=new I;return r.subscribe(({facts:n})=>{t.appendChild(bs(n)),t.classList.add("md-source__repository--active")}),wp(e).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Ep(e,{viewport$:t,header$:r}){return Re(document.body).pipe(g(()=>Sn(e,{header$:r,viewport$:t})),f(({offset:{y:n}})=>({hidden:n>=10})),fe("hidden"))}function Qs(e,t){return j(()=>{let r=new I;return r.subscribe({next({hidden:n}){e.hidden=n},complete(){e.hidden=!1}}),(X("navigation.tabs.sticky")?Y({hidden:!1}):Ep(e,t)).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Tp(e,{viewport$:t,header$:r}){let n=new Map,o=P(".md-nav__link",e);for(let s of o){let c=decodeURIComponent(s.hash.substring(1)),l=Le(`[id="${c}"]`);typeof l!="undefined"&&n.set(s,l)}let i=r.pipe(fe("height"),f(({height:s})=>{let c=ht("main"),l=G(":scope > :first-child",c);return s+.9*(l.offsetTop-c.offsetTop)}),xe());return Re(document.body).pipe(fe("height"),g(s=>j(()=>{let c=[];return Y([...n].reduce((l,[u,p])=>{for(;c.length&&n.get(c[c.length-1]).tagName>=p.tagName;)c.pop();let d=p.offsetTop;for(;!d&&p.parentElement;)p=p.parentElement,d=p.offsetTop;let m=p.offsetParent;for(;m;m=m.offsetParent)d+=m.offsetTop;return l.set([...c=[...c,u]].reverse(),d)},new Map))}).pipe(f(c=>new Map([...c].sort(([,l],[,u])=>l-u))),Ze(i),g(([c,l])=>t.pipe(Or(([u,p],{offset:{y:d},size:m})=>{let h=d+m.height>=Math.floor(s.height);for(;p.length;){let[,v]=p[0];if(v-l<d||h)u=[...u,p.shift()];else break}for(;u.length;){let[,v]=u[u.length-1];if(v-l>=d&&!h)p=[u.pop(),...p];else break}return[u,p]},[[],[...c]]),ie((u,p)=>u[0]===p[0]&&u[1]===p[1])))))).pipe(f(([s,c])=>({prev:s.map(([l])=>l),next:c.map(([l])=>l)})),J({prev:[],next:[]}),Pt(2,1),f(([s,c])=>s.prev.length<c.prev.length?{prev:c.prev.slice(Math.max(0,s.prev.length-1),c.prev.length),next:[]}:{prev:c.prev.slice(-1),next:c.next.slice(0,c.next.length-s.next.length)}))}function ec(e,{viewport$:t,header$:r,main$:n,target$:o}){return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));if(i.subscribe(({prev:s,next:c})=>{for(let[l]of c)l.classList.remove("md-nav__link--passed"),l.classList.remove("md-nav__link--active");for(let[l,[u]]of s.entries())u.classList.add("md-nav__link--passed"),u.classList.toggle("md-nav__link--active",l===s.length-1)}),X("toc.follow")){let s=R(t.pipe(Be(1),f(()=>{})),t.pipe(Be(250),f(()=>"smooth")));i.pipe(L(({prev:c})=>c.length>0),Ze(n.pipe(Ie(ge))),pe(s)).subscribe(([[{prev:c}],l])=>{let[u]=c[c.length-1];if(u.offsetHeight){let p=ki(u);if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2,behavior:l})}}})}return X("navigation.tracking")&&t.pipe(Q(a),fe("offset"),Be(250),ke(1),Q(o.pipe(ke(1))),jt({delay:250}),pe(i)).subscribe(([,{prev:s}])=>{let c=Ye(),l=s[s.length-1];if(l&&l.length){let[u]=l,{hash:p}=new URL(u.href);c.hash!==p&&(c.hash=p,history.replaceState({},"",`${c}`))}else c.hash="",history.replaceState({},"",`${c}`)}),Tp(e,{viewport$:t,header$:r}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function Sp(e,{viewport$:t,main$:r,target$:n}){let o=t.pipe(f(({offset:{y:a}})=>a),Pt(2,1),f(([a,s])=>a>s&&s>0),ie()),i=r.pipe(f(({active:a})=>a));return re([i,o]).pipe(f(([a,s])=>!(a&&s)),ie(),Q(n.pipe(ke(1))),ye(!0),jt({delay:250}),f(a=>({hidden:a})))}function tc(e,{viewport$:t,header$:r,main$:n,target$:o}){let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({hidden:s}){e.hidden=s,s?(e.setAttribute("tabindex","-1"),e.blur()):e.removeAttribute("tabindex")},complete(){e.style.top="",e.hidden=!0,e.removeAttribute("tabindex")}}),r.pipe(Q(a),fe("height")).subscribe(({height:s})=>{e.style.top=`${s+16}px`}),b(e,"click").subscribe(s=>{s.preventDefault(),window.scrollTo({top:0})}),Sp(e,{viewport$:t,main$:n,target$:o}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))}function rc(e,t){return e.protocol=t.protocol,e.hostname=t.hostname,t.port&&(e.port=t.port),e}function Op(e,t){let r=new Map;for(let n of P("url",e)){let o=G("loc",n),i=[rc(new URL(o.textContent),t)];r.set(`${i[0]}`,i);for(let a of P("[rel=alternate]",n)){let s=a.getAttribute("href");s!=null&&i.push(rc(new URL(s),t))}}return r}function dr(e){return ns(new URL("sitemap.xml",e)).pipe(f(t=>Op(t,new URL(e))),_e(()=>Y(new Map)),xe())}function nc({document$:e}){let t=new Map;e.pipe(g(()=>P("link[rel=alternate]")),f(r=>new URL(r.href)),L(r=>!t.has(r.toString())),oe(r=>dr(r).pipe(f(n=>[r,n]),_e(()=>y)))).subscribe(([r,n])=>{t.set(r.toString().replace(/\/$/,""),n)}),b(document.body,"click").pipe(L(r=>!r.metaKey&&!r.ctrlKey),g(r=>{if(r.target instanceof Element){let n=r.target.closest("a");if(n&&!n.target){let o=[...t].find(([p])=>n.href.startsWith(`${p}/`));if(typeof o=="undefined")return y;let[i,a]=o,s=Ye();if(s.href.startsWith(i))return y;let c=Ue(),l=s.href.replace(c.base,"");l=`${i}/${l}`;let u=a.has(l.split("#")[0])?new URL(l,c.base):new URL(i);return r.preventDefault(),Y(u)}}return y})).subscribe(r=>dt(r,!0))}var Co=_r(Mo());function Lp(e){e.setAttribute("data-md-copying","");let t=e.closest("[data-copy]"),r=t?t.getAttribute("data-copy"):e.innerText;return e.removeAttribute("data-md-copying"),r.trimEnd()}function oc({alert$:e}){Co.default.isSupported()&&new U(t=>{new Co.default("[data-clipboard-target], [data-clipboard-text]",{text:r=>r.getAttribute("data-clipboard-text")||Lp(G(r.getAttribute("data-clipboard-target")))}).on("success",r=>t.next(r))}).pipe($(t=>{t.trigger.focus()}),f(()=>Bt("clipboard.copied"))).subscribe(e)}function ic(e,t){if(!(e.target instanceof Element))return y;let r=e.target.closest("a");if(r===null)return y;if(r.target||e.metaKey||e.ctrlKey)return y;let n=new URL(r.href);return n.search=n.hash="",t.has(`${n}`)?(e.preventDefault(),Y(r)):y}function ac(e){let t=new Map;for(let r of P(":scope > *",e.head))t.set(r.outerHTML,r);return t}function sc(e){for(let t of P("[href], [src]",e))for(let r of["href","src"]){let n=t.getAttribute(r);if(n&&!/^(?:[a-z]+:)?\/\//i.test(n)){t[r]=t[r];break}}return Y(e)}function Mp(e){for(let n of["[data-md-component=announce]","[data-md-component=container]","[data-md-component=header-topic]","[data-md-component=outdated]","[data-md-component=logo]","[data-md-component=skip]",...X("navigation.tabs.sticky")?["[data-md-component=tabs]"]:[]]){let o=Le(n),i=Le(n,e);typeof o!="undefined"&&typeof i!="undefined"&&o.replaceWith(i)}let t=ac(document);for(let[n,o]of ac(e))t.has(n)?t.delete(n):document.head.appendChild(o);for(let n of t.values()){let o=n.getAttribute("name");o!=="theme-color"&&o!=="color-scheme"&&n.remove()}let r=ht("container");return nt(P("script",r)).pipe(g(n=>{let o=e.createElement("script");if(n.src){for(let i of n.getAttributeNames())o.setAttribute(i,n.getAttribute(i));return n.replaceWith(o),new U(i=>{o.onload=()=>i.complete()})}else return o.textContent=n.textContent,n.replaceWith(o),y}),he(),ye(document))}function cc({sitemap$:e,location$:t,viewport$:r,progress$:n}){if(location.protocol==="file:")return Ke;Y(document).subscribe(sc);let o=b(document.body,"click").pipe(Ze(e),g(([s,c])=>ic(s,c)),f(({href:s})=>new URL(s)),xe()),i=b(window,"popstate").pipe(f(Ye),xe());o.pipe(pe(r)).subscribe(([s,{offset:c}])=>{history.replaceState(c,""),history.pushState(null,"",s)}),R(o,i).subscribe(t);let a=t.pipe(fe("pathname"),g(s=>En(s,{progress$:n}).pipe(_e(()=>(dt(s,!0),y)))),g(sc),g(Mp),xe());return R(a.pipe(pe(t,(s,c)=>c)),a.pipe(g(()=>t),fe("hash")),t.pipe(ie((s,c)=>s.pathname===c.pathname&&s.hash===c.hash),g(()=>o),$(()=>history.back()))).subscribe(s=>{var c,l;history.state!==null||!s.hash?window.scrollTo(0,(l=(c=history.state)==null?void 0:c.y)!=null?l:0):(history.scrollRestoration="auto",es(s.hash),history.scrollRestoration="manual")}),t.subscribe(()=>{history.scrollRestoration="manual"}),b(window,"beforeunload").subscribe(()=>{history.scrollRestoration="auto"}),r.pipe(fe("offset"),Be(100)).subscribe(({offset:s})=>{history.replaceState(s,"")}),X("navigation.instant.prefetch")&&R(b(document.body,"mousemove"),b(document.body,"focusin")).pipe(Ze(e),g(([s,c])=>ic(s,c)),Be(25),Yn(({href:s})=>s),cn(s=>{let c=document.createElement("link");return c.rel="prefetch",c.href=s.toString(),document.head.appendChild(c),b(c,"load").pipe(f(()=>c),Me(1))})).subscribe(s=>s.remove()),a}function lc(e){var u;let{selectedVersionSitemap:t,selectedVersionBaseURL:r,currentLocation:n,currentBaseURL:o}=e,i=(u=Ho(o))==null?void 0:u.pathname;if(i===void 0)return;let a=kp(n.pathname,i);if(a===void 0)return;let s=Cp(t.keys());if(!t.has(s))return;let c=Ho(a,s);if(!c||!t.has(c.href))return;let l=Ho(a,r);if(l)return l.hash=n.hash,l.search=n.search,l}function Ho(e,t){try{return new URL(e,t)}catch(r){return}}function kp(e,t){if(e.startsWith(t))return e.slice(t.length)}function Ap(e,t){let r=Math.min(e.length,t.length),n;for(n=0;n<r&&e[n]===t[n];++n);return n}function Cp(e){let t;for(let r of e)t===void 0?t=r:t=t.slice(0,Ap(t,r));return t!=null?t:""}function uc({document$:e}){let t=Ue(),r=et(new URL("../versions.json",t.base)).pipe(_e(()=>y)),n=r.pipe(f(o=>{let[,i]=t.base.match(/([^/]+)\/?$/);return o.find(({version:a,aliases:s})=>a===i||s.includes(i))||o[0]}));r.pipe(f(o=>new Map(o.map(i=>[`${new URL(`../${i.version}/`,t.base)}`,i]))),g(o=>b(document.body,"click").pipe(L(i=>!i.metaKey&&!i.ctrlKey),pe(n),g(([i,a])=>{if(i.target instanceof Element){let s=i.target.closest("a");if(s&&!s.target&&o.has(s.href)){let c=s.href;return!i.target.closest(".md-version")&&o.get(c)===a?y:(i.preventDefault(),Y(new URL(c)))}}return y}),g(i=>dr(i).pipe(f(a=>{var s;return(s=lc({selectedVersionSitemap:a,selectedVersionBaseURL:i,currentLocation:Ye(),currentBaseURL:t.base}))!=null?s:i})))))).subscribe(o=>dt(o,!0)),re([r,n]).subscribe(([o,i])=>{G(".md-header__topic").appendChild(_s(o,i))}),e.pipe(g(()=>n)).subscribe(o=>{var s;let i=new URL(t.base),a=__md_get("__outdated",sessionStorage,i);if(a===null){a=!0;let c=((s=t.version)==null?void 0:s.default)||"latest";Array.isArray(c)||(c=[c]);e:for(let l of c)for(let u of o.aliases.concat(o.version))if(new RegExp(l,"i").test(u)){a=!1;break e}__md_set("__outdated",a,sessionStorage,i)}if(a)for(let c of Ee("outdated"))c.hidden=!1})}function pc({document$:e,viewport$:t}){e.pipe(g(()=>P(".md-ellipsis")),oe(r=>Et(r).pipe(Q(e.pipe(ke(1))),L(n=>n),f(()=>r),Me(1))),L(r=>r.offsetWidth<r.scrollWidth),oe(r=>{let n=r.innerText,o=r.closest("a")||r;return o.title=n,X("content.tooltips")?Ge(o,{viewport$:t}).pipe(Q(e.pipe(ke(1))),V(()=>o.removeAttribute("title"))):y})).subscribe(),X("content.tooltips")&&e.pipe(g(()=>P(".md-status")),oe(r=>Ge(r,{viewport$:t}))).subscribe()}function fc({document$:e,tablet$:t}){e.pipe(g(()=>P(".md-toggle--indeterminate")),$(r=>{r.indeterminate=!0,r.checked=!1}),oe(r=>b(r,"change").pipe(Xn(()=>r.classList.contains("md-toggle--indeterminate")),f(()=>r))),pe(t)).subscribe(([r,n])=>{r.classList.remove("md-toggle--indeterminate"),n&&(r.checked=!1)})}function Hp(){return/(iPad|iPhone|iPod)/.test(navigator.userAgent)}function mc({document$:e}){e.pipe(g(()=>P("[data-md-scrollfix]")),$(t=>t.removeAttribute("data-md-scrollfix")),L(Hp),oe(t=>b(t,"touchstart").pipe(f(()=>t)))).subscribe(t=>{let r=t.scrollTop;r===0?t.scrollTop=1:r+t.offsetHeight===t.scrollHeight&&(t.scrollTop=r-1)})}Object.entries||(Object.entries=function(e){let t=[];for(let r of Object.keys(e))t.push([r,e[r]]);return t});Object.values||(Object.values=function(e){let t=[];for(let r of Object.keys(e))t.push(e[r]);return t});typeof Element!="undefined"&&(Element.prototype.scrollTo||(Element.prototype.scrollTo=function(e,t){typeof e=="object"?(this.scrollLeft=e.left,this.scrollTop=e.top):(this.scrollLeft=e,this.scrollTop=t)}),Element.prototype.replaceWith||(Element.prototype.replaceWith=function(...e){let t=this.parentNode;if(t){e.length===0&&t.removeChild(this);for(let r=e.length-1;r>=0;r--){let n=e[r];typeof n=="string"?n=document.createTextNode(n):n.parentNode&&n.parentNode.removeChild(n),r?t.insertBefore(this.previousSibling,n):t.replaceChild(n,this)}}}));function $p(){return location.protocol==="file:"?ar(`${new URL("search.js",Mn.base)}`).pipe(f(()=>__index),_e(()=>Ke),se(1)):et(new URL("search.json",Mn.base))}document.documentElement.classList.remove("no-js");document.documentElement.classList.add("js");var vt=Si(),Ur=Za(),hr=ts(Ur),hc=Xa(),ze=cs(),$o=Ir("(min-width: 60em)"),vc=Ir("(min-width: 76.25em)"),bc=rs(),Mn=Ue(),gc=Le(".md-search")?$p():Ke,Po=new I;oc({alert$:Po});nc({document$:vt});var Io=new I,_c=dr(Mn.base);X("navigation.instant")&&cc({sitemap$:_c,location$:Ur,viewport$:ze,progress$:Io}).subscribe(vt);var dc;((dc=Mn.version)==null?void 0:dc.provider)==="mike"&&uc({document$:vt});R(Ur,hr).pipe(It(125)).subscribe(()=>{Eo("drawer",!1),Eo("search",!1)});hc.pipe(L(({mode:e,meta:t})=>e==="global"&&!t)).subscribe(e=>{switch(e.type){case",":case"p":let t=document.querySelector("link[rel=prev]");t instanceof HTMLLinkElement&&dt(t);break;case".":case"n":let r=document.querySelector("link[rel=next]");r instanceof HTMLLinkElement&&dt(r);break;case"/":let n=document.querySelector("[data-md-component=search] button");n instanceof HTMLButtonElement&&n.click();break;case"Enter":let o=xt();o instanceof HTMLLabelElement&&o.click()}});pc({viewport$:ze,document$:vt});fc({document$:vt,tablet$:$o});mc({document$:vt});var Lt=Us(ht("header"),{viewport$:ze}),Fr=vt.pipe(f(()=>ht("main")),g(e=>Ws(e,{viewport$:ze,header$:Lt})),se(1)),Pp=R(...Ee("consent").map(e=>us(e,{target$:hr})),...Ee("dialog").map(e=>Fs(e,{alert$:Po})),...Ee("palette").map(e=>Vs(e)),...Ee("progress").map(e=>zs(e,{progress$:Io})),...Ee("search").map(e=>Ks(e,{index$:gc})),...Ee("source").map(e=>Zs(e))),Ip=j(()=>R(...Ee("announce").map(e=>ls(e)),...Ee("content").map(e=>js(e,{sitemap$:_c,viewport$:ze,target$:hr,print$:bc})),...Ee("content").map(e=>X("search.highlight")?Ys(e,{index$:gc,location$:Ur}):y),...Ee("header").map(e=>Ns(e,{viewport$:ze,header$:Lt,main$:Fr})),...Ee("header-title").map(e=>Ds(e,{viewport$:ze,header$:Lt})),...Ee("sidebar").map(e=>e.getAttribute("data-md-type")==="navigation"?yo(vc,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr})):yo($o,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr}))),...Ee("tabs").map(e=>Qs(e,{viewport$:ze,header$:Lt})),...Ee("toc").map(e=>ec(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})),...Ee("top").map(e=>tc(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})))),yc=vt.pipe(g(()=>Ip),Rt(Pp),se(1));yc.subscribe();window.document$=vt;window.location$=Ur;window.target$=hr;window.keyboard$=hc;window.viewport$=ze;window.tablet$=$o;window.screen$=vc;window.print$=bc;window.alert$=Po;window.progress$=Io;window.component$=yc;})();
-/*! update cache: 20260331044524 */
+/*! update cache: 20260331053217 */
diff --git a/ja/chapter_stack_and_queue/queue/index.html b/ja/chapter_stack_and_queue/queue/index.html
index 0a236b028..81dec591c 100644
--- a/ja/chapter_stack_and_queue/queue/index.html
+++ b/ja/chapter_stack_and_queue/queue/index.html
@@ -6445,7 +6445,7 @@
 <a id="__codelineno-36-2" name="__codelineno-36-2" href="#__codelineno-36-2"></a><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-36-3" name="__codelineno-36-3" href="#__codelineno-36-3"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">nums</span><span class="p">;</span><span class="w">       </span><span class="c1">// キュー要素を格納する配列</span>
 <a id="__codelineno-36-4" name="__codelineno-36-4" href="#__codelineno-36-4"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">front</span><span class="p">;</span><span class="w">       </span><span class="c1">// 先頭ポインタ。先頭要素を指す</span>
-<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// 末尾ポインタ。キューの末尾 + 1 を指す</span>
+<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// 現在のキュー内の要素数</span>
 <a id="__codelineno-36-6" name="__codelineno-36-6" href="#__codelineno-36-6"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queCapacity</span><span class="p">;</span><span class="w"> </span><span class="c1">// キューの容量</span>
 <a id="__codelineno-36-7" name="__codelineno-36-7" href="#__codelineno-36-7"></a><span class="p">}</span><span class="w"> </span><span class="n">ArrayQueue</span><span class="p">;</span>
 <a id="__codelineno-36-8" name="__codelineno-36-8" href="#__codelineno-36-8"></a>
diff --git a/ja/javascripts/katex.js b/ja/javascripts/katex.js
index 4953d6994..bdee3e6b8 100644
--- a/ja/javascripts/katex.js
+++ b/ja/javascripts/katex.js
@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260331044524 */
+/*! update cache: 20260331053217 */
diff --git a/ja/javascripts/mathjax.js b/ja/javascripts/mathjax.js
index 08685f45f..e756f0f29 100644
--- a/ja/javascripts/mathjax.js
+++ b/ja/javascripts/mathjax.js
@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260331044524 */
+/*! update cache: 20260331053217 */
diff --git a/ja/javascripts/starfield.js b/ja/javascripts/starfield.js
index ff79c29cb..5569a232c 100644
--- a/ja/javascripts/starfield.js
+++ b/ja/javascripts/starfield.js
@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260331044524 */
+/*! update cache: 20260331053217 */
diff --git a/ja/search.json b/ja/search.json
index 42bdcc1ec..cfddf1df2 100644
--- a/ja/search.json
+++ b/ja/search.json
@@ -1 +1 @@
-{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"第 16 章   付録","text":"","path":["第 16 章 &nbsp; 付録"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"章の内容","text":"<ul> <li>16.1   プログラミング環境のインストール</li> <li>16.2   一緒に制作に参加しましょう</li> <li>16.3   用語集</li> </ul>","path":["第 16 章 &nbsp; 付録"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   一緒に制作に参加しましょう","text":"<p>著者の力には限りがあるため、本書にはどうしても一部の漏れや誤りが含まれる可能性があります。ご了承ください。誤字、リンク切れ、内容の欠落、表現の曖昧さ、説明の不明瞭さ、文章構成の不適切さなどの問題を見つけた場合は、ぜひ修正にご協力ください。読者により良い学習リソースを提供できます。</p> <p>すべての寄稿者の GitHub ID は、本書のリポジトリ、Web 版、PDF 版のホームページに掲載され、オープンソースコミュニティへの惜しみない貢献に感謝を表します。</p> <p>オープンソースの魅力</p> <p>紙の書籍では、2 回の増刷の間隔が長くなりがちで、内容更新は非常に不便です。</p> <p>一方、このオープンソース書籍では、内容更新のサイクルは数日、場合によっては数時間にまで短縮されています。</p>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   内容の微調整","text":"<p>以下の図のように、各ページの右上には「編集アイコン」があります。次の手順で本文やコードを修正できます。</p> <ol> <li>「編集アイコン」をクリックし、「このリポジトリを Fork する必要があります」と表示された場合は、その操作を承認してください。</li> <li>Markdown のソースファイルを修正し、内容が正しいことを確認したうえで、できるだけ書式の統一を保ってください。</li> <li>ページ下部に修正内容の説明を入力し、その後「Propose file change」ボタンをクリックします。ページ遷移後、「Create pull request」ボタンをクリックするとプルリクエストを作成できます。</li> </ol> <p></p> <p> 図 16-3   ページ編集ボタン </p> <p>画像は直接修正できないため、新しい Issue を作成するかコメントで問題を説明してください。できるだけ早く描き直して差し替えます。</p>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   コンテンツ制作","text":"<p>コードを他のプログラミング言語へ翻訳することや、記事内容を拡充することなど、このオープンソースプロジェクトへの参加に興味がある場合は、以下の Pull Request ワークフローに従ってください。</p> <ol> <li>GitHub にログインし、本書のコードリポジトリを個人アカウントに Fork します。</li> <li>Fork したリポジトリのページに入り、<code>git clone</code> コマンドを使ってリポジトリをローカルにクローンします。</li> <li>ローカルでコンテンツを作成し、完全なテストを行ってコードの正しさを確認します。</li> <li>ローカルで行った変更を Commit し、その後リモートリポジトリへ Push します。</li> <li>リポジトリのページを更新し、「Create pull request」ボタンをクリックするとプルリクエストを作成できます。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Docker デプロイ","text":"<p><code>hello-algo</code> のルートディレクトリで以下の Docker スクリプトを実行すると、<code>http://localhost:8000</code> で本プロジェクトにアクセスできます。</p> <pre><code>docker-compose up -d\n</code></pre> <p>以下のコマンドでデプロイを削除できます。</p> <pre><code>docker-compose down\n</code></pre>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   プログラミング環境のインストール","text":"","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   IDE のインストール","text":"<p>オープンソースで軽量な VS Code をローカルの統合開発環境（IDE）として使用することを推奨します。VS Code 公式サイト にアクセスし、使用している OS に応じたバージョンの VS Code をダウンロードしてインストールしてください。</p> <p></p> <p> 図 16-1   公式サイトから VS Code をダウンロード </p> <p>VS Code には強力な拡張機能のエコシステムがあり、ほとんどのプログラミング言語の実行とデバッグをサポートしています。Python を例にすると、「Python Extension Pack」拡張機能をインストールした後、Python コードをデバッグできるようになります。インストール手順を以下に示します。</p> <p></p> <p> 図 16-2   VS Code 拡張機能のインストール </p>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   言語環境のインストール","text":"","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Python 環境","text":"<ol> <li>Miniconda3 をダウンロードしてインストールします。Python 3.10 以降が必要です。</li> <li>VS Code の拡張機能マーケットプレイスで <code>python</code> を検索し、Python Extension Pack をインストールします。</li> <li>（任意）コマンドラインで <code>pip install black</code> を入力し、コード整形ツールをインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   C/C++ 環境","text":"<ol> <li>Windows システムでは MinGW をインストールする必要があります（設定チュートリアル）。MacOS には Clang が標準搭載されているため、追加インストールは不要です。</li> <li>VS Code の拡張機能マーケットプレイスで <code>c++</code> を検索し、C/C++ Extension Pack をインストールします。</li> <li>（任意）Settings ページを開き、コード整形オプション <code>Clang_format_fallback Style</code> を検索して、<code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code> に設定します。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Java 環境","text":"<ol> <li>OpenJDK をダウンロードしてインストールします（バージョンは JDK 9 より新しい必要があります）。</li> <li>VS Code の拡張機能マーケットプレイスで <code>java</code> を検索し、Extension Pack for Java をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   C# 環境","text":"<ol> <li>.Net 8.0 をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>C# Dev Kit</code> を検索し、C# Dev Kit をインストールします（設定チュートリアル）。</li> <li>Visual Studio を使用することもできます（インストール手順）。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Go 環境","text":"<ol> <li>go をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>go</code> を検索し、Go をインストールします。</li> <li>ショートカットキー <code>Ctrl + Shift + P</code> を押してコマンドパレットを開き、go と入力して <code>Go: Install/Update Tools</code> を選択し、すべてにチェックを入れてインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Swift 環境","text":"<ol> <li>Swift をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>swift</code> を検索し、Swift for Visual Studio Code をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   JavaScript 環境","text":"<ol> <li>Node.js をダウンロードしてインストールします。</li> <li>（任意）VS Code の拡張機能マーケットプレイスで <code>Prettier</code> を検索し、コード整形ツールをインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   TypeScript 環境","text":"<ol> <li>JavaScript 環境と同じ手順でインストールします。</li> <li>TypeScript Execute (tsx) をインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>typescript</code> を検索し、Pretty TypeScript Errors をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Dart 環境","text":"<ol> <li>Dart をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>dart</code> を検索し、Dart をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Rust 環境","text":"<ol> <li>Rust をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>rust</code> を検索し、rust-analyzer をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   用語集","text":"<p>以下の表は、本書に登場する重要な用語を一覧にしたものです。特に次の点に注意してください。</p> <ul> <li>名詞の英語表現も覚えておくと、英語文献を読む際に役立ちます。</li> <li>一部の名詞は、簡体字中国語と繁体字中国語で呼び方が異なります。</li> </ul> <p> 表 16-1   データ構造とアルゴリズムの重要用語 </p> English 日本語 日本語 algorithm アルゴリズム アルゴリズム data structure データ構造 データ構造 code コード コード file ファイル ファイル function 関数 関数 method メソッド メソッド variable 変数 変数 asymptotic complexity analysis 漸近計算量解析 漸近計算量解析 time complexity 時間計算量 時間計算量 space complexity 空間計算量 空間計算量 loop ループ ループ iteration 反復 反復 recursion 再帰 再帰 tail recursion 末尾再帰 末尾再帰 recursion tree 再帰木 再帰木 big-\\(O\\) notation ビッグオー記法 ビッグオー記法 asymptotic upper bound 漸近上界 漸近上界 sign-magnitude 符号絶対値表現 符号絶対値表現 1’s complement 1の補数 1の補数 2’s complement 2の補数 2の補数 array 配列 配列 index インデックス インデックス linked list 連結リスト 連結リスト linked list node, list node 連結リストノード 連結リストノード head node 先頭ノード 先頭ノード tail node 末尾ノード 末尾ノード list リスト リスト dynamic array 動的配列 動的配列 hard disk ハードディスク ハードディスク random-access memory (RAM) メモリ メモリ cache memory キャッシュ キャッシュ cache miss キャッシュミス キャッシュミス cache hit rate キャッシュヒット率 キャッシュヒット率 stack スタック スタック top of the stack スタックトップ スタックトップ bottom of the stack スタックボトム スタックボトム queue キュー キュー double-ended queue 両端キュー 両端キュー front of the queue キュー先頭 キュー先頭 rear of the queue キュー末尾 キュー末尾 hash table ハッシュテーブル ハッシュテーブル hash set ハッシュ集合 ハッシュ集合 bucket バケット バケット hash function ハッシュ関数 ハッシュ関数 hash collision ハッシュ衝突 ハッシュ衝突 load factor 負荷率 負荷率 separate chaining 連鎖アドレス法 連鎖アドレス法 open addressing オープンアドレス法 オープンアドレス法 linear probing 線形探索 線形探索 lazy deletion 遅延削除 遅延削除 binary tree 二分木 二分木 tree node ノード ノード left-child node 左子ノード 左子ノード right-child node 右子ノード 右子ノード parent node 親ノード 親ノード left subtree 左部分木 左部分木 right subtree 右部分木 右部分木 root node 根ノード 根ノード leaf node 葉ノード 葉ノード edge 辺 辺 level レベル レベル degree 次数 次数 height 高さ 高さ depth 深さ 深さ perfect binary tree 完備二分木 完備二分木 complete binary tree 完全二分木 完全二分木 full binary tree 満二分木 満二分木 balanced binary tree 平衡二分木 平衡二分木 binary search tree 二分探索木 二分探索木 AVL tree AVL 木 AVL 木 red-black tree 赤黒木 赤黒木 level-order traversal レベル順走査 レベル順走査 breadth-first traversal 幅優先走査 幅優先走査 depth-first traversal 深さ優先走査 深さ優先走査 binary search tree 二分探索木 二分探索木 balanced binary search tree 平衡二分探索木 平衡二分探索木 balance factor 平衡係数 平衡係数 heap ヒープ ヒープ max heap 最大ヒープ 最大ヒープ min heap 最小ヒープ 最小ヒープ priority queue 優先度付きキュー 優先度付きキュー heapify ヒープ化 ヒープ化 top-\\(k\\) problem Top-\\(k\\) 問題 Top-\\(k\\) 問題 graph グラフ グラフ vertex 頂点 頂点 undirected graph 無向グラフ 無向グラフ directed graph 有向グラフ 有向グラフ connected graph 連結グラフ 連結グラフ disconnected graph 非連結グラフ 非連結グラフ weighted graph 重み付きグラフ 重み付きグラフ adjacency 隣接 隣接 path 経路 経路 in-degree 入次数 入次数 out-degree 出次数 出次数 adjacency matrix 隣接行列 隣接行列 adjacency list 隣接リスト 隣接リスト breadth-first search 幅優先探索 幅優先探索 depth-first search 深さ優先探索 深さ優先探索 binary search 二分探索 二分探索 searching algorithm 探索アルゴリズム 探索アルゴリズム sorting algorithm ソートアルゴリズム ソートアルゴリズム selection sort 選択ソート 選択ソート bubble sort バブルソート バブルソート insertion sort 挿入ソート 挿入ソート quick sort クイックソート クイックソート merge sort マージソート マージソート heap sort ヒープソート ヒープソート bucket sort バケットソート バケットソート counting sort 計数ソート 計数ソート radix sort 基数ソート 基数ソート divide and conquer 分割統治 分割統治 hanota problem ハノイの塔問題 ハノイの塔問題 backtracking algorithm バックトラッキングアルゴリズム バックトラッキングアルゴリズム constraint 制約 制約 solution 解 解 state 状態 状態 pruning 枝刈り 枝刈り permutations problem 全順列問題 全順列問題 subset-sum problem 部分和問題 部分和問題 \\(n\\)-queens problem \\(n\\) クイーン問題 \\(n\\) クイーン問題 dynamic programming 動的計画法 動的計画法 initial state 初期状態 初期状態 state-transition equation 状態遷移方程式 状態遷移方程式 knapsack problem ナップサック問題 ナップサック問題 edit distance problem 編集距離問題 編集距離問題 greedy algorithm 貪欲法 貪欲法","path":["第 16 章 &nbsp; 付録","16.3 &nbsp; 用語集"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"第 4 章   配列と連結リスト","text":"<p>Abstract</p> <p>データ構造の世界は、まるで重厚なれんがの壁のようです。</p> <p>配列のれんがは整然と並び、一つひとつがぴったりと接しています。連結リストのれんがはあちこちに分散し、それらをつなぐつるがれんがのすき間を自由に行き交います。</p>","path":["第 4 章 &nbsp; 配列と連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"章の内容","text":"<ul> <li>4.1   配列</li> <li>4.2   連結リスト</li> <li>4.3   リスト</li> <li>4.4   メモリとキャッシュ *</li> <li>4.5   まとめ</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   配列","text":"<p>配列（array）は線形データ構造の一種であり、同じ型の要素を連続したメモリ領域に格納します。要素が配列内にある位置を、その要素のインデックス（index）と呼びます。下図は、配列の主要な概念と格納方式を示しています。</p> <p></p> <p> 図 4-1   配列の定義と格納方式 </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   配列の一般的な操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   配列の初期化","text":"<p>必要に応じて、配列の初期化方法として初期値なしと初期値ありの 2 種類を使い分けられます。初期値を指定しない場合、多くのプログラミング言語では配列要素は \\(0\\) に初期化されます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># 配列を初期化する\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* 配列を初期化する */\n// スタック上に格納\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// ヒープ上に格納（手動で領域を解放する必要がある）\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* 配列を初期化する */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* 配列を初期化する */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* 配列を初期化する */\nvar arr [5]int\n// Go では、長さを指定する場合（[5]int）は配列であり、長さを指定しない場合（[]int）はスライス\n// Go の配列はコンパイル時に長さが確定するよう設計されているため、長さの指定には定数しか使用できない\n// 拡張 extend() メソッドを実装しやすくするため、以下ではスライス（Slice）を配列（Array）として扱う\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* 配列を初期化する */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* 配列を初期化する */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* 配列を初期化する */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* 配列を初期化する */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* 配列を初期化する */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// Rust では、長さを指定する場合（[i32; 5]）は配列であり、長さを指定しない場合（&amp;[i32]）はスライス\n// Rust の配列はコンパイル時に長さが確定するよう設計されているため、長さの指定には定数しか使用できない\n// Vector は Rust で一般に動的配列として使われる型\n// 拡張 extend() メソッドを実装しやすくするため、以下では vector を配列（array）として扱う\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* 配列を初期化する */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* 配列を初期化する */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># 配列を初期化する\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0Aarr%20%3D%20%5B0%5D%20*%205%20%20%23%20%5B%200,%200,%200,%200,%200%20%5D%0Anums%20%3D%20%5B1,%203,%202,%205,%204%5D&amp;cumulative=false&amp;curInstr=0&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   要素へのアクセス","text":"<p>配列要素は連続したメモリ領域に格納されるため、要素のメモリアドレスの計算は非常に容易です。配列のメモリアドレス（先頭要素のメモリアドレス）とある要素のインデックスが与えられれば、下図の式を使ってその要素のメモリアドレスを計算でき、直接その要素にアクセスできます。</p> <p></p> <p> 図 4-2   配列要素のメモリアドレスの計算 </p> <p>上図を見ると、配列の最初の要素のインデックスは \\(0\\) であり、これは少し直感に反するように思えます。というのも、\\(1\\) から数え始めるほうが自然だからです。しかし、アドレス計算式の観点では、**インデックスの本質はメモリアドレスのオフセット**です。先頭要素のアドレスのオフセットは \\(0\\) であるため、そのインデックスが \\(0\\) なのは妥当です。</p> <p>配列では要素へのアクセスは非常に効率的であり、\\(O(1)\\) 時間で任意の要素にランダムアクセスできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"要素へランダムアクセス\"\"\"\n    # 区間 [0, len(nums)-1] からランダムに数字を 1 つ選ぶ\n    random_index = random.randint(0, len(nums) - 1)\n    # ランダムな要素を取得して返す\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int *nums, int size) {\n    // 区間 [0, size) からランダムに 1 つの数を選ぶ\n    int randomIndex = rand() % size;\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int[] nums) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* 要素へランダムアクセス */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // 区間 [0, nums.Length) からランダムに数字を 1 つ選ぶ\n    int randomIndex = random.Next(nums.Length);\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* 要素へランダムアクセス */\nfunc randomAccess(nums []int) (randomNum int) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    randomIndex := rand.Intn(len(nums))\n    // ランダムな要素を取得して返す\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* 要素へランダムアクセス */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // 区間 [0, nums.count) からランダムに数字を 1 つ選ぶ\n    let randomIndex = nums.indices.randomElement()!\n    // ランダムな要素を取得して返す\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* 要素へランダムアクセス */\nfunction randomAccess(nums) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    const random_index = Math.floor(Math.random() * nums.length);\n    // ランダムな要素を取得して返す\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* 要素へランダムアクセス */\nfunction randomAccess(nums: number[]): number {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    const random_index = Math.floor(Math.random() * nums.length);\n    // ランダムな要素を取得して返す\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* 要素へランダムアクセス */\nint randomAccess(List&lt;int&gt; nums) {\n  // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n  int randomIndex = Random().nextInt(nums.length);\n  // ランダムな要素を取得して返す\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* 要素へランダムアクセス */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // 区間 [0, nums.len()) からランダムに数字を 1 つ選ぶ\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // ランダムな要素を取得して返す\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int *nums, int size) {\n    // 区間 [0, size) からランダムに 1 つの数を選ぶ\n    int randomIndex = rand() % size;\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* 要素へランダムアクセス */\nfun randomAccess(nums: IntArray): Int {\n    // 区間 [0, nums.size) からランダムに数字を 1 つ選ぶ\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // ランダムな要素を取得して返す\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### 要素にランダムアクセス ###\ndef random_access(nums)\n  # 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n  random_index = Random.rand(0...nums.length)\n\n  # ランダムな要素を取得して返す\n  nums[random_index]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   要素の挿入","text":"<p>配列要素はメモリ内で「ぴったり隣接して」おり、その間にほかのデータを格納する余地はありません。下図のように、配列の途中に要素を挿入したい場合は、その要素より後ろにあるすべての要素を 1 つずつ後ろへずらし、その後でそのインデックスに要素を代入する必要があります。</p> <p></p> <p> 図 4-3   配列への要素挿入の例 </p> <p>注意すべき点として、配列の長さは固定であるため、要素を 1 つ挿入すると配列末尾の要素が必ず「失われ」ます。この問題の解決策は「リスト」の章で扱います。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"配列の index 番目に要素 num を挿入\"\"\"\n    # インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # index の要素に num を代入する\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int *nums, int size, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int[] nums, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid Insert(int[] nums, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunc insert(nums []int, num int, index int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunction insert(nums, num, index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunction insert(nums: number[], num: number, index: number): void {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* 配列の添字 index に要素 _num を挿入 */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // インデックス index 以降の全要素を 1 つ後ろへ移動する\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // _num を index の位置の要素に代入\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int *nums, int size, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### 配列のインデックス index に要素 num を挿入 ###\ndef insert(nums, num, index)\n  # インデックス index 以降の全要素を 1 つ後ろへ移動する\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # index の要素に num を代入する\n  nums[index] = num\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   要素の削除","text":"<p>同様に、下図のように、インデックス \\(i\\) の要素を削除したい場合は、インデックス \\(i\\) より後ろの要素をすべて 1 つずつ前へずらす必要があります。</p> <p></p> <p> 図 4-4   配列からの要素削除の例 </p> <p>注意してください。要素の削除が完了すると、もともとの末尾要素は「意味を持たない」状態になるため、わざわざ変更する必要はありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"index の要素を削除する\"\"\"\n    # インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* index の要素を削除する */\nvoid remove(int *nums, int size, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* index の要素を削除する */\nvoid remove(int[] nums, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* index の要素を削除する */\nvoid Remove(int[] nums, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* index の要素を削除する */\nfunc remove(nums []int, index int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* index の要素を削除する */\nfunc remove(nums: inout [Int], index: Int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* index の要素を削除する */\nfunction remove(nums, index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* index の要素を削除する */\nfunction remove(nums: number[], index: number): void {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* index の要素を削除する */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // インデックス index より後ろの全要素を 1 つ前へ移動する\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* index の要素を削除する */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* index の要素を削除する */\n// 注意: stdio.h が remove 識別子を使用している\nvoid removeItem(int *nums, int size, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* index の要素を削除する */\nfun remove(nums: IntArray, index: Int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### インデックス index の要素を削除 ###\ndef remove(nums, index)\n  # インデックス index より後ろの全要素を 1 つ前へ移動する\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>全体として見ると、配列の挿入と削除には次の欠点があります。</p> <ul> <li>時間計算量が高い：配列の挿入と削除の平均時間計算量はいずれも \\(O(n)\\) であり、ここで \\(n\\) は配列長です。</li> <li>要素が失われる：配列の長さは不変であるため、要素を挿入すると配列長の範囲を超えた要素は失われます。</li> <li>メモリの浪費：やや長めの配列を初期化して先頭部分だけを使うこともでき、この場合データ挿入時に失われる末尾要素はすべて「無意味」ですが、その代わり一部のメモリ領域が無駄になります。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   配列の走査","text":"<p>ほとんどのプログラミング言語では、インデックスを使って配列を走査することも、各要素を直接取り出しながら走査することもできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"配列を走査\"\"\"\n    count = 0\n    # インデックスで配列を走査\n    for i in range(len(nums)):\n        count += nums[i]\n    # 配列要素を直接走査\n    for num in nums:\n        count += num\n    # データのインデックスと要素を同時に走査する\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* 配列を走査 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* 配列を走査 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* 配列を走査 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* 配列を走査 */\nfunc traverse(nums []int) {\n    count := 0\n    // インデックスで配列を走査\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // 配列要素を直接走査\n    for _, num := range nums {\n        count += num\n    }\n    // データのインデックスと要素を同時に走査する\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* 配列を走査 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // インデックスで配列を走査\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // 配列要素を直接走査\n    for num in nums {\n        count += num\n    }\n    // データのインデックスと要素を同時に走査する\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* 配列を走査 */\nfunction traverse(nums) {\n    let count = 0;\n    // インデックスで配列を走査\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* 配列を走査 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // インデックスで配列を走査\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* 配列要素を走査する */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // インデックスで配列を走査\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // 配列要素を直接走査\n  for (int _num in nums) {\n    count += _num;\n  }\n  // forEach メソッドで配列を走査する\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* 配列を走査 */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // インデックスで配列を走査\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // 配列要素を直接走査\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* 配列を走査 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* 配列を走査 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // インデックスで配列を走査\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // 配列要素を直接走査\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### 配列を走査 ###\ndef traverse(nums)\n  count = 0\n\n  # インデックスで配列を走査\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # 配列要素を直接走査\n  for num in nums\n    count += num\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   要素の検索","text":"<p>配列内で指定した要素を探すには、配列を走査し、各反復で要素値が一致するかを判定し、一致したら対応するインデックスを出力します。</p> <p>配列は線形データ構造であるため、上記の検索操作は「線形探索」と呼ばれます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"配列内で指定要素を探す\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* 配列内で指定要素を探す */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* 配列内で指定要素を探す */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* 配列内で指定要素を探す */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* 配列内で指定要素を探す */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* 配列内で指定要素を探す */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* 配列内で指定要素を探す */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* 配列内で指定要素を探す */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* 配列内で指定要素を探す */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* 配列内で指定要素を探す */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* 配列内で指定要素を探す */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* 配列内で指定要素を探す */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### 配列内の指定要素を検索 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   配列の拡張","text":"<p>複雑なシステム環境では、配列の後方にあるメモリ領域が利用可能であることをプログラム側で保証できず、そのため安全に配列容量を拡張できません。したがって、ほとんどのプログラミング言語では、配列の長さは不変です。</p> <p>配列を拡張したい場合は、より大きな新しい配列を作り、元の配列の要素を順に新配列へコピーする必要があります。これは \\(O(n)\\) の操作であり、配列が大きい場合は非常に時間がかかります。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"配列長を拡張する\"\"\"\n    # 拡張後の長さを持つ配列を初期化する\n    res = [0] * (len(nums) + enlarge)\n    # 元の配列の全要素を新しい配列にコピー\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # 拡張後の新しい配列を返す\n    return res\n</code></pre> array.cpp<pre><code>/* 配列長を拡張する */\nint *extend(int *nums, int size, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int *res = new int[size + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // メモリを解放する\n    delete[] nums;\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.java<pre><code>/* 配列長を拡張する */\nint[] extend(int[] nums, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int[] res = new int[nums.length + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.cs<pre><code>/* 配列長を拡張する */\nint[] Extend(int[] nums, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int[] res = new int[nums.Length + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.go<pre><code>/* 配列長を拡張する */\nfunc extend(nums []int, enlarge int) []int {\n    // 拡張後の長さを持つ配列を初期化する\n    res := make([]int, len(nums)+enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for i, num := range nums {\n        res[i] = num\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.swift<pre><code>/* 配列長を拡張する */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // 拡張後の長さを持つ配列を初期化する\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.js<pre><code>/* 配列長を拡張する */\n// JavaScript の Array は動的配列であり、直接拡張できます\n// 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\nfunction extend(nums, enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 元の配列の全要素を新しい配列にコピー\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.ts<pre><code>/* 配列長を拡張する */\n// TypeScript の Array は動的配列であり、直接拡張できます\n// 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\nfunction extend(nums: number[], enlarge: number): number[] {\n    // 拡張後の長さを持つ配列を初期化する\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 元の配列の全要素を新しい配列にコピー\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.dart<pre><code>/* 配列長を拡張する */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // 拡張後の長さを持つ配列を初期化する\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // 元の配列の全要素を新しい配列にコピー\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // 拡張後の新しい配列を返す\n  return res;\n}\n</code></pre> array.rs<pre><code>/* 配列長を拡張する */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // 拡張後の長さを持つ配列を初期化する\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // 拡張後の新しい配列を返す\n    res\n}\n</code></pre> array.c<pre><code>/* 配列長を拡張する */\nint *extend(int *nums, int size, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の領域を初期化する\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.kt<pre><code>/* 配列長を拡張する */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // 拡張後の長さを持つ配列を初期化する\n    val res = IntArray(nums.size + enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.rb<pre><code>### 配列長を拡張 ###\n# Ruby の Array は動的配列であり、直接拡張できます\n# 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\ndef extend(nums, enlarge)\n  # 拡張後の長さを持つ配列を初期化する\n  res = Array.new(nums.length + enlarge, 0)\n\n  # 元の配列の全要素を新しい配列にコピー\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # 拡張後の新しい配列を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   配列の利点と限界","text":"<p>配列は連続したメモリ領域に格納され、要素の型も同一です。この方法には豊富な事前情報が含まれており、システムはそれらを利用してデータ構造の操作効率を最適化できます。</p> <ul> <li>空間効率が高い：配列はデータに連続したメモリブロックを割り当てるため、追加の構造オーバーヘッドが不要です。</li> <li>ランダムアクセスをサポートする：配列では任意の要素に \\(O(1)\\) 時間でアクセスできます。</li> <li>キャッシュ局所性：配列要素にアクセスする際、コンピュータはその要素だけでなく周囲のデータもキャッシュするため、高速キャッシュを利用して後続操作の実行速度を高められます。</li> </ul> <p>連続領域への格納は諸刃の剣であり、次のような制約があります。</p> <ul> <li>挿入と削除の効率が低い：配列内の要素が多い場合、挿入や削除では大量の要素を移動する必要があります。</li> <li>長さが不変：配列は初期化後に長さが固定され、拡張するにはすべてのデータを新しい配列へコピーする必要があり、コストが大きくなります。</li> <li>空間の浪費：配列に割り当てたサイズが実際の必要量を上回る場合、余分な領域は無駄になります。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   配列の典型的な応用","text":"<p>配列は基礎的で一般的なデータ構造であり、さまざまなアルゴリズムで頻繁に使われるだけでなく、多様な複雑データ構造の実装にも利用できます。</p> <ul> <li>ランダムアクセス：いくつかのサンプルをランダムに抽出したい場合、配列に格納してランダムな系列を生成し、インデックスに基づいてランダムサンプリングを行えます。</li> <li>ソートと探索：配列はソートアルゴリズムと探索アルゴリズムで最もよく使われるデータ構造です。クイックソート、マージソート、二分探索などは主に配列上で行われます。</li> <li>ルックアップテーブル：ある要素やその対応関係を高速に調べる必要がある場合、配列をルックアップテーブルとして使えます。たとえば文字から ASCII コードへの対応を実装したいなら、文字の ASCII コード値をインデックスとし、対応する要素を配列の対応位置に格納できます。</li> <li>機械学習：ニューラルネットワークでは、ベクトル、行列、テンソル間の線形代数演算が大量に使われ、これらのデータはいずれも配列の形で構築されます。配列はニューラルネットワークプログラミングで最もよく使われるデータ構造です。</li> <li>データ構造の実装：配列はスタック、キュー、ハッシュテーブル、ヒープ、グラフなどのデータ構造の実装に利用できます。たとえば、グラフの隣接行列表現は実際には 2 次元配列です。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   連結リスト","text":"<p>メモリ空間はすべてのプログラムに共通の資源であり、複雑なシステム実行環境では、空きメモリがメモリの各所に散在している可能性があります。配列を格納するメモリ空間は連続していなければなりませんが、配列が非常に大きい場合、メモリはそのような大きな連続領域を提供できないことがあります。このとき、連結リストの柔軟性という利点が現れます。</p> <p>連結リスト（linked list）は線形データ構造の一種であり、各要素はノードオブジェクトです。各ノードは「参照」によって接続されます。参照には次のノードのメモリアドレスが記録されており、これによって現在のノードから次のノードへアクセスできます。</p> <p>連結リストの設計では、各ノードをメモリの各所に分散して格納でき、それらのメモリアドレスは連続している必要がありません。</p> <p></p> <p> 図 4-5   連結リストの定義と格納方式 </p> <p>上図を見ると、連結リストの構成単位はノード（node）オブジェクトです。各ノードは 2 つのデータ、すなわちノードの「値」と次のノードを指す「参照」を含みます。</p> <ul> <li>連結リストの最初のノードを「先頭ノード」、最後のノードを「末尾ノード」と呼びます。</li> <li>末尾ノードが指す先は「空」であり、Java、C++、Python ではそれぞれ <code>null</code>、<code>nullptr</code>、<code>None</code> と表記します。</li> <li>C、C++、Go、Rust などポインタをサポートする言語では、上記の「参照」は「ポインタ」に置き換えるべきです。</li> </ul> <p>以下のコードが示すように、連結リストノード <code>ListNode</code> は値のほかに、追加で 1 つの参照（ポインタ）を保持する必要があります。そのため、同じデータ量であれば、連結リストは配列より多くのメモリ空間を消費します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"連結リストノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # ノードの値\n        self.next: ListNode | None = None # 次のノードへの参照\n</code></pre> <pre><code>/* 連結リストノード構造体 */\nstruct ListNode {\n    int val;         // ノードの値\n    ListNode *next;  // 次のノードへのポインタ\n    ListNode(int x) : val(x), next(nullptr) {}  // コンストラクタ\n};\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode next;  // 次のノードへの参照\n    ListNode(int x) { val = x; }  // コンストラクタ\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode(int x) {  //コンストラクタ\n    int val = x;         // ノードの値\n    ListNode? next;      // 次のノードへの参照\n}\n</code></pre> <pre><code>/* 連結リストノード構造体 */\ntype ListNode struct {\n    Val  int       // ノードの値\n    Next *ListNode // 次のノードへのポインタ\n}\n\n// NewListNode コンストラクタ。新しい連結リストを作成する\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    var val: Int // ノードの値\n    var next: ListNode? // 次のノードへの参照\n\n    init(x: Int) { // コンストラクタ\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // ノードの値\n        this.next = (next === undefined ? null : next); // 次のノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // ノードの値\n        this.next = next === undefined ? null : next;  // 次のノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n  int val; // ノードの値\n  ListNode? next; // 次のノードへの参照\n  ListNode(this.val, [this.next]); // コンストラクタ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* 連結リストノードクラス */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // ノードの値\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 次のノードへのポインタ\n}\n</code></pre> <pre><code>/* 連結リストノード構造体 */\ntypedef struct ListNode {\n    int val;               // ノードの値\n    struct ListNode *next; // 次のノードへのポインタ\n} ListNode;\n\n/* コンストラクタ */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\n// コンストラクタ\nclass ListNode(x: Int) {\n    val _val: Int = x          // ノードの値\n    val next: ListNode? = null // 次のノードへの参照\n}\n</code></pre> <pre><code># 連結リストノードクラス\nclass ListNode\n  attr_accessor :val  # ノードの値\n  attr_accessor :next # 次のノードへの参照\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   連結リストの基本操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   連結リストの初期化","text":"<p>連結リストの構築は 2 つの手順に分かれます。第 1 に各ノードオブジェクトを初期化し、第 2 にノード間の参照関係を構築します。初期化が完了したら、連結リストの先頭ノードから出発し、参照で <code>next</code> をたどってすべてのノードに順にアクセスできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化\n# 各ノードを初期化\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// ノード間の参照を構築\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// ノード間の参照を構築\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\\\n// 各ノードを初期化\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// ノード間の参照を構築\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// ノード間の参照を構築\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化\n# 各ノードを初期化\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%93%BE%E8%A1%A8%201%20-%3E%203%20-%3E%202%20-%3E%205%20-%3E%204%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%90%84%E4%B8%AA%E8%8A%82%E7%82%B9%0A%20%20%20%20n0%20%3D%20ListNode%281%29%0A%20%20%20%20n1%20%3D%20ListNode%283%29%0A%20%20%20%20n2%20%3D%20ListNode%282%29%0A%20%20%20%20n3%20%3D%20ListNode%285%29%0A%20%20%20%20n4%20%3D%20ListNode%284%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%0A%20%20%20%20n0.next%20%3D%20n1%0A%20%20%20%20n1.next%20%3D%20n2%0A%20%20%20%20n2.next%20%3D%20n3%0A%20%20%20%20n3.next%20%3D%20n4&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>配列全体は 1 つの変数であり、たとえば配列 <code>nums</code> には <code>nums[0]</code> や <code>nums[1]</code> などの要素が含まれます。一方、連結リストは複数の独立したノードオブジェクトで構成されます。通常、先頭ノードを連結リストの代名詞として扱います。たとえば上記のコードの連結リストは <code>n0</code> と表せます。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   ノードの挿入","text":"<p>連結リストへのノード挿入は非常に簡単です。下図に示すように、隣り合う 2 つのノード <code>n0</code> と <code>n1</code> の間に新しいノード <code>P</code> を挿入したいとします。このとき 2 つのノードの参照（ポインタ）を変更するだけでよく、時間計算量は \\(O(1)\\) です。</p> <p>これに対して、配列に要素を挿入する時間計算量は \\(O(n)\\) であり、データ量が大きい場合の効率は低くなります。</p> <p></p> <p> 図 4-6   連結リストへのノード挿入例 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"連結リストでノード n0 の後ろにノード P を挿入する\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストのノード n0 の後にノード _p を挿入 ###\n# Ruby の `p` は組み込み関数で、`P` は定数なので、代わりに `_p` を使える\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   ノードの削除","text":"<p>下図に示すように、連結リストでのノード削除も非常に簡単で、1 つのノードの参照（ポインタ）を変更するだけで済みます。</p> <p>なお、削除操作が完了した後もノード <code>P</code> は依然として <code>n1</code> を指していますが、実際にはこの連結リストをたどっても <code>P</code> へはアクセスできません。つまり、<code>P</code> はすでにこの連結リストには属していません。</p> <p></p> <p> 図 4-7   連結リストのノード削除 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"連結リストでノード n0 の直後のノードを削除する\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // メモリを解放する\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\n// 注意: stdio.h が remove 識別子を使用している\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // メモリを解放する\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストのノード n0 の直後のノードを削除 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   ノードへのアクセス","text":"<p>**連結リストでノードにアクセスする効率は低い**です。前節で述べたように、配列では任意の要素へ \\(O(1)\\) 時間でアクセスできます。これに対して連結リストでは、プログラムは先頭ノードから出発し、1 つずつ後ろへたどって目的のノードを見つける必要があります。つまり、連結リストの第 \\(i\\) ノードにアクセスするには \\(i - 1\\) 回のループが必要であり、時間計算量は \\(O(n)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"連結リスト内で index 番目のノードにアクセス\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### 連結リスト内の index 番目のノードにアクセス ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   ノードの探索","text":"<p>連結リストを走査し、その中から値が <code>target</code> のノードを探し、そのノードの連結リスト内でのインデックスを出力します。この処理も線形探索に属します。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"連結リストで値が target の最初のノードを探す\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストで値が target の最初のノードを探す */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストで値が target の最初のノードを探す ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","level":2,"title":"4.2.2   配列 vs. 連結リスト","text":"<p>次の表は、配列と連結リストの各種特徴と操作効率をまとめたものです。両者は互いに逆の格納戦略を採用しているため、各種性質や操作効率にも対照的な特徴が現れます。</p> <p> 表 4-1   配列と連結リストの効率比較 </p> 配列 連結リスト 格納方式 連続したメモリ空間 分散したメモリ空間 容量拡張 長さは不変 柔軟に拡張可能 メモリ効率 要素のメモリ消費は少ないが、空間を無駄にする可能性がある 要素のメモリ消費が多い 要素へのアクセス \\(O(1)\\) \\(O(n)\\) 要素の追加 \\(O(n)\\) \\(O(1)\\) 要素の削除 \\(O(n)\\) \\(O(1)\\)","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   一般的な連結リストの種類","text":"<p>下図に示すように、一般的な連結リストの種類は 3 つあります。</p> <ul> <li>単方向連結リスト：前述した通常の連結リストのことです。単方向連結リストのノードは、値と次のノードを指す参照の 2 つのデータを含みます。最初のノードを先頭ノード、最後のノードを末尾ノードと呼び、末尾ノードは空 <code>None</code> を指します。</li> <li>循環連結リスト：単方向連結リストの末尾ノードを先頭ノードへ向けると（先頭と末尾をつなぐと）、循環連結リストが得られます。循環連結リストでは、任意のノードを先頭ノードとみなせます。</li> <li>双方向連結リスト：単方向連結リストと比べて、双方向連結リストは 2 方向の参照を記録します。双方向連結リストのノード定義には、後続ノード（次のノード）と前駆ノード（前のノード）を指す参照（ポインタ）が含まれます。単方向連結リストより柔軟で、2 方向に連結リストを走査できますが、そのぶん多くのメモリ空間を必要とします。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"双方向連結リストノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # ノードの値\n        self.next: ListNode | None = None  # 後続ノードへの参照\n        self.prev: ListNode | None = None  # 前駆ノードへの参照\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\nstruct ListNode {\n    int val;         // ノードの値\n    ListNode *next;  // 後続ノードへのポインタ\n    ListNode *prev;  // 前駆ノードへのポインタ\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // コンストラクタ\n};\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode next;  // 後続ノードへの参照\n    ListNode prev;  // 前駆ノードへの参照\n    ListNode(int x) { val = x; }  // コンストラクタ\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode(int x) {  // コンストラクタ\n    int val = x;    // ノードの値\n    ListNode next;  // 後続ノードへの参照\n    ListNode prev;  // 前駆ノードへの参照\n}\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\ntype DoublyListNode struct {\n    Val  int             // ノードの値\n    Next *DoublyListNode // 後続ノードへのポインタ\n    Prev *DoublyListNode // 前駆ノードへのポインタ\n}\n\n// NewDoublyListNode の初期化\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    var val: Int // ノードの値\n    var next: ListNode? // 後続ノードへの参照\n    var prev: ListNode? // 前駆ノードへの参照\n\n    init(x: Int) { // コンストラクタ\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // ノードの値\n        this.next = next  ===  undefined ? null : next;  // 後続ノードへの参照\n        this.prev = prev  ===  undefined ? null : prev;  // 前駆ノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // ノードの値\n        this.next = next  ===  undefined ? null : next;  // 後続ノードへの参照\n        this.prev = prev  ===  undefined ? null : prev;  // 前駆ノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode? next;  // 後続ノードへの参照\n    ListNode? prev;  // 前駆ノードへの参照\n    ListNode(this.val, [this.next, this.prev]);  // コンストラクタ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 双方向連結リストノード型 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // ノードの値\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 後続ノードへのポインタ\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 前駆ノードへのポインタ\n}\n\n/* コンストラクタ */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\ntypedef struct ListNode {\n    int val;               // ノードの値\n    struct ListNode *next; // 後続ノードへのポインタ\n    struct ListNode *prev; // 前駆ノードへのポインタ\n} ListNode;\n\n/* コンストラクタ */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\n// コンストラクタ\nclass ListNode(x: Int) {\n    val _val: Int = x           // ノードの値\n    val next: ListNode? = null  // 後続ノードへの参照\n    val prev: ListNode? = null  // 前駆ノードへの参照\n}\n</code></pre> <pre><code># 双方向連結リストノードクラス\nclass ListNode\n  attr_accessor :val    # ノードの値\n  attr_accessor :next   # 後続ノードへの参照\n  attr_accessor :prev   # 前駆ノードへの参照\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> 図 4-8   一般的な連結リストの種類 </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   連結リストの典型的な応用","text":"<p>単方向連結リストは、スタック、キュー、ハッシュテーブル、グラフなどのデータ構造の実装によく用いられます。</p> <ul> <li>スタックとキュー：挿入と削除の両方の操作を連結リストの一端で行うと、その性質は後入れ先出しとなり、スタックに対応します。挿入を連結リストの一端で行い、削除をもう一端で行うと、その性質は先入れ先出しとなり、キューに対応します。</li> <li>ハッシュテーブル：連鎖アドレス法はハッシュ衝突を解決する主流の方式の 1 つであり、この方式では、衝突したすべての要素が 1 つの連結リストに格納されます。</li> <li>グラフ：隣接リストはグラフを表現する一般的な方法の 1 つであり、グラフの各頂点は 1 つの連結リストに関連付けられます。連結リスト内の各要素は、その頂点に接続されたほかの頂点を表します。</li> </ul> <p>双方向連結リストは、前後の要素をすばやく見つける必要がある場面でよく用いられます。</p> <ul> <li>高度なデータ構造：たとえば赤黒木や B 木では、ノードの親ノードへアクセスする必要があります。これは、ノード内に親ノードを指す参照を保持することで実現でき、双方向連結リストに似ています。</li> <li>ブラウザ履歴：Web ブラウザでユーザーが進むボタンや戻るボタンをクリックしたとき、ブラウザはユーザーが訪れた前後のページを知る必要があります。双方向連結リストの性質によって、この操作は簡単になります。</li> <li>LRU アルゴリズム：キャッシュ淘汰（LRU）アルゴリズムでは、最近最も使用されていないデータをすばやく見つける必要があり、さらにノードの高速な追加と削除も必要です。そのため、双方向連結リストが非常に適しています。</li> </ul> <p>循環連結リストは、オペレーティングシステムのリソーススケジューリングのように、周期的な操作が必要な場面でよく用いられます。</p> <ul> <li>ラウンドロビン時間片スケジューリングアルゴリズム：オペレーティングシステムにおいて、ラウンドロビン時間片スケジューリングは一般的な CPU スケジューリングアルゴリズムであり、一連のプロセスを循環的に処理する必要があります。各プロセスには 1 つの時間片が割り当てられ、その時間片を使い切ると、CPU は次のプロセスへ切り替わります。この循環操作は、循環連結リストで実現できます。</li> <li>データバッファ：一部のデータバッファ実装でも、循環連結リストが使われることがあります。たとえば音声・動画プレーヤーでは、データストリームを複数のバッファブロックに分割して循環連結リストへ格納し、シームレス再生を実現できます。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   リスト","text":"<p>リスト（list）は抽象的なデータ構造の概念であり、要素の順序付き集合を表す。要素のアクセス、更新、追加、削除、走査などの操作をサポートし、利用者は容量制限の問題を考慮する必要がない。リストは連結リストまたは配列に基づいて実装できる。</p> <ul> <li>連結リストは本質的にリストと見なすことができ、要素の追加・削除・参照・更新をサポートし、柔軟に動的拡張できる。</li> <li>配列も要素の追加・削除・参照・更新をサポートするが、長さが不変であるため、長さ制限のあるリストとしか見なせない。</li> </ul> <p>配列でリストを実装する場合、長さが不変である性質によってリストの実用性が低下する。これは、通常は事前にどれだけのデータを格納する必要があるかを決められず、適切なリスト長を選びにくいためである。長さが小さすぎると利用要件を満たせない可能性が高く、大きすぎるとメモリ空間の浪費を招く。</p> <p>この問題を解決するために、動的配列（dynamic array）を用いてリストを実装できる。これは配列の各種利点を引き継ぎつつ、プログラム実行中に動的な拡張を行える。</p> <p>実際には、多くのプログラミング言語の標準ライブラリが提供するリストは動的配列に基づいて実装されている。たとえば、Python の <code>list</code> 、Java の <code>ArrayList</code> 、C++ の <code>vector</code> 、C# の <code>List</code> などである。以降の議論では、「リスト」と「動的配列」を同じ概念として扱う。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   リストの基本操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   リストの初期化","text":"<p>通常は「初期値なし」と「初期値あり」の 2 つの初期化方法を用いる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストを初期化\n# 初期値なし\nnums1: list[int] = []\n# 初期値あり\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* リストを初期化 */\n// なお、C++ では vector が本稿でいう nums に相当する\n// 初期値なし\nvector&lt;int&gt; nums1;\n// 初期値あり\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// 初期値あり（配列の要素型は int[] のラッパークラスである Integer[] である必要があることに注意）\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;int&gt; nums1 = [];\n// 初期値あり\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* リストを初期化 */\n// 初期値なし\nnums1 := []int{}\n// 初期値あり\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* リストを初期化 */\n// 初期値なし\nlet nums1: [Int] = []\n// 初期値あり\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* リストを初期化 */\n// 初期値なし\nconst nums1 = [];\n// 初期値あり\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* リストを初期化 */\n// 初期値なし\nconst nums1: number[] = [];\n// 初期値あり\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;int&gt; nums1 = [];\n// 初期値あり\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* リストを初期化 */\n// 初期値なし\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// 初期値あり\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストを初期化 */\n// 初期値なし\nvar nums1 = listOf&lt;Int&gt;()\n// 初期値あり\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># リストを初期化\n# 初期値なし\nnums1 = []\n# 初期値あり\nnums = [1, 3, 2, 5, 4]\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20%23%20%E6%97%A0%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums1%20%3D%20%5B%5D%0A%20%20%20%20%23%20%E6%9C%89%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D&amp;cumulative=false&amp;curInstr=4&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   要素へのアクセス","text":"<p>リストの本質は配列であるため、要素へのアクセスと更新は \\(O(1)\\) 時間で行え、効率が高い。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 要素にアクセス\nnum: int = nums[1]  # インデックス 1 の要素にアクセス\n\n# 要素を更新\nnums[1] = 0    # インデックス 1 の要素を 0 に更新\n</code></pre> list.cpp<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.java<pre><code>/* 要素にアクセス */\nint num = nums.get(1);  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums.set(1, 0);  // インデックス 1 の要素を 0 に更新\n</code></pre> list.cs<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list_test.go<pre><code>/* 要素にアクセス */\nnum := nums[1]  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0     // インデックス 1 の要素を 0 に更新\n</code></pre> list.swift<pre><code>/* 要素にアクセス */\nlet num = nums[1] // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0 // インデックス 1 の要素を 0 に更新\n</code></pre> list.js<pre><code>/* 要素にアクセス */\nconst num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.ts<pre><code>/* 要素にアクセス */\nconst num: number = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.dart<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.rs<pre><code>/* 要素にアクセス */\nlet num: i32 = nums[1];  // インデックス 1 の要素にアクセス\n/* 要素を更新 */\nnums[1] = 0;             // インデックス 1 の要素を 0 に更新\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* 要素にアクセス */\nval num = nums[1]       // インデックス 1 の要素にアクセス\n/* 要素を更新 */\nnums[1] = 0             // インデックス 1 の要素を 0 に更新\n</code></pre> list.rb<pre><code># 要素にアクセス\nnum = nums[1] # インデックス 1 の要素にアクセス\n# 要素を更新\nnums[1] = 0 # インデックス 1 の要素を 0 に更新\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20num%20%3D%20nums%5B1%5D%20%20%23%20%E8%AE%BF%E9%97%AE%E7%B4%A2%E5%BC%95%201%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0%0A%0A%20%20%20%20%23%20%E6%9B%B4%E6%96%B0%E5%85%83%E7%B4%A0%0A%20%20%20%20nums%5B1%5D%20%3D%200%20%20%20%20%23%20%E5%B0%86%E7%B4%A2%E5%BC%95%201%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0%E6%9B%B4%E6%96%B0%E4%B8%BA%200&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   要素の挿入と削除","text":"<p>配列と比べて、リストでは要素を自由に追加・削除できる。リスト末尾への要素追加の時間計算量は \\(O(1)\\) だが、要素の挿入と削除の効率は依然として配列と同じで、時間計算量は \\(O(n)\\) である。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストをクリア\nnums.clear()\n\n# 末尾に要素を追加\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# 途中に要素を挿入\nnums.insert(3, 6)  # インデックス 3 に数値 6 を挿入\n\n# 要素を削除\nnums.pop(3)        # インデックス 3 の要素を削除\n</code></pre> list.cpp<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* 途中に要素を挿入 */\nnums.insert(nums.begin() + 3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.erase(nums.begin() + 3);      // インデックス 3 の要素を削除\n</code></pre> list.java<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.add(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);  // インデックス 3 の要素を削除\n</code></pre> list.cs<pre><code>/* リストをクリア */\nnums.Clear();\n\n/* 末尾に要素を追加 */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* 途中に要素を挿入 */\nnums.Insert(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.RemoveAt(3);  // インデックス 3 の要素を削除\n</code></pre> list_test.go<pre><code>/* リストをクリア */\nnums = nil\n\n/* 末尾に要素を追加 */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* 途中に要素を挿入 */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums = append(nums[:3], nums[4:]...) // インデックス 3 の要素を削除\n</code></pre> list.swift<pre><code>/* リストをクリア */\nnums.removeAll()\n\n/* 末尾に要素を追加 */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* 途中に要素を挿入 */\nnums.insert(6, at: 3) // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(at: 3) // インデックス 3 の要素を削除\n</code></pre> list.js<pre><code>/* リストをクリア */\nnums.length = 0;\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.splice(3, 0, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.splice(3, 1);  // インデックス 3 の要素を削除\n</code></pre> list.ts<pre><code>/* リストをクリア */\nnums.length = 0;\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.splice(3, 0, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.splice(3, 1);  // インデックス 3 の要素を削除\n</code></pre> list.dart<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.insert(3, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.removeAt(3); // インデックス 3 の要素を削除\n</code></pre> list.rs<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.insert(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);    // インデックス 3 の要素を削除\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.add(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);  // インデックス 3 の要素を削除\n</code></pre> list.rb<pre><code># リストをクリア\nnums.clear\n\n# 末尾に要素を追加\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# 途中に要素を挿入\nnums.insert(3, 6) # インデックス 3 に数値 6 を挿入\n\n# 要素を削除\nnums.delete_at(3) # インデックス 3 の要素を削除\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E6%9C%89%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B8%85%E7%A9%BA%E5%88%97%E8%A1%A8%0A%20%20%20%20nums.clear%28%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%9C%A8%E5%B0%BE%E9%83%A8%E6%B7%BB%E5%8A%A0%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.append%281%29%0A%20%20%20%20nums.append%283%29%0A%20%20%20%20nums.append%282%29%0A%20%20%20%20nums.append%285%29%0A%20%20%20%20nums.append%284%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%9C%A8%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.insert%283,%206%29%20%20%23%20%E5%9C%A8%E7%B4%A2%E5%BC%95%203%20%E5%A4%84%E6%8F%92%E5%85%A5%E6%95%B0%E5%AD%97%206%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.pop%283%29%20%20%20%20%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E7%B4%A2%E5%BC%95%203%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   リストの走査","text":"<p>配列と同様に、リストもインデックスに基づいて走査することも、各要素を直接走査することもできる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># インデックスでリストを走査\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# リストの要素を直接走査\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* リストの要素を直接走査 */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* インデックスでリストを走査 */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* インデックスでリストを走査 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* インデックスでリストを走査 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* インデックスでリストを走査 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// インデックスでリストを走査\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// リストの要素を直接走査\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* インデックスでリストを走査 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># インデックスでリストを走査\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# リストの要素を直接走査\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%80%9A%E8%BF%87%E7%B4%A2%E5%BC%95%E9%81%8D%E5%8E%86%E5%88%97%E8%A1%A8%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20nums%5Bi%5D%0A%0A%20%20%20%20%23%20%E7%9B%B4%E6%8E%A5%E9%81%8D%E5%8E%86%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20num&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   リストの連結","text":"<p>新しいリスト <code>nums1</code> が与えられたとき、それを元のリストの末尾に連結できる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 2 つのリストを連結\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # リスト nums1 を nums の後ろに連結\n</code></pre> list.cpp<pre><code>/* 2 つのリストを連結 */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// リスト nums1 を nums の後ろに連結\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* 2 つのリストを連結 */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.cs<pre><code>/* 2 つのリストを連結 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list_test.go<pre><code>/* 2 つのリストを連結 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // リスト nums1 を nums の後ろに連結\n</code></pre> list.swift<pre><code>/* 2 つのリストを連結 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // リスト nums1 を nums の後ろに連結\n</code></pre> list.js<pre><code>/* 2 つのリストを連結 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.ts<pre><code>/* 2 つのリストを連結 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.dart<pre><code>/* 2 つのリストを連結 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.rs<pre><code>/* 2 つのリストを連結 */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* 2 つのリストを連結 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // リスト nums1 を nums の後ろに連結\n</code></pre> list.rb<pre><code># 2 つのリストを連結\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%8B%BC%E6%8E%A5%E4%B8%A4%E4%B8%AA%E5%88%97%E8%A1%A8%0A%20%20%20%20nums1%20%3D%20%5B6,%208,%207,%2010,%209%5D%0A%20%20%20%20nums%20%2B%3D%20nums1%20%20%23%20%E5%B0%86%E5%88%97%E8%A1%A8%20nums1%20%E6%8B%BC%E6%8E%A5%E5%88%B0%20nums%20%E4%B9%8B%E5%90%8E&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   リストをソート","text":"<p>リストのソートが完了すると、配列系アルゴリズム問題でよく問われる「二分探索」や「両ポインタ」アルゴリズムを使えるようになる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストをソート\nnums.sort()  # ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.cpp<pre><code>/* リストをソート */\nsort(nums.begin(), nums.end());  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.java<pre><code>/* リストをソート */\nCollections.sort(nums);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.cs<pre><code>/* リストをソート */\nnums.Sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list_test.go<pre><code>/* リストをソート */\nsort.Ints(nums)  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.swift<pre><code>/* リストをソート */\nnums.sort() // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.js<pre><code>/* リストをソート */\nnums.sort((a, b) =&gt; a - b);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.ts<pre><code>/* リストをソート */\nnums.sort((a, b) =&gt; a - b);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.dart<pre><code>/* リストをソート */\nnums.sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.rs<pre><code>/* リストをソート */\nnums.sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストをソート */\nnums.sort() // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.rb<pre><code># リストをソート\nnums = nums.sort { |a, b| a &lt;=&gt; b } # ソート後、リスト要素は小さい順に並ぶ\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%8E%92%E5%BA%8F%E5%88%97%E8%A1%A8%0A%20%20%20%20nums.sort%28%29%20%20%23%20%E6%8E%92%E5%BA%8F%E5%90%8E%EF%BC%8C%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%E4%BB%8E%E5%B0%8F%E5%88%B0%E5%A4%A7%E6%8E%92%E5%88%97&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   リストの実装","text":"<p>多くのプログラミング言語にはリストが組み込まれており、たとえば Java、C++、Python などがある。それらの実装は比較的複雑で、初期容量や拡張倍率など各種パラメータの設定もよく考えられている。興味があればソースコードを参照して学べる。</p> <p>リストの動作原理への理解を深めるため、ここでは簡易版のリストを実装し、以下の 3 つの設計ポイントを含める。</p> <ul> <li>初期容量：妥当な配列の初期容量を選ぶ。この例では 10 を初期容量として選ぶ。</li> <li>要素数の記録：<code>size</code> という変数を宣言して、現在のリスト要素数を記録し、要素の挿入と削除に応じてリアルタイムに更新する。この変数により、リスト末尾の位置を特定し、拡張が必要かどうかを判断できる。</li> <li>拡張機構：要素を挿入する時点でリスト容量がいっぱいなら、拡張が必要になる。まず拡張倍率に応じてより大きな配列を作成し、次に現在の配列の全要素を順に新しい配列へ移す。この例では、配列を毎回以前の 2 倍に拡張する。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"リストクラス\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._capacity: int = 10  # リスト容量\n        self._arr: list[int] = [0] * self._capacity  # 配列（リスト要素を格納）\n        self._size: int = 0  # リストの長さ（現在の要素数）\n        self._extend_ratio: int = 2  # リスト拡張時の増加倍率\n\n    def size(self) -&gt; int:\n        \"\"\"リストの長さを取得（現在の要素数）\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"リスト容量を取得する\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"要素にアクセス\"\"\"\n        # インデックスが範囲外なら例外を送出する。以下同様\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"要素を更新\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"末尾に要素を追加\"\"\"\n        # 要素数が容量を超えると、拡張機構が発動する\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"中間に要素を挿入\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        # 要素数が容量を超えると、拡張機構が発動する\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # index 以降の要素をすべて 1 つ後ろへずらす\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # 要素数を更新\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"要素を削除\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        num = self._arr[index]\n        # インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # 要素数を更新\n        self._size -= 1\n        # 削除された要素を返す\n        return num\n\n    def extend_capacity(self):\n        \"\"\"リストの拡張\"\"\"\n        # 元の配列の `_extend_ratio` 倍の長さを持つ新しい配列を作成し、元の配列を新しい配列にコピーする\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # リストの容量を更新\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"有効長のリストを返す\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* リストクラス */\nclass MyList {\n  private:\n    int *arr;             // 配列（リスト要素を格納）\n    int arrCapacity = 10; // リスト容量\n    int arrSize = 0;      // リストの長さ（現在の要素数）\n    int extendRatio = 2;   // リスト拡張時の増加倍率\n\n  public:\n    /* コンストラクタ */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* デストラクタメソッド */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    int size() {\n        return arrSize;\n    }\n\n    /* リスト容量を取得する */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* 要素にアクセス */\n    int get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    void add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 中間に要素を挿入 */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size() == capacity())\n            extendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 要素を削除 */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        arrSize--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    void extendCapacity() {\n        // 元の配列の `extendRatio` 倍の長さを持つ新しい配列を作成する\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // 元の配列の全要素を新しい配列にコピー\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // メモリを解放する\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* 出力用にリストを Vector に変換 */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* リストクラス */\nclass MyList {\n    private int[] arr; // 配列（リスト要素を格納）\n    private int capacity = 10; // リスト容量\n    private int size = 0; // リストの長さ（現在の要素数）\n    private int extendRatio = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public int size() {\n        return size;\n    }\n\n    /* リスト容量を取得する */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* 要素にアクセス */\n    public int get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public void add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // 要素数を更新\n        size++;\n    }\n\n    /* 中間に要素を挿入 */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        size++;\n    }\n\n    /* 要素を削除 */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public void extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // リストの容量を更新\n        capacity = arr.length;\n    }\n\n    /* リストを配列に変換する */\n    public int[] toArray() {\n        int size = size();\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* リストクラス */\nclass MyList {\n    private int[] arr;           // 配列（リスト要素を格納）\n    private int arrCapacity = 10;    // リスト容量\n    private int arrSize = 0;         // リストの長さ（現在の要素数）\n    private readonly int extendRatio = 2;  // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* リスト容量を取得する */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* 要素にアクセス */\n    public int Get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public void Add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 中間に要素を挿入 */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 要素を削除 */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        arrSize--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public void ExtendCapacity() {\n        // `arrCapacity * extendRatio` の長さを持つ配列を新規作成し、元の配列を新しい配列にコピーする\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // リストの容量を更新\n        arrCapacity = arr.Length;\n    }\n\n    /* リストを配列に変換する */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* リストクラス */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* コンストラクタ */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // リスト容量\n        arr:         make([]int, 10), // 配列（リスト要素を格納）\n        arrSize:     0,               // リストの長さ（現在の要素数）\n        extendRatio: 2,               // リスト拡張時の増加倍率\n    }\n}\n\n/* リストの長さを取得（現在の要素数） */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* リスト容量を取得する */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* 要素にアクセス */\nfunc (l *myList) get(index int) int {\n    // インデックスが範囲外なら例外を送出する。以下同様\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    return l.arr[index]\n}\n\n/* 要素を更新 */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    l.arr[index] = num\n}\n\n/* 末尾に要素を追加 */\nfunc (l *myList) add(num int) {\n    // 要素数が容量を超えると、拡張機構が発動する\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // 要素数を更新\n    l.arrSize++\n}\n\n/* 中間に要素を挿入 */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    // 要素数が容量を超えると、拡張機構が発動する\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // index 以降の要素をすべて 1 つ後ろへずらす\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // 要素数を更新\n    l.arrSize++\n}\n\n/* 要素を削除 */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    num := l.arr[index]\n    // インデックス index より後の要素をすべて 1 つ前に移動する\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // 要素数を更新\n    l.arrSize--\n    // 削除された要素を返す\n    return num\n}\n\n/* リストの拡張 */\nfunc (l *myList) extendCapacity() {\n    // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // リストの容量を更新\n    l.arrCapacity = len(l.arr)\n}\n\n/* 有効長のリストを返す */\nfunc (l *myList) toArray() []int {\n    // 有効長の範囲内のリスト要素のみを変換\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* リストクラス */\nclass MyList {\n    private var arr: [Int] // 配列（リスト要素を格納）\n    private var _capacity: Int // リスト容量\n    private var _size: Int // リストの長さ（現在の要素数）\n    private let extendRatio: Int // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* リスト容量を取得する */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* 要素にアクセス */\n    func get(index: Int) -&gt; Int {\n        // インデックスが範囲外ならエラーを投げる。以下同様\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        return arr[index]\n    }\n\n    /* 要素を更新 */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        arr[index] = num\n    }\n\n    /* 末尾に要素を追加 */\n    func add(num: Int) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // 要素数を更新\n        _size += 1\n    }\n\n    /* 中間に要素を挿入 */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        // 要素数が容量を超えると、拡張機構が発動する\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // 要素数を更新\n        _size += 1\n    }\n\n    /* 要素を削除 */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        let num = arr[index]\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // 要素数を更新\n        _size -= 1\n        // 削除された要素を返す\n        return num\n    }\n\n    /* リストの拡張 */\n    func extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // リストの容量を更新\n        _capacity = arr.count\n    }\n\n    /* リストを配列に変換する */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* リストクラス */\nclass MyList {\n    #arr = new Array(); // 配列（リスト要素を格納）\n    #capacity = 10; // リスト容量\n    #size = 0; // リストの長さ（現在の要素数）\n    #extendRatio = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    size() {\n        return this.#size;\n    }\n\n    /* リスト容量を取得する */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* 要素にアクセス */\n    get(index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        return this.#arr[index];\n    }\n\n    /* 要素を更新 */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        this.#arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    add(num) {\n        // 長さが容量に等しい場合は拡張が必要\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 新しい要素をリストの末尾に追加する\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* 中間に要素を挿入 */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // 要素数を更新\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* 要素を削除 */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        let num = this.#arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // 要素数を更新\n        this.#size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // リストの容量を更新\n        this.#capacity = this.#arr.length;\n    }\n\n    /* リストを配列に変換する */\n    toArray() {\n        let size = this.size();\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* リストクラス */\nclass MyList {\n    private arr: Array&lt;number&gt;; // 配列（リスト要素を格納）\n    private _capacity: number = 10; // リスト容量\n    private _size: number = 0; // リストの長さ（現在の要素数）\n    private extendRatio: number = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public size(): number {\n        return this._size;\n    }\n\n    /* リスト容量を取得する */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* 要素にアクセス */\n    public get(index: number): number {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        return this.arr[index];\n    }\n\n    /* 要素を更新 */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        this.arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public add(num: number): void {\n        // 長さが容量に等しい場合は拡張が必要\n        if (this._size === this._capacity) this.extendCapacity();\n        // 新しい要素をリストの末尾に追加する\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* 中間に要素を挿入 */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // 要素数を更新\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* 要素を削除 */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        let num = this.arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // 要素数を更新\n        this._size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public extendCapacity(): void {\n        // `size` の長さを持つ配列を新規作成し、元の配列を新しい配列にコピーする\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // リストの容量を更新\n        this._capacity = this.arr.length;\n    }\n\n    /* リストを配列に変換する */\n    public toArray(): number[] {\n        let size = this.size();\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* リストクラス */\nclass MyList {\n  late List&lt;int&gt; _arr; // 配列（リスト要素を格納）\n  int _capacity = 10; // リスト容量\n  int _size = 0; // リストの長さ（現在の要素数）\n  int _extendRatio = 2; // リスト拡張時の増加倍率\n\n  /* コンストラクタ */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* リストの長さを取得（現在の要素数） */\n  int size() =&gt; _size;\n\n  /* リスト容量を取得する */\n  int capacity() =&gt; _capacity;\n\n  /* 要素にアクセス */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    return _arr[index];\n  }\n\n  /* 要素を更新 */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    _arr[index] = _num;\n  }\n\n  /* 末尾に要素を追加 */\n  void add(int _num) {\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // 要素数を更新\n    _size++;\n  }\n\n  /* 中間に要素を挿入 */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (_size == _capacity) extendCapacity();\n    // index 以降の要素をすべて 1 つ後ろへずらす\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // 要素数を更新\n    _size++;\n  }\n\n  /* 要素を削除 */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    int _num = _arr[index];\n    // インデックス index より後の要素をすべて 1 つ前に移動する\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // 要素数を更新\n    _size--;\n    // 削除された要素を返す\n    return _num;\n  }\n\n  /* リストの拡張 */\n  void extendCapacity() {\n    // 元の配列の `_extendRatio` 倍の長さを持つ新しい配列を作成する\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // 元の配列を新しい配列にコピー\n    List.copyRange(_newNums, 0, _arr);\n    // `_arr` の参照を更新\n    _arr = _newNums;\n    // リストの容量を更新\n    _capacity = _arr.length;\n  }\n\n  /* リストを配列に変換する */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* リストクラス */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // 配列（リスト要素を格納）\n    capacity: usize,     // リスト容量\n    size: usize,         // リストの長さ（現在の要素数）\n    extend_ratio: usize, // リスト拡張時の増加倍率\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* コンストラクタ */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* リスト容量を取得する */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* 要素にアクセス */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if index &gt;= self.size {\n            panic!(\"インデックスが範囲外です\")\n        };\n        return self.arr[index];\n    }\n\n    /* 要素を更新 */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"インデックスが範囲外です\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    pub fn add(&amp;mut self, num: i32) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // 要素数を更新\n        self.size += 1;\n    }\n\n    /* 中間に要素を挿入 */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"インデックスが範囲外です\")\n        };\n        // 要素数が容量を超えると、拡張機構が発動する\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // 要素数を更新\n        self.size += 1;\n    }\n\n    /* 要素を削除 */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"インデックスが範囲外です\")\n        };\n        let num = self.arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // 要素数を更新\n        self.size -= 1;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    pub fn extend_capacity(&amp;mut self) {\n        // 元の配列の extend_ratio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // リストの容量を更新\n        self.capacity = new_capacity;\n    }\n\n    /* リストを配列に変換する */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // 有効長の範囲内のリスト要素のみを変換\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* リストクラス */\ntypedef struct {\n    int *arr;        // 配列（リスト要素を格納）\n    int capacity;    // リスト容量\n    int size;        // リストのサイズ\n    int extendRatio; // リストが拡張されるたびの倍率\n} MyList;\n\n/* コンストラクタ */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* デストラクタ */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* リストの長さを取得 */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* リスト容量を取得する */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* 要素にアクセス */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* 要素を更新 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* 末尾に要素を追加 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 容量を拡張\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* 中間に要素を挿入 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 容量を拡張\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* 要素を削除 */\n// 注意: stdio.h が remove 識別子を使用している\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* リストの拡張 */\nvoid extendCapacity(MyList *nums) {\n    // 先に領域を確保する\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // 古いデータを新しいデータにコピー\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // 古いデータを解放する\n    free(temp);\n\n    // 新しいデータに更新\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* 出力用にリストを Array に変換 */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* リストクラス */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // 配列（リスト要素を格納）\n    private var capacity: Int = 10 // リスト容量\n    private var size: Int = 0 // リストの長さ（現在の要素数）\n    private var extendRatio: Int = 2 // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    fun size(): Int {\n        return size\n    }\n\n    /* リスト容量を取得する */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* 要素にアクセス */\n    fun get(index: Int): Int {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        return arr[index]\n    }\n\n    /* 要素を更新 */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        arr[index] = num\n    }\n\n    /* 末尾に要素を追加 */\n    fun add(num: Int) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // 要素数を更新\n        size++\n    }\n\n    /* 中間に要素を挿入 */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity()\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // 要素数を更新\n        size++\n    }\n\n    /* 要素を削除 */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        val num = arr[index]\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // 要素数を更新\n        size--\n        // 削除された要素を返す\n        return num\n    }\n\n    /* リストの拡張 */\n    fun extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = arr.copyOf(capacity() * extendRatio)\n        // リストの容量を更新\n        capacity = arr.size\n    }\n\n    /* リストを配列に変換する */\n    fun toArray(): IntArray {\n        val size = size()\n        // 有効長の範囲内のリスト要素のみを変換\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### リストクラス ###\nclass MyList\n  attr_reader :size       # リストの長さを取得（現在の要素数）\n  attr_reader :capacity   # リスト容量を取得する\n\n  ### コンストラクタ ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### 要素にアクセス ###\n  def get(index)\n    # インデックスが範囲外なら例外を送出する。以下同様\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### 要素にアクセス ###\n  def set(index, num)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### 末尾に要素を追加 ###\n  def add(num)\n    # 要素数が容量を超えると、拡張機構が発動する\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # 要素数を更新\n    @size += 1\n  end\n\n  ### 途中に要素を挿入 ###\n  def insert(index, num)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n\n    # 要素数が容量を超えると、拡張機構が発動する\n    extend_capacity if size == capacity\n\n    # index 以降の要素をすべて 1 つ後ろへずらす\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # 要素数を更新\n    @size += 1\n  end\n\n  ### 要素の削除 ###\n  def remove(index)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # インデックス index より後の要素をすべて 1 つ前に移動する\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # 要素数を更新\n    @size -= 1\n\n    # 削除された要素を返す\n    num\n  end\n\n  ### リストの容量拡張 ###\n  def extend_capacity\n    # 元の配列の extend_ratio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # リストの容量を更新\n    @capacity = arr.length\n  end\n\n  ### リストを配列に変換 ###\n  def to_array\n    sz = size\n    # 有効長の範囲内のリスト要素のみを変換\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   メモリとキャッシュ *","text":"<p>本章の前二節では、配列と連結リストという二つの基礎的かつ重要なデータ構造を扱いました。これらはそれぞれ「連続格納」と「分散格納」という二つの物理構造を表しています。</p> <p>実際には、物理構造はプログラムにおけるメモリとキャッシュの利用効率を大きく左右し、ひいてはアルゴリズムプログラム全体の性能に影響します。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   コンピュータの記憶装置","text":"<p>コンピュータには三種類の記憶装置があります。ハードディスク（hard disk）、メモリ（random-access memory, RAM）、キャッシュ（cache memory）です。以下の表は、これらがコンピュータシステムで担う役割と性能上の特徴を示しています。</p> <p> 表 4-2   コンピュータの記憶装置 </p> ハードディスク メモリ キャッシュ 用途 OS、プログラム、ファイルなどを長期保存 実行中のプログラムや処理中のデータを一時保存 頻繁にアクセスされるデータや命令を保存し、CPU のメモリアクセス回数を減らす 揮発性 電源断後もデータは失われない 電源断後にデータは失われる 電源断後にデータは失われる 容量 大きい、TB 級 小さい、GB 級 非常に小さい、MB 級 速度 遅い、数百〜数千 MB/s 速い、数十 GB/s 非常に速い、数十〜数百 GB/s 価格（人民元） 比較的安価、数角〜数元 / GB 比較的高価、数十〜数百元 / GB 非常に高価、CPU と一体で価格設定される <p>コンピュータの記憶システムは、下図のようなピラミッド構造として捉えられます。ピラミッドの頂点に近い記憶装置ほど速度は速く、容量は小さく、コストは高くなります。この多層構造は偶然ではなく、コンピュータ科学者やエンジニアによる熟慮の末の設計です。</p> <ul> <li>ハードディスクはメモリで置き換えにくい。まず、メモリ内のデータは電源断後に失われるため、長期保存には向きません。次に、メモリのコストはハードディスクの数十倍であり、消費者市場で広く普及しにくいという問題があります。</li> <li>キャッシュは大容量と高速性を両立しにくい。L1、L2、L3 キャッシュの容量が段階的に増えるにつれて、物理サイズは大きくなり、CPU コアとの物理的距離も遠くなります。その結果、データ転送時間が増え、要素アクセスの遅延も大きくなります。現在の技術では、多層キャッシュ構造が容量、速度、コストの最適なバランスです。</li> </ul> <p></p> <p> 図 4-9   コンピュータの記憶システム </p> <p>Tip</p> <p>コンピュータの記憶階層は、速度、容量、コストの三者間にある巧妙なバランスを体現しています。実際、このようなトレードオフはあらゆる工業分野に広く存在しており、異なる利点と制約のあいだで最適な均衡点を見つけることが求められます。</p> <p>要するに、ハードディスクは大量データの長期保存に、メモリはプログラム実行中に処理しているデータの一時保存に、キャッシュは頻繁にアクセスされるデータや命令の保存に用いられ、プログラム実行効率を高めます。三者は協調して動作し、コンピュータシステムの高効率な運用を支えています。</p> <p>次の図に示すように、プログラム実行時にはデータがハードディスクからメモリへ読み込まれ、CPU の計算に使われます。キャッシュは CPU の一部と見なせ、メモリからデータを賢く読み込むことで、CPU に高速なデータ読み出しを提供し、プログラムの実行効率を大きく高め、低速なメモリへの依存を減らします。</p> <p></p> <p> 図 4-10   ハードディスク、メモリ、キャッシュ間のデータの流れ </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   データ構造のメモリ効率","text":"<p>メモリ空間の利用という観点では、配列と連結リストにはそれぞれ利点と制約があります。</p> <p>一方で、メモリは有限であり、同じメモリ領域を複数のプログラムで共有することはできません。そのため、データ構造にはできるだけ効率よく空間を使うことが求められます。配列の要素は密に並んでおり、連結リストのノード間参照（ポインタ）を保持する追加領域が不要なため、空間効率は高くなります。しかし、配列は十分な連続メモリを一度に確保する必要があり、メモリ浪費を招くことがありますし、拡張時にも追加の時間と空間コストがかかります。これに対して連結リストは「ノード」単位で動的にメモリを割り当て・解放でき、より高い柔軟性を備えています。</p> <p>他方で、プログラムの実行中には、メモリの確保と解放を繰り返すにつれて、空きメモリの断片化はますます進み、メモリ利用効率の低下を招きます。配列は連続した格納方式を取るため、比較的メモリ断片化を起こしにくい構造です。反対に、連結リストの要素は分散して格納されるため、頻繁な挿入や削除を行うと、より断片化を招きやすくなります。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   データ構造のキャッシュ効率","text":"<p>キャッシュは容量こそメモリよりはるかに小さいものの、速度はメモリよりずっと速く、プログラム実行速度において極めて重要な役割を果たします。キャッシュ容量には限りがあり、頻繁にアクセスされる一部のデータしか保持できません。そのため、CPU がアクセスしようとするデータがキャッシュ内に存在しない場合、キャッシュミス（cache miss）が発生し、CPU は低速なメモリから必要なデータを読み込まなければなりません。</p> <p>当然ながら、「キャッシュミス」が少ないほど、CPU のデータ読み書き効率は高くなり、プログラム性能も向上します。CPU がキャッシュからデータを正常に取得できた割合をキャッシュヒット率（cache hit rate）と呼び、この指標は通常、キャッシュ効率の評価に用いられます。</p> <p>できるだけ高い効率を実現するため、キャッシュは次のようなデータ読み込みの仕組みを採用しています。</p> <ul> <li>キャッシュライン：キャッシュはデータを 1 バイト単位で保存・読み込みするのではなく、キャッシュライン単位で扱います。1 バイト単位の転送と比べて、キャッシュライン単位のほうが効率的です。</li> <li>プリフェッチ機構：プロセッサはデータアクセスのパターン（たとえば順次アクセス、一定ステップ幅のスキップアクセスなど）を予測し、そのパターンに応じてデータをキャッシュへ読み込むことで、ヒット率を高めます。</li> <li>空間的局所性：あるデータがアクセスされた場合、その近傍のデータも近いうちにアクセスされる可能性があります。そのため、キャッシュはあるデータを読み込む際に、その周辺のデータもあわせて読み込み、ヒット率を高めます。</li> <li>時間的局所性：あるデータがアクセスされた場合、そのデータは近い将来に再びアクセスされる可能性が高いです。キャッシュはこの性質を利用し、最近アクセスしたデータを保持することでヒット率を高めます。</li> </ul> <p>実際には、配列と連結リストではキャッシュの利用効率が異なり、主に次の点に表れます。</p> <ul> <li>使用空間：連結リストの要素は配列要素より多くの空間を占めるため、キャッシュに収まる有効データ量は少なくなります。</li> <li>キャッシュライン：連結リストのデータはメモリの各所に分散しており、キャッシュは「ライン単位で読み込む」ため、無効データまで読み込む割合が高くなります。</li> <li>プリフェッチ機構：配列のほうが連結リストよりもデータアクセスのパターンを「予測しやすく」、システムが次に読み込まれるデータを推測しやすくなります。</li> <li>空間的局所性：配列はまとまったメモリ空間に格納されるため、読み込まれたデータの近くにあるデータも、まもなくアクセスされる可能性が高くなります。</li> </ul> <p>全体として、配列はより高いキャッシュヒット率を持つため、操作効率では通常、連結リストより優れています。このため、アルゴリズム問題を解く際には、配列ベースで実装されたデータ構造のほうが好まれることが多くなります。</p> <p>注意すべきなのは、**キャッシュ効率が高いからといって、配列があらゆる状況で連結リストより優れているとは限らない**という点です。実際にどのデータ構造を選ぶかは、具体的な要件に応じて決めるべきです。たとえば、配列と連結リストはいずれも「スタック」データ構造を実装できますが（次章で詳しく説明します）、適した場面は異なります。</p> <ul> <li>アルゴリズム問題に取り組むときは、一般に配列ベースのスタックを選ぶ傾向があります。より高い操作効率とランダムアクセス能力を備えており、その代償は配列用に一定量のメモリを事前確保することだけです。</li> <li>データ量が非常に大きく、動的性が高く、スタックの想定サイズを見積もりにくい場合は、連結リストベースのスタックのほうが適しています。連結リストなら大量のデータをメモリの異なる場所に分散して保存でき、配列拡張による追加コストも回避できます。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   まとめ","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>配列と連結リストは 2 種類の基本的なデータ構造であり、それぞれコンピュータメモリにおけるデータの 2 つの格納方式、すなわち連続領域への格納と分散領域への格納を表す。両者の特徴は相互補完的である。</li> <li>配列はランダムアクセスをサポートし、使用メモリも少ない。一方で、要素の挿入と削除の効率は低く、初期化後に長さを変更できない。</li> <li>連結リストは参照（ポインタ）を変更することでノードの挿入と削除を効率的に行え、長さも柔軟に調整できる。一方で、ノードへのアクセス効率は低く、メモリ使用量も多い。一般的な連結リストには単方向連結リスト、循環連結リスト、双方向連結リストがある。</li> <li>リストは、追加・削除・検索・更新をサポートする順序付き要素集合であり、通常は動的配列に基づいて実装される。配列の利点を保ちながら、長さを柔軟に調整できる。</li> <li>リストの登場により配列の実用性は大幅に高まったが、一部のメモリ領域が無駄になる可能性がある。</li> <li>プログラムの実行時、データは主にメモリに格納される。配列はより高いメモリ空間効率を提供でき、連結リストはメモリ利用の面でより柔軟である。</li> <li>キャッシュは、キャッシュライン、プリフェッチ機構、空間局所性と時間局所性といったデータ読み込み機構を通じて CPU に高速なデータアクセスを提供し、プログラムの実行効率を大きく向上させる。</li> <li>配列はキャッシュヒット率が高いため、通常は連結リストよりも高効率である。データ構造を選択する際は、具体的な要件や場面に応じて適切に選ぶべきである。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：配列をスタックに格納する場合とヒープに格納する場合では、時間効率と空間効率に影響がありますか？</p> <p>スタック上とヒープ上の配列はいずれも連続したメモリ領域に格納されるため、データ操作の効率は基本的に同じである。ただし、スタックとヒープにはそれぞれ特徴があり、以下の違いが生じる。</p> <ol> <li>確保と解放の効率：スタックは比較的小さなメモリ領域で、確保はコンパイラによって自動的に行われる。一方、ヒープメモリは相対的に大きく、コード内で動的に確保できる反面、断片化しやすい。そのため、ヒープ上での確保と解放は通常スタック上より遅い。</li> <li>サイズ制限：スタックメモリは比較的小さく、ヒープのサイズは一般に利用可能メモリに制限される。そのため、ヒープは大きな配列の格納により適している。</li> <li>柔軟性：スタック上の配列サイズはコンパイル時に確定している必要があるが、ヒープ上の配列サイズは実行時に動的に決定できる。</li> </ol> <p>Q：なぜ配列では同じ型の要素が求められるのに、連結リストでは同じ型であることが強調されないのですか？</p> <p>連結リストはノードで構成され、ノード同士は参照（ポインタ）で接続されている。各ノードには <code>int</code>、<code>double</code>、<code>string</code>、<code>object</code> など、異なる型のデータを格納できる。</p> <p>これに対して、配列要素は同じ型でなければならない。そうでなければ、オフセットを計算して対応する要素位置を取得できないからである。たとえば、配列に <code>int</code> と <code>long</code> の 2 種類が同時に含まれていて、各要素がそれぞれ 4 バイトと 8 バイトを占める場合、配列内に 2 種類の「要素長」が存在するため、次の式ではオフセットを計算できない。</p> <pre><code># 要素のメモリアドレス = 配列のメモリアドレス（先頭要素のメモリアドレス） + 要素長 * 要素インデックス\n</code></pre> <p>Q：ノード <code>P</code> を削除した後、<code>P.next</code> を <code>None</code> に設定する必要はありますか？</p> <p><code>P.next</code> を変更しなくてもよい。この連結リストの観点では、先頭ノードから末尾ノードまでたどっても、もはや <code>P</code> に出会うことはない。つまり、ノード <code>P</code> はすでに連結リストから削除されており、この時点で <code>P</code> がどこを指していても、この連結リストには影響しない。</p> <p>データ構造とアルゴリズム（問題を解くとき）の観点では、切り離さなくても問題はなく、プログラムのロジックが正しいことを保証すればよい。標準ライブラリの観点では、切り離したほうがより安全で、ロジックも明確である。切り離さない場合、削除されたノードが適切に回収されなかったとすると、後続ノードのメモリ回収に影響する可能性がある。</p> <p>Q：連結リストでの挿入と削除の時間計算量は \\(O(1)\\) です。しかし、追加や削除の前には要素を探すのに \\(O(n)\\) の時間が必要です。では、なぜ時間計算量は \\(O(n)\\) ではないのですか？</p> <p>要素を先に探してから削除するのであれば、時間計算量が \\(O(n)\\) であるのは確かである。しかし、連結リストの \\(O(1)\\) での追加・削除という利点は、ほかの用途で生かせる。たとえば、両端キューは連結リストで実装するのに適しており、先頭ノードと末尾ノードを常に指すポインタ変数を維持すれば、各挿入・削除操作はどれも \\(O(1)\\) になる。</p> <p>Q：図「連結リストの定義と格納方式」で、薄青色のノードポインタ部分は 1 つのメモリアドレスを占めているのですか？ それともノード値と半分ずつなのでしょうか？</p> <p>この模式図は定性的な表現にすぎず、定量的な表現は具体的な状況に応じて分析する必要がある。</p> <ul> <li>ノード値が占める領域は型によって異なり、たとえば <code>int</code>、<code>long</code>、<code>double</code>、インスタンスオブジェクトなどがある。</li> <li>ポインタ変数が占めるメモリ空間の大きさは、使用する OS やコンパイル環境によって異なり、多くは 8 バイトまたは 4 バイトである。</li> </ul> <p>Q：リストの末尾への要素追加は常に \\(O(1)\\) ですか？</p> <p>要素を追加する際にリスト長を超える場合は、先にリストを拡張してから追加する必要がある。システムは新しいメモリ領域を確保し、元のリストの全要素をそこへ移動するため、このとき時間計算量は \\(O(n)\\) になる。</p> <p>Q：「リストの登場により配列の実用性は大きく向上したが、一部のメモリ空間が無駄になる可能性がある」というのは、容量、長さ、拡張倍率のような追加変数が占めるメモリのことですか？</p> <p>ここでいう空間の無駄には主に 2 つの意味がある。一方では、リストには初期長が設定されるが、必ずしもそれだけ必要とは限らない。もう一方では、頻繁な拡張を防ぐため、拡張時には通常ある係数、たとえば \\(\\times 1.5\\) を掛ける。このため、多くの空きスロットが生じ、通常それらを完全に埋めることはできない。</p> <p>Q：Python で <code>n = [1, 2, 3]</code> を初期化した後、この 3 つの要素のアドレスは連続しています。しかし <code>m = [2, 1, 3]</code> を初期化すると、各要素の id は連続しておらず、それぞれ <code>n</code> 内の同じ値と一致していることがわかります。これらの要素のアドレスが連続していないなら、<code>m</code> も配列なのですか？</p> <p>仮にリスト要素を連結リストのノード <code>n = [n1, n2, n3, n4, n5]</code> に置き換えたとしても、通常この 5 つのノードオブジェクトもメモリ上の各所に分散して格納される。それでも、与えられたリストインデックスに対して、私たちは依然として \\(O(1)\\) 時間でノードのメモリアドレスを取得し、対応するノードにアクセスできる。これは、配列に格納されているのがノードそのものではなく、ノードへの参照だからである。</p> <p>多くの言語と異なり、Python では数値もオブジェクトとしてラップされており、リストに格納されているのは数値そのものではなく、数値への参照である。そのため、2 つの配列内の同じ数値が同一の id を持つことがあり、しかもそれらの数値のメモリアドレスは連続している必要がない。</p> <p>Q：C++ STL の <code>std::list</code> はすでに双方向連結リストを実装していますが、アルゴリズム本ではあまり直接使われないようです。何か制約があるのでしょうか？</p> <p>一方では、私たちは多くの場合、アルゴリズムの実装に配列を好み、必要なときにだけ連結リストを使う。その主な理由は 2 つある。</p> <ul> <li>空間オーバーヘッド：各要素には 2 つの追加ポインタ（前の要素用と次の要素用）が必要なため、<code>std::list</code> は通常 <code>std::vector</code> より多くの空間を消費する。</li> <li>キャッシュ非効率：データが連続して格納されていないため、<code>std::list</code> はキャッシュの利用効率が低い。一般には、<code>std::vector</code> のほうが性能がよい。</li> </ul> <p>もう一方では、連結リストを使う必要がある代表的な場面は主に二分木とグラフである。スタックやキューについては、連結リストではなく、たいてい言語が提供する <code>stack</code> と <code>queue</code> を使う。</p> <p>Q：<code>res = [[0]] * n</code> という操作で 2 次元リストを生成した場合、それぞれの <code>[0]</code> は独立していますか？</p> <p>独立していない。この 2 次元リストでは、すべての <code>[0]</code> は実際には同一オブジェクトへの参照である。そのうちの 1 つを変更すると、対応するすべての要素が一緒に変化することがわかる。</p> <p>2 次元リスト内の各 <code>[0]</code> を独立させたい場合は、<code>res = [[0] for _ in range(n)]</code> を使って実現できる。この方式の原理は、独立した <code>[0]</code> リストオブジェクトを \\(n\\) 個初期化していることにある。</p> <p>Q：<code>res = [0] * n</code> という操作で生成されたリストでは、それぞれの整数 0 は独立していますか？</p> <p>このリストでは、すべての整数 0 が同一オブジェクトへの参照である。これは、Python が小さな整数（通常は -5 から 256）に対してキャッシュプール機構を採用し、オブジェクトの再利用を最大化して性能を向上させているためである。</p> <p>それらは同じオブジェクトを指しているが、それでもリスト内の各要素は独立して変更できる。これは、Python の整数が「イミュータブルオブジェクト」だからである。ある要素を変更するとき、実際には別のオブジェクトへの参照に切り替わるのであって、元のオブジェクトそのものを変更しているわけではない。</p> <p>しかし、リスト要素が「ミュータブルオブジェクト」（たとえばリスト、辞書、クラスインスタンスなど）である場合は、ある要素を変更するとそのオブジェクト自体が直接変更され、そのオブジェクトを参照しているすべての要素に同じ変化が生じる。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"第 13 章   バックトラッキング","text":"<p>Abstract</p> <p>私たちは迷宮の探検者のように、前へ進む道で困難に出会うことがあります。</p> <p>バックトラッキングの力によってやり直しができ、試行を重ね、最後には光へ通じる出口を見つけられます。</p>","path":["第 13 章 &nbsp; バックトラッキング"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"章の内容","text":"<ul> <li>13.1   バックトラッキングアルゴリズム</li> <li>13.2   全順列問題</li> <li>13.3   部分和問題</li> <li>13.4   n クイーン問題</li> <li>13.5   まとめ</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   バックトラッキングアルゴリズム","text":"<p>バックトラッキングアルゴリズム（backtracking algorithm）は、総当たりによって問題を解く手法です。その中核となる考え方は、初期状態から出発し、あり得るすべての解を力任せに探索し、正しい解に到達したらそれを記録し、解を見つけるか、考えられるすべての選択を試しても解が見つからなくなるまで続ける、というものです。</p> <p>バックトラッキングアルゴリズムでは、通常「深さ優先探索」を用いて解空間をたどります。「二分木」の章で述べたように、前順・中順・後順走査はいずれも深さ優先探索に属します。ここでは前順走査を使ってバックトラッキング問題を構成し、その仕組みを段階的に理解していきます。</p> <p>例題1</p> <p>1 本の二分木が与えられたとき、値が \\(7\\) のノードをすべて探索して記録し、そのノードのリストを返してください。</p> <p>この問題では、この木を前順走査し、現在のノードの値が \\(7\\) かどうかを判定します。該当する場合は、そのノードの値を結果リスト <code>res</code> に追加します。関連する処理は下図と次のコードのとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # 解を記録\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 解を記録\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* 前順走査：例題 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* 前順走査：例題 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // 解を記録\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* 前順走査：例題 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // 解を記録\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* 前順走査：例題 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 解を記録\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* 前順走査：例題 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 解を記録\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // 解を記録\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* 前順走査：例題 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* 前順走査：例題 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### 前順走査：例題1 ###\ndef pre_order(root)\n  return unless root\n\n  # 解を記録\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 13-1   前順走査でノードを探索する </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   試行と戻る","text":"<p>バックトラッキングアルゴリズムと呼ばれるのは、解空間を探索する際に「試行」と「戻る」という戦略を取るためです。探索中に、ある状態から先へ進めない、または条件を満たす解を得られないと分かった場合、アルゴリズムは直前の選択を取り消して前の状態へ戻り、別の選択肢を試します。</p> <p>例題1では、各ノードへの訪問が 1 回の「試行」に対応し、葉ノードを越えるか親ノードへ戻る <code>return</code> は「戻る」を表します。</p> <p>ここで強調しておきたいのは、**戻るとは関数の return だけを指すわけではない**という点です。これを説明するために、例題1を少し拡張します。</p> <p>例題2</p> <p>二分木の中で値が \\(7\\) のノードをすべて探索し、根ノードからそれらのノードまでの経路を返してください。</p> <p>例題1のコードを土台に、訪問済みノードの経路を記録するためのリスト <code>path</code> を導入します。値が \\(7\\) のノードに到達したら、<code>path</code> をコピーして結果リスト <code>res</code> に追加します。走査が完了すると、<code>res</code> にはすべての解が保存されています。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 2\"\"\"\n    if root is None:\n        return\n    # 試す\n    path.append(root)\n    if root.val == 7:\n        # 解を記録\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # バックトラック\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // 試す\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // 試す\n    path.add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // バックトラック\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* 前順走査：例題 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // 試す\n    path.Add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // バックトラック\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* 前順走査：例題 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // 試す\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 解を記録\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // バックトラック\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* 前順走査：例題 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 試す\n    path.append(root)\n    if root.val == 7 {\n        // 解を記録\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // バックトラック\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* 前順走査：例題 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* 前順走査：例題 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // 試す\n  path.add(root);\n  if (root.val == 7) {\n    // 解を記録\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // バックトラック\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* 前順走査：例題 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // 試す\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // バックトラック\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // 試す\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 解を記録\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* 前順走査：例題 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // 試す\n    path!!.add(root)\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // バックトラック\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### 前順走査：例題2 ###\ndef pre_order(root)\n  return unless root\n\n  # 試す\n  $path &lt;&lt; root\n\n  # 解を記録\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # バックトラック\n  $path.pop\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>各「試行」で現在のノードを <code>path</code> に追加して経路を記録し、「戻る」前にはそのノードを <code>path</code> から取り除き、**今回の試行前の状態を復元する**必要があります。</p> <p>次の図に示す過程を見ると、試行と戻るは「前進」と「取り消し」として理解できます。この 2 つの操作は互いに逆向きです。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 13-2   試行と戻る </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   枝刈り","text":"<p>複雑なバックトラッキング問題には、通常 1 つ以上の制約条件が含まれます。制約条件は多くの場合「枝刈り」に利用できます。</p> <p>例題3</p> <p>二分木の中で値が \\(7\\) のノードをすべて探索し、根ノードからそれらのノードまでの経路を返してください。ただし、経路には値が \\(3\\) のノードを含めてはいけません。</p> <p>上の制約条件を満たすために、枝刈り操作を追加する必要があります。探索中に値が \\(3\\) のノードに出会った場合は、そこで早めに return し、それ以上探索を続けません。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 3\"\"\"\n    # 枝刈り\n    if root is None or root.val == 3:\n        return\n    # 試す\n    path.append(root)\n    if root.val == 7:\n        # 解を記録\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # バックトラック\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode *root) {\n    // 枝刈り\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // 試す\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode root) {\n    // 枝刈り\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 試す\n    path.add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // バックトラック\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* 前順走査：例題 3 */\nvoid PreOrder(TreeNode? root) {\n    // 枝刈り\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 試す\n    path.Add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // バックトラック\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* 前順走査：例題 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // 枝刈り\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // 試す\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 解を記録\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // バックトラック\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* 前順走査：例題 3 */\nfunc preOrder(root: TreeNode?) {\n    // 枝刈り\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // 試す\n    path.append(root)\n    if root.val == 7 {\n        // 解を記録\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // バックトラック\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* 前順走査：例題 3 */\nfunction preOrder(root, path, res) {\n    // 枝刈り\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* 前順走査：例題 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 枝刈り\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // 試す\n  path.add(root);\n  if (root.val == 7) {\n    // 解を記録\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // バックトラック\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* 前順走査：例題 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // 枝刈り\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // 試す\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // バックトラック\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode *root) {\n    // 枝刈り\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // 試す\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 解を記録\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* 前順走査：例題 3 */\nfun preOrder(root: TreeNode?) {\n    // 枝刈り\n    if (root == null || root._val == 3) {\n        return\n    }\n    // 試す\n    path!!.add(root)\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // バックトラック\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### 前順走査：例題3 ###\ndef pre_order(root)\n  # 枝刈り\n  return if !root || root.val == 3\n\n  # 試す\n  $path.append(root)\n\n  # 解を記録\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # バックトラック\n  $path.pop\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>「枝刈り」は非常にイメージしやすい名称です。次の図のように、探索中に**制約条件を満たさない探索分岐を切り落とす**ことで、多くの無意味な試行を避け、探索効率を高められます。</p> <p></p> <p> 図 13-3   制約条件にもとづく枝刈り </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   フレームワークコード","text":"<p>次に、バックトラッキングにおける「試行・戻る・枝刈り」の本体部分を抽出し、汎用性の高いコードフレームワークへまとめてみます。</p> <p>以下のフレームワークコードでは、<code>state</code> は問題の現在状態、<code>choices</code> はその状態で取り得る選択肢を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"バックトラッキングアルゴリズムのフレームワーク\"\"\"\n    # 解かどうかを判定\n    if is_solution(state):\n        # 解を記録\n        record_solution(state, res)\n        # これ以上探索しない\n        return\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り: 選択が妥当かを判定\n        if is_valid(state, choice):\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (Choice choice : choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (Choice choice : choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 解かどうかを判定\n    if (IsSolution(state)) {\n        // 解を記録\n        RecordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    foreach (Choice choice in choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (IsValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // 解かどうかを判定\n    if isSolution(state) {\n        // 解を記録\n        recordSolution(state, res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for _, choice := range choices {\n        // 枝刈り: 選択が妥当かを判定\n        if isValid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // 解かどうかを判定\n    if isSolution(state: state) {\n        // 解を記録\n        recordSolution(state: state, res: &amp;res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 選択が妥当かを判定\n        if isValid(state: state, choice: choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunction backtrack(state, choices, res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (let choice of choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (let choice of choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // 解かどうかを判定\n  if (isSolution(state)) {\n    // 解を記録\n    recordSolution(state, res);\n    // これ以上探索しない\n    return;\n  }\n  // すべての選択肢を走査\n  for (Choice choice in choices) {\n    // 枝刈り: 選択が妥当かを判定\n    if (isValid(state, choice)) {\n      // 試行: 選択を行い、状態を更新\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // 戻る: 選択を取り消し、前の状態に戻す\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // 解かどうかを判定\n    if is_solution(state) {\n        // 解を記録\n        record_solution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 選択が妥当かを判定\n        if is_valid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res, numRes);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; numChoices; i++) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, &amp;choices[i])) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### バックトラッキングアルゴリズムのフレームワーク ###\ndef backtrack(state, choices, res)\n    # 解かどうかを判定\n    if is_solution?(state)\n        # 解を記録\n        record_solution(state, res)\n        return\n    end\n\n    # すべての選択肢を走査\n    for choice in choices\n        # 枝刈り: 選択が妥当かを判定\n        if is_valid?(state, choice)\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>次に、このフレームワークコードを用いて例題3を解きます。状態 <code>state</code> はノードの走査経路、選択肢 <code>choices</code> は現在のノードの左子ノードと右子ノード、結果 <code>res</code> は経路のリストです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"現在の状態が解かどうかを判定\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"解を記録\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"現在の状態で、この選択が有効かどうかを判定\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"状態を更新\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"状態を元に戻す\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"バックトラッキング：例題 3\"\"\"\n    # 解かどうかを確認\n    if is_solution(state):\n        # 解を記録\n        record_solution(state, res)\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り：選択が妥当かを確認する\n        if is_valid(state, choice):\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            # 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (TreeNode *choice : choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* 現在の状態が解かどうかを判定 */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (TreeNode choice : choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* 現在の状態が解かどうかを判定 */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* 解を記録 */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* 状態を元に戻す */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* バックトラッキング：例題 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 解かどうかを確認\n    if (IsSolution(state)) {\n        // 解を記録\n        RecordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    foreach (TreeNode choice in choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (IsValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            MakeChoice(state, choice);\n            // 次の選択へ進む\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* 現在の状態が解かどうかを判定 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* 解を記録 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* 状態を更新 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* 状態を元に戻す */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* バックトラッキング：例題 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // 解かどうかを確認\n    if isSolution(state) {\n        // 解を記録\n        recordSolution(state, res)\n    }\n    // すべての選択肢を走査\n    for _, choice := range *choices {\n        // 枝刈り：選択が妥当かを確認する\n        if isValid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            // 次の選択へ進む\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* 現在の状態が解かどうかを判定 */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* 解を記録 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* 状態を更新 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* 状態を元に戻す */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* バックトラッキング：例題 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // 解かどうかを確認\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り：選択が妥当かを確認する\n        if isValid(state: state, choice: choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state: &amp;state, choice: choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* 現在の状態が解かどうかを判定 */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 解を記録 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 状態を更新 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfunction backtrack(state, choices, res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* 現在の状態が解かどうかを判定 */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 解を記録 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 状態を更新 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // 解かどうかを確認\n  if (isSolution(state)) {\n    // 解を記録\n    recordSolution(state, res);\n  }\n  // すべての選択肢を走査\n  for (TreeNode? choice in choices) {\n    // 枝刈り：選択が妥当かを確認する\n    if (isValid(state, choice)) {\n      // 試行: 選択を行い、状態を更新\n      makeChoice(state, choice);\n      // 次の選択へ進む\n      backtrack(state, [choice!.left, choice.right], res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* 現在の状態が解かどうかを判定 */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* 解を記録 */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* 状態を更新 */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // 解かどうかを確認\n    if is_solution(state) {\n        // 解を記録\n        record_solution(state, res);\n    }\n    // すべての選択肢を走査\n    for &amp;choice in choices.iter() {\n        // 枝刈り：選択が妥当かを確認する\n        if is_valid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            make_choice(state, choice.unwrap().clone());\n            // 次の選択へ進む\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // 解かどうかを確認\n    if (isSolution()) {\n        // 解を記録\n        recordSolution();\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(choice);\n            // 次の選択へ進む\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* 現在の状態が解かどうかを判定 */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* 解を記録 */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* 状態を更新 */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* 状態を元に戻す */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* バックトラッキング：例題 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res)\n    }\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            // 次の選択へ進む\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### 現在の状態が解かどうかを判定 ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### 解を記録 ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### 現在の状態で、この選択が妥当かを判定 ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### 状態を更新 ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### 状態を復元 ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### バックトラッキング法：例題3 ###\ndef backtrack(state, choices, res)\n  # 解かどうかを確認\n  record_solution(state, res) if is_solution?(state)\n\n  # すべての選択肢を走査\n  for choice in choices\n    # 枝刈り：選択が妥当かを確認する\n    if is_valid?(state, choice)\n      # 試行: 選択を行い、状態を更新\n      make_choice(state, choice)\n      # 次の選択へ進む\n      backtrack(state, [choice.left, choice.right], res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>問題の条件より、値が \\(7\\) のノードを見つけた後も探索を続ける必要があります。そのため、解を記録した後の <code>return</code> 文は削除しなければなりません。次の図は、<code>return</code> 文を残す場合と削除する場合の探索過程を比較したものです。</p> <p></p> <p> 図 13-4   return を残す場合と削除する場合の探索過程の比較 </p> <p>前順走査にもとづく実装と比べると、バックトラッキングアルゴリズムのフレームワークにもとづく実装はやや冗長に見えますが、汎用性に優れています。実際、多くのバックトラッキング問題はこのフレームワークで解けます。具体的な問題に応じて <code>state</code> と <code>choices</code> を定義し、各メソッドを実装すれば十分です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   よく使われる用語","text":"<p>アルゴリズム問題をより明確に分析するために、バックトラッキングでよく使われる用語の意味を整理し、例題3に対応する例を次の表にまとめます。</p> <p> 表 13-1   よく使われるバックトラッキング用語 </p> 用語 定義 例題3 解（solution） 問題の特定の条件を満たす答えであり、1 つまたは複数存在し得る 根ノードからノード \\(7\\) までの、制約条件を満たすすべての経路 制約条件（constraint） 解の実現可能性を制限する条件であり、通常は枝刈りに用いられる 経路にノード \\(3\\) を含まないこと 状態（state） ある時点における問題の状況を表し、すでに行った選択を含む 現在までに訪問したノードの経路、すなわち <code>path</code> ノードリスト 試行（attempt） 利用可能な選択肢にもとづいて解空間を探索する過程であり、選択、状態更新、解判定を含む 左右の子ノードを再帰的に訪問し、ノードを <code>path</code> に追加し、値が \\(7\\) か判定する 戻る（backtracking） 制約条件を満たさない状態に出会ったとき、それまでの選択を取り消して前の状態へ戻ること 葉ノードを越えたとき、ノード訪問を終えたとき、値が \\(3\\) のノードに出会ったときに探索を終了し、関数から戻る 枝刈り（pruning） 問題の性質や制約条件にもとづき、無意味な探索経路を避ける方法であり、探索効率を高める 値が \\(3\\) のノードに出会ったら、それ以上探索しない <p>Tip</p> <p>問題、解、状態などの概念は汎用的であり、分割統治、バックトラッキング、動的計画法、貪欲法などのアルゴリズムにも共通して現れます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   利点と限界","text":"<p>バックトラッキングアルゴリズムの本質は深さ優先探索です。条件を満たす解を見つけるまで、あり得るすべての解を試します。この方法の利点は、考えられるすべての解を見つけられることであり、適切な枝刈りを行えば高い効率を発揮します。</p> <p>しかし、大規模または複雑な問題を扱う場合、バックトラッキングアルゴリズムの実行効率は受け入れがたいことがあります。</p> <ul> <li>時間：バックトラッキングアルゴリズムでは通常、状態空間のすべての可能性をたどる必要があり、時間計算量は指数時間や階乗時間に達することがあります。</li> <li>空間：再帰呼び出しの過程では現在の状態（たとえば経路や枝刈り用の補助変数など）を保持する必要があり、深さが大きいと空間使用量も大きくなります。</li> </ul> <p>それでもなお、バックトラッキングアルゴリズムは一部の探索問題や制約充足問題に対する最良の解法です。この種の問題では、どの選択が有効な解を生むかを事前に予測できないため、可能な選択肢をすべてたどる必要があります。このときの鍵は**いかに効率を最適化するか**であり、代表的な方法は 2 つあります。</p> <ul> <li>枝刈り：解が生じないことが確実な経路を探索しないことで、時間と空間を節約する。</li> <li>ヒューリスティック探索：探索中に何らかの戦略や推定値を導入し、有効な解を生みやすい経路を優先的に探索する。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   バックトラッキングの典型例題","text":"<p>バックトラッキングアルゴリズムは、多くの探索問題、制約充足問題、組合せ最適化問題の解決に利用できます。</p> <p>探索問題：この種の問題の目標は、特定の条件を満たす解を見つけることです。</p> <ul> <li>全順列問題：ある集合が与えられたとき、考えられるすべての順列を求める。</li> <li>部分和問題：ある集合と目標和が与えられたとき、和が目標値となるすべての部分集合を見つける。</li> <li>ハノイの塔問題：3 本の柱と大きさの異なる複数の円盤が与えられたとき、すべての円盤を 1 本の柱から別の柱へ移動する。ただし 1 回に 1 枚しか動かせず、大きい円盤を小さい円盤の上に置いてはならない。</li> </ul> <p>制約充足問題：この種の問題の目標は、すべての制約条件を満たす解を見つけることです。</p> <ul> <li>\\(n\\) クイーン問題：\\(n \\times n\\) の盤面に \\(n\\) 個のクイーンを配置し、互いに攻撃し合わないようにする。</li> <li>数独：\\(9 \\times 9\\) のグリッドに数字 \\(1\\) ~ \\(9\\) を入れ、各行・各列・各 \\(3 \\times 3\\) の小区画で数字が重複しないようにする。</li> <li>グラフ彩色問題：無向グラフが与えられたとき、隣接する頂点が同じ色にならないように、できるだけ少ない色で各頂点を彩色する。</li> </ul> <p>組合せ最適化問題：この種の問題の目標は、組合せ空間の中で条件を満たす最適解を見つけることです。</p> <ul> <li>0-1 ナップサック問題：複数の品物とナップサックが与えられ、各品物には価値と重さがある。ナップサック容量の範囲内で総価値が最大になるように品物を選ぶ。</li> <li>巡回セールスマン問題：グラフ内のある頂点から出発し、他のすべての頂点をちょうど 1 回ずつ訪れて出発点へ戻るときの最短経路を求める。</li> <li>最大クリーク問題：無向グラフが与えられたとき、任意の 2 頂点間に辺が存在する最大の完全部分グラフを見つける。</li> </ul> <p>多くの組合せ最適化問題では、バックトラッキングは最適な解法ではない点に注意してください。</p> <ul> <li>0-1 ナップサック問題は通常、より高い時間効率を得るために動的計画法で解く。</li> <li>巡回セールスマン問題は著名な NP-Hard 問題であり、よく用いられる解法には遺伝的アルゴリズムや蟻コロニー最適化などがある。</li> <li>最大クリーク問題はグラフ理論における古典的問題であり、貪欲法などのヒューリスティックで解ける。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   n クイーン問題","text":"<p>Question</p> <p>チェスのルールによれば、クイーンは同じ行、同じ列、または同じ斜線上にある駒を攻撃できます。\\(n\\) 個のクイーンと \\(n \\times n\\) サイズの盤面が与えられたとき、すべてのクイーンが互いに攻撃し合わない配置を求めます。</p> <p>下図に示すように、\\(n = 4\\) のとき、2 つの解を見つけることができます。バックトラッキングの観点から見ると、\\(n \\times n\\) サイズの盤面には合計 \\(n^2\\) 個のマスがあり、これがすべての選択肢 <code>choices</code> を与えます。クイーンを 1 つずつ配置していく過程で、盤面の状態は絶えず変化し、その各時点の盤面が状態 <code>state</code> です。</p> <p></p> <p> 図 13-15   4 クイーン問題の解 </p> <p>下図は本問題の 3 つの制約条件を示しています。複数のクイーンは同じ行、同じ列、同じ対角線上に置けません。なお、対角線には主対角線 <code>\\</code> と副対角線 <code>/</code> の 2 種類があります。</p> <p></p> <p> 図 13-16   n クイーン問題の制約条件 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   行ごとの配置戦略","text":"<p>クイーンの数と盤面の行数はいずれも \\(n\\) なので、次の推論を容易に得られます：盤面の各行にはクイーンを 1 つだけ配置できます。</p> <p>つまり、行ごとの配置戦略を採用できます：最初の行から始めて、各行に 1 つのクイーンを配置し、最後の行まで進みます。</p> <p>下図は 4 クイーン問題における行ごとの配置過程を示しています。図の大きさの都合上、下図では 1 行目における検索分岐の 1 つだけを展開し、列制約と対角線制約を満たさない案はすべて枝刈りしています。</p> <p></p> <p> 図 13-17   行ごとの配置戦略 </p> <p>本質的には、行ごとの配置戦略は枝刈りとして機能します。これにより、同じ行に複数のクイーンが現れるすべての探索分岐を回避できます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   列と対角線の枝刈り","text":"<p>列制約を満たすために、長さ \\(n\\) のブール配列 <code>cols</code> を用いて、各列にクイーンがあるかどうかを記録できます。配置を決めるたびに、<code>cols</code> を使って既存のクイーンがある列を枝刈りし、バックトラッキングの中で <code>cols</code> の状態を動的に更新します。</p> <p>Tip</p> <p>注意として、行列の原点は左上にあり、行インデックスは上から下へ、列インデックスは左から右へ増加します。</p> <p>では、対角線制約はどのように扱えばよいのでしょうか。盤面上のあるマスの行列インデックスを \\((row, col)\\) とし、行列内のある主対角線を選ぶと、その対角線上のすべてのマスで行インデックスから列インデックスを引いた値が等しいことが分かります。つまり、主対角線上のすべてのマスでは \\(row - col\\) が一定値になります。</p> <p>つまり、2 つのマスが \\(row_1 - col_1 = row_2 - col_2\\) を満たすなら、それらは必ず同じ主対角線上にあります。この性質を利用して、下図の配列 <code>diags1</code> により、各主対角線にクイーンがあるかどうかを記録できます。</p> <p>同様に、副対角線上のすべてのマスでは \\(row + col\\) が一定値です。副対角線制約も配列 <code>diags2</code> を使って処理できます。</p> <p></p> <p> 図 13-18   列制約と対角線制約の処理 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   コード実装","text":"<p>注意として、\\(n\\) 次正方行列では \\(row - col\\) の範囲は \\([-n + 1, n - 1]\\) 、\\(row + col\\) の範囲は \\([0, 2n - 2]\\) です。したがって、主対角線と副対角線の本数はいずれも \\(2n - 1\\) であり、配列 <code>diags1</code> と <code>diags2</code> の長さもともに \\(2n - 1\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"バックトラッキング：N クイーン\"\"\"\n    # すべての行への配置が完了したら、解を記録する\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # すべての列を走査\n    for col in range(n):\n        # このマスに対応する主対角線と副対角線を計算\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"N クイーンを解く\"\"\"\n    # n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # 列にクイーンがあるか記録\n    diags1 = [False] * (2 * n - 1)  # 主対角線にクイーンがあるかを記録\n    diags2 = [False] * (2 * n - 1)  # 副対角線にクイーンがあるかを記録\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // 列にクイーンがあるか記録\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // 主対角線にクイーンがあるかを記録\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // 副対角線にクイーンがあるかを記録\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // 列にクイーンがあるか記録\n    boolean[] diags1 = new boolean[2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    boolean[] diags2 = new boolean[2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* バックトラッキング：N クイーン */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // 列にクイーンがあるか記録\n    bool[] diags1 = new bool[2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    bool[] diags2 = new bool[2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* バックトラッキング：N クイーン */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // すべての列を走査\n    for col := 0; col &lt; n; col++ {\n        // このマスに対応する主対角線と副対角線を計算\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // 試行：そのマスにクイーンを置く\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // 次の行に配置する\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // 戻す：そのマスを空きマスに戻す\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunc nQueens(n int) [][][]string {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // 列にクイーンがあるか記録\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* バックトラッキング：N クイーン */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        res.append(state)\n        return\n    }\n    // すべての列を走査\n    for col in 0 ..&lt; n {\n        // このマスに対応する主対角線と副対角線を計算\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // 次の行に配置する\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // 列にクイーンがあるか記録\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // 主対角線にクイーンがあるかを記録\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // 副対角線にクイーンがあるかを記録\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* バックトラッキング：N クイーン */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // すべての列を走査\n    for (let col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunction nQueens(n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 列にクイーンがあるか記録\n    const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録\n    const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* バックトラッキング：N クイーン */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // すべての行への配置が完了したら、解を記録する\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // すべての列を走査\n    for (let col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunction nQueens(n: number): string[][][] {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 列にクイーンがあるか記録\n    const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録\n    const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // すべての行への配置が完了したら、解を記録する\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // すべての列を走査\n  for (int col = 0; col &lt; n; col++) {\n    // このマスに対応する主対角線と副対角線を計算\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // 試行：そのマスにクイーンを置く\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // 次の行に配置する\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // 戻す：そのマスを空きマスに戻す\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // 列にクイーンがあるか記録\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // 主対角線にクイーンがあるかを記録\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // 副対角線にクイーンがあるかを記録\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* バックトラッキング：N クイーン */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // すべての列を走査\n    for col in 0..n {\n        // このマスに対応する主対角線と副対角線を計算\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* N クイーンを解く */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // 列にクイーンがあるか記録\n    let mut diags1 = vec![false; 2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    let mut diags2 = vec![false; 2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // 列にクイーンがあるか記録\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // 主対角線にクイーンがあるかを記録\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // 副対角線にクイーンがあるかを記録\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* バックトラッキング：N クイーン */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // すべての列を走査\n    for (col in 0..&lt;n) {\n        // このマスに対応する主対角線と副対角線を計算\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* N クイーンを解く */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // 列にクイーンがあるか記録\n    val diags1 = BooleanArray(2 * n - 1) // 主対角線にクイーンがあるかを記録\n    val diags2 = BooleanArray(2 * n - 1) // 副対角線にクイーンがあるかを記録\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### バックトラッキング法：Nクイーン ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # すべての行への配置が完了したら、解を記録する\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # すべての列を走査\n  for col in 0...n\n    # このマスに対応する主対角線と副対角線を計算\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # 試行：そのマスにクイーンを置く\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # 次の行に配置する\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # 戻す：そのマスを空きマスに戻す\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Nクイーンを解く ###\ndef n_queens(n)\n  # n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # 列にクイーンがあるか記録\n  diags1 = Array.new(2 * n - 1, false) # 主対角線にクイーンがあるかを記録\n  diags2 = Array.new(2 * n - 1, false) # 副対角線にクイーンがあるかを記録\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>行ごとに \\(n\\) 回配置し、列制約を考慮すると、1 行目から最終行までの選択肢はそれぞれ \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 個となるため、時間計算量は \\(O(n!)\\) です。解を記録する際には、行列 <code>state</code> をコピーして <code>res</code> に追加する必要があり、このコピー操作には \\(O(n^2)\\) 時間を要します。したがって、全体の時間計算量は \\(O(n! \\cdot n^2)\\) です。実際には、対角線制約による枝刈りも探索空間を大きく縮小できるため、探索効率はしばしば上記の時間計算量より良くなります。</p> <p>配列 <code>state</code> は \\(O(n^2)\\) の空間を使用し、配列 <code>cols</code>、<code>diags1</code>、<code>diags2</code> はいずれも \\(O(n)\\) の空間を使用します。最大再帰深さは \\(n\\) で、スタックフレーム空間として \\(O(n)\\) を使用します。したがって、空間計算量は \\(O(n^2)\\) です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   全順列問題","text":"<p>全順列問題はバックトラッキングアルゴリズムの典型的な応用例です。これは、ある集合（配列や文字列など）が与えられたとき、その要素のあり得るすべての順列を求める問題です。</p> <p>下表に、入力配列とそれに対応するすべての順列から成る例をいくつか示します。</p> <p> 表 13-2   全順列の例 </p> 入力配列 すべての順列 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   等しい要素がない場合","text":"<p>Question</p> <p>重複要素を含まない整数配列を入力として受け取り、あり得るすべての順列を返します。</p> <p>バックトラッキングアルゴリズムの観点から見ると、順列生成の過程は一連の選択の結果として捉えられます。入力配列が \\([1, 2, 3]\\) だとすると、最初に \\(1\\) を選び、次に \\(3\\) を選び、最後に \\(2\\) を選べば、順列 \\([1, 3, 2]\\) が得られます。戻る操作は 1 つの選択を取り消し、その後で別の選択を試し続けることを表します。</p> <p>バックトラッキングコードの観点では、候補集合 <code>choices</code> は入力配列中のすべての要素であり、状態 <code>state</code> は現時点までに選ばれた要素です。各要素は 1 回しか選べないことに注意してください。したがって <code>state</code> 内の要素はすべて一意でなければなりません。</p> <p>下図のように、探索過程は再帰木として展開できます。木の各ノードは現在の状態 <code>state</code> を表します。根ノードから始めて 3 ラウンドの選択を経て葉ノードに到達し、各葉ノードが 1 つの順列に対応します。</p> <p></p> <p> 図 13-5   全順列の再帰木 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   重複選択の枝刈り","text":"<p>各要素が 1 回しか選ばれないようにするため、ブール配列 <code>selected</code> の導入を考えます。ここで <code>selected[i]</code> は <code>choices[i]</code> がすでに選ばれているかどうかを表し、これに基づいて次の枝刈りを行います。</p> <ul> <li>選択 <code>choice[i]</code> を行った後、<code>selected[i]</code> を \\(\\text{True}\\) に設定し、その要素が選択済みであることを表します。</li> <li>選択肢リスト <code>choices</code> を走査するとき、すでに選ばれたノードはすべてスキップします。これが枝刈りです。</li> </ul> <p>下図のように、1 回目に 1、2 回目に 3、3 回目に 2 を選ぶとします。このとき 2 回目では要素 1 の分岐を、3 回目では要素 1 と要素 3 の分岐を刈り取る必要があります。</p> <p></p> <p> 図 13-6   全順列の枝刈り例 </p> <p>上図から、この枝刈りにより探索空間の大きさは \\(O(n^n)\\) から \\(O(n!)\\) へ削減されることがわかります。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   コード実装","text":"<p>以上を整理できれば、フレームワークコードの「穴埋め」を行えます。全体のコードを短くするため、フレームワークコード中の各関数を個別には実装せず、これらを <code>backtrack()</code> 関数内に展開します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"バックトラッキング：順列 I\"\"\"\n    # 状態の長さが要素数に等しければ、解を記録\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    for i, choice in enumerate(choices):\n        # 枝刈り：要素の重複選択を許可しない\n        if not selected[i]:\n            # 試行: 選択を行い、状態を更新\n            selected[i] = True\n            state.append(choice)\n            # 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全順列 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push_back(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全順列 I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.add(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全順列 I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* バックトラッキング：順列 I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.Add(choice);\n            // 次の選択へ進む\n            Backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全順列 I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* バックトラッキング：順列 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // すべての選択肢を走査\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 枝刈り：要素の重複選択を許可しない\n        if !(*selected)[i] {\n            // 試行: 選択を行い、状態を更新\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 次の選択へ進む\n            backtrackI(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全順列 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* バックトラッキング：順列 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    for (i, choice) in choices.enumerated() {\n        // 枝刈り：要素の重複選択を許可しない\n        if !selected[i] {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true\n            state.append(choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全順列 I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* バックトラッキング：順列 I */\nfunction backtrack(state, choices, selected, res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* バックトラッキング：順列 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 状態の長さが要素数に等しければ、解を記録\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 枝刈り：要素の重複選択を許可しない\n    if (!selected[i]) {\n      // 試行: 選択を行い、状態を更新\n      selected[i] = true;\n      state.add(choice);\n      // 次の選択へ進む\n      backtrack(state, choices, selected, res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全順列 I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* バックトラッキング：順列 I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if !selected[i] {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state.clone(), choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全順列 I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // 状態（部分集合）\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 次の選択へ進む\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全順列 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* バックトラッキング：順列 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true\n            state.add(choice)\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全順列 I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### バックトラッキング法：全順列 I ###\ndef backtrack(state, choices, selected, res)\n  # 状態の長さが要素数に等しければ、解を記録\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  choices.each_with_index do |choice, i|\n    # 枝刈り：要素の重複選択を許可しない\n    unless selected[i]\n      # 試行: 選択を行い、状態を更新\n      selected[i] = true\n      state &lt;&lt; choice\n      # 次の選択へ進む\n      backtrack(state, choices, selected, res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全順列 I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   等しい要素を考慮する場合","text":"<p>Question</p> <p>整数配列を入力として受け取り、配列には重複要素が含まれる場合があります。重複しない順列をすべて返します。</p> <p>入力配列が \\([1, 1, 2]\\) だと仮定します。2 つの重複する要素 \\(1\\) を区別しやすくするため、2 つ目の \\(1\\) を \\(\\hat{1}\\) と記します。</p> <p>下図のように、上述の方法で生成される順列の半分は重複しています。</p> <p></p> <p> 図 13-7   重複した順列 </p> <p>では、重複した順列をどのように取り除けばよいのでしょうか。最も直接的なのは、ハッシュ集合を用いて順列結果をそのまま重複排除する方法です。しかしこのやり方は十分に洗練されていません。なぜなら、重複順列を生成する探索分岐はそもそも不要であり、事前に見つけて枝刈りすべきだからです。そうすることで、アルゴリズム効率をさらに高められます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   等しい要素の枝刈り","text":"<p>下図を見ると、1 回目のラウンドでは \\(1\\) を選ぶことと \\(\\hat{1}\\) を選ぶことは等価であり、これら 2 つの選択の下で生成される順列はすべて重複します。したがって \\(\\hat{1}\\) を枝刈りすべきです。</p> <p>同様に、1 回目で \\(2\\) を選んだ後では、2 回目のラウンドにおける \\(1\\) と \\(\\hat{1}\\) も重複分岐を生むため、2 回目の \\(\\hat{1}\\) も枝刈りすべきです。</p> <p>本質的には、各ラウンドの選択において、等しい複数の要素が 1 回しか選ばれないようにすることが目標です。</p> <p></p> <p> 図 13-8   重複順列の枝刈り </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   コード実装","text":"<p>前問のコードを土台として、各ラウンドの選択でハッシュ集合 <code>duplicated</code> を 1 つ用意し、そのラウンドですでに試した要素を記録して、重複要素を枝刈りすることを考えます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"バックトラッキング：順列 II\"\"\"\n    # 状態の長さが要素数に等しければ、解を記録\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if not selected[i] and choice not in duplicated:\n            # 試行: 選択を行い、状態を更新\n            duplicated.add(choice)  # 選択済みの要素値を記録\n            selected[i] = True\n            state.append(choice)\n            # 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全順列 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.emplace(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push_back(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全順列 II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.add(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全順列 II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* バックトラッキング：順列 II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.Add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.Add(choice);\n            // 次の選択へ進む\n            Backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全順列 II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* バックトラッキング：順列 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // すべての選択肢を走査\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // 試す: 選択を行って状態を更新\n            // 選択済みの要素値を記録\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 次の選択へ進む\n            backtrackII(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全順列 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* バックトラッキング：順列 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if !selected[i], !duplicated.contains(choice) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.insert(choice) // 選択済みの要素値を記録\n            selected[i] = true\n            state.append(choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全順列 II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* バックトラッキング：順列 II */\nfunction backtrack(state, choices, selected, res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* バックトラッキング：順列 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 状態の長さが要素数に等しければ、解を記録\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // 試行: 選択を行い、状態を更新\n      duplicated.add(choice); // 選択済みの要素値を記録\n      selected[i] = true;\n      state.add(choice);\n      // 次の選択へ進む\n      backtrack(state, choices, selected, res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全順列 II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* バックトラッキング：順列 II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // すべての選択肢を走査\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.insert(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state.clone(), choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全順列 II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての選択肢を走査\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // 試行: 選択を行い、状態を更新\n            duplicated[choice] = true; // 選択済みの要素値を記録\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 次の選択へ進む\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全順列 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* バックトラッキング：順列 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice) // 選択済みの要素値を記録\n            selected[i] = true\n            state.add(choice)\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全順列 II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### バックトラッキング法：全順列 II ###\ndef backtrack(state, choices, selected, res)\n  # 状態の長さが要素数に等しければ、解を記録\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # 試行: 選択を行い、状態を更新\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # 次の選択へ進む\n      backtrack(state, choices, selected, res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全順列 II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>要素どうしがすべて互いに異なると仮定すると、\\(n\\) 個の要素には全部で \\(n!\\)  通りの順列（階乗）があります。結果を記録する際には、長さ \\(n\\) のリストをコピーする必要があり、これに \\(O(n)\\) 時間を要します。したがって時間計算量は \\(O(n!n)\\) です。</p> <p>再帰の最大深さは \\(n\\) であり、\\(O(n)\\) のスタックフレーム空間を使います。<code>selected</code> は \\(O(n)\\) 空間を使用します。同時刻に存在する <code>duplicated</code> は最大で \\(n\\) 個であり、\\(O(n^2)\\) 空間を要します。したがって空間計算量は \\(O(n^2)\\) です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3-2","level":3,"title":"3.   2 種類の枝刈りの比較","text":"<p><code>selected</code> と <code>duplicated</code> はどちらも枝刈りに用いられますが、目的は異なる点に注意してください。</p> <ul> <li>重複選択の枝刈り：探索全体を通して <code>selected</code> は 1 つだけです。これは現在の状態にどの要素が含まれているかを記録し、ある要素が <code>state</code> に重複して現れるのを防ぎます。</li> <li>等しい要素の枝刈り：各ラウンドの選択、すなわち各回の <code>backtrack</code> 呼び出しには <code>duplicated</code> が含まれます。これはそのラウンドの走査（<code>for</code> ループ）でどの要素がすでに選ばれたかを記録し、等しい要素が 1 回しか選ばれないことを保証します。</li> </ul> <p>下図は、2 つの枝刈り条件が有効になる範囲を示しています。木の各ノードは 1 つの選択を表し、根ノードから葉ノードまでの経路上の各ノードが 1 つの順列を構成することに注意してください。</p> <p></p> <p> 図 13-9   2 種類の枝刈り条件の作用範囲 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   部分和問題","text":"","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   重複しない要素の場合","text":"<p>Question</p> <p>正整数配列 <code>nums</code> と目標の正整数 <code>target</code> が与えられたとき、要素の和が <code>target</code> に等しくなるすべての組合せを見つけてください。配列に重複要素はなく、各要素は複数回選択できます。これらの組合せをリスト形式で返してください。リストに重複する組合せを含めてはなりません。</p> <p>例えば、入力集合 \\(\\{3, 4, 5\\}\\) と目標整数 \\(9\\) に対する解は \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) です。次の 2 点に注意してください。</p> <ul> <li>入力集合内の要素は何度でも繰り返し選択できます。</li> <li>部分集合では要素の順序を区別しません。例えば \\(\\{4, 5\\}\\) と \\(\\{5, 4\\}\\) は同じ部分集合です。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   全順列の解法を参考にする","text":"<p>全順列問題と同様に、部分集合の生成過程を一連の選択結果として捉え、選択の過程で「要素の和」を逐次更新できます。そして要素の和が <code>target</code> に等しくなった時点で、その部分集合を結果リストに記録します。</p> <p>ただし全順列問題と異なるのは、**この問題では集合内の要素を無制限に選択できる**点です。そのため、要素がすでに選択されたかどうかを記録する <code>selected</code> ブール配列は不要です。全順列のコードに少し修正を加えると、まず次の解法コードが得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"バックトラッキング：部分和 I\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if total == target:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    for i in range(len(choices)):\n        # 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target:\n            continue\n        # 試行：選択を行い、要素と total を更新する\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 I を解く（重複部分集合を含む）\"\"\"\n    state = []  # 状態（部分集合）\n    total = 0  # 部分和\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // 状態（部分集合）\n    int total = 0;           // 部分和\n    vector&lt;vector&lt;int&gt;&gt; res; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    int total = 0; // 部分和\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* バックトラッキング：部分和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    int total = 0; // 部分和\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    for i := 0; i &lt; len(*choices); i++ {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    total := 0              // 部分和\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if total == target {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    for i in choices.indices {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let total = 0 // 部分和\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(state, target, total, choices, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // 状態（部分集合）\n    const total = 0; // 部分和\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    const total = 0; // 部分和\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  for (int i = 0; i &lt; choices.length; i++) {\n    // 枝刈り：部分和が target を超える場合はその選択をスキップする\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // 試行：選択を行い、要素と total を更新する\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  int total = 0; // 要素の合計\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* バックトラッキング：部分和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    for i in 0..choices.len() {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    let total = 0; // 部分和\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state[stateSize++] = choices[i];\n        // 次の選択へ進む\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // 解の個数を 0 に初期化する\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* バックトラッキング：部分和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    for (i in choices.indices) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    val total = 0 // 部分和\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  for i in 0...choices.length\n    # 枝刈り：部分和が target を超える場合はその選択をスキップする\n    next if total + choices[i] &gt; target\n    # 試行：選択を行い、要素と total を更新する\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  for i in 0...choices.length\n    # 枝刈り：部分和が target を超える場合はその選択をスキップする\n    next if total + choices[i] &gt; target\n    # 試行：選択を行い、要素と total を更新する\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n# ## 部分和 I を解く（重複する部分集合を含む）###\ndef subset_sum_i_naive(nums, target)\n  state = [] # 状態（部分集合）\n  total = 0 # 部分和\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードに配列 \\([3, 4, 5]\\) と目標値 \\(9\\) を入力すると、出力は \\([3, 3, 3], [4, 5], [5, 4]\\) となります。和が \\(9\\) となる部分集合はすべて見つかっていますが、重複する部分集合 \\([4, 5]\\) と \\([5, 4]\\) が含まれています。</p> <p>これは、探索過程では選択順を区別する一方で、部分集合では選択順を区別しないためです。次の図のように、先に \\(4\\) を選んでから \\(5\\) を選ぶ場合と、先に \\(5\\) を選んでから \\(4\\) を選ぶ場合は別の分岐ですが、対応する部分集合は同じです。</p> <p></p> <p> 図 13-10   部分集合探索と境界超過の枝刈り </p> <p>重複する部分集合を取り除くために、**直接的な方法として結果リストの重複を除去する**ことが考えられます。しかし、この方法は効率が低く、その理由は次の 2 点です。</p> <ul> <li>配列要素が多い場合、特に <code>target</code> が大きい場合には、探索過程で大量の重複部分集合が生成されます。</li> <li>部分集合（配列）同士の違いを比較するのは非常に時間がかかり、まず配列をソートし、その後に各要素を比較する必要があります。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   重複部分集合の枝刈り","text":"<p>**探索過程で枝刈りを行って重複を除去する**ことを考えます。次の図を観察すると、重複部分集合は配列要素を異なる順序で選択したときに生じます。例えば次のような状況です。</p> <ol> <li>1 回目と 2 回目でそれぞれ \\(3\\) と \\(4\\) を選ぶと、これら 2 要素を含むすべての部分集合、すなわち \\([3, 4, \\dots]\\) が生成されます。</li> <li>その後、1 回目で \\(4\\) を選んだ場合、**2 回目では \\(3\\) をスキップすべき**です。というのも、この選択で生成される部分集合 \\([4, 3, \\dots]\\) は、手順 <code>1.</code> で生成された部分集合と完全に重複するからです。</li> </ol> <p>探索過程では、各階層の選択は左から右へ順に試されるため、右側にある分岐ほど多く枝刈りされます。</p> <ol> <li>最初の 2 回で \\(3\\) と \\(5\\) を選ぶと、部分集合 \\([3, 5, \\dots]\\) が生成されます。</li> <li>最初の 2 回で \\(4\\) と \\(5\\) を選ぶと、部分集合 \\([4, 5, \\dots]\\) が生成されます。</li> <li>もし 1 回目で \\(5\\) を選ぶなら、**2 回目では \\(3\\) と \\(4\\) をスキップすべき**です。なぜなら、部分集合 \\([5, 3, \\dots]\\) と \\([5, 4, \\dots]\\) は、手順 <code>1.</code> と手順 <code>2.</code> で述べた部分集合と完全に重複するからです。</li> </ol> <p></p> <p> 図 13-11   異なる選択順によって生じる重複部分集合 </p> <p>まとめると、入力配列 \\([x_1, x_2, \\dots, x_n]\\) が与えられ、探索過程における選択列を \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) とすると、この選択列は \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) を満たす必要があります。この条件を満たさない選択列は重複を生むため、枝刈りすべきです。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   コード実装","text":"<p>この枝刈りを実現するために、走査の開始位置を示す変数 <code>start</code> を初期化します。**選択 \\(x_{i}\\) を行った後、次のラウンドはインデックス \\(i\\) から走査を開始する**ように設定します。これにより、選択列が \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) を満たし、部分集合の一意性が保証されます。</p> <p>これに加えて、コードには次の 2 つの最適化も施しています。</p> <ul> <li>探索を始める前に、まず配列 <code>nums</code> をソートします。すべての選択肢を走査するとき、**部分集合の和が <code>target</code> を超えたら直ちにループを終了**します。後続の要素はさらに大きいため、その和も必ず <code>target</code> を超えるからです。</li> <li>要素和を保持する変数 <code>total</code> は省略し、**<code>target</code> から減算することで要素和を管理**します。<code>target</code> が \\(0\\) になったときに解を記録します。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"バックトラッキング：部分和 I\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if target == 0:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in range(start, len(choices)):\n        # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0:\n            break\n        # 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 I を解く\"\"\"\n    state = []  # 状態（部分集合）\n    nums.sort()  # nums をソート\n    start = 0  # 開始点を走査\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 I を解く */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 状態（部分集合）\n    sort(nums.begin(), nums.end()); // nums をソート\n    int start = 0;                  // 開始点を走査\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    Arrays.sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* バックトラッキング：部分和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    Array.Sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i := start; i &lt; len(*choices); i++ {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 I を解く */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    sort.Ints(nums)         // nums をソート\n    start := 0              // 開始点を走査\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in choices.indices.dropFirst(start) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 I を解く */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let nums = nums.sorted() // nums をソート\n    let start = 0 // 開始点を走査\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(state, target, choices, start, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfunction subsetSumI(nums, target) {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  for (int i = start; i &lt; choices.length; i++) {\n    // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 試す：選択を行い、target と start を更新\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  nums.sort(); // nums をソート\n  int start = 0; // 開始点を走査\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* バックトラッキング：部分和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in start..choices.len() {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    nums.sort(); // nums をソート\n    let start = 0; // 開始点を走査\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 次の選択へ進む\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 I を解く */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // nums をソート\n    int start = 0;                           // 開始点を走査\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* バックトラッキング：部分和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (i in start..&lt;choices.size) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 I を解く */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    nums.sort() // nums をソート\n    val start = 0 // 開始点を走査\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, choices, start, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # すべての選択肢を走査\n  # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  for i in start...choices.length\n    # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    break if target - choices[i] &lt; 0\n    # 試す：選択を行い、target と start を更新\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### 部分和 I を解く ###\ndef subset_sum_i(nums, target)\n  state = [] # 状態（部分集合）\n  nums.sort! # nums をソート\n  start = 0 # 開始点を走査\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、配列 \\([3, 4, 5]\\) と目標値 \\(9\\) を上のコードに入力したときの、全体のバックトラッキング過程を示しています。</p> <p></p> <p> 図 13-12   部分和 I のバックトラッキング過程 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   重複要素を考慮する場合","text":"<p>Question</p> <p>正整数配列 <code>nums</code> と目標の正整数 <code>target</code> が与えられたとき、要素の和が <code>target</code> に等しくなるすべての組合せを見つけてください。与えられた配列には重複要素が含まれる可能性があり、各要素は 1 回しか選択できません。これらの組合せをリスト形式で返してください。リストに重複する組合せを含めてはなりません。</p> <p>前問と比べると、この問題の入力配列には重複要素が含まれる可能性があります。そのため、新たな問題が生じます。例えば、配列 \\([4, \\hat{4}, 5]\\) と目標値 \\(9\\) が与えられると、既存コードの出力は \\([4, 5], [\\hat{4}, 5]\\) となり、重複部分集合が現れます。</p> <p>この重複が生じる原因は、同じ値の要素があるラウンドで複数回選ばれてしまうことにあります。次の図では、1 回目には 3 つの選択肢があり、そのうち 2 つはどちらも \\(4\\) です。これにより 2 本の重複した探索分岐が生じ、重複部分集合が出力されます。同様に、2 回目の 2 つの \\(4\\) も重複部分集合を生みます。</p> <p></p> <p> 図 13-13   等しい要素によって生じる重複部分集合 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   等しい要素の枝刈り","text":"<p>この問題を解決するには、各ラウンドで等しい要素が 1 回しか選ばれないように制限する必要があります。実装方法は巧妙です。配列はすでにソートされているため、等しい要素は必ず隣り合っています。したがって、あるラウンドの選択で現在の要素が左隣の要素と等しいなら、それはすでに選ばれたことを意味するので、その要素を直接スキップします。</p> <p>同時に、**この問題では各配列要素を 1 回しか選択できない**という制約もあります。幸い、この制約も変数 <code>start</code> を使って満たせます。すなわち、選択 \\(x_{i}\\) を行った後、次のラウンドはインデックス \\(i + 1\\) から後ろへ走査するよう設定します。これにより、重複部分集合を除去できるだけでなく、同じ要素を繰り返し選ぶことも防げます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   コード実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"バックトラッキング：部分和 II\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if target == 0:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    # 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in range(start, len(choices)):\n        # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0:\n            break\n        # 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 II を解く\"\"\"\n    state = []  # 状態（部分集合）\n    nums.sort()  # nums をソート\n    start = 0  # 開始点を走査\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 II を解く */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 状態（部分集合）\n    sort(nums.begin(), nums.end()); // nums をソート\n    int start = 0;                  // 開始点を走査\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    Arrays.sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* バックトラッキング：部分和 II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    Array.Sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* バックトラッキング：部分和 II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i := start; i &lt; len(*choices); i++ {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 II を解く */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    sort.Ints(nums)         // nums をソート\n    start := 0              // 開始点を走査\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* バックトラッキング：部分和 II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in choices.indices.dropFirst(start) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 II を解く */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let nums = nums.sorted() // nums をソート\n    let start = 0 // 開始点を走査\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* バックトラッキング：部分和 II */\nfunction backtrack(state, target, choices, start, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfunction subsetSumII(nums, target) {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* バックトラッキング：部分和 II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n  for (int i = start; i &lt; choices.length; i++) {\n    // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // 試す：選択を行い、target と start を更新\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  nums.sort(); // nums をソート\n  int start = 0; // 開始点を走査\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* バックトラッキング：部分和 II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in start..choices.len() {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    nums.sort(); // nums をソート\n    let start = 0; // 開始点を走査\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 枝刈り 1: 部分集合の和が target を超えたら、そのままスキップする\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 次の選択へ進む\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 II を解く */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // nums をソート\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // バックトラッキングを開始\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* バックトラッキング：部分和 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (i in start..&lt;choices.size) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 II を解く */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    nums.sort() // nums をソート\n    val start = 0 // 開始点を走査\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### バックトラッキング法：部分和 II ###\ndef backtrack(state, target, choices, start, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  # 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n  for i in start...choices.length\n    # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    break if target - choices[i] &lt; 0\n    # 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # 試す：選択を行い、target と start を更新\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### 部分和 II を解く ###\ndef subset_sum_ii(nums, target)\n  state = [] # 状態（部分集合）\n  nums.sort! # nums をソート\n  start = 0 # 開始点を走査\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、配列 \\([4, 4, 5]\\) と目標値 \\(9\\) に対するバックトラッキング過程を示しており、全部で 4 種類の枝刈り操作が含まれています。図とコードコメントを対応させながら、探索全体の流れと、各枝刈り操作がどのように機能するかを理解してください。</p> <p></p> <p> 図 13-14   部分和 II のバックトラッキング過程 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   まとめ","text":"","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>バックトラッキングアルゴリズムの本質は全探索法であり、解空間を深さ優先で走査することで条件を満たす解を探索します。探索の過程で条件を満たす解に出会ったら記録し、すべての解を見つけるか探索が完了するまで続けます。</li> <li>バックトラッキングアルゴリズムの探索過程は、試行と戻るという 2 つの部分から成ります。深さ優先探索によってさまざまな選択を試し、制約条件を満たさない状況に遭遇した場合は直前の選択を取り消して前の状態に戻り、ほかの選択を引き続き試します。試行と戻るは互いに逆方向の操作です。</li> <li>バックトラッキング問題には通常複数の制約条件が含まれており、それらを枝刈りに利用できます。枝刈りによって不要な探索分岐を早期に打ち切り、探索効率を大幅に高められます。</li> <li>バックトラッキングアルゴリズムは主に探索問題と制約充足問題の解決に用いられます。組合せ最適化問題もバックトラッキングで解けますが、より高効率またはより適した解法が存在することが少なくありません。</li> <li>全順列問題の目的は、与えられた集合要素のすべての可能な並べ方を探索することです。各要素が選択済みかどうかを配列で記録し、同じ要素を重複して選ぶ探索分岐を刈り取ることで、各要素が 1 度だけ選ばれるようにします。</li> <li>全順列問題では、集合内に重複要素があると最終結果にも重複した順列が現れます。各ラウンドで等しい要素は 1 回しか選べないように制約する必要があり、通常はハッシュ集合を用いて実現します。</li> <li>部分和問題の目標は、与えられた集合の中から和が目標値となるすべての部分集合を見つけることです。集合では要素順序を区別しませんが、探索過程では順序違いの結果も出力されるため、重複部分集合が生じます。そこで、バックトラッキング前にデータをソートし、各ラウンドの走査開始位置を示す変数を設定することで、重複部分集合を生成する探索分岐を枝刈りします。</li> <li>部分和問題では、配列中の等しい要素が重複集合を生みます。配列がソート済みであるという前提を利用し、隣接要素が等しいかどうかを判定して枝刈りすることで、等しい要素が各ラウンドで 1 回しか選ばれないようにします。</li> <li>\\(n\\) クイーン問題の目的は、\\(n \\times n\\) の盤面に \\(n\\) 個のクイーンを配置する方法を見つけることであり、どの 2 つのクイーンも互いに攻撃できないことが条件です。この問題の制約には行制約、列制約、主対角線制約、副対角線制約があります。行制約を満たすため、行ごとに配置する戦略を採用し、各行に 1 個のクイーンを置くことを保証します。</li> <li>列制約と対角線制約の扱い方は似ています。列制約については、各列にクイーンが存在するかどうかを配列で記録し、選択したマスが有効かどうかを判定します。対角線制約については、主対角線と副対角線それぞれにクイーンが存在するかを 2 つの配列で記録します。難点は、同じ主対角線または副対角線上にあるマスが満たす行列インデックスの規則を見つけることにあります。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：バックトラッキングと再帰の関係はどのように理解すればよいですか？</p> <p>全体として見ると、バックトラッキングは「アルゴリズム戦略」の一種であり、再帰はむしろ「道具」に近いものです。</p> <ul> <li>バックトラッキングアルゴリズムは通常、再帰に基づいて実装されます。ただし、バックトラッキングは再帰の応用場面の 1 つであり、探索問題における再帰の応用です。</li> <li>再帰の構造は「部分問題への分解」という問題解決パラダイムを表しており、分割統治、バックトラッキング、動的計画法（メモ化再帰）などの問題によく用いられます。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"第 2 章   計算量解析","text":"<p>Abstract</p> <p>計算量解析は、広大なアルゴリズム宇宙における時空の案内人のようなものです。</p> <p>それは、時間と空間という二つの次元で私たちをより深く探求へ導き、より洗練された解決策を見つけ出します。</p>","path":["第 2 章 &nbsp; 計算量解析"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"章の内容","text":"<ul> <li>2.1   アルゴリズム効率の評価</li> <li>2.2   反復と再帰</li> <li>2.3   時間計算量</li> <li>2.4   空間計算量</li> <li>2.5   まとめ</li> </ul>","path":["第 2 章 &nbsp; 計算量解析"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   反復と再帰","text":"<p>アルゴリズムでは、ある処理を繰り返し実行することがよくあり、これは複雑度解析と密接に関係しています。そのため、時間計算量と空間計算量を紹介する前に、まずプログラム内で反復実行を実現する方法、つまり 2 つの基本的な制御構造である反復と再帰について見ていきます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   反復","text":"<p>反復（iteration）は、ある処理を繰り返し実行するための制御構造です。反復では、プログラムは一定の条件を満たす間、あるコード片を繰り返し実行し、その条件を満たさなくなるまで続けます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   for ループ","text":"<p><code>for</code> ループは最も一般的な反復形式の 1 つで、反復回数があらかじめ分かっている場合に適しています。</p> <p>次の関数は <code>for</code> ループを用いて \\(1 + 2 + \\dots + n\\) の総和を計算しており、その結果は変数 <code>res</code> に記録されます。なお、Python の <code>range(a, b)</code> に対応する区間は「左閉右開」であり、走査範囲は \\(a, a + 1, \\dots, b-1\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for ループ\"\"\"\n    res = 0\n    # 1, 2, ..., n-1, n を順に加算する\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for ループ */\nint ForLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for ループ */\nfunc forLoop(n int) int {\n    res := 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for ループ */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for ループ */\nfunction forLoop(n) {\n    let res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for ループ */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for ループ */\nint forLoop(int n) {\n  int res = 0;\n  // 1, 2, ..., n-1, n を順に加算する\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for ループ */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for ループ */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for ループ ###\ndef for_loop(n)\n  res = 0\n\n  # 1, 2, ..., n-1, n を順に加算する\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、この総和関数のフローチャートです。</p> <p></p> <p> 図 2-1   総和関数のフローチャート </p> <p>この総和関数の操作回数は入力データサイズ \\(n\\) に比例し、言い換えれば「線形関係」にあります。実際、時間計算量が記述するのはこの「線形関係」そのものです。関連内容は次節で詳しく説明します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   while ループ","text":"<p><code>for</code> ループと同様に、<code>while</code> ループも反復を実現する方法の 1 つです。<code>while</code> ループでは、各反復のたびにまず条件を確認し、条件が真であれば実行を続け、そうでなければループを終了します。</p> <p>次に、<code>while</code> ループを使って \\(1 + 2 + \\dots + n\\) の総和を求めてみましょう。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while ループ\"\"\"\n    res = 0\n    i = 1  # 条件変数を初期化する\n    # 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n:\n        res += i\n        i += 1  # 条件変数を更新する\n    return res\n</code></pre> iteration.cpp<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while ループ */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while ループ */\nfunc whileLoop(n int) int {\n    res := 0\n    // 条件変数を初期化する\n    i := 1\n    // 1, 2, ..., n-1, n を順に加算する\n    for i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while ループ */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n {\n        res += i\n        i += 1 // 条件変数を更新する\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while ループ */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while ループ */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while ループ */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // 条件変数を初期化する\n  // 1, 2, ..., n-1, n を順に加算する\n  while (i &lt;= n) {\n    res += i;\n    i++; // 条件変数を更新する\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while ループ */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 条件変数を初期化する\n\n    // 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n {\n        res += i;\n        i += 1; // 条件変数を更新する\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while ループ */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i\n        i++ // 条件変数を更新する\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while ループ ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 2, ..., n-1, n を順に加算する\n  while i &lt;= n\n    res += i\n    i += 1 # 条件変数を更新する\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>**<code>while</code> ループは <code>for</code> ループより自由度が高い**です。<code>while</code> ループでは、条件変数の初期化や更新手順を柔軟に設計できます。</p> <p>たとえば次のコードでは、条件変数 \\(i\\) が各反復で 2 回更新されており、このようなケースは <code>for</code> ループではあまり扱いやすくありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while ループ（2回更新）\"\"\"\n    res = 0\n    i = 1  # 条件変数を初期化する\n    # 1, 4, 10, ... を順に加算する\n    while i &lt;= n:\n        res += i\n        # 条件変数を更新する\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while ループ（2回更新） */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while ループ（2回更新） */\nfunc whileLoopII(n int) int {\n    res := 0\n    // 条件変数を初期化する\n    i := 1\n    // 1, 4, 10, ... を順に加算する\n    for i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while ループ（2回更新） */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while ループ（2回更新） */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while ループ（2回更新） */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // 条件変数を初期化する\n  // 1, 4, 10, ... を順に加算する\n  while (i &lt;= n) {\n    res += i;\n    // 条件変数を更新する\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while ループ（2回更新） */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 条件変数を初期化する\n\n    // 1, 4, 10, ... を順に加算する\n    while i &lt;= n {\n        res += i;\n        // 条件変数を更新する\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while ループ（2回更新） */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i\n        // 条件変数を更新する\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while ループ ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 2, ..., n-1, n を順に加算する\n  while i &lt;= n\n    res += i\n    i += 1 # 条件変数を更新する\n  end\n\n  res\nend\n\n# ## while ループ（2 回更新）###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 4, 10, ... を順に加算する\n  while i &lt;= n\n    res += i\n    # 条件変数を更新する\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>総じて、**<code>for</code> ループのコードはより簡潔で、<code>while</code> ループはより柔軟**です。どちらも反復構造を実現できますが、どちらを使うかは問題ごとの要件に応じて決めるべきです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   ネストしたループ","text":"<p>1 つのループ構造の中に別のループ構造を入れ子にできます。以下では <code>for</code> ループを例にします。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"二重 for ループ\"\"\"\n    res = \"\"\n    # i = 1, 2, ..., n-1, n とループする\n    for i in range(1, n + 1):\n        # j = 1, 2, ..., n-1, n とループする\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* 二重 for ループ */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; ++i) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* 二重 for ループ */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* 二重 for ループ */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* 二重 for ループ */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // i = 1, 2, ..., n-1, n とループする\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // j = 1, 2, ..., n-1, n とループする\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* 二重 for ループ */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // i = 1, 2, ..., n-1, n とループする\n    for i in 1 ... n {\n        // j = 1, 2, ..., n-1, n とループする\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* 二重 for ループ */\nfunction nestedForLoop(n) {\n    let res = '';\n    // i = 1, 2, ..., n-1, n とループする\n    for (let i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* 二重 for ループ */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // i = 1, 2, ..., n-1, n とループする\n    for (let i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* 二重 for ループ */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // i = 1, 2, ..., n-1, n とループする\n  for (int i = 1; i &lt;= n; i++) {\n    // j = 1, 2, ..., n-1, n とループする\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* 二重 for ループ */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // i = 1, 2, ..., n-1, n とループする\n    for i in 1..=n {\n        // j = 1, 2, ..., n-1, n とループする\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* 二重 for ループ */\nchar *nestedForLoop(int n) {\n    // n * n は対応する点の個数であり、\"(i, j), \" に対応する文字列長の最大は 6+10*2 で、さらに末尾の空文字 \\0 のための追加領域が必要\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* 二重 for ループ */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // i = 1, 2, ..., n-1, n とループする\n    for (i in 1..n) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### 二重 for ループ ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # i = 1, 2, ..., n-1, n とループする\n  for i in 1..n\n    # j = 1, 2, ..., n-1, n とループする\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、このネストしたループのフローチャートです。</p> <p></p> <p> 図 2-2   ネストしたループのフローチャート </p> <p>この場合、関数の操作回数は \\(n^2\\) に比例し、言い換えればアルゴリズムの実行時間は入力データサイズ \\(n\\) と「二次関係」にあります。</p> <p>さらにネストしたループを追加することもできます。ネストが 1 段増えるたびに「次元が 1 つ上がる」ことになり、時間計算量は「三次関係」「四次関係」へと高くなっていきます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   再帰","text":"<p>再帰（recursion）は、関数が自分自身を呼び出すことで問題を解決するアルゴリズム戦略です。主に 2 つの段階から成ります。</p> <ol> <li>再帰呼び出し：プログラムは自分自身をより深く呼び出し続け、通常はより小さい、またはより単純化された引数を渡し、「終了条件」に達するまで進みます。</li> <li>復帰： 「終了条件」が満たされると、プログラムは最も深い再帰関数から 1 層ずつ戻り、各層の結果をまとめていきます。</li> </ol> <p>実装の観点から見ると、再帰コードは主に 3 つの要素から成ります。</p> <ol> <li>終了条件：いつ再帰呼び出しから復帰へ切り替わるかを決めます。</li> <li>再帰呼び出し：再帰呼び出しに対応し、関数が自分自身を呼び出します。通常はより小さい、またはより単純化された引数を入力します。</li> <li>結果の返却：復帰に対応し、現在の再帰レベルの結果を 1 つ上の層へ返します。</li> </ol> <p>次のコードを見ると、関数 <code>recur(n)</code> を呼び出すだけで \\(1 + 2 + \\dots + n\\) を計算できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"再帰\"\"\"\n    # 終了条件\n    if n == 1:\n        return 1\n    # 再帰：再帰呼び出し\n    res = recur(n - 1)\n    # 帰りがけ：結果を返す\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* 再帰 */\nint Recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = Recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* 再帰 */\nfunc recur(n int) int {\n    // 終了条件\n    if n == 1 {\n        return 1\n    }\n    // 再帰：再帰呼び出し\n    res := recur(n - 1)\n    // 帰りがけ：結果を返す\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* 再帰 */\nfunc recur(n: Int) -&gt; Int {\n    // 終了条件\n    if n == 1 {\n        return 1\n    }\n    // 再帰：再帰呼び出し\n    let res = recur(n: n - 1)\n    // 帰りがけ：結果を返す\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* 再帰 */\nfunction recur(n) {\n    // 終了条件\n    if (n === 1) return 1;\n    // 再帰：再帰呼び出し\n    const res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* 再帰 */\nfunction recur(n: number): number {\n    // 終了条件\n    if (n === 1) return 1;\n    // 再帰：再帰呼び出し\n    const res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* 再帰 */\nint recur(int n) {\n  // 終了条件\n  if (n == 1) return 1;\n  // 再帰：再帰呼び出し\n  int res = recur(n - 1);\n  // 帰りがけ：結果を返す\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* 再帰 */\nfn recur(n: i32) -&gt; i32 {\n    // 終了条件\n    if n == 1 {\n        return 1;\n    }\n    // 再帰：再帰呼び出し\n    let res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* 再帰 */\nfun recur(n: Int): Int {\n    // 終了条件\n    if (n == 1)\n        return 1\n    // 再帰: 再帰呼び出し\n    val res = recur(n - 1)\n    // 戻る: 結果を返す\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### 再帰 ###\ndef recur(n)\n  # 終了条件\n  return 1 if n == 1\n  # 再帰：再帰呼び出し\n  res = recur(n - 1)\n  # 帰りがけ：結果を返す\n  n + res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、この関数の再帰過程を示しています。</p> <p></p> <p> 図 2-3   総和関数の再帰過程 </p> <p>計算の観点では、反復と再帰は同じ結果を得られますが、それらは問題を考え解決するためのまったく異なる 2 つのパラダイムを表しています。</p> <ul> <li>反復：「ボトムアップ」で問題を解決します。最も基本的な手順から始め、それらを繰り返したり積み上げたりして、処理が完了するまで進めます。</li> <li>再帰：「トップダウン」で問題を解決します。元の問題をより小さな部分問題に分解し、それらの部分問題は元の問題と同じ形を持ちます。さらに部分問題をより小さな部分問題へと分解し、基本ケースに達したところで停止します（基本ケースの解は既知です）。</li> </ul> <p>前述の総和関数を例に、問題を \\(f(n) = 1 + 2 + \\dots + n\\) とします。</p> <ul> <li>反復：ループ内で総和の過程を模擬し、\\(1\\) から \\(n\\) まで走査して、各反復で加算を行えば \\(f(n)\\) を求められます。</li> <li>再帰：問題を部分問題 \\(f(n) = n + f(n-1)\\) に分解し、これを再帰的に分解し続け、基本ケース \\(f(1) = 1\\) に達したところで終了します。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   呼び出しスタック","text":"<p>再帰関数が自分自身を呼び出すたびに、システムは新たに開始された関数のためにメモリを割り当て、局所変数、呼び出し先アドレス、その他の情報を保存します。これにより 2 つの結果が生じます。</p> <ul> <li>関数のコンテキストデータは「スタックフレーム領域」と呼ばれるメモリ領域に保存され、関数が戻るまで解放されません。したがって、再帰は通常、反復より多くのメモリ空間を消費します。</li> <li>再帰による関数呼び出しには追加のオーバーヘッドが発生します。そのため再帰は通常、ループより時間効率が低くなります。</li> </ul> <p>次の図のように、終了条件が発動する前には、まだ戻っていない再帰関数が同時に \\(n\\) 個存在し、再帰の深さは \\(n\\) になります。</p> <p></p> <p> 図 2-4   再帰呼び出しの深さ </p> <p>実際には、プログラミング言語が許容する再帰の深さには通常上限があり、深すぎる再帰はスタックオーバーフローを引き起こす可能性があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   末尾再帰","text":"<p>興味深いことに、関数が返る直前の最後の処理で再帰呼び出しを行う場合、その関数はコンパイラやインタプリタによって最適化され、空間効率が反復と同程度になることがあります。これを末尾再帰（tail recursion）と呼びます。</p> <ul> <li>通常の再帰：関数が 1 つ上の階層の関数へ戻った後も、引き続きコードを実行する必要があるため、システムは 1 つ上の呼び出しのコンテキストを保存しておく必要があります。</li> <li>末尾再帰：再帰呼び出しが関数の返却前の最後の操作であるため、1 つ上の階層へ戻った後に他の処理を続ける必要がなく、システムは 1 つ上の関数のコンテキストを保存する必要がありません。</li> </ul> <p>\\(1 + 2 + \\dots + n\\) の計算を例にすると、結果変数 <code>res</code> を関数の引数にすることで、末尾再帰を実現できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"末尾再帰\"\"\"\n    # 終了条件\n    if n == 0:\n        return res\n    # 末尾再帰呼び出し\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* 末尾再帰 */\nint TailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* 末尾再帰 */\nfunc tailRecur(n int, res int) int {\n    // 終了条件\n    if n == 0 {\n        return res\n    }\n    // 末尾再帰呼び出し\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* 末尾再帰 */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // 終了条件\n    if n == 0 {\n        return res\n    }\n    // 末尾再帰呼び出し\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* 末尾再帰 */\nfunction tailRecur(n, res) {\n    // 終了条件\n    if (n === 0) return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* 末尾再帰 */\nfunction tailRecur(n: number, res: number): number {\n    // 終了条件\n    if (n === 0) return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n  // 終了条件\n  if (n == 0) return res;\n  // 末尾再帰呼び出し\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* 末尾再帰 */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // 終了条件\n    if n == 0 {\n        return res;\n    }\n    // 末尾再帰呼び出し\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* 末尾再帰 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // `tailrec` キーワードを追加して末尾再帰最適化を有効にする\n    // 終了条件\n    if (n == 0)\n        return res\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### 末尾再帰 ###\ndef tail_recur(n, res)\n  # 終了条件\n  return res if n == 0\n  # 末尾再帰呼び出し\n  tail_recur(n - 1, res + n)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>末尾再帰の実行過程を次の図に示します。通常の再帰と末尾再帰を比べると、加算処理が実行されるタイミングが異なります。</p> <ul> <li>通常の再帰：加算処理は復帰の過程で実行され、各層が戻るたびにもう一度加算を行います。</li> <li>末尾再帰：加算処理は再帰呼び出しの過程で実行され、復帰の過程では各層が戻るだけで済みます。</li> </ul> <p></p> <p> 図 2-5   末尾再帰の過程 </p> <p>Tip</p> <p>多くのコンパイラやインタプリタは末尾再帰最適化をサポートしていない点に注意してください。たとえば、Python はデフォルトで末尾再帰最適化をサポートしていないため、関数が末尾再帰の形であっても、スタックオーバーフローが発生する可能性があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   再帰木","text":"<p>「分割統治」に関連するアルゴリズム問題を扱う際、再帰は反復よりも発想が直感的で、コードも読みやすいことがよくあります。「フィボナッチ数列」を例に見てみましょう。</p> <p>Question</p> <p>フィボナッチ数列 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) が与えられたとき、この数列の第 \\(n\\) 項を求めてください。</p> <p>フィボナッチ数列の第 \\(n\\) 項を \\(f(n)\\) とすると、次の 2 つが容易に分かります。</p> <ul> <li>数列の最初の 2 項は \\(f(1) = 0\\) と \\(f(2) = 1\\) です。</li> <li>数列中の各項は直前の 2 項の和であり、すなわち \\(f(n) = f(n - 1) + f(n - 2)\\) です。</li> </ul> <p>漸化式に従って再帰呼び出しを行い、最初の 2 項を終了条件とすれば、再帰コードを書けます。<code>fib(n)</code> を呼び出すことでフィボナッチ数列の第 \\(n\\) 項を得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"フィボナッチ数列：再帰\"\"\"\n    # 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    res = fib(n - 1) + fib(n - 2)\n    # 結果 f(n) を返す\n    return res\n</code></pre> recursion.cpp<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* フィボナッチ数列：再帰 */\nint Fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = Fib(n - 1) + Fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* フィボナッチ数列：再帰 */\nfunc fib(n int) int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    res := fib(n-1) + fib(n-2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* フィボナッチ数列：再帰 */\nfunc fib(n: Int) -&gt; Int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.js<pre><code>/* フィボナッチ数列：再帰 */\nfunction fib(n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    const res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* フィボナッチ数列：再帰 */\nfunction fib(n: number): number {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    const res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n  // 終了条件 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n  int res = fib(n - 1) + fib(n - 2);\n  // 結果 f(n) を返す\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* フィボナッチ数列：再帰 */\nfn fib(n: i32) -&gt; i32 {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    let res = fib(n - 1) + fib(n - 2);\n    // 結果を返す\n    res\n}\n</code></pre> recursion.c<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* フィボナッチ数列：再帰 */\nfun fib(n: Int): Int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    val res = fib(n - 1) + fib(n - 2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.rb<pre><code>### フィボナッチ数列：再帰 ###\ndef fib(n)\n  # 終了条件 f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n  res = fib(n - 1) + fib(n - 2)\n  # 結果 f(n) を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、関数内で 2 回の再帰呼び出しを行っています。これは 1 回の呼び出しから 2 つの呼び出し分岐が生じることを意味します。次の図のように、この再帰呼び出しを繰り返していくと、最終的に深さ \\(n\\) の再帰木（recursion tree）が生成されます。</p> <p></p> <p> 図 2-6   フィボナッチ数列の再帰木 </p> <p>本質的に見ると、再帰は「問題をより小さな部分問題へ分解する」という思考パラダイムを体現しており、この分割統治の戦略は非常に重要です。</p> <ul> <li>アルゴリズムの観点では、探索、ソート、バックトラッキング、分割統治、動的計画法など、多くの重要な戦略が直接または間接にこの考え方を用いています。</li> <li>データ構造の観点では、再帰は連結リスト、木、グラフに関する問題の処理に本質的に適しており、これらは分割統治の考え方で分析しやすいからです。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   両者の比較","text":"<p>以上をまとめると、次の表のように、反復と再帰は実装、性能、適用性の面で違いがあります。</p> <p> 表 2-1   反復と再帰の特徴の比較 </p> 反復 再帰 実装方法 ループ構造 関数が自分自身を呼び出す 時間効率 通常は効率が高く、関数呼び出しの負荷がない 関数呼び出しのたびにオーバーヘッドが発生する メモリ使用 通常は固定サイズのメモリ空間を使う 関数呼び出しの蓄積により大量のスタックフレーム領域を使う可能性がある 適用対象 単純な反復処理に適し、コードが直感的で読みやすい 木、グラフ、分割統治、バックトラッキングなどの部分問題分解に適し、コード構造が簡潔で明快 <p>Tip</p> <p>以下の内容が難しいと感じる場合は、「スタック」の章を読み終えた後に改めて復習してください。</p> <p>では、反復と再帰にはどのような内在的な関係があるのでしょうか。前述の再帰関数を例にすると、加算処理は再帰の復帰段階で行われます。これは、最初に呼び出された関数が実際には最後に加算を完了することを意味しており、この動作の仕組みはスタックの「後入れ先出し」の原則とよく似ています。</p> <p>実際、「呼び出しスタック」や「スタックフレーム領域」といった再帰の用語自体が、再帰とスタックの密接な関係を示唆しています。</p> <ol> <li>再帰呼び出し：関数が呼び出されると、システムは「呼び出しスタック」上にその関数のための新しいスタックフレームを割り当て、局所変数、引数、返却先アドレスなどのデータを保存します。</li> <li>復帰：関数の実行が完了して戻ると、対応するスタックフレームは「呼び出しスタック」から取り除かれ、前の関数の実行環境が復元されます。</li> </ol> <p>したがって、明示的なスタックを使って呼び出しスタックの振る舞いを模擬することができ、その結果として再帰を反復形式へ変換できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"反復で再帰を模擬する\"\"\"\n    # 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack = []\n    res = 0\n    # 再帰：再帰呼び出し\n    for i in range(n, 0, -1):\n        # 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.append(i)\n    # 帰りがけ：結果を返す\n    while stack:\n        # 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (!stack.empty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (!stack.isEmpty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 反復で再帰を模擬する */\nint ForLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.Push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.Count &gt; 0) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 反復で再帰を模擬する */\nfunc forLoopRecur(n int) int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack := list.New()\n    res := 0\n    // 再帰：再帰呼び出し\n    for i := n; i &gt; 0; i-- {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.PushBack(i)\n    }\n    // 帰りがけ：結果を返す\n    for stack.Len() != 0 {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 反復で再帰を模擬する */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    var stack: [Int] = []\n    var res = 0\n    // 再帰：再帰呼び出し\n    for i in (1 ... n).reversed() {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.append(i)\n    }\n    // 帰りがけ：結果を返す\n    while !stack.isEmpty {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 反復で再帰を模擬する */\nfunction forLoopRecur(n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    const stack = [];\n    let res = 0;\n    // 再帰：再帰呼び出し\n    for (let i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.length) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 反復で再帰を模擬する */\nfunction forLoopRecur(n: number): number {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    const stack: number[] = [];\n    let res: number = 0;\n    // 再帰：再帰呼び出し\n    for (let i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.length) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n  // 明示的なスタックを使ってシステムコールスタックを模擬する\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // 再帰：再帰呼び出し\n  for (int i = n; i &gt; 0; i--) {\n    // 「スタックへのプッシュ」で「再帰」を模擬する\n    stack.add(i);\n  }\n  // 帰りがけ：結果を返す\n  while (!stack.isEmpty) {\n    // 「スタックから取り出す操作」で「帰り」をシミュレート\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 反復で再帰を模擬する */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // 再帰：再帰呼び出し\n    for i in (1..=n).rev() {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while !stack.is_empty() {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    int stack[1000]; // 大きな配列を使ってスタックを実装する\n    int top = -1;    // スタックトップのインデックス\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack[1 + top++] = i;\n    }\n    // 帰りがけ：結果を返す\n    while (top &gt;= 0) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 反復で再帰を模擬する */\nfun forLoopRecur(n: Int): Int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // 再帰: 再帰呼び出し\n    for (i in n downTo 0) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i)\n    }\n    // 戻る: 結果を返す\n    while (stack.isNotEmpty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 反復で再帰をシミュレート ###\ndef for_loop_recur(n)\n  # 明示的なスタックを使ってシステムコールスタックを模擬する\n  stack = []\n  res = 0\n\n  # 再帰：再帰呼び出し\n  for i in n.downto(0)\n    # 「スタックへのプッシュ」で「再帰」を模擬する\n    stack &lt;&lt; i\n  end\n  # 帰りがけ：結果を返す\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、再帰を反復へ変換すると、コードはより複雑になります。反復と再帰は多くの場合に相互変換できますが、常にそうする価値があるとは限りません。理由は次の 2 点です。</p> <ul> <li>変換後のコードは理解しにくくなり、可読性が下がる可能性があります。</li> <li>複雑な問題によっては、システムの呼び出しスタックの振る舞いを模擬すること自体が非常に難しい場合があります。</li> </ul> <p>要するに、反復を選ぶか再帰を選ぶかは、対象となる問題の性質によって決まります。実際のプログラミングでは、両者の長所と短所を見極め、状況に応じて適切な方法を選ぶことが重要です。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   アルゴリズム効率の評価","text":"<p>アルゴリズム設計では、次の 2 つのレベルの目標を順に追求します。</p> <ol> <li>問題の解法を見つける：アルゴリズムは、定められた入力範囲内で問題の正しい解を確実に求められる必要があります。</li> <li>最適な解法を追求する：同じ問題に対して複数の解法が存在する場合があり、私たちはできるだけ効率的なアルゴリズムを見つけたいと考えます。</li> </ol> <p>つまり、問題を解けることを前提として、アルゴリズム効率はその良し悪しを測る主要な評価指標となっており、次の 2 つの観点を含みます。</p> <ul> <li>時間効率：アルゴリズムの実行時間の長さ。</li> <li>空間効率：アルゴリズムが使用するメモリ空間の大きさ。</li> </ul> <p>簡単に言えば、**私たちの目標は「高速で省メモリ」なデータ構造とアルゴリズムを設計すること**です。そして、アルゴリズム効率を効果的に評価することは非常に重要です。そうすることで初めて、さまざまなアルゴリズムを比較し、さらにアルゴリズム設計と最適化の過程を導けるからです。</p> <p>効率の評価方法は主に 2 種類に分けられます。実測と理論的な見積もりです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   実測","text":"<p>いまアルゴリズム <code>A</code> とアルゴリズム <code>B</code> があり、どちらも同じ問題を解けるとします。この 2 つのアルゴリズムの効率を比較する必要がある場合、最も直接的な方法は 1 台のコンピュータで両者を実行し、その実行時間とメモリ使用量を監視して記録することです。この評価方法は実際の状況を反映できますが、大きな制約もあります。</p> <p>一方では、**テスト環境による干渉要因を排除しにくい**という問題があります。ハードウェア構成はアルゴリズムの性能に影響します。たとえば、並列度の高いアルゴリズムはマルチコア CPU での実行により適しており、メモリアクセスが集中的なアルゴリズムは高性能メモリ上でより良い性能を示します。つまり、異なるマシンでのテスト結果は一致しない可能性があります。これは、さまざまなマシンでテストして平均効率を統計的に求める必要があることを意味しますが、それは現実的ではありません。</p> <p>他方では、**完全なテストを実施するには非常に多くの資源が必要**です。入力データ量が変化すると、アルゴリズムは異なる効率を示します。たとえば、入力データ量が小さいときはアルゴリズム <code>A</code> の実行時間がアルゴリズム <code>B</code> より短くても、入力データ量が大きいときには結果がちょうど逆になるかもしれません。そのため、説得力のある結論を得るには、さまざまな規模の入力データでテストする必要があり、それには大量の計算資源を要します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   理論的な見積もり","text":"<p>実測には大きな制約があるため、いくつかの計算だけによってアルゴリズムの効率を評価することを考えられます。この見積もり方法は漸近計算量解析（asymptotic complexity analysis）と呼ばれ、略して計算量解析といいます。</p> <p>計算量解析は、アルゴリズムの実行に必要な時間資源と空間資源が入力データ規模とどのような関係にあるかを表します。これは、入力データ規模が増加するにつれて、アルゴリズムの実行に必要な時間と空間がどのように増加するかという傾向を記述するものです。この定義はややわかりにくいので、次の 3 つのポイントに分けて理解できます。</p> <ul> <li>「時間資源と空間資源」は、それぞれ時間計算量（time complexity）と空間計算量（space complexity）に対応します。</li> <li>「入力データ規模が増加するにつれて」とは、計算量がアルゴリズムの実行効率と入力データ規模との関係を反映していることを意味します。</li> <li>「時間と空間の増加傾向」とは、計算量解析が注目するのは実行時間や使用空間の具体的な値ではなく、時間や空間の増加の「速さ」であることを示します。</li> </ul> <p>計算量解析は実測という方法の欠点を克服しています。その点は次のように表れます。</p> <ul> <li>実際にコードを動かす必要がなく、より環境にやさしく省エネルギーです。</li> <li>テスト環境から独立しており、解析結果はすべての実行プラットフォームに適用できます。</li> <li>異なるデータ量におけるアルゴリズム効率を表せ、とくに大規模データ量での性能を反映できます。</li> </ul> <p>Tip</p> <p>それでも計算量の概念がまだわかりにくくても、心配はいりません。後続の章で詳しく説明します。</p> <p>計算量解析は、アルゴリズム効率を評価するための「物差し」を私たちに与えてくれます。これにより、あるアルゴリズムの実行に必要な時間資源と空間資源を測り、異なるアルゴリズム同士の効率を比較できます。</p> <p>計算量は数学的な概念であり、初学者にとってはやや抽象的で、学習の難度も比較的高いかもしれません。この観点から見ると、計算量解析は最初に紹介する内容としてはあまり適していない可能性があります。しかし、あるデータ構造やアルゴリズムの特徴を議論する際には、その実行速度や空間使用状況の分析を避けることはできません。</p> <p>以上を踏まえると、データ構造とアルゴリズムを深く学ぶ前に、**まず計算量解析について初歩的な理解を持ち、簡単なアルゴリズムの計算量解析ができるようにしておくこと**を勧めます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   空間計算量","text":"<p>空間計算量（space complexity）は、アルゴリズムが占有するメモリ空間がデータ量の増加に伴ってどのように増えるかを測る指標です。この概念は時間計算量と非常によく似ており、「実行時間」を「占有メモリ空間」に置き換えるだけです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   アルゴリズムに関連する空間","text":"<p>アルゴリズムが実行中に使用するメモリ空間には、主に次の種類があります。</p> <ul> <li>入力空間：アルゴリズムの入力データを格納するための空間。</li> <li>一時空間：アルゴリズムの実行中に使用する変数、オブジェクト、関数コンテキストなどのデータを格納するための空間。</li> <li>出力空間：アルゴリズムの出力データを格納するための空間。</li> </ul> <p>一般に、空間計算量の集計範囲は「一時空間」と「出力空間」を合わせたものです。</p> <p>一時空間はさらに三つに分けられます。</p> <ul> <li>一時データ：アルゴリズム実行中の各種定数、変数、オブジェクトなどを保存するための空間。</li> <li>スタックフレーム空間：呼び出された関数のコンテキストデータを保存するための空間。システムは関数を呼び出すたびにスタックの先頭にスタックフレームを作成し、関数が戻るとその空間を解放します。</li> <li>命令空間：コンパイル後のプログラム命令を保存するための空間で、実際の集計では通常無視されます。</li> </ul> <p>プログラムの空間計算量を分析する際には、通常、一時データ、スタックフレーム空間、出力データの三つを数えます。以下の図に示すとおりです。</p> <p></p> <p> 図 2-15   アルゴリズムで使用される関連空間 </p> <p>関連するコードを以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"クラス\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # ノードの値\n        self.next: Node | None = None  # 次のノードへの参照\n\ndef function() -&gt; int:\n    \"\"\"関数\"\"\"\n    # いくつかの処理を実行...\n    return 0\n\ndef algorithm(n) -&gt; int:  # 入力データ\n    A = 0                 # 一時データ（定数。一般に大文字で表す）\n    b = 0                 # 一時データ（変数）\n    node = Node(0)        # 一時データ（オブジェクト）\n    c = function()        # スタックフレーム空間（関数呼び出し）\n    return A + b + c      # 出力データ\n</code></pre> <pre><code>/* 構造体 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* 関数 */\nint func() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) {        // 入力データ\n    const int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node* node = new Node(0); // 一時データ（オブジェクト）\n    int c = func();           // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* 関数 */\nint function() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) {        // 入力データ\n    final int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node node = new Node(0);  // 一時データ（オブジェクト）\n    int c = function();       // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* 関数 */\nint Function() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint Algorithm(int n) {        // 入力データ\n    const int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node node = new(0);       // 一時データ（オブジェクト）\n    int c = Function();       // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* 構造体 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* node 構造体を作成 */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* 関数 */\nfunc function() int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfunc algorithm(n int) int { // 入力データ\n    const a = 0             // 一時データ（定数）\n    b := 0                  // 一時データ（変数）\n    newNode(0)              // 一時データ（オブジェクト）\n    c := function()         // スタックフレーム空間（関数呼び出し）\n    return a + b + c        // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* 関数 */\nfunc function() -&gt; Int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // 入力データ\n    let a = 0             // 一時データ（定数）\n    var b = 0             // 一時データ（変数）\n    let node = Node(x: 0) // 一時データ（オブジェクト）\n    let c = function()    // スタックフレーム空間（関数呼び出し）\n    return a + b + c      // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // ノードの値\n        this.next = null;                       // 次のノードへの参照\n    }\n}\n\n/* 関数 */\nfunction constFunc() {\n    // いくつかの処理を実行\n    return 0;\n}\n\nfunction algorithm(n) {       // 入力データ\n    const a = 0;              // 一時データ（定数）\n    let b = 0;                // 一時データ（変数）\n    const node = new Node(0); // 一時データ（オブジェクト）\n    const c = constFunc();    // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // ノードの値\n        this.next = null;                       // 次のノードへの参照\n    }\n}\n\n/* 関数 */\nfunction constFunc(): number {\n    // いくつかの処理を実行\n    return 0;\n}\n\nfunction algorithm(n: number): number { // 入力データ\n    const a = 0;                        // 一時データ（定数）\n    let b = 0;                          // 一時データ（変数）\n    const node = new Node(0);           // 一時データ（オブジェクト）\n    const c = constFunc();              // スタックフレーム空間（関数呼び出し）\n    return a + b + c;                   // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* 関数 */\nint function() {\n  // いくつかの処理を実行...\n  return 0;\n}\n\nint algorithm(int n) {  // 入力データ\n  const int a = 0;      // 一時データ（定数）\n  int b = 0;            // 一時データ（変数）\n  Node node = Node(0);  // 一時データ（オブジェクト）\n  int c = function();   // スタックフレーム空間（関数呼び出し）\n  return a + b + c;     // 出力データ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 構造体 */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Node 構造体を作成 */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* 関数 */\nfn function() -&gt; i32 {      \n    // いくつかの処理を実行...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // 入力データ\n    const a: i32 = 0;               // 一時データ（定数）\n    let mut b = 0;                  // 一時データ（変数）\n    let node = Node::new(0);        // 一時データ（オブジェクト）\n    let c = function();             // スタックフレーム空間（関数呼び出し）\n    return a + b + c;               // 出力データ\n}\n</code></pre> <pre><code>/* 関数 */\nint func() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) { // 入力データ\n    const int a = 0;   // 一時データ（定数）\n    int b = 0;         // 一時データ（変数）\n    int c = func();    // スタックフレーム空間（関数呼び出し）\n    return a + b + c;  // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* 関数 */\nfun function(): Int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // 入力データ\n    val a = 0                // 一時データ（定数）\n    var b = 0                // 一時データ（変数）\n    val node = Node(0)       // 一時データ（オブジェクト）\n    val c = function()       // スタックフレーム空間（関数呼び出し）\n    return a + b + c         // 出力データ\n}\n</code></pre> <pre><code>### クラス ###\nclass Node\n    attr_accessor :val      # ノードの値\n    attr_accessor :next     # 次のノードへの参照\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### 関数 ###\ndef function\n    # いくつかの処理を実行...\n    0\nend\n\n### アルゴリズム ###\ndef algorithm(n)        # 入力データ\n    a = 0               # 一時データ（定数）\n    b = 0               # 一時データ（変数）\n    node = Node.new(0)  # 一時データ（オブジェクト）\n    c = function        # スタックフレーム空間（関数呼び出し）\n    a + b + c           # 出力データ\nend\n</code></pre>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   推定方法","text":"<p>空間計算量の推定方法は時間計算量とおおむね同じで、数える対象を「操作回数」から「使用空間の大きさ」に変えるだけです。</p> <p>ただし時間計算量と異なり、通常は最悪空間計算量だけに注目します。メモリ空間は厳格な要件であり、どの入力データに対しても十分なメモリを確保できることを保証しなければならないからです。</p> <p>以下のコードを見ると、最悪空間計算量における「最悪」には二つの意味があります。</p> <ol> <li>最悪の入力データを基準にする：\\(n &lt; 10\\) のとき空間計算量は \\(O(1)\\) ですが、\\(n &gt; 10\\) のとき初期化される配列 <code>nums</code> が \\(O(n)\\) の空間を占有するため、最悪空間計算量は \\(O(n)\\) です。</li> <li>アルゴリズム実行中のメモリ使用量のピークを基準にする：例えば、プログラムは最後の行を実行する前までは \\(O(1)\\) の空間しか使いませんが、配列 <code>nums</code> を初期化するときには \\(O(n)\\) の空間を占有するため、最悪空間計算量は \\(O(n)\\) です。</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>再帰関数では、スタックフレーム空間の集計に注意が必要です。以下のコードを見てみましょう。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # いくつかの処理を実行\n    return 0\n\ndef loop(n: int):\n    \"\"\"ループの空間計算量は O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"再帰の空間計算量は O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // いくつかの処理を実行\n    return 0\n}\n\n/* ループの空間計算量は O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* 再帰の空間計算量は O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // いくつかの処理を実行\n    return 0\n}\n\n/* ループの空間計算量は O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* 再帰の空間計算量は O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // いくつかの処理を実行\n  return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // いくつかの処理を実行\n    return 0\n}\n/* ループの空間計算量は O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # いくつかの処理を実行\n    0\nend\n\n### ループの空間計算量は O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### 再帰の空間計算量は O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>関数 <code>loop()</code> と <code>recur()</code> はどちらも時間計算量は \\(O(n)\\) ですが、空間計算量は異なります。</p> <ul> <li>関数 <code>loop()</code> はループの中で <code>function()</code> を \\(n\\) 回呼び出しますが、各反復での <code>function()</code> は戻るたびにスタックフレーム空間が解放されるため、空間計算量は依然として \\(O(1)\\) です。</li> <li>再帰関数 <code>recur()</code> は実行中に未返却の <code>recur()</code> が同時に \\(n\\) 個存在するため、\\(O(n)\\) のスタックフレーム空間を占有します。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   よくある型","text":"<p>入力データサイズを \\(n\\) とすると、以下の図はよくある空間計算量の型を低い順から高い順に示しています。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{定数階} &lt; \\text{対数階} &lt; \\text{線形階} &lt; \\text{平方階} &lt; \\text{指数階} \\end{aligned} \\] <p></p> <p> 図 2-16   よくある空間計算量の型 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   定数階 \\(O(1)\\)","text":"<p>定数階は、個数が入力データサイズ \\(n\\) に依存しない定数、変数、オブジェクトなどによく現れます。</p> <p>注意すべき点として、ループ内で変数を初期化したり関数を呼び出したりして使用されたメモリは、次の反復に入ると解放されるため、空間の占有は累積せず、空間計算量は依然として \\(O(1)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"関数\"\"\"\n    # 何らかの処理を行う\n    return 0\n\ndef constant(n: int):\n    \"\"\"定数階\"\"\"\n    # 定数、変数、オブジェクトは O(1) の空間を占める\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # ループ内の変数は O(1) の空間を占める\n    for _ in range(n):\n        c = 0\n    # ループ内の関数は O(1) の空間を占める\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* 関数 */\nint func() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 関数 */\nint function() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 関数 */\nint Function() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid Constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 関数 */\nfunc function() int {\n    // いくつかの操作を実行...\n    return 0\n}\n\n/* 定数階 */\nfunc spaceConstant(n int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // ループ内の変数は O(1) の空間を占める\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* 関数 */\n@discardableResult\nfunc function() -&gt; Int {\n    // 何らかの処理を行う\n    return 0\n}\n\n/* 定数階 */\nfunc constant(n: Int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // ループ内の変数は O(1) の空間を占める\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* 関数 */\nfunction constFunc() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nfunction constant(n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 関数 */\nfunction constFunc(): number {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nfunction constant(n: number): void {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 関数 */\nint function() {\n  // 何らかの処理を行う\n  return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n  // 定数、変数、オブジェクトは O(1) の空間を占める\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // ループ内の変数は O(1) の空間を占める\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // ループ内の関数は O(1) の空間を占める\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 関数 */\nfn function() -&gt; i32 {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // ループ内の変数は O(1) の空間を占める\n    for i in 0..n {\n        let c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 関数 */\nint func() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 関数 */\nfun function(): Int {\n    // 何らかの処理を行う\n    return 0\n}\n\n/* 定数階 */\nfun constant(n: Int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // ループ内の変数は O(1) の空間を占める\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 関数 ###\ndef function\n  # 何らかの処理を行う\n  0\nend\n\n### 定数階 ###\ndef constant(n)\n  # 定数、変数、オブジェクトは O(1) の空間を占める\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # ループ内の変数は O(1) の空間を占める\n  (0...n).each { c = 0 }\n  # ループ内の関数は O(1) の空間を占める\n  (0...n).each { function }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   線形階 \\(O(n)\\)","text":"<p>線形階は、要素数が \\(n\\) に比例する配列、連結リスト、スタック、キューなどによく現れます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"線形階\"\"\"\n    # 長さ n のリストは O(n) の空間を使用\n    nums = [0] * n\n    # 長さ n のハッシュテーブルは O(n) の空間を使用\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    vector&lt;int&gt; nums(n);\n    // 長さ n のリストは O(n) の空間を使用\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int[] nums = new int[n];\n    // 長さ n のリストは O(n) の空間を使用\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 線形階 */\nvoid Linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int[] nums = new int[n];\n    // 長さ n のリストは O(n) の空間を使用\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 線形階 */\nfunc spaceLinear(n int) {\n    // 長さ n の配列は O(n) の空間を使用\n    _ = make([]int, n)\n    // 長さ n のリストは O(n) の空間を使用\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 線形階 */\nfunc linear(n: Int) {\n    // 長さ n の配列は O(n) の空間を使用\n    let nums = Array(repeating: 0, count: n)\n    // 長さ n のリストは O(n) の空間を使用\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* 線形階 */\nfunction linear(n) {\n    // 長さ n の配列は O(n) の空間を使用\n    const nums = new Array(n);\n    // 長さ n のリストは O(n) の空間を使用\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 線形階 */\nfunction linear(n: number): void {\n    // 長さ n の配列は O(n) の空間を使用\n    const nums = new Array(n);\n    // 長さ n のリストは O(n) の空間を使用\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 線形階 */\nvoid linear(int n) {\n  // 長さ n の配列は O(n) の空間を使用\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // 長さ n のリストは O(n) の空間を使用\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // 長さ n のハッシュテーブルは O(n) の空間を使用\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 線形階 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // 長さ n の配列は O(n) の空間を使用\n    let mut nums = vec![0; n as usize];\n    // 長さ n のリストは O(n) の空間を使用\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* ハッシュテーブル */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // uthash.h を用いて実装\n} HashTable;\n\n/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // 長さ n のリストは O(n) の空間を使用\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // メモリを解放する\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 線形階 */\nfun linear(n: Int) {\n    // 長さ n の配列は O(n) の空間を使用\n    val nums = Array(n) { 0 }\n    // 長さ n のリストは O(n) の空間を使用\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  # 長さ n のリストは O(n) の空間を使用\n  nums = Array.new(n, 0)\n\n  # 長さ n のハッシュテーブルは O(n) の空間を使用\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、この関数の再帰の深さは \\(n\\) であり、同時に \\(n\\) 個の未返却 <code>linear_recur()</code> 関数が存在するため、\\(O(n)\\) のスタックフレーム空間を使用します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"線形時間（再帰実装）\"\"\"\n    print(\"再帰 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"再帰 n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    System.out.println(\"再帰 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 線形時間（再帰実装） */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"再帰 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 線形時間（再帰実装） */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"再帰 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 線形時間（再帰実装） */\nfunc linearRecur(n: Int) {\n    print(\"再帰 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 線形時間（再帰実装） */\nfunction linearRecur(n) {\n    console.log(`再帰 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 線形時間（再帰実装） */\nfunction linearRecur(n: number): void {\n    console.log(`再帰 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n  print('再帰 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 線形時間（再帰実装） */\nfn linear_recur(n: i32) {\n    println!(\"再帰 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    printf(\"再帰 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* 線形時間（再帰実装） */\nfun linearRecur(n: Int) {\n    println(\"再帰 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  # 長さ n のリストは O(n) の空間を使用\n  nums = Array.new(n, 0)\n\n  # 長さ n のハッシュテーブルは O(n) の空間を使用\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n\n# ## 線形階（再帰実装）###\ndef linear_recur(n)\n  puts \"再帰 n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-17   再帰関数が生み出す線形階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階は、要素数が \\(n\\) の二乗に比例する行列やグラフによく現れます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"二乗階\"\"\"\n    # 二次元リストは O(n^2) の空間を使用\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 二次元リストは O(n^2) の空間を使用\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 行列は O(n^2) の空間を使用する\n    int[][] numMatrix = new int[n][n];\n    // 二次元リストは O(n^2) の空間を使用\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 二乗階 */\nvoid Quadratic(int n) {\n    // 行列は O(n^2) の空間を使用する\n    int[,] numMatrix = new int[n, n];\n    // 二次元リストは O(n^2) の空間を使用\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 二乗階 */\nfunc spaceQuadratic(n int) {\n    // 行列は O(n^2) の空間を使用する\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 二乗階 */\nfunc quadratic(n: Int) {\n    // 二次元リストは O(n^2) の空間を使用\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* 二乗階 */\nfunction quadratic(n) {\n    // 行列は O(n^2) の空間を使用する\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二次元リストは O(n^2) の空間を使用\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 二乗階 */\nfunction quadratic(n: number): void {\n    // 行列は O(n^2) の空間を使用する\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二次元リストは O(n^2) の空間を使用\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n  // 行列は O(n^2) の空間を使用する\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 二次元リストは O(n^2) の空間を使用\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 二乗階 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // 行列は O(n^2) の空間を使用する\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 二次元リストは O(n^2) の空間を使用\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 二次元リストは O(n^2) の空間を使用\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* 二乗階 */\nfun quadratic(n: Int) {\n    // 行列は O(n^2) の空間を使用する\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 二次元リストは O(n^2) の空間を使用\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、この関数の再帰の深さは \\(n\\) であり、各再帰関数の中で長さがそれぞれ \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) の配列を初期化しています。平均長は \\(n / 2\\) なので、全体では \\(O(n^2)\\) の空間を占有します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"二次時間（再帰実装）\"\"\"\n    if n &lt;= 0:\n        return 0\n    # 配列 nums の長さは n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"再帰 n = \" &lt;&lt; n &lt;&lt; \" における nums の長さ = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"再帰 n = \" + n + \" における nums の長さ = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 二次時間（再帰実装） */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"再帰 n = \" + n + \" における nums の長さ = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 二次時間（再帰実装） */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"再帰 n = %d における nums の長さ = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 二次時間（再帰実装） */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"再帰 n = \\(n) における nums の長さ = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 二次時間（再帰実装） */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 二次時間（再帰実装） */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('再帰 n = $n における nums の長さ = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 二次時間（再帰実装） */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"再帰 n = {} における nums の長さ = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"再帰 n = %d における nums の長さ = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* 二次時間（再帰実装） */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"再帰 n = $n における nums の長さ = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## 平方階（再帰実装）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 配列 nums の長さは n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-18   再帰関数が生み出す平方階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   指数階 \\(O(2^n)\\)","text":"<p>指数階は二分木によく現れます。以下の図を見ると、高さが \\(n\\) の「満二分木」のノード数は \\(2^n - 1\\) であり、\\(O(2^n)\\) の空間を占有します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"指数時間（完全二分木の構築）\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* 指数時間（完全二分木の構築） */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* 指数時間（完全二分木の構築） */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* 指数時間（完全二分木の構築） */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* 指数時間（完全二分木の構築） */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* 指数時間（完全二分木の構築） */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* 指数時間（完全二分木の構築） */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## 平方階（再帰実装）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 配列 nums の長さは n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n\n# ## 指数階（満二分木を構築）###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-19   満二分木が生み出す指数階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   対数階 \\(O(\\log n)\\)","text":"<p>対数階は分割統治アルゴリズムによく現れます。例えばマージソートでは、長さ \\(n\\) の配列を入力として、各再帰で配列を中央から二つに分割するため、高さ \\(\\log n\\) の再帰木が形成され、\\(O(\\log n)\\) のスタックフレーム空間を使用します。</p> <p>また、数値を文字列に変換する場合を考えると、正の整数 \\(n\\) の桁数は \\(\\lfloor \\log_{10} n \\rfloor + 1\\) であり、対応する文字列長も \\(\\lfloor \\log_{10} n \\rfloor + 1\\) です。したがって空間計算量は \\(O(\\log_{10} n + 1) = O(\\log n)\\) となります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   時間と空間のトレードオフ","text":"<p>理想的には、アルゴリズムの時間計算量と空間計算量の両方を最適にしたいところです。しかし実際には、この二つを同時に最適化するのは通常きわめて困難です。</p> <p>時間計算量を下げるには、通常、空間計算量を増やす代償が必要であり、その逆も同様です。メモリ空間を犠牲にして実行速度を上げる考え方を「空間を時間と引き換えにする」と呼び、その逆を「時間を空間と引き換えにする」と呼びます。</p> <p>どちらの考え方を選ぶかは、何をより重視するかによって決まります。多くの場合、空間より時間のほうが貴重なので、「空間を時間と引き換えにする」戦略のほうが一般的です。もちろん、データ量が非常に大きい場合には、空間計算量を抑えることも同じくらい重要です。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   まとめ","text":"","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<p>アルゴリズム効率の評価</p> <ul> <li>時間効率と空間効率は、アルゴリズムの良し悪しを測る二つの主要な評価指標です。</li> <li>実測によってアルゴリズム効率を評価できますが、テスト環境の影響を排除しにくく、多くの計算資源も消費します。</li> <li>複雑度分析は実測の欠点を補い、分析結果はすべての実行プラットフォームに適用でき、データ規模ごとの効率も明らかにできます。</li> </ul> <p>時間計算量</p> <ul> <li>時間計算量は、アルゴリズムの実行時間がデータ量の増加に伴ってどう変化するかを測るためのものであり、効率評価に有効です。ただし、入力データ量が小さい場合や時間計算量が同じ場合などには、効率の優劣を正確に比較できないことがあります。</li> <li>最悪時間計算量はビッグオー記法 \\(O\\) で表され、関数の漸近上界に対応し、\\(n\\) が正の無限大に近づくときの操作回数 \\(T(n)\\) の増加の度合いを表します。</li> <li>時間計算量の推定は二段階に分かれ、まず操作回数を数え、次に漸近上界を判断します。</li> <li>一般的な時間計算量を低い順から並べると、\\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n \\log n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\)、\\(O(n!)\\) などがあります。</li> <li>一部のアルゴリズムの時間計算量は固定ではなく、入力データの分布に関係します。時間計算量には最悪、最良、平均時間計算量がありますが、最良時間計算量は入力データが厳しい条件を満たす必要があるため、ほとんど使われません。</li> <li>平均時間計算量は、ランダムな入力データに対するアルゴリズムの実行効率を表し、実運用時の性能に最も近い指標です。平均時間計算量を求めるには、入力データの分布と、それを踏まえた数学的期待値を統計する必要があります。</li> </ul> <p>空間計算量</p> <ul> <li>空間計算量の役割は時間計算量に似ており、アルゴリズムが使用するメモリ空間がデータ量の増加に伴ってどう変化するかを測ります。</li> <li>アルゴリズム実行中に関係するメモリ空間は、入力空間、一時空間、出力空間に分けられます。通常、入力空間は空間計算量の計算に含めません。一時空間は一時データ、スタックフレーム空間、命令空間に分けられ、このうちスタックフレーム空間は通常、再帰関数でのみ空間計算量に影響します。</li> <li>私たちは通常、最悪空間計算量のみに注目し、最悪の入力データと最悪の実行時点における空間計算量を数えます。</li> <li>一般的な空間計算量を低い順から並べると、\\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\) などがあります。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：尾再帰の空間計算量は \\(O(1)\\) ですか？</p> <p>理論上、尾再帰関数の空間計算量は \\(O(1)\\) まで最適化できます。ただし、ほとんどのプログラミング言語（Java、Python、C++、Go、C# など）は尾再帰の自動最適化をサポートしていないため、通常は空間計算量を \\(O(n)\\) と見なします。</p> <p>Q：関数とメソッドという二つの用語の違いは何ですか？</p> <p>関数（function）は独立して実行でき、すべての引数は明示的に渡されます。メソッド（method）はオブジェクトに関連付けられ、それを呼び出すオブジェクトが暗黙的に渡され、クラスのインスタンスに含まれるデータを操作できます。</p> <p>以下では、いくつかの一般的なプログラミング言語を例に説明します。</p> <ul> <li>C 言語は手続き型プログラミング言語であり、オブジェクト指向の概念がないため、関数しかありません。ただし、構造体（struct）を作成してオブジェクト指向プログラミングを模倣でき、構造体に関連付けられた関数は、他のプログラミング言語におけるメソッドに相当します。</li> <li>Java と C# はオブジェクト指向のプログラミング言語であり、コードブロック（メソッド）は通常あるクラスの一部です。静的メソッドの振る舞いは関数に似ており、クラスに束縛され、特定のインスタンス変数にはアクセスできません。</li> <li>C++ と Python は、手続き型プログラミング（関数）にもオブジェクト指向プログラミング（メソッド）にも対応しています。</li> </ul> <p>Q：「一般的な空間計算量の種類」の図が表しているのは、使用空間の絶対量ですか？</p> <p>いいえ。この図が示しているのは空間計算量であり、表しているのは増加傾向であって、使用空間の絶対量ではありません。</p> <p>\\(n = 8\\) と仮定すると、各曲線の値が対応する関数と一致していないように見えるかもしれません。これは、各曲線に定数項が含まれており、値の範囲を視覚的に見やすい範囲へ圧縮しているためです。</p> <p>実際には、各手法の「定数項」の複雑度がどれほどか通常は分からないため、一般に複雑度だけを根拠に \\(n = 8\\) 以下で最適解を選ぶことはできません。ただし、\\(n = 8^5\\) であれば選びやすく、このときは増加傾向がすでに支配的になっています。</p> <p>Q 実際の利用場面に応じて、時間（または空間）を犠牲にしてアルゴリズムを設計することはありますか？</p> <p>実際の応用では、多くの場合、空間を犠牲にして時間を得る選択をします。たとえばデータベースのインデックスでは、通常 B+ 木やハッシュインデックスを構築し、大量のメモリ空間を使う代わりに、\\(O(\\log n)\\) あるいは \\(O(1)\\) の高速な検索を実現します。</p> <p>空間資源が貴重な場面では、時間を犠牲にして空間を得ることもあります。たとえば組み込み開発では、デバイスのメモリが非常に貴重なため、エンジニアはハッシュテーブルの使用をやめ、配列による順次探索を選んでメモリ使用量を節約することがあります。その代償として探索は遅くなります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   時間計算量","text":"<p>実行時間はアルゴリズムの効率を直感的かつ正確に反映します。あるコードの実行時間を正確に見積もりたい場合、どのようにすればよいでしょうか？</p> <ol> <li>実行プラットフォームを特定する。ハードウェア構成、プログラミング言語、システム環境などが含まれ、これらの要因はいずれもコードの実行効率に影響します。</li> <li>各種計算操作に必要な実行時間を評価する。例えば加算 <code>+</code> には 1 ns 、乗算 <code>*</code> には 10 ns 、出力 <code>print()</code> には 5 ns などが必要です。</li> <li>コード中のすべての計算操作を数える。そして各操作の実行時間を合計することで、実行時間を得ます。</li> </ol> <p>例えば次のコードでは、入力データサイズを \\(n\\) とします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># ある実行プラットフォーム上で\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # n 回ループ\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // n 回ループ\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // n 回ループ\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // n 回ループ\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // n 回ループ\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // n 回ループ\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># ある実行プラットフォーム上で\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # n 回ループ\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>上記の方法に基づくと、アルゴリズムの実行時間は \\((6n + 12)\\) ns になります：</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>しかし実際には、アルゴリズムの実行時間を統計的に求めることは合理的でも現実的でもありません。まず、見積もり時間を実行プラットフォームに縛りたくありません。アルゴリズムはさまざまな異なるプラットフォームで動作する必要があるからです。次に、各種操作の実行時間を知ること自体が難しく、見積もりの難易度を大きく引き上げます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   実行時間の増加傾向を捉える","text":"<p>時間計算量の分析で扱うのはアルゴリズムの実行時間そのものではなく、**データ量が増えたときに実行時間がどう増加するかという傾向**です。</p> <p>「実行時間の増加傾向」という概念はやや抽象的なので、例を通して理解してみましょう。入力データサイズを \\(n\\) とし、3 つのアルゴリズム <code>A</code>、<code>B</code>、<code>C</code> を考えます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># アルゴリズム A の時間計算量：定数階\ndef algorithm_A(n: int):\n    print(0)\n# アルゴリズム B の時間計算量：線形階\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# アルゴリズム C の時間計算量：定数階\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// アルゴリズム B の時間計算量：線形階\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// アルゴリズム B の時間計算量：線形階\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// アルゴリズム C の時間計算量：定数階\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// アルゴリズム B の時間計算量：線形階\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// アルゴリズム B の時間計算量：線形階\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithmA(int n) {\n  print(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// アルゴリズム B の時間計算量：線形階\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// アルゴリズム B の時間計算量：線形階\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># アルゴリズム A の時間計算量：定数階\ndef algorithm_A(n)\n    puts 0\nend\n\n# アルゴリズム B の時間計算量：線形階\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# アルゴリズム C の時間計算量：定数階\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>以下の図は、上記 3 つのアルゴリズム関数の時間計算量を示しています。</p> <ul> <li>アルゴリズム <code>A</code> には出力操作が \\(1\\) 回しかなく、実行時間は \\(n\\) が大きくなっても増加しません。このアルゴリズムの時間計算量を「定数階」と呼びます。</li> <li>アルゴリズム <code>B</code> の出力操作は \\(n\\) 回ループする必要があり、実行時間は \\(n\\) の増加に対して線形に増加します。このアルゴリズムの時間計算量は「線形階」と呼ばれます。</li> <li>アルゴリズム <code>C</code> の出力操作は \\(1000000\\) 回ループする必要があり、実行時間は長いものの、入力データサイズ \\(n\\) とは無関係です。したがって <code>C</code> の時間計算量は <code>A</code> と同じく、依然として「定数階」です。</li> </ul> <p></p> <p> 図 2-7   アルゴリズム A、B、C の時間増加傾向 </p> <p>アルゴリズムの実行時間を直接数える方法と比べて、時間計算量分析にはどのような特徴があるでしょうか？</p> <ul> <li>時間計算量はアルゴリズム効率を有効に評価できます。例えばアルゴリズム <code>B</code> の実行時間は線形に増加するため、\\(n &gt; 1\\) ではアルゴリズム <code>A</code> より遅く、\\(n &gt; 1000000\\) ではアルゴリズム <code>C</code> より遅くなります。実際、入力データサイズ \\(n\\) が十分に大きければ、「定数階」のアルゴリズムは必ず「線形階」のアルゴリズムより優れます。これが実行時間の増加傾向の意味です。</li> <li>時間計算量の見積もり方法はより簡潔です。実行プラットフォームや計算操作の種類は、アルゴリズム実行時間の増加傾向とは無関係です。そのため時間計算量分析では、すべての計算操作の実行時間を同じ「単位時間」とみなしてよく、「計算操作の実行時間を数える」作業を「計算操作の個数を数える」作業へ簡略化できます。これにより見積もりの難易度は大きく下がります。</li> <li>時間計算量には一定の限界もあります。例えばアルゴリズム <code>A</code> と <code>C</code> の時間計算量は同じでも、実際の実行時間には大きな差があります。同様に、アルゴリズム <code>B</code> の時間計算量は <code>C</code> より高いものの、入力データサイズ \\(n\\) が小さい場合にはアルゴリズム <code>B</code> のほうが明らかに優れます。このような場合、時間計算量だけでアルゴリズム効率の高低を判断するのは難しいことがあります。もっとも、こうした問題があっても、複雑度分析は依然としてアルゴリズム効率を評価する最も有効で一般的な方法です。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   関数の漸近上界","text":"<p>入力サイズが \\(n\\) の次の関数を考えます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # n 回ループ\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // +1（各反復で i ++ を実行）\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // n 回ループ\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // n 回ループ\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++){ // +1（各反復で i ++ を実行）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++){ // +1（各反復で i ++ を実行）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // n 回ループ\n  for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // n 回ループ\n    for _ in 0..n { // +1（各反復で i ++ を実行）\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // +1（各反復で i ++ を実行）\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // n 回ループ\n    for (i in 0..&lt;n) { // +1（各反復で i ++ を実行）\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # n 回ループ\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>アルゴリズムの操作回数を入力データサイズ \\(n\\) の関数とし、\\(T(n)\\) と表すと、上の関数の操作回数は次のようになります：</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) は一次関数であり、実行時間の増加傾向が線形であることを示しています。したがってその時間計算量は線形階です。</p> <p>線形階の時間計算量を \\(O(n)\\) と表します。この数学記号はビッグ \\(O\\) 記法（big-\\(O\\) notation）と呼ばれ、関数 \\(T(n)\\) の漸近上界（asymptotic upper bound）を表します。</p> <p>時間計算量の分析は本質的に「操作回数 \\(T(n)\\)」の漸近上界を求めることであり、明確な数学的定義があります。</p> <p>関数の漸近上界</p> <p>正の実数 \\(c\\) と実数 \\(n_0\\) が存在し、すべての \\(n &gt; n_0\\) について \\(T(n) \\leq c \\cdot f(n)\\) が成り立つならば、\\(f(n)\\) は \\(T(n)\\) の漸近上界の 1 つであるとみなせます。これを \\(T(n) = O(f(n))\\) と記します。</p> <p>下図のように、漸近上界を求めるとは関数 \\(f(n)\\) を探すことであり、\\(n\\) が無限大へ近づくときに \\(T(n)\\) と \\(f(n)\\) が同じ増加オーダーにあり、定数係数 \\(c\\) だけが異なる状態を表します。</p> <p></p> <p> 図 2-8   関数の漸近上界 </p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   求め方","text":"<p>漸近上界はやや数学色が強い概念ですが、完全に理解できていなくても心配はいりません。まずは求め方を押さえ、実践を重ねる中で徐々にその数学的意味をつかめば十分です。</p> <p>定義より、\\(f(n)\\) が定まれば時間計算量 \\(O(f(n))\\) が得られます。では、漸近上界 \\(f(n)\\) をどのように決めればよいのでしょうか。大きく 2 段階あります。まず操作回数を数え、その後で漸近上界を判断します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-1","level":3,"title":"1.   第 1 ステップ：操作回数を数える","text":"<p>コードについては、上から下へ 1 行ずつ数えれば十分です。しかし、前述の \\(c \\cdot f(n)\\) における定数係数 \\(c\\) は任意に大きく取れるため、操作回数 \\(T(n)\\) に含まれるさまざまな係数や定数項は無視できます。この原則から、次のような簡略化のコツが得られます。</p> <ol> <li>\\(T(n)\\) 中の定数を無視する。それらはすべて \\(n\\) と無関係なので、時間計算量には影響しません。</li> <li>すべての係数を省略する。例えば \\(2n\\) 回や \\(5n + 1\\) 回のループは、いずれも \\(n\\) 回と簡略化できます。\\(n\\) の前の係数は時間計算量に影響しないからです。</li> <li>ループが入れ子のときは乗算を使う。総操作回数は外側のループと内側のループの操作回数の積に等しく、各ループ層には引き続き <code>1.</code> と <code>2.</code> のコツをそれぞれ適用できます。</li> </ol> <p>次の関数では、上記のコツを使って操作回数を数えられます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0（コツ 1）\n    a = a + n  # +0（コツ 1）\n    # +n（コツ 2）\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n（コツ 3）\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0（コツ 1）\n    a = a + n  // +0（コツ 1）\n    // +n（コツ 2）\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n（コツ 3）\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0（コツ 1）\n    a = a + n // +0（コツ 1）\n    // +n（コツ 2）\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n（コツ 3）\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（コツ 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（コツ 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0（コツ 1）\n  a = a + n; // +0（コツ 1）\n  // +n（コツ 2）\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n（コツ 3）\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0（コツ 1）\n    a = a + n;        // +0（コツ 1）\n\n    // +n（コツ 2）\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n（コツ 3）\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0（コツ 1）\n    a = a + n   // +0（コツ 1）\n    // +n（コツ 2）\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n（コツ 3）\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0（コツ 1）\n    a = a + n   # +0（コツ 1）\n    # +n（コツ 2）\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n（コツ 3）\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>次の式は、上記のコツを使う前後の集計結果を示したもので、どちらから求めても時間計算量は \\(O(n^2)\\) です。</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{厳密集計 (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{手抜き集計 (o.O)} \\end{aligned} \\]","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-2","level":3,"title":"2.   第 2 ステップ：漸近上界を判断する","text":"<p>時間計算量は \\(T(n)\\) の最高次の項によって決まります。これは、\\(n\\) が無限大に近づくとき、最高次の項が支配的となり、他の項の影響は無視できるからです。</p> <p>以下の表はその例です。いくつか極端な値を入れているのは、「係数では次数は変わらない」という結論を強調するためです。\\(n\\) が無限大に近づくと、これらの定数は重要でなくなります。</p> <p> 表 2-2   異なる操作回数に対応する時間計算量 </p> 操作回数 \\(T(n)\\) 時間計算量 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   よくある種類","text":"<p>入力データサイズを \\(n\\) とすると、よくある時間計算量の種類は次図のとおりです（小さい順に並べています）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{定数階} &lt; \\text{対数階} &lt; \\text{線形階} &lt; \\text{線形対数階} &lt; \\text{平方階} &lt; \\text{指数階} &lt; \\text{階乗階} \\end{aligned} \\] <p></p> <p> 図 2-9   よくある時間計算量の種類 </p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   定数階 \\(O(1)\\)","text":"<p>定数階の操作回数は入力データサイズ \\(n\\) と無関係であり、\\(n\\) が変化しても増減しません。</p> <p>次の関数では、操作回数 <code>size</code> が大きい可能性はありますが、入力データサイズ \\(n\\) とは無関係なので、時間計算量は依然として \\(O(1)\\) です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"定数階\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 定数階 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 定数階 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 定数階 */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 定数階 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 定数階 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 定数階 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 定数階 */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 定数階 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 定数階 ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   線形階 \\(O(n)\\)","text":"<p>線形階の操作回数は入力データサイズ \\(n\\) に対して線形に増加します。線形階は通常、単一ループに現れます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"線形階\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形階 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形階 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形階 */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形階 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形階 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形階 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形階 */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形階 */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>配列走査や連結リスト走査などの操作の時間計算量はいずれも \\(O(n)\\) であり、ここでの \\(n\\) は配列または連結リストの長さです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"線形時間（配列を走査）\"\"\"\n    count = 0\n    # ループ回数は配列長に比例する\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形時間（配列を走査） */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形時間（配列を走査） */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // ループ回数は配列長に比例する\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形時間（配列を走査） */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // ループ回数は配列長に比例する\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形時間（配列を走査） */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // ループ回数は配列長に比例する\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形時間（配列を走査） */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // ループ回数は配列長に比例する\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // ループ回数は配列長に比例する\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形時間（配列を走査） */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // ループ回数は配列長に比例する\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形時間（配列を走査） */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // ループ回数は配列長に比例する\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n\n# ## 線形階（配列を走査）###\ndef array_traversal(nums)\n  count = 0\n\n  # ループ回数は配列長に比例する\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>注意すべきなのは、**入力データサイズ \\(n\\) は入力データの型に応じて具体的に定める必要がある**ということです。例えば 1 つ目の例では変数 \\(n\\) が入力データサイズであり、2 つ目の例では配列長 \\(n\\) がデータサイズです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階の操作回数は入力データサイズ \\(n\\) に対して二乗のオーダーで増加します。平方階は通常、入れ子ループに現れ、外側のループと内側のループの時間計算量がともに \\(O(n)\\) であるため、全体の時間計算量は \\(O(n^2)\\) になります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"二乗階\"\"\"\n    count = 0\n    # ループ回数はデータサイズ n の二乗に比例する\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 二乗階 */\nint Quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 二乗階 */\nfunc quadratic(n int) int {\n    count := 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 二乗階 */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 二乗階 */\nfunction quadratic(n) {\n    let count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 二乗階 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 二乗階 */\nint quadratic(int n) {\n  int count = 0;\n  // ループ回数はデータサイズ n の二乗に比例する\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 二乗階 */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 二乗階 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図は、定数階・線形階・平方階の 3 種類の時間計算量を比較したものです。</p> <p></p> <p> 図 2-10   定数階、線形階、平方階の時間計算量 </p> <p>バブルソートを例にとると、外側のループは \\(n - 1\\) 回実行され、内側のループは \\(n-1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 回実行され、平均すると \\(n / 2\\) 回です。したがって時間計算量は \\(O((n - 1) n / 2) = O(n^2)\\) となります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"二次時間（バブルソート）\"\"\"\n    count = 0  # カウンタ\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # 要素交換には 3 回の単位操作が含まれる\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(int[] nums) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 二次時間（バブルソート） */\nint BubbleSort(int[] nums) {\n    int count = 0;  // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 二次時間（バブルソート） */\nfunc bubbleSort(nums []int) int {\n    count := 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 二次時間（バブルソート） */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 二次時間（バブルソート） */\nfunction bubbleSort(nums) {\n    let count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 二次時間（バブルソート） */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // カウンタ\n  // 外側のループ：未ソート区間は [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // 要素交換には 3 回の単位操作が含まれる\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 二次時間（バブルソート） */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // カウンタ\n\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 二次時間（バブルソート） */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   指数階 \\(O(2^n)\\)","text":"<p>生物学における「細胞分裂」は指数階増加の典型例です。初期状態では細胞が \\(1\\) 個あり、1 回分裂すると \\(2\\) 個、2 回分裂すると \\(4\\) 個となり、以下同様に、\\(n\\) 回分裂すると \\(2^n\\) 個の細胞になります。</p> <p>以下の図とコードは細胞分裂の過程を模擬したもので、時間計算量は \\(O(2^n)\\) です。なお、入力の \\(n\\) は分裂回数を表し、戻り値 <code>count</code> は総分裂回数を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"指数時間（ループ実装）\"\"\"\n    count = 0\n    base = 1\n    # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指数時間（ループ実装） */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 指数時間（ループ実装） */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 指数時間（ループ実装） */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 指数時間（ループ実装） */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指数時間（ループ実装） */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指数時間（ループ実装） */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指数時間（ループ実装） */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-11   指数階の時間計算量 </p> <p>実際のアルゴリズムでも、指数階は再帰関数によく現れます。例えば次のコードでは、再帰的に 2 つへ分岐し、\\(n\\) 回分裂した後に停止します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"指数時間（再帰実装）\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指数時間（再帰実装） */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 指数時間（再帰実装） */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 指数時間（再帰実装） */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 指数時間（再帰実装） */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指数時間（再帰実装） */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指数時間（再帰実装） */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指数時間（再帰実装） */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>指数階の増加は非常に速く、全探索法（ブルートフォース、バックトラッキングなど）によく見られます。データ規模が大きい問題では、指数階は受け入れられず、通常は動的計画法や貪欲法などを使って解く必要があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   対数階 \\(O(\\log n)\\)","text":"<p>指数階とは逆に、対数階は「各ラウンドで半分になる」状況を表します。入力データサイズを \\(n\\) とすると、各ラウンドで半減するため、ループ回数は \\(\\log_2 n\\)、すなわち \\(2^n\\) の逆関数になります。</p> <p>以下の図とコードは、「各ラウンドで半分になる」過程を模擬したもので、時間計算量は \\(O(\\log_2 n)\\)、簡潔には \\(O(\\log n)\\) と書きます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"対数時間（ループ実装）\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 対数時間（ループ実装） */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 対数時間（ループ実装） */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 対数時間（ループ実装） */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 対数時間（ループ実装） */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 対数時間（ループ実装） */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 対数時間（ループ実装） */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 対数時間（ループ実装） */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## 対数階（ループ実装）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-12   対数階の時間計算量 </p> <p>指数階と同様に、対数階も再帰関数によく現れます。次のコードは高さ \\(\\log_2 n\\) の再帰木を形成します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"対数時間（再帰実装）\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 対数時間（再帰実装） */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 対数時間（再帰実装） */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 対数時間（再帰実装） */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 対数時間（再帰実装） */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 対数時間（再帰実装） */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 対数時間（再帰実装） */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 対数時間（再帰実装） */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## 対数階（ループ実装）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n\n# ## 対数階（再帰実装）###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>対数階は分割統治に基づくアルゴリズムによく現れ、「1 つを複数に分ける」「複雑なものを単純化する」という考え方を体現しています。増加は緩やかで、定数階に次いで理想的な時間計算量です。</p> <p>\\(O(\\log n)\\) の底は何か？</p> <p>正確には、「\\(m\\) 個に分ける」場合に対応する時間計算量は \\(O(\\log_m n)\\) です。そして対数の底の変換公式により、底が異なっても同値な時間計算量が得られます：</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>つまり、底 \\(m\\) は複雑度に影響を与えずに変換できます。そのため通常は底 \\(m\\) を省略し、対数階を単に \\(O(\\log n)\\) と記します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   線形対数階 \\(O(n \\log n)\\)","text":"<p>線形対数階は入れ子ループによく現れ、2 層のループの時間計算量はそれぞれ \\(O(\\log n)\\) と \\(O(n)\\) です。関連するコードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"線形対数時間\"\"\"\n    if n &lt;= 1:\n        return 1\n    # 二つに分割すると、部分問題の規模は半分になる\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # 現在の部分問題には n 個の操作が含まれる\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形対数時間 */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形対数時間 */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形対数時間 */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形対数時間 */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形対数時間 */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形対数時間 */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形対数時間 */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形対数時間 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は線形対数階がどのように生じるかを示しています。二分木の各層の操作総数はすべて \\(n\\) であり、木全体は \\(\\log_2 n + 1\\) 層あるため、時間計算量は \\(O(n \\log n)\\) です。</p> <p></p> <p> 図 2-13   線形対数階の時間計算量 </p> <p>主なソートアルゴリズムの時間計算量は通常 \\(O(n \\log n)\\) であり、例えばクイックソート、マージソート、ヒープソートなどがあります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   階乗階 \\(O(n!)\\)","text":"<p>階乗階は、数学における「全順列」の問題に対応します。互いに重複しない \\(n\\) 個の要素が与えられたとき、そのすべての並べ方を求めると、通り数は次のようになります：</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>階乗は通常、再帰で実装されます。以下の図とコードのように、第 1 層では \\(n\\) 個に分岐し、第 2 層では \\(n - 1\\) 個に分岐し、以下同様に、第 \\(n\\) 層で分岐が停止します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"階乗時間（再帰実装）\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # 1個から n 個に分裂\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 階乗時間（再帰実装） */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 階乗時間（再帰実装） */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // 1個から n 個に分裂\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 階乗時間（再帰実装） */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // 1個から n 個に分裂\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 階乗時間（再帰実装） */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // 1個から n 個に分裂\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 階乗時間（再帰実装） */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // 1個から n 個に分裂\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // 1個から n 個に分裂\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 階乗時間（再帰実装） */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // 1個から n 個に分裂\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 階乗時間（再帰実装） */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // 1個から n 個に分裂\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形対数時間 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n\n# ## 階乗階（再帰実装）###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # 1個から n 個に分裂\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-14   階乗階の時間計算量 </p> <p>注意すべき点として、\\(n \\geq 4\\) なら常に \\(n! &gt; 2^n\\) なので、階乗階は指数階よりもさらに速く増加し、\\(n\\) が大きい場合にはやはり受け入れられません。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   最悪・最良・平均時間計算量","text":"<p>アルゴリズムの時間効率は固定ではなく、入力データの分布に左右されることが多いです。長さ \\(n\\) の配列 <code>nums</code> を考えます。<code>nums</code> は \\(1\\) から \\(n\\) までの数字で構成され、各数字は 1 回だけ現れます。ただし要素の順序はランダムにシャッフルされており、目標は要素 \\(1\\) のインデックスを返すことです。ここから次の結論が得られます。</p> <ul> <li><code>nums = [?, ?, ..., 1]</code>、つまり末尾の要素が \\(1\\) の場合は、配列全体を最後まで走査する必要があり、最悪時間計算量 \\(O(n)\\) になります。</li> <li><code>nums = [1, ?, ?, ...]</code>、つまり先頭要素が \\(1\\) の場合は、配列がどれだけ長くてもそれ以上走査する必要がなく、最良時間計算量 \\(\\Omega(1)\\) になります。</li> </ul> <p>「最悪時間計算量」は関数の漸近上界に対応し、ビッグ \\(O\\) 記法で表します。同様に、「最良時間計算量」は関数の漸近下界に対応し、\\(\\Omega\\) 記法で表します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"要素が 1, 2, ..., n で順序がシャッフルされた配列を生成する\"\"\"\n    # 配列 nums =: 1, 2, 3, ..., n を生成する\n    nums = [i for i in range(1, n + 1)]\n    # 配列要素をランダムにシャッフル\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"配列 nums 内で数値 1 のインデックスを探す\"\"\"\n    for i in range(len(nums)):\n        # 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        # 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // システム時刻を使って乱数シードを生成する\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // 配列要素をランダムにシャッフル\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // 配列要素をランダムにシャッフル\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // 配列要素をランダムにシャッフル\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    var nums = Array(1 ... n)\n    // 配列要素をランダムにシャッフル\n    nums.shuffle()\n    return nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // 配列 nums = { 1, 2, 3, ..., n } を生成\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // 配列要素をランダムにシャッフル\n  nums.shuffle();\n\n  return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n    // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // 配列要素をランダムにシャッフル\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint *randomNumbers(int n) {\n    // ヒープ領域にメモリを確保する（要素数 n、要素型 int の一次元可変長配列を作成）\n    int *nums = (int *)malloc(n * sizeof(int));\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // 配列要素をランダムにシャッフル\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### 1, 2, ..., n を要素とする配列を生成し、順序をシャッフルする ###\ndef random_numbers(n)\n  # 配列 nums =: 1, 2, 3, ..., n を生成する\n  nums = Array.new(n) { |i| i + 1 }\n  # 配列要素をランダムにシャッフル\n  nums.shuffle!\nend\n\n### 配列 nums 内の数値 1 のインデックスを探す ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n    # 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>実際には、最良時間計算量を使うことはあまりありません。通常それが実現する確率はごく低く、誤解を招く可能性があるからです。**一方で最悪時間計算量はより実用的で、効率の安全側の目安を与えてくれる**ため、安心してアルゴリズムを使えます。</p> <p>上の例から分かるように、最悪時間計算量と最良時間計算量は「特殊なデータ分布」でのみ現れ、その発生確率は低いことが多く、アルゴリズムの実行効率をそのまま正確に反映するわけではありません。それに対して、**平均時間計算量はランダム入力におけるアルゴリズムの実行効率を表せる**ため、\\(\\Theta\\) 記法で表します。</p> <p>一部のアルゴリズムでは、ランダムなデータ分布における平均的な状況を比較的簡単に求められます。例えば上の例では、入力配列はシャッフルされているため、要素 \\(1\\) が任意のインデックスに現れる確率は等しいです。したがってアルゴリズムの平均ループ回数は配列長の半分 \\(n / 2\\) となり、平均時間計算量は \\(\\Theta(n / 2) = \\Theta(n)\\) です。</p> <p>しかし、より複雑なアルゴリズムでは、平均時間計算量を計算するのはしばしば困難です。データ分布に対する全体の数学的期待値を分析するのが難しいからです。そのような場合、通常は最悪時間計算量をアルゴリズム効率の評価基準として用います。</p> <p>なぜ \\(\\Theta\\) 記号をあまり見かけないのか？</p> <p>おそらく \\(O\\) 記号のほうが口にしやすいため、平均時間計算量を表すのにもよく使われます。ただし厳密には、この用法は正確ではありません。本書や他の資料で「平均時間計算量 \\(O(n)\\)」のような表現を見かけた場合は、そのまま \\(\\Theta(n)\\) と理解してください。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"第 3 章   データ構造","text":"<p>Abstract</p> <p>データ構造は、堅固で多様な枠組みのようなものである。</p> <p>それはデータを秩序立てて組織するための青写真を示し、アルゴリズムはその上で生き生きと動き出す。</p>","path":["第 3 章 &nbsp; データ構造"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"章の内容","text":"<ul> <li>3.1   データ構造の分類</li> <li>3.2   基本データ型</li> <li>3.3   数値エンコーディング *</li> <li>3.4   文字エンコーディング *</li> <li>3.5   まとめ</li> </ul>","path":["第 3 章 &nbsp; データ構造"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   基本データ型","text":"<p>コンピュータ内のデータについて考えるとき、テキスト、画像、動画、音声、3D モデルなど、さまざまな形態を思い浮かべます。これらのデータの構成形式はそれぞれ異なりますが、いずれも各種の基本データ型によって成り立っています。</p> <p>**基本データ型は CPU が直接演算できる型**であり、アルゴリズムの中で直接使われます。主なものは次のとおりです。</p> <ul> <li>整数型 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> 。</li> <li>浮動小数点数型 <code>float</code>、<code>double</code> ，小数を表すために使います。</li> <li>文字型 <code>char</code> ，各言語の文字、句読点、さらには絵文字などを表すために使います。</li> <li>真偽値型 <code>bool</code> ，真か偽かの判定を表すために使います。</li> </ul> <p>基本データ型はコンピュータ内で 2 進数の形で格納されます。1 つの二進桁は \\(1\\) ビットです。現代のほとんどのオペレーティングシステムでは、\\(1\\) バイト（byte）は \\(8\\) ビット（bit）で構成されます。</p> <p>基本データ型の値域は、その型が占める領域の大きさによって決まります。以下では Java を例に取ります。</p> <ul> <li>整数型 <code>byte</code> は \\(1\\) バイト = \\(8\\) ビットを占め、\\(2^{8}\\) 個の数を表せます。</li> <li>整数型 <code>int</code> は \\(4\\) バイト = \\(32\\) ビットを占め、\\(2^{32}\\) 個の数を表せます。</li> </ul> <p>下表は、Java における各種基本データ型の使用領域、値域、デフォルト値を示したものです。この表を丸暗記する必要はなく、大まかに理解しておけば十分であり、必要になったときに参照すればかまいません。</p> <p> 表 3-1   基本データ型の使用領域と値域 </p> 型 記号 使用領域 最小値 最大値 デフォルト値 整数 <code>byte</code> 1 バイト \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 バイト \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 バイト \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 バイト \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) 浮動小数点数 <code>float</code> 4 バイト \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 バイト \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) 文字 <code>char</code> 2 バイト \\(0\\) \\(2^{16} - 1\\) \\(0\\) 真偽値 <code>bool</code> 1 バイト \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>注意してください。上表は Java の基本データ型に対するものです。各プログラミング言語にはそれぞれ独自のデータ型定義があり、使用領域、値域、デフォルト値は異なる場合があります。</p> <ul> <li>Python では、整数型 <code>int</code> は利用可能なメモリに制限されるだけで任意の大きさを取れます。浮動小数点数 <code>float</code> は倍精度 64 ビットです。<code>char</code> 型はなく、1 文字は実際には長さ 1 の文字列 <code>str</code> です。</li> <li>C と C++ では基本データ型の大きさは明確に規定されておらず、実装やプラットフォームによって異なります。上表は LP64 データモデル に従っており、Linux や macOS を含む Unix 系 64 ビット OS で用いられています。</li> <li><code>char</code> の大きさは C と C++ では 1 バイトですが、多くのプログラミング言語では採用する文字エンコーディング方式によって決まります。詳しくは「文字エンコーディング」の章を参照してください。</li> <li>真偽値を表すのに必要なのは 1 ビット（\\(0\\) または \\(1\\)）だけですが、メモリ上では通常 1 バイトとして格納されます。これは、現代のコンピュータ CPU が通常 1 バイトを最小のアドレス指定可能なメモリ単位としているためです。</li> </ul> <p>では、基本データ型とデータ構造の間にはどのような関係があるのでしょうか。データ構造とは、コンピュータ内でデータを組織し格納する方法のことです。この言葉で主役なのは「データ」ではなく「構造」です。</p> <p>「数字の並び」を表したいなら、自然に配列の使用を思い浮かべるでしょう。これは、配列の線形構造が数字どうしの隣接関係や順序関係を表せるからです。しかし、格納する内容が整数 <code>int</code> なのか、小数 <code>float</code> なのか、文字 <code>char</code> なのかは、「データ構造」とは関係ありません。</p> <p>言い換えると、基本データ型はデータの「内容の型」を提供し、データ構造はデータの「組織方法」を提供します。たとえば次のコードでは、同じデータ構造（配列）を使って <code>int</code>、<code>float</code>、<code>char</code>、<code>bool</code> など異なる基本データ型を格納・表現しています。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># さまざまな基本データ型で配列を初期化する\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python の文字は実際には長さ 1 の文字列\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python のリストはさまざまな基本データ型とオブジェクト参照を自由に格納できる\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript の配列はさまざまな基本データ型とオブジェクトを自由に格納できる\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby のリストはさまざまな基本データ型とオブジェクト参照を自由に格納できる\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E4%BD%BF%E7%94%A8%E5%A4%9A%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20*%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%AD%97%E7%AC%A6%E5%AE%9E%E9%99%85%E4%B8%8A%E6%98%AF%E9%95%BF%E5%BA%A6%E4%B8%BA%201%20%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%0A%20%20%20%20characters%20%3D%20%5B'0'%5D%20*%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%88%97%E8%A1%A8%E5%8F%AF%E4%BB%A5%E8%87%AA%E7%94%B1%E5%AD%98%E5%82%A8%E5%90%84%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%AF%B9%E8%B1%A1%E5%BC%95%E7%94%A8%0A%20%20%20%20data%20%3D%20%5B0,%200.0,%20'a',%20False,%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 3 章 &nbsp; データ構造","3.2 &nbsp; 基本データ型"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   文字エンコーディング *","text":"<p>コンピュータでは、すべてのデータは二進数の形で保存されており、文字 <code>char</code> も例外ではありません。文字を表すためには、「文字セット」を定義し、各文字と二進数の間の一対一の対応関係を定める必要があります。文字セットがあれば、コンピュータは対応表を参照して二進数から文字への変換を行えます。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   ASCII 文字セット","text":"<p>ASCII コードは最も早く登場した文字セットで、その正式名称は American Standard Code for Information Interchange（米国標準情報交換コード）です。これは 7 ビットの二進数（1 バイトの下位 7 ビット）で 1 文字を表し、最大で 128 種類の異なる文字を表現できます。下図のように、ASCII コードには英字の大文字と小文字、数字 0 ~ 9、いくつかの句読点、そしていくつかの制御文字（改行やタブなど）が含まれます。</p> <p></p> <p> 図 3-6   ASCII コード </p> <p>しかし、ASCII コードで表現できるのは英語だけです。コンピュータのグローバル化に伴い、より多くの言語を表せる EASCII 文字セットが生まれました。これは ASCII の 7 ビットを 8 ビットへ拡張したもので、256 種類の異なる文字を表現できます。</p> <p>世界では、さまざまな地域に適した EASCII 文字セットが次々に登場しました。これらの文字セットでは、前半の 128 文字は ASCII コードで統一され、後半の 128 文字は各言語の要件に合わせて個別に定義されています。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   GBK 文字セット","text":"<p>その後、人々は**EASCII コードでも多くの言語に必要な文字数を満たせない**ことに気づきました。たとえば漢字は 10 万字近くあり、日常的に使うものだけでも数千字あります。中国国家標準総局は 1980 年に GB2312 文字セットを公開し、6763 字の漢字を収録して、漢字のコンピュータ処理の基本的な需要を満たしました。</p> <p>しかし、GB2312 では一部の珍しい字や繁体字を扱えません。GBK 文字セットは GB2312 を基に拡張されたもので、合計 21886 字の漢字を収録しています。GBK のエンコーディング方式では、ASCII 文字は 1 バイト、漢字は 2 バイトで表されます。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Unicode 文字セット","text":"<p>コンピュータ技術が急速に発展するにつれて、文字セットと符号化規格は百花繚乱の状態となり、それに伴って多くの問題も生じました。一方では、これらの文字セットは通常、特定の言語の文字しか定義しておらず、多言語環境では正常に動作できませんでした。もう一方では、同じ言語にも複数の文字セット規格が存在し、2 台のコンピュータが異なる符号化規格を使っていると、情報伝達の際に文字化けが発生しました。</p> <p>当時の研究者たちはこう考えました。十分に完全な文字セットを打ち出して、世界中のあらゆる言語と記号をそこに収録すれば、多言語環境や文字化けの問題を解決できるのではないか。この発想に後押しされて、大規模で包括的な文字セット Unicode が誕生しました。</p> <p>Unicode の中国語名は「統一コード」であり、理論上は 100 万を超える文字を収容できます。Unicode は世界中の文字を 1 つの文字セットに統合することを目指し、さまざまな言語の文字を処理・表示できる汎用文字セットを提供することで、符号化規格の違いによる文字化けを減らそうとしています。</p> <p>1991 年の公開以来、Unicode は新しい言語と文字を継続的に拡充してきました。2022 年 9 月時点で、Unicode にはすでに 149186 文字が含まれており、各種言語の文字、記号、さらには絵文字まで収録されています。巨大な Unicode 文字セットでは、よく使われる文字は 2 バイトを占め、一部の珍しい文字は 3 バイト、さらには 4 バイトを占めます。</p> <p>Unicode は汎用文字セットであり、本質的には各文字に番号（「コードポイント」）を割り当てるものですが、それらのコードポイントをコンピュータ内でどのように保存するかまでは規定していません。ここで疑問が生じます。長さの異なる Unicode コードポイントが同じテキストに現れたとき、システムはどのように文字を解析するのでしょうか。たとえば長さ 2 バイトの符号が与えられたとき、それが 2 バイトの 1 文字なのか、1 バイトの 2 文字なのかをどう判定するのでしょうか。</p> <p>この問題に対して、**すべての文字を固定長の符号として保存する**という直接的な解決策があります。下図のように、「Hello」の各文字は 1 バイト、「アルゴリズム」の各文字は 2 バイトを占めます。上位ビットを 0 で埋めることで、「Hello アルゴリズム」のすべての文字を 2 バイト長にエンコードできます。こうすれば、システムは 2 バイトごとに 1 文字を解析して、この語句の内容を復元できます。</p> <p></p> <p> 図 3-7   Unicode エンコーディングの例 </p> <p>しかし ASCII コードはすでに、英語の符号化には 1 バイトで十分であることを示しています。上記の方式を採用すると、英語のテキストが占める空間は ASCII エンコーディング時の 2 倍になり、メモリ空間の浪費が大きくなります。そのため、より効率的な Unicode エンコーディング方式が必要です。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   UTF-8 エンコーディング","text":"<p>現在、UTF-8 は国際的に最も広く使われている Unicode エンコーディング方式になっています。**これは可変長のエンコーディング**であり、1 文字を 1 〜 4 バイトで表し、文字の複雑さに応じて長さが変わります。ASCII 文字は 1 バイト、ラテン文字とギリシャ文字は 2 バイト、一般的な漢字は 3 バイト、そのほかの一部の珍しい文字は 4 バイト必要です。</p> <p>UTF-8 の符号化規則はそれほど複雑ではなく、次の 2 つのケースに分けられます。</p> <ul> <li>長さ 1 バイトの文字では、最上位ビットを \\(0\\) にし、残りの 7 ビットを Unicode コードポイントに設定します。ここで注意すべきなのは、ASCII 文字が Unicode 文字セットの先頭 128 個のコードポイントを占めていることです。つまり、UTF-8 エンコーディングは ASCII コードと下位互換性があります。このため、UTF-8 を使って古い ASCII コードのテキストを解析できます。</li> <li>長さ \\(n\\) バイトの文字（ただし \\(n &gt; 1\\)）では、先頭バイトの上位 \\(n\\) ビットをすべて \\(1\\) にし、第 \\(n + 1\\) ビットを \\(0\\) に設定します。2 バイト目以降では、各バイトの上位 2 ビットをいずれも \\(10\\) にし、残りのすべてのビットで文字の Unicode コードポイントを埋めます。</li> </ul> <p>下図は「Helloアルゴリズム」に対応する UTF-8 エンコーディングを示しています。観察すると、上位 \\(n\\) ビットがすべて \\(1\\) に設定されているため、システムは先頭から連続する \\(1\\) の個数を読むことで、その文字の長さが \\(n\\) であると解析できます。</p> <p>では、なぜ残りのすべてのバイトの上位 2 ビットを \\(10\\) にするのでしょうか。実は、この \\(10\\) は検査用の印として機能します。システムが誤ったバイト位置からテキストを解析し始めたとしても、バイト先頭の \\(10\\) によって異常を素早く判定できます。</p> <p>この \\(10\\) を検査用の印とする理由は、UTF-8 の符号化規則では上位 2 ビットが \\(10\\) になる文字は存在しないからです。この結論は背理法で証明できます。ある文字の上位 2 ビットが \\(10\\) だと仮定すると、その文字の長さは \\(1\\) であり、ASCII コードに対応することになります。しかし ASCII コードの最上位ビットは \\(0\\) であるはずなので、仮定と矛盾します。</p> <p></p> <p> 図 3-8   UTF-8 エンコーディングの例 </p> <p>UTF-8 以外にも、一般的なエンコーディング方式として次の 2 つがあります。</p> <ul> <li>UTF-16 エンコーディング：1 文字を 2 バイトまたは 4 バイトで表します。すべての ASCII 文字と一般的な非英語文字は 2 バイトで表し、一部の文字だけが 4 バイトを必要とします。2 バイトの文字については、UTF-16 エンコーディングは Unicode コードポイントと等しくなります。</li> <li>UTF-32 エンコーディング：各文字を必ず 4 バイトで表します。つまり UTF-32 は UTF-8 や UTF-16 よりも多くの領域を消費し、とくに ASCII 文字の比率が高いテキストでその傾向が顕著です。</li> </ul> <p>記憶領域の使用量という観点では、UTF-8 は英語文字の表現に非常に効率的で、必要なのは 1 バイトだけです。一方、UTF-16 は一部の非英語文字（たとえば中国語の文字）の符号化でより効率的になることがあり、必要なのは 2 バイトだけで、UTF-8 では 3 バイト必要になる場合があります。</p> <p>互換性という観点では、UTF-8 の汎用性が最も高く、多くのツールやライブラリが UTF-8 を優先的にサポートしています。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   プログラミング言語の文字エンコーディング","text":"<p>従来の多くのプログラミング言語では、実行中の文字列に UTF-16 や UTF-32 のような固定長エンコーディングが使われています。固定長エンコーディングでは、文字列を配列のように扱えるため、次のような利点があります。</p> <ul> <li>ランダムアクセス：UTF-16 で符号化された文字列はランダムアクセスが容易です。UTF-8 は可変長エンコーディングなので、第 \\(i\\) 文字を見つけるには文字列の先頭から第 \\(i\\) 文字まで走査する必要があり、\\(O(n)\\) の時間がかかります。</li> <li>文字数の計算：ランダムアクセスと同様に、UTF-16 で符号化された文字列の長さを計算するのも \\(O(1)\\) の操作です。しかし、UTF-8 で符号化された文字列の長さを計算するには、文字列全体を走査する必要があります。</li> <li>文字列操作：UTF-16 で符号化された文字列では、多くの文字列操作（分割、連結、挿入、削除など）をより簡単に行えます。UTF-8 で符号化された文字列では、これらの操作を行う際に、無効な UTF-8 エンコーディングを生じさせないための追加計算が通常必要になります。</li> </ul> <p>実際、プログラミング言語における文字エンコーディング方式の設計は、とても興味深い話題であり、多くの要因が関わっています。</p> <ul> <li>Java の <code>String</code> 型は UTF-16 エンコーディングを使用し、各文字は 2 バイトを占めます。これは Java 言語の設計当初、人々が 16 ビットあればあらゆる文字を表現するのに十分だと考えていたためです。しかし、これは誤った判断でした。その後 Unicode 規格は 16 ビットを超える範囲へ拡張されたため、現在の Java では 1 文字が 16 ビット値の組（「サロゲートペア」）で表されることがあります。</li> <li>JavaScript と TypeScript の文字列が UTF-16 エンコーディングを使う理由も Java と似ています。1995 年に Netscape 社が初めて JavaScript 言語を公開した当時、Unicode はまだ発展初期にあり、16 ビットの符号化で十分すべての Unicode 文字を表せると考えられていました。</li> <li>C# が UTF-16 エンコーディングを使う主な理由は、.NET プラットフォームが Microsoft によって設計され、Microsoft の多くの技術（Windows オペレーティングシステムを含む）で UTF-16 エンコーディングが広く使われているためです。</li> </ul> <p>以上のプログラミング言語は文字数を過小評価していたため、16 ビットを超える長さの Unicode 文字を表すために「サロゲートペア」を採用せざるを得ませんでした。これはやむを得ない妥協策です。一方では、サロゲートペアを含む文字列では、1 文字が 2 バイトまたは 4 バイトを占める可能性があり、固定長エンコーディングの利点が失われます。もう一方では、サロゲートペアの処理には追加のコードが必要となり、プログラミングの複雑さとデバッグの難しさが増します。</p> <p>こうした理由から、一部のプログラミング言語では別のエンコーディング方式が採用されました。</p> <ul> <li>Python の <code>str</code> は Unicode エンコーディングを使用し、柔軟な文字列表現を採用しています。保存される文字の長さは、その文字列中で最大の Unicode コードポイントに依存します。文字列がすべて ASCII 文字であれば各文字は 1 バイト、ASCII の範囲を超える文字があってもすべてが基本多言語面（BMP）内であれば各文字は 2 バイト、BMP を超える文字があれば各文字は 4 バイトを占めます。</li> <li>Go 言語の <code>string</code> 型は内部で UTF-8 エンコーディングを使用します。Go 言語には単一の Unicode コードポイントを表す <code>rune</code> 型も用意されています。</li> <li>Rust 言語の <code>str</code> と <code>String</code> 型は内部で UTF-8 エンコーディングを使用します。Rust にも単一の Unicode コードポイントを表す <code>char</code> 型があります。</li> </ul> <p>注意すべきなのは、ここまでの議論はすべて、プログラミング言語内での文字列の保存方法についてであり、**文字列をファイルに保存したりネットワークで転送したりする方法とは別の問題である**ということです。ファイル保存やネットワーク転送では、通常、互換性と空間効率を最適化するために文字列を UTF-8 形式にエンコードします。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   データ構造の分類","text":"<p>代表的なデータ構造には、配列、連結リスト、スタック、キュー、ハッシュテーブル、木、ヒープ、グラフがあり、これらは「論理構造」と「物理構造」の 2 つの観点から分類できます。</p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   論理構造：線形と非線形","text":"<p>論理構造はデータ要素間の論理的な関係を示します。配列と連結リストでは、データは一定の順序で並び、データ間の線形関係を表します。一方、木ではデータは上から下へ階層的に並び、「祖先」と「子孫」の派生関係を示します。グラフはノードと辺で構成され、複雑なネットワーク関係を反映します。</p> <p>以下の図に示すように、論理構造は「線形」と「非線形」の 2 つに大別できます。線形構造は比較的直感的で、データが論理関係において線形に並ぶことを指します。非線形構造はその逆で、非線形に配置されます。</p> <ul> <li>線形データ構造：配列、連結リスト、スタック、キュー、ハッシュテーブルであり、要素間は 1 対 1 の順序関係です。</li> <li>非線形データ構造：木、ヒープ、グラフ、ハッシュテーブル。</li> </ul> <p>非線形データ構造は、さらに木構造と網状構造に分けられます。</p> <ul> <li>木構造：木、ヒープ、ハッシュテーブルであり、要素間は 1 対多の関係です。</li> <li>網状構造：グラフであり、要素間は多対多の関係です。</li> </ul> <p></p> <p> 図 3-1   線形データ構造と非線形データ構造 </p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   物理構造：連続と分散","text":"<p>アルゴリズムのプログラムが実行されるとき、処理中のデータは主にメモリに格納されます。下図はコンピュータのメモリモジュールを示しており、各黒い四角はそれぞれ 1 つのメモリ空間を表しています。メモリは巨大な Excel の表のようなものだと考えることができ、各セルには一定量のデータを格納できます。</p> <p>システムはメモリアドレスを通じて目的の位置にあるデータへアクセスします。下図に示すように、コンピュータは特定の規則に従って表内の各セルに番号を割り当て、各メモリ空間が一意のメモリアドレスを持つようにします。これらのアドレスがあれば、プログラムはメモリ内のデータにアクセスできます。</p> <p></p> <p> 図 3-2   メモリモジュール、メモリ空間、メモリアドレス </p> <p>Tip</p> <p>補足すると、メモリを Excel の表にたとえるのは単純化した比喩であり、実際のメモリの動作機構はより複雑で、アドレス空間、メモリ管理、キャッシュ機構、仮想メモリ、物理メモリなどの概念が関わります。</p> <p>メモリはすべてのプログラムで共有される資源であり、あるメモリ領域が 1 つのプログラムに占有されると、通常は他のプログラムが同時に利用できません。したがって、データ構造とアルゴリズムの設計では、メモリ資源は重要な考慮要素です。たとえば、アルゴリズムが使用するメモリ使用量のピークは、システムに残っている空きメモリを超えてはなりません。大きな連続メモリ領域が不足している場合、選択するデータ構造は分散したメモリ空間に格納できる必要があります。</p> <p>下図に示すように、物理構造はデータがコンピュータメモリ内にどのように格納されるかを表します。これは連続空間への格納（配列）と分散空間への格納（連結リスト）に分けられます。物理構造は低レベルでデータのアクセス、更新、追加、削除などの操作方法を決定し、2 種類の物理構造は時間効率と空間効率の面で相補的な特徴を持ちます。</p> <p></p> <p> 図 3-3   連続空間格納と分散空間格納 </p> <p>補足すると、すべてのデータ構造は配列、連結リスト、またはその両者の組み合わせに基づいて実装されます。たとえば、スタックとキューは配列でも連結リストでも実装できます。一方、ハッシュテーブルの実装には配列と連結リストの両方が含まれる場合があります。</p> <ul> <li>配列に基づいて実装可能：スタック、キュー、ハッシュテーブル、木、ヒープ、グラフ、行列、テンソル（次元 \\(\\geq 3\\) の配列）など。</li> <li>連結リストに基づいて実装可能：スタック、キュー、ハッシュテーブル、木、ヒープ、グラフなど。</li> </ul> <p>連結リストは初期化後も、プログラムの実行中に長さを調整できるため、「動的データ構造」とも呼ばれます。配列は初期化後に長さを変更できないため、「静的データ構造」とも呼ばれます。なお、配列もメモリを再割り当てすることで長さを変更でき、ある程度の「動的性」を持たせることができます。</p> <p>Tip</p> <p>物理構造の理解が難しいと感じる場合は、先に次の章を読んでから本節を振り返ることを勧めます。</p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   数値エンコーディング *","text":"<p>Tip</p> <p>本書では、タイトルに * 記号が付いている章は選読です。時間が限られている場合や理解が難しいと感じる場合は、いったん読み飛ばし、必読章を終えてから個別に取り組んでください。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331-1-2","level":2,"title":"3.3.1   符号付き絶対値表現、1 の補数、2 の補数","text":"<p>前節の表を見ると、すべての整数型で表せる負数の個数は正数より 1 つ多く、たとえば <code>byte</code> の値域は \\([-128, 127]\\) です。この現象は直感に反するように見えますが、その背景には符号付き絶対値表現、1 の補数、2 の補数に関する知識があります。</p> <p>まず押さえておくべきなのは、**数値はコンピュータ内で「2 の補数」の形で保存される**ということです。その理由を説明する前に、まずはこの 3 つの定義を示します。</p> <ul> <li>符号付き絶対値表現：数値の二進表現の最上位ビットを符号ビットとみなし、\\(0\\) は正数、\\(1\\) は負数を表し、残りのビットが数値の値を表します。</li> <li>1 の補数：正数の 1 の補数は符号付き絶対値表現と同じで、負数の 1 の補数は符号ビットを除くすべてのビットを反転したものです。</li> <li>2 の補数：正数の 2 の補数は符号付き絶対値表現と同じで、負数の 2 の補数は 1 の補数に \\(1\\) を加えたものです。</li> </ul> <p>下図は、符号付き絶対値表現、1 の補数、2 の補数の変換方法を示しています。</p> <p></p> <p> 図 3-4   符号付き絶対値表現、1 の補数、2 の補数の相互変換 </p> <p>符号付き絶対値表現（sign-magnitude）は最も直感的ですが、いくつかの制約があります。まず、負数の符号付き絶対値表現はそのまま演算に使えません。たとえば符号付き絶対値表現で \\(1 + (-2)\\) を計算すると、結果は \\(-3\\) になってしまい、これは明らかに誤りです。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>この問題を解決するために、コンピュータには1 の補数（1's complement）が導入されました。まず符号付き絶対値表現を 1 の補数に変換し、1 の補数で \\(1 + (-2)\\) を計算してから、結果を 1 の補数から符号付き絶対値表現へ戻すと、正しい結果 \\(-1\\) が得られます。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(符号付き絶対値表現)} + 1000 \\; 0010 \\; \\text{(符号付き絶対値表現)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(1 の補数)} + 1111  \\; 1101 \\; \\text{(1 の補数)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(1 の補数)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(符号付き絶対値表現)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>一方、数値 0 の符号付き絶対値表現には \\(+0\\) と \\(-0\\) の 2 つの表し方があります。つまり、数値 0 に対して異なる 2 つの二進コードが対応しており、これは曖昧さの原因になります。たとえば条件判定で正のゼロと負のゼロを区別しないと、誤った判定結果になる可能性があります。また、この曖昧さを解消しようとすると追加の判定処理が必要になり、計算効率が下がるおそれがあります。</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>符号付き絶対値表現と同様に、1 の補数にも正負のゼロの曖昧さがあります。そこでコンピュータはさらに2 の補数（2's complement）を導入しました。まずは負のゼロについて、符号付き絶対値表現、1 の補数、2 の補数の変換を見てみましょう。</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(符号付き絶対値表現)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(1 の補数)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(2 の補数)} \\newline \\end{aligned} \\] <p>負のゼロの 1 の補数に \\(1\\) を加えると桁上がりが発生しますが、<code>byte</code> 型の長さは 8 ビットしかないため、第 9 ビットへあふれた \\(1\\) は捨てられます。つまり、負のゼロの 2 の補数は \\(0000 \\; 0000\\) であり、正のゼロの 2 の補数と同じです。そのため、2 の補数表現ではゼロは 1 つしか存在せず、正負のゼロの曖昧さは解消されます。</p> <p>最後にもう 1 つ疑問が残ります。<code>byte</code> 型の値域は \\([-128, 127]\\) ですが、余分にある負数 \\(-128\\) はどのように得られるのでしょうか。区間 \\([-127, +127]\\) にあるすべての整数には、それぞれ対応する符号付き絶対値表現、1 の補数、2 の補数があり、符号付き絶対値表現と 2 の補数の間は相互に変換できます。</p> <p>しかし、2 の補数 \\(1000 \\; 0000\\) だけは例外で、対応する符号付き絶対値表現を持ちません。変換規則に従うと、この 2 の補数に対応する符号付き絶対値表現は \\(0000 \\; 0000\\) になります。これは明らかに矛盾しています。なぜなら、この符号付き絶対値表現は数値 \\(0\\) を表し、その 2 の補数は自分自身であるはずだからです。コンピュータでは、この特別な 2 の補数 \\(1000 \\; 0000\\) を \\(-128\\) と定めています。実際、2 の補数での \\((-1) + (-127)\\) の計算結果はちょうど \\(-128\\) になります。</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(符号付き絶対値表現)} + 1000 \\; 0001 \\; \\text{(符号付き絶対値表現)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(1 の補数)} + 1111  \\; 1110 \\; \\text{(1 の補数)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(2 の補数)} + 1111  \\; 1111 \\; \\text{(2 の補数)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(2 の補数)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>すでにお気づきかもしれませんが、上の計算はすべて加算です。これは重要な事実を示しています。**コンピュータ内部のハードウェア回路は、主として加算を基準に設計されている**のです。なぜなら、加算はほかの演算（乗算、除算、減算など）に比べてハードウェアで実装しやすく、並列化もしやすく、演算速度も速いからです。</p> <p>ただし、これはコンピュータが加算しかできないという意味ではありません。加算といくつかの基本的な論理演算を組み合わせることで、コンピュータはさまざまな数学演算を実現できます。たとえば減算 \\(a - b\\) は加算 \\(a + (-b)\\) に変換できますし、乗算や除算も繰り返しの加算または減算に変換できます。</p> <p>これで、コンピュータが 2 の補数を使う理由をまとめられます。2 の補数表現に基づけば、コンピュータは同じ回路と操作で正数と負数の加算を扱うことができ、減算専用の特別なハードウェア回路を設計する必要がなく、正負のゼロの曖昧さも特別に処理しなくて済みます。これにより、ハードウェア設計は大幅に簡略化され、演算効率も向上します。</p> <p>2 の補数の設計は非常に巧妙ですが、紙幅の都合上ここまでにします。興味のある読者は、さらに深く調べてみてください。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   浮動小数点数のエンコーディング","text":"<p>注意深い人なら気づくかもしれません。<code>int</code> と <code>float</code> はどちらも長さが 4 バイトで同じなのに、なぜ <code>float</code> の値域は <code>int</code> よりはるかに広いのでしょうか。これはかなり直感に反します。というのも、<code>float</code> は小数を表す必要があるので、本来なら値域は狭くなるはずだからです。</p> <p>実際には、これは浮動小数点数 <code>float</code> が異なる表現方法を採用しているためです。32 ビット長の二進数を次のように表します。</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>IEEE 754 標準によれば、32-bit 長の <code>float</code> は次の 3 つの部分から構成されます。</p> <ul> <li>符号部 \\(\\mathrm{S}\\) ：1 ビットを占め、\\(b_{31}\\) に対応します。</li> <li>指数部 \\(\\mathrm{E}\\) ：8 ビットを占め、\\(b_{30} b_{29} \\ldots b_{23}\\) に対応します。</li> <li>仮数部 \\(\\mathrm{N}\\) ：23 ビットを占め、\\(b_{22} b_{21} \\ldots b_0\\) に対応します。</li> </ul> <p>二進数 <code>float</code> に対応する値は次式で計算されます。</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>十進数に直すと、計算式は次のようになります。</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>各項の取り得る範囲は次のとおりです。</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> 図 3-5   IEEE 754 標準における float の計算例 </p> <p>上図を見ると、例として \\(\\mathrm{S} = 0\\) 、 \\(\\mathrm{E} = 124\\) 、\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) が与えられた場合、次のようになります。</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>これで最初の疑問に答えられます。**<code>float</code> の表現方法には指数部が含まれているため、その値域は <code>int</code> よりはるかに広い**のです。上の計算より、<code>float</code> が表せる最大の正数は \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) であり、符号ビットを切り替えれば最小の負数が得られます。</p> <p>浮動小数点数 <code>float</code> は値域を広げる一方で、その代償として精度を犠牲にしています。整数型 <code>int</code> は 32 ビットすべてを数値の表現に使うため、数値は一様に分布します。しかし指数部があるため、浮動小数点数 <code>float</code> は値が大きくなるほど、隣り合う 2 つの数の差も大きくなる傾向があります。</p> <p>次の表のとおり、指数部 \\(\\mathrm{E} = 0\\) と \\(\\mathrm{E} = 255\\) には特別な意味があり、ゼロ、無限大、\\(\\mathrm{NaN}\\) などを表すために使われます。</p> <p> 表 3-2   指数部の意味 </p> 指数部 E 仮数部 \\(\\mathrm{N} = 0\\) 仮数部 \\(\\mathrm{N} \\ne 0\\) 計算式 \\(0\\) \\(\\pm 0\\) 非正規化数 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) 正規化数 正規化数 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>なお、非正規化数によって浮動小数点数の精度は大きく向上します。最小の正の正規化数は \\(2^{-126}\\) であり、最小の正の非正規化数は \\(2^{-126} \\times 2^{-23}\\) です。</p> <p>倍精度 <code>double</code> も <code>float</code> と同様の表現方法を採用しているため、ここでは詳述しません。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   まとめ","text":"","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li>データ構造は、論理構造と物理構造という 2 つの観点から分類できます。論理構造はデータ要素間の論理的関係を記述し、物理構造はデータのコンピュータメモリ上での格納方法を記述します。</li> <li>代表的な論理構造には、線形、木構造、網状構造などがあります。通常、論理構造に基づいてデータ構造を線形（配列、連結リスト、スタック、キュー）と非線形（木、グラフ、ヒープ）の 2 種類に分類します。ハッシュテーブルの実装には、線形データ構造と非線形データ構造が同時に含まれる場合があります。</li> <li>プログラムの実行時、データはコンピュータメモリに格納されます。各メモリ空間には対応するメモリアドレスがあり、プログラムはそれらのメモリアドレスを通じてデータにアクセスします。</li> <li>物理構造は主に連続領域への格納（配列）と分散領域への格納（連結リスト）に分けられます。すべてのデータ構造は、配列、連結リスト、またはその両方の組み合わせによって実装されます。</li> <li>コンピュータにおける基本データ型には、整数 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code>、浮動小数点数 <code>float</code>、<code>double</code>、文字 <code>char</code>、真偽値 <code>bool</code> があります。これらの値域は、使用する記憶領域の大きさと表現方式によって決まります。</li> <li>符号付き絶対値表現、1 の補数、2 の補数は、コンピュータで数値を符号化する 3 つの方法であり、相互に変換できます。整数の符号付き絶対値表現では最上位ビットが符号ビットで、残りのビットが数値の値です。</li> <li>整数はコンピュータ内では 2 の補数の形式で格納されます。2 の補数表現では、コンピュータは正数と負数の加算を同じように扱うことができ、減算のために特別なハードウェア回路を別途設計する必要がなく、さらに正負のゼロが重複する問題もありません。</li> <li>浮動小数点数の符号化は、1 ビットの符号部、8 ビットの指数部、23 ビットの仮数部で構成されます。指数部があるため、浮動小数点数の値域は整数よりはるかに広くなりますが、その代償として精度が犠牲になります。</li> <li>ASCII コードは最も早く登場した英字文字集合で、長さは 1 バイト、収録文字数は 127 です。GBK 文字集合はよく使われる中国語文字集合で、2 万字以上の漢字を収録しています。Unicode は完全な文字集合標準を提供することを目指しており、世界中のさまざまな言語の文字を収録することで、文字コード方式の不一致によって生じる文字化けの問題を解決します。</li> <li>UTF-8 は最も広く使われている Unicode の符号化方式で、汎用性が非常に高いです。可変長の符号化方式であり、拡張性に優れ、記憶領域の利用効率を効果的に高めます。UTF-16 と UTF-32 は固定長の符号化方式です。中国語を符号化する場合、UTF-16 は UTF-8 よりも使用領域が小さくなります。Java や C# などのプログラミング言語は、デフォルトで UTF-16 を使用します。</li> </ul>","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：なぜハッシュテーブルには線形データ構造と非線形データ構造が同時に含まれるのですか？</p> <p>ハッシュテーブルの基盤は配列であり、ハッシュ衝突を解決するために「チェイン法」（後続の「ハッシュ衝突」の章で説明します）を使うことがあります。配列内の各バケットは 1 つの連結リストを指し、その連結リストの長さがある閾値を超えると、木（通常は赤黒木）に変換されることもあります。</p> <p>格納の観点から見ると、ハッシュテーブルの基盤は配列であり、各バケットスロットには値が入ることもあれば、連結リストや木が入ることもあります。したがって、ハッシュテーブルには線形データ構造（配列、連結リスト）と非線形データ構造（木）が同時に含まれる場合があります。</p> <p>Q：<code>char</code> 型の長さは 1 バイトですか？</p> <p><code>char</code> 型の長さは、プログラミング言語が採用する符号化方式によって決まります。たとえば、Java、JavaScript、TypeScript、C# はいずれも UTF-16 符号化（Unicode コードポイントを保持）を採用しているため、<code>char</code> 型の長さは 2 バイトです。</p> <p>Q：配列ベースで実装されたデータ構造を「静的データ構造」と呼ぶのは曖昧ではありませんか？ スタックも push や pop などの操作ができ、これらの操作はどれも「動的」です。</p> <p>スタックは確かに動的なデータ操作を実現できますが、データ構造自体は依然として「静的」（長さが不変）です。配列ベースのデータ構造でも要素を動的に追加または削除できますが、その容量は固定です。データ量が事前に確保した大きさを超えた場合は、より大きな新しい配列を作成し、古い配列の内容を新しい配列にコピーする必要があります。</p> <p>Q：スタック（キュー）を構築するときにサイズを指定していないのに、なぜそれらは「静的データ構造」なのですか？</p> <p>高水準プログラミング言語では、スタック（キュー）の初期容量を人手で指定する必要はなく、この作業はクラス内部で自動的に行われます。たとえば、Java の <code>ArrayList</code> の初期容量は通常 10 です。また、容量拡張も自動的に実装されています。詳しくは後続の「リスト」の章を参照してください。</p> <p>Q：符号付き絶対値表現から 2 の補数への変換方法は「先にビット反転してから 1 を加える」ですが、2 の補数から符号付き絶対値表現への変換は逆演算である「先に 1 を引いてからビット反転する」べきなのに、同じく「先にビット反転してから 1 を加える」でも求められます。これはなぜですか？</p> <p>これは、符号付き絶対値表現と 2 の補数の相互変換が、実際には「補数」を計算する過程だからです。まず補数の定義を示します。\\(a + b = c\\) とすると、\\(a\\) を \\(b\\) から \\(c\\) への補数と呼び、逆に \\(b\\) も \\(a\\) から \\(c\\) への補数と呼びます。</p> <p>長さ \\(n = 4\\) ビットの 2 進数 \\(0010\\) が与えられたとします。この数を符号付き絶対値表現（符号ビットは考慮しない）とみなすと、その 2 の補数は「先にビット反転してから 1 を加える」ことで得られます。</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>ここで、符号付き絶対値表現と 2 の補数の和は \\(0010 + 1110 = 10000\\) となります。つまり、2 の補数 \\(1110\\) は符号付き絶対値表現 \\(0010\\) から \\(10000\\) への「補数」です。これは、上記の「先にビット反転してから 1 を加える」が、実際には \\(10000\\) への補数を計算する過程であることを意味します。</p> <p>では、2 の補数 \\(1110\\) から \\(10000\\) への「補数」はいくつでしょうか。これもやはり「先にビット反転してから 1 を加える」ことで求められます。</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>言い換えると、符号付き絶対値表現と 2 の補数は互いに相手から \\(10000\\) への「補数」なので、「符号付き絶対値表現から 2 の補数への変換」と「2 の補数から符号付き絶対値表現への変換」は同じ操作（先にビット反転してから 1 を加える）で実現できます。</p> <p>もちろん、逆演算を用いて 2 の補数 \\(1110\\) の符号付き絶対値表現を求めることもでき、その場合は「先に 1 を引いてからビット反転する」ことになります。</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>まとめると、「先にビット反転してから 1 を加える」と「先に 1 を引いてからビット反転する」の 2 つの演算は、どちらも \\(10000\\) への補数を計算しており、等価です。</p> <p>本質的には、「ビット反転」という操作は実際には \\(1111\\) への補数を求めています（常に <code>符号付き絶対値表現 + 1 の補数 = 1111</code> が成り立つため）。そして、1 の補数にさらに 1 を加えて得られる 2 の補数が、\\(10000\\) への補数です。</p> <p>上記では \\(n = 4\\) を例にしましたが、この考え方は任意のビット長の 2 進数に一般化できます。</p>","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"第 12 章   分割統治","text":"<p>Abstract</p> <p>難題は段階的に分解され、そのたびにより単純になっていく。</p> <p>分割統治は一つの重要な事実を示している。単純なことから始めれば、すべてはもはや複雑ではない。</p>","path":["第 12 章 &nbsp; 分割統治"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"章の内容","text":"<ul> <li>12.1   分割統治法</li> <li>12.2   分割統治探索戦略</li> <li>12.3   二分木の構築問題</li> <li>12.4   ハノイの塔の問題</li> <li>12.5   まとめ</li> </ul>","path":["第 12 章 &nbsp; 分割統治"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   分割統治探索戦略","text":"<p>私たちはすでに学んだように、探索アルゴリズムは大きく二つに分けられる。</p> <ul> <li>力ずく探索：データ構造を走査することで実現され、時間計算量は \\(O(n)\\) である。</li> <li>適応的探索：固有のデータ構造や事前情報を利用し、時間計算量は \\(O(\\log n)\\) 、さらには \\(O(1)\\) に達しうる。</li> </ul> <p>実際、時間計算量が \\(O(\\log n)\\) の探索アルゴリズムは通常、分割統治戦略に基づいて実装される。たとえば二分探索や木構造である。</p> <ul> <li>二分探索の各ステップでは、問題（配列内で目標要素を探索すること）を小さな問題（配列の半分で目標要素を探索すること）に分解し、この過程は配列が空になるか目標要素が見つかるまで続く。</li> <li>木構造は分割統治の考え方を代表するものであり、二分探索木、AVL 木、ヒープなどのデータ構造では、さまざまな操作の時間計算量はいずれも \\(O(\\log n)\\) である。</li> </ul> <p>二分探索の分割統治戦略は以下のとおりである。</p> <ul> <li>問題は分解できる：二分探索は、元の問題（配列内で探索すること）を部分問題（配列の半分で探索すること）へ再帰的に分解する。これは中央要素と目標要素を比較することで実現される。</li> <li>部分問題は独立している：二分探索では、各ラウンドで一つの部分問題だけを処理し、ほかの部分問題の影響を受けない。</li> <li>部分問題の解を統合する必要はない：二分探索は特定の要素を探すことを目的としているため、部分問題の解を統合する必要がない。部分問題が解決されると、元の問題も同時に解決される。</li> </ul> <p>分割統治が探索効率を高められる本質的な理由は、力ずく探索では各ラウンドで一つの候補しか除外できないのに対し、**分割統治による探索では各ラウンドで候補の半分を除外できる**からである。</p>","path":["第 12 章 &nbsp; 分割統治","12.2 &nbsp; 分割統治探索戦略"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   分割統治に基づく二分探索","text":"<p>前の章では、二分探索を漸化式（反復）に基づいて実装した。ここでは分割統治（再帰）に基づいてこれを実装する。</p> <p>Question</p> <p>長さ \\(n\\) の昇順配列 <code>nums</code> が与えられ、そのすべての要素は一意である。要素 <code>target</code> を探索せよ。</p> <p>分割統治の観点から、探索区間 \\([i, j]\\) に対応する部分問題を \\(f(i, j)\\) と記す。</p> <p>元の問題 \\(f(0, n-1)\\) を出発点として、次の手順で二分探索を行う。</p> <ol> <li>探索区間 \\([i, j]\\) の中点 \\(m\\) を計算し、それに基づいて探索区間の半分を除外する。</li> <li>規模が半分に縮小された部分問題を再帰的に解く。候補は \\(f(i, m-1)\\) または \\(f(m+1, j)\\) である。</li> <li><code>1.</code> と <code>2.</code> の手順を繰り返し、<code>target</code> が見つかるか区間が空になったら返す。</li> </ol> <p>次の図は、配列内で要素 \\(6\\) を二分探索する分割統治の過程を示している。</p> <p></p> <p> 図 12-4   二分探索の分割統治の過程 </p> <p>実装コードでは、再帰関数 <code>dfs()</code> を宣言して問題 \\(f(i, j)\\) を解く。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"二分探索：問題 f(i, j)\"\"\"\n    # 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j:\n        return -1\n    # 中点インデックス m を計算\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1)\n    else:\n        # 目標要素が見つかったらそのインデックスを返す\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索\"\"\"\n    n = len(nums)\n    # 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* 二分探索：問題 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // 問題 f(0, n-1) を解く\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* 二分探索：問題 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // 区間が空なら対象要素は存在しないため、-1 を返す\n    if i &gt; j {\n        return -1\n    }\n    // 中点インデックスを計算する\n    m := i + ((j - i) &gt;&gt; 1)\n    // 中点の要素と目標要素の大小を判定する\n    if nums[m] &lt; target {\n        // 小さければ右半分の配列を再帰\n        // 部分問題 f(m+1, j) を解く\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // 大きければ左半分の配列を再帰\n        // 部分問題 f(i, m-1) を解く\n        return dfs(nums, target, i, m-1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m\n    }\n}\n\n/* 二分探索 */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* 二分探索：問題 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j {\n        return -1\n    }\n    // 中点インデックス m を計算\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m\n    }\n}\n\n/* 二分探索 */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 問題 f(0, n-1) を解く\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* 二分探索：問題 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* 二分探索：問題 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // 区間が空なら対象要素は存在しないので -1 を返す\n  if (i &gt; j) {\n    return -1;\n  }\n  // 中点インデックス m を計算\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // 部分問題 f(m+1, j) を再帰的に解く\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // 部分問題 f(i, m-1) を再帰的に解く\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // 目標要素が見つかったらそのインデックスを返す\n    return m;\n  }\n}\n\n/* 二分探索 */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // 問題 f(0, n-1) を解く\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* 二分探索：問題 f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // 問題 f(0, n-1) を解く\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* 二分探索：問題 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1\n    }\n    // 中点インデックス m を計算\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        dfs(nums, target, i, m - 1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        m\n    }\n}\n\n/* 二分探索 */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### 二分探索: 問題 f(i, j) ###\ndef dfs(nums, target, i, j)\n  # 区間が空なら対象要素は存在しないので -1 を返す\n  return -1 if i &gt; j\n\n  # 中点インデックス m を計算\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # 部分問題 f(m+1, j) を再帰的に解く\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # 部分問題 f(i, m-1) を再帰的に解く\n    return dfs(nums, target, i, m - 1)\n  else\n    # 目標要素が見つかったらそのインデックスを返す\n    return m\n  end\nend\n\n### 二分探索 ###\ndef binary_search(nums, target)\n  n = nums.length\n  # 問題 f(0, n-1) を解く\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 12 章 &nbsp; 分割統治","12.2 &nbsp; 分割統治探索戦略"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   二分木の構築問題","text":"<p>Question</p> <p>二分木の前順走査 <code>preorder</code> と中順走査 <code>inorder</code> が与えられたとき、これらから二分木を構築し、その根ノードを返してください。二分木には値が重複するノードが存在しないものとします（下図のとおり）。</p> <p></p> <p> 図 12-5   二分木を構築する例のデータ </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   分割統治問題かどうかを判断する","text":"<p>元の問題は <code>preorder</code> と <code>inorder</code> から二分木を構築することであり、典型的な分割統治問題です。</p> <ul> <li>問題は分解できる：分割統治の観点から見ると、元の問題は 2 つの部分問題、すなわち左部分木の構築と右部分木の構築に分けられ、さらに根ノードを初期化する 1 ステップが加わります。各部分木（部分問題）に対しても、同じ分割方法を再利用してより小さな部分木（部分問題）へと分けていき、最小の部分問題（空部分木）に達した時点で終了します。</li> <li>部分問題は独立している：左部分木と右部分木は互いに独立しており、両者の間に重なりはありません。左部分木を構築するときは、中順走査と前順走査のうち左部分木に対応する部分だけを見れば十分です。右部分木も同様です。</li> <li>部分問題の解は統合できる：左部分木と右部分木（部分問題の解）が得られたら、それらを根ノードに接続することで元の問題の解を得られます。</li> </ul>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   部分木をどのように分割するか","text":"<p>以上の分析より、この問題は分割統治で解けます。では、前順走査 <code>preorder</code> と中順走査 <code>inorder</code> を使って左部分木と右部分木をどのように分割すればよいのでしょうか？</p> <p>定義に従うと、<code>preorder</code> と <code>inorder</code> はいずれも 3 つの部分に分けられます。</p> <ul> <li>前順走査：<code>[ 根ノード | 左部分木 | 右部分木 ]</code> ，例えば上図の木は <code>[ 3 | 9 | 2 1 7 ]</code> に対応します。</li> <li>中順走査：<code>[ 左部分木 | 根ノード ｜ 右部分木 ]</code> ，例えば上図の木は <code>[ 9 | 3 | 1 2 7 ]</code> に対応します。</li> </ul> <p>上図のデータを例にすると、下図の手順によって分割結果を得られます。</p> <ol> <li>前順走査の先頭要素 3 が根ノードの値です。</li> <li>根ノード 3 の <code>inorder</code> におけるインデックスを探すと、そのインデックスを用いて <code>inorder</code> を <code>[ 9 | 3 ｜ 1 2 7 ]</code> に分割できます。</li> <li><code>inorder</code> の分割結果から、左部分木と右部分木のノード数はそれぞれ 1 と 3 であることがわかり、したがって <code>preorder</code> を <code>[ 3 | 9 | 2 1 7 ]</code> に分割できます。</li> </ol> <p></p> <p> 図 12-6   前順走査と中順走査で部分木を分割する </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   変数を用いて部分木区間を記述する","text":"<p>以上の分割方法により、**根ノード、左部分木、右部分木が <code>preorder</code> と <code>inorder</code> の中で占めるインデックス区間**が得られました。これらのインデックス区間を表すために、いくつかのポインタ変数を導入します。</p> <ul> <li>現在の木の根ノードが <code>preorder</code> に現れるインデックスを \\(i\\) とします。</li> <li>現在の木の根ノードが <code>inorder</code> に現れるインデックスを \\(m\\) とします。</li> <li>現在の木が <code>inorder</code> において占めるインデックス区間を \\([l, r]\\) とします。</li> </ul> <p>次の表のように、これらの変数を用いれば根ノードの <code>preorder</code> におけるインデックスと、部分木の <code>inorder</code> におけるインデックス区間を表せます。</p> <p> 表 12-1   根ノードと部分木の前順走査・中順走査におけるインデックス </p> 根ノードの <code>preorder</code> におけるインデックス 部分木の <code>inorder</code> におけるインデックス区間 現在の木 \\(i\\) \\([l, r]\\) 左部分木 \\(i + 1\\) \\([l, m-1]\\) 右部分木 \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>右部分木の根ノードのインデックスにある \\((m-l)\\) は「左部分木のノード数」を意味します。下図と合わせて理解することを勧めます。</p> <p></p> <p> 図 12-7   根ノードと左右部分木のインデックス区間の表し方 </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   コードの実装","text":"<p>\\(m\\) の検索効率を高めるために、ハッシュテーブル <code>hmap</code> を用いて配列 <code>inorder</code> の要素からインデックスへの対応を保存します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"二分木を構築：分割統治\"\"\"\n    # 部分木区間が空なら終了する\n    if r - l &lt; 0:\n        return None\n    # ルートノードを初期化する\n    root = TreeNode(preorder[i])\n    # m を求めて左右部分木を分割する\n    m = inorder_map[preorder[i]]\n    # 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # 根ノードを返す\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"二分木を構築\"\"\"\n    # inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* 二分木を構築：分割統治 */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return NULL;\n    // ルートノードを初期化する\n    TreeNode *root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* 二分木を構築：分割統治 */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return null;\n    // ルートノードを初期化する\n    TreeNode root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* 二分木を構築：分割統治 */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return null;\n    // ルートノードを初期化する\n    TreeNode root = new(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* 二分木を構築：分割統治 */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // 部分木区間が空なら終了する\n    if r-l &lt; 0 {\n        return nil\n    }\n    // ルートノードを初期化する\n    root := NewTreeNode(preorder[i])\n    // m を求めて左右部分木を分割する\n    m := inorderMap[preorder[i]]\n    // 部分問題：左部分木を構築する\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // 部分問題：右部分木を構築する\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* 二分木を構築：分割統治 */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // 部分木区間が空なら終了する\n    if r - l &lt; 0 {\n        return nil\n    }\n    // ルートノードを初期化する\n    let root = TreeNode(x: preorder[i])\n    // m を求めて左右部分木を分割する\n    let m = inorderMap[preorder[i]]!\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* 二分木を構築：分割統治 */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null;\n    // ルートノードを初期化する\n    const root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    const m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nfunction buildTree(preorder, inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* 二分木を構築：分割統治 */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null;\n    // ルートノードを初期化する\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    const m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* 二分木を構築：分割統治 */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // 部分木区間が空なら終了する\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // ルートノードを初期化する\n  TreeNode? root = TreeNode(preorder[i]);\n  // m を求めて左右部分木を分割する\n  int m = inorderMap[preorder[i]]!;\n  // 部分問題：左部分木を構築する\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // 部分問題：右部分木を構築する\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // 根ノードを返す\n  return root;\n}\n\n/* 二分木を構築 */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* 二分木を構築：分割統治 */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 部分木区間が空なら終了する\n    if r - l &lt; 0 {\n        return None;\n    }\n    // ルートノードを初期化する\n    let root = TreeNode::new(preorder[i as usize]);\n    // m を求めて左右部分木を分割する\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // 部分問題：左部分木を構築する\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    Some(root)\n}\n\n/* 二分木を構築 */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* 二分木を構築：分割統治 */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return NULL;\n    // ルートノードを初期化する\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // 部分問題：右部分木を構築する\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* 二分木を構築：分割統治 */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null\n    // ルートノードを初期化する\n    val root = TreeNode(preorder[i])\n    // m を求めて左右部分木を分割する\n    val m = inorderMap[preorder[i]]!!\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### 二分木を構築：分割統治 ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # 部分木区間が空なら終了する\n  return if r - l &lt; 0\n\n  # ルートノードを初期化する\n  root = TreeNode.new(preorder[i])\n  # m を求めて左右部分木を分割する\n  m = inorder_map[preorder[i]]\n  # 部分問題：左部分木を構築する\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # 部分問題：右部分木を構築する\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # 根ノードを返す\n  root\nend\n\n### 二分木を構築 ###\ndef build_tree(preorder, inorder)\n  # inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は二分木を構築する再帰過程を示しています。各ノードは下向きに「再帰していく」過程で生成され、各辺（参照）は上向きに「戻る」過程で張られます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 12-8   二分木を構築する再帰過程 </p> <p>各再帰関数における前順走査 <code>preorder</code> と中順走査 <code>inorder</code> の分割結果を下図に示します。</p> <p></p> <p> 図 12-9   各再帰関数での分割結果 </p> <p>木のノード数を \\(n\\) とすると、各ノードの初期化（再帰関数 <code>dfs()</code> の 1 回の実行）には \\(O(1)\\) 時間かかります。したがって、全体の時間計算量は \\(O(n)\\) です。</p> <p>ハッシュテーブルには <code>inorder</code> の要素からインデックスへの対応を保存するため、空間計算量は \\(O(n)\\) です。最悪の場合、すなわち二分木が連結リストに退化すると、再帰の深さは \\(n\\) に達し、\\(O(n)\\) のスタックフレーム空間を使用します。したがって、全体の空間計算量は \\(O(n)\\) です。</p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   分割統治法","text":"<p>分割統治法（divide and conquer）は、問題を分けて統べるという意味であり、非常に重要で一般的なアルゴリズム戦略です。分割統治法は通常、再帰に基づいて実装され、「分」と「治」の 2 つのステップから構成されます。</p> <ol> <li>分（分割段階）：元の問題を 2 つ以上の部分問題へ再帰的に分解し、最小の部分問題に到達した時点で停止します。</li> <li>治（統合段階）：解が既知である最小の部分問題から始めて、部分問題の解を下から上へ統合し、元の問題の解を構築します。</li> </ol> <p>以下の図に示すように、「マージソート」は分割統治戦略の典型的な応用の一つです。</p> <ol> <li>分：元の配列（元の問題）を 2 つの部分配列（部分問題）へ再帰的に分割し、部分配列に要素が 1 つだけ残るまで続けます。</li> <li>治：整列済みの部分配列（部分問題の解）を下から上へ統合し、整列済みの元の配列（元の問題の解）を得ます。</li> </ol> <p></p> <p> 図 12-1   マージソートの分割統治戦略 </p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   分割統治法の問題を見極めるには","text":"<p>ある問題が分割統治法で解くのに適しているかどうかは、通常、次の判断基準を参考にできます。</p> <ol> <li>問題は分解できる：元の問題は、より小さく類似した部分問題に分解でき、同じ方法で再帰的に分割できます。</li> <li>部分問題は独立している：部分問題同士に重複がなく、相互依存もないため、独立して解決できます。</li> <li>部分問題の解は統合できる：元の問題の解は、部分問題の解を統合することで得られます。</li> </ol> <p>明らかに、マージソートは以上の 3 つの判断基準を満たしています。</p> <ol> <li>問題は分解できる：配列（元の問題）を 2 つの部分配列（部分問題）へ再帰的に分割します。</li> <li>部分問題は独立している：各部分配列は独立にソートできます（部分問題は独立に解けます）。</li> <li>部分問題の解は統合できる：2 つの整列済み部分配列（部分問題の解）は、1 つの整列済み配列（元の問題の解）に統合できます。</li> </ol>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   分割統治法で効率を高める","text":"<p>分割統治法はアルゴリズムの問題を効果的に解けるだけでなく、多くの場合アルゴリズムの効率も高められます。ソートアルゴリズムでは、クイックソート、マージソート、ヒープソートが選択ソート、バブルソート、挿入ソートより高速ですが、これは分割統治戦略を適用しているためです。</p> <p>ここで次の疑問が生じます。なぜ分割統治法はアルゴリズム効率を高められるのでしょうか。その根本的な仕組みは何でしょうか？言い換えると、大きな問題を複数の部分問題に分解し、部分問題を解き、それらの解を統合して元の問題の解にするという手順は、なぜ元の問題を直接解くより効率的なのでしょうか。この問題は、操作回数と並列計算の 2 つの観点から議論できます。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   操作回数の最適化","text":"<p>「バブルソート」を例に取ると、長さ \\(n\\) の配列を処理するのに \\(O(n^2)\\) の時間がかかります。以下の図のように、配列を中央で 2 つの部分配列に分けると仮定すると、分割には \\(O(n)\\) の時間、各部分配列のソートには \\(O((n / 2)^2)\\) の時間、2 つの部分配列の統合には \\(O(n)\\) の時間が必要で、全体の時間計算量は次のようになります：</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> 図 12-2   配列分割前後のバブルソート </p> <p>次に、以下の不等式を計算します。左辺と右辺はそれぞれ、分割前と分割後の操作総数です：</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>これは、\\(n &gt; 4\\) のときに分割後の操作回数の方が少なくなり、ソート効率が高くなることを意味します。ただし、分割後の時間計算量は依然として 2 次の \\(O(n^2)\\) であり、計算量の定数項が小さくなっただけです。</p> <p>さらに考えると、部分配列を中央からさらに 2 つの部分配列へと分割し続け、部分配列に要素が 1 つだけ残るまで分割を止めないとしたらどうでしょうか。この考え方がまさに「マージソート」であり、時間計算量は \\(O(n \\log n)\\) です。</p> <p>さらに、分割点をいくつか増やして、元の配列を平均的に \\(k\\) 個の部分配列に分けるとしたらどうでしょうか。この状況は「バケットソート」と非常によく似ており、大量データのソートに非常に適しています。理論上の時間計算量は \\(O(n + k)\\) に達します。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   並列計算の最適化","text":"<p>分割統治法で生成される部分問題は互いに独立しているため、通常は並列に解くことができます。つまり、分割統治法はアルゴリズムの時間計算量を下げられるだけでなく、オペレーティングシステムの並列最適化にも有利です。</p> <p>並列最適化は、マルチコアまたはマルチプロセッサ環境で特に有効です。システムが複数の部分問題を同時に処理でき、計算資源をより十分に活用できるため、全体の実行時間を大幅に短縮できます。</p> <p>たとえば、以下の図に示す「バケットソート」では、大量のデータを各バケットに均等に割り当てることで、すべてのバケットのソート処理を各計算ユニットに分散し、完了後に結果を統合できます。</p> <p></p> <p> 図 12-3   バケットソートの並列計算 </p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   分割統治法の代表的な応用","text":"<p>一方では、分割統治法は多くの古典的なアルゴリズム問題を解くのに使えます。</p> <ul> <li>最近点対探索：このアルゴリズムは、まず点集合を 2 つに分け、それぞれの部分における最近点対を求め、最後に 2 つの部分をまたぐ最近点対を求めます。</li> <li>大整数乗算：たとえば Karatsuba 法では、大整数の乗算を、より小さな整数どうしのいくつかの乗算と加算に分解します。</li> <li>行列乗算：たとえば Strassen 法では、大きな行列の乗算を、複数の小さな行列の乗算と加算に分解します。</li> <li>ハノイの塔問題：ハノイの塔問題は再帰によって解くことができ、これは典型的な分割統治戦略の応用です。</li> <li>反転対の計算：ある数列で前の数が後ろの数より大きい場合、その 2 つの数は反転対を構成します。反転対の問題は、分割統治の考え方を利用し、マージソートを用いて解けます。</li> </ul> <p>他方で、分割統治法はアルゴリズムとデータ構造の設計にも非常に広く応用されています。</p> <ul> <li>二分探索：二分探索では、整列済み配列を中央のインデックスで 2 つに分け、目標値と中央要素の比較結果に基づいてどちらの半区間を除外するかを決め、残った区間で同じ二分操作を行います。</li> <li>マージソート：本節の冒頭で紹介したため、ここでは繰り返しません。</li> <li>クイックソート：クイックソートは基準値を 1 つ選び、配列を、基準値より小さい要素の部分配列と、基準値より大きい要素の部分配列に分け、その後それぞれに対して同じ分割操作を行い、部分配列に要素が 1 つだけ残るまで続けます。</li> <li>バケットソート：バケットソートの基本的な考え方は、データを複数のバケットに分散し、各バケット内の要素をソートしたうえで、各バケットの要素を順に取り出して整列済み配列を得ることです。</li> <li>木構造：たとえば二分探索木、AVL 木、赤黒木、B 木、B+ 木などでは、探索・挿入・削除などの操作をいずれも分割統治戦略の応用とみなせます。</li> <li>ヒープ：ヒープは特殊な完全二分木であり、挿入、削除、ヒープ化などの各種操作には、実際には分割統治の考え方が含まれています。</li> <li>ハッシュテーブル：ハッシュテーブル自体は分割統治を直接適用しているわけではありませんが、いくつかのハッシュ衝突解決法では間接的に分割統治戦略が使われています。たとえば、連鎖アドレス法における長い連結リストは、検索効率を高めるために赤黒木へ変換されます。</li> </ul> <p>このように、**分割統治法は「静かに物を潤す」ようなアルゴリズム思想**であり、さまざまなアルゴリズムやデータ構造の中に潜んでいます。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   ハノイの塔の問題","text":"<p>マージソートや二分木の構築では、いずれも元の問題を元問題の半分の規模をもつ 2 つの部分問題に分解していました。しかし、ハノイの塔の問題では、異なる分解戦略を採用します。</p> <p>Question</p> <p>3 本の柱があり、それぞれを <code>A</code>、<code>B</code>、<code>C</code> とします。初期状態では、柱 <code>A</code> に \\(n\\) 枚の円盤が通されており、上から下へ小さい順に並んでいます。私たちの課題は、この \\(n\\) 枚の円盤を柱 <code>C</code> に移し、元の順序を保つことです（以下の図のとおり）。円盤を移動する際には、次のルールに従う必要があります。</p> <ol> <li>円盤は 1 本の柱の頂上から取り出し、別の柱の頂上に置くことしかできません。</li> <li>1 回に移動できる円盤は 1 枚だけです。</li> <li>小さい円盤は常に大きい円盤の上になければなりません。</li> </ol> <p></p> <p> 図 12-10   ハノイの塔の問題の例 </p> <p>規模が \\(i\\) のハノイの塔の問題を \\(f(i)\\) と表します 。たとえば \\(f(3)\\) は、\\(3\\) 枚の円盤を <code>A</code> から <code>C</code> へ移動するハノイの塔の問題を表します。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   基本ケースを考える","text":"<p>以下の図に示すように、問題 \\(f(1)\\) 、すなわち円盤が 1 枚だけの場合は、それを <code>A</code> から <code>C</code> へ直接移動すれば済みます。</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> 図 12-11   規模 1 の問題の解 </p> <p>以下の図に示すように、問題 \\(f(2)\\) 、すなわち円盤が 2 枚ある場合は、小さい円盤が常に大きい円盤の上にある条件を満たすため、<code>B</code> を借りて移動を行う必要があります。</p> <ol> <li>まず上の小さい円盤を <code>A</code> から <code>B</code> へ移します。</li> <li>次に大きい円盤を <code>A</code> から <code>C</code> へ移します。</li> <li>最後に小さい円盤を <code>B</code> から <code>C</code> へ移します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 12-12   規模 2 の問題の解 </p> <p>問題 \\(f(2)\\) を解く過程は、**2 枚の円盤を <code>B</code> を介して <code>A</code> から <code>C</code> へ移す**と要約できます。このとき、<code>C</code> を目標の柱、<code>B</code> を補助の柱と呼びます。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   部分問題への分解","text":"<p>問題 \\(f(3)\\) 、すなわち円盤が 3 枚ある場合になると、状況はやや複雑になります。</p> <p>\\(f(1)\\) と \\(f(2)\\) の解が既知なので、分割統治の観点から、<code>A</code> の上部にある 2 枚の円盤をひとまとまりとみなして、次の図の手順を実行できます。こうして 3 枚の円盤を <code>A</code> から <code>C</code> へ順調に移動できます。</p> <ol> <li><code>B</code> を目標の柱、<code>C</code> を補助の柱として、2 枚の円盤を <code>A</code> から <code>B</code> へ移します。</li> <li><code>A</code> に残った 1 枚の円盤を <code>A</code> から <code>C</code> へ直接移動します。</li> <li><code>C</code> を目標の柱、<code>A</code> を補助の柱として、2 枚の円盤を <code>B</code> から <code>C</code> へ移します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 12-13   規模 3 の問題の解 </p> <p>本質的には、問題 \\(f(3)\\) を 2 つの部分問題 \\(f(2)\\) と 1 つの部分問題 \\(f(1)\\) に分けています 。この 3 つの部分問題を順に解けば、元の問題も解決されます。これは、部分問題が独立しており、解を組み合わせられることを示しています。</p> <p>ここまでで、次の図に示すハノイの塔の問題を解く分割統治戦略をまとめられます。元の問題 \\(f(n)\\) を 2 つの部分問題 \\(f(n-1)\\) と 1 つの部分問題 \\(f(1)\\) に分け、次の順序でこの 3 つの部分問題を解きます。</p> <ol> <li>\\(n-1\\) 枚の円盤を <code>C</code> を介して <code>A</code> から <code>B</code> へ移します。</li> <li>残り \\(1\\) 枚の円盤を <code>A</code> から <code>C</code> へ直接移します。</li> <li>\\(n-1\\) 枚の円盤を <code>A</code> を介して <code>B</code> から <code>C</code> へ移します。</li> </ol> <p>この 2 つの部分問題 \\(f(n-1)\\) は、同じ方法で再帰的に分割できます。最小の部分問題 \\(f(1)\\) に到達するまでこれを続けます。一方、\\(f(1)\\) の解は既知であり、1 回の移動操作だけで済みます。</p> <p></p> <p> 図 12-14   ハノイの塔の問題を解く分割統治戦略 </p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   コードの実装","text":"<p>コードでは、再帰関数 <code>dfs(i, src, buf, tar)</code> を定義します。その役割は、柱 <code>src</code> の上部にある \\(i\\) 枚の円盤を、補助の柱 <code>buf</code> を使って目標の柱 <code>tar</code> へ移動することです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"円盤を 1 枚移動\"\"\"\n    # src の上から円盤を1枚取り出す\n    pan = src.pop()\n    # 円盤を tar の上に置く\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"ハノイの塔の問題 f(i) を解く\"\"\"\n    # src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1:\n        move(src, tar)\n        return\n    # 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf)\n    # 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    # 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"ハノイの塔を解く\"\"\"\n    n = len(A)\n    # A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* 円盤を 1 枚移動 */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // src の上から円盤を1枚取り出す\n    int pan = src.back();\n    src.pop_back();\n    // 円盤を tar の上に置く\n    tar.push_back(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* 円盤を 1 枚移動 */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // src の上から円盤を1枚取り出す\n    Integer pan = src.remove(src.size() - 1);\n    // 円盤を tar の上に置く\n    tar.add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* 円盤を 1 枚移動 */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // src の上から円盤を1枚取り出す\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // 円盤を tar の上に置く\n    tar.Add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    DFS(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    Move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    DFS(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* 円盤を 1 枚移動 */\nfunc move(src, tar *list.List) {\n    // src の上から円盤を1枚取り出す\n    pan := src.Back()\n    // 円盤を tar の上に置く\n    tar.PushBack(pan.Value)\n    // `src` の最上部の円盤を取り外す\n    src.Remove(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfsHanota(i-1, src, tar, buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* ハノイの塔を解く */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* 円盤を 1 枚移動 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // src の上から円盤を1枚取り出す\n    let pan = src.popLast()!\n    // 円盤を tar の上に置く\n    tar.append(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src: &amp;src, tar: &amp;tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* ハノイの塔を解く */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // リストの末尾が柱の上端に対応する\n    // src の上から n 個の円盤を、B を介して C に移動する\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* 円盤を 1 枚移動 */\nfunction move(src, tar) {\n    // src の上から円盤を1枚取り出す\n    const pan = src.pop();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunction dfs(i, src, buf, tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* 円盤を 1 枚移動 */\nfunction move(src: number[], tar: number[]): void {\n    // src の上から円盤を1枚取り出す\n    const pan = src.pop();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* 円盤を 1 枚移動 */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // src の上から円盤を1枚取り出す\n  int pan = src.removeLast();\n  // 円盤を tar の上に置く\n  tar.add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n  dfs(i - 1, src, tar, buf);\n  // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n  move(src, tar);\n  // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n  dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // A の上から n 枚の円盤を B を介して C へ移す\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* 円盤を 1 枚移動 */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // src の上から円盤を1枚取り出す\n    let pan = src.pop().unwrap();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move_pan(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* 円盤を 1 枚移動 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // src の上から円盤を1枚取り出す\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // 円盤を tar の上に置く\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, srcSize, tar, tarSize);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* 円盤を 1 枚移動 */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // src の上から円盤を1枚取り出す\n    val pan = src.removeAt(src.size - 1)\n    // 円盤を tar の上に置く\n    tar.add(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar)\n}\n\n/* ハノイの塔を解く */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### 円盤を1枚移動 ###\ndef move(src, tar)\n  # src の上から円盤を1枚取り出す\n  pan = src.pop\n  # 円盤を tar の上に置く\n  tar &lt;&lt; pan\nend\n\n### ハノイの塔 f(i) を解く ###\ndef dfs(i, src, buf, tar)\n  # src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n  dfs(i - 1, src, tar, buf)\n  # 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n  move(src, tar)\n  # 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n  dfs(i - 1, buf, src, tar)\nend\n\n### ハノイの塔を解く ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # A の上から n 枚の円盤を B を介して C へ移す\n  dfs(n, _A, _B, _C)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、ハノイの塔の問題は高さ \\(n\\) の再帰木を形成し、各ノードは 1 つの部分問題、すなわち 1 つ起動された <code>dfs()</code> 関数に対応します。したがって時間計算量は \\(O(2^n)\\) 、空間計算量は \\(O(n)\\) です。</p> <p></p> <p> 図 12-15   ハノイの塔の問題の再帰木 </p> <p>Quote</p> <p>ハノイの塔の問題は古い伝説に由来します。古代インドのある寺院で、僧侶たちは 3 本の高いダイヤモンドの柱と、\\(64\\) 枚の大きさの異なる金の円盤を持っていました。僧侶たちは絶えず円盤を動かし、最後の 1 枚が正しく置かれた瞬間に世界が終わると信じていました。</p> <p>しかし、たとえ僧侶たちが 1 秒に 1 回移動するとしても、合計でおよそ \\(2^{64} \\approx 1.84×10^{19}\\) 秒、約 \\(5850\\) 億年が必要で、現在推定されている宇宙の年齢をはるかに上回ります。したがって、この伝説が本当だったとしても、世界の終わりを心配する必要はなさそうです。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   まとめ","text":"","path":["第 12 章 &nbsp; 分割統治","12.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>分割統治法は一般的なアルゴリズム設計戦略であり、分（分割）と治（統合）の 2 つの段階からなり、通常は再帰に基づいて実装されます。</li> <li>それが分割統治法の問題かどうかを判断する基準には、問題を分解できるか、部分問題が独立しているか、部分問題を統合できるかが含まれます。</li> <li>マージソートは分割統治法の典型的な応用であり、配列を再帰的に同じ長さの 2 つの部分配列に分割し、要素が 1 つだけになるまで続け、その後で各層を順に統合してソートを完了します。</li> <li>分割統治法を導入すると、多くの場合アルゴリズムの効率を高められます。一方では操作回数が減り、他方では分割後にシステムの並列最適化を行いやすくなります。</li> <li>分割統治法は多くのアルゴリズム問題を解決できるだけでなく、データ構造やアルゴリズム設計にも広く応用されており、至る所でその姿を見ることができます。</li> <li>総当たり探索と比べて、適応的な探索のほうが効率的です。時間計算量が \\(O(\\log n)\\) の探索アルゴリズムは、通常は分割統治法に基づいて実装されます。</li> <li>二分探索は分割統治法のもう 1 つの典型的な応用であり、部分問題の解を統合する手順を含みません。再帰的な分割統治によって二分探索を実現できます。</li> <li>二分木を構築する問題では、木の構築（元の問題）を左部分木と右部分木の構築（部分問題）に分けられます。これは、先行順序走査と中間順序走査のインデックス区間を分割することで実現できます。</li> <li>ハノイの塔の問題では、規模 \\(n\\) の問題を、規模 \\(n-1\\) の 2 つの部分問題と規模 \\(1\\) の 1 つの部分問題に分けられます。これら 3 つの部分問題を順に解くと、元の問題も解決されます。</li> </ul>","path":["第 12 章 &nbsp; 分割統治","12.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"第 14 章   動的計画法","text":"<p>Abstract</p> <p>小川は川へと注ぎ、河川は大海へと注ぐ。</p> <p>動的計画法は小さな問題の解を集めて大きな問題の答えとし、一歩ずつ私たちを問題解決の彼岸へと導く。</p>","path":["第 14 章 &nbsp; 動的計画法"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"章の内容","text":"<ul> <li>14.1   動的計画法入門</li> <li>14.2   動的計画法の問題特性</li> <li>14.3   動的計画法の問題解決の考え方</li> <li>14.4   0-1 ナップサック問題</li> <li>14.5   完全ナップサック問題</li> <li>14.6   編集距離問題</li> <li>14.7   まとめ</li> </ul>","path":["第 14 章 &nbsp; 動的計画法"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   動的計画法の問題特性","text":"<p>前節では、動的計画法が部分問題への分解によってどのように元の問題を解くのかを学びました。実際、部分問題への分解は汎用的なアルゴリズムの考え方であり、分割統治法、動的計画法、バックトラッキングでは重視点が異なります。</p> <ul> <li>分割統治法は、元の問題を再帰的に複数の互いに独立した部分問題へ分割し、最小の部分問題に至るまで分解したうえで、バックトラック時に部分問題の解を統合し、最終的に元の問題の解を得ます。</li> <li>動的計画法も問題を再帰的に分解しますが、分割統治法との主な違いは、動的計画法における部分問題が相互依存しており、分解の過程で多数の重複部分問題が現れることです。</li> <li>バックトラッキング法は、試行と巻き戻しの中ですべての可能な解を列挙し、枝刈りによって不要な探索分岐を避けます。元の問題の解は一連の意思決定ステップから構成されるため、各決定ステップ以前の部分系列を一つの部分問題と見なせます。</li> </ul> <p>実際、動的計画法は最適化問題を解くためによく用いられます。これらは重複部分問題を含むだけでなく、さらに二つの大きな特性、すなわち最適部分構造と無後効性を備えています。</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   最適部分構造","text":"<p>階段昇り問題を少し変更し、最適部分構造の概念をより示しやすくします。</p> <p>階段昇りの最小コスト</p> <p>階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。各段には非負整数が貼られており、その段に到達するために支払う必要があるコストを表します。非負整数配列 \\(cost\\) が与えられ、\\(cost[i]\\) は第 \\(i\\) 段で支払うコストを表し、\\(cost[0]\\) は地面（開始地点）です。頂上に到達するために必要な最小コストを求めてください。</p> <p>下図に示すように、第 \\(1\\)、\\(2\\)、\\(3\\) 段のコストがそれぞれ \\(1\\)、\\(10\\)、\\(1\\) である場合、地面から第 \\(3\\) 段まで上る最小コストは \\(2\\) です。</p> <p></p> <p> 図 14-6   第 3 段まで上る最小コスト </p> <p>\\(dp[i]\\) を第 \\(i\\) 段まで上るのに累積して支払ったコストとします。第 \\(i\\) 段には \\(i - 1\\) 段または \\(i - 2\\) 段からしか到達できないため、\\(dp[i]\\) は \\(dp[i - 1] + cost[i]\\) または \\(dp[i - 2] + cost[i]\\) のいずれかになります。コストをできるだけ小さくするには、この二つのうち小さいほうを選べばよいです。</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>ここから最適部分構造の意味を導けます。**元の問題の最適解は、部分問題の最適解から構築される**ということです。</p> <p>この問題が最適部分構造を持つことは明らかです。二つの部分問題の最適解 \\(dp[i-1]\\) と \\(dp[i-2]\\) からより良いほうを選び、それを用いて元の問題 \\(dp[i]\\) の最適解を構築しています。</p> <p>では、前節の階段昇り問題には最適部分構造があるのでしょうか。その目的は方法数を求めることで、一見すると計数問題です。しかし問い方を変えて「最大の方法数を求める」とすると、意外にも、問題の変更前後は等価であるにもかかわらず、最適部分構造が現れます。すなわち、第 \\(n\\) 段の最大方法数は第 \\(n-1\\) 段と第 \\(n-2\\) 段の最大方法数の和に等しいのです。このように、最適部分構造の解釈は比較的柔軟であり、問題によって意味合いが異なります。</p> <p>状態遷移方程式と初期状態 \\(dp[1] = cost[1]\\) および \\(dp[2] = cost[2]\\) に基づいて、次の動的計画法コードが得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"階段登りの最小コスト：動的計画法\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [0] * (n + 1)\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1], dp[2] = cost[1], cost[2]\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;int&gt; dp(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![-1; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int *dp = calloc(n + 1, sizeof(int));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = IntArray(n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 階段登りの最小コスト：動的計画法 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = cost[1], cost[2]\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は上記コードの動的計画法の過程を示しています。</p> <p></p> <p> 図 14-7   階段昇り最小コストの動的計画法の過程 </p> <p>この問題では空間最適化も可能であり、一次元をゼロ次元まで圧縮することで、空間計算量を \\(O(n)\\) から \\(O(1)\\) に削減できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"階段昇りの最小コスト：空間最適化後の動的計画法\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    a, b := cost[1], cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 階段登りの最小コスト：動的計画法 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = cost[1], cost[2]\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# 階段昇りの最小コスト：空間最適化後の動的計画法\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   無後効性","text":"<p>無後効性は、動的計画法が問題を効率よく解ける重要な特性の一つであり、その定義は次のとおりです。ある確定した状態が与えられたとき、その後の発展は現在の状態のみに依存し、過去に経たすべての状態には依存しない。</p> <p>階段昇り問題を例にすると、状態 \\(i\\) が与えられたとき、そこから状態 \\(i+1\\) と状態 \\(i+2\\) へ発展し、それぞれ \\(1\\) 段進む場合と \\(2\\) 段進む場合に対応します。この二つの選択を行う際、状態 \\(i\\) より前の状態を考慮する必要はなく、それらは状態 \\(i\\) の将来に影響を与えません。</p> <p>しかし、階段昇り問題に制約を一つ追加すると、状況は変わります。</p> <p>制約付き階段昇り</p> <p>全部で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。ただし、連続する 2 回で \\(1\\) 段ずつ上ることはできません。頂上まで上る方法は何通りあるでしょうか。</p> <p>下図に示すように、第 \\(3\\) 段まで上る実行可能な方法は \\(2\\) 通りしか残りません。そのうち、\\(1\\) 段ずつ 3 回連続で上る方法は制約を満たさないため除外されます。</p> <p></p> <p> 図 14-8   制約付きで第 3 段まで上る方法数 </p> <p>この問題では、前回が \\(1\\) 段上りだった場合、次回は必ず \\(2\\) 段上らなければなりません。これは、**次の一手が現在の状態（現在いる階段の段数）だけでは独立に決まらず、一つ前の状態（前回いた段数）にも関係する**ことを意味します。</p> <p>容易に分かるように、この問題はもはや無後効性を満たしておらず、状態遷移方程式 \\(dp[i] = dp[i-1] + dp[i-2]\\) も成立しません。というのも、\\(dp[i-1]\\) は今回 \\(1\\) 段上る場合を表しますが、その中には「前回も \\(1\\) 段上ってきた」方法が多数含まれており、制約を満たすためには \\(dp[i-1]\\) をそのまま \\(dp[i]\\) に加えることができないからです。</p> <p>このため、状態定義を拡張する必要があります。**状態 \\([i, j]\\) は、第 \\(i\\) 段にいて前回に \\(j\\) 段上ったことを表す**とし、ここで \\(j \\in \\{1, 2\\}\\) です。この状態定義により、前回が \\(1\\) 段上りか \\(2\\) 段上りかを有効に区別でき、現在の状態がどこから来たのかを判断できます。</p> <ul> <li>前回に \\(1\\) 段上った場合、その前の回は \\(2\\) 段上りしか選べないため、\\(dp[i, 1]\\) は \\(dp[i-1, 2]\\) からのみ遷移できます。</li> <li>前回に \\(2\\) 段上った場合、その前の回は \\(1\\) 段上りまたは \\(2\\) 段上りを選べるため、\\(dp[i, 2]\\) は \\(dp[i-2, 1]\\) または \\(dp[i-2, 2]\\) から遷移できます。</li> </ul> <p>下図に示すように、この定義のもとでは \\(dp[i, j]\\) は状態 \\([i, j]\\) に対応する方法数を表します。このとき状態遷移方程式は次のようになります。</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> 図 14-9   制約を考慮した漸化関係 </p> <p>最終的に、\\(dp[n, 1] + dp[n, 2]\\) を返せば十分であり、その和が第 \\(n\\) 段まで上る方法の総数を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"制約付き階段登り：動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[][] dp = new int[n + 1][3];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* 制約付き階段登り：動的計画法 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[,] dp = new int[n + 1, 3];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* 制約付き階段登り：動的計画法 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([][3]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* 制約付き階段登り：動的計画法 */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* 制約付き階段登り：動的計画法 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* 制約付き階段登り：動的計画法 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* 制約付き階段登り：動的計画法 */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* 制約付き階段登り：動的計画法 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(3) }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### 制約付き階段登り：動的計画法 ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上の例では、追加で考慮すべきなのは一つ前の状態だけであるため、状態定義を拡張することで問題を再び無後効性に適合させることができます。しかし、問題によっては非常に強い「後効性」があります。</p> <p>階段昇りと障害物生成</p> <p>全部で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。**第 \\(i\\) 段に到達すると、システムは自動的に第 \\(2i\\) 段に障害物を置き、それ以降はどの回でも第 \\(2i\\) 段へ跳ぶことができない**とします。例えば、最初の 2 回でそれぞれ第 \\(2\\) 段、第 \\(3\\) 段に到達した場合、その後は第 \\(4\\) 段と第 \\(6\\) 段に跳ぶことはできません。頂上まで上る方法は何通りあるでしょうか。</p> <p>この問題では、次の跳躍が過去のすべての状態に依存します。なぜなら、各跳躍がより高い段に障害物を設置し、将来の跳躍に影響するからです。この種の問題は、動的計画法では解きにくいことが多いです。</p> <p>実際、多くの複雑な組合せ最適化問題（例えば巡回セールスマン問題）は無後効性を満たしません。このような問題に対しては、通常、ヒューリスティック探索、遺伝的アルゴリズム、強化学習などの他の方法を用いて、限られた時間内に実用的な局所最適解を得ます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   動的計画法の問題解決の考え方","text":"<p>前の 2 節では動的計画法の問題の主要な特徴を紹介しました。ここからは、さらに実用的な 2 つの問題を一緒に考えていきます。</p> <ol> <li>ある問題が動的計画法の問題かどうかを、どのように判断すればよいでしょうか？</li> <li>動的計画法の問題を解くには、どこから着手し、完全な手順はどのようなものでしょうか？</li> </ol>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   問題の判定","text":"<p>一般に、ある問題が重複部分問題と最適部分構造を含み、さらに無後效性を満たしているなら、通常は動的計画法で解くのに適しています。しかし、問題文からこれらの性質を直接読み取るのは簡単ではありません。そのため通常は条件を少し緩めて、**まずその問題がバックトラッキング（全探索）で解くのに適しているか**を観察します。</p> <p>バックトラッキングで解くのに適した問題は、通常「決定木モデル」を満たします。この種の問題は木構造で表現でき、各ノードは 1 つの決定を表し、各経路は 1 つの決定列を表します。</p> <p>言い換えると、問題に明確な決定の概念が含まれており、解が一連の決定によって生成されるなら、その問題は決定木モデルを満たし、通常はバックトラッキングで解くことができます。</p> <p>これに加えて、動的計画法の問題には判定のための「加点要素」もあります。</p> <ul> <li>問題文に最大（最小）や最多（最少）などの最適化に関する記述がある。</li> <li>問題の状態が配列、多次元行列、または木で表現でき、ある状態とその周辺の状態の間に漸化的な関係がある。</li> </ul> <p>反対に、「減点要素」もあります。</p> <ul> <li>問題の目的が最適解を求めることではなく、あり得るすべての解を列挙することである。</li> <li>問題文に明確な順列・組合せの特徴があり、具体的な複数の解を返す必要がある。</li> </ul> <p>ある問題が決定木モデルを満たし、さらに比較的明確な「加点要素」を備えているなら、その問題は動的計画法の問題であると仮定し、解く過程でそれを検証できます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   問題を解く手順","text":"<p>動的計画法の解法の流れは問題の性質や難易度によって異なりますが、通常は次の手順に従います。すなわち、決定を記述し、状態を定義し、\\(dp\\) テーブルを構築し、状態遷移方程式を導出し、境界条件を定めます。</p> <p>解法の手順をより具体的に示すために、ここでは古典的な問題である「最小経路和」を例にします。</p> <p>Question</p> <p>\\(n \\times m\\) の 2 次元グリッド <code>grid</code> が与えられます。グリッドの各セルには非負整数が格納されており、そのセルのコストを表します。ロボットは左上のセルを始点とし、毎回下または右に 1 マスだけ移動して、右下のセルまで進みます。左上から右下までの最小経路和を返してください。</p> <p>次の図は 1 つの例を示しており、このグリッドの最小経路和は \\(13\\) です。</p> <p></p> <p> 図 14-10   最小経路和のサンプルデータ </p> <p>ステップ 1：各ラウンドの決定を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>この問題における各ラウンドの決定は、現在のマスから下または右へ 1 マス進むことです。現在のマスの行・列インデックスを \\([i, j]\\) とすると、下または右へ 1 マス進んだ後のインデックスは \\([i+1, j]\\) または \\([i, j+1]\\) になります。したがって、状態には行インデックスと列インデックスの 2 つの変数を含め、\\([i, j]\\) と表します。</p> <p>状態 \\([i, j]\\) に対応する部分問題は、始点 \\([0, 0]\\) から \\([i, j]\\) まで進む最小経路和であり、その解を \\(dp[i, j]\\) と記します。</p> <p>これで、次の図に示す 2 次元の \\(dp\\) 行列が得られます。そのサイズは入力グリッド \\(grid\\) と同じです。</p> <p></p> <p> 図 14-11   状態の定義と dp テーブル </p> <p>Note</p> <p>動的計画法とバックトラッキングの過程は、いずれも 1 つの決定列として記述できます。そして状態は、すべての決定変数から構成されます。状態には解法の進行状況を表すすべての変数が含まれているべきであり、次の状態を導くのに十分な情報を持っている必要があります。</p> <p>各状態は 1 つの部分問題に対応しており、すべての部分問題の解を保存するために \\(dp\\) テーブルを定義します。状態の各独立変数は、\\(dp\\) テーブルの 1 つの次元に対応します。本質的に、\\(dp\\) テーブルは状態と部分問題の解との対応関係です。</p> <p>ステップ 2：最適部分構造を見つけ、状態遷移方程式を導出する</p> <p>状態 \\([i, j]\\) は、上のマス \\([i-1, j]\\) または左のマス \\([i, j-1]\\) からしか遷移してきません。したがって最適部分構造は、\\([i, j]\\) に到達する最小経路和が、\\([i, j-1]\\) の最小経路和と \\([i-1, j]\\) の最小経路和のうち小さい方によって決まる、ということです。</p> <p>以上の分析から、次の図に示す状態遷移方程式を導くことができます。</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> 図 14-12   最適部分構造と状態遷移方程式 </p> <p>Note</p> <p>定義済みの \\(dp\\) テーブルに基づいて、元の問題と部分問題の関係を考え、部分問題の最適解から元の問題の最適解を構成する方法、すなわち最適部分構造を見つけます。</p> <p>ひとたび最適部分構造が見つかれば、それを使って状態遷移方程式を構築できます。</p> <p>ステップ 3：境界条件と状態遷移の順序を決める</p> <p>この問題では、先頭行にある状態は左の状態からしか得られず、先頭列にある状態は上の状態からしか得られません。したがって、先頭行 \\(i = 0\\) と先頭列 \\(j = 0\\) が境界条件になります。</p> <p>次の図に示すように、各マスは左のマスと上のマスから遷移してくるため、ループを用いて行列を走査します。外側のループで各行を、内側のループで各列を走査します。</p> <p></p> <p> 図 14-13   境界条件と状態遷移の順序 </p> <p>Note</p> <p>境界条件は、動的計画法では \\(dp\\) テーブルの初期化に使われ、探索では枝刈りに使われます。</p> <p>状態遷移の順序で重要なのは、現在の問題の解を計算するときに、それが依存するより小さな部分問題の解がすべてすでに正しく計算済みであることを保証する点です。</p> <p>以上の分析により、すでに動的計画法のコードを直接書くことができます。しかし、部分問題への分解はトップダウンの考え方であるため、「力任せ探索 \\(\\rightarrow\\) メモ化探索 \\(\\rightarrow\\) 動的計画法」の順に実装するほうが、思考の流れにはより自然です。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-1","level":3,"title":"1.   方法 1：力任せ探索","text":"<p>状態 \\([i, j]\\) から探索を開始し、より小さな状態 \\([i-1, j]\\) と \\([i, j-1]\\) へと分解していきます。再帰関数には次の要素が含まれます。</p> <ul> <li>再帰引数：状態 \\([i, j]\\) 。</li> <li>戻り値：\\([0, 0]\\) から \\([i, j]\\) までの最小経路和 \\(dp[i, j]\\) 。</li> <li>終了条件：\\(i = 0\\) かつ \\(j = 0\\) のとき、コスト \\(grid[0, 0]\\) を返す。</li> <li>枝刈り：\\(i &lt; 0\\) または \\(j &lt; 0\\) でインデックスが範囲外になった場合、コスト \\(+\\infty\\) を返し、実行不可能であることを表す。</li> </ul> <p>実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"最小経路和：全探索\"\"\"\n    # 左上のセルなら探索を終了する\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：全探索 */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：全探索 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：全探索 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // 左上のセルなら探索を終了する\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：全探索 */\nfunction minPathSumDFS(grid, i, j) {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：全探索 */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // 左上のセルなら探索を終了する\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  if (i &lt; 0 || j &lt; 0) {\n    // Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // 左上隅から (i, j) までの最小経路コストを返す\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：全探索 */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：全探索 */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：全探索 ###\ndef min_path_sum_dfs(grid, i, j)\n  # 左上のセルなら探索を終了する\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # 左上隅から (i, j) までの最小経路コストを返す\n  [left, up].min + grid[i][j]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、\\(dp[2, 1]\\) を根ノードとする再帰木を示しています。この中にはいくつかの重複部分問題が含まれており、その数はグリッド <code>grid</code> のサイズが大きくなるにつれて急激に増加します。</p> <p>本質的に、重複部分問題が生じる理由は、**左上からあるセルへ到達する経路が複数存在すること**にあります。</p> <p></p> <p> 図 14-14   力任せ探索の再帰木 </p> <p>各状態には下と右の 2 通りの選択肢があり、左上から右下まで進むには合計で \\(m + n - 2\\) 歩必要です。したがって最悪時間計算量は \\(O(2^{m + n})\\) です。ここで、\\(n\\) と \\(m\\) はそれぞれグリッドの行数と列数を表します。なお、この見積もりではグリッド境界付近の状況を考慮していません。境界に達すると選択肢は 1 つだけになるため、実際の経路数はこれより少なくなります。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-2","level":3,"title":"2.   方法 2：メモ化探索","text":"<p>グリッド <code>grid</code> と同じサイズのメモ配列 <code>mem</code> を導入し、各部分問題の解を記録して、重複部分問題を枝刈りします。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"最小経路和：メモ化探索\"\"\"\n    # 左上のセルなら探索を終了する\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 既に記録があればそのまま返す\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # 左と上のセルからの最小経路コスト\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：メモ化探索 */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：メモ化探索 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：メモ化探索 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // 左上のセルなら探索を終了する\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：メモ化探索 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：メモ化探索 */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // 左上のセルなら探索を終了する\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  if (i &lt; 0 || j &lt; 0) {\n    // Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 既に記録があればそのまま返す\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // 左と上のセルからの最小経路コスト\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // 左上から (i, j) までの最小経路コストを記録して返す\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：メモ化探索 */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 既に記録があればそのまま返す\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // 左と上のセルからの最小経路コスト\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：メモ化探索 */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：メモ化探索 ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # 左上のセルなら探索を終了する\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 既に記録があればそのまま返す\n  return mem[i][j] if mem[i][j] != -1\n  # 左と上のセルからの最小経路コスト\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # 左上から (i, j) までの最小経路コストを記録して返す\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図に示すように、メモ化を導入すると、すべての部分問題の解は 1 回だけ計算すればよくなります。したがって時間計算量は状態総数、すなわちグリッドサイズの \\(O(nm)\\) に依存します。</p> <p></p> <p> 図 14-15   メモ化探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-3","level":3,"title":"3.   方法 3：動的計画法","text":"<p>反復に基づいて動的計画法の解法を実装すると、コードは次のようになります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小経路和：動的計画法\"\"\"\n    n, m = len(grid), len(grid[0])\n    # dp テーブルを初期化\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # 状態遷移：先頭行\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # 状態遷移：先頭列\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # 状態遷移: 残りの行と列\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：動的計画法 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：動的計画法 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // dp テーブルを初期化\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：動的計画法 */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：動的計画法 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：動的計画法 */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // 状態遷移：先頭行\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // 状態遷移：先頭列\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：動的計画法 */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // dp テーブルを初期化\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：動的計画法 */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // dp テーブルを初期化\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：動的計画法 ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # dp テーブルを初期化\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # 状態遷移：先頭行\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # 状態遷移：先頭列\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # 状態遷移: 残りの行と列\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は最小経路和の状態遷移の過程を示しています。グリッド全体を走査するため、時間計算量は \\(O(nm)\\) です。</p> <p>配列 <code>dp</code> のサイズは \\(n \\times m\\) であるため、空間計算量は \\(O(nm)\\) です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-16   最小経路和の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   空間最適化","text":"<p>各マスは左のマスと上のマスにのみ関係するため、1 行の配列だけを使って \\(dp\\) テーブルを実装できます。</p> <p>ただし、配列 <code>dp</code> は 1 行分の状態しか表せないため、先頭列の状態を事前に初期化することはできず、各行を走査するときに更新する必要があります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小経路和：空間最適化後の動的計画法\"\"\"\n    n, m = len(grid), len(grid[0])\n    # dp テーブルを初期化\n    dp = [0] * m\n    # 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # 状態遷移：残りの行\n    for i in range(1, n):\n        # 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        # 状態遷移：残りの列\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // dp テーブルを初期化\n    int[] dp = new int[m];\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // dp テーブルを初期化\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // dp テーブルを初期化\n    dp := make([]int, m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt; n; i++ {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 状態遷移：残りの行\n    for i in 1 ..&lt; n {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = new Array(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = new Array(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // 状態遷移：残りの行\n  for (int i = 1; i &lt; n; i++) {\n    // 状態遷移：先頭列\n    dp[0] = dp[0] + grid[i][0];\n    // 状態遷移：残りの列\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // dp テーブルを初期化\n    let mut dp = vec![0; m];\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for i in 1..n {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // dp テーブルを初期化\n    int *dp = calloc(m, sizeof(int));\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // dp テーブルを初期化\n    val dp = IntArray(m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 状態遷移：残りの行\n    for (i in 1..&lt;n) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：空間最適化後の動的計画法 ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # dp テーブルを初期化\n  dp = Array.new(m, 0)\n  # 状態遷移：先頭行\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # 状態遷移：残りの行\n  for i in 1...n\n    # 状態遷移：先頭列\n    dp[0] = dp[0] + grid[i][0]\n    # 状態遷移：残りの列\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   編集距離問題","text":"<p>編集距離は、Levenshtein 距離とも呼ばれ、2つの文字列の相互変換に必要な最小の編集回数を指し、通常は情報検索や自然言語処理において2つの系列の類似度を測るために用いられます。</p> <p>Question</p> <p>2つの文字列 \\(s\\) と \\(t\\) を入力し、\\(s\\) を \\(t\\) に変換するのに必要な最小編集回数を返してください。</p> <p>1つの文字列に対して3種類の編集操作を行えます。1文字の挿入、1文字の削除、任意の文字への置換です。</p> <p>下図に示すように、<code>kitten</code> を <code>sitting</code> に変換するには 3 回の編集が必要で、内訳は 2 回の置換と 1 回の挿入です。<code>hello</code> を <code>algo</code> に変換する場合も 3 回必要で、内訳は 2 回の置換と 1 回の削除です。</p> <p></p> <p> 図 14-27   編集距離のサンプルデータ </p> <p>編集距離問題は決定木モデルで自然に説明できます。文字列が木のノードに対応し、1回の決定（1回の編集操作）が木の1本の辺に対応します。</p> <p>下図に示すように、操作に制限がない場合、各ノードからは多くの辺を派生でき、それぞれの辺が1種類の操作に対応します。これは <code>hello</code> から <code>algo</code> への変換に多くの経路があり得ることを意味します。</p> <p>決定木の観点から見ると、本問の目標はノード <code>hello</code> とノード <code>algo</code> の間の最短経路を求めることです。</p> <p></p> <p> 図 14-28   決定木モデルに基づく編集距離問題の表現 </p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   動的計画法の考え方","text":"<p>第1ステップ：各ラウンドの決定を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>各ラウンドの決定は、文字列 \\(s\\) に対して1回の編集操作を行うことです。</p> <p>編集操作の過程で問題の規模が徐々に小さくなることを期待します。そうして初めて部分問題を構築できます。文字列 \\(s\\) と \\(t\\) の長さをそれぞれ \\(n\\) と \\(m\\) とし、まず両文字列の末尾の文字 \\(s[n-1]\\) と \\(t[m-1]\\) を考えます。</p> <ul> <li>\\(s[n-1]\\) と \\(t[m-1]\\) が同じなら、それらをスキップして、直接 \\(s[n-2]\\) と \\(t[m-2]\\) を考えます。</li> <li>\\(s[n-1]\\) と \\(t[m-1]\\) が異なるなら、\\(s\\) に対して1回の編集（挿入、削除、置換）を行い、両文字列の末尾の文字を同じにします。そうすることでそれらをスキップし、より小さい問題を考えられます。</li> </ul> <p>つまり、文字列 \\(s\\) に対する各ラウンドの決定（編集操作）は、\\(s\\) と \\(t\\) における残りの未一致文字を変化させます。したがって、状態は現在 \\(s\\) と \\(t\\) で考えている第 \\(i\\) と第 \\(j\\) 文字とし、\\([i, j]\\) と記します。</p> <p>状態 \\([i, j]\\) に対応する部分問題は、**\\(s\\) の先頭 \\(i\\) 文字を \\(t\\) の先頭 \\(j\\) 文字に変換するのに必要な最小編集回数**です。</p> <p>これにより、サイズが \\((i+1) \\times (j+1)\\) の2次元 \\(dp\\) テーブルが得られます。</p> <p>第2ステップ：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>部分問題 \\(dp[i, j]\\) を考えます。これに対応する2つの文字列の末尾文字は \\(s[i-1]\\) と \\(t[j-1]\\) であり、編集操作の違いに応じて下図の3つの場合に分けられます。</p> <ol> <li>\\(s[i-1]\\) の後ろに \\(t[j-1]\\) を追加する。このとき残る部分問題は \\(dp[i, j-1]\\) です。</li> <li>\\(s[i-1]\\) を削除する。このとき残る部分問題は \\(dp[i-1, j]\\) です。</li> <li>\\(s[i-1]\\) を \\(t[j-1]\\) に置き換える。このとき残る部分問題は \\(dp[i-1, j-1]\\) です。</li> </ol> <p></p> <p> 図 14-29   編集距離の状態遷移 </p> <p>以上の分析から、最適部分構造は次のように得られます。\\(dp[i, j]\\) の最小編集回数は、\\(dp[i, j-1]\\)、\\(dp[i-1, j]\\)、\\(dp[i-1, j-1]\\) の3つのうち最小の編集回数に、今回の編集回数 \\(1\\) を加えたものです。対応する状態遷移方程式は次のとおりです：</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>注意すべき点として、\\(s[i-1]\\) と \\(t[j-1]\\) が同じ場合、現在の文字を編集する必要はありません。この場合の状態遷移方程式は次のとおりです：</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>第3ステップ：境界条件と状態遷移の順序を決める</p> <p>2つの文字列がともに空のとき、編集回数は \\(0\\)、すなわち \\(dp[0, 0] = 0\\) です。\\(s\\) が空で \\(t\\) が空でないとき、最小編集回数は \\(t\\) の長さに等しいため、先頭行は \\(dp[0, j] = j\\) です。\\(s\\) が空でなく \\(t\\) が空のとき、最小編集回数は \\(s\\) の長さに等しいため、先頭列は \\(dp[i, 0] = i\\) です。</p> <p>状態遷移方程式を観察すると、\\(dp[i, j]\\) の解は左、上、左上の解に依存します。そのため、2重ループで \\(dp\\) テーブル全体を順方向に走査すれば十分です。</p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   コードの実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"編集距離：動的計画法\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # 状態遷移：先頭行と先頭列\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # 状態遷移: 残りの行と列\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編集距離：動的計画法 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編集距離：動的計画法 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // 状態遷移：先頭行と先頭列\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編集距離：動的計画法 */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // 状態遷移：先頭行と先頭列\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編集距離：動的計画法 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // 状態遷移：先頭行と先頭列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編集距離：動的計画法 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // 状態遷移：先頭行と先頭列\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編集距離：動的計画法 */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // 状態遷移：先頭行と先頭列\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編集距離：動的計画法 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // 状態遷移：先頭行と先頭列\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編集距離：動的計画法 ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # 状態遷移：先頭行と先頭列\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # 状態遷移: 残りの行と列\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図に示すように、編集距離問題の状態遷移の過程はナップサック問題と非常によく似ており、どちらも2次元グリッドを埋めていく過程とみなせます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-30   編集距離の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   空間最適化","text":"<p>\\(dp[i,j]\\) は上の \\(dp[i-1, j]\\)、左の \\(dp[i, j-1]\\)、左上の \\(dp[i-1, j-1]\\) から遷移されますが、順方向走査では左上の \\(dp[i-1, j-1]\\) を失い、逆方向走査では \\(dp[i, j-1]\\) を事前に構築できません。そのため、どちらの走査順序も適切ではありません。</p> <p>そのため、変数 <code>leftup</code> を用いて左上の解 \\(dp[i-1, j-1]\\) を一時保存し、左と上の解だけを考えればよくなります。このときの状況は完全ナップサック問題と同じであり、順方向走査を用いることができます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"編集距離：空間最適化した動的計画法\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # 状態遷移：先頭行\n    for j in range(1, m + 1):\n        dp[j] = j\n    # 状態遷移：残りの行\n    for i in range(1, n + 1):\n        # 状態遷移：先頭列\n        leftup = dp[0]  # dp[i-1, j-1] を一時保存する\n        dp[0] += 1\n        # 状態遷移：残りの列\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            else:\n                # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # 次の反復の dp[i-1, j-1] に更新する\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // 状態遷移：先頭行\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for i := 1; i &lt;= n; i++ {\n        // 状態遷移：先頭列\n        leftUp := dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftUp\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // 状態遷移：先頭行\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for i in 1 ... n {\n        // 状態遷移：先頭列\n        var leftup = dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        let leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        let leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // 状態遷移：先頭行\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // 状態遷移：残りの行\n  for (int i = 1; i &lt;= n; i++) {\n    // 状態遷移：先頭列\n    int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n    dp[0] = i;\n    // 状態遷移：残りの列\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[j] = leftup;\n      } else {\n        // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // 状態遷移：先頭行\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // 状態遷移：残りの行\n    for i in 1..=n {\n        // 状態遷移：先頭列\n        let mut leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i as i32;\n        // 状態遷移：残りの列\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    int res = dp[m];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // 状態遷移：先頭行\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for (i in 1..n) {\n        // 状態遷移：先頭列\n        var leftup = dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編集距離：空間最適化した動的計画法 ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # 状態遷移：先頭行\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # 状態遷移：残りの行\n  for i in 1...(n + 1)\n    # 状態遷移：先頭列\n    leftup = dp.first # dp[i-1, j-1] を一時保存する\n    dp[0] += 1\n    # 状態遷移：残りの列\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[j] = leftup\n      else\n        # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # 次の反復の dp[i-1, j-1] に更新する\n    end\n  end\n  dp[m]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   動的計画法入門","text":"<p>動的計画法（dynamic programming）は重要なアルゴリズムパラダイムであり、問題をより小さな部分問題の列に分解し、それらの解を保存して重複計算を避けることで、時間効率を大幅に向上させます。</p> <p>本節では、古典的な例題から始めて、まずその力任せのバックトラッキング解法を示し、そこに含まれる重複部分問題を観察したうえで、より効率的な動的計画法の解法を段階的に導きます。</p> <p>階段を上る</p> <p>全体で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。頂上まで到達する方法は何通りあるでしょうか？</p> <p>次の図に示すように、\\(3\\) 段の階段では、頂上まで到達する方法は全部で \\(3\\) 通りあります。</p> <p></p> <p> 図 14-1   3 段の階段を上る方法の数 </p> <p>この問題の目的は方法の総数を求めることです。考えられるすべての可能性をバックトラッキングで総当たりすることができます。具体的には、階段を上ることを複数ラウンドの選択過程とみなし、地面から出発して各ラウンドで \\(1\\) 段または \\(2\\) 段上ります。階段の頂上に到達するたびに方法数を \\(1\\) 増やし、頂上を越えた場合は枝刈りします。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"バックトラッキング\"\"\"\n    # 第 n 段に到達したら、方法数を 1 増やす\n    if state == n:\n        res[0] += 1\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n:\n            continue\n        # 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res)\n        # バックトラック\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"階段登り：バックトラッキング\"\"\"\n    choices = [1, 2]  # 1 段または 2 段上ることを選べる\n    state = 0  # 第 0 段から上り始める\n    res = [0]  # res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* バックトラッキング */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    for (auto &amp;choice : choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // 1 段または 2 段上ることを選べる\n    int state = 0;                // 第 0 段から上り始める\n    vector&lt;int&gt; res = {0};        // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* バックトラッキング */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (Integer choice : choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // 1 段または 2 段上ることを選べる\n    int state = 0; // 第 0 段から上り始める\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* バックトラッキング */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    foreach (int choice in choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        Backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    int state = 0; // 第 0 段から上り始める\n    List&lt;int&gt; res = [0]; // res[0] を使って方法数を記録する\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* バックトラッキング */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // すべての選択肢を走査\n    for _, choice := range choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state+choice &gt; n {\n            continue\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state+choice, n, res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunc climbingStairsBacktrack(n int) int {\n    // 1 段または 2 段上ることを選べる\n    choices := []int{1, 2}\n    // 第 0 段から上り始める\n    state := 0\n    res := make([]int, 1)\n    // res[0] を使って方法数を記録する\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* バックトラッキング */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] += 1\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n {\n            continue\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // 1 段または 2 段上ることを選べる\n    let state = 0 // 第 0 段から上り始める\n    var res: [Int] = []\n    res.append(0) // res[0] を使って方法数を記録する\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* バックトラッキング */\nfunction backtrack(choices, state, n, res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state === n) res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    const state = 0; // 第 0 段から上り始める\n    const res = new Map();\n    res.set(0, 0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* バックトラッキング */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state === n) res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    const state = 0; // 第 0 段から上り始める\n    const res = new Map();\n    res.set(0, 0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* バックトラッキング */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // 第 n 段に到達したら、方法数を 1 増やす\n  if (state == n) {\n    res[0]++;\n  }\n  // すべての選択肢を走査\n  for (int choice in choices) {\n    // 枝刈り: 第 n 段を超えないようにする\n    if (state + choice &gt; n) continue;\n    // 試行: 選択を行い、状態を更新\n    backtrack(choices, state + choice, n, res);\n    // バックトラック\n  }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // 1 段または 2 段上ることを選べる\n  int state = 0; // 第 0 段から上り始める\n  List&lt;int&gt; res = [];\n  res.add(0); // res[0] を使って方法数を記録する\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* バックトラッキング */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // すべての選択肢を走査\n    for &amp;choice in choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n {\n            continue;\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // 1 段または 2 段上ることを選べる\n    let state = 0; // 第 0 段から上り始める\n    let mut res = Vec::new();\n    res.push(0); // res[0] を使って方法数を記録する\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* バックトラッキング */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res, len);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // 1 段または 2 段上ることを選べる\n    int state = 0;           // 第 0 段から上り始める\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // res[0] を使って方法数を記録する\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* バックトラッキング */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0] = res[0] + 1\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // 1 段または 2 段上ることを選べる\n    val state = 0 // 第 0 段から上り始める\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### バックトラッキング ###\ndef backtrack(choices, state, n, res)\n  # 第 n 段に到達したら、方法数を 1 増やす\n  res[0] += 1 if state == n\n  # すべての選択肢を走査\n  for choice in choices\n    # 枝刈り: 第 n 段を超えないようにする\n    next if state + choice &gt; n\n\n    # 試行: 選択を行い、状態を更新\n    backtrack(choices, state + choice, n, res)\n  end\n  # バックトラック\nend\n\n### 階段登り：バックトラッキング ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # 1 段または 2 段上ることを選べる\n  state = 0 # 第 0 段から上り始める\n  res = [0] # res[0] を使って方法数を記録する\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-1","level":2,"title":"14.1.1   方法 1：総当たり探索","text":"<p>バックトラッキング法は通常、問題を明示的に分解するのではなく、問題解決を一連の意思決定ステップとみなし、試行と枝刈りによってあらゆる可能な解を探索します。</p> <p>この問題を問題分解の観点から分析してみましょう。\\(i\\) 段目まで上る方法が全部で \\(dp[i]\\) 通りあるとすると、\\(dp[i]\\) が元の問題であり、その部分問題には次が含まれます：</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>各ラウンドでは \\(1\\) 段または \\(2\\) 段しか上れないため、\\(i\\) 段目の階段に立っているとき、直前のラウンドでは \\(i - 1\\) 段目または \\(i - 2\\) 段目にしか立てません。言い換えると、\\(i -1\\) 段目または \\(i - 2\\) 段目からしか \\(i\\) 段目へ進めません。</p> <p>ここから重要な帰結が得られます。**\\(i - 1\\) 段目まで上る方法数と \\(i - 2\\) 段目まで上る方法数の和が、\\(i\\) 段目まで上る方法数に等しい**のです。式は次のとおりです：</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>これは、階段を上る問題では各部分問題の間に漸化関係があり、**元の問題の解は部分問題の解から構築できる**ことを意味します。次の図はこの漸化関係を示しています。</p> <p></p> <p> 図 14-2   方法数の漸化関係 </p> <p>漸化式に基づいて総当たり探索の解法を得ることができます。\\(dp[n]\\) を出発点とし、**より大きな問題を再帰的に 2 つのより小さな問題の和へ分解**していき、最小部分問題 \\(dp[1]\\) と \\(dp[2]\\) に到達したら返します。ここで最小部分問題の解は既知であり、\\(dp[1] = 1\\)、\\(dp[2] = 2\\) です。これは、第 \\(1\\) 段目と第 \\(2\\) 段目まで上る方法がそれぞれ \\(1\\) 通り、\\(2\\) 通りであることを表します。</p> <p>次のコードを見ると、標準的なバックトラッキングコードと同じく深さ優先探索に属しますが、より簡潔です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"検索\"\"\"\n    # dp[1] と dp[2] は既知なので返す\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"階段登り：探索\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* 検索 */\nint DFS(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* 検索 */\nfunc dfs(i int) int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* 階段登り：探索 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* 検索 */\nfunc dfs(i: Int) -&gt; Int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* 階段登り：探索 */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* 検索 */\nfunction dfs(i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* 検索 */\nfunction dfs(i: number): number {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* 検索 */\nint dfs(int i) {\n  // dp[1] と dp[2] は既知なので返す\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* 検索 */\nfn dfs(i: usize) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* 階段登り：探索 */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* 検索 */\nfun dfs(i: Int): Int {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* 階段登り：探索 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### 探索 ###\ndef dfs(i)\n  # dp[1] と dp[2] は既知なので返す\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### 階段登り：探索 ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は総当たり探索によって形成される再帰木を示しています。問題 \\(dp[n]\\) に対して、その再帰木の深さは \\(n\\)、時間計算量は \\(O(2^n)\\) です。指数オーダーは爆発的に増加するため、比較的大きな \\(n\\) を入力すると長時間待たされることになります。</p> <p></p> <p> 図 14-3   階段上りに対応する再帰木 </p> <p>上の図を見ると、指数オーダーの時間計算量は「重複部分問題」によって生じています。たとえば \\(dp[9]\\) は \\(dp[8]\\) と \\(dp[7]\\) に分解され、\\(dp[8]\\) は \\(dp[7]\\) と \\(dp[6]\\) に分解されるため、どちらにも部分問題 \\(dp[7]\\) が含まれています。</p> <p>このように、部分問題の中にはさらに小さな重複部分問題が含まれ、それが際限なく続いていきます。計算資源の大部分は、こうした重複部分問題に浪費されています。</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-2","level":2,"title":"14.1.2   方法 2：メモ化探索","text":"<p>アルゴリズム効率を高めるため、**すべての重複部分問題を 1 回だけ計算したい**と考えます。そのために、各部分問題の解を記録する配列 <code>mem</code> を宣言し、探索の過程で重複部分問題を枝刈りします。</p> <ol> <li>\\(dp[i]\\) を初めて計算したとき、その結果を <code>mem[i]</code> に記録して後で使えるようにします。</li> <li>再び \\(dp[i]\\) を計算する必要が生じたときは、<code>mem[i]</code> から直接結果を取得し、その部分問題の重複計算を避けます。</li> </ol> <p>コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"メモ化探索\"\"\"\n    # dp[1] と dp[2] は既知なので返す\n    if i == 1 or i == 2:\n        return i\n    # dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # dp[i] を記録する\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"階段登り：メモ化探索\"\"\"\n    # mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* メモ化探索 */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* メモ化探索 */\nint dfs(int i, int[] mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* メモ化探索 */\nint DFS(int i, int[] mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* メモ化探索 */\nfunc dfsMem(i int, mem []int) int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* メモ化探索 */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* メモ化探索 */\nfunction dfs(i, mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* メモ化探索 */\nfunction dfs(i: number, mem: number[]): number {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* メモ化探索 */\nint dfs(int i, List&lt;int&gt; mem) {\n  // dp[1] と dp[2] は既知なので返す\n  if (i == 1 || i == 2) return i;\n  // dp[i] の記録があれば、それをそのまま返す\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // dp[i] を記録する\n  mem[i] = count;\n  return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n  // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* メモ化探索 */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    count\n}\n\n/* 階段登り：メモ化探索 */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* メモ化探索 */\nint dfs(int i, int *mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* メモ化探索 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2) return i\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### メモ化探索 ###\ndef dfs(i, mem)\n  # dp[1] と dp[2] は既知なので返す\n  return i if i == 1 || i == 2\n  # dp[i] の記録があれば、それをそのまま返す\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # dp[i] を記録する\n  mem[i] = count\nend\n\n### 階段登り：メモ化探索 ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図を見ると、メモ化を行うことで、すべての重複部分問題は 1 回だけ計算すればよくなり、時間計算量は \\(O(n)\\) まで改善されます。これは大きな飛躍です。</p> <p></p> <p> 図 14-4   メモ化探索に対応する再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-3","level":2,"title":"14.1.3   方法 3：動的計画法","text":"<p>**メモ化探索は「トップダウン」の方法**です。元の問題（根ノード）から始めて、より大きな部分問題を再帰的により小さな部分問題へ分解し、解が既知である最小部分問題（葉ノード）に至ります。その後、バックトラックしながら各層で部分問題の解を集め、元の問題の解を構築します。</p> <p>これとは対照的に、**動的計画法は「ボトムアップ」の方法**です。最小部分問題の解から始めて、より大きな部分問題の解を反復的に構築し、最終的に元の問題の解を得ます。</p> <p>動的計画法にはバックトラックの過程が含まれないため、再帰を使う必要はなく、ループによる反復だけで実装できます。次のコードでは、部分問題の解を保存する配列 <code>dp</code> を初期化しており、これはメモ化探索における配列 <code>mem</code> と同じ記録の役割を果たします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"階段登り：動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [0] * (n + 1)\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1], dp[2] = 1, 2\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;int&gt; dp(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 階段登り：動的計画法 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 階段登り：動的計画法 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 階段登り：動的計画法 */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 階段登り：動的計画法 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1).fill(-1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 階段登り：動的計画法 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1).fill(-1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1] = 1;\n  dp[2] = 2;\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 階段登り：動的計画法 */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![-1; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 階段登り：動的計画法 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = IntArray(n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 階段登り：動的計画法 ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = 1, 2\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、以上のコードの実行過程をシミュレートしたものです。</p> <p></p> <p> 図 14-5   階段上りの動的計画法の過程 </p> <p>バックトラッキング法と同様に、動的計画法でも問題解決の特定段階を表すために「状態」という概念を用います。各状態は 1 つの部分問題と、それに対応する局所最適解に対応します。たとえば、階段を上る問題では、状態は現在いる階段の段数 \\(i\\) と定義されます。</p> <p>以上を踏まえると、動的計画法のよく使われる用語を次のようにまとめられます。</p> <ul> <li>配列 <code>dp</code> を dp テーブル と呼び、\\(dp[i]\\) は状態 \\(i\\) に対応する部分問題の解を表します。</li> <li>最小部分問題に対応する状態（第 \\(1\\) 段目と第 \\(2\\) 段目の階段）を初期状態と呼びます。</li> <li>漸化式 \\(dp[i] = dp[i-1] + dp[i-2]\\) を状態遷移方程式と呼びます。</li> </ul>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   空間最適化","text":"<p>注意深い読者は気づいたかもしれません。\\(dp[i]\\) は \\(dp[i-1]\\) と \\(dp[i-2]\\) にしか依存しないため、すべての部分問題の解を保存するために配列 <code>dp</code> を使う必要はありません。2 つの変数を順に更新していくだけで十分です。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"階段登り：空間最適化した動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 階段登り：空間最適化後の動的計画法 ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、配列 <code>dp</code> が占めていた領域を省けるため、空間計算量は \\(O(n)\\) から \\(O(1)\\) へと下がります。</p> <p>動的計画法の問題では、現在の状態はしばしば直前の限られた個数の状態にしか関係しません。このような場合は、必要な状態だけを保持し、「次元削減」によってメモリ空間を節約できます。この空間最適化の技巧は「ローリング変数」または「ローリング配列」と呼ばれます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 ナップサック問題","text":"<p>ナップサック問題は、動的計画法の入門として非常に適した問題であり、動的計画法で最もよく見られる問題形式の1つです。これには 0-1 ナップサック問題、完全ナップサック問題、多重ナップサック問題など、多くの派生があります。</p> <p>本節では、まず最も一般的な 0-1 ナップサック問題を解いていきます。</p> <p>Question</p> <p>\\(n\\) 個の品物が与えられ、\\(i\\) 番目の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量 \\(cap\\) のナップサックがあります。各品物は1回しか選べないとき、ナップサック容量の制約下で入れられる品物の最大価値を求めてください。</p> <p>以下の図を見てみましょう。品物番号 \\(i\\) は \\(1\\) から始まり、配列のインデックスは \\(0\\) から始まるため、品物 \\(i\\) は重さ \\(wgt[i-1]\\)、価値 \\(val[i-1]\\) に対応します。</p> <p></p> <p> 図 14-17   0-1 ナップサックのサンプルデータ </p> <p>0-1 ナップサック問題は、\\(n\\) 回の意思決定からなる過程とみなせます。各品物について「入れない」「入れる」という2つの選択肢があるため、この問題は決定木モデルを満たします。</p> <p>この問題の目的は「ナップサック容量の制約下で入れられる品物の最大価値」を求めることなので、動的計画法の問題である可能性が高いです。</p> <p>ステップ1：各ラウンドの選択を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>各品物について、ナップサックに入れなければ容量は変わらず、入れれば容量は減少します。ここから状態を、現在の品物番号 \\(i\\) とナップサック容量 \\(c\\) として定義し、\\([i, c]\\) と表せます。</p> <p>状態 \\([i, c]\\) に対応する部分問題は、先頭 \\(i\\) 個の品物を容量 \\(c\\) のナップサックに入れるときの最大価値 であり、これを \\(dp[i, c]\\) と記します。</p> <p>求めるべきものは \\(dp[n, cap]\\) なので、サイズ \\((n+1) \\times (cap+1)\\) の2次元 \\(dp\\) テーブルが必要です。</p> <p>ステップ2：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>品物 \\(i\\) に対する選択を行った後に残るのは、先頭 \\(i-1\\) 個の品物に対する部分問題であり、次の2つのケースに分けられます。</p> <ul> <li>品物 \\(i\\) を入れない ：ナップサック容量は変わらず、状態は \\([i-1, c]\\) に変化します。</li> <li>品物 \\(i\\) を入れる ：ナップサック容量は \\(wgt[i-1]\\) だけ減少し、価値は \\(val[i-1]\\) だけ増加して、状態は \\([i-1, c-wgt[i-1]]\\) に変化します。</li> </ul> <p>以上の分析から、この問題の最適部分構造が分かります。すなわち、最大価値 \\(dp[i, c]\\) は、品物 \\(i\\) を入れない場合と入れる場合のうち、より価値の大きい方に等しい ということです。これにより、次の状態遷移方程式を導けます。</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>注意すべき点として、現在の品物の重さ \\(wgt[i - 1]\\) が残りのナップサック容量 \\(c\\) を超える場合は、入れない選択しかできません。</p> <p>ステップ3：境界条件と状態遷移の順序を決める</p> <p>品物がない場合、またはナップサック容量が \\(0\\) の場合、最大価値は \\(0\\) です。すなわち、先頭列 \\(dp[i, 0]\\) と先頭行 \\(dp[0, c]\\) はいずれも \\(0\\) になります。</p> <p>現在の状態 \\([i, c]\\) は、上側の状態 \\([i-1, c]\\) と左上の状態 \\([i-1, c-wgt[i-1]]\\) から遷移してくるため、2重ループで \\(dp\\) テーブル全体を順方向に走査すれば十分です。</p> <p>以上の分析に基づき、次に全探索、メモ化探索、動的計画法の順で実装していきます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-1","level":3,"title":"1.   方法1：全探索","text":"<p>探索コードには次の要素が含まれます。</p> <ul> <li>再帰引数：状態 \\([i, c]\\) です。</li> <li>戻り値：部分問題の解 \\(dp[i, c]\\) です。</li> <li>終了条件：品物番号が範囲外である \\(i = 0\\)、またはナップサックの残り容量が \\(0\\) のとき、再帰を終了して価値 \\(0\\) を返します。</li> <li>枝刈り：現在の品物の重さがナップサックの残り容量を超える場合、入れない選択しかできません。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 ナップサック：総当たり探索\"\"\"\n    # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 or c == 0:\n        return 0\n    # ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // 2つの案のうち価値が大きいほうを返す\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // ナップサック容量を超える場合は、入れない選択しかできない\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // 品物 i を入れない場合と入れる場合の最大価値を計算する\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 2つの案のうち価値が大きいほうを返す\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 全探索 ###\ndef knapsack_dfs(wgt, val, i, c)\n  # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  return 0 if i == 0 || c == 0\n  # ナップサック容量を超える場合は、入れない選択しかできない\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # 品物 i を入れない場合と入れる場合の最大価値を計算する\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 2つの案のうち価値が大きいほうを返す\n  [no, yes].max\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図のように、各品物ごとに「選ばない」「選ぶ」の2つの探索分岐が生じるため、時間計算量は \\(O(2^n)\\) です。</p> <p>再帰木を観察すると、\\(dp[1, 10]\\) などの重複部分問題が存在することが分かります。品物数が多く、ナップサック容量が大きく、特に同じ重さの品物が多い場合には、重複部分問題の数は大幅に増加します。</p> <p></p> <p> 図 14-18   0-1 ナップサック問題の全探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-2","level":3,"title":"2.   方法2：メモ化探索","text":"<p>重複部分問題が一度だけ計算されるようにするため、メモ配列 <code>mem</code> を用いて部分問題の解を記録します。ここで <code>mem[i][c]</code> は \\(dp[i, c]\\) に対応します。</p> <p>メモ化を導入すると、時間計算量は部分問題の数に依存し、すなわち \\(O(n \\times cap)\\) になります。実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 ナップサック：メモ化探索\"\"\"\n    # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 or c == 0:\n        return 0\n    # 既に記録があればそのまま返す\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // 2つの案のうち価値が大きいほうを返す\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 既に記録があればそのまま返す\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // ナップサック容量を超える場合は、入れない選択しかできない\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // 品物 i を入れない場合と入れる場合の最大価値を計算する\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 2 つの案のうち価値が大きい方を記録して返す\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: メモ化探索 ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  return 0 if i == 0 || c == 0\n  # 既に記録があればそのまま返す\n  return mem[i][c] if mem[i][c] != -1\n  # ナップサック容量を超える場合は、入れない選択しかできない\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # 品物 i を入れない場合と入れる場合の最大価値を計算する\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 2 つの案のうち価値が大きい方を記録して返す\n  mem[i][c] = [no, yes].max\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、メモ化探索で剪定された探索分岐を示しています。</p> <p></p> <p> 図 14-19   0-1 ナップサック問題のメモ化探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-3","level":3,"title":"3.   方法3：動的計画法","text":"<p>動的計画法の本質は、状態遷移に従って \\(dp\\) テーブルを埋めていく過程です。コードは次のようになります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 ナップサック：動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 状態遷移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：動的計画法 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：動的計画法 */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：動的計画法 */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 動的計画法 ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図のように、時間計算量と空間計算量はいずれも配列 <code>dp</code> のサイズによって決まり、\\(O(n \\times cap)\\) です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-20   0-1 ナップサック問題の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   空間最適化","text":"<p>各状態は直前の行の状態にしか依存しないため、2つの配列をローテーションして用いることで、空間計算量を \\(O(n^2)\\) から \\(O(n)\\) に削減できます。</p> <p>さらに考えると、1つの配列だけで空間最適化を実現できるでしょうか。観察すると、各状態は真上または左上のマスから遷移してきます。配列が1つしかないと仮定すると、\\(i\\) 行目の走査を開始した時点では、その配列にはまだ \\(i-1\\) 行目の状態が格納されています。</p> <ul> <li>順方向に走査すると、\\(dp[i, j]\\) に到達した時点で、左上にある \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) の値がすでに上書きされている可能性があり、正しい状態遷移結果を得られません。</li> <li>逆方向に走査すれば、上書きの問題は発生せず、状態遷移を正しく行えます。</li> </ul> <p>次の図は、単一配列のもとで \\(i = 1\\) 行目から \\(i = 2\\) 行目へ変換する過程を示しています。順方向走査と逆方向走査の違いを考えてみてください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-21   0-1 ナップサックの空間最適化後の動的計画法の過程 </p> <p>コード実装では、配列 <code>dp</code> の第1次元 \\(i\\) をそのまま削除し、内側のループを逆方向走査に変更するだけで済みます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 ナップサック：空間最適化後の動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [0] * (cap + 1)\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 逆順に走査する\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([]int, cap+1)\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 逆順に走査する\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        // 逆順に走査する\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(cap + 1).fill(0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(cap + 1).fill(0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    // 逆順に走査する\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; cap + 1];\n    // 状態遷移\n    for i in 1..=n {\n        // 逆順に走査する\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = IntArray(cap + 1)\n    // 状態遷移\n    for (i in 1..n) {\n        // 逆順に走査する\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 空間最適化後の動的計画法 ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(cap + 1, 0)\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 逆順に走査する\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   まとめ","text":"","path":["第 14 章 &nbsp; 動的計画法","14.7 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>動的計画法は問題を分解し、部分問題の解を保存することで重複計算を避け、計算効率を高めます。</li> <li>時間を考慮しなければ、すべての動的計画法の問題はバックトラッキング（総当たり探索）で解けますが、再帰木には大量の重複部分問題が存在するため、効率はきわめて低くなります。メモ化配列を導入すると、計算済みのすべての部分問題の解を保存でき、重複部分問題が 1 回だけ計算されることを保証できます。</li> <li>メモ化探索はトップダウンの再帰的解法であり、それに対応する動的計画法はボトムアップの漸化式による解法で、ちょうど「表を埋める」ようなものです。現在の状態は一部の局所状態にのみ依存するため、\\(dp\\) 表の 1 次元を削減して空間計算量を下げることができます。</li> <li>部分問題への分解は汎用的なアルゴリズムの考え方であり、分割統治、動的計画法、バックトラッキングではそれぞれ異なる性質を持ちます。</li> <li>動的計画法の問題には 3 つの大きな特徴があります。重複部分問題、最適部分構造、無後効性です。</li> <li>元の問題の最適解が部分問題の最適解から構築できるなら、その問題は最適部分構造を持ちます。</li> <li>無後効性とは、ある状態の将来の発展がその状態のみに関係し、過去に経たすべての状態とは無関係であることを指します。多くの組合せ最適化問題は無後効性を持たず、動的計画法で高速に解くことはできません。</li> </ul> <p>ナップサック問題</p> <ul> <li>ナップサック問題は最も典型的な動的計画法の問題の 1 つであり、0-1 ナップサック、完全ナップサック、多重ナップサックなどの派生があります。</li> <li>0-1 ナップサックの状態は、容量 \\(c\\) のナップサックに対して、前 \\(i\\) 個の品物で得られる最大価値として定義されます。ナップサックに入れない場合と入れる場合の 2 つの判断から最適部分構造を得て、状態遷移方程式を構築できます。空間最適化では、各状態が真上と左上の状態に依存するため、左上の状態が上書きされるのを避けるために配列を逆順に走査する必要があります。</li> <li>完全ナップサック問題では各品物の選択数に制限がないため、品物を入れる場合の状態遷移は 0-1 ナップサック問題とは異なります。状態は真上と真左の状態に依存するので、空間最適化では順方向に走査するべきです。</li> <li>コイン両替問題は完全ナップサック問題の変種です。「最大」価値を求める問題から「最小」の硬貨枚数を求める問題へ変わるため、状態遷移方程式の \\(\\max()\\) は \\(\\min()\\) に置き換える必要があります。また、ナップサック容量を「超えない」ことを目指すのではなく、目標金額を「ちょうど」作ることを目指すため、\\(amt + 1\\) を「目標金額を作れない」無効解の表現として用います。</li> <li>コイン両替問題 II では、「最少硬貨枚数」を求める問題から「硬貨の組合せ数」を求める問題へ変わるため、状態遷移方程式も \\(\\min()\\) から総和演算子へ対応して変わります。</li> </ul> <p>編集距離問題</p> <ul> <li>編集距離（Levenshtein 距離）は 2 つの文字列間の類似度を測るために用いられ、ある文字列を別の文字列へ変換するための最小編集回数として定義されます。編集操作には追加、削除、置換が含まれます。</li> <li>編集距離問題の状態は、\\(s\\) の前 \\(i\\) 文字を \\(t\\) の前 \\(j\\) 文字へ変更するのに必要な最小編集回数として定義されます。\\(s[i] \\ne t[j]\\) のときは、追加、削除、置換の 3 つの判断があり、それぞれに対応する残りの部分問題があります。これにより最適部分構造を見いだし、状態遷移方程式を構築できます。一方、\\(s[i] = t[j]\\) のときは現在の文字を編集する必要はありません。</li> <li>編集距離では、状態は真上、真左、左上の状態に依存します。そのため、空間最適化後は順方向でも逆方向でも正しく状態遷移できません。そこで、変数を 1 つ用いて左上の状態を一時保存し、完全ナップサック問題と等価な形へ変換することで、空間最適化後に順方向走査を行えるようにします。</li> </ul>","path":["第 14 章 &nbsp; 動的計画法","14.7 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   完全ナップサック問題","text":"<p>本節では、まずもう 1 つの代表的なナップサック問題である完全ナップサック問題を解き、その特殊例である硬貨交換問題について見ていきます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   完全ナップサック問題","text":"<p>Question</p> <p>\\(n\\) 個の品物が与えられ、\\(i\\) 番目の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量 \\(cap\\) のナップサックがあります。各品物は繰り返し選択できます。ナップサック容量の制約下で入れられる品物の最大価値を求めてください。例を以下の図に示します。</p> <p></p> <p> 図 14-22   完全ナップサック問題のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   動的計画法の考え方","text":"<p>完全ナップサック問題は 0-1 ナップサック問題と非常によく似ています。違いは、品物の選択回数に制限がない点だけです。</p> <ul> <li>0-1 ナップサック問題では、各品物は 1 つしかないため、品物 \\(i\\) をナップサックに入れた後は先頭 \\(i-1\\) 個の品物からしか選べません。</li> <li>完全ナップサック問題では、各品物の数は無限であるため、品物 \\(i\\) をナップサックに入れた後も、引き続き先頭 \\(i\\) 個の品物から選べます。</li> </ul> <p>完全ナップサック問題では、状態 \\([i, c]\\) の変化は 2 つの場合に分けられます。</p> <ul> <li>品物 \\(i\\) を入れない ：0-1 ナップサック問題と同様に、\\([i-1, c]\\) へ遷移します。</li> <li>品物 \\(i\\) を入れる ：0-1 ナップサック問題とは異なり、\\([i, c-wgt[i-1]]\\) へ遷移します。</li> </ul> <p>したがって、状態遷移方程式は次のようになります。</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   コード実装","text":"<p>2 つの問題のコードを比較すると、状態遷移の中で 1 か所だけ \\(i-1\\) が \\(i\\) に変わり、それ以外は完全に同じです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全ナップサック問題：動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 状態遷移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全ナップサック問題：動的計画法 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全ナップサック問題：動的計画法 */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全ナップサック問題：動的計画法 */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全ナップサック：動的計画法 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   空間最適化","text":"<p>現在の状態は左側と上側の状態から遷移してくるため、空間最適化後は \\(dp\\) テーブルの各行を順方向に走査する必要があります。</p> <p>この走査順序は 0-1 ナップサックとはちょうど逆です。両者の違いは次の図を用いて理解してください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-23   完全ナップサック問題における空間最適化後の動的計画法の過程 </p> <p>コード実装は比較的簡単で、配列 <code>dp</code> の第 1 次元を削除するだけです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全ナップサック問題：空間最適化後の動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [0] * (cap + 1)\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([]int, cap+1)\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; cap + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = IntArray(cap + 1)\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全ナップサック：動的計画法 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n# ## 完全ナップサック: 空間最適化後の動的計画法 ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(cap + 1, 0)\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   硬貨交換問題","text":"<p>ナップサック問題は動的計画法の代表的な問題群であり、多くの派生問題があります。硬貨交換問題もその 1 つです。</p> <p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は繰り返し選択できます。目標金額を作るために必要な最小の硬貨枚数を求めてください。目標金額を作れない場合は \\(-1\\) を返します。例を以下の図に示します。</p> <p></p> <p> 図 14-24   硬貨交換問題のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   動的計画法の考え方","text":"<p>硬貨交換は完全ナップサック問題の特殊なケースとみなせます。両者には次の対応関係と相違点があります。</p> <ul> <li>2 つの問題は相互に変換でき、「品物」は「硬貨」、「品物の重さ」は「硬貨の額面」、「ナップサック容量」は「目標金額」に対応します。</li> <li>最適化の目標は逆であり、完全ナップサック問題は品物価値の最大化、硬貨交換問題は硬貨枚数の最小化を目指します。</li> <li>完全ナップサック問題はナップサック容量を「超えない」解を求めますが、硬貨交換は目標金額に「ちょうど」一致する解を求めます。</li> </ul> <p>ステップ 1：各ラウンドの選択を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>状態 \\([i, a]\\) に対応する部分問題は、**先頭 \\(i\\) 種類の硬貨で金額 \\(a\\) を作るための最小硬貨枚数**であり、これを \\(dp[i, a]\\) と表します。</p> <p>2 次元 \\(dp\\) テーブルのサイズは \\((n+1) \\times (amt+1)\\) です。</p> <p>ステップ 2：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>本問の状態遷移方程式は、完全ナップサック問題と比べて次の 2 点が異なります。</p> <ul> <li>本問では最小値を求めるため、演算子 \\(\\max()\\) を \\(\\min()\\) に変更する必要があります。</li> <li>最適化の対象は品物価値ではなく硬貨枚数であるため、硬貨を選んだときは \\(+1\\) すれば十分です。</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>ステップ 3：境界条件と状態遷移順序を決める</p> <p>目標金額が \\(0\\) のとき、それを作るための最小硬貨枚数は \\(0\\) です。つまり、先頭列のすべての \\(dp[i, 0]\\) は \\(0\\) になります。</p> <p>硬貨が 1 枚もない場合、任意の \\(&gt; 0\\) の目標金額を作ることはできません。これは無効解です。状態遷移方程式内の \\(\\min()\\) 関数が無効解を識別して除外できるように、それらを \\(+ \\infty\\) で表すことを考えます。すなわち、先頭行のすべての \\(dp[0, a]\\) を \\(+ \\infty\\) とします。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   コード実装","text":"<p>多くのプログラミング言語には \\(+ \\infty\\) を表す変数が用意されていないため、通常は整数型 <code>int</code> の最大値で代用します。しかし、その場合は大きな数のオーバーフローが起こり得ます。状態遷移方程式中の \\(+ 1\\) 操作で桁あふれが発生する可能性があるためです。</p> <p>そのため、ここでは数値 \\(amt + 1\\) を無効解の表現として用います。金額 \\(amt\\) を作るための硬貨枚数は最大でも \\(amt\\) 枚だからです。最後に返す前に、\\(dp[n, amt]\\) が \\(amt + 1\\) に等しいかを判定し、等しければ \\(-1\\) を返して目標金額を作れないことを表します。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替：動的計画法\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # dp テーブルを初期化\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 状態遷移：先頭行と先頭列\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # 状態遷移: 残りの行と列\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][amt + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* コイン両替：動的計画法 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, amt + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 状態遷移：先頭行と先頭列\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 状態遷移：先頭行と先頭列\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* コイン両替：動的計画法 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* コイン両替：動的計画法 */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 状態遷移：先頭行と先頭列\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* コイン両替：動的計画法 */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 状態遷移：先頭行と先頭列\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* コイン両替：動的計画法 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 状態遷移：先頭行と先頭列\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### コイン両替：動的計画法 ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 状態遷移：先頭行と先頭列\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # 状態遷移: 残りの行と列\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は硬貨交換の動的計画法の過程を示しており、完全ナップサック問題と非常によく似ています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-25   硬貨交換問題の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   空間最適化","text":"<p>硬貨交換の空間最適化の方法は、完全ナップサック問題と同じです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン交換：空間最適化後の動的計画法\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # dp テーブルを初期化\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            else:\n                # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // dp テーブルを初期化\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 順方向に走査する\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // dp テーブルを初期化\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a];\n      } else {\n        // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // dp テーブルを初期化\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // dp テーブルを初期化\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### コイン両替：空間最適化した動的計画法 ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # dp テーブルを初期化\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a]\n      else\n        # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   硬貨交換問題 II","text":"<p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は繰り返し選択できるとして、**目標金額を作る硬貨の組合せ数**を求めてください。例を以下の図に示します。</p> <p></p> <p> 図 14-26   硬貨交換問題 II のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   動的計画法の考え方","text":"<p>前問と比べて、本問の目的は組合せ数を求めることです。そのため、部分問題は 先頭 \\(i\\) 種類の硬貨で金額 \\(a\\) を作れる組合せ数 になります。一方、\\(dp\\) テーブルは引き続きサイズ \\((n+1) \\times (amt + 1)\\) の 2 次元行列です。</p> <p>現在の状態における組合せ数は、現在の硬貨を選ばない場合と選ぶ場合の 2 つの選択肢の組合せ数の和に等しくなります。状態遷移方程式は次のとおりです。</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>目標金額が \\(0\\) のときは、どの硬貨も選ばなくても目標金額を作れるため、先頭列のすべての \\(dp[i, 0]\\) を \\(1\\) に初期化します。硬貨がないときは、任意の \\(&gt;0\\) の目標金額を作れないため、先頭行のすべての \\(dp[0, a]\\) は \\(0\\) になります。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   コード実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替 II：動的計画法\"\"\"\n    n = len(coins)\n    # dp テーブルを初期化\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 先頭列を初期化する\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # 状態遷移\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][amt + 1];\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* コイン両替 II：動的計画法 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, amt + 1];\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* コイン両替 II：動的計画法 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 先頭列を初期化する\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* コイン両替 II：動的計画法 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 先頭列を初期化する\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* コイン両替 II：動的計画法 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 先頭列を初期化する\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* コイン両替 II：動的計画法 */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 先頭列を初期化する\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 先頭列を初期化する\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // コイン i を選ばない場合と選ぶ場合の和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* コイン両替 II：動的計画法 */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 先頭列を初期化する\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* コイン両替 II：動的計画法 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 先頭列を初期化する\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### コイン両替 II：動的計画法 ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 先頭列を初期化する\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a]\n      else\n        # コイン i を選ばない場合と選ぶ場合の和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   空間最適化","text":"<p>空間最適化の方法も同様で、硬貨の次元を削除するだけです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替 II：空間最適化した動的計画法\"\"\"\n    n = len(coins)\n    # dp テーブルを初期化\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            else:\n                # コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // dp テーブルを初期化\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 順方向に走査する\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a];\n      } else {\n        // コイン i を選ばない場合と選ぶ場合の和\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // dp テーブルを初期化\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // dp テーブルを初期化\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### コイン両替 II：空間最適化した動的計画法 ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # dp テーブルを初期化\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a]\n      else\n        # コイン i を選ばない場合と選ぶ場合の和\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"第 9 章   グラフ","text":"<p>Abstract</p> <p>人生の旅路において、私たちはそれぞれ一つひとつのノードのようなものであり、無数の見えない辺によって結ばれています。</p> <p>出会いと別れのたびに、この巨大なネットワークグラフの中に固有の足跡が刻まれます。</p>","path":["第 9 章 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"章の内容","text":"<ul> <li>9.1   グラフ</li> <li>9.2   グラフの基本操作</li> <li>9.3   グラフの走査</li> <li>9.4   まとめ</li> </ul>","path":["第 9 章 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   グラフ","text":"<p>グラフ（graph）は、頂点（vertex）と辺（edge）から構成される非線形データ構造です。グラフ \\(G\\) は、頂点集合 \\(V\\) と辺集合 \\(E\\) からなる集合として抽象的に表せます。以下の例は、5 個の頂点と 7 本の辺を含むグラフを示しています。</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>頂点をノード、辺を各ノードをつなぐ参照（ポインタ）とみなせば、グラフは連結リストを拡張したデータ構造の一種と捉えられます。次の図に示すように、線形関係（連結リスト）や分治関係（木）と比べて、ネットワーク関係（グラフ）は自由度が高く、そのぶん複雑です。</p> <p></p> <p> 図 9-1   連結リスト、木、グラフの関係 </p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   グラフの一般的な種類と用語","text":"<p>辺が方向性を持つかどうかに応じて、無向グラフ（undirected graph）と有向グラフ（directed graph）に分けられます。次の図のとおりです。</p> <ul> <li>無向グラフでは、辺は 2 つの頂点間の「双方向」の接続関係を表します。例えば WeChat や QQ における「友だち関係」です。</li> <li>有向グラフでは、辺は方向性を持ち、すなわち \\(A \\rightarrow B\\) と \\(A \\leftarrow B\\) の 2 方向の辺は互いに独立です。例えば Weibo や Douyin における「フォロー」と「フォロワー」の関係です。</li> </ul> <p></p> <p> 図 9-2   有向グラフと無向グラフ </p> <p>すべての頂点が連結しているかどうかに応じて、連結グラフ（connected graph）と非連結グラフ（disconnected graph）に分けられます。次の図のとおりです。</p> <ul> <li>連結グラフでは、ある頂点から出発すると、ほかの任意の頂点に到達できます。</li> <li>非連結グラフでは、ある頂点から出発すると、少なくとも 1 つの頂点には到達できません。</li> </ul> <p></p> <p> 図 9-3   連結グラフと非連結グラフ </p> <p>辺に「重み」の変数を追加すると、次の図に示すような重み付きグラフ（weighted graph）が得られます。例えば『Honor of Kings』のようなモバイルゲームでは、システムが共にプレイした時間に基づいてプレイヤー間の「親密度」を計算します。この親密度ネットワークは重み付きグラフで表せます。</p> <p></p> <p> 図 9-4   重み付きグラフと重みなしグラフ </p> <p>グラフというデータ構造には、次のような基本用語があります。</p> <ul> <li>隣接（adjacency）：2 つの頂点の間に辺が存在するとき、この 2 つの頂点は「隣接している」といいます。上図では、頂点 1 に隣接する頂点は 2、3、5 です。</li> <li>経路（path）：頂点 A から頂点 B までに通過する辺で構成された列を、A から B への「経路」と呼びます。上図では、辺の列 1-5-2-4 は頂点 1 から頂点 4 への 1 本の経路です。</li> <li>次数（degree）：ある頂点が持つ辺の本数です。有向グラフでは、入次数（in-degree）はその頂点に向かう辺の本数を表し、出次数（out-degree）はその頂点から出る辺の本数を表します。</li> </ul>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   グラフの表現","text":"<p>グラフの一般的な表現方法には「隣接行列」と「隣接リスト」があります。以下では無向グラフを例に説明します。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   隣接行列","text":"<p>グラフの頂点数を \\(n\\) とすると、隣接行列（adjacency matrix）は \\(n \\times n\\) の行列を用いてグラフを表します。各行（列）は 1 つの頂点を表し、行列要素は辺を表します。\\(1\\) または \\(0\\) を用いて、2 つの頂点の間に辺があるかどうかを示します。</p> <p>次の図のように、隣接行列を \\(M\\)、頂点リストを \\(V\\) とすると、行列要素 \\(M[i, j] = 1\\) は頂点 \\(V[i]\\) から頂点 \\(V[j]\\) への辺が存在することを表し、逆に \\(M[i, j] = 0\\) は 2 つの頂点の間に辺がないことを表します。</p> <p></p> <p> 図 9-5   グラフの隣接行列による表現 </p> <p>隣接行列には次の特徴があります。</p> <ul> <li>単純グラフでは、頂点は自分自身とは接続できないため、このとき隣接行列の主対角線上の要素には意味がありません。</li> <li>無向グラフでは、2 方向の辺は等価であるため、このとき隣接行列は主対角線に関して対称です。</li> <li>隣接行列の要素を \\(1\\) と \\(0\\) から重みに置き換えると、重み付きグラフを表せます。</li> </ul> <p>隣接行列でグラフを表す場合、行列要素に直接アクセスして辺を取得できるため、追加・削除・検索・更新の操作効率は高く、時間計算量はいずれも \\(O(1)\\) です。しかし、行列の空間計算量は \\(O(n^2)\\) であり、メモリ使用量は多くなります。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   隣接リスト","text":"<p>隣接リスト（adjacency list）は、\\(n\\) 本の連結リストを使ってグラフを表します。連結リストのノードは頂点を表します。第 \\(i\\) 本の連結リストは頂点 \\(i\\) に対応し、その頂点に隣接するすべての頂点（その頂点と接続された頂点）を格納します。次の図は、隣接リストで保存したグラフの例です。</p> <p></p> <p> 図 9-6   グラフの隣接リストによる表現 </p> <p>隣接リストは実際に存在する辺だけを格納し、辺の総数は通常 \\(n^2\\) よりはるかに小さいため、より省スペースです。しかし、隣接リストでは辺を見つけるために連結リストを走査する必要があるため、時間効率は隣接行列に及びません。</p> <p>上図を見ると、隣接リストの構造はハッシュテーブルにおける「連鎖アドレス法」と非常によく似ているため、同様の方法で効率を最適化できます。例えば、連結リストが長い場合は AVL 木や赤黒木に変換して時間効率を \\(O(n)\\) から \\(O(\\log n)\\) に改善できます。さらに、連結リストをハッシュテーブルに変換すれば、時間計算量を \\(O(1)\\) まで下げられます。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   グラフの一般的な応用","text":"<p>次の表のように、多くの現実のシステムはグラフでモデル化でき、対応する問題もグラフ計算の問題に帰着できます。</p> <p> 表 9-1   現実世界でよく見られるグラフ </p> 頂点 辺 グラフ計算問題 ソーシャルネットワーク ユーザー 友だち関係 潜在的な友だちの推薦 地下鉄路線 駅 駅間の接続性 最短経路の推薦 太陽系 天体 天体間の万有引力作用 惑星軌道の計算","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   グラフの基本操作","text":"<p>グラフの基本操作は、「辺」に対する操作と「頂点」に対する操作に分けられます。「隣接行列」と「隣接リスト」の 2 つの表現方法では、実装方法が異なります。</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   隣接行列に基づく実装","text":"<p>頂点数が \\(n\\) の無向グラフを与えると、各種操作の実装方法は次図のとおりです。</p> <ul> <li>辺の追加または削除：隣接行列で指定した辺を直接変更すればよく、\\(O(1)\\) 時間です。無向グラフであるため、2 方向の辺を同時に更新する必要があります。</li> <li>頂点の追加：隣接行列の末尾に 1 行 1 列を追加し、すべてを \\(0\\) で埋めればよく、\\(O(n)\\) 時間です。</li> <li>頂点の削除：隣接行列から 1 行 1 列を削除します。先頭行と先頭列を削除する場合が最悪で、\\((n-1)^2\\) 個の要素を「左上へ移動」させる必要があるため、\\(O(n^2)\\) 時間です。</li> <li>初期化：\\(n\\) 個の頂点を受け取り、長さ \\(n\\) の頂点リスト <code>vertices</code> を初期化するのに \\(O(n)\\) 時間、サイズ \\(n \\times n\\) の隣接行列 <code>adjMat</code> を初期化するのに \\(O(n^2)\\) 時間かかります。</li> </ul> 隣接行列の初期化辺の追加辺の削除頂点の追加頂点の削除 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-7   隣接行列の初期化、辺の追加と削除、頂点の追加と削除 </p> <p>以下は、隣接行列でグラフを表した実装コードです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"隣接行列に基づく無向グラフクラス\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"コンストラクタ\"\"\"\n        # 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n        self.vertices: list[int] = []\n        # 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n        self.adj_mat: list[list[int]] = []\n        # 頂点を追加\n        for val in vertices:\n            self.add_vertex(val)\n        # 辺を追加\n        # 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"頂点数を取得\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"頂点を追加\"\"\"\n        n = self.size()\n        # 頂点リストに新しい頂点の値を追加\n        self.vertices.append(val)\n        # 隣接行列に 1 行追加\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # 隣接行列に 1 列追加\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"頂点を削除\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # 頂点リストから index の頂点を削除する\n        self.vertices.pop(index)\n        # 隣接行列で index 行を削除する\n        self.adj_mat.pop(index)\n        # 隣接行列で index 列を削除する\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"辺を追加\"\"\"\n        # パラメータ i, j は vertices の要素インデックスに対応する\n        # 範囲外と同値の場合の処理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"辺を削除\"\"\"\n        # パラメータ i, j は vertices の要素インデックスに対応する\n        # 範囲外と同値の場合の処理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"隣接行列を出力\"\"\"\n        print(\"頂点リスト =\", self.vertices)\n        print(\"隣接行列 =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n  public:\n    /* コンストラクタ */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // 頂点を追加\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* 頂点を追加 */\n    void addVertex(int val) {\n        int n = size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.push_back(val);\n        // 隣接行列に 1 行追加\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // 隣接行列に 1 列追加\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        // 頂点リストから index の頂点を削除する\n        vertices.erase(vertices.begin() + index);\n        // 隣接行列で index 行を削除する\n        adjMat.erase(adjMat.begin() + index);\n        // 隣接行列で index 列を削除する\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    void addEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    void removeEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    void print() {\n        cout &lt;&lt; \"頂点リスト = \";\n        printVector(vertices);\n        cout &lt;&lt; \"隣接行列 =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // 頂点を追加\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* 頂点を追加 */\n    public void addVertex(int val) {\n        int n = size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.add(val);\n        // 隣接行列に 1 行追加\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // 隣接行列に 1 列追加\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // 頂点リストから index の頂点を削除する\n        vertices.remove(index);\n        // 隣接行列で index 行を削除する\n        adjMat.remove(index);\n        // 隣接行列で index 列を削除する\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void addEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void removeEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* 隣接行列を出力 */\n    public void print() {\n        System.out.print(\"頂点リスト = \");\n        System.out.println(vertices);\n        System.out.println(\"隣接行列 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    List&lt;List&lt;int&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* 頂点を追加 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.Add(val);\n        // 隣接行列に 1 行追加\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // 隣接行列に 1 列追加\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // 頂点リストから index の頂点を削除する\n        vertices.RemoveAt(index);\n        // 隣接行列で index 行を削除する\n        adjMat.RemoveAt(index);\n        // 隣接行列で index 列を削除する\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void AddEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void RemoveEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    public void Print() {\n        Console.Write(\"頂点リスト = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"隣接行列 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* 隣接行列に基づく無向グラフクラス */\ntype graphAdjMat struct {\n    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    vertices []int\n    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    adjMat [][]int\n}\n\n/* コンストラクタ */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // 頂点を追加\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // グラフを初期化する\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // 辺を追加\n    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* 頂点数を取得 */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* 頂点を追加 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // 頂点リストに新しい頂点の値を追加\n    g.vertices = append(g.vertices, val)\n    // 隣接行列に 1 行追加\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // 隣接行列に 1 列追加\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* 頂点を削除 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // 頂点リストから index の頂点を削除する\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // 隣接行列で index 行を削除する\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // 隣接行列で index 列を削除する\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* 辺を追加 */\n// 引数 i, j は vertices の要素インデックスに対応する\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // インデックスの範囲外と等値の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* 辺を削除 */\n// 引数 i, j は vertices の要素インデックスに対応する\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // インデックスの範囲外と等値の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* 隣接行列を出力 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t頂点リスト = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t隣接行列 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    private var vertices: [Int] // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    private var adjMat: [[Int]] // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // 頂点を追加\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* 頂点を追加 */\n    func addVertex(val: Int) {\n        let n = size()\n        // 頂点リストに新しい頂点の値を追加\n        vertices.append(val)\n        // 隣接行列に 1 行追加\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // 隣接行列に 1 列追加\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* 頂点を削除 */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"範囲外\")\n        }\n        // 頂点リストから index の頂点を削除する\n        vertices.remove(at: index)\n        // 隣接行列で index 行を削除する\n        adjMat.remove(at: index)\n        // 隣接行列で index 列を削除する\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    func addEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"範囲外\")\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    func removeEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"範囲外\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 隣接行列を出力 */\n    func print() {\n        Swift.print(\"頂点リスト = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"隣接行列 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* 頂点を追加 */\n    addVertex(val) {\n        const n = this.size();\n        // 頂点リストに新しい頂点の値を追加\n        this.vertices.push(val);\n        // 隣接行列に 1 行追加\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 隣接行列に 1 列追加\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 頂点リストから index の頂点を削除する\n        this.vertices.splice(index, 1);\n\n        // 隣接行列で index 行を削除する\n        this.adjMat.splice(index, 1);\n        // 隣接行列で index 列を削除する\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    addEdge(i, j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    removeEdge(i, j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    print() {\n        console.log('頂点リスト = ', this.vertices);\n        console.log('隣接行列 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vertices: number[]; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    adjMat: number[][]; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* 頂点を追加 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // 頂点リストに新しい頂点の値を追加\n        this.vertices.push(val);\n        // 隣接行列に 1 行追加\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 隣接行列に 1 列追加\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 頂点リストから index の頂点を削除する\n        this.vertices.splice(index, 1);\n\n        // 隣接行列で index 行を削除する\n        this.adjMat.splice(index, 1);\n        // 隣接行列で index 列を削除する\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    addEdge(i: number, j: number): void {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    removeEdge(i: number, j: number): void {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    print(): void {\n        console.log('頂点リスト = ', this.vertices);\n        console.log('隣接行列 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // 頂点要素。要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n  /* コンストラクタ */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // 頂点を追加\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // 辺を追加\n    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* 頂点数を取得 */\n  int size() {\n    return vertices.length;\n  }\n\n  /* 頂点を追加 */\n  void addVertex(int val) {\n    int n = size();\n    // 頂点リストに新しい頂点の値を追加\n    vertices.add(val);\n    // 隣接行列に 1 行追加\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // 隣接行列に 1 列追加\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* 頂点を削除 */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // 頂点リストから index の頂点を削除する\n    vertices.removeAt(index);\n    // 隣接行列で index 行を削除する\n    adjMat.removeAt(index);\n    // 隣接行列で index 列を削除する\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* 辺を追加 */\n  // 引数 i, j は vertices の要素インデックスに対応する\n  void addEdge(int i, int j) {\n    // インデックスの範囲外と等値の処理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* 辺を削除 */\n  // 引数 i, j は vertices の要素インデックスに対応する\n  void removeEdge(int i, int j) {\n    // インデックスの範囲外と等値の処理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* 隣接行列を出力 */\n  void printAdjMat() {\n    print(\"頂点リスト = $vertices\");\n    print(\"隣接行列 = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* 隣接行列に基づく無向グラフ型 */\npub struct GraphAdjMat {\n    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    pub vertices: Vec&lt;i32&gt;,\n    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* コンストラクタ */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // 頂点を追加\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* 頂点数を取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* 頂点を追加 */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // 頂点リストに新しい頂点の値を追加\n        self.vertices.push(val);\n        // 隣接行列に 1 行追加\n        self.adj_mat.push(vec![0; n]);\n        // 隣接行列に 1 列追加\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // 頂点リストから index の頂点を削除する\n        self.vertices.remove(index);\n        // 隣接行列で index 行を削除する\n        self.adj_mat.remove(index);\n        // 隣接行列で index 列を削除する\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* 辺を追加 */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // パラメータ i, j は vertices の要素インデックスに対応する\n        // 範囲外と同値の場合の処理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // パラメータ i, j は vertices の要素インデックスに対応する\n        // 範囲外と同値の場合の処理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    pub fn print(&amp;self) {\n        println!(\"頂点リスト = {:?}\", self.vertices);\n        println!(\"隣接行列 =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* 隣接行列に基づく無向グラフ構造体 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* コンストラクタ */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* デストラクタ */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* 頂点を追加 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"グラフの頂点数が最大値に達しました\\n\");\n        return;\n    }\n    // n 番目の頂点を追加し、n 行目と n 列目を 0 にする\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* 頂点を削除 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"頂点インデックスが範囲外です\\n\");\n        return;\n    }\n    // 頂点リストから index の頂点を削除する\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // 隣接行列で index 行を削除する\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // 隣接行列で index 列を削除する\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* 辺を追加 */\n// 引数 i, j は vertices の要素インデックスに対応する\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"辺インデックスが範囲外であるか、同一です\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* 辺を削除 */\n// 引数 i, j は vertices の要素インデックスに対応する\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"辺インデックスが範囲外であるか、同一です\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* 隣接行列を出力 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"頂点リスト = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"隣接行列 =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    init {\n        // 頂点を追加\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* 頂点を追加 */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // 頂点リストに新しい頂点の値を追加\n        vertices.add(_val)\n        // 隣接行列に 1 行追加\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // 隣接行列に 1 列追加\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* 頂点を削除 */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // 頂点リストから index の頂点を削除する\n        vertices.removeAt(index)\n        // 隣接行列で index 行を削除する\n        adjMat.removeAt(index)\n        // 隣接行列で index 列を削除する\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    fun addEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    fun removeEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 隣接行列を出力 */\n    fun print() {\n        print(\"頂点リスト = \")\n        println(vertices)\n        println(\"隣接行列 =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### 隣接行列で実装した無向グラフクラス ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### コンストラクタ ###\n    # 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    @vertices = []\n    # 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    @adj_mat = []\n    # 頂点を追加\n    vertices.each { |val| add_vertex(val) }\n    # 辺を追加\n    # 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### 頂点数を取得 ###\n  def size\n    @vertices.length\n  end\n\n  ### 頂点を追加 ###\n  def add_vertex(val)\n    n = size\n    # 頂点リストに新しい頂点の値を追加\n    @vertices &lt;&lt; val\n    # 隣接行列に 1 行追加\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # 隣接行列に 1 列追加\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### 頂点を削除 ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # 頂点リストから index の頂点を削除する\n    @vertices.delete_at(index)\n    # 隣接行列で index 行を削除する\n    @adj_mat.delete_at(index)\n    # 隣接行列で index 列を削除する\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### 辺を追加 ###\n  def add_edge(i, j)\n    # パラメータ i, j は vertices の要素インデックスに対応する\n    # 範囲外と同値の場合の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### 辺を削除 ###\n  def remove_edge(i, j)\n    # パラメータ i, j は vertices の要素インデックスに対応する\n    # 範囲外と同値の場合の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### 隣接行列を出力 ###\n  def __print__\n    puts \"頂点リスト = #{@vertices}\"\n    puts '隣接行列 ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   隣接リストに基づく実装","text":"<p>無向グラフの頂点総数を \\(n\\)、辺総数を \\(m\\) とすると、各種操作は次図の方法で実装できます。</p> <ul> <li>辺の追加：頂点に対応する連結リストの末尾に辺を追加すればよく、\\(O(1)\\) 時間です。無向グラフなので、2 方向の辺を同時に追加する必要があります。</li> <li>辺の削除：頂点に対応する連結リストから指定した辺を探して削除するため、\\(O(m)\\) 時間です。無向グラフでは、2 方向の辺を同時に削除する必要があります。</li> <li>頂点の追加：隣接リストに 1 つの連結リストを追加し、新しい頂点をその連結リストの先頭ノードとするため、\\(O(1)\\) 時間です。</li> <li>頂点の削除：隣接リスト全体を走査し、指定した頂点を含むすべての辺を削除する必要があるため、\\(O(n + m)\\) 時間です。</li> <li>初期化：隣接リストに \\(n\\) 個の頂点と \\(2m\\) 本の辺を作成するため、\\(O(n + m)\\) 時間です。</li> </ul> 隣接リストの初期化辺の追加辺の削除頂点の追加頂点の削除 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-8   隣接リストの初期化、辺の追加と削除、頂点の追加と削除 </p> <p>以下は隣接リストのコード実装です。上図と比べると、実際のコードには次の違いがあります。</p> <ul> <li>頂点の追加と削除を容易にし、コードを簡潔にするため、連結リストの代わりにリスト（動的配列）を使用しています。</li> <li>ハッシュテーブルを用いて隣接リストを格納しており、<code>key</code> は頂点インスタンス、<code>value</code> はその頂点に隣接する頂点のリスト（連結リスト）です。</li> </ul> <p>また、隣接リストでは頂点を表すために <code>Vertex</code> クラスを使用しています。その理由は、もし隣接行列と同様にリストのインデックスで異なる頂点を区別すると、インデックス \\(i\\) の頂点を削除する場合、隣接リスト全体を走査して、\\(i\\) より大きいすべてのインデックスを \\(1\\) 減らす必要があり、効率が非常に低いためです。これに対して、各頂点が一意な <code>Vertex</code> インスタンスであれば、ある頂点を削除しても他の頂点を変更する必要はありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"隣接リストに基づく無向グラフクラス\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"コンストラクタ\"\"\"\n        # 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # すべての頂点と辺を追加\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"頂点数を取得\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"辺を追加\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 辺 vet1 - vet2 を追加\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"辺を削除\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 辺 vet1 - vet2 を削除\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"頂点を追加\"\"\"\n        if vet in self.adj_list:\n            return\n        # 隣接リストに新しいリストを追加\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"頂点を削除\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # 隣接リストから頂点 vet に対応するリストを削除\n        self.adj_list.pop(vet)\n        # 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"隣接リストを出力\"\"\"\n        print(\"隣接リスト =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n  public:\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* vector 内の指定ノードを削除 */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* コンストラクタ */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // すべての頂点と辺を追加\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int size() {\n        return adjList.size();\n    }\n\n    /* 辺を追加 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"頂点が存在しません\");\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* 辺を削除 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"頂点が存在しません\");\n        // 辺 vet1 - vet2 を削除\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* 頂点を追加 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* 頂点を削除 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"頂点が存在しません\");\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.erase(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    void print() {\n        cout &lt;&lt; \"隣接リスト =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* コンストラクタ */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // すべての頂点と辺を追加\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* 辺を追加 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 辺 vet1 - vet2 を追加\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* 辺を削除 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 辺 vet1 - vet2 を削除\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* 頂点を追加 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* 頂点を削除 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.remove(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public void print() {\n        System.out.println(\"隣接リスト =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* コンストラクタ */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // すべての頂点と辺を追加\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* 辺を追加 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* 辺を削除 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* 頂点を追加 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList.Add(vet, []);\n    }\n\n    /* 頂点を削除 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.Remove(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public void Print() {\n        Console.WriteLine(\"隣接リスト =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* 隣接リストに基づく無向グラフクラス */\ntype graphAdjList struct {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList map[Vertex][]Vertex\n}\n\n/* コンストラクタ */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // すべての頂点と辺を追加\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* 頂点数を取得 */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* 辺を追加 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 辺 `vet1 - vet2` を追加し、無名 `struct{}` を追加する\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* 辺を削除 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 辺 vet1 - vet2 を削除\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* 頂点を追加 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // 隣接リストに新しいリストを追加\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* 頂点を削除 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // 隣接リストから頂点 vet に対応するリストを削除\n    delete(g.adjList, vet)\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* 隣接リストを出力 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"隣接リスト = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* コンストラクタ */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // すべての頂点と辺を追加\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* 辺を追加 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"引数エラー\")\n        }\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* 辺を削除 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"引数エラー\")\n        }\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* 頂点を追加 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = []\n    }\n\n    /* 頂点を削除 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"引数エラー\")\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.removeValue(forKey: vet)\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public func print() {\n        Swift.print(\"隣接リスト =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList;\n\n    /* コンストラクタ */\n    constructor(edges) {\n        this.adjList = new Map();\n        // すべての頂点と辺を追加\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* 辺を追加 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を追加\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 辺を削除 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を削除\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 頂点を追加 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // 隣接リストに新しいリストを追加\n        this.adjList.set(vet, []);\n    }\n\n    /* 頂点を削除 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        this.adjList.delete(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    print() {\n        console.log('隣接リスト =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* コンストラクタ */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // すべての頂点と辺を追加\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* 辺を追加 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を追加\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 辺を削除 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を削除\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 頂点を追加 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // 隣接リストに新しいリストを追加\n        this.adjList.set(vet, []);\n    }\n\n    /* 頂点を削除 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        this.adjList.delete(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    print(): void {\n        console.log('隣接リスト =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n  // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* コンストラクタ */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* 頂点数を取得 */\n  int size() {\n    return adjList.length;\n  }\n\n  /* 辺を追加 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 辺 vet1 - vet2 を追加\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* 辺を削除 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 辺 vet1 - vet2 を削除\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* 頂点を追加 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // 隣接リストに新しいリストを追加\n    adjList[vet] = [];\n  }\n\n  /* 頂点を削除 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // 隣接リストから頂点 vet に対応するリストを削除\n    adjList.remove(vet);\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* 隣接リストを出力 */\n  void printAdjList() {\n    print(\"隣接リスト =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* 隣接リストに基づく無向グラフ型 */\npub struct GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* コンストラクタ */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // すべての頂点と辺を追加\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* 頂点数を取得 */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* 辺を追加 */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 辺 vet1 - vet2 を追加\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* 辺を削除 */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 辺 vet1 - vet2 を削除\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* 頂点を追加 */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // 隣接リストに新しいリストを追加\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* 頂点を削除 */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // 隣接リストから頂点 vet に対応するリストを削除\n        self.adj_list.remove(&amp;vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    pub fn print(&amp;self) {\n        println!(\"隣接リスト =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* ノード構造体 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // 頂点\n    struct AdjListNode *next; // 後続ノード\n} AdjListNode;\n\n/* 頂点に対応するノードを検索 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 辺を追加する補助関数 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // 先頭挿入法\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* 辺削除の補助関数 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // 連結リスト内で vet に対応するノードを探索\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // vet に対応するノードを連結リストから削除\n    pre-&gt;next = cur-&gt;next;\n    // メモリを解放する\n    free(cur);\n}\n\n/* 隣接リストに基づく無向グラフクラス */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // ノード配列\n    int size;                     // ノード数\n} GraphAdjList;\n\n/* コンストラクタ */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* デストラクタ */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* 頂点に対応するノードを検索 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 辺を追加 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // 辺 vet1 - vet2 を追加\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* 辺を削除 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // 辺 vet1 - vet2 を削除\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* 頂点を追加 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // 隣接リストに新しいリストを追加\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* 頂点を削除 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // 隣接リストから頂点 vet に対応するリストを削除\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // この頂点より後ろの頂点を前に詰めて欠損を埋める\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* コンストラクタ */\n    init {\n        // すべての頂点と辺を追加\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* 頂点数を取得 */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* 辺を追加 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* 辺を削除 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* 頂点を追加 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = mutableListOf()\n    }\n\n    /* 頂点を削除 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.remove(vet)\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* 隣接リストを出力 */\n    fun print() {\n        println(\"隣接リスト =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### 隣接リストで実装した無向グラフクラス ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### コンストラクタ ###\n  def initialize(edges)\n    # 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    @adj_list = {}\n    # すべての頂点と辺を追加\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### 頂点数を取得 ###\n  def size\n    @adj_list.length\n  end\n\n  ### 辺を追加 ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### 辺を削除 ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # 辺 vet1 - vet2 を削除\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### 頂点を追加 ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # 隣接リストに新しいリストを追加\n    @adj_list[vet] = []\n  end\n\n  ### 頂点を削除 ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # 隣接リストから頂点 vet に対応するリストを削除\n    @adj_list.delete(vet)\n    # 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### 隣接リストを出力 ###\n  def __print__\n    puts '隣接リスト ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   効率の比較","text":"<p>グラフに \\(n\\) 個の頂点と \\(m\\) 本の辺があるとすると、次の表は隣接行列と隣接リストの時間効率および空間効率を比較したものです。なお、隣接リスト（連結リスト）は本記事の実装に対応し、隣接リスト（ハッシュテーブル）はすべての連結リストをハッシュテーブルに置き換えた実装を指します。</p> <p> 表 9-2   隣接行列と隣接リストの比較 </p> 隣接行列 隣接リスト（連結リスト） 隣接リスト（ハッシュテーブル） 隣接判定 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 辺の追加 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 辺の削除 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 頂点の追加 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) 頂点の削除 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) メモリ使用量 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>上表を見ると、隣接リスト（ハッシュテーブル）の時間効率と空間効率が最も優れているように見えます。しかし実際には、隣接行列のほうが辺の操作効率は高く、必要なのは 1 回の配列アクセスまたは代入だけです。総合的に見ると、隣接行列は「空間を時間と引き換えにする」原則を体現し、隣接リストは「時間を空間と引き換えにする」原則を体現しています。</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   グラフの走査","text":"<p>木は「一対多」の関係を表すのに対し、グラフはより高い自由度を持ち、任意の「多対多」の関係を表現できます。したがって、木はグラフの一種の特殊な場合とみなせます。明らかに、木の走査操作もグラフの走査操作の一種の特殊な場合です。</p> <p>グラフと木はいずれも、走査操作を実現するために探索アルゴリズムを用いる必要があります。グラフの走査方法も、幅優先走査と深さ優先走査の 2 種類に分けられます。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   幅優先走査","text":"<p>幅優先走査は、近いところから遠いところへ向かう走査方法であり、ある頂点から出発して、常に最も近い頂点を優先して訪問し、層ごとに外側へ広がっていきます。以下の図に示すように、左上の頂点から出発し、まずその頂点のすべての隣接頂点を走査し、次に次の頂点のすべての隣接頂点を走査し、これを繰り返して、すべての頂点を訪問するまで続けます。</p> <p></p> <p> 図 9-9   グラフの幅優先走査 </p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   アルゴリズムの実装","text":"<p>BFS は通常キューを用いて実装され、コードは以下のとおりです。キューは「先入れ先出し」という性質を持ち、これは BFS の「近いところから遠いところへ」という考え方と本質的に一致しています。</p> <ol> <li>走査の開始頂点 <code>startVet</code> をキューに追加し、ループを開始します。</li> <li>ループの各反復で、キュー先頭の頂点を取り出して訪問を記録し、その後その頂点のすべての隣接頂点をキューの末尾に追加します。</li> <li>手順 <code>2.</code> を繰り返し、すべての頂点が訪問されると終了します。</li> </ol> <p>頂点の重複走査を防ぐために、どの頂点が訪問済みかを記録するハッシュ集合 <code>visited</code> を用います。</p> <p>Tip</p> <p>ハッシュ集合は、<code>value</code> を持たず <code>key</code> だけを格納するハッシュテーブルとみなせます。これは \\(O(1)\\) の時間計算量で <code>key</code> の追加・削除・検索・更新を行えます。<code>key</code> の一意性にもとづき、ハッシュ集合は通常、データの重複排除などの場面で用いられます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"幅優先探索\"\"\"\n    # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n    # 頂点の走査順序\n    res = []\n    # 訪問済み頂点を記録するためのハッシュ集合\n    visited = set[Vertex]([start_vet])\n    # BFS の実装にキューを用いる\n    que = deque[Vertex]([start_vet])\n    # 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while len(que) &gt; 0:\n        vet = que.popleft()  # 先頭の頂点をデキュー\n        res.append(vet)  # 訪問した頂点を記録\n        # この頂点のすべての隣接頂点を走査\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # 訪問済みの頂点をスキップ\n            que.append(adj_vet)  # 未訪問の頂点のみをキューに追加\n            visited.add(adj_vet)  # この頂点を訪問済みにする\n    # 頂点の走査順を返す\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂点の走査順序\n    vector&lt;Vertex *&gt; res;\n    // 訪問済み頂点を記録するためのハッシュ集合\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // BFS の実装にキューを用いる\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // 先頭の頂点をデキュー\n        res.push_back(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // 訪問済みの頂点をスキップ\n            que.push(adjVet);        // 未訪問の頂点のみをキューに追加\n            visited.emplace(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 訪問済み頂点を記録するためのハッシュ集合\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // 先頭の頂点をデキュー\n        res.add(vet);            // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // 訪問済みの頂点をスキップ\n            que.offer(adjVet);   // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // BFS の実装にキューを用いる\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // 先頭の頂点をデキュー\n        res.Add(vet);               // 訪問した頂点を記録\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // 訪問済みの頂点をスキップ\n            }\n            que.Enqueue(adjVet);   // 未訪問の頂点のみをキューに追加\n            visited.Add(adjVet);   // この頂点を訪問済みにする\n        }\n    }\n\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂点の走査順序\n    res := make([]Vertex, 0)\n    // 訪問済み頂点を記録するためのハッシュ集合\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // キューは BFS の実装に用い、スライスでキューをシミュレートする\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    for len(queue) &gt; 0 {\n        // 先頭の頂点をデキュー\n        vet := queue[0]\n        queue = queue[1:]\n        // 訪問した頂点を記録\n        res = append(res, vet)\n        // この頂点のすべての隣接頂点を走査\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // 未訪問の頂点のみをキューに追加\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂点の走査順序\n    var res: [Vertex] = []\n    // 訪問済み頂点を記録するためのハッシュ集合\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // BFS の実装にキューを用いる\n    var que: [Vertex] = [startVet]\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while !que.isEmpty {\n        let vet = que.removeFirst() // 先頭の頂点をデキュー\n        res.append(vet) // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // 訪問済みの頂点をスキップ\n            }\n            que.append(adjVet) // 未訪問の頂点のみをキューに追加\n            visited.insert(adjVet) // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphBFS(graph, startVet) {\n    // 頂点の走査順序\n    const res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited = new Set();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    const que = [startVet];\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.length) {\n        const vet = que.shift(); // 先頭の頂点をデキュー\n        res.push(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            que.push(adjVet); // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂点の走査順序\n    const res: Vertex[] = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    const que = [startVet];\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.length) {\n        const vet = que.shift(); // 先頭の頂点をデキュー\n        res.push(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            que.push(adjVet); // 未訪問のものだけをキューに入れる\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* 幅優先探索 */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  // 頂点の走査順序\n  List&lt;Vertex&gt; res = [];\n  // 訪問済み頂点を記録するためのハッシュ集合\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // BFS の実装にキューを用いる\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // 先頭の頂点をデキュー\n    res.add(vet); // 訪問した頂点を記録\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // 訪問済みの頂点をスキップ\n      }\n      que.add(adjVet); // 未訪問の頂点のみをキューに追加\n      visited.add(adjVet); // この頂点を訪問済みにする\n    }\n  }\n  // 頂点の走査順を返す\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂点の走査順序\n    let mut res = vec![];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // BFS の実装にキューを用いる\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // 訪問した頂点を記録\n\n        // この頂点のすべての隣接頂点を走査\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // 訪問済みの頂点をスキップ\n                }\n                que.push_back(adj_vet); // 未訪問の頂点のみをキューに追加\n                visited.insert(adj_vet); // この頂点を訪問済みにする\n            }\n        }\n    }\n    // 頂点の走査順を返す\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* ノードキュー構造体 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* コンストラクタ */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* キューが空かどうかを判定 */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* エンキュー操作 */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* デキュー操作 */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* 頂点が訪問済みかを確認 */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // 走査してノードを探すため、O(n) 時間を要する\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // BFS の実装にキューを用いる\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // 先頭の頂点をデキュー\n        res[(*resSize)++] = vet;      // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // 訪問済みの頂点をスキップ\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // 未訪問の頂点のみをキューに追加\n                visited[(*visitedSize)++] = node-&gt;vertex; // この頂点を訪問済みにする\n            }\n            node = node-&gt;next;\n        }\n    }\n    // メモリを解放する\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // 頂点の走査順序\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 訪問済み頂点を記録するためのハッシュ集合\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // BFS の実装にキューを用いる\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.isEmpty()) {\n        val vet = que.poll() // 先頭の頂点をデキュー\n        res.add(vet)         // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // 訪問済みの頂点をスキップ\n            que.offer(adjVet)   // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet) // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### 幅優先探索 ###\ndef graph_bfs(graph, start_vet)\n  # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  # 頂点の走査順序\n  res = []\n  # 訪問済み頂点を記録するためのハッシュ集合\n  visited = Set.new([start_vet])\n  # BFS の実装にキューを用いる\n  que = [start_vet]\n  # 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n  while que.length &gt; 0\n    vet = que.shift # 先頭の頂点をデキュー\n    res &lt;&lt; vet # 訪問した頂点を記録\n    # この頂点のすべての隣接頂点を走査\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # 訪問済みの頂点をスキップ\n      que &lt;&lt; adj_vet # 未訪問の頂点のみをキューに追加\n      visited.add(adj_vet) # この頂点を訪問済みにする\n    end\n  end\n  # 頂点の走査順を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>コードはやや抽象的なので、以下の図と照らし合わせて理解を深めることを勧めます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-10   グラフの幅優先走査の手順 </p> <p>幅優先走査の順序列は一意ですか？</p> <p>一意ではありません。幅優先走査は「近いところから遠いところへ」の順で走査することだけを要求し、同じ距離にある複数の頂点の走査順は任意に入れ替えて構いません。上図を例にすると、頂点 \\(1\\) と \\(3\\) の訪問順は交換でき、頂点 \\(2\\)、\\(4\\)、\\(6\\) の訪問順も任意に入れ替えられます。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   計算量の分析","text":"<p>時間計算量：すべての頂点は 1 回ずつキューに入り、1 回ずつキューから出るため、\\(O(|V|)\\) 時間です。隣接頂点を走査する過程では、無向グラフであるため、すべての辺が \\(2\\) 回訪問され、\\(O(2|E|)\\) 時間です。したがって全体では \\(O(|V| + |E|)\\) 時間です。</p> <p>空間計算量：リスト <code>res</code>、ハッシュ集合 <code>visited</code>、キュー <code>que</code> に含まれる頂点数は最大で \\(|V|\\) であるため、\\(O(|V|)\\) 空間です。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   深さ優先走査","text":"<p>深さ優先走査は、まず行けるところまで進み、進めなくなったら戻る走査方法です。以下の図に示すように、左上の頂点から出発し、現在の頂点のある隣接頂点を訪問して、行き止まりに達するまで進んだら戻り、再び別の方向へ進んで行き止まりまで進んで戻る、ということを繰り返し、すべての頂点の走査が完了するまで続けます。</p> <p></p> <p> 図 9-11   グラフの深さ優先走査 </p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   アルゴリズムの実装","text":"<p>この「行き止まりまで進んでから戻る」アルゴリズムのパターンは、通常再帰にもとづいて実装されます。幅優先走査と同様に、深さ優先走査でも、頂点の重複訪問を避けるために、訪問済みの頂点を記録するハッシュ集合 <code>visited</code> を用います。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"深さ優先走査の補助関数\"\"\"\n    res.append(vet)  # 訪問した頂点を記録\n    visited.add(vet)  # この頂点を訪問済みにする\n    # この頂点のすべての隣接頂点を走査\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # 訪問済みの頂点をスキップ\n        # 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"深さ優先探索\"\"\"\n    # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n    # 頂点の走査順序\n    res = []\n    # 訪問済み頂点を記録するためのハッシュ集合\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // 訪問した頂点を記録\n    visited.emplace(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂点の走査順序\n    vector&lt;Vertex *&gt; res;\n    // 訪問済み頂点を記録するためのハッシュ集合\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 訪問済み頂点を記録するためのハッシュ集合\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* 深さ優先走査の補助関数 */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // 訪問した頂点を記録\n    visited.Add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* 深さ優先走査の補助関数 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append 操作は新しい参照を返すため、元の参照を新しい slice の参照で再代入する必要がある\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // この頂点のすべての隣接頂点を走査\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // 隣接頂点を再帰的に訪問\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂点の走査順序\n    res := make([]Vertex, 0)\n    // 訪問済み頂点を記録するためのハッシュ集合\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* 深さ優先走査の補助関数 */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // 訪問した頂点を記録\n    visited.insert(vet) // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂点の走査順序\n    var res: [Vertex] = []\n    // 訪問済み頂点を記録するためのハッシュ集合\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphDFS(graph, startVet) {\n    // 頂点の走査順序\n    const res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* 深さ優先走査の補助関数 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂点の走査順序\n    const res: Vertex[] = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // 訪問した頂点を記録\n  visited.add(vet); // この頂点を訪問済みにする\n  // この頂点のすべての隣接頂点を走査\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // 訪問済みの頂点をスキップ\n    }\n    // 隣接頂点を再帰的に訪問\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* 深さ優先探索 */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // 頂点の走査順序\n  List&lt;Vertex&gt; res = [];\n  // 訪問済み頂点を記録するためのハッシュ集合\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* 深さ優先走査の補助関数 */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // 訪問した頂点を記録\n    visited.insert(vet); // この頂点を訪問済みにする\n                         // この頂点のすべての隣接頂点を走査\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            // 隣接頂点を再帰的に訪問\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂点の走査順序\n    let mut res = vec![];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* 頂点が訪問済みかを確認 */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // 走査してノードを探すため、O(n) 時間を要する\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // 訪問した頂点を記録\n    res[(*resSize)++] = vet;\n    // この頂点のすべての隣接頂点を走査\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // 訪問済みの頂点をスキップ\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // 隣接頂点を再帰的に訪問\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* 深さ優先走査の補助関数 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // 訪問した頂点を記録\n    visited.add(vet) // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // 頂点の走査順序\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 訪問済み頂点を記録するためのハッシュ集合\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### 深さ優先探索の補助関数 ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # 訪問した頂点を記録\n  visited.add(vet) # この頂点を訪問済みにする\n  # この頂点のすべての隣接頂点を走査\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # 訪問済みの頂点をスキップ\n    # 隣接頂点を再帰的に訪問\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### 深さ優先探索 ###\ndef graph_dfs(graph, start_vet)\n  # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  # 頂点の走査順序\n  res = []\n  # 訪問済み頂点を記録するためのハッシュ集合\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>深さ優先走査のアルゴリズムの流れは以下の図のとおりです。</p> <ul> <li>**直線の破線は下向きの再帰呼び出し**を表し、新しい頂点を訪問するために新たな再帰メソッドが開始されたことを意味します。</li> <li>**曲線の破線は上向きのバックトラック**を表し、この再帰メソッドがすでに戻って、呼び出し元の位置までたどり着いたことを意味します。</li> </ul> <p>理解を深めるために、以下の図とコードを結びつけて、DFS 全体の過程を頭の中でシミュレーションする（あるいは紙に書き出す）ことを勧めます。各再帰メソッドがいつ開始し、いつ戻るかも含めて追ってみてください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-12   グラフの深さ優先走査の手順 </p> <p>深さ優先走査の順序列は一意ですか？</p> <p>幅優先走査と同様に、深さ優先走査の順序列も一意ではありません。ある頂点が与えられたとき、どの方向を先に探索してもよく、つまり隣接頂点の順序は任意に入れ替えられ、それでも深さ優先走査になります。</p> <p>木の走査を例にすると、「根 \\(\\rightarrow\\) 左 \\(\\rightarrow\\) 右」「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」「左 \\(\\rightarrow\\) 右 \\(\\rightarrow\\) 根」は、それぞれ先行順、中間順、後行順走査に対応します。これらは 3 種類の走査優先順位を示していますが、いずれも深さ優先走査に属します。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   計算量の分析","text":"<p>時間計算量：すべての頂点は \\(1\\) 回ずつ訪問されるため、\\(O(|V|)\\) 時間です。すべての辺は \\(2\\) 回ずつ訪問されるため、\\(O(2|E|)\\) 時間です。したがって全体では \\(O(|V| + |E|)\\) 時間です。</p> <p>空間計算量：リスト <code>res</code> とハッシュ集合 <code>visited</code> に含まれる頂点数は最大で \\(|V|\\) であり、再帰の深さも最大で \\(|V|\\) であるため、\\(O(|V|)\\) 空間です。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   まとめ","text":"","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>グラフは頂点と辺から構成され、一組の頂点と一組の辺からなる集合として表せます。</li> <li>線形関係（連結リスト）や分治関係（木）と比べて、ネットワーク関係（グラフ）は自由度が高く、そのぶん複雑です。</li> <li>有向グラフの辺は方向性を持ち、連結グラフでは任意の頂点に到達でき、重み付きグラフの各辺は重み変数を含みます。</li> <li>隣接行列は行列を用いてグラフを表し、各行（列）が 1 つの頂点を表し、行列要素が辺を表します。\\(1\\) または \\(0\\) を用いて、2 つの頂点の間に辺があるかないかを示します。隣接行列は追加・削除・検索・更新の操作効率が高い一方で、より多くの空間を消費します。</li> <li>隣接リストは複数の連結リストを使ってグラフを表し、第 \\(i\\) 個の連結リストが頂点 \\(i\\) に対応し、その頂点に隣接するすべての頂点を格納します。隣接リストは隣接行列よりも省スペースですが、辺を探すために連結リストを走査する必要があるため、時間効率は低くなります。</li> <li>隣接リスト内の連結リストが長くなりすぎた場合は、赤黒木やハッシュテーブルに変換することで、検索効率を高められます。</li> <li>アルゴリズムの考え方という観点では、隣接行列は「空間を時間と引き換えにする」ことを体現し、隣接リストは「時間を空間と引き換えにする」ことを体現します。</li> <li>グラフは、ソーシャルネットワークや地下鉄路線など、さまざまな現実のシステムをモデル化するために使えます。</li> <li>木はグラフの特殊な一例であり、木の走査もグラフ走査の特殊な一例です。</li> <li>グラフの幅優先探索は、近いところから遠いところへ、層ごとに広がっていく探索方法であり、通常はキューを使って実装します。</li> <li>グラフの深さ優先探索は、まず行けるところまで進み、進めなくなったらバックトラックする探索方法であり、通常は再帰に基づいて実装します。</li> </ul>","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：経路の定義は頂点列ですか、それとも辺列ですか？</p> <p>Wikipedia では言語版ごとに定義が一致していません。英語版では「経路は辺の列」であり、中国語版では「経路は頂点の列」です。以下は英語版の原文です：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>本書では、経路を頂点列ではなく辺列とみなします。これは、2 つの頂点の間に複数の辺が存在する可能性があり、その場合は各辺がそれぞれ 1 本の経路に対応するためです。</p> <p>Q：非連結グラフには到達できない頂点がありますか？</p> <p>非連結グラフでは、ある頂点から出発すると、少なくとも 1 つの頂点には到達できません。非連結グラフ全体を走査するには、グラフ内のすべての連結成分をたどれるように複数の始点を設定する必要があります。</p> <p>Q：隣接リストにおいて、「その頂点に接続されたすべての頂点」の順序に決まりはありますか？</p> <p>順序は任意でかまいません。ただし実際の応用では、頂点を追加した順序や頂点値の大小順など、特定の規則に従って並べ替える必要がある場合があります。そうすることで、「ある種の極値を持つ」頂点をすばやく見つけやすくなります。</p>","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"第 15 章   貪欲法","text":"<p>Abstract</p> <p>ヒマワリは太陽に向かって回り、自らが最も大きく成長できる可能性を常に追い求める。</p> <p>貪欲戦略は、一回ごとの単純な選択を通じて、徐々に最適な答えへと導く。</p>","path":["第 15 章 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"章の内容","text":"<ul> <li>15.1   貪欲法</li> <li>15.2   分数ナップサック問題</li> <li>15.3   最大容量問題</li> <li>15.4   最大積分割問題</li> <li>15.5   まとめ</li> </ul>","path":["第 15 章 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   分数ナップサック問題","text":"<p>Question</p> <p>\\(n\\) 個の品物が与えられ、第 \\(i\\) 個の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量が \\(cap\\) のナップサックがある。各品物は 1 回だけ選択できるが、品物の一部を選ぶこともでき、価値は選択した重量の割合に応じて計算される。容量制限の下でナップサック内の品物の最大価値を求めよ。例を以下に示す。</p> <p></p> <p> 図 15-3   分数ナップサック問題の例データ </p> <p>分数ナップサック問題は 0-1 ナップサック問題と全体として非常によく似ており、状態には現在の品物 \\(i\\) と容量 \\(c\\) が含まれ、目標は容量制限下での最大価値を求めることである。</p> <p>異なる点は、本問では品物の一部だけを選べることである。以下に示すように、品物は任意に分割でき、対応する価値は重量の割合に応じて計算される。</p> <ol> <li>品物 \\(i\\) について、単位重量あたりの価値は \\(val[i-1] / wgt[i-1]\\) であり、これを単位価値と呼ぶ。</li> <li>品物 \\(i\\) の一部を重さ \\(w\\) だけ入れると、ナップサックに増える価値は \\(w \\times val[i-1] / wgt[i-1]\\) となる。</li> </ol> <p></p> <p> 図 15-4   品物の単位重量あたりの価値 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>ナップサック内の品物の総価値を最大化することは、**本質的には単位重量あたりの品物価値を最大化すること**である。そこから、以下に示す貪欲戦略を導ける。</p> <ol> <li>品物を単位価値の高い順にソートする。</li> <li>すべての品物を走査し、各回で単位価値が最も高い品物を貪欲に選択する。</li> <li>残りのナップサック容量が足りない場合は、現在の品物の一部を使ってナップサックを満たす。</li> </ol> <p></p> <p> 図 15-5   分数ナップサック問題の貪欲戦略 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   コード実装","text":"<p>品物を単位価値でソートできるように、<code>Item</code> クラスを定義する。貪欲選択を繰り返し、ナップサックが満杯になったら終了して解を返す。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"品物\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # 品物の重さ\n        self.v = v  # 品物の価値\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"分数ナップサック：貪欲法\"\"\"\n    # 重さと価値の 2 属性を持つ品物リストを作成\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # 単位価値 item.v / item.w の高い順にソートする\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # 貪欲選択を繰り返す\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v\n            cap -= item.w\n        else:\n            # 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap\n            # 残り容量がないため、ループを抜ける\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* 品物 */\nclass Item {\n  public:\n    int w; // 品物の重さ\n    int v; // 品物の価値\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // 貪欲選択を繰り返す\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double)item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* 品物 */\nclass Item {\n    int w; // 品物の重さ\n    int v; // 品物の価値\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // 貪欲選択を繰り返す\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double) item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* 品物 */\nclass Item(int w, int v) {\n    public int w = w; // 品物の重さ\n    public int v = v; // 品物の価値\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // 貪欲選択を繰り返す\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double)item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* 品物 */\ntype Item struct {\n    w int // 品物の重さ\n    v int // 品物の価値\n}\n\n/* 分数ナップサック：貪欲法 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // 貪欲選択を繰り返す\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* 品物 */\nclass Item {\n    var w: Int // 品物の重さ\n    var v: Int // 品物の価値\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // 貪欲選択を繰り返す\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* 品物 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // 品物の重さ\n        this.v = v; // 品物の価値\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 貪欲選択を繰り返す\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* 品物 */\nclass Item {\n    w: number; // 品物の重さ\n    v: number; // 品物の価値\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 貪欲選択を繰り返す\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* 品物 */\nclass Item {\n  int w; // 品物の重さ\n  int v; // 品物の価値\n\n  Item(this.w, this.v);\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // 重さと価値の 2 属性を持つ品物リストを作成\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // 単位価値 item.v / item.w の高い順にソートする\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // 貪欲選択を繰り返す\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n      res += item.v / item.w * cap;\n      // 残り容量がないため、ループを抜ける\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* 品物 */\nstruct Item {\n    w: i32, // 品物の重さ\n    v: i32, // 品物の価値\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // 貪欲選択を繰り返す\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* 品物 */\ntypedef struct {\n    int w; // 品物の重さ\n    int v; // 品物の価値\n} Item;\n\n/* 分数ナップサック：貪欲法 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // 貪欲選択を繰り返す\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* 品物 */\nclass Item(\n    val w: Int, // 品物\n    val v: Int  // 品物の価値\n)\n\n/* 分数ナップサック：貪欲法 */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // 貪欲選択を繰り返す\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += item.v.toDouble() / item.w * cap\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### アイテム ###\nclass Item\n  attr_accessor :w # 品物の重さ\n  attr_accessor :v # 品物の価値\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### 分数ナップサック：貪欲法 ###\ndef fractional_knapsack(wgt, val, cap)\n  # 重さと価値の 2 属性を持つ品物リストを作成する\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # 単位価値 item.v / item.w の高い順にソートする\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # 貪欲選択を繰り返す\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n      res += item.v\n      cap -= item.w\n    else\n      # 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n      res += (item.v.to_f / item.w) * cap\n      # 残り容量がないため、ループを抜ける\n      break\n    end\n  end\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>組み込みのソートアルゴリズムの時間計算量は通常 \\(O(\\log n)\\)、空間計算量は通常 \\(O(\\log n)\\) または \\(O(n)\\) であり、具体的な値はプログラミング言語の実装に依存する。</p> <p>ソートを除けば、最悪の場合は品物リスト全体を走査する必要があるため、時間計算量は \\(O(n)\\) であり、ここで \\(n\\) は品物数である。</p> <p><code>Item</code> オブジェクトのリストを初期化しているため、空間計算量は \\(O(n)\\) である。</p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>背理法を用いる。品物 \\(x\\) が単位価値最大の品物であり、あるアルゴリズムで得られた最大価値を <code>res</code> とするが、その解には品物 \\(x\\) が含まれていないと仮定する。</p> <p>ここでナップサックから単位重量の任意の品物を取り出し、単位重量の品物 \\(x\\) に置き換える。品物 \\(x\\) の単位価値が最大であるため、置き換え後の総価値は必ず <code>res</code> より大きくなる。これは <code>res</code> が最適解であることに矛盾し、最適解には必ず品物 \\(x\\) が含まれなければならないことを示す。</p> <p>この解に含まれる他の品物についても、同様の矛盾を構成できる。要するに、単位価値がより大きい品物は常により良い選択である。これは貪欲戦略が有効であることを示している。</p> <p>以下に示すように、品物の重さと品物の単位価値をそれぞれ二次元グラフの横軸と縦軸とみなすと、分数ナップサック問題は「有限な横軸区間で囲まれる最大面積を求める問題」に変換できる。この類比は、幾何学的な観点から貪欲戦略の有効性を理解する助けになる。</p> <p></p> <p> 図 15-6   分数ナップサック問題の幾何学的表現 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   貪欲法","text":"<p>貪欲法（greedy algorithm）は、最適化問題を解くための一般的なアルゴリズムです。その基本的な考え方は、問題の各意思決定段階において、その時点で最善に見える選択を行い、すなわち貪欲に局所最適な決定を下すことで、大域最適解を得ようとするものです。貪欲法は簡潔で効率的であり、多くの実際の問題で広く用いられています。</p> <p>貪欲法と動的計画法は、どちらも最適化問題を解く際によく用いられます。両者には、最適部分構造に依存するなどの共通点がありますが、その動作原理は異なります。</p> <ul> <li>動的計画法は、前の段階までのすべての決定に基づいて現在の決定を考え、過去の部分問題の解を用いて現在の部分問題の解を構築します。</li> <li>貪欲法は過去の決定を考慮せず、ひたすら前に進みながら貪欲な選択を行い、問題の範囲を縮小し続けて、最終的に問題を解決します。</li> </ul> <p>まずは例題「コイン両替」を通して、貪欲法の仕組みを理解しましょう。この問題はすでに「完全ナップサック問題」の節で紹介しているので、見覚えがあるはずです。</p> <p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は何度でも選べるとき、目標金額を作るために必要な最小の硬貨枚数を求めてください。目標金額を作れない場合は \\(-1\\) を返します。</p> <p>この問題で採用する貪欲戦略は下図のとおりです。目標金額が与えられたら、それを超えず、かつ最も近い硬貨を貪欲に選択し、この手順を目標金額を作り切るまで繰り返します。</p> <p></p> <p> 図 15-1   コイン両替の貪欲戦略 </p> <p>実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン交換：貪欲法\"\"\"\n    # coins リストはソート済みと仮定する\n    i = len(coins) - 1\n    count = 0\n    # 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0:\n        # 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # coins[i] を選択する\n        amt -= coins[i]\n        count += 1\n    # 実行可能な解が見つからなければ -1 を返す\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.size() - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.length - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* コイン交換：貪欲法 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.Length - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* コイン交換：貪欲法 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // coins リストはソート済みと仮定する\n    i := len(coins) - 1\n    count := 0\n    // 残額がなくなるまで貪欲選択を繰り返す\n    for amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // coins[i] を選択する\n        amt -= coins[i]\n        count++\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* コイン交換：貪欲法 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // coins リストはソート済みと仮定する\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // coins[i] を選択する\n        amt -= coins[i]\n        count += 1\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* コイン交換：貪欲法 */\nfunction coinChangeGreedy(coins, amt) {\n    // coins 配列はソート済みと仮定する\n    let i = coins.length - 1;\n    let count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* コイン交換：貪欲法 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // coins 配列はソート済みと仮定する\n    let i = coins.length - 1;\n    let count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // coins リストはソート済みと仮定する\n  int i = coins.length - 1;\n  int count = 0;\n  // 残額がなくなるまで貪欲選択を繰り返す\n  while (amt &gt; 0) {\n    // 残額以下で最も近い硬貨を見つける\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // coins[i] を選択する\n    amt -= coins[i];\n    count++;\n  }\n  // 実行可能な解が見つからなければ -1 を返す\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* コイン交換：貪欲法 */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // coins リストはソート済みと仮定する\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count += 1;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = size - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* コイン交換：貪欲法 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // coins リストはソート済みと仮定する\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (am &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // coins[i] を選択する\n        am -= coins[i]\n        count++\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### コイン両替：貪欲法 ###\ndef coin_change_greedy(coins, amt)\n  # coins リストはソート済みと仮定する\n  i = coins.length - 1\n  count = 0\n  # 残額がなくなるまで貪欲選択を繰り返す\n  while amt &gt; 0\n    # 残額以下で最も近い硬貨を見つける\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # coins[i] を選択する\n    amt -= coins[i]\n    count += 1\n  end\n  # 実行可能な解が見つからなければ `-1` を返す\n  amt == 0 ? count : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>思わずこう言いたくなるかもしれません。So clean！貪欲法はわずか十行ほどのコードでコイン両替問題を解いてしまいます。</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   貪欲法の利点と限界","text":"<p>**貪欲法は操作が直接的で実装が簡単なだけでなく、通常は効率も高い**です。上のコードでは、硬貨の最小額面を \\(\\min(coins)\\) とすると、貪欲選択のループ回数は高々 \\(amt / \\min(coins)\\) 回であり、時間計算量は \\(O(amt / \\min(coins))\\) です。これは動的計画法による解法の時間計算量 \\(O(n \\times amt)\\) より 1 桁小さいオーダーです。</p> <p>しかし、硬貨の額面の組み合わせによっては、貪欲法では最適解を見つけられません。下図に 2 つの例を示します。</p> <ul> <li>正例 \\(coins = [1, 5, 10, 20, 50, 100]\\)：この硬貨の組み合わせでは、任意の \\(amt\\) に対して貪欲法で最適解を見つけられます。</li> <li>反例 \\(coins = [1, 20, 50]\\)：\\(amt = 60\\) とすると、貪欲法では \\(50 + 1 \\times 10\\) という両替しか見つからず、硬貨は合計 \\(11\\) 枚になります。しかし動的計画法なら最適解 \\(20 + 20 + 20\\) を見つけられ、必要なのはわずか \\(3\\) 枚です。</li> <li>反例 \\(coins = [1, 49, 50]\\)：\\(amt = 98\\) とすると、貪欲法では \\(50 + 1 \\times 48\\) という両替しか見つからず、硬貨は合計 \\(49\\) 枚になります。しかし動的計画法なら最適解 \\(49 + 49\\) を見つけられ、必要なのはわずか \\(2\\) 枚です。</li> </ul> <p></p> <p> 図 15-2   貪欲法では最適解を見つけられない例 </p> <p>つまり、コイン両替問題に対して、貪欲法は大域最適解を保証できず、非常に悪い解を見つけてしまうこともあります。この問題は動的計画法で解くほうが適しています。</p> <p>一般に、貪欲法が適用できる状況は次の 2 つに分けられます。</p> <ol> <li>最適解を保証できる場合：この場合、貪欲法はしばしば最良の選択です。多くの場合、バックトラッキングや動的計画法より効率的だからです。</li> <li>近似最適解を見つけられる場合：この場合も貪欲法は有効です。多くの複雑な問題では、大域最適解を求めること自体が非常に難しく、より高い効率で準最適解を得られるだけでも十分価値があります。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   貪欲法の特性","text":"<p>では、どのような問題が貪欲法に適しているのでしょうか。言い換えると、貪欲法はどのような場合に最適解を保証できるのでしょうか。</p> <p>動的計画法と比べると、貪欲法の適用条件はより厳しく、主に次の 2 つの性質に注目します。</p> <ul> <li>貪欲選択性：局所最適な選択が常に大域最適解につながる場合にのみ、貪欲法は最適解を保証できます。</li> <li>最適部分構造：元の問題の最適解が、部分問題の最適解を含むことです。</li> </ul> <p>最適部分構造については「動的計画法」の節ですでに紹介したので、ここでは繰り返しません。なお、問題によっては最適部分構造が明確でなくても、貪欲法で解ける場合があります。</p> <p>ここでは主に、貪欲選択性をどのように判定するかを考えます。説明だけを見ると単純そうですが、実際には多くの問題で、貪欲選択性を証明するのは容易ではありません。</p> <p>たとえばコイン両替問題では、反例を挙げて貪欲選択性が成り立たないことを示すのは簡単ですが、成り立つことを証明するのは難しいです。もし、**どのような条件を満たす硬貨の組み合わせなら貪欲法で解けるのか**と問われると、直感や例示に頼った曖昧な答えしか出せず、厳密な数学的証明を与えるのは困難です。</p> <p>Quote</p> <p>ある論文では、ある硬貨の組み合わせについて、任意の金額に対する最適解を貪欲法で求められるかどうかを判定する、時間計算量 \\(O(n^3)\\) のアルゴリズムが示されています。</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   貪欲法の問題解決手順","text":"<p>貪欲法による問題解決の流れは、おおむね次の 3 段階に分けられます。</p> <ol> <li>問題分析：状態の定義、最適化目標、制約条件などを整理し、問題の性質を理解します。この段階はバックトラッキングや動的計画法でも共通して現れます。</li> <li>貪欲戦略の決定：各ステップでどのように貪欲選択を行うかを定めます。この戦略により各ステップで問題規模を縮小し、最終的に問題全体を解決します。</li> <li>正しさの証明：通常は、その問題が貪欲選択性と最適部分構造を持つことを示す必要があります。この段階では、帰納法や背理法などの数学的証明が必要になることがあります。</li> </ol> <p>貪欲戦略を定めることは問題解決の核心ですが、実際には簡単ではないことも多く、主な理由は次のとおりです。</p> <ul> <li>問題ごとに貪欲戦略の差が大きい。多くの問題では貪欲戦略は比較的わかりやすく、おおまかな考察や試行だけで見つけられます。しかし複雑な問題では、貪欲戦略が非常に見えにくいことがあり、その場合は解法経験やアルゴリズム力が大きく問われます。</li> <li>一見もっともらしい貪欲戦略もある。自信を持って貪欲戦略を設計し、コードを書いて提出しても、一部のテストケースを通過できないことがあります。これは、その貪欲戦略が「部分的にしか正しくない」ためであり、先ほどのコイン両替は典型例です。</li> </ul> <p>正しさを保証するためには、貪欲戦略に対して厳密な数学的証明を行うべきであり、通常は背理法や数学的帰納法が必要になります。</p> <p>しかし、正しさの証明もまた簡単とは限りません。手がかりがない場合には、テストケースを使ってコードをデバッグしながら、貪欲戦略を少しずつ修正して検証していくことがよくあります。</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   貪欲法の典型問題","text":"<p>貪欲法は、貪欲選択性と最適部分構造を満たす最適化問題によく用いられます。以下に典型的な貪欲法の問題をいくつか挙げます。</p> <ul> <li>硬貨のお釣り問題：ある種の硬貨の組み合わせでは、貪欲法で常に最適解が得られます。</li> <li>区間スケジューリング問題：いくつかのタスクがあり、それぞれがある時間区間で実行されるとします。できるだけ多くのタスクを完了することが目標で、毎回終了時刻が最も早いタスクを選ぶなら、貪欲法で最適解を得られます。</li> <li>分数ナップサック問題：一群の品物と積載容量が与えられたとき、総重量が容量を超えず、かつ総価値が最大になるように品物を選ぶ問題です。毎回、価値対重量比（価値 / 重量）が最も高い品物を選ぶなら、ある条件下で貪欲法は最適解を得られます。</li> <li>株式売買問題：株価の履歴が与えられ、複数回の売買が可能ですが、すでに株を保有している場合は売却前に再度購入することはできません。目標は最大利益を得ることです。</li> <li>ハフマン符号化：ハフマン符号化は、可逆データ圧縮に用いられる貪欲法です。ハフマン木を構築する際、毎回出現頻度が最も低い 2 つのノードを選んで併合すると、最終的に得られるハフマン木の重み付きパス長（符号長）は最小になります。</li> <li>Dijkstra アルゴリズム：与えられた始点から他の各頂点への最短経路問題を解く貪欲法です。</li> </ul>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   最大容量問題","text":"<p>Question</p> <p>配列 \\(ht\\) が与えられ、各要素は垂直な仕切り板の高さを表します。配列内の任意の 2 枚の仕切り板と、その間の空間で容器を構成できます。</p> <p>容器の容量は高さと幅の積（面積）に等しく、高さは短い方の仕切り板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。</p> <p>配列から 2 枚の仕切り板を選び、構成される容器の容量が最大となるようにしてください。最大容量を返します。例を以下の図に示します。</p> <p></p> <p> 図 15-7   最大容量問題のサンプルデータ </p> <p>容器は任意の 2 枚の仕切り板で囲まれるため、本問の状態は 2 枚の仕切り板のインデックスで表され、\\([i, j]\\) と記します。</p> <p>問題の条件より、容量は高さと幅の積に等しく、高さは短い板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。容量を \\(cap[i, j]\\) とすると、計算式は次のようになります。</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>配列の長さを \\(n\\) とすると、2 枚の仕切り板の組合せ数（状態総数）は \\(C_n^2 = \\frac{n(n - 1)}{2}\\) 個です。最も直接的には、すべての状態を総当たりできます。これにより最大容量を求められ、時間計算量は \\(O(n^2)\\) です。</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>この問題にはさらに効率的な解法があります。以下の図のように、状態 \\([i, j]\\) を 1 つ選び、インデックスが \\(i &lt; j\\) かつ高さが \\(ht[i] &lt; ht[j]\\) を満たすとします。つまり、\\(i\\) が短い板、\\(j\\) が長い板です。</p> <p></p> <p> 図 15-8   初期状態 </p> <p>以下の図のように、このとき長い板 \\(j\\) を短い板 \\(i\\) に近づけると、容量は必ず小さくなります。</p> <p>これは、長い板 \\(j\\) を動かした後は幅 \\(j-i\\) が必ず小さくなるためです。また、高さは短い板で決まるので、高さは変わらない（ \\(i\\) が依然として短い板）か、小さくなる（移動後の \\(j\\) が短い板になる）ことしかありません。</p> <p></p> <p> 図 15-9   長い板を内側へ動かした後の状態 </p> <p>逆に考えると、短い板 \\(i\\) を内側へ縮めた場合にのみ、容量が大きくなる可能性があります。幅は必ず小さくなりますが、**高さは大きくなる可能性がある**からです（移動後の短い板 \\(i\\) がより長くなる可能性があります）。たとえば次の図では、短い板を動かした後に面積が大きくなっています。</p> <p></p> <p> 図 15-10   短い板を内側へ動かした後の状態 </p> <p>以上から、本問の貪欲戦略を導けます。2 本のポインタを初期化して容器の両端に置き、各ラウンドで短い板に対応するポインタを内側へ縮め、2 本のポインタが出会うまで続けます。</p> <p>以下の図は、貪欲戦略の実行過程を示しています。</p> <ol> <li>初期状態では、ポインタ \\(i\\) と \\(j\\) は配列の両端にあります。</li> <li>現在の状態の容量 \\(cap[i, j]\\) を計算し、最大容量を更新します。</li> <li>板 \\(i\\) と板 \\(j\\) の高さを比較し、短い板を内側へ 1 マス移動します。</li> <li><code>2.</code> と <code>3.</code> を繰り返し実行し、\\(i\\) と \\(j\\) が出会ったら終了します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 15-11   最大容量問題の貪欲な過程 </p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   コード実装","text":"<p>コードのループ回数は最大でも \\(n\\) 回であるため、時間計算量は \\(O(n)\\) です。</p> <p>変数 \\(i\\)、\\(j\\)、\\(res\\) が使う追加領域は定数サイズなので、空間計算量は \\(O(1)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"最大容量：貪欲法\"\"\"\n    # i, j を初期化し、それぞれ配列の両端に置く\n    i, j = 0, len(ht) - 1\n    # 初期の最大容量は 0\n    res = 0\n    # 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j:\n        # 最大容量を更新する\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # 短い方を内側へ動かす\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.size() - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(int[] ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.length - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* 最大容量：貪欲法 */\nint MaxCapacity(int[] ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.Length - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* 最大容量：貪欲法 */\nfunc maxCapacity(ht []int) int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    i, j := 0, len(ht)-1\n    // 初期の最大容量は 0\n    res := 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    for i &lt; j {\n        // 最大容量を更新する\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* 最大容量：貪欲法 */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // 初期の最大容量は 0\n    var res = 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j {\n        // 最大容量を更新する\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* 最大容量：貪欲法 */\nfunction maxCapacity(ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let i = 0,\n        j = ht.length - 1;\n    // 初期の最大容量は 0\n    let res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* 最大容量：貪欲法 */\nfunction maxCapacity(ht: number[]): number {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let i = 0,\n        j = ht.length - 1;\n    // 初期の最大容量は 0\n    let res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(List&lt;int&gt; ht) {\n  // i, j を初期化し、それぞれ配列の両端に置く\n  int i = 0, j = ht.length - 1;\n  // 初期の最大容量は 0\n  int res = 0;\n  // 2 枚の板が出会うまで貪欲選択を繰り返す\n  while (i &lt; j) {\n    // 最大容量を更新する\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // 短い方を内側へ動かす\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* 最大容量：貪欲法 */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // 初期の最大容量は 0\n    let mut res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j {\n        // 最大容量を更新する\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(int ht[], int htLength) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0;\n    int j = htLength - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* 最大容量：貪欲法 */\nfun maxCapacity(ht: IntArray): Int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    var i = 0\n    var j = ht.size - 1\n    // 初期の最大容量は 0\n    var res = 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### 最大容量：貪欲法 ###\ndef max_capacity(ht)\n  # i, j を初期化し、それぞれ配列の両端に置く\n  i, j = 0, ht.length - 1\n  # 初期の最大容量は 0\n  res = 0\n\n  # 2 枚の板が出会うまで貪欲選択を繰り返す\n  while i &lt; j\n    # 最大容量を更新する\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # 短い方を内側へ動かす\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>貪欲法が総当たりより速いのは、各ラウンドの貪欲な選択がいくつかの状態を「スキップ」するためです。</p> <p>たとえば状態 \\(cap[i, j]\\) において、\\(i\\) が短い板、\\(j\\) が長い板だとします。貪欲に短い板 \\(i\\) を内側へ 1 マス動かすと、次の図に示す状態が「スキップ」されます。これは、その後それらの状態の容量を検証できないことを意味します。</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> 図 15-12   短い板の移動によってスキップされる状態 </p> <p>観察すると、これらのスキップされた状態は、実際には長い板 \\(j\\) を内側へ動かしたすべての状態そのものです。前述のとおり、長い板を内側へ動かすと容量は必ず小さくなります。つまり、スキップされた状態はいずれも最適解にはなりえず、それらを飛ばしても最適解を逃すことはありません。</p> <p>以上の分析から、短い板を動かす操作は「安全」であり、貪欲戦略は有効であると分かります。</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   最大積分割問題","text":"<p>Question</p> <p>正整数 \\(n\\) が与えられたとき、それを少なくとも 2 つの正整数の和に分割し、分割後のすべての整数の積の最大値を求めよ。下図に示す。</p> <p></p> <p> 図 15-13   最大積分割問題の定義 </p> <p>仮に \\(n\\) を \\(m\\) 個の整数因子に分割し、そのうち第 \\(i\\) 個の因子を \\(n_i\\) と記すと、</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>本問題の目的は、すべての整数因子の積の最大値を求めることであり、すなわち</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>考えるべきことは、分割数 \\(m\\) をいくつにすべきか、各 \\(n_i\\) をいくつにすべきかである。</p>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>経験的に、2 つの整数の積はその和より大きくなることが多い。\\(n\\) から因子 \\(2\\) を 1 つ切り出すと、それらの積は \\(2(n-2)\\) となる。この積を \\(n\\) と比較すると、</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>下図のように、\\(n \\geq 4\\) のとき、\\(2\\) を 1 つ切り出すと積は大きくなる。これは、\\(4\\) 以上の整数はすべて分割すべきことを意味する。</p> <p>貪欲戦略一：分割方法に \\(\\geq 4\\) の因子が含まれるなら、それはさらに分割すべきである。最終的な分割方法に現れる因子は \\(1\\)、\\(2\\)、\\(3\\) の 3 種類だけである。</p> <p></p> <p> 図 15-14   分割により積が大きくなる </p> <p>次に、どの因子が最適かを考える。\\(1\\)、\\(2\\)、\\(3\\) の 3 つの因子のうち、明らかに \\(1\\) が最も悪い。なぜなら \\(1 \\times (n-1) &lt; n\\) は常に成り立ち、\\(1\\) を切り出すとかえって積が小さくなるからである。</p> <p>下図のように、\\(n = 6\\) のとき、\\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\) が成り立つ。これは、\\(2\\) を切り出すより \\(3\\) を切り出すほうが有利であることを意味する。</p> <p>貪欲戦略二：分割方法の中に存在してよい \\(2\\) は高々 2 つである。なぜなら、3 つの \\(2\\) は常に 2 つの \\(3\\) に置き換えられ、より大きな積を得られるからである。</p> <p></p> <p> 図 15-15   最適な分割因子 </p> <p>以上より、次の貪欲戦略が導かれる。</p> <ol> <li>整数 \\(n\\) を入力し、余りが \\(0\\)、\\(1\\)、\\(2\\) になるまで、そこから因子 \\(3\\) を繰り返し切り出す。</li> <li>余りが \\(0\\) のとき、\\(n\\) は \\(3\\) の倍数であることを表すため、何も処理しない。</li> <li>余りが \\(2\\) のときは、それ以上分割せず、そのまま残す。</li> <li>余りが \\(1\\) のとき、\\(2 \\times 2 &gt; 1 \\times 3\\) であるため、最後の \\(3\\) を \\(2\\) に置き換えるべきである。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   コード実装","text":"<p>下図のように、ループで整数を分割する必要はなく、切り捨て除算によって \\(3\\) の個数 \\(a\\) を、剰余演算によって余り \\(b\\) を得られる。このとき、</p> \\[ n = 3 a + b \\] <p>なお、\\(n \\leq 3\\) の境界ケースでは、必ず \\(1\\) を 1 つ分割する必要があり、積は \\(1 \\times (n - 1)\\) となる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"最大切断積：貪欲法\"\"\"\n    # n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    a, b = n // 3, n % 3\n    if b == 1:\n        # 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # 余りが 2 のときは、そのままにする\n        return int(math.pow(3, a)) * 2\n    # 余りが 0 のときは、そのままにする\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int)pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int) Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* 最大切断積：貪欲法 */\nint MaxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* 最大切断積：貪欲法 */\nfunc maxProductCutting(n int) int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* 最大切断積：貪欲法 */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        return pow(3, a) * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* 最大切断積：貪欲法 */\nfunction maxProductCutting(n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 余りが 2 のときは、そのままにする\n        return Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* 最大切断積：貪欲法 */\nfunction maxProductCutting(n: number): number {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 余りが 2 のときは、そのままにする\n        return Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n  // n &lt;= 3 のときは、必ず 1 を切り出す\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // 余りが 2 のときは、そのままにする\n    return (pow(3, a) * 2).toInt();\n  }\n  // 余りが 0 のときは、そのままにする\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* 最大切断積：貪欲法 */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        3_i32.pow(a as u32) * 2\n    } else {\n        // 余りが 0 のときは、そのままにする\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* 最大切断積：貪欲法 */\nfun maxProductCutting(n: Int): Int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### 最大分割積：貪欲法 ###\ndef max_product_cutting(n)\n  # n &lt;= 3 のときは、必ず 1 を切り出す\n  return 1 * (n - 1) if n &lt;= 3\n  # 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n  a, b = n / 3, n % 3\n  # 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # 余りが 2 のときは、そのままにする\n  return (3.pow(a) * 2).to_i if b == 2\n  # 余りが 0 のときは、そのままにする\n  3.pow(a).to_i\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 15-16   最大積分割の計算方法 </p> <p>時間計算量は、プログラミング言語におけるべき乗演算の実装方法に依存する。Python を例に取ると、よく使われるべき乗計算関数は 3 種類ある。</p> <ul> <li>演算子 <code>**</code> と関数 <code>pow()</code> の時間計算量はいずれも \\(O(\\log⁡ a)\\) である。</li> <li>関数 <code>math.pow()</code> は内部で C 言語ライブラリの <code>pow()</code> 関数を呼び出し、浮動小数点のべき乗を実行するため、時間計算量は \\(O(1)\\) である。</li> </ul> <p>変数 \\(a\\) と \\(b\\) が使う追加領域は定数サイズであり、したがって空間計算量は \\(O(1)\\) である。</p>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>背理法を用い、\\(n \\geq 4\\) の場合のみを考える。</p> <ol> <li>すべての因子は \\(\\leq 3\\) ：最適な分割方法に \\(\\geq 4\\) の因子 \\(x\\) が存在すると仮定すると、それは必ずさらに \\(2(x-2)\\) に分割でき、より大きい（または等しい）積が得られる。これは仮定に矛盾する。</li> <li>分割方法に \\(1\\) は含まれない ：最適な分割方法に因子 \\(1\\) が 1 つ存在すると仮定すると、それは必ず別の因子に併合でき、より大きい積を得られる。これは仮定に矛盾する。</li> <li>分割方法に含まれる \\(2\\) は高々 2 つ ：最適な分割方法に 3 つの \\(2\\) が含まれると仮定すると、それは必ず 2 つの \\(3\\) に置き換えられ、積はより大きくなる。これは仮定に矛盾する。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   まとめ","text":"","path":["第 15 章 &nbsp; 貪欲法","15.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   重要な振り返り","text":"<ul> <li>貪欲法は通常、最適化問題を解くために用いられ、その原理は各意思決定段階で局所最適な決定を行い、全体最適解を得ることを目指すというものである。</li> <li>貪欲法は反復的に次々と貪欲な選択を行い、各ラウンドで問題をより小さな部分問題へと変換し、最終的に問題を解決する。</li> <li>貪欲法は実装が簡単であるだけでなく、問題を解く効率も高い。動的計画法と比べると、貪欲法の時間計算量は通常より低い。</li> <li>硬貨両替問題では、ある種の硬貨の組み合わせに対しては貪欲法で最適解を保証できるが、別の組み合わせではそうではなく、非常に悪い解を見つけてしまう可能性がある。</li> <li>貪欲法による解法に適した問題は、貪欲選択性と最適部分構造という 2 つの性質を備えている。貪欲選択性は、貪欲戦略の有効性を表している。</li> <li>一部の複雑な問題では、貪欲選択性を証明するのは容易ではない。相対的には、反例による否定のほうが簡単であり、硬貨両替問題がその一例である。</li> <li>貪欲法の問題を解く流れは主に 3 段階に分かれる。すなわち、問題分析、貪欲戦略の決定、正しさの証明である。このうち、貪欲戦略の決定が中核であり、正しさの証明はしばしば難所となる。</li> <li>分数ナップサック問題は 0-1 ナップサックを基に、品物の一部を選ぶことを許しているため、貪欲法で解くことができる。貪欲戦略の正しさは背理法で証明できる。</li> <li>最大容量問題は全探索で解くことができ、時間計算量は \\(O(n^2)\\) である。貪欲戦略を設計し、各ラウンドで短い板を内側へ動かすことで、時間計算量を \\(O(n)\\) に最適化できる。</li> <li>最大分割積問題では、2 つの貪欲戦略を順に導いた。すなわち、\\(\\geq 4\\) の整数はすべてさらに分割すべきであり、最適な分割因子は \\(3\\) である。コードにはべき乗演算が含まれており、時間計算量はその実装方法に依存し、通常は \\(O(1)\\) または \\(O(\\log n)\\) である。</li> </ul>","path":["第 15 章 &nbsp; 貪欲法","15.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"第 6 章   ハッシュテーブル","text":"<p>Abstract</p> <p>コンピュータの世界では、ハッシュテーブルは聡明な図書館員のような存在です。</p> <p>彼は請求記号の計算方法を知っており、そのため目的の本を素早く見つけられます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"章の内容","text":"<ul> <li>6.1   ハッシュテーブル</li> <li>6.2   ハッシュ衝突</li> <li>6.3   ハッシュアルゴリズム</li> <li>6.4   まとめ</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   ハッシュアルゴリズム","text":"<p>前の 2 節では、ハッシュテーブルの動作原理とハッシュ衝突の処理方法を紹介しました。しかし、オープンアドレス法であれ連鎖方式であれ、それらが保証できるのは衝突発生時でもハッシュテーブルが正常に動作することだけであり、ハッシュ衝突そのものを減らすことはできません。</p> <p>ハッシュ衝突があまりにも頻繁に発生すると、ハッシュテーブルの性能は急激に劣化します。下図のように、連鎖方式のハッシュテーブルでは、理想的な場合にはキーと値のペアが各バケットに均等に分布し、最良の検索効率を達成します。最悪の場合には、すべてのキーと値のペアが同じバケットに格納され、時間計算量は \\(O(n)\\) に劣化します。</p> <p></p> <p> 図 6-8   ハッシュ衝突の最良ケースと最悪ケース </p> <p>キーと値のペアの分布はハッシュ関数によって決まります。ハッシュ関数の計算手順を思い出すと、まずハッシュ値を計算し、その後で配列長に対して剰余を取ります。</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>上の式から分かるように、ハッシュテーブルの容量 <code>capacity</code> が固定されているとき、出力値を決めるのはハッシュアルゴリズム <code>hash()</code> です。したがって、それがキーと値のペアのハッシュテーブル内での分布も決定します。</p> <p>これは、ハッシュ衝突の発生確率を下げるには、ハッシュアルゴリズム <code>hash()</code> の設計に注目すべきだということを意味します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631","level":2,"title":"6.3.1   ハッシュアルゴリズムの目標","text":"<p>「高速かつ安定した」ハッシュテーブルというデータ構造を実現するために、ハッシュアルゴリズムは次の特徴を備える必要があります。</p> <ul> <li>決定性：同じ入力に対して、ハッシュアルゴリズムは常に同じ出力を生成しなければなりません。そうして初めて、ハッシュテーブルの信頼性が保たれます。</li> <li>高効率：ハッシュ値の計算過程は十分に高速であるべきです。計算コストが小さいほど、ハッシュテーブルの実用性は高くなります。</li> <li>均一分布：ハッシュアルゴリズムは、キーと値のペアがハッシュテーブル内に均等に分布するようにすべきです。分布が均一であるほど、ハッシュ衝突の確率は低くなります。</li> </ul> <p>実際には、ハッシュアルゴリズムはハッシュテーブルの実装だけでなく、ほかの多くの分野でも広く利用されています。</p> <ul> <li>パスワード保存：ユーザーのパスワードを保護するために、システムは通常、平文パスワードを直接保存せず、そのハッシュ値を保存します。ユーザーがパスワードを入力すると、システムは入力内容のハッシュ値を計算し、保存済みのハッシュ値と比較します。一致すれば、そのパスワードは正しいと見なされます。</li> <li>データ完全性検査：送信側はデータのハッシュ値を計算してデータと一緒に送信できます。受信側は受け取ったデータのハッシュ値を再計算し、受信したハッシュ値と比較できます。両者が一致すれば、そのデータは完全だと見なされます。</li> </ul> <p>暗号分野の応用では、ハッシュ値から元のパスワードを推測するといった逆解析を防ぐために、ハッシュアルゴリズムにはさらに高いレベルの安全性が求められます。</p> <ul> <li>一方向性：ハッシュ値から入力データに関するいかなる情報も逆算できないこと。</li> <li>耐衝突性：異なる 2 つの入力で同じハッシュ値になるものを見つけることが、極めて困難であること。</li> <li>アバランシェ効果：入力のわずかな変化が、出力の大きく予測不能な変化を引き起こすこと。</li> </ul> <p>注意してほしいのは、**「均一分布」と「耐衝突性」は独立した 2 つの概念である**という点です。均一分布を満たしていても、耐衝突性を満たすとは限りません。たとえば、入力 <code>key</code> がランダムである場合、ハッシュ関数 <code>key % 100</code> は均一に分布した出力を生成できます。しかし、このハッシュアルゴリズムはあまりにも単純で、下 2 桁が同じ <code>key</code> はすべて同じ出力になります。そのため、ハッシュ値から利用可能な <code>key</code> を容易に逆算でき、結果としてパスワードが破られてしまいます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632","level":2,"title":"6.3.2   ハッシュアルゴリズムの設計","text":"<p>ハッシュアルゴリズムの設計は、多くの要素を考慮しなければならない複雑な問題です。しかし、要求の高くない場面であれば、いくつかの単純なハッシュアルゴリズムを設計することもできます。</p> <ul> <li>加算ハッシュ：入力の各文字の ASCII コードを足し合わせ、その合計をハッシュ値とします。</li> <li>乗算ハッシュ：乗算の非相関性を利用し、各ラウンドで定数を掛けながら、各文字の ASCII コードをハッシュ値に累積します。</li> <li>XOR ハッシュ：入力データの各要素を XOR 演算で 1 つのハッシュ値に累積します。</li> <li>回転ハッシュ：各文字の ASCII コードを 1 つのハッシュ値に累積し、各回の累積前にハッシュ値を回転させます。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"加算ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"乗算ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"回転ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* 加算ハッシュ */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* 加算ハッシュ */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* 加算ハッシュ */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* 加算ハッシュ */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 乗算ハッシュ */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR ハッシュ */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* 回転ハッシュ */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* 加算ハッシュ */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 乗算ハッシュ */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR ハッシュ */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* 回転ハッシュ */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* 加算ハッシュ */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乗算ハッシュ */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR ハッシュ */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 回転ハッシュ */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* 加算ハッシュ */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乗算ハッシュ */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR ハッシュ */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 回転ハッシュ */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* 加算ハッシュ */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* 加算ハッシュ */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 乗算ハッシュ */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR ハッシュ */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* 回転ハッシュ */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* 加算ハッシュ */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* 加算ハッシュ */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 乗算ハッシュ */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR ハッシュ */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* 回転ハッシュ */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### 加算ハッシュ ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### 乗算ハッシュ ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR ハッシュ ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### 回転ハッシュ ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>見て分かるように、各ハッシュアルゴリズムの最後のステップでは、大きな素数 \\(1000000007\\) で剰余を取り、ハッシュ値が適切な範囲に収まるようにしています。ここで考えてみる価値があるのは、なぜ素数での剰余を強調するのか、あるいは合成数で剰余を取ることにどんな欠点があるのか、という点です。これは興味深い問題です。</p> <p>先に結論を述べると、法として大きな素数を使うと、ハッシュ値が均一に分布することを最大限に保証できます。素数はほかの数と公約数を持たないため、剰余演算によって生じる周期的なパターンを減らし、ハッシュ衝突を避けやすくなります。</p> <p>たとえば、法として合成数 \\(9\\) を選ぶとします。これは \\(3\\) で割り切れるため、\\(3\\) で割り切れるすべての <code>key</code> は、\\(0\\)、\\(3\\)、\\(6\\) の 3 つのハッシュ値に写像されます。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>入力 <code>key</code> がたまたまこのような等差数列の分布をしていると、ハッシュ値に偏りが生じ、ハッシュ衝突がさらに深刻になります。そこで <code>modulus</code> を素数 \\(13\\) に置き換えると仮定すると、<code>key</code> と <code>modulus</code> の間に公約数が存在しないため、出力されるハッシュ値の均一性は明らかに向上します。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>補足すると、<code>key</code> がランダムかつ均一に分布していると保証できるなら、法に素数を選んでも合成数を選んでも構いません。どちらでも均一に分布したハッシュ値を出力できます。しかし、<code>key</code> の分布に何らかの周期性がある場合、合成数で剰余を取るほうが偏りが生じやすくなります。</p> <p>要するに、通常は法として素数を選び、その素数はできるだけ大きいほうが望ましいです。そうすることで周期的なパターンをできる限り取り除き、ハッシュアルゴリズムの堅牢性を高められます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633","level":2,"title":"6.3.3   一般的なハッシュアルゴリズム","text":"<p>上で紹介した単純なハッシュアルゴリズムは、どれも比較的「脆弱」であり、ハッシュアルゴリズムの設計目標にはほど遠いことが分かります。たとえば、加算と XOR は交換法則を満たすため、加算ハッシュと XOR ハッシュでは、内容が同じで順序だけ異なる文字列を区別できません。これはハッシュ衝突を悪化させ、一部の安全上の問題を引き起こす可能性があります。</p> <p>実際には、MD5、SHA-1、SHA-2、SHA-3 などの標準的なハッシュアルゴリズムを用いることが一般的です。これらは任意長の入力データを、固定長のハッシュ値へ写像できます。</p> <p>ここ 1 世紀近くの間、ハッシュアルゴリズムは継続的に改良と最適化が進められてきました。ある研究者たちは性能向上に取り組み、別の研究者やハッカーたちは安全性の弱点を探し続けてきました。次の表は、実際の応用でよく使われるハッシュアルゴリズムを示したものです。</p> <ul> <li>MD5 と SHA-1 は何度も攻撃に成功されているため、各種のセキュリティ用途では廃止されています。</li> <li>SHA-2 系列の SHA-256 は最も安全なハッシュアルゴリズムの 1 つであり、いまだに成功した攻撃例がないため、多くのセキュリティ用途やプロトコルで広く使われています。</li> <li>SHA-3 は SHA-2 と比べて実装コストが低く、計算効率も高い一方で、現時点での普及度は SHA-2 系列に及びません。</li> </ul> <p> 表 6-2   一般的なハッシュアルゴリズム </p> MD5 SHA-1 SHA-2 SHA-3 発表年 1992 1995 2002 2008 出力長 128 bit 160 bit 256/512 bit 224/256/384/512 bit ハッシュ衝突 多い 多い 非常に少ない 非常に少ない セキュリティレベル 低く、攻撃に成功されている 低く、攻撃に成功されている 高い 高い 用途 廃止済みだが、データ完全性検査には使われる 廃止済み 暗号資産の取引検証、デジタル署名など SHA-2 の代替に使える","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634","level":2,"title":"6.3.4   データ構造のハッシュ値","text":"<p>ご存じのように、ハッシュテーブルの <code>key</code> には整数、小数、文字列などのデータ型を使えます。プログラミング言語は通常、これらのデータ型に対して組み込みのハッシュアルゴリズムを提供し、ハッシュテーブル内のバケットインデックス計算に利用します。Python を例にすると、<code>hash()</code> 関数を呼び出して各種データ型のハッシュ値を計算できます。</p> <ul> <li>整数と真理値のハッシュ値は、その値自身です。</li> <li>浮動小数点数と文字列のハッシュ値の計算はやや複雑なので、興味がある読者は自分で調べてみてください。</li> <li>タプルのハッシュ値は、各要素のハッシュ値を求めてから、それらを組み合わせて 1 つのハッシュ値にしたものです。</li> <li>オブジェクトのハッシュ値は、そのメモリアドレスに基づいて生成されます。オブジェクトのハッシュメソッドをオーバーライドすれば、内容に基づくハッシュ値を実装できます。</li> </ul> <p>Tip</p> <p>注意してください。組み込みのハッシュ値計算関数の定義や方法は、プログラミング言語ごとに異なります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# 整数 3 のハッシュ値は 3\n\nbol = True\nhash_bol = hash(bol)\n# 真理値 True のハッシュ値は 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# 小数 3.14159 のハッシュ値は 326484311674566659\n\nstr = \"Hello アルゴリズム\"\nhash_str = hash(str)\n# 文字列「Hello アルゴリズム」のハッシュ値は 4617003410720528961\n\ntup = (12836, \"シャオハ\")\nhash_tup = hash(tup)\n# タプル (12836, 'シャオハ') のハッシュ値は 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# ノードオブジェクト &lt;ListNode object at 0x1058fd810&gt; のハッシュ値は 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// 整数 3 のハッシュ値は 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// 真理値 1 のハッシュ値は 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// 小数 3.14159 のハッシュ値は 4614256650576692846\n\nstring str = \"Hello アルゴリズム\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// 文字列「Hello アルゴリズム」のハッシュ値は 15466937326284535026\n\n// C++ では、組み込みの std:hash() は基本データ型のハッシュ値計算のみを提供する\n// 配列やオブジェクトのハッシュ値計算は自分で実装する必要がある\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// 整数 3 のハッシュ値は 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// 真理値 true のハッシュ値は 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// 小数 3.14159 のハッシュ値は -1340954729\n\nString str = \"Hello アルゴリズム\";\nint hashStr = str.hashCode();\n// 文字列「Hello アルゴリズム」のハッシュ値は -727081396\n\nObject[] arr = { 12836, \"シャオハ\" };\nint hashTup = Arrays.hashCode(arr);\n// 配列 [12836, シャオハ] のハッシュ値は 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// ノードオブジェクト utils.ListNode@7dc5e7b4 のハッシュ値は 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// 整数 3 のハッシュ値は 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// 真理値 true のハッシュ値は 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// 小数 3.14159 のハッシュ値は -1340954729;\n\nstring str = \"Hello アルゴリズム\";\nint hashStr = str.GetHashCode();\n// 文字列「Hello アルゴリズム」のハッシュ値は -586107568;\n\nobject[] arr = [12836, \"シャオハ\"];\nint hashTup = arr.GetHashCode();\n// 配列 [12836, シャオハ] のハッシュ値は 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// ノードオブジェクト 0 のハッシュ値は 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// 整数 3 のハッシュ値は 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// 真理値 true のハッシュ値は -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// 小数 3.14159 のハッシュ値は -2465384235396674631\n\nlet str = \"Hello アルゴリズム\"\nlet hashStr = str.hashValue\n// 文字列「Hello アルゴリズム」のハッシュ値は -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"シャオハ\")]\nlet hashTup = arr.hashValue\n// 配列 [AnyHashable(12836), AnyHashable(\"シャオハ\")] のハッシュ値は -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// ノードオブジェクト utils.ListNode のハッシュ値は -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.ts<pre><code>// TypeScript は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// 整数 3 のハッシュ値は 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// 真理値 true のハッシュ値は 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// 小数 3.14159 のハッシュ値は 2570631074981783\n\nString str = \"Hello アルゴリズム\";\nint hashStr = str.hashCode;\n// 文字列「Hello アルゴリズム」のハッシュ値は 468167534\n\nList arr = [12836, \"シャオハ\"];\nint hashArr = arr.hashCode;\n// 配列 [12836, シャオハ] のハッシュ値は 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// ノードオブジェクト Instance of 'ListNode' のハッシュ値は 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// 整数 3 のハッシュ値は 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// 真理値 true のハッシュ値は 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// 小数 3.14159 のハッシュ値は 2566941990314602357\n\nlet str = \"Hello アルゴリズム\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// 文字列「Hello アルゴリズム」のハッシュ値は 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"シャオハ\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// タプル (12836, \"シャオハ\") のハッシュ値は 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// ノードオブジェクト RefCell { value: ListNode { val: 42, next: None } } のハッシュ値は15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// 整数 3 のハッシュ値は 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// 真理値 true のハッシュ値は 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// 小数 3.14159 のハッシュ値は -1340954729\n\nval str = \"Hello アルゴリズム\"\nval hashStr = str.hashCode()\n// 文字列「Hello アルゴリズム」のハッシュ値は -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"シャオハ\")\nval hashTup = arr.hashCode()\n// 配列 [12836, シャオハ] のハッシュ値は 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// ノードオブジェクト utils.ListNode@1d81eb93 のハッシュ値は 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# 整数 3 のハッシュ値は -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# 真理値 true のハッシュ値は -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# 小数 3.14159 のハッシュ値は -1479186995943067893\n\nstr = \"Hello アルゴリズム\"\nhash_str = str.hash\n# 文字列「Hello アルゴリズム」のハッシュ値は -4075943250025831763\n\ntup = [12836, 'シャオハ']\nhash_tup = tup.hash\n# タプル (12836, 'シャオハ') のハッシュ値は 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# ノードオブジェクト #&lt;ListNode:0x000078133140ab70&gt; のハッシュ値は 4302940560806366381\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%E6%95%B4%E6%95%B0%203%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%E5%B8%83%E5%B0%94%E9%87%8F%20True%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%E5%B0%8F%E6%95%B0%203.14159%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20%E7%AE%97%E6%B3%95%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%E5%AD%97%E7%AC%A6%E4%B8%B2%E2%80%9CHello%20%E7%AE%97%E6%B3%95%E2%80%9D%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836,%20%22%E5%B0%8F%E5%93%88%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%E5%85%83%E7%BB%84%20%2812836,%20'%E5%B0%8F%E5%93%88'%29%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%AF%B9%E8%B1%A1%20%3CListNode%20object%20at%200x1058fd810%3E%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>多くのプログラミング言語では、不変オブジェクトだけがハッシュテーブルの <code>key</code> として使えます。仮にリスト（動的配列）を <code>key</code> とすると、その内容が変化したときにハッシュ値も変わってしまうため、もとの <code>value</code> をハッシュテーブルから検索できなくなります。</p> <p>カスタムオブジェクト（たとえば連結リストのノード）のメンバ変数は可変ですが、それでもハッシュ可能です。これは、オブジェクトのハッシュ値が通常はメモリアドレスに基づいて生成されるためです。オブジェクトの内容が変化しても、メモリアドレスが変わらなければ、ハッシュ値も変わりません。</p> <p>注意深い人なら、異なるコンソールでプログラムを実行したときに、出力されるハッシュ値が異なることに気づくかもしれません。これは、Python インタプリタが起動のたびに文字列ハッシュ関数へランダムな salt 値を追加しているためです。この方法によって HashDoS 攻撃を効果的に防ぎ、ハッシュアルゴリズムの安全性を高めています。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   ハッシュ衝突","text":"<p>前節で述べたように、**通常、ハッシュ関数の入力空間は出力空間よりもはるかに大きい**ため、理論上ハッシュ衝突は避けられません。例えば、入力空間がすべての整数で、出力空間が配列の容量サイズである場合、必然的に複数の整数が同じバケットインデックスに写像されます。</p> <p>ハッシュ衝突は検索結果の誤りを招き、ハッシュテーブルの利用可能性に深刻な影響を与えます。この問題を解決するために、ハッシュ衝突が発生するたびにハッシュテーブルを拡張し、衝突が消えるまで続けることが考えられます。この方法は単純で効果的ですが、効率が低すぎます。なぜなら、ハッシュテーブルの拡張には大量のデータ移動とハッシュ値の計算が必要だからです。効率を高めるために、次の戦略を採用できます。</p> <ol> <li>ハッシュテーブルのデータ構造を改良し、ハッシュ衝突が発生してもハッシュテーブルが正常に動作できるようにする。</li> <li>必要な場合、すなわちハッシュ衝突が比較的深刻なときにのみ、拡張操作を実行する。</li> </ol> <p>ハッシュテーブルの構造改善方法には、主に「チェイン法」と「オープンアドレッシング」があります。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   チェイン法","text":"<p>元のハッシュテーブルでは、各バケットには 1 つのキーと値のペアしか格納できません。チェイン法（separate chaining）では、単一要素を連結リストに置き換え、キーと値のペアを連結リストのノードとして扱い、衝突したすべてのキーと値のペアを同じ連結リストに格納します。下図はチェイン法によるハッシュテーブルの例を示しています。</p> <p></p> <p> 図 6-5   チェイン法ハッシュテーブル </p> <p>チェイン法で実装されたハッシュテーブルでは、操作方法が次のように変わります。</p> <ul> <li>要素の検索：入力 <code>key</code> をハッシュ関数に通してバケットインデックスを得ると、連結リストの先頭ノードにアクセスできます。その後、連結リストを走査して <code>key</code> を比較し、目的のキーと値のペアを探します。</li> <li>要素の追加：まずハッシュ関数で連結リストの先頭ノードにアクセスし、その後ノード（キーと値のペア）を連結リストに追加します。</li> <li>要素の削除：ハッシュ関数の結果に基づいて連結リストの先頭にアクセスし、続いて連結リストを走査して対象ノードを探し、削除します。</li> </ul> <p>チェイン法には次の制約があります。</p> <ul> <li>使用メモリの増加：連結リストにはノードポインタが含まれるため、配列よりも多くのメモリを消費します。</li> <li>検索効率の低下：対応する要素を見つけるために連結リストを線形走査する必要があるためです。</li> </ul> <p>以下のコードはチェイン法ハッシュテーブルの簡単な実装を示しています。注意すべき点は 2 つあります。</p> <ul> <li>連結リストの代わりにリスト（動的配列）を使って、コードを簡潔にしています。この設定では、ハッシュテーブル（配列）は複数のバケットを含み、各バケットは 1 つのリストです。</li> <li>以下の実装にはハッシュテーブルの拡張メソッドが含まれています。負荷率が \\(\\frac{2}{3}\\) を超えたとき、ハッシュテーブルを元の \\(2\\) 倍に拡張します。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"チェイン法ハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self.size = 0  # キーと値のペア数\n        self.capacity = 4  # ハッシュテーブル容量\n        self.load_thres = 2.0 / 3.0  # リサイズを発動する負荷率のしきい値\n        self.extend_ratio = 2  # 拡張倍率\n        self.buckets = [[] for _ in range(self.capacity)]  # バケット配列\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負荷率\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"検索操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査し、key が見つかれば対応する val を返す\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # key が見つからない場合は None を返す\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"追加操作\"\"\"\n        # 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # その key が存在しなければ、キーと値のペアを末尾に追加\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査してキーと値のペアを削除\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"ハッシュテーブルを拡張\"\"\"\n        # 元のハッシュテーブルを一時保存\n        buckets = self.buckets\n        # リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n  private:\n    int size;                       // キーと値のペア数\n    int capacity;                   // ハッシュテーブル容量\n    double loadThres;               // リサイズを発動する負荷率のしきい値\n    int extendRatio;                // 拡張倍率\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // バケット配列\n\n  public:\n    /* コンストラクタ */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* デストラクタメソッド */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // メモリを解放する\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // key が見つからない場合は空文字列を返す\n        return \"\";\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // そこからキーと値の組を削除する\n                delete tmp;                       // メモリを解放する\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // メモリを解放する\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    int size; // キーと値のペア数\n    int capacity; // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio; // 拡張倍率\n    List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n    /* コンストラクタ */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 検索操作 */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    void put(int key, String val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査してキーと値のペアを削除\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    int size; // キーと値のペア数\n    int capacity; // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio; // 拡張倍率\n    List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n    /* コンストラクタ */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // バケットを走査してキーと値のペアを削除\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void Extend() {\n        // 元のハッシュテーブルを一時保存\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* チェイン法ハッシュテーブル */\ntype hashMapChaining struct {\n    size        int      // キーと値のペア数\n    capacity    int      // ハッシュテーブル容量\n    loadThres   float64  // リサイズを発動する負荷率のしきい値\n    extendRatio int      // 拡張倍率\n    buckets     [][]pair // バケット配列\n}\n\n/* コンストラクタ */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* ハッシュ関数 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* 負荷率 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* 検索操作 */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // バケットを走査し、key が見つかれば対応する val を返す\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // key が見つからない場合は空文字列を返す\n    return \"\"\n}\n\n/* 追加操作 */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // その key が存在しなければ、キーと値のペアを末尾に追加\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* 削除操作 */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // バケットを走査してキーと値のペアを削除\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // スライスから削除する\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nfunc (m *hashMapChaining) extend() {\n    // 元のハッシュテーブルを一時保存\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // リサイズ後の新しいハッシュテーブルを初期化\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* ハッシュテーブルを出力 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    var loadThres: Double // リサイズを発動する負荷率のしきい値\n    var extendRatio: Int // 拡張倍率\n    var buckets: [[Pair]] // バケット配列\n\n    /* コンストラクタ */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* ハッシュ関数 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負荷率 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // `key` が見つからなければ `nil` を返す\n        return nil\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査してキーと値のペアを削除\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    func extend() {\n        // 元のハッシュテーブルを一時保存\n        let bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    #size; // キーと値のペア数\n    #capacity; // ハッシュテーブル容量\n    #loadThres; // リサイズを発動する負荷率のしきい値\n    #extendRatio; // 拡張倍率\n    #buckets; // バケット配列\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key, val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend() {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    #size: number; // キーと値のペア数\n    #capacity: number; // ハッシュテーブル容量\n    #loadThres: number; // リサイズを発動する負荷率のしきい値\n    #extendRatio: number; // 拡張倍率\n    #buckets: Pair[][]; // バケット配列\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* 検索操作 */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key: number, val: string): void {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend(): void {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n  late int size; // キーと値のペア数\n  late int capacity; // ハッシュテーブル容量\n  late double loadThres; // リサイズを発動する負荷率のしきい値\n  late int extendRatio; // 拡張倍率\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n  /* コンストラクタ */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* ハッシュ関数 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* 負荷率 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査し、key が見つかれば対応する val を返す\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // key が見つからない場合は null を返す\n    return null;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // その key が存在しなければ、キーと値のペアを末尾に追加\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査してキーと値のペアを削除\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* ハッシュテーブルを拡張 */\n  void extend() {\n    // 元のハッシュテーブルを一時保存\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* チェイン法ハッシュテーブル */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* コンストラクタ */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* 負荷率 */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* 削除操作 */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // バケットを走査してキーと値のペアを削除\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // key が見つからない場合は None を返す\n        None\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fn extend(&amp;mut self) {\n        // 元のハッシュテーブルを一時保存\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* 追加操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* 検索操作 */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // key が見つからない場合は None を返す\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* 連結リストノード */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* チェイン法ハッシュテーブル */\ntypedef struct {\n    int size;         // キーと値のペア数\n    int capacity;     // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio;  // 拡張倍率\n    Node **buckets;   // バケット配列\n} HashMapChaining;\n\n/* コンストラクタ */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* デストラクタ */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* ハッシュ関数 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負荷率 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 検索操作 */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // バケットを走査し、key が見つかれば対応する val を返す\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // key が見つからない場合は空文字列を返す\n}\n\n/* 追加操作 */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // 指定した `key` に遭遇したら、対応する `val` を更新して返す\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // 該当する `key` がなければ、キーと値のペアを連結リストの先頭に追加する\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* ハッシュテーブルを拡張 */\nvoid extend(HashMapChaining *hashMap) {\n    // 元のハッシュテーブルを一時保存\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // メモリを解放する\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* 削除操作 */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // そこからキーと値の組を削除する\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // メモリを解放する\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    val loadThres: Double // リサイズを発動する負荷率のしきい値\n    val extendRatio: Int // 拡張倍率\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // バケット配列\n\n    /* コンストラクタ */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負荷率 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // key が見つからない場合は null を返す\n        return null\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査してキーと値のペアを削除\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fun extend() {\n        // 元のハッシュテーブルを一時保存\n        val bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        // mutablelist には固定サイズがない\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### キーアドレス法ハッシュテーブル ###\nclass HashMapChaining\n  ### コンストラクタ ###\n  def initialize\n    @size = 0 # キーと値のペア数\n    @capacity = 4 # ハッシュテーブル容量\n    @load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値\n    @extend_ratio = 2 # 拡張倍率\n    @buckets = Array.new(@capacity) { [] } # バケット配列\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負荷率 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査し、key が見つかれば対応する val を返す\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # `key` が見つからなければ `nil` を返す\n    nil\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    # 負荷率がしきい値を超えたら、リサイズを実行\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # その key が存在しなければ、キーと値のペアを末尾に追加\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査してキーと値のペアを削除\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### ハッシュテーブルを拡張 ###\n  def extend\n    # 元のハッシュテーブルを一時保存\n    buckets = @buckets\n    # リサイズ後の新しいハッシュテーブルを初期化\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>注意すべきなのは、連結リストが長い場合、検索効率 \\(O(n)\\) は非常に低いことです。このとき、連結リストを「AVL 木」または「赤黒木」に変換することで、検索操作の時間計算量を \\(O(\\log n)\\) に最適化できます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   オープンアドレッシング","text":"<p>オープンアドレッシング（open addressing）では追加のデータ構造を導入せず、「複数回の探索」によってハッシュ衝突を処理します。探索方法には主に線形探索、二次探索、多重ハッシュなどがあります。</p> <p>以下では線形探索を例に、オープンアドレッシングハッシュテーブルの動作の仕組みを説明します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   線形探索","text":"<p>線形探索では、固定ステップ長の線形探索によって探索を行います。その操作方法は通常のハッシュテーブルとは異なります。</p> <ul> <li>要素の挿入：ハッシュ関数によってバケットインデックスを計算し、バケット内にすでに要素がある場合は、衝突位置から後方へ線形に走査し（ステップ長は通常 \\(1\\) ）、空のバケットが見つかるまで進み、その中に要素を挿入します。</li> <li>要素の検索：ハッシュ衝突が見つかった場合は、同じステップ長で後方へ線形走査を行い、対応する要素が見つかるまで続け、 <code>value</code> を返します。空のバケットに遭遇した場合は、対象要素がハッシュテーブル内に存在しないことを意味するため、 <code>None</code> を返します。</li> </ul> <p>下図はオープンアドレッシング（線形探索）ハッシュテーブルにおけるキーと値のペアの分布を示しています。このハッシュ関数では、末尾 2 桁が同じ <code>key</code> はすべて同じバケットに写像されます。線形探索によって、それらはそのバケットとその後続のバケットに順に格納されます。</p> <p></p> <p> 図 6-6   オープンアドレッシング（線形探索）ハッシュテーブルにおけるキーと値のペアの分布 </p> <p>しかし、**線形探索では「クラスタリング現象」が起こりやすい**です。具体的には、配列内で連続して占有された位置が長いほど、それらの連続位置でハッシュ衝突が発生する可能性が高くなり、さらにその位置の集積成長を促して悪循環を生み、最終的には追加・削除・検索・更新操作の効率低下を招きます。</p> <p>注意すべきなのは、**オープンアドレッシングハッシュテーブルでは要素を直接削除できない**ことです。これは、要素を削除すると配列内に空バケット <code>None</code> が生じ、要素を検索するときに線形探索がその空バケットに到達した時点で返ってしまうため、その空バケットより後ろの要素には二度とアクセスできなくなるからです。結果として、プログラムがそれらの要素を存在しないと誤判定する可能性があります。下図のとおりです。</p> <p></p> <p> 図 6-7   オープンアドレッシングで要素を削除したことによる検索問題 </p> <p>この問題を解決するために、遅延削除（lazy deletion）の仕組みを採用できます。これは要素をハッシュテーブルから直接取り除かず、代わりに定数 <code>TOMBSTONE</code> を使ってこのバケットをマークします。この仕組みでは、<code>None</code> と <code>TOMBSTONE</code> はどちらも空バケットを表し、どちらにもキーと値のペアを配置できます。ただし異なるのは、線形探索が <code>TOMBSTONE</code> に到達した場合は、その先にキーと値のペアが存在する可能性があるため、探索を続けるべきだという点です。</p> <p>しかし、遅延削除はハッシュテーブルの性能劣化を加速させる可能性があります。これは、削除操作のたびに削除マークが 1 つ生成され、<code>TOMBSTONE</code> が増えるにつれて探索時間も増加するためです。線形探索では、対象要素を見つけるまでに複数の <code>TOMBSTONE</code> を飛び越える必要があるかもしれません。</p> <p>そのため、線形探索では、遭遇した最初の <code>TOMBSTONE</code> のインデックスを記録し、見つかった対象要素とその <code>TOMBSTONE</code> を交換することを考えます。こうする利点は、要素を検索または追加するたびに、要素が理想位置（探索開始点）により近いバケットへ移動し、検索効率が向上することです。</p> <p>以下のコードは、遅延削除を含むオープンアドレッシング（線形探索）ハッシュテーブルを実装したものです。ハッシュテーブルの空間をより十分に活用するために、ハッシュテーブルを「環状配列」とみなし、配列末尾を越えたら先頭に戻って探索を続けます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"オープンアドレス法ハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self.size = 0  # キーと値のペア数\n        self.capacity = 4  # ハッシュテーブル容量\n        self.load_thres = 2.0 / 3.0  # リサイズを発動する負荷率のしきい値\n        self.extend_ratio = 2  # 拡張倍率\n        self.buckets: list[Pair | None] = [None] * self.capacity  # バケット配列\n        self.TOMBSTONE = Pair(-1, \"-1\")  # 削除済みマーク\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負荷率\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"key に対応するバケットインデックスを探す\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # 線形プロービングを行い、空バケットに達したら終了\n        while self.buckets[index] is not None:\n            # key が見つかったら、対応するバケットのインデックスを返す\n            if self.buckets[index].key == key:\n                # 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # 移動後のバケットインデックスを返す\n                return index  # バケットのインデックスを返す\n            # 最初に見つかった削除マークを記録\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % self.capacity\n        # key が存在しない場合は追加位置のインデックスを返す\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"検索操作\"\"\"\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、対応する val を返す\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # キーと値のペアが存在しない場合は `None` を返す\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"追加操作\"\"\"\n        # 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、val を上書きして返す\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # キーと値の組が存在しない場合は、その組を追加する\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、削除マーカーで上書きする\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"ハッシュテーブルを拡張\"\"\"\n        # 元のハッシュテーブルを一時保存\n        buckets_tmp = self.buckets\n        # リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // キーと値のペア数\n    int capacity = 4;                     // ハッシュテーブル容量\n    const double loadThres = 2.0 / 3.0;     // リサイズを発動する負荷率のしきい値\n    const int extendRatio = 2;            // 拡張倍率\n    vector&lt;Pair *&gt; buckets;               // バケット配列\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // 削除済みマーク\n\n  public:\n    /* コンストラクタ */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* デストラクタメソッド */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != nullptr) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index]-&gt;key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // キーと値の組が存在しない場合は空文字列を返す\n        return \"\";\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private int size; // キーと値のペア数\n    private int capacity = 4; // ハッシュテーブル容量\n    private final double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n    private final int extendRatio = 2; // 拡張倍率\n    private Pair[] buckets; // バケット配列\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // 削除済みマーク\n\n    /* コンストラクタ */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* ハッシュ関数 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index].key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    public String get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void put(int key, String val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    public void remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    private void extend() {\n        // 元のハッシュテーブルを一時保存\n        Pair[] bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    int size; // キーと値のペア数\n    int capacity = 4; // ハッシュテーブル容量\n    double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n    int extendRatio = 2; // 拡張倍率\n    Pair[] buckets; // バケット配列\n    Pair TOMBSTONE = new(-1, \"-1\"); // 削除済みマーク\n\n    /* コンストラクタ */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index].key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void Extend() {\n        // 元のハッシュテーブルを一時保存\n        Pair[] bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* オープンアドレス法ハッシュテーブル */\ntype hashMapOpenAddressing struct {\n    size        int     // キーと値のペア数\n    capacity    int     // ハッシュテーブル容量\n    loadThres   float64 // リサイズを発動する負荷率のしきい値\n    extendRatio int     // 拡張倍率\n    buckets     []*pair // バケット配列\n    TOMBSTONE   *pair   // 削除済みマーク\n}\n\n/* コンストラクタ */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* ハッシュ関数 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // キーに基づいてハッシュ値を計算\n}\n\n/* 負荷率 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // 現在の負荷率を計算\n}\n\n/* key に対応するバケットインデックスを探す */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // 初期インデックスを取得\n    firstTombstone := -1     // 最初に遭遇した `TOMBSTONE` の位置を記録する\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // 移動後のバケットインデックスを返す\n            }\n            return index // 見つかったインデックスを返す\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // 最初に遭遇した削除マークの位置を記録する\n        }\n        index = (index + 1) % h.capacity // 線形探索を行い、末尾を越えたら先頭に戻る\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* 検索操作 */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // キーと値の組が見つかったら、対応する val を返す\n    }\n    return \"\" // キーと値のペアが存在しない場合は `\"\"` を返す\n}\n\n/* 追加操作 */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // 負荷率がしきい値を超えたら、リサイズを実行\n    }\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // キーと値の組が存在しない場合は、その組を追加する\n        h.size++\n    } else {\n        h.buckets[index].val = val // キーと値のペアが見つかった場合は、`val` を上書きする\n    }\n}\n\n/* 削除操作 */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // キーと値の組が見つかったら、削除マーカーで上書きする\n        h.size--\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // 元のハッシュテーブルを一時保存\n    h.capacity *= h.extendRatio           // 容量を更新\n    h.buckets = make([]*pair, h.capacity) // リサイズ後の新しいハッシュテーブルを初期化\n    h.size = 0                            // サイズをリセットする\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* ハッシュテーブルを出力 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    var loadThres: Double // リサイズを発動する負荷率のしきい値\n    var extendRatio: Int // 拡張倍率\n    var buckets: [Pair?] // バケット配列\n    var TOMBSTONE: Pair // 削除済みマーク\n\n    /* コンストラクタ */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* ハッシュ関数 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負荷率 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // 線形プロービングを行い、空バケットに達したら終了\n        while buckets[index] != nil {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if buckets[index]!.key == key {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 移動後のバケットインデックスを返す\n                }\n                return index // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、対応する val を返す\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // キーと値の組が存在しなければ null を返す\n        return nil\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、val を上書きして返す\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    func extend() {\n        // 元のハッシュテーブルを一時保存\n        let bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    #size; // キーと値のペア数\n    #capacity; // ハッシュテーブル容量\n    #loadThres; // リサイズを発動する負荷率のしきい値\n    #extendRatio; // 拡張倍率\n    #buckets; // バケット配列\n    #TOMBSTONE; // 削除済みマーク\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0; // キーと値のペア数\n        this.#capacity = 4; // ハッシュテーブル容量\n        this.#loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n        this.#extendRatio = 2; // 拡張倍率\n        this.#buckets = Array(this.#capacity).fill(null); // バケット配列\n        this.#TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (this.#buckets[index] !== null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (this.#buckets[index].key === key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % this.#capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key, val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key) {\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend() {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private size: number; // キーと値のペア数\n    private capacity: number; // ハッシュテーブル容量\n    private loadThres: number; // リサイズを発動する負荷率のしきい値\n    private extendRatio: number; // 拡張倍率\n    private buckets: Array&lt;Pair | null&gt;; // バケット配列\n    private TOMBSTONE: Pair; // 削除済みマーク\n\n    /* コンストラクタ */\n    constructor() {\n        this.size = 0; // キーと値のペア数\n        this.capacity = 4; // ハッシュテーブル容量\n        this.loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n        this.extendRatio = 2; // 拡張倍率\n        this.buckets = Array(this.capacity).fill(null); // バケット配列\n        this.TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク\n    }\n\n    /* ハッシュ関数 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* 負荷率 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (this.buckets[index] !== null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (this.buckets[index]!.key === key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % this.capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    get(key: number): string | null {\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key: number, val: string): void {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* 削除操作 */\n    remove(key: number): void {\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    private extend(): void {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n  late int _size; // キーと値のペア数\n  int _capacity = 4; // ハッシュテーブル容量\n  double _loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n  int _extendRatio = 2; // 拡張倍率\n  late List&lt;Pair?&gt; _buckets; // バケット配列\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // 削除済みマーク\n\n  /* コンストラクタ */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* ハッシュ関数 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* 負荷率 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* key に対応するバケットインデックスを探す */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // 線形プロービングを行い、空バケットに達したら終了\n    while (_buckets[index] != null) {\n      // key が見つかったら、対応するバケットのインデックスを返す\n      if (_buckets[index]!.key == key) {\n        // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // 移動後のバケットインデックスを返す\n        }\n        return index; // バケットのインデックスを返す\n      }\n      // 最初に見つかった削除マークを記録\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n      index = (index + 1) % _capacity;\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、対応する val を返す\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // キーと値の組が存在しなければ null を返す\n    return null;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、val を上書きして返す\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // キーと値の組が存在しない場合は、その組を追加する\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、削除マーカーで上書きする\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* ハッシュテーブルを拡張 */\n  void extend() {\n    // 元のハッシュテーブルを一時保存\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* オープンアドレス法ハッシュテーブル */\nstruct HashMapOpenAddressing {\n    size: usize,                // キーと値のペア数\n    capacity: usize,            // ハッシュテーブル容量\n    load_thres: f64,            // リサイズを発動する負荷率のしきい値\n    extend_ratio: usize,        // 拡張倍率\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // バケット配列\n    TOMBSTONE: Option&lt;Pair&gt;,    // 削除済みマーク\n}\n\nimpl HashMapOpenAddressing {\n    /* コンストラクタ */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* 負荷率 */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while self.buckets[index].is_some() {\n            // `key` に遭遇したら、対応するバケットのインデックスを返す\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // 以前に削除マークに遭遇していた場合は、キーと値のペアをそのインデックスへ移動する\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % self.capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* 検索操作 */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // キーと値の組が存在しなければ null を返す\n        None\n    }\n\n    /* 追加操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* 削除操作 */\n    fn remove(&amp;mut self, key: i32) {\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fn extend(&amp;mut self) {\n        // 元のハッシュテーブルを一時保存\n        let buckets_tmp = self.buckets.clone();\n        // リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* ハッシュテーブルを出力 */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* オープンアドレス法ハッシュテーブル */\ntypedef struct {\n    int size;         // キーと値のペア数\n    int capacity;     // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio;  // 拡張倍率\n    Pair **buckets;   // バケット配列\n    Pair *TOMBSTONE;  // 削除済みマーク\n} HashMapOpenAddressing;\n\n/* コンストラクタ */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* デストラクタ */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* ハッシュ関数 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負荷率 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* key に対応するバケットインデックスを探す */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // 線形プロービングを行い、空バケットに達したら終了\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // key が見つかったら、対応するバケットのインデックスを返す\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // 移動後のバケットインデックスを返す\n            }\n            return index; // バケットのインデックスを返す\n        }\n        // 最初に見つかった削除マークを記録\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* 検索操作 */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、対応する val を返す\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // キーと値の組が存在しない場合は空文字列を返す\n    return \"\";\n}\n\n/* 追加操作 */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、val を上書きして返す\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // キーと値の組が存在しない場合は、その組を追加する\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* 削除操作 */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、削除マーカーで上書きする\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // 元のハッシュテーブルを一時保存\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private var size: Int               // キーと値のペア数\n    private var capacity: Int           // ハッシュテーブル容量\n    private val loadThres: Double       // リサイズを発動する負荷率のしきい値\n    private val extendRatio: Int        // 拡張倍率\n    private var buckets: Array&lt;Pair?&gt;   // バケット配列\n    private val TOMBSTONE: Pair         // 削除済みマーク\n\n    /* コンストラクタ */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負荷率 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index]?.key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 移動後のバケットインデックスを返す\n                }\n                return index // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fun extend() {\n        // 元のハッシュテーブルを一時保存\n        val bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### オープンアドレス法ハッシュテーブル ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # 削除済みマーク\n\n  ### コンストラクタ ###\n  def initialize\n    @size = 0 # キーと値のペア数\n    @capacity = 4 # ハッシュテーブル容量\n    @load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値\n    @extend_ratio = 2 # 拡張倍率\n    @buckets = Array.new(@capacity) # バケット配列\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負荷率 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### key に対応するバケットインデックスを検索 ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # 線形プロービングを行い、空バケットに達したら終了\n    while !@buckets[index].nil?\n      # key が見つかったら、対応するバケットのインデックスを返す\n      if @buckets[index].key == key\n        # 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # 移動後のバケットインデックスを返す\n        end\n        return index # バケットのインデックスを返す\n      end\n      # 最初に見つかった削除マークを記録\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n      index = (index + 1) % @capacity\n    end\n    # key が存在しない場合は追加位置のインデックスを返す\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値の組が見つかったら、対応する val を返す\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # キーと値のペアが存在しない場合は `nil` を返す\n    nil\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    # 負荷率がしきい値を超えたら、リサイズを実行\n    extend if load_factor &gt; @load_thres\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値のペアが見つかった場合は、`val` を上書きして返す\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # キーと値の組が存在しない場合は、その組を追加する\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値の組が見つかったら、削除マーカーで上書きする\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### ハッシュテーブルを拡張 ###\n  def extend\n    # 元のハッシュテーブルを一時保存\n    buckets_tmp = @buckets\n    # リサイズ後の新しいハッシュテーブルを初期化\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   二次探索","text":"<p>二次探索は線形探索に似ており、オープンアドレッシングの一般的な戦略の 1 つです。衝突が発生したとき、二次探索では単純に固定歩数を飛ばすのではなく、「探索回数の二乗」に相当する歩数、すなわち \\(1, 4, 9, \\dots\\) 歩を飛ばします。</p> <p>二次探索には主に次の利点があります。</p> <ul> <li>二次探索は、探索回数の二乗の距離を飛ばすことで、線形探索のクラスタリング効果を緩和しようとします。</li> <li>二次探索はより大きな距離を飛ばして空き位置を探すため、データ分布がより均一になるのに役立ちます。</li> </ul> <p>しかし、二次探索は完璧ではありません。</p> <ul> <li>依然としてクラスタリング現象は存在し、ある位置が他の位置より占有されやすいことがあります。</li> <li>二乗の増加により、二次探索はハッシュテーブル全体を探索できない可能性があります。これは、ハッシュテーブルに空バケットがあっても、二次探索ではそこに到達できないことがあることを意味します。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   多重ハッシュ","text":"<p>その名のとおり、多重ハッシュ法では複数のハッシュ関数 \\(f_1(x)\\)、\\(f_2(x)\\)、\\(f_3(x)\\)、\\(\\dots\\) を使って探索を行います。</p> <ul> <li>要素の挿入：ハッシュ関数 \\(f_1(x)\\) で衝突が発生した場合は、\\(f_2(x)\\) を試し、以下同様に、空き位置が見つかるまで続けてから要素を挿入します。</li> <li>要素の検索：同じハッシュ関数の順序で探索し、対象要素が見つかった時点で返します。空き位置に遭遇するか、すべてのハッシュ関数を試しても見つからない場合は、ハッシュテーブル内にその要素は存在しないため、 <code>None</code> を返します。</li> </ul> <p>線形探索と比べると、多重ハッシュ法はクラスタリングを起こしにくい一方で、複数のハッシュ関数により追加の計算量が発生します。</p> <p>Tip</p> <p>注意してください。オープンアドレッシング（線形探索、二次探索、多重ハッシュ）のハッシュテーブルには、いずれも「要素を直接削除できない」という問題があります。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   プログラミング言語の選択","text":"<p>各種プログラミング言語は異なるハッシュテーブル実装戦略を採用しています。以下にいくつか例を挙げます。</p> <ul> <li>Python はオープンアドレッシングを採用しています。辞書 <code>dict</code> は疑似乱数を用いて探索します。</li> <li>Java はチェイン法を採用しています。JDK 1.8 以降、<code>HashMap</code> 内の配列長が 64 に達し、かつ連結リスト長が 8 に達すると、連結リストは検索性能を高めるため赤黒木に変換されます。</li> <li>Go はチェイン法を採用しています。Go では各バケットに最大 8 個のキーと値のペアを格納でき、容量を超えるとオーバーフローバケットを連結します。オーバーフローバケットが多すぎる場合は、性能を確保するために特殊な等量拡張操作を実行します。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   ハッシュテーブル","text":"<p>ハッシュテーブル（hash table）は、散列表とも呼ばれ、キー <code>key</code> と値 <code>value</code> の対応関係を構築することで、高効率な要素検索を実現します。具体的には、ハッシュテーブルにキー <code>key</code> を入力すると、対応する値 <code>value</code> を \\(O(1)\\) 時間で取得できます。</p> <p>以下の図に示すように、\\(n\\) 人の学生がいるとし、各学生は「名前」と「学籍番号」の 2 つの情報を持っています。もし「学籍番号を入力すると対応する名前を返す」という検索機能を実現したいなら、下図のようなハッシュテーブルを用いることができます。</p> <p></p> <p> 図 6-1   ハッシュテーブルの抽象表現 </p> <p>ハッシュテーブルのほかに、配列や連結リストでも検索機能を実現できます。それらの効率比較を次の表に示します。</p> <ul> <li>要素の追加：要素を配列（連結リスト）の末尾に追加するだけでよく、\\(O(1)\\) 時間です。</li> <li>要素の検索：配列（連結リスト）は無秩序なので、すべての要素を走査する必要があり、\\(O(n)\\) 時間かかります。</li> <li>要素の削除：先に要素を検索してから配列（連結リスト）から削除する必要があり、\\(O(n)\\) 時間かかります。</li> </ul> <p> 表 6-1   要素検索効率の比較 </p> 配列 連結リスト ハッシュテーブル 要素の検索 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) 要素の追加 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 要素の削除 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>以上から分かるように、ハッシュテーブルにおける追加・削除・検索・更新の時間計算量はいずれも \\(O(1)\\) であり、非常に高効率です。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#611","level":2,"title":"6.1.1   ハッシュテーブルの基本操作","text":"<p>ハッシュテーブルの一般的な操作には、初期化、検索、キーと値のペアの追加、キーと値のペアの削除などがあります。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># ハッシュテーブルを初期化\nhmap: dict = {}\n\n# 追加操作\n# ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n# 検索操作\n# ハッシュテーブルにキー key を入力し、値 value を取得\nname: str = hmap[15937]\n\n# 削除操作\n# ハッシュテーブルからキーと値のペア (key, value) を削除\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* ハッシュテーブルを初期化 */\nunordered_map&lt;int, string&gt; map;\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\";\nmap[15937] = \"シャオルオ\";\nmap[16750] = \"シャオスワン\";\nmap[13276] = \"シャオファ\";\nmap[10583] = \"シャオヤー\";\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nstring name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* ハッシュテーブルを初期化 */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.put(12836, \"シャオハ\");\nmap.put(15937, \"シャオルオ\");\nmap.put(16750, \"シャオスワン\");\nmap.put(13276, \"シャオファ\");\nmap.put(10583, \"シャオヤー\");\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nString name = map.get(15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* ハッシュテーブルを初期化 */\nDictionary&lt;int, string&gt; map = new() {\n    /* 追加操作 */\n    // ハッシュテーブルにキーと値のペア (key, value) を追加\n    { 12836, \"シャオハ\" },\n    { 15937, \"シャオルオ\" },\n    { 16750, \"シャオスワン\" },\n    { 13276, \"シャオファ\" },\n    { 10583, \"シャオヤー\" }\n};\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nstring name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* ハッシュテーブルを初期化 */\nhmap := make(map[int]string)\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nname := hmap[15937]\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* ハッシュテーブルを初期化 */\nvar map: [Int: String] = [:]\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\"\nmap[15937] = \"シャオルオ\"\nmap[16750] = \"シャオスワン\"\nmap[13276] = \"シャオファ\"\nmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map[15937]!\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* ハッシュテーブルを初期化 */\nconst map = new Map();\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.set(12836, 'シャオハ');\nmap.set(15937, 'シャオルオ');\nmap.set(16750, 'シャオスワン');\nmap.set(13276, 'シャオファ');\nmap.set(10583, 'シャオヤー');\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map.get(15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* ハッシュテーブルを初期化 */\nconst map = new Map&lt;number, string&gt;();\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.set(12836, 'シャオハ');\nmap.set(15937, 'シャオルオ');\nmap.set(16750, 'シャオスワン');\nmap.set(13276, 'シャオファ');\nmap.set(10583, 'シャオヤー');\nconsole.info('\\n追加後のハッシュテーブルは次のとおりです\\nKey -&gt; Value');\nconsole.info(map);\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map.get(15937);\nconsole.info('\\n学籍番号 15937 を入力し、名前を検索: ' + name);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.delete(10583);\nconsole.info('\\n10583 を削除した後のハッシュテーブル\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* ハッシュテーブルを初期化 */\nMap&lt;int, String&gt; map = {};\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\";\nmap[15937] = \"シャオルオ\";\nmap[16750] = \"シャオスワン\";\nmap[13276] = \"シャオファ\";\nmap[10583] = \"シャオヤー\";\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nString name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* ハッシュテーブルを初期化 */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.insert(12836, \"シャオハ\".to_string());\nmap.insert(15937, \"シャオルオ\".to_string());\nmap.insert(16750, \"シャオスワン\".to_string());\nmap.insert(13279, \"シャオファ\".to_string());\nmap.insert(10583, \"シャオヤー\".to_string());\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C には組み込みのハッシュテーブルはありません\n</code></pre> hash_map.kt<pre><code>/* ハッシュテーブルを初期化 */\nval map = HashMap&lt;Int,String&gt;()\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\"\nmap[15937] = \"シャオルオ\"\nmap[16750] = \"シャオスワン\"\nmap[13276] = \"シャオファ\"\nmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nval name = map[15937]\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># ハッシュテーブルを初期化\nhmap = {}\n\n# 追加操作\n# ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n# 検索操作\n# ハッシュテーブルにキー key を入力し、値 value を取得\nname = hmap[15937]\n\n# 削除操作\n# ハッシュテーブルからキーと値のペア (key, value) を削除\nhmap.delete(10583)\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%9F%A5%E8%AF%A2%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%90%91%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E8%BE%93%E5%85%A5%E9%94%AE%20key%20%EF%BC%8C%E5%BE%97%E5%88%B0%E5%80%BC%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E5%88%A0%E9%99%A4%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>ハッシュテーブルには、キーと値のペア、キー、値を走査する 3 つの一般的な方法があります。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># ハッシュテーブルを走査\n# キーと値のペア key-&gt;value を走査\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# キー key のみを走査\nfor key in hmap.keys():\n    print(key)\n# 値 value のみを走査\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// イテレータを使って key-&gt;value を走査\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// キー key のみを走査\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// 値 value のみを走査\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// キー key のみを走査\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// 値 value のみを走査\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// キー key のみを走査\nfor key := range hmap {\n    fmt.Println(key)\n}\n// 値 value のみを走査\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// キー Key のみを走査\nfor key in map.keys {\n    print(key)\n}\n// 値 Value のみを走査\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* ハッシュテーブルを走査 */\nconsole.info('\\nキーと値のペア Key-&gt;Value を走査');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nキー Key のみを走査');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n値 Value のみを走査');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* ハッシュテーブルを走査 */\nconsole.info('\\nキーと値のペア Key-&gt;Value を走査');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nキー Key のみを走査');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n値 Value のみを走査');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// キー Key のみを走査\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// 値 Value のみを走査\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// キー Key のみを走査\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// 値 Value のみを走査\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C には組み込みのハッシュテーブルはありません\n</code></pre> hash_map.kt<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// キー key のみを走査\nfor (key in map.keys) {\n    println(key)\n}\n// 値 value のみを走査\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># ハッシュテーブルを走査\n# キーと値のペア key-&gt;value を走査\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# キー key のみを走査\nhmap.keys.each { |key| puts key }\n\n# 値 value のみを走査\nhmap.values.each { |val| puts val }\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E9%94%AE%E5%80%BC%E5%AF%B9%20key-%3Evalue%0A%20%20%20%20for%20key,%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key,%20%22-%3E%22,%20value%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E9%94%AE%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E5%80%BC%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#612","level":2,"title":"6.1.2   ハッシュテーブルの簡単な実装","text":"<p>まずは最も単純なケースとして、**1 つの配列だけでハッシュテーブルを実装する**ことを考えます。ハッシュテーブルでは、配列中の各空き位置をバケット（bucket）と呼び、各バケットには 1 つのキーと値のペアを格納できます。したがって、検索操作とは <code>key</code> に対応するバケットを見つけ、そのバケットから <code>value</code> を取得することです。</p> <p>では、<code>key</code> に基づいて対応するバケットをどのように特定するのでしょうか。これはハッシュ関数（hash function）によって実現されます。ハッシュ関数の役割は、大きな入力空間をより小さな出力空間に写像することです。ハッシュテーブルでは、入力空間はすべての <code>key</code> 、出力空間はすべてのバケット（配列インデックス）です。言い換えると、<code>key</code> を入力すると、ハッシュ関数によってその <code>key</code> に対応するキーと値のペアの配列内での格納位置を求められます。</p> <p><code>key</code> を入力したとき、ハッシュ関数の計算過程は次の 2 段階に分かれます。</p> <ol> <li>あるハッシュアルゴリズム <code>hash()</code> を用いてハッシュ値を計算します。</li> <li>ハッシュ値をバケット数（配列長）<code>capacity</code> で剰余し、その <code>key</code> に対応するバケット（配列インデックス）<code>index</code> を求めます。</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>その後、<code>index</code> を使ってハッシュテーブル内の対応するバケットにアクセスし、<code>value</code> を取得できます。</p> <p>配列長を <code>capacity = 100</code> 、ハッシュアルゴリズムを <code>hash(key) = key</code> とすると、ハッシュ関数は <code>key % 100</code> となります。次の図では、<code>key</code> を学籍番号、<code>value</code> を名前の例として、ハッシュ関数の動作原理を示します。</p> <p></p> <p> 図 6-2   ハッシュ関数の動作原理 </p> <p>以下のコードは、単純なハッシュテーブルを実装したものです。ここでは、キーと値のペアを表すために <code>key</code> と <code>value</code> をクラス <code>Pair</code> にまとめています。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"キーと値の組\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"配列ベースのハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        # 100 個のバケットを含む配列を初期化\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"検索操作\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"追加と更新の操作\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        index: int = self.hash_func(key)\n        # None に設定し、削除を表す\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"すべてのキーと値のペアを取得\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"すべてのキーを取得\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"すべての値を取得\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* キーと値の組 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // メモリを解放する\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // メモリを解放して nullptr に設定する\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* キーと値の組 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* ハッシュ関数 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* 削除操作 */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // null に設定し、削除を表す\n        buckets.set(index, null);\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* キーと値の組 int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // null に設定し、削除を表す\n        buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* キーと値の組 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* 配列ベースのハッシュテーブル */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* ハッシュテーブルを初期化 */\nfunc newArrayHashMap() *arrayHashMap {\n    // 100 個のバケットを含む配列を初期化\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* ハッシュ関数 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* 検索操作 */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* 追加操作 */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* 削除操作 */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // nil に設定し、削除を表す\n    a.buckets[index] = nil\n}\n\n/* すべてのキーのペアを取得する */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* すべてのキーを取得 */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* すべての値を取得 */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* ハッシュテーブルを出力 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* キーと値の組 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* ハッシュ関数 */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // nil に設定し、削除を表す\n        buckets[index] = nil\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* すべてのキーを取得 */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* すべての値を取得 */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* キーと値の組 Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // 100 個のバケットを含む配列を初期化\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* 削除操作 */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // null に設定し、削除を表す\n        this.#buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* すべてのキーを取得 */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* すべての値を取得 */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* キーと値の組 Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // 100 個のバケットを含む配列を初期化\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* ハッシュ関数 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* 検索操作 */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* 削除操作 */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // null に設定し、削除を表す\n        this.buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* すべてのキーを取得 */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* すべての値を取得 */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* キーと値の組 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // 100 個のバケットを含む配列を初期化\n    _buckets = List.filled(100, null);\n  }\n\n  /* ハッシュ関数 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* すべてのキーと値のペアを取得 */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* すべてのキーを取得 */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* すべての値を取得 */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* キーと値の組 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* 配列ベースのハッシュテーブル */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // 100 個のバケットを含む配列を初期化\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* 検索操作 */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* 追加操作 */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* 削除操作 */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // None に設定し、削除を表す\n        self.buckets[index] = None;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* すべてのキーを取得 */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* すべての値を取得 */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* ハッシュテーブルを出力 */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* キーと値の組 int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* 配列ベースのハッシュテーブル */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* コンストラクタ */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* デストラクタ */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* 追加操作 */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* 削除操作 */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* すべてのキーと値のペアを取得 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* すべてのキーを取得 */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* すべての値を取得 */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* キーと値の組 */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    // 100 個のバケットを含む配列を初期化\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // null に設定し、削除を表す\n        buckets[index] = null\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* すべてのキーを取得 */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* すべての値を取得 */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### キーと値のペア ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### 配列で実装したハッシュテーブル ###\nclass ArrayHashMap\n  ### コンストラクタ ###\n  def initialize\n    # 100 個のバケットを含む配列を初期化\n    @buckets = Array.new(100)\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    # nil に設定し、削除を表す\n    @buckets[index] = nil\n  end\n\n  ### すべてのキーと値のペアを取得 ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### すべてのキーを取得 ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### すべての値を取得 ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#613","level":2,"title":"6.1.3   ハッシュ衝突と拡張","text":"<p>本質的には、ハッシュ関数の役割は、すべての <code>key</code> からなる入力空間を、配列のすべてのインデックスからなる出力空間に写像することです。しかし、入力空間は多くの場合、出力空間よりはるかに大きいため、理論上は必ず「複数の入力が同じ出力に対応する」状況が存在します。</p> <p>上の例のハッシュ関数では、入力 <code>key</code> の下 2 桁が同じであれば、出力結果も同じになります。たとえば、学籍番号 12836 と 20336 の 2 人の学生を検索すると、次の結果を得ます：</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>次の図に示すように、2 つの学籍番号が同じ名前を指してしまっており、これは明らかに誤りです。このような、複数の入力が同じ出力に対応する状況をハッシュ衝突（hash collision）と呼びます。</p> <p></p> <p> 図 6-3   ハッシュ衝突の例 </p> <p>容易に分かるように、ハッシュテーブルの容量 \\(n\\) が大きいほど、複数の <code>key</code> が同じバケットに割り当てられる確率は低くなり、衝突も少なくなります。したがって、ハッシュテーブルを拡張することでハッシュ衝突を減らせます。</p> <p>次の図に示すように、拡張前はキーと値のペア <code>(136, A)</code> と <code>(236, D)</code> が衝突していますが、拡張後は衝突が解消されます。</p> <p></p> <p> 図 6-4   ハッシュテーブルの拡張 </p> <p>配列の拡張と同様に、ハッシュテーブルの拡張ではすべてのキーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移し替える必要があり、非常に時間がかかります。また、ハッシュテーブルの容量 <code>capacity</code> が変わるため、ハッシュ関数を使ってすべてのキーと値のペアの格納位置を再計算しなければならず、これによって拡張過程の計算コストがさらに増加します。そのため、プログラミング言語では通常、頻繁な拡張を防ぐために十分大きなハッシュテーブル容量をあらかじめ確保します。</p> <p>負荷率（load factor）はハッシュテーブルにおける重要な概念であり、ハッシュテーブル内の要素数をバケット数で割ったものとして定義され、ハッシュ衝突の深刻さを測るために用いられます。また、ハッシュテーブル拡張の発動条件としてもよく使われます。例えば Java では、負荷率が \\(0.75\\) を超えると、システムはハッシュテーブルを元の \\(2\\) 倍に拡張します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   まとめ","text":"","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li><code>key</code> を入力すると、ハッシュテーブルは \\(O(1)\\) 時間で <code>value</code> を検索でき、非常に高効率である。</li> <li>一般的なハッシュテーブルの操作には、検索、キーと値のペアの追加、キーと値のペアの削除、ハッシュテーブルの走査などがある。</li> <li>ハッシュ関数は <code>key</code> を配列インデックスに写像し、それによって対応するバケットにアクセスして <code>value</code> を取得する。</li> <li>異なる 2 つの <code>key</code> が、ハッシュ関数を通した後に同じ配列インデックスになることがあり、検索結果の誤りを引き起こす。この現象をハッシュ衝突と呼ぶ。</li> <li>ハッシュテーブルの容量が大きいほど、ハッシュ衝突の確率は低くなる。そのため、ハッシュテーブルを拡張することでハッシュ衝突を緩和できる。配列の拡張と同様に、ハッシュテーブルの拡張操作のコストは大きい。</li> <li>負荷率は、ハッシュテーブル内の要素数をバケット数で割ったものと定義され、ハッシュ衝突の深刻さを反映する。ハッシュテーブル拡張を発動する条件としてよく用いられる。</li> <li>連鎖方式では、単一要素を連結リストに変換し、衝突したすべての要素を同じ連結リストに格納する。しかし、連結リストが長すぎると検索効率が低下するため、さらに連結リストを赤黒木に変換して効率を高めることができる。</li> <li>オープンアドレス法は複数回の探索によってハッシュ衝突を処理する。線形探索は固定のステップ幅を用いるが、要素を削除できず、クラスタリングが発生しやすいという欠点がある。二重ハッシュは複数のハッシュ関数を用いて探索するため、線形探索に比べてクラスタリングが起きにくいが、複数のハッシュ関数によって計算量が増える。</li> <li>プログラミング言語ごとに、異なるハッシュテーブル実装が採用されている。たとえば、Java の <code>HashMap</code> は連鎖方式を使用し、Python の <code>Dict</code> はオープンアドレス法を採用している。</li> <li>ハッシュテーブルでは、ハッシュアルゴリズムに決定性、高効率、均一分布という特徴が求められる。暗号学では、ハッシュアルゴリズムはさらに耐衝突性とアバランシェ効果も備えるべきである。</li> <li>ハッシュアルゴリズムは通常、大きな素数を法として用い、ハッシュ値の均一分布を最大限に保証してハッシュ衝突を減らす。</li> <li>一般的なハッシュアルゴリズムには MD5、SHA-1、SHA-2、SHA-3 などがある。MD5 はファイル完全性の検証によく用いられ、SHA-2 はセキュリティ用途やプロトコルでよく用いられる。</li> <li>プログラミング言語は通常、データ型に対して組み込みのハッシュアルゴリズムを提供し、ハッシュテーブル内のバケットインデックスの計算に用いる。通常、ハッシュ可能なのは不変オブジェクトだけである。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ハッシュテーブルの時間計算量が \\(O(n)\\) になるのはどのような場合ですか？</p> <p>ハッシュ衝突が深刻な場合、ハッシュテーブルの時間計算量は \\(O(n)\\) に劣化する。ハッシュ関数の設計が適切で、容量設定が合理的で、衝突が比較的均等な場合、時間計算量は \\(O(1)\\) である。プログラミング言語組み込みのハッシュテーブルを使うとき、通常は時間計算量を \\(O(1)\\) とみなす。</p> <p>Q：なぜハッシュ関数 \\(f(x) = x\\) を使わないのですか？ そうすれば衝突は起きません。</p> <p>\\(f(x) = x\\) というハッシュ関数では、各要素は一意のバケットインデックスに対応し、これは配列と等価である。しかし、入力空間は通常、出力空間（配列長）よりはるかに大きいため、ハッシュ関数の最後のステップはたいてい配列長での剰余になる。言い換えると、ハッシュテーブルの目的は、大きな状態空間をより小さな空間に写像し、\\(O(1)\\) の検索効率を提供することである。</p> <p>Q：ハッシュテーブルの基礎実装は配列、連結リスト、二分木なのに、なぜそれらより高効率になり得るのですか？</p> <p>まず、ハッシュテーブルは時間効率が高くなる一方で、空間効率は低くなる。ハッシュテーブルには、かなりの部分で未使用のメモリが存在する。</p> <p>次に、時間効率が高くなるのは特定の利用場面に限られる。ある機能が同じ時間計算量で配列や連結リストによって実装できるなら、通常はハッシュテーブルより速い。これは、ハッシュ関数の計算にコストがかかり、時間計算量の定数項がより大きいからである。</p> <p>最後に、ハッシュテーブルの時間計算量は劣化する可能性がある。たとえば連鎖方式では、連結リストや赤黒木で検索操作を行うため、なお \\(O(n)\\) 時間に劣化するリスクがある。</p> <p>Q：二重ハッシュにも要素を直接削除できない欠点がありますか？ 削除済みとマークした領域は再利用できますか？</p> <p>二重ハッシュはオープンアドレス法の一種であり、オープンアドレス法はいずれも要素を直接削除できないという欠点があるため、削除のマーク付けが必要になる。削除済みとマークされた領域は再利用できる。新しい要素をハッシュテーブルに挿入し、ハッシュ関数によって削除済みとマークされた位置を見つけた場合、その位置は新しい要素に使用できる。こうすることで、ハッシュテーブルの探索系列を変えずに保ちつつ、空間利用率も確保できる。</p> <p>Q：なぜ線形探索では、要素を探すときにハッシュ衝突が発生するのですか？</p> <p>探索時には、ハッシュ関数で対応するバケットとキーと値のペアを見つけ、<code>key</code> が一致しないことが分かると、それはハッシュ衝突を意味する。そのため、線形探索法では事前に設定したステップ幅に従って順に探索し、正しいキーと値のペアを見つけるか、見つからずに終了するまで続ける。</p> <p>Q：なぜハッシュテーブルの拡張でハッシュ衝突を緩和できるのですか？</p> <p>ハッシュ関数の最後のステップは、たいてい配列長 \\(n\\) での剰余を取り、出力値を配列インデックスの範囲内に収めることである。拡張後は配列長 \\(n\\) が変化し、<code>key</code> に対応するインデックスも変化する可能性がある。もともと同じバケットに入っていた複数の <code>key</code> は、拡張後には複数のバケットに割り当てられる可能性があり、それによってハッシュ衝突が緩和される。</p> <p>Q：高効率な読み書きのためなら、配列を直接使えばよいのではないですか？</p> <p>データの <code>key</code> が連続した小範囲の整数であれば、配列を直接使えばよく、単純で高効率である。しかし <code>key</code> が別の型（たとえば文字列）の場合は、ハッシュ関数を用いて <code>key</code> を配列インデックスに写像し、さらにバケット配列を通じて要素を格納する必要がある。このような構造がハッシュテーブルである。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"第 8 章   ヒープ","text":"<p>Abstract</p> <p>ヒープは連なる山々の峰のように、幾重にも重なり、さまざまな形をしている。</p> <p>いくつもの山の高さはまちまちだが、最も高い峰がいつも最初に目に入る。</p>","path":["第 8 章 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"章の内容","text":"<ul> <li>8.1   ヒープ</li> <li>8.2   ヒープ構築</li> <li>8.3   Top-k 問題</li> <li>8.4   まとめ</li> </ul>","path":["第 8 章 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   ヒープ構築","text":"<p>場合によっては、リスト内のすべての要素を使ってヒープを構築したいことがあります。この過程を「ヒープ構築」と呼びます。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   ヒープへの挿入操作による実現","text":"<p>まず空のヒープを作成し、次にリストを走査して、各要素に対して順に「ヒープへの挿入操作」を実行します。つまり、要素をヒープの末尾に追加してから、その要素に対して「下から上へ」のヒープ化を行います。</p> <p>要素が1つヒープに挿入されるたびに、ヒープの長さは1増加します。ノードは上から下へ順に二分木へ追加されるため、ヒープは「上から下へ」構築されます。</p> <p>要素数を \\(n\\) とすると、各要素のヒープへの挿入操作には \\(O(\\log{n})\\) の時間がかかるため、このヒープ構築法の時間計算量は \\(O(n \\log n)\\) です。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   走査によるヒープ化で実現","text":"<p>実際には、より効率的なヒープ構築法を実現でき、全体は2つの手順に分かれます。</p> <ol> <li>リストのすべての要素をそのままヒープに追加します。この時点では、ヒープの性質はまだ満たされていません。</li> <li>ヒープを逆順で走査し（レベル順走査の逆順）、各非葉ノードに対して順に「上から下へ」のヒープ化を実行します。</li> </ol> <p>あるノードをヒープ化するたびに、そのノードを根とする部分木は合法な部分ヒープになります。また、逆順で走査するため、ヒープは「下から上へ」構築されます。</p> <p>逆順走査を選ぶのは、この方法なら現在のノードの下にある部分木がすでに合法な部分ヒープであることを保証でき、そのうえで現在のノードをヒープ化してはじめて有効になるからです。</p> <p>なお、葉ノードには子ノードがないため、それ自体が自然に合法な部分ヒープであり、ヒープ化は不要です。以下のコードが示すように、最後の非葉ノードは最後のノードの親ノードであり、そこから逆順に走査してヒープ化を実行します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"コンストラクタ。入力リストに基づいてヒープを構築する\"\"\"\n    # リスト要素をそのままヒープに追加\n    self.max_heap = nums\n    # 葉ノード以外のすべてのノードをヒープ化\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(vector&lt;int&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = nums;\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築 */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = new List&lt;int&gt;(nums);\n    // 葉ノード以外のすべてのノードをヒープ化\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* コンストラクタ。スライスからヒープを構築する */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // リスト要素をそのままヒープに追加\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // 葉ノード以外のすべてのノードをヒープ化\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\ninit(nums: [Int]) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = nums\n    // 葉ノード以外のすべてのノードをヒープ化\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* コンストラクタ。空のヒープを作成するか、入力リストからヒープを構築する */\nconstructor(nums) {\n    // リスト要素をそのままヒープに追加\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* コンストラクタ。空のヒープを作成するか、入力リストからヒープを構築する */\nconstructor(nums?: number[]) {\n    // リスト要素をそのままヒープに追加\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(List&lt;int&gt; nums) {\n  // リスト要素をそのままヒープに追加\n  _maxHeap = nums;\n  // 葉ノード以外のすべてのノードをヒープ化\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // リスト要素をそのままヒープに追加\n    let mut heap = MaxHeap { max_heap: nums };\n    // 葉ノード以外のすべてのノードをヒープ化\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* コンストラクタ。スライスからヒープを構築する */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // すべての要素をヒープに入れる\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // 葉ノード以外のすべてのノードをヒープ化\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* 最大ヒープ */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // 配列ではなくリストを使うことで、拡張を考慮する必要がない\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* コンストラクタ。入力リストに基づいてヒープを構築する */\n    init {\n        // リスト要素をそのままヒープに追加\n        maxHeap.addAll(nums!!)\n        // 葉ノード以外のすべてのノードをヒープ化\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* 左子ノードのインデックスを取得 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 右子ノードのインデックスを取得 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 親ノードのインデックスを取得 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // 切り捨て除算\n    }\n\n    /* 要素を交換 */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* ヒープのサイズを取得 */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* ヒープが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        /* ヒープが空かどうかを判定 */\n        return size() == 0\n    }\n\n    /* ヒープ先頭要素にアクセス */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* 要素をヒープに追加 */\n    fun push(_val: Int) {\n        // ノードを追加\n        maxHeap.add(_val)\n        // 下から上へヒープ化\n        siftUp(size() - 1)\n    }\n\n    /* ノード i から始めて、下から上へヒープ化 */\n    private fun siftUp(it: Int) {\n        // Kotlin の関数引数は不変のため、一時変数を作成する\n        var i = it\n        while (true) {\n            // ノード i の親ノードを取得\n            val p = parent(i)\n            // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // 2 つのノードを交換\n            swap(i, p)\n            // ループで下から上へヒープ化\n            i = p\n        }\n    }\n\n    /* 要素をヒープから取り出す */\n    fun pop(): Int {\n        // 空判定の処理\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        swap(0, size() - 1)\n        // ノードを削除\n        val _val = maxHeap.removeAt(size() - 1)\n        // 上から下へヒープ化\n        siftDown(0)\n        // ヒープ先頭要素を返す\n        return _val\n    }\n\n    /* ノード i から始めて、上から下へヒープ化 */\n    private fun siftDown(it: Int) {\n        // Kotlin の関数引数は不変のため、一時変数を作成する\n        var i = it\n        while (true) {\n            // ノード i, l, r のうち値が最大のノードを ma とする\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n            if (ma == i) break\n            // 2 つのノードを交換\n            swap(i, ma)\n            // ループで上から下へヒープ化\n            i = ma\n        }\n    }\n\n    /* ヒープ（二分木）を出力 */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### コンストラクタ。入力リストに基づいてヒープを構築 ###\ndef initialize(nums)\n  # リスト要素をそのままヒープに追加\n  @max_heap = nums\n  # 葉ノード以外のすべてのノードをヒープ化\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   計算量の分析","text":"<p>以下では、2つ目のヒープ構築法の時間計算量を求めてみましょう。</p> <ul> <li>完全二分木のノード数を \\(n\\) とすると、葉ノード数は \\((n + 1) / 2\\) です。ここで \\(/\\) は切り捨て除算を表します。したがって、ヒープ化が必要なノード数は \\((n - 1) / 2\\) です。</li> <li>上から下へのヒープ化の過程では、各ノードは最大で葉ノードまでヒープ化されるため、最大反復回数は二分木の高さ \\(\\log n\\) です。</li> </ul> <p>上の2つを掛け合わせると、ヒープ構築過程の時間計算量は \\(O(n \\log n)\\) となります。しかし、この見積もりは正確ではありません。二分木では下層のノード数が上層よりはるかに多いという性質を考慮していないためです。</p> <p>次に、より正確な計算を行います。計算を簡単にするため、ノード数が \\(n\\) 、高さが \\(h\\) の「満二分木」を仮定します。この仮定は計算結果の正しさに影響しません。</p> <p></p> <p> 図 8-5   満二分木の各層のノード数 </p> <p>上図に示すように、ノードを「上から下へヒープ化」する最大反復回数は、そのノードから葉ノードまでの距離に等しく、この距離こそが「ノードの高さ」です。したがって、各層の「ノード数 \\(\\times\\) ノードの高さ」を合計すれば、**すべてのノードのヒープ化反復回数の総和**が得られます。</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>上式を簡約するには中学の数列の知識を用います。まず \\(T(h)\\) に \\(2\\) を掛けると、次のようになります。</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>ずらして引く方法を用い、下式の \\(2 T(h)\\) から上式の \\(T(h)\\) を引くと、次が得られます。</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>上式を見ると、\\(T(h)\\) は等比数列であることがわかるため、和の公式を直接用いて、時間計算量は次のように求められます。</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>さらに、高さ \\(h\\) の満二分木のノード数は \\(n = 2^{h+1} - 1\\) であるため、計算量は容易に \\(O(2^h) = O(n)\\) とわかります。以上の導出は、**入力リストからヒープを構築する時間計算量が \\(O(n)\\) であり、非常に効率的である**ことを示しています。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   ヒープ","text":"<p>ヒープ（heap）は、特定の条件を満たす完全二分木であり、主に次の 2 種類に分けられます。</p> <ul> <li>最小ヒープ（min heap）：任意のノードの値 \\(\\leq\\) その子ノードの値。</li> <li>最大ヒープ（max heap）：任意のノードの値 \\(\\geq\\) その子ノードの値。</li> </ul> <p></p> <p> 図 8-1   最小ヒープと最大ヒープ </p> <p>ヒープは完全二分木の特殊な例であり、次の性質を持ちます。</p> <ul> <li>最下層のノードは左から順に埋められ、ほかの層のノードはすべて埋まっています。</li> <li>二分木の根ノードを「ヒープ頂点」、最下層で最も右にあるノードを「ヒープ底」と呼びます。</li> <li>最大ヒープ（最小ヒープ）では、ヒープ頂点の要素（根ノード）の値が最大（最小）です。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   ヒープの基本操作","text":"<p>ここで注意したいのは、多くのプログラミング言語が提供しているのは優先度付きキュー（priority queue）であり、これは優先度順に並ぶキューとして定義される抽象データ構造だということです。</p> <p>実際には、ヒープは通常、優先度付きキューの実装に用いられ、最大ヒープは要素が大きい順に取り出される優先度付きキューに相当します。利用の観点では、「優先度付きキュー」と「ヒープ」は等価なデータ構造とみなせます。そのため、本書では両者を特に区別せず、まとめて「ヒープ」と呼びます。</p> <p>ヒープの基本操作を以下の表に示します。メソッド名はプログラミング言語によって異なります。</p> <p> 表 8-1   ヒープの操作効率 </p> メソッド名 説明 時間計算量 <code>push()</code> 要素をヒープに追加 \\(O(\\log n)\\) <code>pop()</code> ヒープ頂点の要素を取り出す \\(O(\\log n)\\) <code>peek()</code> ヒープ頂点の要素にアクセス（最大 / 最小ヒープではそれぞれ最大 / 最小値） \\(O(1)\\) <code>size()</code> ヒープ内の要素数を取得 \\(O(1)\\) <code>isEmpty()</code> ヒープが空かどうかを判定 \\(O(1)\\) <p>実際の応用では、プログラミング言語が提供するヒープクラス（または優先度付きキュークラス）をそのまま使えます。</p> <p>ソートアルゴリズムにおける「昇順」と「降順」と同様に、<code>flag</code> を設定したり <code>Comparator</code> を変更したりすることで、「最小ヒープ」と「最大ヒープ」を切り替えられます。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># 最小ヒープを初期化\nmin_heap, flag = [], 1\n# 最大ヒープを初期化\nmax_heap, flag = [], -1\n\n# Python の heapq モジュールはデフォルトで最小ヒープを実装している\n# 「要素を負にして」からヒープに追加すると、大小関係を反転させて最大ヒープを実現できる\n# この例では、flag = 1 のときは最小ヒープ、flag = -1 のときは最大ヒープに対応する\n\n# 要素をヒープに追加\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# ヒープ頂点の要素を取得\npeek: int = flag * max_heap[0] # 5\n\n# ヒープ頂点の要素を取り出す\n# 取り出された要素は大きい順の列になる\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# ヒープのサイズを取得\nsize: int = len(max_heap)\n\n# ヒープが空かどうかを判定\nis_empty: bool = not max_heap\n\n# 入力リストからヒープを構築\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// 最大ヒープを初期化\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* 要素をヒープに追加 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.top(); // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.size();\n\n/* ヒープが空かどうかを判定 */\nbool isEmpty = maxHeap.empty();\n\n/* 入力リストからヒープを構築 */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// 最大ヒープを初期化（lambda 式で Comparator を変更すればよい）\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* 要素をヒープに追加 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.peek(); // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.size();\n\n/* ヒープが空かどうかを判定 */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* 入力リストからヒープを構築 */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// 最大ヒープを初期化（lambda 式で Comparer を変更すればよい）\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* 要素をヒープに追加 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.Peek();//5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.Count;\n\n/* ヒープが空かどうかを判定 */\nbool isEmpty = maxHeap.Count == 0;\n\n/* 入力リストからヒープを構築 */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// Go では、heap.Interface を実装することで整数の最大ヒープを構築できる\n// heap.Interface を実装するには、同時に sort.Interface も実装する必要がある\ntype intHeap []any\n\n// Push は heap.Interface のメソッドで、要素をヒープに追加する\nfunc (h *intHeap) Push(x any) {\n    // Push と Pop は pointer receiver を引数に取る\n    // スライスの内容を調整するだけでなく、スライスの長さも変更するため。\n    *h = append(*h, x.(int))\n}\n\n// Pop は heap.Interface のメソッドで、ヒープ頂点の要素を取り出す\nfunc (h *intHeap) Pop() any {\n    // 取り出す要素は末尾に格納されている\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len は sort.Interface のメソッド\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less は sort.Interface のメソッド\nfunc (h *intHeap) Less(i, j int) bool {\n    // 最小ヒープを実装する場合は、不等号を小なりに変更する\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap は sort.Interface のメソッド\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top はヒープ頂点の要素を取得\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* ヒープを初期化 */\n    // 最大ヒープを初期化\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* 要素をヒープに追加 */\n    // heap.Interface のメソッドを呼び出して要素を追加する\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* ヒープ頂点の要素を取得 */\n    top := maxHeap.Top()\n    fmt.Printf(\"ヒープ頂点の要素は %d\\n\", top)\n\n    /* ヒープ頂点の要素を取り出す */\n    // heap.Interface のメソッドを呼び出して要素を削除する\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* ヒープのサイズを取得 */\n    size := len(*maxHeap)\n    fmt.Printf(\"ヒープ内の要素数は %d\\n\", size)\n\n    /* ヒープが空かどうかを判定 */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"ヒープは空か %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* ヒープを初期化 */\n// Swift の Heap 型は最大ヒープと最小ヒープの両方をサポートしており、swift-collections の導入が必要\nvar heap = Heap&lt;Int&gt;()\n\n/* 要素をヒープに追加 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* ヒープ頂点の要素を取得 */\nvar peek = heap.max()!\n\n/* ヒープ頂点の要素を取り出す */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* ヒープのサイズを取得 */\nlet size = heap.count\n\n/* ヒープが空かどうかを判定 */\nlet isEmpty = heap.isEmpty\n\n/* 入力リストからヒープを構築 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript には組み込みの Heap クラスがない\n</code></pre> heap.ts<pre><code>// TypeScript には組み込みの Heap クラスがない\n</code></pre> heap.dart<pre><code>// Dart には組み込みの Heap クラスがない\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* ヒープを初期化 */\n// 最小ヒープを初期化\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// 最大ヒープを初期化\nlet mut max_heap = BinaryHeap::new();\n\n/* 要素をヒープに追加 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* ヒープ頂点の要素を取得 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* ヒープのサイズを取得 */\nlet size = max_heap.len();\n\n/* ヒープが空かどうかを判定 */\nlet is_empty = max_heap.is_empty();\n\n/* 入力リストからヒープを構築 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C には組み込みの Heap クラスがない\n</code></pre> heap.kt<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// 最大ヒープを初期化（lambda 式で Comparator を変更すればよい）\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* 要素をヒープに追加 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* ヒープ頂点の要素を取得 */\nvar peek = maxHeap.peek() // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* ヒープのサイズを取得 */\nval size = maxHeap.size\n\n/* ヒープが空かどうかを判定 */\nval isEmpty = maxHeap.isEmpty()\n\n/* 入力リストからヒープを構築 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby には組み込みの Heap クラスがない\n</code></pre> 実行を可視化 <p>https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   ヒープの実装","text":"<p>以下では最大ヒープを実装します。最小ヒープに変換したい場合は、すべての大小比較ロジックを反転させるだけです（たとえば、\\(\\geq\\) を \\(\\leq\\) に置き換えます）。興味のある読者は自分で実装してみてください。</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   ヒープの格納と表現","text":"<p>「二分木」の章で述べたように、完全二分木は配列で表現するのに非常に適しています。ヒープはまさに完全二分木の一種なので、ここでは配列を使ってヒープを格納します。</p> <p>配列で二分木を表す場合、要素はノードの値を表し、インデックスは二分木におけるノードの位置を表します。ノード間の参照関係はインデックスの対応式によって実現できます。</p> <p>次の図に示すように、インデックス \\(i\\) に対して、左子ノードのインデックスは \\(2i + 1\\) 、右子ノードのインデックスは \\(2i + 2\\) 、親ノードのインデックスは \\((i - 1) / 2\\)（切り捨て除算）です。インデックスが範囲外であれば、空ノードまたはノードが存在しないことを表します。</p> <p></p> <p> 図 8-2   ヒープの表現と格納 </p> <p>インデックスの対応式は関数にまとめておくと、後続で使いやすくなります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"左子ノードのインデックスを取得\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"右子ノードのインデックスを取得\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"親ノードのインデックスを取得\"\"\"\n    return (i - 1) // 2  # 切り捨て除算\n</code></pre> my_heap.cpp<pre><code>/* 左子ノードのインデックスを取得 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.java<pre><code>/* 左子ノードのインデックスを取得 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.cs<pre><code>/* 左子ノードのインデックスを取得 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint Parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.go<pre><code>/* 左子ノードのインデックスを取得 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfunc (h *maxHeap) parent(i int) int {\n    // 切り捨て除算\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* 左子ノードのインデックスを取得 */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.js<pre><code>/* 左子ノードのインデックスを取得 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // 切り捨て除算\n}\n</code></pre> my_heap.ts<pre><code>/* 左子ノードのインデックスを取得 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // 切り捨て除算\n}\n</code></pre> my_heap.dart<pre><code>/* 左子ノードのインデックスを取得 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // 切り捨て除算\n}\n</code></pre> my_heap.rs<pre><code>/* 左子ノードのインデックスを取得 */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.c<pre><code>/* 左子ノードのインデックスを取得 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // 切り捨て\n}\n</code></pre> my_heap.kt<pre><code>/* 左子ノードのインデックスを取得 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.rb<pre><code>### 左子ノードのインデックスを取得 ###\ndef left(i)\n  2 * i + 1\nend\n\n### 右子ノードのインデックスを取得 ###\ndef right(i)\n  2 * i + 2\nend\n\n### 親ノードのインデックスを取得 ###\ndef parent(i)\n  (i - 1) / 2     # 切り捨て除算\nend\n</code></pre>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   ヒープ頂点の要素にアクセス","text":"<p>ヒープ頂点の要素は二分木の根ノード、すなわちリストの先頭要素です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"ヒープ先頭要素にアクセス\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* ヒープ先頭要素にアクセス */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* ヒープ先頭要素にアクセス */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* ヒープ先頭要素にアクセス */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* ヒープ先頭要素にアクセス */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* ヒープ先頭要素にアクセス */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* ヒープ先頭要素にアクセス */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* ヒープ先頭要素にアクセス */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* ヒープ先頭要素にアクセス */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### ヒープ先頭要素を参照 ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   要素をヒープに追加","text":"<p>与えられた要素 <code>val</code> を、まずヒープの底に追加します。追加後、<code>val</code> がヒープ内のほかの要素より大きい可能性があるため、ヒープ条件が崩れているかもしれません。そのため、挿入ノードから根ノードまでの経路上にある各ノードを修復する必要があります。この操作をヒープ化（heapify）と呼びます。</p> <p>ヒープへ追加したノードから始めて、**下から上へヒープ化**を行います。次の図のように、挿入ノードとその親ノードの値を比較し、挿入ノードのほうが大きければそれらを交換します。その後もこの操作を繰り返し、下から上へ各ノードを修復して、根ノードを越えるか交換不要のノードに達した時点で終了します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-3   要素をヒープに追加する手順 </p> <p>ノード総数を \\(n\\) とすると、木の高さは \\(O(\\log n)\\) です。したがって、ヒープ化操作のループ回数は高々 \\(O(\\log n)\\) であり、要素をヒープに追加する操作の時間計算量は \\(O(\\log n)\\) です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"要素をヒープに追加\"\"\"\n    # ノードを追加\n    self.max_heap.append(val)\n    # 下から上へヒープ化\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"ノード i から始めて、下から上へヒープ化\"\"\"\n    while True:\n        # ノード i の親ノードを取得\n        p = self.parent(i)\n        # 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # 2 つのノードを交換\n        self.swap(i, p)\n        # ループで下から上へヒープ化\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n    // ノードを追加\n    maxHeap.push_back(val);\n    // 下から上へヒープ化\n    siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 2 つのノードを交換\n        swap(maxHeap[i], maxHeap[p]);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n    // ノードを追加\n    maxHeap.add(val);\n    // 下から上へヒープ化\n    siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // 2 つのノードを交換\n        swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 要素をヒープに追加 */\nvoid Push(int val) {\n    // ノードを追加\n    maxHeap.Add(val);\n    // 下から上へヒープ化\n    SiftUp(Size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid SiftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = Parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」な場合は、ヒープ化を終了する\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 2 つのノードを交換\n        Swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 要素をヒープに追加 */\nfunc (h *maxHeap) push(val any) {\n    // ノードを追加\n    h.data = append(h.data, val)\n    // 下から上へヒープ化\n    h.siftUp(len(h.data) - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // ノード i の親ノードを取得\n        p := h.parent(i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // 2 つのノードを交換\n        h.swap(i, p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 要素をヒープに追加 */\nfunc push(val: Int) {\n    // ノードを追加\n    maxHeap.append(val)\n    // 下から上へヒープ化\n    siftUp(i: size() - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // ノード i の親ノードを取得\n        let p = parent(i: i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // 2 つのノードを交換\n        swap(i: i, j: p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 要素をヒープに追加 */\npush(val) {\n    // ノードを追加\n    this.#maxHeap.push(val);\n    // 下から上へヒープ化\n    this.#siftUp(this.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\n#siftUp(i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        const p = this.#parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // 2 つのノードを交換\n        this.#swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 要素をヒープに追加 */\npush(val: number): void {\n    // ノードを追加\n    this.maxHeap.push(val);\n    // 下から上へヒープ化\n    this.siftUp(this.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nsiftUp(i: number): void {\n    while (true) {\n        // ノード i の親ノードを取得\n        const p = this.parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // 2 つのノードを交換\n        this.swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n  // ノードを追加\n  _maxHeap.add(val);\n  // 下から上へヒープ化\n  siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n  while (true) {\n    // ノード i の親ノードを取得\n    int p = _parent(i);\n    // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // 2 つのノードを交換\n    _swap(i, p);\n    // ループで下から上へヒープ化\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 要素をヒープに追加 */\nfn push(&amp;mut self, val: i32) {\n    // ノードを追加\n    self.max_heap.push(val);\n    // 下から上へヒープ化\n    self.sift_up(self.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // ノード i はすでにヒープの先頭ノードなので、ヒープ化を終了する\n        if i == 0 {\n            break;\n        }\n        // ノード i の親ノードを取得\n        let p = Self::parent(i);\n        // 「ノードの修復が不要」になったら、ヒープ化を終了\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // 2 つのノードを交換\n        self.swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 要素をヒープに追加 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // 通常は、これほど多くのノードを追加すべきではない\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // ノードを追加\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // 下から上へヒープ化\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(maxHeap, i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(maxHeap, i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 要素をヒープに追加 */\nfun push(_val: Int) {\n    // ノードを追加\n    maxHeap.add(_val)\n    // 下から上へヒープ化\n    siftUp(size() - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfun siftUp(it: Int) {\n    // Kotlin の関数引数は不変のため、一時変数を作成する\n    var i = it\n    while (true) {\n        // ノード i の親ノードを取得\n        val p = parent(i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // 2 つのノードを交換\n        swap(i, p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 要素をヒープに挿入 ###\ndef push(val)\n  # ノードを追加\n  @max_heap &lt;&lt; val\n  # 下から上へヒープ化\n  sift_up(size - 1)\nend\n\n### ノード i から下から上へヒープ化 ###\ndef sift_up(i)\n  loop do\n    # ノード i の親ノードを取得\n    p = parent(i)\n    # 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # 2 つのノードを交換\n    swap(i, p)\n    # ループで下から上へヒープ化\n    i = p\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   ヒープ頂点の要素を取り出す","text":"<p>ヒープ頂点の要素は二分木の根ノード、すなわちリストの先頭要素です。もし先頭要素をそのまま削除すると、二分木内のすべてのノードのインデックスが変化してしまい、その後のヒープ化による修復が困難になります。要素インデックスの変動をできるだけ小さくするため、次の手順を取ります。</p> <ol> <li>ヒープ頂点の要素とヒープ底の要素を交換する（根ノードと最も右の葉ノードを交換する）。</li> <li>交換後、ヒープ底をリストから削除する（すでに交換済みであるため、実際に削除されるのは元のヒープ頂点の要素であることに注意）。</li> <li>根ノードから開始し、**上から下へヒープ化**を行う。</li> </ol> <p>次の図のように、**「上から下へのヒープ化」の方向は「下から上へのヒープ化」と逆**です。根ノードの値を 2 つの子ノードと比較し、最大の子ノードと根ノードを交換します。その後、この操作を繰り返し、葉ノードを越えるか交換不要のノードに達した時点で終了します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-4   ヒープ頂点の要素を取り出す手順 </p> <p>要素をヒープに追加する操作と同様に、ヒープ頂点の要素を取り出す操作の時間計算量も \\(O(\\log n)\\) です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"要素をヒープから取り出す\"\"\"\n    # 空判定の処理\n    if self.is_empty():\n        raise IndexError(\"ヒープが空です\")\n    # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    self.swap(0, self.size() - 1)\n    # ノードを削除\n    val = self.max_heap.pop()\n    # 上から下へヒープ化\n    self.sift_down(0)\n    # ヒープ先頭要素を返す\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"ノード i から始めて、上から下へヒープ化\"\"\"\n    while True:\n        # ノード i, l, r のうち値が最大のノードを ma とする\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i:\n            break\n        # 2 つのノードを交換\n        self.swap(i, ma)\n        # ループで上から下へヒープ化\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* 要素をヒープから取り出す */\nvoid pop() {\n    // 空判定の処理\n    if (isEmpty()) {\n        throw out_of_range(\"ヒープが空です\");\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // ノードを削除\n    maxHeap.pop_back();\n    // 上から下へヒープ化\n    siftDown(0);\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 要素をヒープから取り出す */\nint pop() {\n    // 空判定の処理\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(0, size() - 1);\n    // ノードを削除\n    int val = maxHeap.remove(size() - 1);\n    // 上から下へヒープ化\n    siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 要素をヒープから取り出す */\nint Pop() {\n    // 空判定の処理\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    Swap(0, Size() - 1);\n    // ノードを削除\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // 上から下へヒープ化\n    SiftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid SiftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 「ノード i が最大」または「葉ノードを越えた」場合は、ヒープ化を終了する\n        if (ma == i) break;\n        // 2 つのノードを交換\n        Swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 要素をヒープから取り出す */\nfunc (h *maxHeap) pop() any {\n    // 空判定の処理\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    h.swap(0, h.size()-1)\n    // ノードを削除\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // 上から下へヒープ化\n    h.siftDown(0)\n\n    // ヒープ先頭要素を返す\n    return val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // ノード i, l, r のうち値が最大のノードを max とする\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if max == i {\n            break\n        }\n        // 2 つのノードを交換\n        h.swap(i, max)\n        // ループで上から下へヒープ化\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 要素をヒープから取り出す */\nfunc pop() -&gt; Int {\n    // 空判定の処理\n    if isEmpty() {\n        fatalError(\"ヒープが空です\")\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(i: 0, j: size() - 1)\n    // ノードを削除\n    let val = maxHeap.remove(at: size() - 1)\n    // 上から下へヒープ化\n    siftDown(i: 0)\n    // ヒープ先頭要素を返す\n    return val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        swap(i: i, j: ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 要素をヒープから取り出す */\npop() {\n    // 空判定の処理\n    if (this.isEmpty()) throw new Error('ヒープが空です');\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    this.#swap(0, this.size() - 1);\n    // ノードを削除\n    const val = this.#maxHeap.pop();\n    // 上から下へヒープ化\n    this.#siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\n#siftDown(i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) break;\n        // 2 つのノードを交換\n        this.#swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 要素をヒープから取り出す */\npop(): number {\n    // 空判定の処理\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    this.swap(0, this.size() - 1);\n    // ノードを削除\n    const val = this.maxHeap.pop();\n    // 上から下へヒープ化\n    this.siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nsiftDown(i: number): void {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) break;\n        // 2 つのノードを交換\n        this.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 要素をヒープから取り出す */\nint pop() {\n  // 空判定の処理\n  if (isEmpty()) throw Exception('ヒープが空です');\n  // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n  _swap(0, size() - 1);\n  // ノードを削除\n  int val = _maxHeap.removeLast();\n  // 上から下へヒープ化\n  siftDown(0);\n  // ヒープ先頭要素を返す\n  return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n  while (true) {\n    // ノード i, l, r のうち値が最大のノードを ma とする\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    if (ma == i) break;\n    // 2 つのノードを交換\n    _swap(i, ma);\n    // ループで上から下へヒープ化\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 要素をヒープから取り出す */\nfn pop(&amp;mut self) -&gt; i32 {\n    // 空判定の処理\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    self.swap(0, self.size() - 1);\n    // ノードを削除\n    let val = self.max_heap.pop().unwrap();\n    // 上から下へヒープ化\n    self.sift_down(0);\n    // ヒープ先頭要素を返す\n    val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break;\n        }\n        // 2 つのノードを交換\n        self.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 要素をヒープから取り出す */\nint pop(MaxHeap *maxHeap) {\n    // 空判定の処理\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // ノードを削除\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // 上から下へヒープ化\n    siftDown(maxHeap, 0);\n\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを max とする\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (max == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(maxHeap, i, max);\n        // ループで上から下へヒープ化\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 要素をヒープから取り出す */\nfun pop(): Int {\n    // 空判定の処理\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(0, size() - 1)\n    // ノードを削除\n    val _val = maxHeap.removeAt(size() - 1)\n    // 上から下へヒープ化\n    siftDown(0)\n    // ヒープ先頭要素を返す\n    return _val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfun siftDown(it: Int) {\n    // Kotlin の関数引数は不変のため、一時変数を作成する\n    var i = it\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) break\n        // 2 つのノードを交換\n        swap(i, ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 要素をヒープから取り出す ###\ndef pop\n  # 空判定の処理\n  raise IndexError, \"ヒープが空です\" if is_empty?\n  # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n  swap(0, size - 1)\n  # ノードを削除\n  val = @max_heap.pop\n  # 上から下へヒープ化\n  sift_down(0)\n  # ヒープ先頭要素を返す\n  val\nend\n\n### ノード i から上から下へヒープ化 ###\ndef sift_down(i)\n  loop do\n    # ノード i, l, r のうち値が最大のノードを ma とする\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    break if ma == i\n\n    # 2 つのノードを交換\n    swap(i, ma)\n    # ループで上から下へヒープ化\n    i = ma\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   ヒープの代表的な応用","text":"<ul> <li>優先度付きキュー：ヒープは、優先度付きキューを実装するための代表的なデータ構造です。キューへの追加と取り出しの時間計算量はいずれも \\(O(\\log n)\\) で、ヒープ構築は \\(O(n)\\) であり、これらの操作はいずれも非常に効率的です。</li> <li>ヒープソート：与えられたデータ群からヒープを構築し、要素の取り出しを繰り返すことで整列済みデータを得られます。ただし、通常はより洗練された方法でヒープソートを実装します。詳しくは「ヒープソート」の章を参照してください。</li> <li>最大の \\(k\\) 個の要素を取得：これは古典的なアルゴリズム問題であると同時に、典型的な応用でもあります。たとえば、人気上位 10 件のニュースをホットトピックとして選んだり、売上上位 10 件の商品を選んだりする場面です。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   まとめ","text":"","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>ヒープは完全二分木であり、条件の違いによって最大ヒープと最小ヒープに分けられる。最大（最小）ヒープの根の要素は最大値（最小値）である。</li> <li>優先度付きキューとは、取り出し時に優先度が考慮されるキューであり、通常はヒープを用いて実装される。</li> <li>ヒープの代表的な操作とそれに対応する時間計算量には、要素の挿入 \\(O(\\log n)\\)、根の要素の削除 \\(O(\\log n)\\)、根の要素へのアクセス \\(O(1)\\) などがある。</li> <li>完全二分木は配列で表現するのに非常に適しているため、通常は配列を使ってヒープを格納する。</li> <li>ヒープ化操作はヒープの性質を保つために用いられ、挿入操作と削除操作の両方で使用される。</li> <li>\\(n\\) 個の要素を入力してヒープを構築する時間計算量は \\(O(n)\\) まで最適化でき、非常に効率的である。</li> <li>Top-k は古典的なアルゴリズム問題であり、ヒープ構造を用いることで効率的に解くことができ、時間計算量は \\(O(n \\log k)\\) である。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：データ構造の「ヒープ」とメモリ管理の「ヒープ」は同じ概念ですか？</p> <p>両者は同じ概念ではなく、たまたまどちらも「ヒープ」と呼ばれているだけである。コンピュータシステムのメモリにおけるヒープは動的メモリ割り当ての一部であり、プログラムは実行時にこれを使ってデータを格納できる。プログラムは一定量のヒープメモリを要求し、オブジェクトや配列などの複雑な構造を保存できる。これらのデータが不要になったときは、メモリリークを防ぐためにそのメモリを解放する必要がある。スタックメモリと比べると、ヒープメモリの管理と使用にはより慎重さが求められ、不適切に扱うとメモリリークやダングリングポインタなどの問題を引き起こす可能性がある。</p>","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-k 問題","text":"<p>Question</p> <p>長さ \\(n\\) の未整列配列 <code>nums</code> が与えられたとき、配列内で最大の \\(k\\) 個の要素を返してください。</p> <p>この問題について、まずは発想が比較的直接的な 2 つの解法を紹介し、その後でより効率の高いヒープ解法を紹介します。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#831","level":2,"title":"8.3.1   方法一：走査による選択","text":"<p>以下の図に示すように \\(k\\) 回の走査を行い、各ラウンドでそれぞれ第 \\(1\\)、\\(2\\)、\\(\\dots\\)、\\(k\\) 位の要素を取り出すことができます。時間計算量は \\(O(nk)\\) です。</p> <p>この方法は \\(k \\ll n\\) の場合にしか適していません。\\(k\\) が \\(n\\) にかなり近いと、時間計算量は \\(O(n^2)\\) に近づき、非常に時間がかかるためです。</p> <p></p> <p> 図 8-6   走査によって最大の k 個の要素を探す </p> <p>Tip</p> <p>\\(k = n\\) のとき、完全な昇順列を得ることができ、この場合は「選択ソート」アルゴリズムと等価になります。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#832","level":2,"title":"8.3.2   方法二：ソート","text":"<p>以下の図に示すように、まず配列 <code>nums</code> をソートし、その後で右端の \\(k\\) 個の要素を返すことができます。時間計算量は \\(O(n \\log n)\\) です。</p> <p>明らかに、この方法は必要以上の処理を行っています。なぜなら、必要なのは最大の \\(k\\) 個の要素を見つけることだけであり、他の要素をソートする必要はないからです。</p> <p></p> <p> 図 8-7   ソートによって最大の k 個の要素を探す </p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#833","level":2,"title":"8.3.3   方法三：ヒープ","text":"<p>ヒープを用いることで、Top-k 問題をより効率的に解くことができます。手順は以下の図のとおりです。</p> <ol> <li>最小ヒープを初期化し、そのヒープ頂点の要素が最小となるようにします。</li> <li>まず配列の先頭 \\(k\\) 個の要素を順にヒープへ挿入します。</li> <li>\\(k + 1\\) 番目の要素から開始し、現在の要素がヒープ頂点の要素より大きければ、ヒープ頂点の要素を取り出し、現在の要素をヒープへ挿入します。</li> <li>走査が完了した後、ヒープに保持されているのが最大の \\(k\\) 個の要素です。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-8   ヒープに基づいて最大の k 個の要素を探す </p> <p>サンプルコードは以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"ヒープに基づいて配列中の最大の k 個の要素を探す\"\"\"\n    # 最小ヒープを初期化\n    heap = []\n    # 配列の先頭 k 個の要素をヒープに追加\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i in range(k, len(nums)):\n        # 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // 最小ヒープを初期化\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.size(); i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // 最小ヒープを初期化\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // 最小ヒープを初期化\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.Length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // 最小ヒープを初期化\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // 配列の先頭 k 個の要素をヒープに追加\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i := k; i &lt; len(nums); i++ {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // 最小ヒープを初期化し、先頭 k 個の要素でヒープを構築する\n    var heap = Heap(nums.prefix(k))\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i in nums.indices.dropFirst(k) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* 要素をヒープに追加 */\nfunction pushMinHeap(maxHeap, val) {\n    // 要素を反転する\n    maxHeap.push(-val);\n}\n\n/* 要素をヒープから取り出す */\nfunction popMinHeap(maxHeap) {\n    // 要素を反転する\n    return -maxHeap.pop();\n}\n\n/* ヒープ先頭要素にアクセス */\nfunction peekMinHeap(maxHeap) {\n    // 要素を反転する\n    return -maxHeap.peek();\n}\n\n/* ヒープから要素を取り出す */\nfunction getMinHeap(maxHeap) {\n    // 要素を反転する\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunction topKHeap(nums, k) {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    const maxHeap = new MaxHeap([]);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (let i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // ヒープ内の要素を返す\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* 要素をヒープに追加 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // 要素を反転する\n    maxHeap.push(-val);\n}\n\n/* 要素をヒープから取り出す */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // 要素を反転する\n    return -maxHeap.pop();\n}\n\n/* ヒープ先頭要素にアクセス */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // 要素を反転する\n    return -maxHeap.peek();\n}\n\n/* ヒープから要素を取り出す */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // 要素を反転する\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    const maxHeap = new MaxHeap([]);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (let i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // ヒープ内の要素を返す\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // 最小ヒープを初期化し、配列の先頭 k 個の要素をヒープに入れる\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // k+1 番目の要素から開始し、ヒープ長を k に保つ\n  for (int i = k; i &lt; nums.length; i++) {\n    // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap は最大ヒープであり、Reverse で要素の順序を反転することで最小ヒープを実現する\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for &amp;num in nums.iter().skip(k) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* 要素をヒープに追加 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // 要素を反転する\n    push(maxHeap, -val);\n}\n\n/* 要素をヒープから取り出す */\nint popMinHeap(MaxHeap *maxHeap) {\n    // 要素を反転する\n    return -pop(maxHeap);\n}\n\n/* ヒープ先頭要素にアクセス */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // 要素を反転する\n    return -peek(maxHeap);\n}\n\n/* ヒープから要素を取り出す */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // ヒープ内のすべての要素を反転して res 配列に格納\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* ヒープから要素を取り出す */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // ヒープ内のすべての要素を反転して res 配列に格納\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// ヒープに基づいて配列中の最大の k 個の要素を求める関数\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; sizeNums; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // メモリを解放する\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // 最小ヒープを初期化\n    val heap = PriorityQueue&lt;Int&gt;()\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (i in k..&lt;nums.size) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### ヒープに基づいて配列中の最大 k 個の要素を探す ###\ndef top_k_heap(nums, k)\n  # 最小ヒープを初期化する\n  # 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n  max_heap = MaxHeap.new([])\n\n  # 配列の先頭 k 個の要素をヒープに追加\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # k+1 番目の要素から開始し、ヒープ長を k に保つ\n  for i in k...nums.length\n    # 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>合計で \\(n\\) 回のヒープ挿入と取り出しを行い、ヒープの最大長は \\(k\\) であるため、時間計算量は \\(O(n \\log k)\\) です。この方法は非常に効率が高く、\\(k\\) が小さいときは時間計算量が \\(O(n)\\) に近づき、\\(k\\) が大きいときでも \\(O(n \\log n)\\) を超えることはありません。</p> <p>さらに、この方法は動的データストリームの利用シーンにも適しています。データが継続的に追加される場合でも、ヒープ内の要素を保ち続けることで、最大の \\(k\\) 個の要素を動的に更新できます。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"はじめに","text":"<p>数年前、私は LeetCode 中国版で「剣指 Offer」シリーズの解説を共有し、多くの読者から励ましと支持をいただきました。読者との交流の中で、最もよく聞かれた質問の一つが「アルゴリズムをどう学び始めればよいか」でした。次第に、私はこの問題に強い関心を抱くようになりました。</p> <p>手探りでひたすら問題を解くことは、最も人気のある方法のようです。単純で、直接的で、しかも効果的です。しかし問題演習は「マインスイーパー」を遊ぶことに似ており、独学力の高い人は地雷を一つずつうまく取り除ける一方で、基礎が十分でない人は大きな痛手を受け、挫折の中で少しずつ後退してしまいがちです。教材を通読するのもよくある方法ですが、就職を目指す人にとっては、卒業論文、履歴書の提出、筆記試験や面接の準備ですでに大半の力を使い果たしており、分厚い本を読み込むことはしばしば困難な挑戦になってしまいます。</p> <p>もしあなたも同じような悩みを抱えているなら、この本があなたのもとに“たどり着いた”のは幸運なことです。本書は、この問いに対して私が示す答えです。たとえ最良の解ではなくても、少なくとも前向きな試みではあります。本書だけで直接内定を得られるわけではありませんが、データ構造とアルゴリズムの「知識地図」を探る手助けをし、さまざまな「地雷」の形や大きさ、分布を理解し、いろいろな「地雷除去の方法」を身につけられるよう導きます。こうした力があれば、問題演習や文献読解をより自在に進め、やがて完整な知識体系を築いていけると信じています。</p> <p>私はファインマン教授の言葉に深く賛同しています。「Knowledge isn't free. You have to pay attention.」この意味において、本書は完全に「無料」ではありません。本書のためにあなたが払ってくれる貴重な「注意」に応えるため、私はできる限りの力を尽くし、最大限の「注意」を注いで本書を書き上げます。</p> <p>私は自らの学識と力量の浅さをよく承知しています。本書の内容はある程度磨きをかけてきたものの、なお多くの誤りが残っているはずです。先生方、そして学習者の皆さまからのご批判とご指摘を心よりお願いいたします。</p> <p></p> Hello、アルゴリズム！ <p>コンピュータの登場は世界に大きな変革をもたらしました。高速な計算能力と優れたプログラム可能性によって、アルゴリズムの実行とデータ処理の理想的な媒体となったのです。ビデオゲームのリアルな映像、自動運転の知的な意思決定、AlphaGo の見事な対局、ChatGPT の自然な対話に至るまで、これらの応用はいずれもコンピュータ上でアルゴリズムが巧みに表現されたものです。</p> <p>実際には、コンピュータが誕生する以前から、アルゴリズムとデータ構造は世界のいたるところに存在していました。初期のアルゴリズムは比較的単純で、たとえば古代の数え方や道具作りの手順などがそれに当たります。文明の進歩とともに、アルゴリズムは次第により精緻で複雑なものになっていきました。匠の巧みな技から、生産力を解放する工業製品、さらには宇宙の運行を支配する科学法則に至るまで、ほとんどあらゆる平凡なもの、あるいは驚嘆すべきものの背後には、精妙なアルゴリズムの思想が潜んでいます。</p> <p>同様に、データ構造も至るところに存在します。社会ネットワークのような大きなものから地下鉄路線のような小さなものまで、多くのシステムは「グラフ」としてモデル化できます。国家のような大きな単位から家庭のような小さな単位まで、社会の主な組織形態には「木」の特徴があります。冬服は「スタック」のように、最初に着たものが最後に脱がれます。バドミントンシャトルの筒は「キュー」のように、一方から入れて他方から取り出します。辞書は「ハッシュテーブル」のようなもので、目的の見出し語を素早く探せます。</p> <p>本書は、わかりやすいアニメーション図解と実行可能なコード例を通じて、読者がアルゴリズムとデータ構造の核心概念を理解し、さらにプログラミングによってそれらを実装できるようになることを目指しています。そのうえで、本書は複雑な世界の中にあるアルゴリズムの生き生きとした現れを明らかにし、アルゴリズムの美しさを示そうとしています。本書があなたの助けになれば幸いです。</p>","path":["はじめに"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"第 1 章   アルゴリズム入門","text":"<p>Abstract</p> <p>一人の少女が軽やかに舞い、データと織り重なり合いながら、スカートの裾にはアルゴリズムの旋律がたなびいています。</p> <p>彼女はあなたをこの舞いへと誘います。その足取りに続いて、論理と美しさに満ちたアルゴリズムの世界へ踏み入りましょう。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","第 1 章 &nbsp; アルゴリズム入門"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"章の内容","text":"<ul> <li>1.1   アルゴリズムは至るところにある</li> <li>1.2   アルゴリズムとは</li> <li>1.3   まとめ</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","第 1 章 &nbsp; アルゴリズム入門"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   アルゴリズムは至るところにある","text":"<p>「アルゴリズム」という言葉を聞くと、自然に数学を思い浮かべます。しかし実際には、多くのアルゴリズムは複雑な数学を必要とせず、むしろ基本的な論理に依存しており、その論理は私たちの日常生活のいたるところで見られます。</p> <p>アルゴリズムを本格的に議論する前に、ひとつ面白い事実を共有しておきます。あなたはすでに知らず知らずのうちに多くのアルゴリズムを身につけ、それらを日常生活に応用することに慣れているのです。以下では、いくつかの具体例を挙げてこれを示します。</p> <p>例1：辞書を引く。辞書では、各漢字に対応するピンインがあり、辞書はピンインのアルファベット順に並んでいます。ピンインの先頭文字が \\(r\\) の字を探すと仮定すると、通常は次の図のような方法で行います。</p> <ol> <li>辞書をおよそ半分のところまで開き、そのページの先頭文字を確認し、先頭文字が \\(m\\) だとします。</li> <li>ピンインのアルファベット表では \\(r\\) は \\(m\\) の後にあるため、辞書の前半を除外し、探索範囲を後半に絞ります。</li> <li>ピンインの先頭文字が \\(r\\) のページを見つけるまで、手順 <code>1.</code> と手順 <code>2.</code> を繰り返します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 1-1   辞書を引く手順 </p> <p>辞書を引くという小学生の必須スキルは、実は有名な「二分探索」アルゴリズムそのものです。データ構造の観点では、辞書を整列済みの「配列」とみなせます。アルゴリズムの観点では、上記の一連の辞書引きの操作を「二分探索」とみなせます。</p> <p>例2：トランプを整理する。カードゲームをするとき、毎回手札のトランプを小さい順に並べ替える必要があります。その流れは次の図のとおりです。</p> <ol> <li>トランプを「整列済み」と「未整列」の2つの部分に分け、初期状態では一番左の1枚がすでに整列済みだとします。</li> <li>未整列部分から1枚のトランプを取り出し、整列済み部分の正しい位置に挿入します。完了すると、左端の2枚は整列済みになります。</li> <li>手順 <code>2.</code> を繰り返し、各ラウンドで未整列部分から1枚を整列済み部分へ挿入し、すべてのトランプが整列済みになるまで続けます。</li> </ol> <p></p> <p> 図 1-2   トランプを並べ替える手順 </p> <p>上記のトランプ整理の方法は、本質的には「挿入ソート」アルゴリズムです。これは小規模なデータ集合を処理する際に非常に効率的で、多くのプログラミング言語のソートライブラリ関数にも挿入ソートが使われています。</p> <p>例3：お釣りを出す。スーパーで \\(69\\) 元の商品を購入し、店員に \\(100\\) 元渡したとすると、店員は \\(31\\) 元のお釣りを返す必要があります。店員は自然に次の図のような考え方をします。</p> <ol> <li>選択肢は \\(31\\) 元より小さい額面の貨幣で、\\(1\\) 元、\\(5\\) 元、\\(10\\) 元、\\(20\\) 元があります。</li> <li>選択肢の中から最大の \\(20\\) 元を取り出すと、残りは \\(31 - 20 = 11\\) 元です。</li> <li>残りの選択肢の中から最大の \\(10\\) 元を取り出すと、残りは \\(11 - 10 = 1\\) 元です。</li> <li>残りの選択肢の中から最大の \\(1\\) 元を取り出すと、残りは \\(1 - 1 = 0\\) 元です。</li> <li>お釣りは完了し、内訳は \\(20 + 10 + 1 = 31\\) 元です。</li> </ol> <p></p> <p> 図 1-3   お釣りの過程 </p> <p>以上の手順では、各ステップでその時点で最善と思われる選択肢を取っています。つまり、できるだけ額面の大きい貨幣を使い、最終的に実行可能なお釣りの方案を得ています。データ構造とアルゴリズムの観点から見ると、この方法は本質的に「貪欲法」です。</p> <p>料理を一品作ることから星間航行に至るまで、ほとんどあらゆる問題の解決にアルゴリズムは欠かせません。コンピュータの登場によって、プログラミングを通じてデータ構造をメモリに格納し、さらにコードを書いて CPU や GPU にアルゴリズムを実行させることが可能になりました。こうして、生活の中の問題をコンピュータに移し、より効率的な方法でさまざまな複雑な問題を解決できるのです。</p> <p>Tip</p> <p>データ構造、アルゴリズム、配列、二分探索といった概念がまだ少し曖昧でも、そのまま読み進めてください。本書がデータ構造とアルゴリズムの知識の世界へと案内します。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.1 &nbsp; アルゴリズムは至るところにある"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   まとめ","text":"","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>アルゴリズムは日常生活の至る所にあり、決して手の届かない難解な知識ではありません。実際、私たちは気づかないうちに多くのアルゴリズムを身につけ、生活のさまざまな問題を解決しています。</li> <li>辞書を引く原理は二分探索アルゴリズムと一致しています。二分探索アルゴリズムは分割統治という重要なアルゴリズム思想を体現しています。</li> <li>トランプを整理する過程は挿入ソートアルゴリズムと非常によく似ています。挿入ソートアルゴリズムは小規模なデータ集合のソートに適しています。</li> <li>貨幣の釣り銭を求める手順の本質は貪欲アルゴリズムであり、各ステップでその時点で最善と思われる選択を取ります。</li> <li>アルゴリズムとは、限られた時間内に特定の問題を解決するための一連の命令または操作手順であり、データ構造とは、コンピュータ内でデータを組織し保存する方法です。</li> <li>データ構造とアルゴリズムは密接に結びついています。データ構造はアルゴリズムの土台であり、アルゴリズムはデータ構造に生命を吹き込みます。</li> <li>データ構造とアルゴリズムは積み木の組み立てにたとえることができます。積み木はデータを表し、積み木の形や接続方法などはデータ構造を表し、積み木を組み立てる手順がアルゴリズムに対応します。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：プログラマーとして、私は日常業務でアルゴリズムを使って問題を解決したことがありません。よく使うアルゴリズムはプログラミング言語にすべてカプセル化されており、そのまま使えばよいです。これは、仕事上の問題がまだアルゴリズムを必要とする段階に達していないことを意味するのでしょうか？</p> <p>具体的な仕事のスキルを武術の「型」にたとえるなら、基礎科目はむしろ「内功」に近いものです。</p> <p>私は、アルゴリズム（およびその他の基礎科目）を学ぶ意義は、仕事でそれをゼロから実装することではなく、学んだ知識に基づいて問題解決の際に専門的な反応や判断を下せるようになり、その結果として仕事全体の品質を高めることにあると考えています。簡単な例を挙げると、どのプログラミング言語にもソート関数が組み込まれています。</p> <ul> <li>もしデータ構造とアルゴリズムを学んでいなければ、どんなデータが与えられても、そのソート関数に任せてしまうかもしれません。問題なく動き、性能も悪くなく、一見すると特に問題はありません。</li> <li>しかしアルゴリズムを学んでいれば、組み込みのソート関数の時間計算量が \\(O(n \\log n)\\) であることを知っています。さらに、与えられたデータが固定桁数の整数（例えば学籍番号）であれば、より効率の高い「基数ソート」を使って、時間計算量を \\(O(nk)\\) に下げることができます。ここで \\(k\\) は桁数です。データ量が非常に大きい場合、節約できた実行時間は大きな価値を生みます（コスト削減、体験向上など）。</li> </ul> <p>工学分野では、多くの問題で最適解に到達することは難しく、少なくない問題は「だいたい」解決されているにすぎません。問題の難しさは、一方では問題そのものの性質に依存し、他方ではそれを観測する人の知識の蓄積にも依存します。知識が充実し、経験が豊富であるほど、問題分析はより深くなり、問題はより洗練された形で解決できるようになります。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   アルゴリズムとは","text":"","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   アルゴリズムの定義","text":"<p>アルゴリズム（algorithm）とは、限られた時間内に特定の問題を解決するための一連の命令または操作手順であり、次のような特徴を持ちます。</p> <ul> <li>問題が明確であり、入力と出力の定義がはっきりしています。</li> <li>実行可能であり、有限の手順、時間、メモリ空間で完了できます。</li> <li>各手順の意味が確定しており、同じ入力と実行条件では常に同じ出力になります。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   データ構造の定義","text":"<p>データ構造（data structure）とは、データを整理して保存する方式であり、データの内容、データ間の関係、データの操作方法を含み、次のような設計目標があります。</p> <ul> <li>使用する空間をできるだけ少なくし、コンピュータのメモリを節約します。</li> <li>データの操作をできるだけ高速にし、アクセス、追加、削除、更新などを含みます。</li> <li>簡潔なデータ表現と論理情報を提供し、アルゴリズムが効率よく動作できるようにします。</li> </ul> <p>データ構造の設計はトレードオフに満ちた過程です。ある面を改善したい場合、別の面で妥協が必要になることがよくあります。以下に 2 つの例を示します。</p> <ul> <li>連結リストは配列に比べてデータの追加や削除がしやすい一方で、データアクセス速度を犠牲にしています。</li> <li>グラフは連結リストに比べてより豊富な論理情報を提供しますが、より大きなメモリ空間を必要とします。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   データ構造とアルゴリズムの関係","text":"<p>以下の図のように、データ構造とアルゴリズムは高度に関連し、密接に結び付いており、具体的には次の 3 つの点に表れます。</p> <ul> <li>データ構造はアルゴリズムの土台です。データ構造はアルゴリズムに対して、構造化して格納されたデータと、そのデータを操作する方法を提供します。</li> <li>アルゴリズムはデータ構造に命を吹き込みます。データ構造そのものはデータ情報を保存するだけであり、アルゴリズムと組み合わせて初めて特定の問題を解決できます。</li> <li>アルゴリズムは通常、異なるデータ構造に基づいて実装できますが、実行効率が大きく異なる場合があり、適切なデータ構造を選ぶことが重要です。</li> </ul> <p></p> <p> 図 1-4   データ構造とアルゴリズムの関係 </p> <p>データ構造とアルゴリズムは、以下の図に示す組み立てブロックのようなものです。1 セットのブロックには多くの部品が含まれるだけでなく、詳しい組み立て説明書も付いています。説明書に従って一歩ずつ操作すれば、精巧なブロック模型を組み立てられます。</p> <p></p> <p> 図 1-5   組み立てブロック </p> <p>両者の詳細な対応関係を次の表に示します。</p> <p> 表 1-1   データ構造とアルゴリズムを組み立てブロックにたとえる </p> データ構造とアルゴリズム 組み立てブロック 入力データ まだ組み立てていないブロック データ構造 ブロックの構成形式。形状、大きさ、接続方法などを含む アルゴリズム ブロックを目標の形に組み上げる一連の操作手順 出力データ ブロック模型 <p>特筆すべき点として、データ構造とアルゴリズムはプログラミング言語から独立しています。だからこそ、本書では複数のプログラミング言語に基づく実装を提供できます。</p> <p>慣習的な略称</p> <p>実際の議論では、私たちは通常「データ構造とアルゴリズム」を略して「アルゴリズム」と呼びます。たとえば広く知られている LeetCode のアルゴリズム問題は、実際にはデータ構造とアルゴリズムの両方の知識を同時に問うています。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_paperbook/","level":1,"title":"紙の書籍","text":"<p>長い時間をかけて磨き上げた『Hello アルゴリズム』の紙の書籍が、ついに発売されました！今の気持ちは、次の一節で表せます：</p> <p>風を追い月を追って立ち止まるな、草原の果てには春の山がある。</p> <p></p> <p>以下の動画では紙の書籍を紹介しており、私の考えもいくつか含まれています：</p> <ul> <li>データ構造とアルゴリズムを学ぶ重要性。</li> <li>なぜ紙の書籍で Python を選んだのか。</li> <li>知識共有に対する理解。</li> </ul> <p>新人 UP 主ですので、ぜひ応援と高評価・チャンネル登録をお願いします～ありがとうございます！</p> <p>紙の書籍のスナップショット：</p> <p></p> <p></p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_2","level":2,"title":"長所と短所","text":"<p>紙の書籍ならではの魅力を、簡単にまとめると次のとおりです：</p> <ul> <li>フルカラー印刷を採用し、本書の「アニメーション図解」の強みをそのまま活かせます。</li> <li>紙の素材にもこだわり、色彩を高い精度で再現しつつ、紙の書籍ならではの質感も残しています。</li> <li>紙の書籍版は Web 版よりも書式が整っており、たとえば図中の数式には斜体を用いています。</li> <li>価格を上げずに、マインドマップの折り込みページやしおりも付属します。</li> <li>紙の書籍、Web 版、PDF 版で内容は同期しており、自由に切り替えて読めます。</li> </ul> <p>Tip</p> <p>紙の書籍と Web 版を同期させるのは難しいため、細かな違いが生じる場合があります。ご了承ください！</p> <p>もちろん、購入前に検討しておくべき点もいくつかあります：</p> <ul> <li>Python 言語を使用しているため、あなたの主言語と合わない可能性があります（Python は疑似コードと捉え、考え方の理解を重視してください）。</li> <li>フルカラー印刷は図解やコードの読みやすさを大きく高める一方で、白黒印刷より価格はやや高くなります。</li> </ul> <p>Tip</p> <p>「印刷品質」と「価格」は、アルゴリズムにおける「時間効率」と「空間効率」のようなもので、両立は容易ではありません。そして私は、「印刷品質」は「時間効率」に当たるため、より重視すべきだと考えています。</p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_3","level":2,"title":"購入リンク","text":"<p>紙の書籍に興味があれば、ぜひ一冊ご検討ください。新刊の 5 割引を用意していただきましたので、こちらのリンクをご覧いただくか、以下の QR コードをスキャンしてください：</p> <p></p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_4","level":2,"title":"あとがき","text":"<p>当初、私は紙の書籍出版に必要な作業量を甘く見ていて、オープンソースプロジェクトをきちんと保守していれば、紙の書籍版も何らかの自動化手段で生成できると思っていました。実際には、紙の書籍の制作フローとオープンソースプロジェクトの更新の仕組みには大きな違いがあり、その間をつなぐには多くの追加作業が必要でした。</p> <p>一冊の本の初稿と出版基準を満たす完成稿との間には、なお大きな隔たりがあります。出版社（企画、編集、デザイン、マーケティングなど）と著者が力を合わせ、長い時間をかけて磨き上げていく必要があります。ここで、図霊の企画編集者である王軍花さん、そして人民郵電出版社と図霊コミュニティで本書の出版工程に携わってくださったすべての皆さまに感謝いたします！</p> <p>この本があなたの助けになれば幸いです！</p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"第 0 章   はじめに","text":"<p>Abstract</p> <p>アルゴリズムは美しい交響曲のようであり、コードの一行一行が旋律のように流れていきます。</p> <p>この本があなたの心の中でそっと響き、独自で深い旋律を残してくれることを願っています。</p>","path":["第 0 章 &nbsp; 前書き","第 0 章 &nbsp; はじめに"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"章の内容","text":"<ul> <li>0.1   本書について</li> <li>0.2   本書の使い方</li> <li>0.3   まとめ</li> </ul>","path":["第 0 章 &nbsp; 前書き","第 0 章 &nbsp; はじめに"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   本書について","text":"<p>本プロジェクトは、オープンソースで無料、かつ初心者にやさしいデータ構造とアルゴリズムの入門書を作ることを目的としています。</p> <ul> <li>全編でアニメーション付きの図解を採用し、内容は明快で理解しやすく、学習曲線もなだらかで、初心者がデータ構造とアルゴリズムの知識地図を探求できるよう導きます。</li> <li>ソースコードはワンクリックで実行でき、読者が演習を通じてプログラミング能力を高め、アルゴリズムの動作原理とデータ構造の内部実装を理解する助けとなります。</li> <li>読者どうしの助け合いによる学習を推奨しており、コメント欄で質問や見解を共有し、対話と議論を通じてともに成長していくことを歓迎します。</li> </ul>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   対象読者","text":"<p>もしあなたがアルゴリズム初心者で、これまでアルゴリズムに触れたことがない、あるいはすでに多少の問題演習の経験はあるものの、データ構造とアルゴリズムについてはまだ曖昧な理解にとどまり、できるかできないかの間を行き来しているなら、本書はまさにあなたのために作られています！</p> <p>もしすでに一定量の問題演習を積み、ほとんどの問題パターンに慣れているなら、本書はアルゴリズム知識体系の復習と整理に役立ちます。リポジトリのソースコードは「問題演習ツール集」や「アルゴリズム辞典」として活用できます。</p> <p>もしあなたがアルゴリズムの「達人」なら、貴重なご提案をいただけることを楽しみにしています。あるいは一緒に執筆に参加してください。</p> <p>前提条件</p> <p>少なくともいずれか一つの言語でのプログラミング基礎があり、簡単なコードを読んだり書いたりできる必要があります。</p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   内容構成","text":"<p>本書の主な内容は以下の図のとおりです。</p> <ul> <li>計算量解析：データ構造とアルゴリズムを評価する観点と方法。時間計算量と空間計算量の求め方、代表的な種類、例など。</li> <li>データ構造：基本データ型とデータ構造の分類方法。配列、連結リスト、スタック、キュー、ハッシュテーブル、木、ヒープ、グラフなどのデータ構造の定義、長所と短所、基本操作、代表的な種類、典型的な応用、実装方法など。</li> <li>アルゴリズム：探索、ソート、分割統治、バックトラッキング、動的計画法、貪欲法などのアルゴリズムの定義、長所と短所、効率、適用場面、問題を解く手順、例題など。</li> </ul> <p></p> <p> 図 0-1   本書の主な内容 </p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   謝辞","text":"<p>本書は、オープンソースコミュニティの多くの貢献者による共同の努力のもとで、継続的に改善されています。時間と労力を注いでくださったすべての執筆者の皆さんに感謝します。お名前は次のとおりです（GitHub により自動生成された順序）：krahets、coderonion、Gonglja、nuomi1、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、rongyi、msk397、gvenusleo、khoaxuantu、rivertwilight、K3v123、gyt95、zhuoqinyue、yuelinxin、Zuoxun、mingXta、Phoenix0415、FangYuan33、GN-Yu、longsizhuo、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、pengchzn、QiLOL、magentaqin、hello-ikun、JoseHung、qualifier1024、thomasq0、sunshinesDL、L-Super、Guanngxu、Transmigration-zhou、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、Shyam-Chen、theNefelibatas、longranger2、codeberg-user、xiongsp、JeffersonHuang、prinpal、seven1240、Wonderdch、malone6、xiaomiusa87、gaofer、bluebean-cloud、a16su、SamJin98、hongyun-robot、nanlei、XiaChuerwu、yd-j、iron-irax、mgisr、steventimes、junminhong、heshuyue、danny900714、MolDuM、Nigh、Dr-XYZ、XC-Zero、reeswell、PXG-XPG、NI-SW、Horbin-Magician、Enlightenus、YangXuanyi、beatrix-chan、DullSword、xjr7670、jiaxianhua、qq909244296、iStig、boloboloda、hts0000、gledfish、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、linyejoe2、liuxjerry、llql1211、fbigm、echo1937、szu17dmy、dshlstarr、Yucao-cy、coderlef、czruby、bongbongbakudan、beintentional、ZongYangL、ZhongYuuu、ZhongGuanbin、hezhizhen、linzeyan、ZJKung、luluxia、xb534、ztkuaikuai、yw-1021、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yanedie、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、sslmj2020、smilelsb、siqyka、selear、sdshaoda、Xi-Row、popozhu、nuquist19、noobcodemaker、XiaoK29、chadyi、lyl625760、lucaswangdev、0130w、shanghai-Jerry、EJackYang、Javesun99、eltociear、lipusheng、KNChiu、BlindTerran、ShiMaRing、lovelock、FreddieLi、FloranceYeh、fanchenggang、gltianwen、goerll、nedchu、curly210102、CuB3y0nd、KraHsu、CarrotDLaw、youshaoXG、bubble9um、Asashishi、Asa0oo0o0o、fanenr、eagleanurag、akshiterate、52coder、foursevenlove、KorsChen、GaochaoZhu、hopkings2008、yang-le、realwujing、Evilrabbit520、Umer-Jahangir、Turing-1024-Lee、Suremotoo、paoxiaomooo、Chieko-Seren、Allen-Scai、ymmmas、Risuntsy、Richard-Zhang1019、RafaelCaso、qingpeng9802、primexiao、Urbaner3、zhongfq、nidhoggfgg、MwumLi、CreatorMetaSky、martinx、ZnYang2018、hugtyftg、logan-qiu、psychelzh、Keynman、KeiichiKasai と KawaiiAsh。</p> <p>本書のコードレビューは coderonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、khoaxuantu、krahets、night-cruise、nuomi1、Reanon と rongyi によって行われました（アルファベット順）。彼らが費やしてくれた時間と労力に感謝します。各言語のコードの規範性と統一性が保たれているのは、まさに彼らのおかげです。</p> <p>本書の繁体字中国語版は Shyam-Chen と Dr-XYZ がレビューし、英語版は yuelinxin、K3v123、QiLOL、Phoenix0415、SamJin98、yanedie、RafaelCaso、pengchzn、thomasq0 と magentaqin がレビューし、日本語版は eltociear がレビューしました。彼らの継続的な貢献があってこそ、本書はより幅広い読者に届けられています。感謝いたします。</p> <p>本書の ePub 電子書籍生成ツールは zhongfq によって開発されました。彼の貢献に感謝します。読者により自由な読書方法を提供してくれました。</p> <p>本書の執筆過程で、私は多くの方々の助けを得ました。</p> <ul> <li>会社での私の指導教員である李汐博士に感謝します。ある対話の中で「すぐに行動しよう」と励ましてくださり、この本を書く決意を固めることができました；</li> <li>私の恋人であり、本書の最初の読者でもある泡泡に感謝します。アルゴリズム初心者の視点から多くの貴重な提案をしてくれたおかげで、本書はより初心者に適したものになりました；</li> <li>腾宝、琦宝、飞宝が本書に創造性あふれる名前を付けてくれたことに感謝します。みんなが最初のコード行「Hello World!」を書いた美しい記憶を呼び起こしてくれました；</li> <li>校铨が知的財産の面で専門的な支援をしてくれたことに感謝します。これは本オープンソース書籍の改善に重要な役割を果たしました；</li> <li>苏潼が本書の美しい表紙と logo をデザインし、私の完璧主義につき合って何度も辛抱強く修正してくれたことに感謝します；</li> <li>@squidfunk が組版に関する助言を提供してくれたこと、そして彼が開発したオープンソースのドキュメントテーマ Material-for-MkDocs に感謝します。</li> </ul> <p>執筆の過程で、私はデータ構造とアルゴリズムに関する多くの教材や記事を読みました。これらの作品は本書に優れた手本を与え、本書の内容の正確性と品質を支えてくれました。ここに、すべての先生方と先人たちの卓越した貢献に感謝します！</p> <p>本書は手と頭を同時に使う学習方法を提唱しています。この点で私は『手を動かして学ぶ深層学習』から大きな啓発を受けました。ここで読者の皆さんにこの優れた著作を強くお勧めします。</p> <p>心から両親に感謝します。いつも支え励ましてくれたからこそ、私はこの興味深いことに取り組む機会を得ることができました。</p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   本書の使い方","text":"<p>Tip</p> <p>最適な読書体験を得るために、本節の内容を一通り読むことをおすすめします。</p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   文章スタイルの約束","text":"<ul> <li>見出しの後に <code>*</code> が付いているのは選読章で、内容は比較的難しめです。時間が限られている場合は、先に読み飛ばしてもかまいません。</li> <li>専門用語は太字（紙書籍版と PDF 版）または下線付き（Web 版）で示します。たとえば配列（array）のようなものです。文献を読む際に役立つため、覚えておくことをおすすめします。</li> <li>重要な内容やまとめの文は 太字 で示します。これらの文章には特に注意してください。</li> <li>特定の意味を持つ語句には“引用符”を付け、曖昧さを避けます。</li> <li>プログラミング言語ごとに用語が一致しない場合、本書では Python を基準とします。たとえば、“空”を表すのに <code>None</code> を使います。</li> <li>本書では、よりコンパクトなレイアウトのために、言語ごとのコメント規約を一部省略しています。コメントは主に3種類あります。タイトルコメント、内容コメント、複数行コメントです。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"タイトルコメント。関数、クラス、テストケースなどを示すために使います\"\"\"\n\n# 内容コメント。コードを詳しく説明するために使います\n\n\"\"\"\n複数行\nコメント\n\"\"\"\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n// 複数行\n// コメント\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>### タイトルコメント。関数、クラス、テストケースなどを示すために使います ###\n\n# 内容コメント。コードを詳しく説明するために使います\n\n# 複数行\n# コメント\n</code></pre>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   アニメーション図解で効率よく学ぶ","text":"<p>文字と比べて、動画や画像は情報密度と構造化の度合いが高く、理解しやすいものです。本書では、重要かつ難解な知識は主にアニメーションによる図解で示し、文章は説明と補足を担います。</p> <p>本書を読んでいて、ある内容に以下の図のようなアニメーション図解がある場合は、図を主、文章を従として、両方を合わせて理解してください。</p> <p></p> <p> 図 0-2   アニメーション図解の例 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   コード実践で理解を深める","text":"<p>本書のサンプルコードは GitHub リポジトリ で管理されています。以下の図のように、ソースコードにはテストケースが付いており、ワンクリックで実行できます。</p> <p>時間に余裕があれば、コードを見ながら自分で一度書いてみることをおすすめします。学習時間が限られている場合でも、少なくともすべてのコードに目を通し、実行してください。</p> <p>コードを読むのに比べて、書く過程のほうが得られるものは多いものです。手を動かしてこそ、本当に学んだことになります。</p> <p></p> <p> 図 0-3   コード実行例 </p> <p>コードを実行する前準備は主に3ステップです。</p> <p>第1ステップ：ローカルのプログラミング環境をインストールする。付録のチュートリアルを参照してインストールしてください。すでにインストール済みであれば、この手順は省略できます。</p> <p>第2ステップ：コードリポジトリをクローンまたはダウンロードする。 GitHub リポジトリ にアクセスしてください。すでに Git をインストールしている場合は、次のコマンドでこのリポジトリをクローンできます：</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>もちろん、以下の図に示す場所で“Download ZIP”ボタンをクリックし、コードの圧縮ファイルを直接ダウンロードしてローカルで展開することもできます。</p> <p></p> <p> 図 0-4   リポジトリのクローンとコードのダウンロード </p> <p>第3ステップ：ソースコードを実行する。以下の図のように、上部にファイル名が表示されているコードブロックについては、リポジトリの <code>codes</code> フォルダ内に対応するソースコードファイルがあります。ソースコードファイルはワンクリックで実行できるため、不要なデバッグ時間を減らし、学習内容に集中できます。</p> <p></p> <p> 図 0-5   コードブロックと対応するソースコードファイル </p> <p>ローカルでコードを実行するだけでなく、Web 版では Python コードの可視化実行にも対応しています（pythontutor を利用）。以下の図のように、コードブロックの下にある“可視化実行”をクリックすると表示を展開し、アルゴリズムコードの実行過程を観察できます。また、“全画面表示”をクリックすると、より見やすい閲覧体験が得られます。</p> <p></p> <p> 図 0-6   Python コードの可視化実行 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   質問と議論を通じてともに成長する","text":"<p>本書を読んでいて、理解できていない知識点を安易に読み飛ばさないでください。コメント欄で気軽に質問してください。私と仲間たちが誠意をもって回答し、通常は 2 日以内に返信します。</p> <p>以下の図のように、Web 版では各章の下部にコメント欄があります。ぜひコメント欄の内容にも目を通してください。一方では、みんなが直面した問題を知ることで知識の抜けを補い、より深い思考を促せます。もう一方では、ほかの仲間の質問にも積極的に答え、見解を共有し、互いの成長を助けてほしいと思います。</p> <p></p> <p> 図 0-7   コメント欄の例 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   アルゴリズム学習ロードマップ","text":"<p>全体として見ると、データ構造とアルゴリズムの学習過程は 3 つの段階に分けられます。</p> <ol> <li>第 1 段階：アルゴリズム入門。さまざまなデータ構造の特徴と使い方に慣れ、異なるアルゴリズムの原理、流れ、用途、効率などを学ぶ必要があります。</li> <li>第 2 段階：アルゴリズム問題を解く。まずは人気の高い問題から取り組み、少なくとも 100 問は蓄積して、主流のアルゴリズム問題に慣れることをおすすめします。最初のうちは、“知識の忘却”が課題になるかもしれませんが、心配はいりません。これはごく自然なことです。“エビングハウスの忘却曲線”に沿って問題を復習すれば、通常は 3～5 回繰り返すことでしっかり記憶に定着します。おすすめの問題リストと学習計画は、この GitHub リポジトリ を参照してください。</li> <li>第 3 段階：知識体系を構築する。学習面では、アルゴリズムの連載記事、解法フレームワーク、教材などを読むことで、知識体系を継続的に充実させられます。問題演習の面では、トピック別分類、1 問多解、1 解多題といった発展的な戦略も試せます。関連する学習ノウハウは各コミュニティで見つけられます。</li> </ol> <p>以下の図のように、本書の内容は主に“第 1 段階”を扱っており、第 2 段階と第 3 段階の学習をより効率的に進める助けとなることを目的としています。</p> <p></p> <p> 図 0-8   アルゴリズム学習ロードマップ </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   まとめ","text":"","path":["第 0 章 &nbsp; 前書き","0.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li>本書の主な対象読者はアルゴリズム初学者です。すでにある程度の基礎がある場合でも、本書はアルゴリズム知識を体系的に振り返る助けとなり、書中のソースコードは「問題演習用ツール集」としても利用できます。</li> <li>本書の内容は主に計算量解析、データ構造、アルゴリズムの三部からなり、この分野の大部分のテーマを網羅しています。</li> <li>アルゴリズム初心者にとって、学習初期の段階で入門書を読むことは非常に重要であり、多くの遠回りを避けられます。</li> <li>本書のアニメーション図解は通常、重要な知識や難しい知識を紹介するために用いられます。本書を読む際は、これらの内容により多く注意を払うべきです。</li> <li>実践はプログラミングを学ぶ最良の方法です。ソースコードを実行し、実際に自分でコードを書くことを強く勧めます。</li> <li>本書のWeb版の各章にはコメント欄が設けられており、疑問や見解をいつでも共有することを歓迎します。</li> </ul>","path":["第 0 章 &nbsp; 前書き","0.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"参考文献","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] 严蔚敏. データ構造（C 言語版）.</p> <p>[5] 邓俊辉. データ構造（C++ 言語版、第3版）.</p> <p>[6] マーク・アレン・ワイス著，陈越訳. データ構造とアルゴリズム解析：Java言語による記述（第3版）.</p> <p>[7] 程杰. データ構造の話.</p> <p>[8] 王争. データ構造とアルゴリズムの美.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["参考文献"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"第 10 章   探索","text":"<p>Abstract</p> <p>探索は未知の冒険であり、私たちは神秘的な空間の隅々まで歩き回る必要があるかもしれず、あるいは素早く目標を特定できるかもしれません。</p> <p>この探索の旅において、すべての探求が思いもよらなかった答えをもたらすかもしれません。</p>","path":["第 10 章 &nbsp; 探索"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"章の内容","text":"<ul> <li>10.1   二分探索</li> <li>10.2   二分探索の挿入位置</li> <li>10.3   二分探索の境界</li> <li>10.4   ハッシュによる最適化戦略</li> <li>10.5   探索アルゴリズム再考</li> <li>10.6   まとめ</li> </ul>","path":["第 10 章 &nbsp; 探索"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   二分探索","text":"<p>二分探索（binary search）は分割統治法に基づく効率的な探索アルゴリズムです。データが整列済みである性質を利用し、各ラウンドで探索範囲を半分に縮小し、目標要素を見つけるか探索区間が空になるまで続けます。</p> <p>Question</p> <p>長さ \\(n\\) の配列 <code>nums</code> が与えられます。要素は小さい順に並んでおり、重複しません。要素 <code>target</code> がこの配列内にある場合はそのインデックスを返し、含まれない場合は \\(-1\\) を返してください。例を次の図に示します。</p> <p></p> <p> 図 10-1   二分探索の例 </p> <p>次の図に示すように、まずポインタ \\(i = 0\\) と \\(j = n - 1\\) を初期化し、それぞれ配列の先頭要素と末尾要素を指すようにして、探索区間 \\([0, n - 1]\\) を表します。角括弧は閉区間を表し、境界値自体を含むことに注意してください。</p> <p>次に、以下の 2 つの手順を繰り返します。</p> <ol> <li>中央のインデックス \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) を計算します。ここで \\(\\lfloor \\: \\rfloor\\) は切り捨てを表します。</li> <li><code>nums[m]</code> と <code>target</code> の大小関係を判定し、次の 3 つの場合に分かれます。<ol> <li><code>nums[m] &lt; target</code> のとき、<code>target</code> は区間 \\([m + 1, j]\\) にあるため、\\(i = m + 1\\) を実行します。</li> <li><code>nums[m] &gt; target</code> のとき、<code>target</code> は区間 \\([i, m - 1]\\) にあるため、\\(j = m - 1\\) を実行します。</li> <li><code>nums[m] = target</code> のとき、<code>target</code> が見つかったので、インデックス \\(m\\) を返します。</li> </ol> </li> </ol> <p>配列に目標要素が含まれない場合、探索区間は最終的に空まで縮小されます。このとき \\(-1\\) を返します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 10-2   二分探索の流れ </p> <p>注意すべき点として、\\(i\\) と \\(j\\) はどちらも <code>int</code> 型であるため、\\(i + j\\) が <code>int</code> 型の範囲を超える可能性があります。大きな数によるオーバーフローを避けるため、通常は式 \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) を用いて中点を計算します。</p> <p>コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索（両閉区間）\"\"\"\n    # 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    i, j = 0, len(nums) - 1\n    # ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j:\n        # 理論上、Python の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # この場合、target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # この場合、target は区間 [i, m-1] にある\n        else:\n            return m  # 目標要素が見つかったらそのインデックスを返す\n    return -1  # 目標要素が見つからなければ -1 を返す\n</code></pre> binary_search.cpp<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.size() - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(int[] nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分探索（両閉区間） */\nint BinarySearch(int[] nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.Length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // 中点インデックス m を計算\n        if (nums[m] &lt; target)      // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else                       // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分探索（両閉区間） */\nfunc binarySearch(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    i, j := 0, len(nums)-1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    for i &lt;= j {\n        m := i + (j-i)/2      // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分探索（両閉区間） */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分探索（両閉区間） */\nfunction binarySearch(nums, target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let i = 0,\n        j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        // 中点インデックス `m` を計算し、`parseInt()` で切り捨てる\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else return m; // 目標要素が見つかったらそのインデックスを返す\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分探索（両閉区間） */\nfunction binarySearch(nums: number[], target: number): number {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let i = 0,\n        j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        // 中点インデックス m を計算\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    return -1; // 目標要素が見つからなければ -1 を返す\n}\n</code></pre> binary_search.dart<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n  int i = 0, j = nums.length - 1;\n  // ループし、探索区間が空になったら終了する（i &gt; j で空）\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      // この場合、target は区間 [m+1, j] にある\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // この場合、target は区間 [i, m-1] にある\n      j = m - 1;\n    } else {\n      // 目標要素が見つかったらそのインデックスを返す\n      return m;\n    }\n  }\n  // 目標要素が見つからなければ -1 を返す\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分探索（両閉区間） */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(int *nums, int len, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = len - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分探索（両閉区間） */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    var i = 0\n    var j = nums.size - 1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        else  // 目標要素が見つかったらそのインデックスを返す\n            return m\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分探索（両閉区間） ###\ndef binary_search(nums, target)\n  # 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n  i, j = 0, nums.length - 1\n\n  # ループし、探索区間が空になったら終了する（i &gt; j で空）\n  while i &lt;= j\n    # 理論上、Ruby の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない\n    m = (i + j) / 2   # 中点インデックス m を計算\n\n    if nums[m] &lt; target\n      i = m + 1 # この場合、target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # この場合、target は区間 [i, m-1] にある\n    else\n      return m  # 目標要素が見つかったらそのインデックスを返す\n    end\n  end\n\n  -1  # 目標要素が見つからなければ -1 を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>時間計算量は \\(O(\\log n)\\) ：二分探索のループでは各ラウンドで区間が半分になるため、ループ回数は \\(\\log_2 n\\) です。</p> <p>空間計算量は \\(O(1)\\) ：ポインタ \\(i\\) と \\(j\\) に必要なのは定数サイズの空間だけです。</p>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   区間の表し方","text":"<p>上記の両閉区間のほかに、一般的な区間表現として「左閉右開」区間があり、\\([0, n)\\) と定義されます。つまり左端は含み、右端は含みません。この表現では、区間 \\([i, j)\\) は \\(i = j\\) のとき空です。</p> <p>この表現に基づいて、同じ機能を持つ二分探索アルゴリズムを実装できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索（左閉右開区間）\"\"\"\n    # 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    i, j = 0, len(nums)\n    # ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # この場合、target は区間 [m+1, j) にある\n        elif nums[m] &gt; target:\n            j = m  # この場合、target は区間 [i, m) にある\n        else:\n            return m  # 目標要素が見つかったらそのインデックスを返す\n    return -1  # 目標要素が見つからなければ -1 を返す\n</code></pre> binary_search.cpp<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.size();\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(int[] nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分探索（左閉右開区間） */\nint BinarySearchLCRO(int[] nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.Length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // 中点インデックス m を計算\n        if (nums[m] &lt; target)      // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else                       // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分探索（左閉右開区間） */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    i, j := 0, len(nums)\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    for i &lt; j {\n        m := i + (j-i)/2      // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m) にある\n            j = m\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分探索（左閉右開区間） */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m) にある\n            j = m\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分探索（左閉右開区間） */\nfunction binarySearchLCRO(nums, target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let i = 0,\n        j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        // 中点インデックス `m` を計算し、`parseInt()` で切り捨てる\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        // 目標要素が見つかったらそのインデックスを返す\n        else return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分探索（左閉右開区間） */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let i = 0,\n        j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        // 中点インデックス m を計算\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    return -1; // 目標要素が見つからなければ -1 を返す\n}\n</code></pre> binary_search.dart<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n  int i = 0, j = nums.length;\n  // ループし、探索区間が空になったら終了する（i = j で空）\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      // この場合、target は区間 [m+1, j) にある\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // この場合、target は区間 [i, m) にある\n      j = m;\n    } else {\n      // 目標要素が見つかったらそのインデックスを返す\n      return m;\n    }\n  }\n  // 目標要素が見つからなければ -1 を返す\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分探索（左閉右開区間） */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = len;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分探索（左閉右開区間） */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    var i = 0\n    var j = nums.size\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m\n        else  // 目標要素が見つかったらそのインデックスを返す\n            return m\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分探索（左閉右開区間） ###\ndef binary_search_lcro(nums, target)\n  # 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n  i, j = 0, nums.length\n\n  # ループし、探索区間が空になったら終了する（i = j で空）\n  while i &lt; j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # この場合、target は区間 [m+1, j) にある\n    elsif nums[m] &gt; target\n      j = m - 1 # この場合、target は区間 [i, m) にある\n    else\n      return m  # 目標要素が見つかったらそのインデックスを返す\n    end\n  end\n\n  -1  # 目標要素が見つからなければ -1 を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図に示すように、2 種類の区間表現では、二分探索アルゴリズムの初期化、ループ条件、区間の縮小操作がそれぞれ異なります。</p> <p>「両閉区間」の表現では左右の境界がどちらも閉区間として定義されるため、ポインタ \\(i\\) とポインタ \\(j\\) による区間縮小の操作も対称になります。このほうがミスをしにくいため、一般には「両閉区間」の書き方を推奨します。</p> <p></p> <p> 図 10-3   2 種類の区間定義 </p>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   利点と限界","text":"<p>二分探索は時間と空間の両面で優れた性能を持ちます。</p> <ul> <li>二分探索は時間効率が高いです。データ量が大きい場合、対数時間計算量は大きな優位性を持ちます。たとえば、データサイズ \\(n = 2^{20}\\) のとき、線形探索では \\(2^{20} = 1048576\\) 回のループが必要ですが、二分探索では \\(\\log_2 2^{20} = 20\\) 回で済みます。</li> <li>二分探索は追加の空間を必要としません。追加領域を要する探索アルゴリズム（たとえばハッシュ探索）と比べて、二分探索はより省メモリです。</li> </ul> <p>しかし、二分探索があらゆる状況に適しているわけではなく、主な理由は次のとおりです。</p> <ul> <li>二分探索は整列済みデータにしか適用できません。入力データが無秩序な場合、二分探索を使うためだけにソートするのは割に合いません。ソートアルゴリズムの時間計算量は通常 \\(O(n \\log n)\\) であり、線形探索や二分探索よりも高いからです。要素を頻繁に挿入する場面では、配列の整列性を保つために特定位置へ挿入する必要があり、その時間計算量は \\(O(n)\\) と高コストです。</li> <li>二分探索は配列にしか適していません。二分探索では要素へ飛び飛びにアクセスする必要がありますが、連結リストでそのようなアクセスを行う効率は低いため、連結リストやそれを基に実装されたデータ構造には向きません。</li> <li>データ量が小さい場合は線形探索のほうが高性能です。線形探索では各ラウンドで 1 回の比較だけで済みますが、二分探索では 1 回の加算、1 回の除算、1 ~ 3 回の比較、1 回の加算（減算）が必要で、合計 4 ~ 6 個の基本操作になります。したがって、データ量 \\(n\\) が小さいときは、線形探索のほうがかえって速くなります。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   二分探索の境界","text":"","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   左端境界を探す","text":"<p>Question</p> <p>長さ \\(n\\) のソート済み配列 <code>nums</code> が与えられ、その中には重複要素が含まれる可能性があります。配列内で最も左にある要素 <code>target</code> のインデックスを返してください。配列にこの要素が含まれない場合は、\\(-1\\) を返します。</p> <p>二分探索で挿入位置を求める方法を思い出すと、探索完了後に \\(i\\) は最も左にある <code>target</code> を指します。したがって、挿入位置を探すことの本質は、最も左にある <code>target</code> のインデックスを探すことです。</p> <p>挿入位置を探す関数を使って左端境界を求めることを考えます。なお、配列に <code>target</code> が含まれない場合があり、そのときは次の 2 つの結果が起こりえます。</p> <ul> <li>挿入位置のインデックス \\(i\\) が範囲外になる。</li> <li>要素 <code>nums[i]</code> が <code>target</code> と等しくない。</li> </ul> <p>上の 2 つの状況に当てはまる場合は、直接 \\(-1\\) を返せば十分です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"最も左の target を二分探索\"\"\"\n    # target の挿入位置を探すのと等価\n    i = binary_search_insertion(nums, target)\n    # target が見つからなければ、-1 を返す\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # target が見つかったら、インデックス i を返す\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 最も左の target を二分探索 */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 最も左の target を二分探索 */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // target の挿入位置を探すのと等価\n    i := binarySearchInsertion(nums, target)\n    // target が見つからなければ、-1 を返す\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 最も左の target を二分探索 */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // target の挿入位置を探すのと等価\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // target が見つからなければ、-1 を返す\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* 最も左の target を二分探索 */\nfunction binarySearchLeftEdge(nums, target) {\n    // target の挿入位置を探すのと等価\n    const i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 最も左の target を二分探索 */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // target の挿入位置を探すのと等価\n    const i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // target の挿入位置を探すのと等価\n  int i = binarySearchInsertion(nums, target);\n  // target が見つからなければ、-1 を返す\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // target が見つかったら、インデックス i を返す\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 最も左の target を二分探索 */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // target の挿入位置を探すのと等価\n    let i = binary_search_insertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binarySearchInsertion(nums, numSize, target);\n    // target が見つからなければ、-1 を返す\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 最も左の target を二分探索 */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // target の挿入位置を探すのと等価\n    val i = binarySearchInsertion(nums, target)\n    // target が見つからなければ、-1 を返す\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### target の最左位置を二分探索 ###\ndef binary_search_left_edge(nums, target)\n  # target の挿入位置を探すのと等価\n  i = binary_search_insertion(nums, target)\n\n  # target が見つからなければ、-1 を返す\n  return -1 if i == nums.length || nums[i] != target\n\n  i # target が見つかったら、インデックス i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   右端境界を探す","text":"<p>では、最も右にある <code>target</code> はどのように探せるでしょうか。最も直接的な方法はコードを修正し、<code>nums[m] == target</code> の場合のポインタの縮小操作を置き換えることです。ここではコードを省略するので、興味があれば自分で実装してみてください。</p> <p>ここでは、より巧妙な 2 つの方法を紹介します。</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   左端境界探索を再利用する","text":"<p>実際には、最も左の要素を探す関数を利用して最も右の要素を探せます。具体的には、最も右にある <code>target</code> を探すことを、最も左にある <code>target + 1</code> を探すことに変換します。</p> <p>下図のように、探索完了後、ポインタ \\(i\\) は最も左にある <code>target + 1</code>（存在する場合）を指し、\\(j\\) は最も右にある <code>target</code> を指します。したがって \\(j\\) を返せばよいです。</p> <p></p> <p> 図 10-7   右端境界の探索を左端境界の探索に変換する </p> <p>返される挿入位置は \\(i\\) なので、そこから \\(1\\) を引いて \\(j\\) を得る必要があることに注意してください：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"最も右の target を二分探索\"\"\"\n    # 最左の target + 1 を探す問題に変換する\n    i = binary_search_insertion(nums, target + 1)\n    # j は最も右の target を指し、i は target より大きい最初の要素を指す\n    j = i - 1\n    # target が見つからなければ、-1 を返す\n    if j == -1 or nums[j] != target:\n        return -1\n    # target が見つかったら、インデックス j を返す\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(int[] nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 最も右の target を二分探索 */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 最も右の target を二分探索 */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // 最左の target + 1 を探す問題に変換する\n    i := binarySearchInsertion(nums, target+1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    j := i - 1\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 最も右の target を二分探索 */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // 最左の target + 1 を探す問題に変換する\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    let j = i - 1\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* 最も右の target を二分探索 */\nfunction binarySearchRightEdge(nums, target) {\n    // 最左の target + 1 を探す問題に変換する\n    const i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    const j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 最も右の target を二分探索 */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 最左の target + 1 を探す問題に変換する\n    const i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    const j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // 最左の target + 1 を探す問題に変換する\n  int i = binarySearchInsertion(nums, target + 1);\n  // j は最も右の target を指し、i は target より大きい最初の要素を指す\n  int j = i - 1;\n  // target が見つからなければ、-1 を返す\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // target が見つかったら、インデックス j を返す\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 最も右の target を二分探索 */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 最左の target + 1 を探す問題に変換する\n    let i = binary_search_insertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    let j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 最も右の target を二分探索 */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // 最左の target + 1 を探す問題に変換する\n    val i = binarySearchInsertion(nums, target + 1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    val j = i - 1\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### target の最右位置を二分探索 ###\ndef binary_search_right_edge(nums, target)\n  # 最左の target + 1 を探す問題に変換する\n  i = binary_search_insertion(nums, target + 1)\n\n  # j は最も右の target を指し、i は target より大きい最初の要素を指す\n  j = i - 1\n\n  # target が見つからなければ、-1 を返す\n  return -1 if j == -1 || nums[j] != target\n\n  j # target が見つかったら、インデックス j を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   要素探索に変換する","text":"<p>配列に <code>target</code> が含まれない場合、最終的に \\(i\\) と \\(j\\) はそれぞれ <code>target</code> より大きい最初の要素と、<code>target</code> より小さい最初の要素を指すことになります。</p> <p>したがって、下図のように、配列中に存在しない要素を構成して、それを使って左右の境界を探せます。</p> <ul> <li>最も左にある <code>target</code> の探索：<code>target - 0.5</code> を探すことに変換でき、ポインタ \\(i\\) を返します。</li> <li>最も右にある <code>target</code> の探索：<code>target + 0.5</code> を探すことに変換でき、ポインタ \\(j\\) を返します。</li> </ul> <p></p> <p> 図 10-8   境界の探索を要素の探索に変換する </p> <p>ここではコードを省略しますが、次の 2 点に注意が必要です。</p> <ul> <li>与えられた配列には小数が含まれないため、等しい場合をどう処理するかを気にする必要はありません。</li> <li>この方法では小数を導入するため、関数内の変数 <code>target</code> を浮動小数点数型に変更する必要があります（Python は変更不要です）。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   二分探索の挿入位置","text":"<p>二分探索は目標要素の検索だけでなく、目標要素の挿入位置を探すなど、多くの派生問題の解決にも利用できます。</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   重複要素がない場合","text":"<p>Question</p> <p>長さ \\(n\\) の整列済み配列 <code>nums</code> と要素 <code>target</code> が与えられます。配列には重複要素は存在しません。ここで <code>target</code> を配列 <code>nums</code> に挿入し、その順序を保ちます。配列中にすでに要素 <code>target</code> が存在する場合は、その左側に挿入します。挿入後の配列における <code>target</code> のインデックスを返してください。例を以下の図に示します。</p> <p></p> <p> 図 10-4   二分探索の挿入位置の例データ </p> <p>前節の二分探索コードを再利用したい場合は、次の二つの問題に答える必要があります。</p> <p>問題 1：配列に <code>target</code> が含まれる場合、挿入位置のインデックスはその要素のインデックスですか？</p> <p>問題では <code>target</code> を等しい要素の左側に挿入するよう求めているため、新しく挿入された <code>target</code> は元の <code>target</code> の位置に入ります。つまり、配列に <code>target</code> が含まれる場合、挿入位置のインデックスはその <code>target</code> のインデックスです。</p> <p>問題 2：配列に <code>target</code> が存在しない場合、挿入位置はどの要素のインデックスですか？</p> <p>二分探索の過程をさらに考えると、<code>nums[m] &lt; target</code> のときは \\(i\\) が移動します。これは、ポインタ \\(i\\) が <code>target</code> 以上の要素へ近づいていることを意味します。同様に、ポインタ \\(j\\) は常に <code>target</code> 以下の要素へ近づいています。</p> <p>したがって二分探索の終了時には、\\(i\\) は最初の <code>target</code> より大きい要素を指し、\\(j\\) は最初の <code>target</code> より小さい要素を指します。よって、配列に <code>target</code> が含まれない場合、挿入インデックスは \\(i\\) です。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索で挿入位置を探す（重複要素なし）\"\"\"\n    i, j = 0, len(nums) - 1  # 両閉区間 [0, n-1] を初期化\n    while i &lt;= j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # target は区間 [i, m-1] にある\n        else:\n            return m  # target が見つかったら、挿入位置 m を返す\n    # target が見つからなければ、挿入位置 i を返す\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 中点インデックス m を計算\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target は区間 [i, m-1] にある\n            j = m - 1\n        } else {\n            // target が見つかったら、挿入位置 m を返す\n            return m\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if nums[m] &gt; target {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            return m // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      i = m + 1; // target は区間 [m+1, j] にある\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target は区間 [i, m-1] にある\n    } else {\n      return m; // target が見つかったら、挿入位置 m を返す\n    }\n  }\n  // target が見つからなければ、挿入位置 i を返す\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 両閉区間 [0, n-1] を初期化\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m;\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            return m // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分探索の挿入位置（重複要素なし） ###\ndef binary_search_insertion_simple(nums, target)\n  # 両閉区間 [0, n-1] を初期化\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # target は区間 [i, m-1] にある\n    else\n      return m  # target が見つかったら、挿入位置 m を返す\n    end\n  end\n\n  i # target が見つからなければ、挿入位置 i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   重複要素がある場合","text":"<p>Question</p> <p>前問を踏まえ、配列には重複要素が含まれる可能性があるものとし、それ以外の条件は変わりません。</p> <p>配列中に複数の <code>target</code> が存在する場合、通常の二分探索ではそのうち一つの <code>target</code> のインデックスしか返せず、その要素の左側と右側にあといくつ <code>target</code> があるかは分かりません。</p> <p>問題では目標要素を最も左に挿入する必要があるため、配列中で最も左にある <code>target</code> のインデックスを探す必要があります。まずは以下の図に示す手順で実現することを考えます。</p> <ol> <li>二分探索を実行し、任意の <code>target</code> のインデックスを得て、これを \\(k\\) とします。</li> <li>インデックス \\(k\\) から始めて左へ線形探索し、最も左の <code>target</code> を見つけたら返します。</li> </ol> <p></p> <p> 図 10-5   線形探索による重複要素の挿入位置 </p> <p>この方法は使用できますが、線形探索を含むため、時間計算量は \\(O(n)\\) です。配列中に重複した <code>target</code> が多い場合、この方法の効率は低くなります。</p> <p>次に、二分探索のコードを拡張することを考えます。以下の図に示すように、全体の流れは変えず、各反復でまず中点インデックス \\(m\\) を計算し、その後 <code>target</code> と <code>nums[m]</code> の大小関係を判定して、次のいくつかの状況に分けます。</p> <ul> <li><code>nums[m] &lt; target</code> または <code>nums[m] &gt; target</code> のときは、まだ <code>target</code> を見つけていないことを意味するため、通常の二分探索と同じ区間縮小を行い、ポインタ \\(i\\) と \\(j\\) を <code>target</code> に近づけます。</li> <li><code>nums[m] == target</code> のときは、<code>target</code> より小さい要素が区間 \\([i, m - 1]\\) にあることを意味するため、\\(j = m - 1\\) として区間を縮小し、ポインタ \\(j\\) を <code>target</code> より小さい要素に近づけます。</li> </ul> <p>ループ終了後、\\(i\\) は最も左の <code>target</code> を指し、\\(j\\) は最初の <code>target</code> より小さい要素を指すため、インデックス \\(i\\) が挿入位置です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 10-6   重複要素に対する二分探索の挿入位置の手順 </p> <p>以下のコードを観察すると、分岐 <code>nums[m] &gt; target</code> と <code>nums[m] == target</code> の処理は同じであるため、両者はまとめることができます。</p> <p>それでも、判定条件を分けたままにしておくことは可能であり、そのほうがロジックがより明確で、可読性も高くなります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索で挿入位置を探す（重複要素あり）\"\"\"\n    i, j = 0, len(nums) - 1  # 両閉区間 [0, n-1] を初期化\n    while i &lt;= j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # target は区間 [i, m-1] にある\n        else:\n            j = m - 1  # target より小さい最初の要素は区間 [i, m-1] にある\n    # 挿入位置 i を返す\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 中点インデックス m を計算\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target は区間 [i, m-1] にある\n            j = m - 1\n        } else {\n            // target より小さい最初の要素は区間 [i, m-1] にある\n            j = m - 1\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if nums[m] &gt; target {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1 // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      i = m + 1; // target は区間 [m+1, j] にある\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target は区間 [i, m-1] にある\n    } else {\n      j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n    }\n  }\n  // 挿入位置 i を返す\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 両閉区間 [0, n-1] を初期化\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1 // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分探索の挿入位置（重複要素あり） ###\ndef binary_search_insertion(nums, target)\n  # 両閉区間 [0, n-1] を初期化\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # target は区間 [i, m-1] にある\n    else\n      j = m - 1 # target より小さい最初の要素は区間 [i, m-1] にある\n    end\n  end\n\n  i # 挿入位置 i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>Tip</p> <p>本節のコードはすべて「両閉区間」の書き方です。興味のある読者は「左閉右開」の書き方を自分で実装してみてください。</p> <p>要するに、二分探索とはポインタ \\(i\\) と \\(j\\) にそれぞれ探索目標を設定することにほかなりません。目標は具体的な要素（たとえば <code>target</code>）である場合もあれば、要素の範囲（たとえば <code>target</code> より小さい要素）である場合もあります。</p> <p>繰り返される二分のループの中で、ポインタ \\(i\\) と \\(j\\) はどちらも事前に定めた目標へ徐々に近づいていきます。最終的に、それらは答えを見つけるか、境界を越えたところで停止します。</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   ハッシュによる最適化戦略","text":"<p>アルゴリズムの問題では，線形探索をハッシュ探索に置き換えることでアルゴリズムの時間計算量を下げることがよくあります。ここでは，あるアルゴリズム問題を通じて理解を深めましょう。</p> <p>Question</p> <p>整数配列 <code>nums</code> と目標要素 <code>target</code> が与えられたとき，配列内から和が <code>target</code> となる 2 つの要素を探索し，それらの配列インデックスを返してください。任意の 1 つの解を返せば十分です。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   線形探索：時間と引き換えに空間を節約","text":"<p>考えられるすべての組み合わせを直接走査することを考えます。次の図に示すように，2 重ループを開始し，各ラウンドで 2 つの整数の和が <code>target</code> であるかを判定します。そうであれば，それらのインデックスを返します。</p> <p></p> <p> 図 10-9   線形探索で 2 数の和を求める </p> <p>コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法 1：総当たり列挙\"\"\"\n    # 2重ループのため、時間計算量は O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法 1：総当たり列挙 */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法 1：総当たり列挙 */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法 1：総当たり列挙 */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法 1：総当たり列挙 */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // 2重ループのため、時間計算量は O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法 1：総当たり列挙 */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // 2重ループのため、時間計算量は O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法 1：総当たり列挙 */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法 1：総当たり列挙 */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法1: 総当たり列挙 */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 2重ループのため、時間計算量は O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法 1：総当たり列挙 */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // 2重ループのため、時間計算量は O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 方法 1：総当たり列挙 */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法 1：総当たり列挙 */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 2重ループのため、時間計算量は O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法1：総当たり列挙 ###\ndef two_sum_brute_force(nums, target)\n  # 2重ループのため、時間計算量は O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>この方法の時間計算量は \\(O(n^2)\\) ，空間計算量は \\(O(1)\\) であり，大規模データでは非常に時間がかかります。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042","level":2,"title":"10.4.2   ハッシュ探索：空間と引き換えに時間を節約","text":"<p>ハッシュテーブルを利用し，キーと値をそれぞれ配列要素と要素のインデックスにします。配列をループで走査し，各ラウンドで次の図に示す手順を実行します。</p> <ol> <li>数値 <code>target - nums[i]</code> がハッシュテーブル内にあるかを判定します。あれば，この 2 つの要素のインデックスを直接返します。</li> <li>キーと値の組 <code>nums[i]</code> とインデックス <code>i</code> をハッシュテーブルに追加します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> 図 10-10   補助ハッシュテーブルで 2 数の和を求める </p> <p>実装コードは次のとおりで，単一ループだけで済みます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法 2：補助ハッシュテーブル\"\"\"\n    # 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    dic = {}\n    # 単一ループで、時間計算量は O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法 2：補助ハッシュテーブル */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法 2：補助ハッシュテーブル */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法 2：補助ハッシュテーブル */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    hashTable := map[int]int{}\n    // 単一ループで、時間計算量は O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    var dic: [Int: Int] = [:]\n    // 単一ループで、時間計算量は O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunction twoSumHashTable(nums, target) {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let m = {};\n    // 単一ループで、時間計算量は O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // 単一ループで、時間計算量は O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法2: 補助ハッシュテーブル */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // 単一ループで、時間計算量は O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法 2：補助ハッシュテーブル */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let mut dic = HashMap::new();\n    // 単一ループで、時間計算量は O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* ハッシュテーブル */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // uthash.h を用いて実装\n} HashTable;\n\n/* ハッシュテーブルを検索する */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* ハッシュテーブルに要素を挿入する */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* 方法 2：補助ハッシュテーブル */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法 2：補助ハッシュテーブル */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // 単一ループで、時間計算量は O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法2：補助ハッシュテーブル ###\ndef two_sum_hash_table(nums, target)\n  # 補助ハッシュテーブルを使用し、空間計算量は O(n)\n  dic = {}\n  # 単一ループで、時間計算量は O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>この方法ではハッシュ探索によって時間計算量を \\(O(n^2)\\) から \\(O(n)\\) に下げ，実行効率を大幅に向上させます。</p> <p>追加のハッシュテーブルを維持する必要があるため，空間計算量は \\(O(n)\\) です。それでも，この方法は全体として時間と空間の効率のバランスがより良く，本問の最適解です。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   探索アルゴリズム再考","text":"<p>探索アルゴリズム（searching algorithm）は、データ構造（配列、連結リスト、木、グラフなど）の中から、特定の条件を満たす 1 つまたは複数の要素を探索するために用いられます。</p> <p>探索アルゴリズムは、実装の考え方に応じて次の 2 種類に分けられます。</p> <ul> <li>データ構造を走査して目標要素を特定する方法。配列、連結リスト、木、グラフの走査などがこれに当たります。</li> <li>データの構成やデータに含まれる事前情報を利用して、要素を効率よく探す方法。二分探索、ハッシュ探索、二分探索木による探索などがこれに当たります。</li> </ul> <p>これらのトピックはすでに前の章で扱っているため、探索アルゴリズムは私たちにとって見慣れたものです。本節では、より体系的な視点から探索アルゴリズムをあらためて見直します。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   総当たり探索","text":"<p>総当たり探索は、データ構造の各要素を順に調べて目標要素を特定します。</p> <ul> <li>“線形探索”は配列や連結リストなどの線形データ構造に適しています。データ構造の一端から始めて、要素を 1 つずつ調べ、目標要素が見つかるか、もう一方の端に達しても見つからないまで続けます。</li> <li>“幅優先探索”と“深さ優先探索”は、グラフと木における 2 つの走査戦略です。幅優先探索は初期ノードから始めて層ごとに探索し、近いところから遠いところへ各ノードを訪れます。深さ優先探索は初期ノードから始めて 1 本の経路を最後までたどり、その後でバックトラックしてほかの経路を試し、データ構造全体を走査し終えるまで続けます。</li> </ul> <p>総当たり探索の利点は、単純で汎用性が高く、**データの前処理や追加のデータ構造を必要としない**ことです。</p> <p>しかし、この種のアルゴリズムの時間計算量は \\(O(n)\\) です。ここで \\(n\\) は要素数であり、そのためデータ量が大きい場合は性能が低くなります。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   適応的な探索","text":"<p>適応的な探索は、データが持つ固有の性質（整列性など）を利用して探索過程を最適化し、目標要素をより効率よく特定します。</p> <ul> <li>“二分探索”は、データの順序性を利用して効率的な探索を行う方法で、配列にしか適用できません。</li> <li>“ハッシュ探索”は、ハッシュ表を用いて探索対象のデータと目標データをキーと値の対応にし、問い合わせ操作を実現します。</li> <li>“木探索”は、特定の木構造（たとえば二分探索木）の中で、ノード値の比較に基づいて不要なノードをすばやく除外し、目標要素を特定します。</li> </ul> <p>この種のアルゴリズムの利点は効率が高く、**時間計算量が \\(O(\\log n)\\) あるいは \\(O(1)\\) に達する**ことです。</p> <p>しかし、これらのアルゴリズムを使うには、たいていデータの前処理が必要です。たとえば、二分探索では事前に配列をソートする必要があり、ハッシュ探索と木探索では追加のデータ構造が必要です。これらのデータ構造を維持するにも、追加の時間と空間のコストがかかります。</p> <p>Tip</p> <p>適応的な探索アルゴリズムは、しばしば検索アルゴリズムとも呼ばれ、主に特定のデータ構造の中で目標要素を高速に取得するために用いられます。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   探索手法の選択","text":"<p>大きさ \\(n\\) のデータ集合が与えられたとき、線形探索、二分探索、木探索、ハッシュ探索など、さまざまな方法で目標要素を探索できます。各手法の動作原理を下図に示します。</p> <p></p> <p> 図 10-11   複数の探索戦略 </p> <p>上記のいくつかの手法について、操作効率と特性を次の表に示します。</p> <p> 表 10-1   探索アルゴリズムの効率比較 </p> 線形探索 二分探索 木探索 ハッシュ探索 要素探索 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) 要素挿入 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 要素削除 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 追加領域 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) データ前処理 / ソート \\(O(n \\log n)\\) 木構築 \\(O(n \\log n)\\) ハッシュ表構築 \\(O(n)\\) データの順序性 なし あり あり なし <p>探索アルゴリズムの選択は、規模、探索性能の要求、データの問い合わせ頻度や更新頻度などにも左右されます。</p> <p>線形探索</p> <ul> <li>汎用性が高く、データの前処理をまったく必要としません。データを 1 回だけ問い合わせればよい場合、ほか 3 つの手法では前処理にかかる時間のほうが、線形探索そのものより長くなることがあります。</li> <li>規模の小さいデータに適しています。この場合、時間計算量が効率に与える影響は比較的小さいです。</li> <li>データ更新頻度が高い場面に適しています。この手法では、データに対する追加の保守が不要だからです。</li> </ul> <p>二分探索</p> <ul> <li>大規模データに適しており、効率が安定しています。最悪時間計算量は \\(O(\\log n)\\) です。</li> <li>データ量が大きすぎる場合には向きません。配列の格納には連続したメモリ領域が必要だからです。</li> <li>頻繁な挿入・削除がある場面には向きません。整列配列を維持するコストが高いためです。</li> </ul> <p>ハッシュ探索</p> <ul> <li>問い合わせ性能への要求が高い場面に適しており、平均時間計算量は \\(O(1)\\) です。</li> <li>順序付きデータや範囲探索が必要な場面には向きません。ハッシュ表ではデータの順序性を維持できないからです。</li> <li>ハッシュ関数とハッシュ衝突処理戦略への依存度が高く、性能劣化のリスクが大きいです。</li> <li>データ量が大きすぎる場合には向きません。ハッシュ表は衝突をできるだけ減らして良好な問い合わせ性能を出すために、追加の空間を必要とするからです。</li> </ul> <p>木探索</p> <ul> <li>巨大データに適しています。木ノードはメモリ上に分散して格納されるためです。</li> <li>順序付きデータの維持や範囲探索が必要な場面に適しています。</li> <li>ノードの挿入・削除を続ける過程で、二分探索木は偏ることがあり、時間計算量は \\(O(n)\\) まで劣化する可能性があります。</li> <li>AVL 木や赤黒木を使えば、各種操作を \\(O(\\log n)\\) の効率で安定して実行できますが、木の平衡を保つ処理による追加コストが発生します。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   まとめ","text":"","path":["第 10 章 &nbsp; 探索","10.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>二分探索はデータの順序性に依存し、ループによって探索区間を半分ずつ縮小しながら探索を行う。入力データがソート済みであることを前提とし、配列または配列ベースで実装されたデータ構造にのみ適用できる。</li> <li>総当たり探索はデータ構造を走査してデータを特定する。線形探索は配列と連結リストに適しており、幅優先探索と深さ優先探索はグラフと木に適している。この種のアルゴリズムは汎用性が高く、データの前処理を必要としないが、時間計算量 \\(O(n)\\) は高い。</li> <li>ハッシュ探索、木探索、二分探索は高効率な探索手法であり、特定のデータ構造内で目的の要素を高速に特定できる。この種のアルゴリズムは効率が高く、時間計算量は \\(O(\\log n)\\) あるいは \\(O(1)\\) に達するが、通常は追加のデータ構造を必要とする。</li> <li>実際には、データ規模、探索性能の要件、データの問い合わせ頻度や更新頻度などの要因を具体的に分析し、そのうえで適切な探索手法を選択する必要がある。</li> <li>線形探索は小規模または頻繁に更新されるデータに適している。二分探索は大規模でソート済みのデータに適している。ハッシュ探索は問い合わせ効率への要求が高く、範囲検索を必要としないデータに適している。木探索は順序の維持と範囲検索のサポートが必要な大規模動的データに適している。</li> <li>ハッシュ探索で線形探索を置き換えることは、実行時間を最適化するための一般的な戦略であり、時間計算量を \\(O(n)\\) から \\(O(1)\\) へと下げられる。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"第 11 章   ソート","text":"<p>Abstract</p> <p>ソートは、混沌を秩序へと変える魔法の鍵のようなものであり、データをより効率的に理解し処理することを可能にします。</p> <p>単純な昇順であれ、複雑な分類配列であれ、ソートはデータの調和のとれた美しさを私たちに示してくれます。</p>","path":["第 11 章 &nbsp; ソート"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"章の内容","text":"<ul> <li>11.1   ソートアルゴリズム</li> <li>11.2   選択ソート</li> <li>11.3   バブルソート</li> <li>11.4   挿入ソート</li> <li>11.5   クイックソート</li> <li>11.6   マージソート</li> <li>11.7   ヒープソート</li> <li>11.8   バケットソート</li> <li>11.9   計数ソート</li> <li>11.10   基数ソート</li> <li>11.11   まとめ</li> </ul>","path":["第 11 章 &nbsp; ソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   バブルソート","text":"<p>バブルソート（bubble sort）は、隣接する要素を繰り返し比較して交換することで整列を行います。この過程が泡のように下から上へ浮かび上がることから、バブルソートと呼ばれます。</p> <p>次の図に示すように、バブル処理は要素の交換操作によってシミュレートできます。配列の最も左の端から右へ走査し、隣接する要素の大小を順に比較して、「左要素 &gt; 右要素」であれば両者を交換します。走査が終わると、最大の要素は配列の最も右端へ移動します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-4   要素の交換操作でバブル処理をシミュレート </p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   アルゴリズムの流れ","text":"<p>配列の長さを \\(n\\) とすると、バブルソートの手順は次の図のとおりです。</p> <ol> <li>まず、\\(n\\) 個の要素に対して「バブル処理」を行い、配列中の最大要素を正しい位置へ交換します。</li> <li>次に、残りの \\(n - 1\\) 個の要素に対して「バブル処理」を行い、2 番目に大きい要素を正しい位置へ交換します。</li> <li>このようにして、\\(n - 1\\) 回の「バブル処理」を終えると、大きいほうから \\(n - 1\\) 個の要素がすべて正しい位置へ交換されます。</li> <li>残った 1 つの要素は必ず最小要素なので、並べ替える必要はなく、これで配列のソートが完了します。</li> </ol> <p></p> <p> 図 11-5   バブルソートの流れ </p> <p>コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"バブルソート\"\"\"\n    n = len(nums)\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(n - 1, 0, -1):\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* バブルソート */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換する\n                // ここでは std::swap() 関数を使用する\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* バブルソート */\nvoid bubbleSort(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* バブルソート */\nvoid BubbleSort(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* バブルソート */\nfunc bubbleSort(nums []int) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* バブルソート */\nfunc bubbleSort(nums: inout [Int]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* バブルソート */\nfunction bubbleSort(nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* バブルソート */\nfunction bubbleSort(nums: number[]): void {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* バブルソート */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // 外側のループ：未ソート区間は [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* バブルソート */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* バブルソート */\nvoid bubbleSort(int nums[], int size) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* バブルソート */\nfun bubbleSort(nums: IntArray) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### バブルソート ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   効率の最適化","text":"<p>ある回の「バブル処理」で交換操作が一度も行われなければ、配列はすでにソート済みであり、結果をそのまま返せることがわかります。したがって、この状況を検出するためのフラグ <code>flag</code> を追加し、発生した時点で直ちに返すようにできます。</p> <p>最適化後も、バブルソートの最悪時間計算量と平均時間計算量は依然として \\(O(n^2)\\) です。ただし、入力配列が完全に整列済みであれば、最良時間計算量は \\(O(n)\\) に達します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"バブルソート（フラグ最適化）\"\"\"\n    n = len(nums)\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # フラグを初期化する\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # 交換する要素を記録\n        if not flag:\n            break  # このバブル処理で要素交換が一度もなければそのまま終了\n</code></pre> bubble_sort.cpp<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換する\n                // ここでは std::swap() 関数を使用する\n                swap(nums[j], nums[j + 1]);\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag)\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag)\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* バブルソート（フラグ最適化） */\nvoid BubbleSortWithFlag(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // 交換する要素を記録\n            }\n        }\n        if (!flag) break;     // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* バブルソート（フラグ最適化） */\nfunc bubbleSortWithFlag(nums []int) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // 交換する要素を記録\n            }\n        }\n        if flag == false { // このバブル処理で要素交換が一度もなければそのまま終了\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* バブルソート（フラグ最適化） */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // フラグを初期化する\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swapAt(j, j + 1)\n                flag = true // 交換する要素を記録\n            }\n        }\n        if !flag { // このバブル処理で要素交換が一度もなければそのまま終了\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* バブルソート（フラグ最適化） */\nfunction bubbleSortWithFlag(nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* バブルソート（フラグ最適化） */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // 外側のループ：未ソート区間は [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // フラグを初期化する\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // 交換する要素を記録\n      }\n    }\n    if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* バブルソート（フラグ最適化） */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swap(j, j + 1);\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if !flag {\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* バブルソート（フラグ最適化） */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // 交換する要素を記録\n            }\n        }\n        if (!flag) break // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### バブルソート ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n\n# ## バブルソート（フラグ最適化）###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # フラグを初期化する\n\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # 交換する要素を記録\n      end\n    end\n\n    break unless flag # このバブル処理で要素交換が一度もなければそのまま終了\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   アルゴリズムの特徴","text":"<ul> <li>時間計算量は \\(O(n^2)\\)、適応的ソート：各回の「バブル処理」で走査する配列の長さは順に \\(n - 1\\)、\\(n - 2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) であり、その総和は \\((n - 1) n / 2\\) です。<code>flag</code> による最適化を導入すると、最良時間計算量は \\(O(n)\\) に達します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>安定ソート：「バブル処理」では等しい要素に出会っても交換しないためです。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   バケットソート","text":"<p>前述のいくつかのソートアルゴリズムは、いずれも「比較ベースのソートアルゴリズム」に属し、要素間の大小を比較することで整列を実現します。この種のソートアルゴリズムの時間計算量は \\(O(n \\log n)\\) を超えられません。続いて、時間計算量が線形オーダーに達しうる「非比較ソートアルゴリズム」をいくつか見ていきます。</p> <p>バケットソート（bucket sort）は分割統治戦略の典型的な応用です。大小関係をもつ複数のバケットを用意し、各バケットがあるデータ範囲に対応するようにして、データを各バケットへ均等に分配します。その後、各バケット内でそれぞれソートを行い、最後にバケットの順序に従ってすべてのデータを結合します。</p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   アルゴリズムの流れ","text":"<p>長さ \\(n\\) の配列を考え、その要素は範囲 \\([0, 1)\\) の浮動小数点数であるとします。バケットソートの流れを以下の図に示します。</p> <ol> <li>\\(k\\) 個のバケットを初期化し、\\(n\\) 個の要素を \\(k\\) 個のバケットに分配します。</li> <li>各バケットに対してそれぞれソートを実行します（ここではプログラミング言語の組み込みソート関数を用います）。</li> <li>バケットを小さい順にたどって結果を結合します。</li> </ol> <p></p> <p> 図 11-13   バケットソートの流れ </p> <p>コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"バケットソート\"\"\"\n    # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. 配列要素を各バケットに振り分ける\n    for num in nums:\n        # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        i = int(num * k)\n        # num をバケット i に追加\n        buckets[i].append(num)\n    # 2. 各バケットをソートする\n    for bucket in buckets:\n        # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort()\n    # 3. バケットを走査して結果を結合\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* バケットソート */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. 配列要素を各バケットに振り分ける\n    for (float num : nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = num * k;\n        // num をバケット bucket_idx に追加\n        buckets[i].push_back(num);\n    }\n    // 2. 各バケットをソートする\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. バケットを走査して結果を結合\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* バケットソート */\nvoid bucketSort(float[] nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (float num : nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = (int) (num * k);\n        // num をバケット i に追加\n        buckets.get(i).add(num);\n    }\n    // 2. 各バケットをソートする\n    for (List&lt;Float&gt; bucket : buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        Collections.sort(bucket);\n    }\n    // 3. バケットを走査して結果を結合\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* バケットソート */\nvoid BucketSort(float[] nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    foreach (float num in nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = (int)(num * k);\n        // num をバケット i に追加\n        buckets[i].Add(num);\n    }\n    // 2. 各バケットをソートする\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.Sort();\n    }\n    // 3. バケットを走査して結果を結合\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* バケットソート */\nfunc bucketSort(nums []float64) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for _, num := range nums {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        i := int(num * float64(k))\n        // num をバケット i に追加\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. 各バケットをソートする\n    for i := 0; i &lt; k; i++ {\n        // 組み込みのスライスソート関数を使う。ほかのソートアルゴリズムに置き換えてもよい\n        sort.Float64s(buckets[i])\n    }\n    // 3. バケットを走査して結果を結合\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* バケットソート */\nfunc bucketSort(nums: inout [Double]) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. 配列要素を各バケットに振り分ける\n    for num in nums {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        let i = Int(num * Double(k))\n        // num をバケット i に追加\n        buckets[i].append(num)\n    }\n    // 2. 各バケットをソートする\n    for i in buckets.indices {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        buckets[i].sort()\n    }\n    // 3. バケットを走査して結果を結合\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* バケットソート */\nfunction bucketSort(nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (const num of nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        const i = Math.floor(num * k);\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for (const bucket of buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. バケットを走査して結果を結合\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* バケットソート */\nfunction bucketSort(nums: number[]): void {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (const num of nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        const i = Math.floor(num * k);\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for (const bucket of buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. バケットを走査して結果を結合\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* バケットソート */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. 配列要素を各バケットに振り分ける\n  for (double _num in nums) {\n    // 入力データの範囲は [0, 1) であり、_num * k を用いてインデックス範囲 [0, k-1] に写像する\n    int i = (_num * k).toInt();\n    // _num をバケット bucket_idx に追加\n    buckets[i].add(_num);\n  }\n  // 2. 各バケットをソートする\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. バケットを走査して結果を結合\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* バケットソート */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. 配列要素を各バケットに振り分ける\n    for &amp;num in nums.iter() {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        let i = (num * k as f64) as usize;\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for bucket in &amp;mut buckets {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. バケットを走査して結果を結合\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* バケットソート */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // k = n/2 個のバケットを初期化する\n    int *sizes = malloc(k * sizeof(int));          // 各バケットのサイズを記録する\n    float **buckets = malloc(k * sizeof(float *)); // 動的配列の配列（バケット）\n    // 各バケットに十分な容量を事前確保する\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. 各バケットをソートする\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. ソート済みのバケットを結合する\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // メモリを解放する\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* バケットソート */\nfun bucketSort(nums: FloatArray) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (num in nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        val i = (num * k).toInt()\n        // num をバケット i に追加\n        buckets[i].add(num)\n    }\n    // 2. 各バケットをソートする\n    for (bucket in buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort()\n    }\n    // 3. バケットを走査して結果を結合\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### バケットソート ###\ndef bucket_sort(nums)\n  # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. 配列要素を各バケットに振り分ける\n  nums.each do |num|\n    # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n    i = (num * k).to_i\n    # num をバケット i に追加\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. 各バケットをソートする\n  buckets.each do |bucket|\n    # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n    bucket.sort!\n  end\n\n  # 3. バケットを走査して結果を結合\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   アルゴリズムの特性","text":"<p>バケットソートは、非常に大規模なデータの処理に適しています。たとえば、入力データに 100 万個の要素が含まれ、空間の制約によりシステムメモリへすべてのデータを一度に読み込めない場合です。このとき、データを 1000 個のバケットに分け、それぞれのバケットを個別にソートしてから、最後に結果を結合できます。</p> <ul> <li>時間計算量は \\(O(n + k)\\) ：要素が各バケット内に平均的に分布していると仮定すると、各バケット内の要素数は \\(\\frac{n}{k}\\) です。1 つのバケットをソートするのに \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) の時間がかかるなら、すべてのバケットのソートには \\(O(n \\log\\frac{n}{k})\\) の時間がかかります。バケット数 \\(k\\) が十分大きいとき、時間計算量は \\(O(n)\\) に近づきます。結果を結合する際には、すべてのバケットと要素を走査する必要があり、\\(O(n + k)\\) の時間を要します。最悪の場合、すべてのデータが 1 つのバケットに割り当てられ、そのバケットのソートに \\(O(n^2)\\) の時間がかかります。</li> <li>空間計算量は \\(O(n + k)\\)、非インプレースソート：\\(k\\) 個のバケットと合計 \\(n\\) 個の要素ぶんの追加領域が必要です。</li> <li>バケットソートが安定かどうかは、バケット内要素のソートに用いるアルゴリズムが安定かどうかに依存します。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   均等な分配を実現するには","text":"<p>バケットソートの時間計算量は理論上 \\(O(n)\\) に達しますが、鍵は要素を各バケットへ均等に分配すること にあります。実際のデータは均一に分布していないことが多いからです。たとえば、Taobao 上のすべての商品を価格帯ごとに 10 個のバケットへ均等に分けたいとしても、商品の価格分布は偏っており、100 元未満は非常に多く、1000 元超は非常に少ないかもしれません。価格区間を単純に 10 等分すると、各バケットの商品数には大きな差が生じます。</p> <p>均等な分配を実現するために、まず大まかな境界線を設定し、データをひとまず 3 個のバケットに粗く振り分けます。分配後は、商品数の多いバケットをさらに 3 個のバケットに分割し、すべてのバケット内の要素数がおおむね等しくなるまでこれを続けます。</p> <p>以下の図に示すように、この方法の本質は再帰木を構築することにあり、目標は葉ノードの値をできるだけ均等にすることです。もちろん、毎回データを 3 個のバケットに分割する必要はなく、具体的な分け方はデータの特徴に応じて柔軟に選べます。</p> <p></p> <p> 図 11-14   再帰的にバケットを分割 </p> <p>商品価格の確率分布をあらかじめ把握しているなら、データの確率分布に基づいて各バケットの価格境界を設定できます。なお、データ分布は必ずしも特別に統計を取る必要はなく、データの特徴に応じて何らかの確率モデルで近似することもできます。</p> <p>以下の図に示すように、商品価格が正規分布に従うと仮定すれば、価格区間を合理的に設定でき、それによって商品を各バケットへ均等に分配できます。</p> <p></p> <p> 図 11-15   確率分布に基づいてバケットを分割 </p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   計数ソート","text":"<p>計数ソート（counting sort）は要素数を集計することでソートを実現し、通常は整数配列に適用されます。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   単純な実装","text":"<p>まず簡単な例を見てみましょう。長さ \\(n\\) の配列 <code>nums</code> が与えられ、その要素はすべて「非負整数」であるとします。計数ソートの全体的な流れを以下の図に示します。</p> <ol> <li>配列を走査し、その中の最大値を見つけて \\(m\\) とし、続いて長さ \\(m + 1\\) の補助配列 <code>counter</code> を作成します。</li> <li><code>counter</code> を用いて <code>nums</code> 内の各数値の出現回数を集計します。ここで <code>counter[num]</code> は数値 <code>num</code> の出現回数に対応します。集計方法は非常に簡単で、<code>nums</code> を走査し（現在の数値を <code>num</code> とする）、各回で <code>counter[num]</code> を \\(1\\) 増やせばよいです。</li> <li><code>counter</code> の各インデックスは自然に順序づけられているため、すべての数値はすでに整列された状態とみなせます。続いて <code>counter</code> を走査し、各数値の出現回数に応じて小さい順に <code>nums</code> へ書き戻せば完了です。</li> </ol> <p></p> <p> 図 11-16   計数ソートの流れ </p> <p>コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"計数ソート\"\"\"\n    # 簡易版。オブジェクトのソートには使えない\n    # 1. 配列の最大要素 m を求める\n    m = max(nums)\n    # 2. 各数値の出現回数を数える\n    # counter[num] は num の出現回数を表す\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid CountingSortNaive(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunc countingSortNaive(nums []int) {\n    // 1. 配列の最大要素 m を求める\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. 配列の最大要素 m を求める\n    let m = nums.max()!\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunction countingSortNaive(nums) {\n    // 1. 配列の最大要素 m を求める\n    let m = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunction countingSortNaive(nums: number[]): void {\n    // 1. 配列の最大要素 m を求める\n    let m: number = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. 配列の最大要素 m を求める\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 各数値の出現回数を数える\n  // counter[_num] は _num の出現回数を表す\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. 配列の最大要素 m を求める\n    let m = *nums.iter().max().unwrap();\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(int nums[], int size) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. メモリを解放する\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfun countingSortNaive(nums: IntArray) {\n    // 1. 配列の最大要素 m を求める\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計数ソート ###\ndef counting_sort_naive(nums)\n  # 簡易版。オブジェクトのソートには使えない\n  # 1. 配列の最大要素 m を求める\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. 各数値の出現回数を数える\n  # counter[num] は num の出現回数を表す\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. counter を走査し、各要素を元の配列 nums に書き戻す\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>計数ソートとバケットソートの関係</p> <p>バケットソートの観点から見ると、計数ソートにおける計数配列 <code>counter</code> の各インデックスを 1 つのバケットとみなし、個数を数える過程を各要素を対応するバケットへ振り分ける操作とみなせます。本質的には、計数ソートは整数データにおけるバケットソートの特殊な一例です。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   完全な実装","text":"<p>注意深い読者なら、**入力データがオブジェクトである場合、上記の手順 <code>3.</code> は機能しない**ことに気づくかもしれません。入力データが商品オブジェクトであり、商品価格（クラスのメンバ変数）に基づいて商品をソートしたいとします。しかし上記のアルゴリズムが返せるのは価格のソート結果だけです。</p> <p>では、元のデータのソート結果を得るにはどうすればよいのでしょうか。まず <code>counter</code> の「累積和」を計算します。名前のとおり、インデックス <code>i</code> における累積和 <code>prefix[i]</code> は、配列の先頭から <code>i</code> 番目までの要素の総和に等しくなります：</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>累積和には明確な意味があり、<code>prefix[num] - 1</code> は要素 <code>num</code> が結果配列 <code>res</code> に最後に現れるインデックスを表します。この情報は非常に重要で、各要素が結果配列のどの位置に現れるべきかを示してくれます。続いて元の配列 <code>nums</code> を逆順に走査し、各要素 <code>num</code> に対して各反復で次の 2 つの手順を行います。</p> <ol> <li><code>num</code> を配列 <code>res</code> のインデックス <code>prefix[num] - 1</code> に格納します。</li> <li>累積和 <code>prefix[num]</code> を \\(1\\) 減らし、次に <code>num</code> を配置するインデックスを得ます。</li> </ol> <p>走査が完了すると、配列 <code>res</code> にソート済みの結果が格納されます。最後に <code>res</code> で元の配列 <code>nums</code> を上書きすれば完了です。以下の図は完全な計数ソートの流れを示しています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-17   計数ソートの手順 </p> <p>計数ソートの実装コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"計数ソート\"\"\"\n    # 完全版。オブジェクトをソートでき、かつ安定ソートである\n    # 1. 配列の最大要素 m を求める\n    m = max(nums)\n    # 2. 各数値の出現回数を数える\n    # counter[num] は num の出現回数を表す\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    # つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    # 結果を記録するための配列 res を初期化\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # num を対応するインデックスに配置\n        counter[num] -= 1  # 累積和を 1 減らして、次に num を配置するインデックスを得る\n    # 結果配列 res で元の配列 nums を上書きする\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--;              // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid CountingSort(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunc countingSort(nums []int) {\n    // 1. 配列の最大要素 m を求める\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // num を対応するインデックスに配置\n        res[counter[num]-1] = num\n        // 累積和を 1 減らして、次に num を配置するインデックスを得る\n        counter[num]--\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunc countingSort(nums: inout [Int]) {\n    // 1. 配列の最大要素 m を求める\n    let m = nums.max()!\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // num を対応するインデックスに配置\n        counter[num] -= 1 // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunction countingSort(nums) {\n    // 1. 配列の最大要素 m を求める\n    let m = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunction countingSort(nums: number[]): void {\n    // 1. 配列の最大要素 m を求める\n    let m: number = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. 配列の最大要素 m を求める\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 各数値の出現回数を数える\n  // counter[_num] は _num の出現回数を表す\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. counter の累積和を求め、「出現回数」を「末尾インデックス」に変換する\n  // つまり counter[_num]-1 は、res において _num が最後に出現する位置のインデックスである\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n  // 結果を記録するための配列 res を初期化\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // _num を対応する添字に配置\n    counter[_num]--; // 累積和を 1 減らし、次に _num を配置するインデックスを得る\n  }\n  // 結果配列 res で元の配列 nums を上書きする\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. 配列の最大要素 m を求める\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // num を対応するインデックスに配置\n        counter[num as usize] -= 1; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(int nums[], int size) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--;              // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    memcpy(nums, res, size * sizeof(int));\n    // 5. メモリを解放する\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfun countingSort(nums: IntArray) {\n    // 1. 配列の最大要素 m を求める\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // num を対応するインデックスに配置\n        counter[num]-- // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計数ソート ###\ndef counting_sort(nums)\n  # 完全版。オブジェクトをソートでき、かつ安定ソートである\n  # 1. 配列の最大要素 m を求める\n  m = nums.max\n  # 2. 各数値の出現回数を数える\n  # counter[num] は num の出現回数を表す\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n  # つまり counter[num]-1 は、num が res に最後に現れるインデックス\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n  # 結果を記録するための配列 res を初期化する\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # num を対応するインデックスに配置\n    counter[num] -= 1 # 累積和を 1 減らして、次に num を配置するインデックスを得る\n  end\n  # 結果配列 res で元の配列 nums を上書きする\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n + m)\\)、非適応ソート ：<code>nums</code> の走査と <code>counter</code> の走査が含まれ、いずれも線形時間です。一般には \\(n \\gg m\\) であり、時間計算量は \\(O(n)\\) に近づきます。</li> <li>空間計算量は \\(O(n + m)\\)、非インプレースソート：長さがそれぞれ \\(n\\) と \\(m\\) の配列 <code>res</code> と <code>counter</code> を利用します。</li> <li>安定ソート：<code>res</code> に要素を埋める順序が「右から左」であるため、<code>nums</code> を逆順に走査することで等しい要素どうしの相対位置が変化するのを防ぎ、安定ソートを実現できます。実際には、<code>nums</code> を順方向に走査しても正しいソート結果は得られますが、その結果は安定ではありません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   制約","text":"<p>ここまで読むと、計数ソートは非常に巧妙で、個数を数えるだけで効率的なソートを実現できると感じるかもしれません。しかし、計数ソートを利用するための前提条件は比較的厳格です。</p> <p>計数ソートは非負整数にしか適用できません。ほかの型のデータに適用したい場合は、それらのデータを非負整数に変換でき、かつ変換の過程で要素間の相対的な大小関係が変わらないことを保証する必要があります。たとえば、負数を含む整数配列に対しては、すべての数値に定数を加えて正数へ変換し、ソート後に元へ戻すことができます。</p> <p>計数ソートはデータ量が多く、値域が小さい場合に適しています。たとえば上記の例では \\(m\\) が大きすぎてはならず、そうでないと過剰な空間を消費します。また、\\(n \\ll m\\) のとき、計数ソートは \\(O(m)\\) 時間を要するため、\\(O(n \\log n)\\) のソートアルゴリズムより遅くなる可能性があります。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   ヒープソート","text":"<p>Tip</p> <p>本節を読む前に、「ヒープ」の章を学習済みであることを確認してください。</p> <p>ヒープソート（heap sort）は、ヒープデータ構造に基づいて実装される効率的なソートアルゴリズムです。すでに学んだ「ヒープ構築操作」と「要素の取り出し操作」を利用してヒープソートを実現できます。</p> <ol> <li>配列を入力して最小ヒープを構築すると、このとき最小要素はヒープの頂点にあります。</li> <li>取り出し操作を繰り返し実行し、取り出された要素を順に記録すれば、昇順に並んだ列が得られます。</li> </ol> <p>以上の方法でも実行できますが、取り出した要素を保存するために追加の配列が必要となり、空間をやや無駄にします。実際には、通常はより洗練された実装方法を用います。</p>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   アルゴリズムの流れ","text":"<p>配列の長さを \\(n\\) とすると、ヒープソートの流れは次図のとおりです。</p> <ol> <li>配列を入力して最大ヒープを構築します。完了後、最大要素はヒープの頂点にあります。</li> <li>ヒープ頂点の要素（最初の要素）とヒープ末尾の要素（最後の要素）を交換します。交換後、ヒープの長さは \\(1\\) 減少し、整列済み要素数は \\(1\\) 増加します。</li> <li>ヒープ頂点の要素から始めて、上から下へヒープ化操作（sift down）を実行します。ヒープ化が完了すると、ヒープの性質が回復します。</li> <li>第 <code>2.</code> ステップと第 <code>3.</code> ステップを繰り返し実行します。これを \\(n - 1\\) 回繰り返すと、配列の整列が完了します。</li> </ol> <p>Tip</p> <p>実際には、要素の取り出し操作にも第 <code>2.</code> ステップと第 <code>3.</code> ステップが含まれており、要素を取り出す処理が 1 つ加わるだけです。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-12   ヒープソートの手順 </p> <p>コード実装では、「ヒープ」の章と同じ上から下へのヒープ化 <code>sift_down()</code> 関数を使用します。注意すべき点として、ヒープの長さは最大要素を取り出すたびに短くなるため、<code>sift_down()</code> 関数に長さパラメータ \\(n\\) を追加し、ヒープの現在の有効な長さを指定する必要があります。コードは以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"ヒープの長さは n。ノード i から下方向にヒープ化\"\"\"\n    while True:\n        # ノード i, l, r のうち値が最大のノードを ma とする\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i:\n            break\n        # 2 つのノードを交換\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # ループで上から下へヒープ化\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"ヒープソート\"\"\"\n    # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in range(len(nums) - 1, 0, -1):\n        # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums[0], nums[i] = nums[i], nums[0]\n        # 根ノードを起点に、上から下へヒープ化\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(nums[i], nums[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        swap(nums[0], nums[i]);\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(int[] nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid HeapSort(int[] nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // 根ノードを起点に、上から下へヒープ化\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfunc heapSort(nums *[]int) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        nums.swapAt(i, ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfunc heapSort(nums: inout [Int]) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in nums.indices.dropFirst().reversed() {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums.swapAt(0, i)\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) {\n            break;\n        }\n        // 2 つのノードを交換\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfunction heapSort(nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) {\n            break;\n        }\n        // 2 つのノードを交換\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfunction heapSort(nums: number[]): void {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // ノード i, l, r のうち値が最大のノードを ma とする\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    if (ma == i) break;\n    // 2 つのノードを交換\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // ループで上から下へヒープ化\n    i = ma;\n  }\n}\n\n/* ヒープソート */\nvoid heapSort(List&lt;int&gt; nums) {\n  // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // ヒープから最大要素を取り出し、n-1 回繰り返す\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // 根ノードを起点に、上から下へヒープ化\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break;\n        }\n        // 2 つのノードを交換\n        nums.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in (1..nums.len()).rev() {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums.swap(0, i);\n        // 根ノードを起点に、上から下へヒープ化\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(int nums[], int n) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = n - 1; i &gt; 0; --i) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) \n            break\n        // 2 つのノードを交換\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfun heapSort(nums: IntArray) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (i in nums.size - 1 downTo 1) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### ヒープ長 n で、ノード i から上から下へヒープ化 ###\ndef sift_down(nums, n, i)\n  while true\n    # ノード i, l, r のうち値が最大のノードを ma とする\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    break if ma == i\n    # 2 つのノードを交換\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # ループで上から下へヒープ化\n    i = ma\n  end\nend\n\n### ヒープソート ###\ndef heap_sort(nums)\n  # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # ヒープから最大要素を取り出し、n-1 回繰り返す\n  (nums.length - 1).downto(1) do |i|\n    # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    nums[0], nums[i] = nums[i], nums[0]\n    # 根ノードを起点に、上から下へヒープ化\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応ソート：ヒープ構築操作には \\(O(n)\\) の時間がかかります。ヒープから最大要素を取り出す時間計算量は \\(O(\\log n)\\) であり、これを合計 \\(n - 1\\) 回繰り返します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：いくつかのポインタ変数が使う空間は \\(O(1)\\) です。要素の交換とヒープ化操作はいずれも元の配列上で行われます。</li> <li>非安定ソート：ヒープ頂点の要素とヒープ末尾の要素を交換する際、等しい要素どうしの相対位置が変化する可能性があります。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   挿入ソート","text":"<p>挿入ソート（insertion sort）は単純なソートアルゴリズムであり、その動作原理は手作業でトランプの山を整える過程と非常によく似ています。</p> <p>具体的には、未ソート区間から基準要素を 1 つ選び、その要素を左側の整列済み区間の要素と 1 つずつ比較し、正しい位置に挿入します。</p> <p>以下の図は、配列に要素を挿入する操作の流れを示しています。基準要素を <code>base</code> とすると、目的のインデックスから <code>base</code> までのすべての要素を 1 つずつ右に移動し、その後 <code>base</code> を目的のインデックスに代入する必要があります。</p> <p></p> <p> 図 11-6   1 回の挿入操作 </p>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   アルゴリズムの流れ","text":"<p>挿入ソート全体の流れを以下の図に示します。</p> <ol> <li>初期状態では、配列の 1 番目の要素はすでに整列済みです。</li> <li>配列の 2 番目の要素を <code>base</code> として選び、正しい位置に挿入すると、**配列の先頭 2 要素が整列済み**になります。</li> <li>3 番目の要素を <code>base</code> として選び、正しい位置に挿入すると、**配列の先頭 3 要素が整列済み**になります。</li> <li>このように繰り返し、最後のラウンドで最後の要素を <code>base</code> として選んで正しい位置に挿入すると、**すべての要素が整列済み**になります。</li> </ol> <p></p> <p> 図 11-7   挿入ソートの流れ </p> <p>コード例は以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"挿入ソート\"\"\"\n    # 外側ループ：整列済み区間は [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # nums[j] を 1 つ右へ移動する\n            j -= 1\n        nums[j + 1] = base  # base を正しい位置に配置する\n</code></pre> insertion_sort.cpp<pre><code>/* 挿入ソート */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* 挿入ソート */\nvoid insertionSort(int[] nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base;        // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* 挿入ソート */\nvoid InsertionSort(int[] nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = bas;         // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* 挿入ソート */\nfunc insertionSort(nums []int) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j--\n        }\n        nums[j+1] = base // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* 挿入ソート */\nfunc insertionSort(nums: inout [Int]) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j -= 1\n        }\n        nums[j + 1] = base // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* 挿入ソート */\nfunction insertionSort(nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* 挿入ソート */\nfunction insertionSort(nums: number[]): void {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* 挿入ソート */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // 外側ループ：整列済み区間は [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n      j--;\n    }\n    nums[j + 1] = base; // base を正しい位置に配置する\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* 挿入ソート */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // nums[j] を 1 つ右へ移動する\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* 挿入ソート */\nvoid insertionSort(int nums[], int size) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // nums[j] を 1 つ右へ移動する\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // base を正しい位置に配置する\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* 挿入ソート */\nfun insertionSort(nums: IntArray) {\n    // 外側ループ: ソート済み要素は 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j--\n        }\n        nums[j + 1] = base        // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### 挿入ソート ###\ndef insertion_sort(nums)\n  n = nums.length\n  # 外側ループ：整列済み区間は [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # nums[j] を 1 つ右へ移動する\n      j -= 1\n    end\n    nums[j + 1] = base # base を正しい位置に配置する\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   アルゴリズムの特徴","text":"<ul> <li>計算量は \\(O(n^2)\\)、適応的ソート：最悪の場合、各挿入操作ではそれぞれ \\(n - 1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 回のループが必要であり、合計は \\((n - 1) n / 2\\) となるため、時間計算量は \\(O(n^2)\\) です。データが整列済みであれば、挿入操作は早期に終了します。入力配列が完全に整列済みである場合、挿入ソートは最良の時間計算量 \\(O(n)\\) に達します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>安定ソート：挿入操作の過程では、要素を等しい要素の右側に挿入するため、それらの順序は変化しません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   挿入ソートの利点","text":"<p>挿入ソートの時間計算量は \\(O(n^2)\\) であり、これから学ぶクイックソートの時間計算量は \\(O(n \\log n)\\) です。挿入ソートの時間計算量のほうが大きいにもかかわらず、**データ量が小さい場合には、挿入ソートのほうが通常は高速**です。</p> <p>この結論は、線形探索と二分探索の適用条件に関する結論と似ています。クイックソートのような \\(O(n \\log n)\\) のアルゴリズムは分割統治法に基づくソートアルゴリズムであり、一般により多くの基本演算を含みます。一方、データ量が小さい場合は、\\(n^2\\) と \\(n \\log n\\) の値は比較的近く、計算量が支配的ではなくなり、各ラウンドにおける基本演算の回数が決定的な役割を果たします。</p> <p>実際、多くのプログラミング言語（たとえば Java）の組み込みソート関数では挿入ソートが採用されており、その大まかな考え方は次のとおりです。長い配列にはクイックソートなどの分割統治法に基づくソートアルゴリズムを使い、短い配列には直接挿入ソートを使います。</p> <p>バブルソート、選択ソート、挿入ソートはいずれも時間計算量が \\(O(n^2)\\) ですが、実際には、挿入ソートはバブルソートや選択ソートよりもはるかに高い頻度で使われます。主な理由は次のとおりです。</p> <ul> <li>バブルソートは要素の交換によって実装され、1 つの一時変数を必要とするため、合計で 3 回の基本演算が関わります。これに対して、挿入ソートは要素の代入に基づいており、必要な基本演算は 1 回だけです。したがって、バブルソートの計算コストは通常、挿入ソートより高くなります。</li> <li>選択ソートの時間計算量はどのような場合でも \\(O(n^2)\\) です。**部分的に整列されたデータが与えられた場合、挿入ソートは通常、選択ソートより効率的**です。</li> <li>選択ソートは安定ではないため、多段ソートには適用できません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   マージソート","text":"<p>マージソート（merge sort）は分割統治戦略に基づくソートアルゴリズムであり、以下の図に示す「分割」と「マージ」の段階から構成されます。</p> <ol> <li>分割段階：再帰によって配列を中点で繰り返し分割し、長い配列のソート問題を短い配列のソート問題へ変換します。</li> <li>マージ段階：部分配列の長さが 1 になったら分割を終了し、マージを開始して、左右 2 つの短いソート済み配列をより長いソート済み配列へと繰り返しマージしていきます。</li> </ol> <p></p> <p> 図 11-10   マージソートの分割とマージの段階 </p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   アルゴリズムの流れ","text":"<p>以下の図に示すように、「分割段階」では配列を上から下へ再帰的に中点で 2 つの部分配列へ分割します。</p> <ol> <li>配列の中点 <code>mid</code> を計算し、左部分配列（区間 <code>[left, mid]</code> ）と右部分配列（区間 <code>[mid + 1, right]</code> ）を再帰的に分割します。</li> <li>手順 <code>1.</code> を再帰的に実行し、部分配列区間の長さが 1 になった時点で終了します。</li> </ol> <p>「マージ段階」では左部分配列と右部分配列を下から上へとマージし、1 つのソート済み配列にします。長さ 1 の部分配列からマージを始めるため、この段階の各部分配列はすでに整列されています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-11   マージソートの手順 </p> <p>観察すると、マージソートの再帰順序は二分木の後順走査と一致していることがわかります。</p> <ul> <li>後順走査：まず左部分木を再帰し、次に右部分木を再帰し、最後に根ノードを処理します。</li> <li>マージソート：まず左部分配列を再帰し、次に右部分配列を再帰し、最後にマージを処理します。</li> </ul> <p>マージソートの実装を以下のコードに示します。注意として、<code>nums</code> のマージ対象区間は <code>[left, right]</code> であり、<code>tmp</code> の対応区間は <code>[0, right - left]</code> です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"左部分配列と右部分配列をマージ\"\"\"\n    # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    # マージ結果を格納する一時配列 tmp を作成\n    tmp = [0] * (right - left + 1)\n    # 左右の部分配列の開始インデックスを初期化する\n    i, j, k = left, mid + 1, 0\n    # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"マージソート\"\"\"\n    # 終了条件\n    if left &gt;= right:\n        return  # 部分配列の長さが 1 になったら再帰を終了\n    # 分割フェーズ\n    mid = (left + right) // 2 # 中点を計算\n    merge_sort(nums, left, mid)  # 左部分配列を再帰処理\n    merge_sort(nums, mid + 1, right)  # 右部分配列を再帰処理\n    # マージフェーズ\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    vector&lt;int&gt; tmp(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    mergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int[] tmp = new int[right - left + 1];\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid mergeSort(int[] nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2; // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int[] tmp = new int[right - left + 1];\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid MergeSort(int[] nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right) return;       // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    MergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    MergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* 左部分配列と右部分配列をマージ */\nfunc merge(nums []int, left, mid, right int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    tmp := make([]int, right-left+1)\n    // 左右の部分配列の開始インデックスを初期化する\n    i, j, k := left, mid+1, 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* マージソート */\nfunc mergeSort(nums []int, left, right int) {\n    // 終了条件\n    if left &gt;= right {\n        return\n    }\n    // 分割フェーズ\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // マージフェーズ\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* 左部分配列と右部分配列をマージ */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // 左右の部分配列の開始インデックスを初期化する\n    var i = left, j = mid + 1, k = 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* マージソート */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // 終了条件\n    if left &gt;= right { // 部分配列の長さが 1 になったら再帰を終了\n        return\n    }\n    // 分割フェーズ\n    let mid = left + (right - left) / 2 // 中点を計算\n    mergeSort(nums: &amp;nums, left: left, right: mid) // 左部分配列を再帰処理\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* 左部分配列と右部分配列をマージ */\nfunction merge(nums, left, mid, right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    const tmp = new Array(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfunction mergeSort(nums, left, right) {\n    // 終了条件\n    if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    let mid = Math.floor(left + (right - left) / 2); // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* 左部分配列と右部分配列をマージ */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    const tmp = new Array(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // 終了条件\n    if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    let mid = Math.floor(left + (right - left) / 2); // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n  // マージ結果を格納する一時配列 tmp を作成\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // 左右の部分配列の開始インデックスを初期化する\n  int i = left, j = mid + 1, k = 0;\n  // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // 左右の部分配列の残り要素を一時配列にコピーする\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* マージソート */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // 終了条件\n  if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n  // 分割フェーズ\n  int mid = left + (right - left) ~/ 2; // 中点を計算\n  mergeSort(nums, left, mid); // 左部分配列を再帰処理\n  mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n  // マージフェーズ\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* 左部分配列と右部分配列をマージ */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // 左右の部分配列の開始インデックスを初期化する\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // 終了条件\n    if left &gt;= right {\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    }\n\n    // 分割フェーズ\n    let mid = left + (right - left) / 2; // 中点を計算\n    merge_sort(nums, left, mid); // 左部分配列を再帰処理\n    merge_sort(nums, mid + 1, right); // 右部分配列を再帰処理\n\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(int *nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // メモリを解放する\n    free(tmp);\n}\n\n/* マージソート */\nvoid mergeSort(int *nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    mergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* 左部分配列と右部分配列をマージ */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    val tmp = IntArray(right - left + 1)\n    // 左右の部分配列の開始インデックスを初期化する\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* マージソート */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // 終了条件\n    if (left &gt;= right) return  // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    val mid = left + (right - left) / 2 // 中点を計算\n    mergeSort(nums, left, mid) // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right) // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### 左部分配列と右部分配列をマージ ###\ndef merge(nums, left, mid, right)\n  # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n  # マージ結果を格納する一時配列 tmp を作成\n  tmp = Array.new(right - left + 1, 0)\n  # 左右の部分配列の開始インデックスを初期化する\n  i, j, k = left, mid + 1, 0\n  # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # 左右の部分配列の残り要素を一時配列にコピーする\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### マージソート ###\ndef merge_sort(nums, left, right)\n  # 終了条件\n  # 部分配列の長さが 1 になったら再帰を終了する\n  return if left &gt;= right\n  # 分割フェーズ\n  mid = left + (right - left) / 2 # 中点を計算\n  merge_sort(nums, left, mid) # 左部分配列を再帰処理\n  merge_sort(nums, mid + 1, right) # 右部分配列を再帰処理\n  # マージフェーズ\n  merge(nums, left, mid, right)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応型ソート：分割によって高さ \\(\\log n\\) の再帰木が生成され、各層でのマージ操作の総数は \\(n\\) であるため、全体の時間計算量は \\(O(n \\log n)\\) です。</li> <li>空間計算量は \\(O(n)\\)、インプレースではないソート：再帰の深さは \\(\\log n\\) であり、サイズ \\(O(\\log n)\\) のスタックフレーム領域を使用します。マージ操作は補助配列を用いて実装する必要があり、サイズ \\(O(n)\\) の追加領域を使用します。</li> <li>安定ソート：マージの過程では、等しい要素の順序は変化しません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   連結リストのソート","text":"<p>連結リストに対しては、マージソートは他のソートアルゴリズムと比べて顕著な利点があり、連結リストのソート問題の空間計算量を \\(O(1)\\) まで最適化できます 。</p> <ul> <li>分割段階：連結リストの分割は「再帰」の代わりに「反復」で実装できるため、再帰で使用するスタックフレーム領域を省けます。</li> <li>マージ段階：連結リストでは、ノードの追加や削除は参照（ポインタ）を変更するだけで実現できるため、マージ段階（2 つの短いソート済み連結リストを 1 つの長いソート済み連結リストにマージすること）では追加の連結リストを作成する必要がありません。</li> </ul> <p>具体的な実装の詳細は比較的複雑なので、興味のある読者は関連資料を参照して学習してください。</p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   クイックソート","text":"<p>クイックソート（quick sort）は分割統治戦略に基づくソートアルゴリズムであり、実行効率が高く、広く利用されています。</p> <p>クイックソートの中核操作は「パーティション」であり、その目的は、配列内のある要素を「基準数」として選び、基準数より小さいすべての要素を左側へ、大きい要素を右側へ移動することです。具体的には、パーティションの流れを下図に示します。</p> <ol> <li>配列の最左端の要素を基準数として選び、2 つのポインタ <code>i</code> と <code>j</code> を初期化して、それぞれ配列の両端を指すようにします。</li> <li>ループを設定し、各ラウンドで <code>i</code>（<code>j</code>）を使ってそれぞれ基準数より大きい（小さい）最初の要素を探し、その後この 2 つの要素を交換します。</li> <li><code>i</code> と <code>j</code> が出会うまでステップ <code>2.</code> を繰り返し、最後に基準数を 2 つの部分配列の境界へ交換します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-8   パーティションの手順 </p> <p>パーティションが完了すると、元の配列は左部分配列、基準数、右部分配列の 3 つに分けられ、「左部分配列の任意の要素 \\(\\leq\\) 基準数 \\(\\leq\\) 右部分配列の任意の要素」を満たします。したがって、次はこの 2 つの部分配列だけをソートすれば済みます。</p> <p>クイックソートの分割統治戦略</p> <p>パーティションの本質は、長い配列のソート問題を 2 つの短い配列のソート問題へ簡略化することです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"番兵分割\"\"\"\n    # nums[left] を基準値とする\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 右から左へ基準値未満の最初の要素を探す\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 左から右へ基準値より大きい最初の要素を探す\n        # 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 基準値のインデックスを返す\n</code></pre> quick_sort.cpp<pre><code>/* 番兵分割 */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums[i], nums[j]); // この 2 つの要素を交換\n    }\n    swap(nums[i], nums[left]);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;                   // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.java<pre><code>/* 要素の交換 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint partition(int[] nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.cs<pre><code>/* 要素の交換 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* 番兵分割 */\nint Partition(int[] nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        Swap(nums, i, j); // この 2 つの要素を交換\n    }\n    Swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.go<pre><code>/* 番兵分割 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // nums[left] を基準値とする\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 右から左へ基準値未満の最初の要素を探す\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.swift<pre><code>/* 番兵分割 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swapAt(i, j) // この 2 つの要素を交換\n    }\n    nums.swapAt(i, left) // 基準値を 2 つの部分配列の境界へ交換する\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.js<pre><code>/* 要素の交換 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\npartition(nums, left, right) {\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.ts<pre><code>/* 要素の交換 */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\npartition(nums: number[], left: number, right: number): number {\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.dart<pre><code>/* 要素の交換 */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // nums[left] を基準値とする\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n    _swap(nums, i, j); // この 2 つの要素を交換\n  }\n  _swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n  return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rs<pre><code>/* 番兵分割 */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // nums[left] を基準値とする\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swap(i, j); // この 2 つの要素を交換\n    }\n    nums.swap(i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.c<pre><code>/* 要素の交換 */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint partition(int nums[], int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // この 2 つの要素を交換\n        swap(nums, i, j);\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    swap(nums, i, left);\n    // 基準値のインデックスを返す\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* 要素の交換 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* 番兵分割 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j)  // この 2 つの要素を交換\n    }\n    swap(nums, i, left)   // 基準値を 2 つの部分配列の境界へ交換する\n    return i              // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rb<pre><code>### 番兵分割 ###\ndef partition(nums, left, right)\n  # nums[left] を基準値とする\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   アルゴリズムの流れ","text":"<p>クイックソート全体の流れを下図に示します。</p> <ol> <li>まず、元の配列に対して 1 回「パーティション」を実行し、未ソートの左部分配列と右部分配列を得ます。</li> <li>次に、左部分配列と右部分配列に対してそれぞれ再帰的に「パーティション」を実行します。</li> <li>部分配列の長さが 1 になるまで再帰を続け、配列全体のソートを完了します。</li> </ol> <p></p> <p> 図 11-9   クイックソートの流れ </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"クイックソート\"\"\"\n    # 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right:\n        return\n    # 番兵分割\n    pivot = self.partition(nums, left, right)\n    # 左右の部分配列を再帰処理\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* クイックソート */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* クイックソート */\nvoid quickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* クイックソート */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = Partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* クイックソート */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return\n    }\n    // 番兵分割\n    pivot := q.partition(nums, left, right)\n    // 左右の部分配列を再帰処理\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* クイックソート */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return\n    }\n    // 番兵分割\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // 左右の部分配列を再帰処理\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* クイックソート */\nquickSort(nums, left, right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) return;\n    // 番兵分割\n    const pivot = this.partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* クイックソート */\nquickSort(nums: number[], left: number, right: number): void {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) {\n        return;\n    }\n    // 番兵分割\n    const pivot = this.partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* クイックソート */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 部分配列の長さが 1 なら再帰を終了する\n  if (left &gt;= right) return;\n  // 番兵分割\n  int pivot = _partition(nums, left, right);\n  // 左右の部分配列を再帰処理\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* クイックソート */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return;\n    }\n    // 番兵分割\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // 左右の部分配列を再帰処理\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* クイックソート */\nvoid quickSort(int nums[], int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) {\n        return;\n    }\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* クイックソート */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) return\n    // 番兵分割\n    val pivot = partition(nums, left, right)\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### クイックソートクラス ###\ndef quick_sort(nums, left, right)\n  # 部分配列の長さが 1 でない場合は再帰する\n  if left &lt; right\n    # 番兵分割\n    pivot = partition(nums, left, right)\n    # 左右の部分配列を再帰処理\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応型ソート：平均的な場合、パーティションの再帰の深さは \\(\\log n\\) で、各層の総ループ回数は \\(n\\) のため、全体で \\(O(n \\log n)\\) 時間を要します。最悪の場合、各回のパーティション操作で長さ \\(n\\) の配列が長さ \\(0\\) と \\(n - 1\\) の 2 つの部分配列に分割され、このとき再帰の深さは \\(n\\) に達し、各層のループ回数は \\(n\\) となるため、全体で \\(O(n^2)\\) 時間を要します。</li> <li>空間計算量は \\(O(n)\\)、インプレースソート：入力配列が完全な逆順の場合、最悪の再帰深さ \\(n\\) に達し、\\(O(n)\\) のスタックフレーム空間を使用します。ソート操作は元の配列上で行われ、追加の配列は用いません。</li> <li>非安定ソート：パーティションの最後のステップで、基準数が等しい要素の右側へ交換される可能性があります。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   クイックソートが速い理由","text":"<p>名前からも分かるように、クイックソートは効率面で一定の優位性を持っています。クイックソートの平均時間計算量は「マージソート」や「ヒープソート」と同じですが、通常はクイックソートのほうが高効率であり、主な理由は次のとおりです。</p> <ul> <li>最悪ケースが起こる確率が低い：クイックソートの最悪時間計算量は \\(O(n^2)\\) で、「マージソート」ほど安定ではありませんが、大半のケースでは \\(O(n \\log n)\\) の時間計算量で動作します。</li> <li>キャッシュ利用効率が高い：パーティション操作の実行時には、システムが部分配列全体をキャッシュに読み込めるため、要素アクセスの効率が高くなります。一方、「ヒープソート」のようなアルゴリズムは要素へ飛び飛びにアクセスする必要があり、この性質を持ちません。</li> <li>計算量の定数係数が小さい：上記 3 つのアルゴリズムの中で、クイックソートは比較、代入、交換などの操作総数が最も少なくなります。これは「挿入ソート」が「バブルソート」より速い理由と似ています。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   基準数の最適化","text":"<p>クイックソートは、入力によっては時間効率が低下する可能性があります。極端な例として、入力配列が完全な逆順であるとします。最左端の要素を基準数として選ぶため、パーティション完了後には基準数が配列の最右端へ交換され、左部分配列の長さが \\(n - 1\\)、右部分配列の長さが \\(0\\) になります。この再帰を続けると、各回のパーティション後に必ず一方の部分配列の長さが \\(0\\) となり、分割統治戦略が機能せず、クイックソートは「バブルソート」に近い形へ退化します。</p> <p>この状況をできるだけ避けるため、パーティションにおける基準数の選び方を最適化できます。たとえば、ランダムに 1 つの要素を選んで基準数にできます。しかし、運が悪く毎回望ましくない基準数を選んでしまうと、効率は依然として十分ではありません。</p> <p>注意すべき点として、プログラミング言語が通常生成するのは「疑似乱数」です。疑似乱数列に合わせて特定のテストケースを構築すると、クイックソートの効率はやはり劣化する可能性があります。</p> <p>さらに改善するために、配列から 3 つの候補要素（通常は先頭、末尾、中間の要素）を選び、**その 3 つの候補要素の中央値を基準数とする**ことができます。こうすると、基準数が「小さすぎず大きすぎもしない」確率が大幅に上がります。もちろん、候補要素をさらに増やして、アルゴリズムの頑健性をいっそう高めることも可能です。この方法を採用すると、時間計算量が \\(O(n^2)\\) まで劣化する確率は大きく下がります。</p> <p>コード例を以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"3つの候補要素の中央値を選ぶ\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m は l と r の間\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l は m と r の間\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"番兵による分割処理（3 点中央値）\"\"\"\n    # nums[left] を基準値とする\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # 中央値を配列の最左端に交換する\n    nums[left], nums[med] = nums[med], nums[left]\n    # nums[left] を基準値とする\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 右から左へ基準値未満の最初の要素を探す\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 左から右へ基準値より大きい最初の要素を探す\n        # 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 基準値のインデックスを返す\n</code></pre> quick_sort.cpp<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums[left], nums[med]);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums[i], nums[j]); // この 2 つの要素を交換\n    }\n    swap(nums[i], nums[left]);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;                   // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.java<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partition(int[] nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.cs<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint Partition(int[] nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    Swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        Swap(nums, i, j); // この 2 つの要素を交換\n    }\n    Swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.go<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l は m と r の間\n    }\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // nums[left] を基準値とする\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // 中央値を配列の最左端に交換する\n    nums[left], nums[med] = nums[med], nums[left]\n    // nums[left] を基準値とする\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 右から左へ基準値未満の最初の要素を探す\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.swift<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l は m と r の間\n    }\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 3つの候補要素の中央値を選ぶ\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // 中央値を配列の最左端に交換する\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 3つの候補要素の中央値を選ぶ */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m は l と r の間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l は m と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\npartition(nums, left, right) {\n    // 3つの候補要素の中央値を選ぶ\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 中央値を配列の最左端に交換する\n    this.swap(nums, left, med);\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.ts<pre><code>/* 3つの候補要素の中央値を選ぶ */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m は l と r の間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l は m と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\npartition(nums: number[], left: number, right: number): number {\n    // 3つの候補要素の中央値を選ぶ\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 中央値を配列の最左端に交換する\n    this.swap(nums, left, med);\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.dart<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m は l と r の間\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l は m と r の間\n  return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 3つの候補要素の中央値を選ぶ\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // 中央値を配列の最左端に交換する\n  _swap(nums, left, med);\n  // nums[left] を基準値とする\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n    _swap(nums, i, j); // この 2 つの要素を交換\n  }\n  _swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n  return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rs<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l は m と r の間\n    }\n    right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 3つの候補要素の中央値を選ぶ\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    nums.swap(left, med);\n    // nums[left] を基準値とする\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swap(i, j); // この 2 つの要素を交換\n    }\n    nums.swap(i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.c<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partitionMedian(int nums[], int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i;            // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.kt<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m は l と r の間\n    if ((l in m..r) || (l in r..m))\n        return left // l は m と r の間\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // 3つの候補要素の中央値を選ぶ\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med)\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j)             // この 2 つの要素を交換\n    }\n    swap(nums, i, left)              // 基準値を 2 つの部分配列の境界へ交換する\n    return i                         // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rb<pre><code>### 3 つの候補要素の中央値を選ぶ ###\ndef median_three(nums, left, mid, right)\n  # 3つの候補要素の中央値を選ぶ\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m は l と r の間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l は m と r の間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### 3 つの候補要素の中央値を選ぶ ###\ndef median_three(nums, left, mid, right)\n  # 3つの候補要素の中央値を選ぶ\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m は l と r の間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l は m と r の間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n# ## 番兵分割（三数中央値）###\ndef partition(nums, left, right)\n  # ## nums[left] を基準値とする\n  med = median_three(nums, left, (left + right) / 2, right)\n  # 中央値を配列の最左端に交換する\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   再帰の深さの最適化","text":"<p>一部の入力では、クイックソートは多くの空間を消費する可能性があります。完全に整列済みの入力配列を例にとり、再帰中の部分配列の長さを \\(m\\) とします。各回のパーティション操作では長さ \\(0\\) の左部分配列と長さ \\(m - 1\\) の右部分配列が生成されます。これは、各再帰呼び出しで減る問題サイズが非常に小さいこと（要素が 1 つ減るだけ）を意味し、再帰木の高さは \\(n - 1\\) に達するため、このとき \\(O(n)\\) のスタックフレーム空間を占有します。</p> <p>スタックフレーム空間の蓄積を防ぐために、各回のパーティション完了後に 2 つの部分配列の長さを比較し、**短いほうの部分配列に対してのみ再帰**を行えます。短い部分配列の長さは \\(n / 2\\) を超えないため、この方法なら再帰の深さを \\(\\log n\\) 以下に抑えられ、最悪時の空間計算量を \\(O(\\log n)\\) まで最適化できます。コードを以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"クイックソート（再帰深度最適化）\"\"\"\n    # 部分配列の長さが 1 なら終了\n    while left &lt; right:\n        # 番兵による分割処理\n        pivot = self.partition(nums, left, right)\n        # 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # 左部分配列を再帰的にソート\n            left = pivot + 1  # 未ソート区間の残りは [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # 右部分配列を再帰的にソート\n            right = pivot - 1  # 未ソート区間の残りは [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1;                 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1;                 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* クイックソート（再帰深度最適化） */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = Partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // 左部分配列を再帰的にソート\n            left = pivot + 1;  // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* クイックソート（再帰深度最適化） */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // 部分配列の長さが 1 なら終了\n    for left &lt; right {\n        // 番兵による分割処理\n        pivot := q.partition(nums, left, right)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // 左部分配列を再帰的にソート\n            left = pivot + 1                 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // 右部分配列を再帰的にソート\n            right = pivot - 1                 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* クイックソート（再帰深度最適化） */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // 部分配列の長さが 1 なら終了\n    while left &lt; right {\n        // 番兵による分割処理\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // 左部分配列を再帰的にソート\n            left = pivot + 1 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // 右部分配列を再帰的にソート\n            right = pivot - 1 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* クイックソート（再帰深度最適化） */\nquickSort(nums, left, right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        let pivot = this.partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* クイックソート（再帰深度最適化） */\nquickSort(nums: number[], left: number, right: number): void {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        let pivot = this.partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 部分配列の長さが 1 なら終了\n  while (left &lt; right) {\n    // 番兵による分割処理\n    int pivot = _partition(nums, left, right);\n    // 2 つの部分配列のうち短いほうにクイックソートを適用する\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n      left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n      right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* クイックソート（再帰深度最適化） */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // 部分配列の長さが 1 なら終了\n    while left &lt; right {\n        // 番兵による分割処理\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            // 左部分配列を再帰的にソート\n            quickSortTailCall(nums, left, pivot - 1);\n            // 未ソート区間の残りは [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // 右部分配列を再帰的にソート\n            quickSortTailCall(nums, pivot + 1, right);\n            // 未ソート区間の残りは [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* クイックソート（再帰深度最適化） */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // 部分配列の長さが 1 なら終了\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // 番兵による分割処理\n        val pivot = partition(nums, l, r)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // 左部分配列を再帰的にソート\n            l = pivot + 1 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // 右部分配列を再帰的にソート\n            r = pivot - 1 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### 番兵分割 ###\ndef partition(nums, left, right)\n  # nums[left] を基準値とする\n  i = left\n  j = right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n\n# ## クイックソート（再帰深度最適化）###\ndef quick_sort(nums, left, right)\n  # 部分配列の長さが 1 でない場合は再帰する\n  while left &lt; right\n    # 番兵分割\n    pivot = partition(nums, left, right)\n    # 2 つの部分配列のうち短いほうにクイックソートを適用する\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # 未ソート区間の残りは [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # 未ソート区間の残りは [left, pivot - 1]\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   基数ソート","text":"<p>前節では計数ソートを紹介しました。これは、データ量 \\(n\\) が大きく、データ範囲 \\(m\\) が小さい場合に適しています。\\(n = 10^6\\) 個の学籍番号をソートすると仮定すると、学籍番号は \\(8\\) 桁の数字なので、データ範囲 \\(m = 10^8\\) は非常に大きくなります。計数ソートでは大量のメモリ空間を確保する必要がありますが、基数ソートではこの問題を回避できます。</p> <p>基数ソート（radix sort）の基本的な考え方は計数ソートと同じで、個数を数えることによってソートを実現します。そのうえで、基数ソートは各桁の段階的な関係を利用し、各桁を順にソートすることで、最終的なソート結果を得ます。</p>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   アルゴリズムの流れ","text":"<p>学籍番号データを例にすると、数字の最下位桁を第 \\(1\\) 位、最上位桁を第 \\(8\\) 位としたとき、基数ソートの流れは次図のようになります。</p> <ol> <li>桁番号 \\(k = 1\\) を初期化します。</li> <li>学籍番号の第 \\(k\\) 位に対して「計数ソート」を実行します。完了すると、データは第 \\(k\\) 位に従って昇順に並びます。</li> <li>\\(k\\) を \\(1\\) 増やし、手順 <code>2.</code> に戻って反復を続けます。すべての桁のソートが完了したら終了します。</li> </ol> <p></p> <p> 図 11-18   基数ソートのアルゴリズムの流れ </p> <p>以下ではコード実装を分解して見ていきます。\\(d\\) 進数の数値 \\(x\\) について、その第 \\(k\\) 位 \\(x_k\\) を取得するには、次の計算式を用います。</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>ここで、\\(\\lfloor a \\rfloor\\) は浮動小数点数 \\(a\\) の切り捨てを表し、\\(\\bmod \\: d\\) は \\(d\\) による剰余を表します。学籍番号データでは、\\(d = 10\\) かつ \\(k \\in [1, 8]\\) です。</p> <p>さらに、数字の第 \\(k\\) 位に基づいてソートできるように、計数ソートのコードを少し変更する必要があります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"要素 num の下から k 桁目を取得（exp = 10^(k-1)）\"\"\"\n    # ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"計数ソート（nums の k 桁目でソート）\"\"\"\n    # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    counter = [0] * 10\n    n = len(nums)\n    # 0~9 の各数字の出現回数を集計する\n    for i in range(n):\n        d = digit(nums[i], exp)  # nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1  # 数字 d の出現回数を数える\n    # 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # d の配列内インデックス j を取得する\n        res[j] = nums[i]  # 現在の要素をインデックス j に格納する\n        counter[d] -= 1  # d の個数を 1 減らす\n    # 結果で元の配列 nums を上書きする\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"基数ソート\"\"\"\n    # 最大桁数の判定用に配列の最大要素を取得\n    m = max(nums)\n    # 下位桁から上位桁の順に走査する\n    exp = 1\n    while exp &lt;= m:\n        # 配列要素の k 桁目に対して計数ソートを行う\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # つまり exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = *max_element(nums.begin(), nums.end());\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(int[] nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int[] counter = new int[10];\n    int n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(int[] nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint Digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nvoid RadixSort(int[] nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunc digit(num, exp int) int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunc countingSortDigit(nums []int, exp int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    counter := make([]int, 10)\n    n := len(nums)\n    // 0~9 の各数字の出現回数を集計する\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d]++             // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i]    // 現在の要素をインデックス j に格納する\n        counter[d]--        // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* 基数ソート */\nfunc radixSort(nums []int) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    var counter = Array(repeating: 0, count: 10)\n    // 0~9 の各数字の出現回数を集計する\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1 // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i] // 現在の要素をインデックス j に格納する\n        counter[d] -= 1 // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* 基数ソート */\nfunc radixSort(nums: inout [Int]) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunction digit(num, exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunction countingSortDigit(nums, exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d]--; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nfunction radixSort(nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m = Math.max(... nums);\n    // 下位桁から上位桁の順に走査する\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunction digit(num: number, exp: number): number {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d]--; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nfunction radixSort(nums: number[]): void {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m: number = Math.max(... nums);\n    // 下位桁から上位桁の順に走査する\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* 要素 `_num` の第 k 桁を取得する。ここで `exp = 10^(k-1)` */\nint digit(int _num, int exp) {\n  // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n  return (_num ~/ exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // 0~9 の各数字の出現回数を集計する\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n    counter[d]++; // 数字 d の出現回数を数える\n  }\n  // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // d の配列内インデックス j を取得する\n    res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n    counter[d]--; // d の個数を 1 減らす\n  }\n  // 結果で元の配列 nums を上書きする\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(List&lt;int&gt; nums) {\n  // 最大桁数の判定用に配列の最大要素を取得する\n  // dart の `int` の長さは 64 ビット\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // 下位桁から上位桁の順に走査する\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // 配列要素の k 桁目に対して計数ソートを行う\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // つまり exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return ((num / exp) % 10) as usize;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // 0~9 の各数字の出現回数を集計する\n    for i in 0..n {\n        let d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d] -= 1; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    nums.copy_from_slice(&amp;res);\n}\n\n/* 基数ソート */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m = *nums.into_iter().max().unwrap();\n    // 下位桁から上位桁の順に走査する\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // 後続のメモリ解放に備えて 0 で初期化する\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; size; i++) {\n        // nums[i] の第 k 位を取得し、d とする\n        int d = digit(nums[i], exp);\n        // 数字 d の出現回数を数える\n        counter[d]++;\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // メモリを解放する\n    free(res);\n    free(counter);\n}\n\n/* 基数ソート */\nvoid radixSort(int nums[], int size) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfun digit(num: Int, exp: Int): Int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    val counter = IntArray(10)\n    val n = nums.size\n    // 0~9 の各数字の出現回数を集計する\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d]++                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i]       // 現在の要素をインデックス j に格納する\n        counter[d]--           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* 基数ソート */\nfun radixSort(nums: IntArray) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // 下位桁から上位桁の順に走査する\n    while (exp &lt;= m) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### num の第 k 桁を取得する。ここで exp = 10^(k-1) ###\ndef digit(num, exp)\n  # k ではなく exp を渡すことで、ここで高コストな累乗計算を繰り返し実行するのを避けられる\n  (num / exp) % 10\nend\n\n### num の第 k 桁を取得する。ここで exp = 10^(k-1) ###\ndef digit(num, exp)\n  # k ではなく exp を渡すことで、ここで高コストな累乗計算を繰り返し実行するのを避けられる\n  (num / exp) % 10\nend\n\n# ## 計数ソート（nums の k 桁目でソート）###\ndef counting_sort_digit(nums, exp)\n  # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n  counter = Array.new(10, 0)\n  n = nums.length\n  # 0~9 の各数字の出現回数を集計する\n  for i in 0...n\n    d = digit(nums[i], exp) # nums[i] の第 k 位を取得し、d とする\n    counter[d] += 1 # 数字 d の出現回数を数える\n  end\n  # 累積和を求め、「出現回数」を「配列インデックス」に変換する\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # d の配列内インデックス j を取得する\n    res[j] = nums[i] # 現在の要素をインデックス j に格納する\n    counter[d] -= 1 # d の個数を 1 減らす\n  end\n  # 結果で元の配列 nums を上書きする\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### 基数ソート ###\ndef radix_sort(nums)\n  # 最大桁数の判定用に配列の最大要素を取得\n  m = nums.max\n  # 下位桁から上位桁の順に走査する\n  exp = 1\n  while exp &lt;= m\n    # 配列要素の k 桁目に対して計数ソートを行う\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # つまり exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>なぜ最下位桁からソートするのですか？</p> <p>連続するソートの各ラウンドでは、後のラウンドの結果が前のラウンドの結果を上書きします。たとえば、第1ラウンドで \\(a &lt; b\\) となっていても、第2ラウンドで \\(a &gt; b\\) となれば、第2ラウンドの結果が優先されます。数字では高位の優先度が低位より高いため、先に低位をソートし、その後で高位をソートする必要があります。</p>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   アルゴリズムの特徴","text":"<p>計数ソートと比べると、基数ソートは値の範囲が大きい場合に適しています。ただし、データが固定桁数の形式で表せること、かつ桁数が大きすぎないことが前提です。たとえば、浮動小数点数は基数ソートに適していません。桁数 \\(k\\) が大きすぎて、時間計算量が \\(O(nk) \\gg O(n^2)\\) になる可能性があるためです。</p> <ul> <li>時間計算量は \\(O(nk)\\)、非適応ソート：データ量を \\(n\\)、データが \\(d\\) 進数、最大桁数を \\(k\\) とすると、ある1桁に対して計数ソートを実行する時間は \\(O(n + d)\\) であり、全 \\(k\\) 桁をソートする時間は \\(O((n + d)k)\\) です。通常、\\(d\\) と \\(k\\) はどちらも比較的小さいため、時間計算量は \\(O(n)\\) に近づきます。</li> <li>空間計算量は \\(O(n + d)\\)、非原地ソート：計数ソートと同様に、基数ソートでは長さ \\(n\\) と \\(d\\) の配列 <code>res</code> と <code>counter</code> を補助的に用います。</li> <li>安定ソート：計数ソートが安定であれば基数ソートも安定です。計数ソートが不安定な場合、基数ソートでは正しいソート結果を保証できません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   選択ソート","text":"<p>選択ソート（selection sort）の仕組みは非常に単純です。ループを開始し、各ラウンドで未ソート区間から最小の要素を選び、整列済み区間の末尾に配置します。</p> <p>配列の長さを \\(n\\) とすると、選択ソートの手順は次の図のようになります。</p> <ol> <li>初期状態では、すべての要素が未ソートであり、未ソートな（インデックス）区間は \\([0, n-1]\\) です。</li> <li>区間 \\([0, n-1]\\) 内の最小要素を選び、インデックス \\(0\\) の要素と交換します。これにより、配列の先頭 1 要素が整列済みになります。</li> <li>区間 \\([1, n-1]\\) 内の最小要素を選び、インデックス \\(1\\) の要素と交換します。これにより、配列の先頭 2 要素が整列済みになります。</li> <li>これを繰り返します。\\(n - 1\\) 回の選択と交換を経ると、配列の先頭 \\(n - 1\\) 要素が整列済みになります。</li> <li>残った 1 つの要素は必ず最大要素なので、ソートは不要です。これで配列のソートは完了します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-2   選択ソートの手順 </p> <p>コードでは、\\(k\\) を用いて未ソート区間内の最小要素を記録します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"選択ソート\"\"\"\n    n = len(nums)\n    # 外側ループ：未整列区間は [i, n-1]\n    for i in range(n - 1):\n        # 内側のループ：未ソート区間の最小要素を見つける\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # 最小要素のインデックスを記録\n        # その最小要素を未整列区間の先頭要素と交換する\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* 選択ソート */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* 選択ソート */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* 選択ソート */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* 選択ソート */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // 外側ループ：未整列区間は [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // 最小要素のインデックスを記録\n                k = j\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* 選択ソート */\nfunc selectionSort(nums: inout [Int]) {\n    // 外側ループ：未整列区間は [i, n-1]\n    for i in nums.indices.dropLast() {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* 選択ソート */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* 選択ソート */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* 選択ソート */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // 外側ループ：未整列区間は [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // 内側のループ：未ソート区間の最小要素を見つける\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // 最小要素のインデックスを記録\n    }\n    // その最小要素を未整列区間の先頭要素と交換する\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* 選択ソート */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // 外側ループ：未整列区間は [i, n-1]\n    for i in 0..n - 1 {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* 選択ソート */\nvoid selectionSort(int nums[], int n) {\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* 選択ソート */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // 外側ループ：未整列区間は [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // 内側のループ：未ソート区間の最小要素を見つける\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### 選択ソート ###\ndef selection_sort(nums)\n  n = nums.length\n  # 外側ループ：未整列区間は [i, n-1]\n  for i in 0...(n - 1)\n    # 内側のループ：未ソート区間の最小要素を見つける\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # 最小要素のインデックスを記録\n      end\n    end\n    # その最小要素を未整列区間の先頭要素と交換する\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.2 &nbsp; 選択ソート"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   アルゴリズムの特徴","text":"<ul> <li>時間計算量は \\(O(n^2)\\)、非適応ソート：外側のループは合計 \\(n - 1\\) 回です。最初のラウンドの未ソート区間の長さは \\(n\\)、最後のラウンドでは \\(2\\) であり、各ラウンドの内側のループ回数はそれぞれ \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(3\\)、\\(2\\) となります。総和は \\(\\frac{(n - 1)(n + 2)}{2}\\) です。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>不安定ソート：次の図のように、要素 <code>nums[i]</code> がそれと等しい要素の右側へ交換され、両者の相対的な順序が変わる可能性があります。</li> </ul> <p> 図 11-3   選択ソートの不安定な例 </p>","path":["第 11 章 &nbsp; ソート","11.2 &nbsp; 選択ソート"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   ソートアルゴリズム","text":"<p>ソートアルゴリズム（sorting algorithm）は、データの集合を特定の順序に従って並べ替えるために用いられます。ソートアルゴリズムは幅広く応用されており、整列済みデータは通常、より効率的に検索、分析、処理できるためです。</p> <p>下図に示すように、ソートアルゴリズムにおけるデータ型は整数、浮動小数点数、文字、文字列などです。ソートの判定規則は、数値の大小、文字の ASCII コード順、またはカスタムルールなど、要件に応じて設定できます。</p> <p></p> <p> 図 11-1   データ型と判定規則の例 </p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   評価軸","text":"<p>実行効率：ソートアルゴリズムの時間計算量はできるだけ低く、かつ全体の操作回数も少ないこと（時間計算量における定数項が小さいこと）が望まれます。大量データの場合、実行効率はとりわけ重要です。</p> <p>インプレース性：その名のとおり、インプレースソートは元の配列を直接操作して並べ替えを行うため、追加の補助配列を必要とせず、メモリを節約できます。通常、インプレースソートはデータの移動操作が少なく、実行速度もより高速です。</p> <p>安定性：安定ソートは、並べ替え完了後も、等しい要素の配列内での相対順序が変化しません。</p> <p>安定ソートは多段ソートの場面で必要条件となります。学生情報を保存した表があり、第 1 列と第 2 列がそれぞれ氏名と年齢であると仮定します。この場合、不安定ソートによって入力データの順序性が失われる可能性があります。</p> <pre><code># 入力データは氏名順にソートされている\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# 不安定ソートアルゴリズムで年齢順にリストを並べ替えると仮定すると、\n# 結果では ('D', 19) と ('A', 19) の相対位置が変わり、\n# 入力データが氏名順である性質が失われる\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>適応性：適応的ソートは、入力データに既に存在する順序情報を利用して計算量を減らし、より優れた時間効率を実現できます。適応的ソートアルゴリズムの最良時間計算量は、通常、平均時間計算量より優れています。</p> <p>比較ベースかどうか：比較ベースのソートは、比較演算子（\\(&lt;\\)、\\(=\\)、\\(&gt;\\)）に依存して要素の相対順序を判定し、それによって配列全体をソートします。理論上の最良時間計算量は \\(O(n \\log n)\\) です。一方、非比較ソートは比較演算子を使用せず、時間計算量は \\(O(n)\\) に達しますが、汎用性は相対的に低くなります。</p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   理想的なソートアルゴリズム","text":"<p>高速、インプレース、安定、適応的、高い汎用性。明らかに、これまでのところ、以上のすべての特性を兼ね備えたソートアルゴリズムはまだ見つかっていません。そのため、ソートアルゴリズムを選択する際には、具体的なデータの特徴と問題の要件に応じて判断する必要があります。</p> <p>次に、さまざまなソートアルゴリズムを一緒に学び、上記の評価軸に基づいて各ソートアルゴリズムの長所と短所を分析していきます。</p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   まとめ","text":"","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>バブルソートは隣接する要素を交換することで整列を行います。フラグを追加して早期リターンを可能にすると、バブルソートの最良時間計算量を \\(O(n)\\) に最適化できます。</li> <li>挿入ソートは各ラウンドで未整列区間の要素を整列済み区間の正しい位置に挿入することで整列を完了します。挿入ソートの時間計算量は \\(O(n^2)\\) ですが、基本操作が比較的少ないため、小規模データのソート処理で非常に人気があります。</li> <li>クイックソートは番兵分割操作に基づいて整列を行います。番兵分割では毎回最悪の基準値を選んでしまう可能性があり、その結果、時間計算量は \\(O(n^2)\\) まで劣化することがあります。中央値の基準値やランダムな基準値を導入すると、この劣化の確率を下げられます。短い部分配列を優先して再帰すれば、再帰の深さを効果的に抑え、空間計算量を \\(O(\\log n)\\) に最適化できます。</li> <li>マージソートは分割とマージという 2 つの段階からなり、分割統治戦略を典型的に体現しています。マージソートでは配列を整列する際に補助配列の作成が必要で、空間計算量は \\(O(n)\\) です。一方、連結リストを整列する場合の空間計算量は \\(O(1)\\) まで最適化できます。</li> <li>バケットソートはデータのバケット分配、バケット内ソート、結果の結合という 3 つの手順を含みます。これも分割統治戦略を体現しており、データ量が非常に大きい場合に適しています。バケットソートの鍵は、データを平均的に分配することにあります。</li> <li>カウントソートはバケットソートの特例であり、データの出現回数を数えることで整列を行います。カウントソートはデータ量が大きく、かつデータ範囲が限られている場合に適しており、データを正の整数に変換できることが前提です。</li> <li>基数ソートは各桁ごとの整列によってデータを整列し、データが固定桁数の数値として表せることを前提とします。</li> <li>総じて言えば、私たちは高効率で、安定で、インプレースで、さらに適応的であるといった利点を備えたソートアルゴリズムを見つけたいと考えます。しかし、ほかのデータ構造やアルゴリズムと同様に、これらすべての条件を同時に満たせるソートアルゴリズムは存在しません。実際の応用では、データの特性に応じて適切なソートアルゴリズムを選ぶ必要があります。</li> <li>下図では、主流のソートアルゴリズムについて、効率、安定性、インプレース性、適応性などを比較しています。</li> </ul> <p> 図 11-19   ソートアルゴリズムの比較 </p>","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ソートアルゴリズムの安定性は、どのような場合に必須ですか？</p> <p>現実には、オブジェクトのある属性に基づいて整列することがあります。たとえば、学生には氏名と身長という 2 つの属性があり、多段階のソートを行いたいとします。まず氏名で整列して <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> を得て、その後に身長で整列します。ソートアルゴリズムが不安定である場合、結果は <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> になる可能性があります。</p> <p>このように、学生 D と C の位置が入れ替わり、氏名に関する順序性が壊れてしまいます。これは望ましくありません。</p> <p>Q：番兵分割において、「右から左へ探索する」順序と「左から右へ探索する」順序は入れ替えられますか？</p> <p>できません。最も左端の要素を基準値とする場合は、必ず先に「右から左へ探索する」を行い、その後に「左から右へ探索する」を行う必要があります。この結論はやや直感に反するので、理由を分析してみましょう。</p> <p>番兵分割 <code>partition()</code> の最後の手順は、<code>nums[left]</code> と <code>nums[i]</code> を交換することです。交換が終わると、基準値の左側にある要素はすべて基準値 <code>&lt;=</code> になります。したがって、最後の交換の前に <code>nums[left] &gt;= nums[i]</code> が必ず成り立っていなければなりません。仮に先に「左から右へ探索する」を行うと、基準値より大きい要素が見つからない場合、<code>i == j</code> の時点でループを抜け、このとき <code>nums[j] == nums[i] &gt; nums[left]</code> となる可能性があります。つまり、この最後の交換によって、基準値より大きい要素が配列の最左端へ移されてしまい、番兵分割は失敗します。</p> <p>たとえば、配列 <code>[0, 0, 0, 0, 1]</code> が与えられたとき、先に「左から右へ探索する」を行うと、番兵分割後の配列は <code>[1, 0, 0, 0, 0]</code> になります。これは誤った結果です。</p> <p>さらに考えると、<code>nums[right]</code> を基準値に選ぶ場合はちょうど逆になり、必ず先に「左から右へ探索する」を行う必要があります。</p> <p>Q：クイックソートの再帰深度最適化について、短い配列を選ぶとなぜ再帰深度が \\(\\log n\\) を超えないと保証できるのですか？</p> <p>再帰深度とは、現在まだ戻っていない再帰呼び出しの数のことです。各ラウンドの番兵分割では、元の配列を 2 つの部分配列に分けます。再帰深度の最適化後は、下方向に再帰する部分配列の長さは最大でも元の配列長の半分です。最悪の場合でも毎回半分の長さになると仮定すれば、最終的な再帰深度は \\(\\log n\\) になります。</p> <p>元のクイックソートを振り返ると、長いほうの配列に対して連続して再帰してしまう可能性があり、最悪の場合は \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) と続き、再帰深度は \\(n\\) になります。再帰深度の最適化により、このような状況を避けられます。</p> <p>Q：配列内のすべての要素が等しい場合、クイックソートの時間計算量は \\(O(n^2)\\) になりますか？このような退化はどう処理すべきですか？</p> <p>はい。この場合は、番兵分割によって配列を「基準値より小さい」「基準値に等しい」「基準値より大きい」の 3 つの部分に分ける方法を検討できます。下方向に再帰するのは、小さい部分と大きい部分だけです。この方法では、入力要素がすべて等しい配列は、1 回の番兵分割だけで整列を完了できます。</p> <p>Q：バケットソートの最悪時間計算量が \\(O(n^2)\\) なのはなぜですか？</p> <p>最悪の場合、すべての要素が同じバケットに振り分けられます。その要素群を整列するのに \\(O(n^2)\\) のアルゴリズムを使えば、時間計算量は \\(O(n^2)\\) になります。</p>","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"第 5 章   スタックとキュー","text":"<p>Abstract</p> <p>スタックは猫を積み重ねるようなもので、キューは猫が列に並ぶようなものです。</p> <p>両者はそれぞれ、後入れ先出しと先入れ先出しの論理関係を表します。</p>","path":["第 5 章 &nbsp; スタックとキュー"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"章の内容","text":"<ul> <li>5.1   スタック</li> <li>5.2   キュー</li> <li>5.3   両端キュー</li> <li>5.4   まとめ</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   両端キュー","text":"<p>キューでは、先頭要素を削除するか末尾に要素を追加することしかできません。次の図に示すように、両端キュー（double-ended queue）はより高い柔軟性を備えており、先頭と末尾の両方で要素の追加や削除を行えます。</p> <p></p> <p> 図 5-7   両端キューの操作 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   両端キューの基本操作","text":"<p>両端キューの基本操作を次の表に示します。具体的なメソッド名は、使用するプログラミング言語によって異なります。</p> <p> 表 5-3   両端キューの操作効率 </p> メソッド名 説明 時間計算量 <code>push_first()</code> 先頭に要素を追加 \\(O(1)\\) <code>push_last()</code> 末尾に要素を追加 \\(O(1)\\) <code>pop_first()</code> 先頭要素を削除 \\(O(1)\\) <code>pop_last()</code> 末尾要素を削除 \\(O(1)\\) <code>peek_first()</code> 先頭要素にアクセス \\(O(1)\\) <code>peek_last()</code> 末尾要素にアクセス \\(O(1)\\) <p>同様に、プログラミング言語に組み込み実装されている両端キューのクラスを直接使うこともできます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# 両端キューを初期化\ndeq: deque[int] = deque()\n\n# 要素をエンキュー\ndeq.append(2)      # 末尾に追加\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # 先頭に追加\ndeq.appendleft(1)\n\n# 要素にアクセス\nfront: int = deq[0]  # 先頭要素\nrear: int = deq[-1]  # 末尾要素\n\n# 要素をデキュー\npop_front: int = deq.popleft()  # 先頭要素をデキュー\npop_rear: int = deq.pop()       # 末尾要素をデキュー\n\n# 両端キューの長さを取得\nsize: int = len(deq)\n\n# 両端キューが空かどうかを判定\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* 両端キューを初期化 */\ndeque&lt;int&gt; deque;\n\n/* 要素をエンキュー */\ndeque.push_back(2);   // 末尾に追加\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // 先頭に追加\ndeque.push_front(1);\n\n/* 要素にアクセス */\nint front = deque.front(); // 先頭要素\nint back = deque.back();   // 末尾要素\n\n/* 要素をデキュー */\ndeque.pop_front();  // 先頭要素をデキュー\ndeque.pop_back();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.size();\n\n/* 両端キューが空かどうかを判定 */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* 両端キューを初期化 */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* 要素をエンキュー */\ndeque.offerLast(2);   // 末尾に追加\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // 先頭に追加\ndeque.offerFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.peekFirst();  // 先頭要素\nint peekLast = deque.peekLast();    // 末尾要素\n\n/* 要素をデキュー */\nint popFirst = deque.pollFirst();  // 先頭要素をデキュー\nint popLast = deque.pollLast();    // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.size();\n\n/* 両端キューが空かどうかを判定 */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* 両端キューを初期化 */\n// C# では、連結リスト LinkedList を両端キューとして使用する\nLinkedList&lt;int&gt; deque = new();\n\n/* 要素をエンキュー */\ndeque.AddLast(2);   // 末尾に追加\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // 先頭に追加\ndeque.AddFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.First.Value;  // 先頭要素\nint peekLast = deque.Last.Value;    // 末尾要素\n\n/* 要素をデキュー */\ndeque.RemoveFirst();  // 先頭要素をデキュー\ndeque.RemoveLast();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.Count;\n\n/* 両端キューが空かどうかを判定 */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* 両端キューを初期化 */\n// Go では、list を両端キューとして使用する\ndeque := list.New()\n\n/* 要素をエンキュー */\ndeque.PushBack(2)      // 末尾に追加\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // 先頭に追加\ndeque.PushFront(1)\n\n/* 要素にアクセス */\nfront := deque.Front() // 先頭要素\nrear := deque.Back()   // 末尾要素\n\n/* 要素をデキュー */\ndeque.Remove(front)    // 先頭要素をデキュー\ndeque.Remove(rear)     // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nsize := deque.Len()\n\n/* 両端キューが空かどうかを判定 */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* 両端キューを初期化 */\n// Swift には組み込みの両端キュークラスがないため、Array を両端キューとして使用する\nvar deque: [Int] = []\n\n/* 要素をエンキュー */\ndeque.append(2) // 末尾に追加\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // 先頭に追加\ndeque.insert(1, at: 0)\n\n/* 要素にアクセス */\nlet peekFirst = deque.first! // 先頭要素\nlet peekLast = deque.last! // 末尾要素\n\n/* 要素をデキュー */\n// Array で模擬する場合、popFirst の計算量は O(n)\nlet popFirst = deque.removeFirst() // 先頭要素をデキュー\nlet popLast = deque.removeLast() // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nlet size = deque.count\n\n/* 両端キューが空かどうかを判定 */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* 両端キューを初期化 */\n// JavaScript には組み込みの両端キューがないため、Array を両端キューとして使用するしかない\nconst deque = [];\n\n/* 要素をエンキュー */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 配列であるため、unshift() メソッドの時間計算量は O(n) です\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 要素にアクセス */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* 要素をデキュー */\n// 配列であるため、shift() メソッドの時間計算量は O(n) です\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* 両端キューの長さを取得 */\nconst size = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* 両端キューを初期化 */\n// TypeScript には組み込みの両端キューがないため、Array を両端キューとして使用するしかない\nconst deque: number[] = [];\n\n/* 要素をエンキュー */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 配列であるため、unshift() メソッドの時間計算量は O(n) です\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 要素にアクセス */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* 要素をデキュー */\n// 配列であるため、shift() メソッドの時間計算量は O(n) です\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* 両端キューの長さを取得 */\nconst size: number = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* 両端キューを初期化 */\n// Dart では、Queue は両端キューとして定義されています\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* 要素をエンキュー */\ndeque.addLast(2);  // 末尾に追加\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // 先頭に追加\ndeque.addFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.first; // 先頭要素\nint peekLast = deque.last;   // 末尾要素\n\n/* 要素をデキュー */\nint popFirst = deque.removeFirst(); // 先頭要素をデキュー\nint popLast = deque.removeLast();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* 両端キューを初期化 */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 要素をエンキュー */\ndeque.push_back(2);  // 末尾に追加\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // 先頭に追加\ndeque.push_front(1);\n\n/* 要素にアクセス */\nif let Some(front) = deque.front() { // 先頭要素\n}\nif let Some(rear) = deque.back() {   // 末尾要素\n}\n\n/* 要素をデキュー */\nif let Some(pop_front) = deque.pop_front() { // 先頭要素をデキュー\n}\nif let Some(pop_rear) = deque.pop_back() {   // 末尾要素をデキュー\n}\n\n/* 両端キューの長さを取得 */\nlet size = deque.len();\n\n/* 両端キューが空かどうかを判定 */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C には組み込みの両端キューがありません\n</code></pre> deque.kt<pre><code>/* 両端キューを初期化 */\nval deque = LinkedList&lt;Int&gt;()\n\n/* 要素をエンキュー */\ndeque.offerLast(2)  // 末尾に追加\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // 先頭に追加\ndeque.offerFirst(1)\n\n/* 要素にアクセス */\nval peekFirst = deque.peekFirst() // 先頭要素\nval peekLast = deque.peekLast()   // 末尾要素\n\n/* 要素をデキュー */\nval popFirst = deque.pollFirst() // 先頭要素をデキュー\nval popLast = deque.pollLast()   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nval size = deque.size\n\n/* 両端キューが空かどうかを判定 */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># 両端キューを初期化\n# Ruby には組み込みの両端キューがないため、Array を両端キューとして使用するしかありません\ndeque = []\n\n# 要素をエンキュー\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# 配列であるため、Array#unshift メソッドの時間計算量は O(n) です\ndeque.unshift(3)\ndeque.unshift(1)\n\n# 要素にアクセス\npeek_first = deque.first\npeek_last = deque.last\n\n# 要素をデキュー\n# 配列であるため、 Array#shift メソッドの時間計算量は O(n) です\npop_front = deque.shift\npop_back = deque.pop\n\n# 両端キューの長さを取得\nsize = deque.length\n\n# 両端キューが空かどうかを判定\nis_empty = size.zero?\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   両端キューの実装 *","text":"<p>両端キューの実装はキューと似ており、連結リストまたは配列を基盤となるデータ構造として選べます。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   双方向連結リストに基づく実装","text":"<p>前節を振り返ると、通常の単方向連結リストを使ってキューを実装しました。これは、先頭ノードの削除（デキューに対応）と末尾ノードの後ろへの新規ノード追加（エンキューに対応）を容易に行えるためです。</p> <p>両端キューでは、先頭と末尾のどちらでもエンキューとデキューを行えます。言い換えると、両端キューではもう一方の対称方向の操作も実装する必要があります。そのため、両端キューの基盤データ構造として「双方向連結リスト」を採用します。</p> <p>次の図に示すように、双方向連結リストの先頭ノードと末尾ノードを両端キューの先頭と末尾と見なし、両端でノードを追加および削除する機能を実現します。</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 5-8   連結リストによる両端キューのエンキューとデキュー </p> <p>実装コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"双方向連結リストノード\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"コンストラクタ\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # 後続ノードへの参照\n        self.prev: ListNode | None = None  # 前駆ノードへの参照\n\nclass LinkedListDeque:\n    \"\"\"双方向連結リストベースの両端キュー\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._front: ListNode | None = None  # 先頭ノード front\n        self._rear: ListNode | None = None  # 末尾ノード rear\n        self._size: int = 0  # 両端キューの長さ\n\n    def size(self) -&gt; int:\n        \"\"\"両端キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"両端キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"エンキュー操作\"\"\"\n        node = ListNode(num)\n        # 連結リストが空なら、front と rear の両方を node に向ける\n        if self.is_empty():\n            self._front = self._rear = node\n        # 先頭へのエンキュー操作\n        elif is_front:\n            # node を連結リストの先頭に追加\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # 先頭ノードを更新する\n        # 末尾へのエンキュー操作\n        else:\n            # node を連結リストの末尾に追加\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # 末尾ノードを更新する\n        self._size += 1  # キューの長さを更新\n\n    def push_first(self, num: int):\n        \"\"\"キュー先頭にエンキュー\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"キュー末尾にエンキュー\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"デキュー操作\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        # キュー先頭からの取り出し\n        if is_front:\n            val: int = self._front.val  # 先頭ノードの値を一時保存\n            # 先頭ノードを削除\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # 先頭ノードを更新する\n        # キュー末尾からの取り出し\n        else:\n            val: int = self._rear.val  # 末尾ノードの値を一時保存\n            # 末尾ノードを削除\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # 末尾ノードを更新する\n        self._size -= 1  # キューの長さを更新\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"キュー先頭からデキュー\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"キュー末尾からデキュー\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"キュー末尾の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"出力用の配列を返す\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* 双方向連結リストノード */\nstruct DoublyListNode {\n    int val;              // ノード値\n    DoublyListNode *next; // 後継ノードへのポインタ\n    DoublyListNode *prev; // 前駆ノードへのポインタ\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize = 0;              // 両端キューの長さ\n\n  public:\n    /* コンストラクタ */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* デストラクタメソッド */\n    ~LinkedListDeque() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* 両端キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー操作 */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty())\n            front = rear = node;\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // 先頭ノードを更新する\n        // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // 末尾ノードを更新する\n        }\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* デキュー操作 */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"キューが空です\");\n        int val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front-&gt;val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // 先頭ノードを更新する\n        // キュー末尾からの取り出し\n        } else {\n            val = rear-&gt;val; // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // 末尾ノードを更新する\n        }\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return front-&gt;val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return rear-&gt;val;\n    }\n\n    /* 出力用の配列を返す */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    int val; // ノード値\n    ListNode next; // 後続ノードへの参照\n    ListNode prev; // 前駆ノードへの参照\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private ListNode front, rear; // 先頭ノード front、末尾ノード rear\n    private int queSize = 0; // 両端キューの長さ\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー操作 */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty())\n            front = rear = node;\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front.prev = node;\n            node.next = front;\n            front = node; // 先頭ノードを更新する\n        // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // 末尾ノードを更新する\n        }\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* デキュー操作 */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front.val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // 先頭ノードを更新する\n        // キュー末尾からの取り出し\n        } else {\n            val = rear.val; // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // 末尾ノードを更新する\n        }\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* 出力用の配列を返す */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* 双方向連結リストノード */\nclass ListNode(int val) {\n    public int val = val;       // ノード値\n    public ListNode? next = null; // 後続ノードへの参照\n    public ListNode? prev = null; // 前駆ノードへの参照\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    ListNode? front, rear; // 先頭ノード front、末尾ノード rear\n    int queSize = 0;      // 両端キューの長さ\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* エンキュー操作 */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front!.prev = node;\n            node.next = front;\n            front = node; // 先頭ノードを更新する\n        }\n        // 末尾へのエンキュー操作\n        else {\n            // node を連結リストの末尾に追加\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // 末尾ノードを更新する\n        }\n\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* デキュー操作 */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front?.val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // 先頭ノードを更新する\n        }\n        // キュー末尾からの取り出し\n        else {\n            val = rear?.val;  // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // 末尾ノードを更新する\n        }\n\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* 出力用の配列を返す */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* 双方向連結リストベースの両端キュー */\ntype linkedListDeque struct {\n    // 組み込みパッケージ list を使う\n    data *list.List\n}\n\n/* 両端キューを初期化する */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* キュー先頭に要素を追加する */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* キュー末尾に要素を追加する */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* 先頭要素を取り出す */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 末尾要素を取り出す */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* キュー末尾の要素にアクセス */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* キューの長さを取得 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* キューが空かどうかを判定 */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    var val: Int // ノード値\n    var next: ListNode? // 後続ノードへの参照\n    weak var prev: ListNode? // 前駆ノードへの参照\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private var front: ListNode? // 先頭ノード front\n    private var rear: ListNode? // 末尾ノード rear\n    private var _size: Int // 両端キューの長さ\n\n    init() {\n        _size = 0\n    }\n\n    /* 両端キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー操作 */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // 先頭へのエンキュー操作\n        else if isFront {\n            // node を連結リストの先頭に追加\n            front?.prev = node\n            node.next = front\n            front = node // 先頭ノードを更新する\n        }\n        // 末尾へのエンキュー操作\n        else {\n            // node を連結リストの末尾に追加\n            rear?.next = node\n            node.prev = rear\n            rear = node // 末尾ノードを更新する\n        }\n        _size += 1 // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* キュー末尾にエンキュー */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* デキュー操作 */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        let val: Int\n        // キュー先頭からの取り出し\n        if isFront {\n            val = front!.val // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // 先頭ノードを更新する\n        }\n        // キュー末尾からの取り出し\n        else {\n            val = rear!.val // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // 末尾ノードを更新する\n        }\n        _size -= 1 // キューの長さを更新\n        return val\n    }\n\n    /* キュー先頭からデキュー */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* キュー末尾からデキュー */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return front!.val\n    }\n\n    /* キュー末尾の要素にアクセス */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return rear!.val\n    }\n\n    /* 出力用の配列を返す */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    prev; // 前駆ノードへの参照（ポインタ）\n    next; // 後継ノードへの参照（ポインタ）\n    val; // ノード値\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    #front; // 先頭ノード front\n    #rear; // 末尾ノード rear\n    #queSize; // 両端キューの長さ\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* 末尾へのエンキュー操作 */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // node を連結リストの末尾に追加\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // 末尾ノードを更新する\n        }\n        this.#queSize++;\n    }\n\n    /* 先頭へのエンキュー操作 */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // node を連結リストの先頭に追加\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // 先頭ノードを更新する\n        }\n        this.#queSize++;\n    }\n\n    /* キュー末尾からの取り出し */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // 末尾ノードの値を保存する\n        // 末尾ノードを削除\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // 末尾ノードを更新する\n        this.#queSize--;\n        return value;\n    }\n\n    /* キュー先頭からの取り出し */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // 末尾ノードの値を保存する\n        // 先頭ノードを削除\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // 先頭ノードを更新する\n        this.#queSize--;\n        return value;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* 両端キューの長さを取得 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 両端キューを出力する */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    prev: ListNode; // 前駆ノードへの参照（ポインタ）\n    next: ListNode; // 後継ノードへの参照（ポインタ）\n    val: number; // ノード値\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private front: ListNode; // 先頭ノード front\n    private rear: ListNode; // 末尾ノード rear\n    private queSize: number; // 両端キューの長さ\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* 末尾へのエンキュー操作 */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // node を連結リストの末尾に追加\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // 末尾ノードを更新する\n        }\n        this.queSize++;\n    }\n\n    /* 先頭へのエンキュー操作 */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // node を連結リストの先頭に追加\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // 先頭ノードを更新する\n        }\n        this.queSize++;\n    }\n\n    /* キュー末尾からの取り出し */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // 末尾ノードの値を保存する\n        // 末尾ノードを削除\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // 末尾ノードを更新する\n        this.queSize--;\n        return value;\n    }\n\n    /* キュー先頭からの取り出し */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // 末尾ノードの値を保存する\n        // 先頭ノードを削除\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // 先頭ノードを更新する\n        this.queSize--;\n        return value;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* 両端キューの長さを取得 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 両端キューを出力する */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n  int val; // ノード値\n  ListNode? next; // 後続ノードへの参照\n  ListNode? prev; // 前駆ノードへの参照\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* 双方向連結リストに基づく双方向キュー */\nclass LinkedListDeque {\n  late ListNode? _front; // 先頭ノード _front\n  late ListNode? _rear; // 末尾ノード _rear\n  int _queSize = 0; // 両端キューの長さ\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* 両端キューの長さを取得 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* 両端キューが空かどうかを判定 */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* エンキュー操作 */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // 連結リストが空なら、`_front` と `_rear` の両方を `node` に向ける\n      _front = _rear = node;\n    } else if (isFront) {\n      // 先頭へのエンキュー操作\n      // node を連結リストの先頭に追加する\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // 先頭ノードを更新する\n    } else {\n      // 末尾へのエンキュー操作\n      // node を連結リストの末尾に追加する\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // 末尾ノードを更新する\n    }\n    _queSize++; // キューの長さを更新\n  }\n\n  /* キュー先頭にエンキュー */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* キュー末尾にエンキュー */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* デキュー操作 */\n  int? pop(bool isFront) {\n    // キューが空なら、そのまま `null` を返す\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // キュー先頭からの取り出し\n      val = _front!.val; // 先頭ノードの値を一時保存\n      // 先頭ノードを削除\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // 先頭ノードを更新する\n    } else {\n      // キュー末尾からの取り出し\n      val = _rear!.val; // 末尾ノードの値を一時保存\n      // 末尾ノードを削除\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // 末尾ノードを更新する\n    }\n    _queSize--; // キューの長さを更新\n    return val;\n  }\n\n  /* キュー先頭からデキュー */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* キュー末尾からデキュー */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* キュー末尾の要素にアクセス */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* 出力用の配列を返す */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* 双方向連結リストノード */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // ノード値\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 後継ノードへのポインタ\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 前駆ノードへのポインタ\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノード front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 末尾ノード rear\n    que_size: usize,                         // 両端キューの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 両端キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* エンキュー操作 */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // 先頭へのエンキュー操作\n        if is_front {\n            match self.front.take() {\n                // 連結リストが空なら、front と rear の両方を node に向ける\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // node を連結リストの先頭に追加\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // 先頭ノードを更新する\n                }\n            }\n        }\n        // 末尾へのエンキュー操作\n        else {\n            match self.rear.take() {\n                // 連結リストが空なら、front と rear の両方を node に向ける\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // node を連結リストの末尾に追加\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // 末尾ノードを更新する\n                }\n            }\n        }\n        self.que_size += 1; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* デキュー操作 */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // キューが空なら、そのまま `None` を返す\n        if self.is_empty() {\n            return None;\n        };\n        // キュー先頭からの取り出し\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // 先頭ノードを更新する\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // キューの長さを更新\n                old_front.borrow().val\n            })\n        }\n        // キュー末尾からの取り出し\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // 末尾ノードを更新する\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // キューの長さを更新\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* キュー先頭からデキュー */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* キュー末尾の要素にアクセス */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* 出力用の配列を返す */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* 双方向連結リストノード */\ntypedef struct DoublyListNode {\n    int val;                     // ノード値\n    struct DoublyListNode *next; // 後続ノード\n    struct DoublyListNode *prev; // 前駆ノード\n} DoublyListNode;\n\n/* コンストラクタ */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* デストラクタ */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* 双方向連結リストベースの両端キュー */\ntypedef struct {\n    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize;                  // 両端キューの長さ\n} LinkedListDeque;\n\n/* コンストラクタ */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* デストラクタ */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // すべてのノードを解放\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // deque 構造体を解放する\n    free(deque);\n}\n\n/* キューの長さを取得 */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* エンキュー */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // 連結リストが空なら、`front` と `rear` の両方を `node` に向ける\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // 先頭へのエンキュー操作\n    else if (isFront) {\n        // node を連結リストの先頭に追加\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // 先頭ノードを更新する\n    }\n    // 末尾へのエンキュー操作\n    else {\n        // node を連結リストの末尾に追加\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // キューの長さを更新\n}\n\n/* キュー先頭にエンキュー */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* キュー末尾にエンキュー */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* キュー先頭の要素にアクセス */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* キュー末尾の要素にアクセス */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* デキュー */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // キュー先頭からの取り出し\n    if (isFront) {\n        val = peekFirst(deque); // 先頭ノードの値を一時保存\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // 先頭ノードを更新する\n    }\n    // キュー末尾からの取り出し\n    else {\n        val = peekLast(deque); // 末尾ノードの値を一時保存\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // 末尾ノードを更新する\n    }\n    deque-&gt;queSize--; // キューの長さを更新\n    return val;\n}\n\n/* キュー先頭からデキュー */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* キュー末尾からデキュー */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* キューを出力する */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // 連結リスト内のデータを配列にコピー\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* 双方向連結リストノード */\nclass ListNode(var _val: Int) {\n    // ノード値\n    var next: ListNode? = null // 後続ノードへの参照\n    var prev: ListNode? = null // 前駆ノードへの参照\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private var front: ListNode? = null // 先頭ノード front\n    private var rear: ListNode? = null // 末尾ノード rear\n    private var queSize: Int = 0 // 両端キューの長さ\n\n    /* 両端キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* エンキュー操作 */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // 先頭へのエンキュー操作\n        } else if (isFront) {\n            // node を連結リストの先頭に追加\n            front?.prev = node\n            node.next = front\n            front = node // 先頭ノードを更新する\n            // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear?.next = node\n            node.prev = rear\n            rear = node // 末尾ノードを更新する\n        }\n        queSize++ // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* キュー末尾にエンキュー */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* デキュー操作 */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // キュー先頭からの取り出し\n        if (isFront) {\n            _val = front!!._val // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // 先頭ノードを更新する\n            // キュー末尾からの取り出し\n        } else {\n            _val = rear!!._val // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // 末尾ノードを更新する\n        }\n        queSize-- // キューの長さを更新\n        return _val\n    }\n\n    /* キュー先頭からデキュー */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* キュー末尾からデキュー */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* 出力用の配列を返す */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n# ## 双方向連結リストノード\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # 後続ノードへの参照\n  attr_accessor :prev # 前ノードへの参照\n\n  ### コンストラクタ ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### 双方向連結リストで実装した両端キュー ###\nclass LinkedListDeque\n  ### 両端キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @front = nil  # 先頭ノード front\n    @rear = nil   # 末尾ノード rear\n    @size = 0     # 両端キューの長さ\n  end\n\n  ### 両端キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### エンキュー操作 ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # 連結リストが空なら、`front` と `rear` の両方を `node` に向ける\n    if is_empty?\n      @front = @rear = node\n    # 先頭へのエンキュー操作\n    elsif is_front\n      # node を連結リストの先頭に追加\n      @front.prev = node\n      node.next = @front\n      @front = node # 先頭ノードを更新する\n    # 末尾へのエンキュー操作\n    else\n      # node を連結リストの末尾に追加\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # 末尾ノードを更新する\n    end\n    @size += 1 # キューの長さを更新\n  end\n\n  ### キュー先頭に追加 ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### キュー末尾に追加 ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### デキュー操作 ###\n  def pop(is_front)\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    # キュー先頭からの取り出し\n    if is_front\n      val = @front.val # 先頭ノードの値を一時保存\n      # 先頭ノードを削除\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # 先頭ノードを更新する\n    # キュー末尾からの取り出し\n    else\n      val = @rear.val # 末尾ノードの値を一時保存\n      # 末尾ノードを削除\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # 末尾ノードを更新する\n    end\n    @size -= 1 # キューの長さを更新\n\n    val\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_first\n    pop(true)\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_last\n    pop(false)\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek_first\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @front.val\n  end\n\n  ### キュー末尾要素を参照 ###\n  def peek_last\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @rear.val\n  end\n\n  ### 表示用の配列を返す ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   配列に基づく実装","text":"<p>次の図に示すように、配列によるキュー実装と同様に、循環配列を使って両端キューを実装することもできます。</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 5-9   配列による両端キューのエンキューとデキュー </p> <p>キュー実装を土台として、「先頭へのエンキュー」と「末尾からのデキュー」のメソッドを追加するだけで済みます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"循環配列ベースの両端キュー\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"コンストラクタ\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"両端キューの容量を取得\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"両端キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"両端キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"循環配列のインデックスを計算\"\"\"\n        # 剰余演算により配列の先頭と末尾をつなげる\n        # i が配列の末尾を越えたら先頭に戻る\n        # i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"キュー先頭にエンキュー\"\"\"\n        if self._size == self.capacity():\n            print(\"両端キューがいっぱいです\")\n            return\n        # 先頭ポインタを左に 1 つ移動する\n        # 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        self._front = self.index(self._front - 1)\n        # num をキュー先頭に追加\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"キュー末尾にエンキュー\"\"\"\n        if self._size == self.capacity():\n            print(\"両端キューがいっぱいです\")\n            return\n        # キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        rear = self.index(self._front + self._size)\n        # num をキュー末尾に追加\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"キュー先頭からデキュー\"\"\"\n        num = self.peek_first()\n        # 先頭ポインタを 1 つ後ろへ進める\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"キュー末尾からデキュー\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"キュー末尾の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        # 末尾要素のインデックスを計算\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"出力用の配列を返す\"\"\"\n        # 有効長の範囲内のリスト要素のみを変換\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // 両端キューの要素を格納する配列\n    int front;        // 先頭ポインタ。先頭要素を指す\n    int queSize;      // 両端キューの長さ\n\n  public:\n    /* コンストラクタ */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* 両端キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    int index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"両端キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"両端キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    int popFirst() {\n        int num = peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        // 末尾要素のインデックスを計算\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private int[] nums; // 両端キューの要素を格納する配列\n    private int front; // 先頭ポインタ。先頭要素を指す\n    private int queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private int index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"双方向キューは満杯です\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"双方向キューは満杯です\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    public int popFirst() {\n        int num = peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // 末尾要素のインデックスを計算\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    public int[] toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    int[] nums;  // 両端キューの要素を格納する配列\n    int front;   // 先頭ポインタ。先頭要素を指す\n    int queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    int Index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"両端キューは満杯です\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = Index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"両端キューは満杯です\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = Index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // 末尾要素のインデックスを計算\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* 循環配列ベースの両端キュー */\ntype arrayDeque struct {\n    nums        []int // 両端キューの要素を格納する配列\n    front       int   // 先頭ポインタ。先頭要素を指す\n    queSize     int   // 両端キューの長さ\n    queCapacity int   // キュー容量（格納できる要素数の上限）\n}\n\n/* キューを初期化 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 両端キューの長さを取得 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* 両端キューが空かどうかを判定 */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 循環配列のインデックスを計算 */\nfunc (q *arrayDeque) index(i int) int {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えて前に出たら末尾に戻る\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* キュー先頭にエンキュー */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"両端キューは満杯です\")\n        return\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n    q.front = q.index(q.front - 1)\n    // num をキュー先頭に追加\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* キュー末尾にエンキュー */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"両端キューは満杯です\")\n        return\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    rear := q.index(q.front + q.queSize)\n    // num をキュー末尾に追加\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* キュー先頭からデキュー */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // 先頭ポインタを 1 つ後ろへ進める\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* キュー末尾からデキュー */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* キュー末尾の要素にアクセス */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // 末尾要素のインデックスを計算\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* 表示用に Slice を取得 */\nfunc (q *arrayDeque) toSlice() []int {\n    // 有効長の範囲内のリスト要素のみを変換\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private var nums: [Int] // 両端キューの要素を格納する配列\n    private var front: Int // 先頭ポインタ。先頭要素を指す\n    private var _size: Int // 両端キューの長さ\n\n    /* コンストラクタ */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 両端キューの容量を取得 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 両端キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private func index(i: Int) -&gt; Int {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        (i + capacity()) % capacity()\n    }\n\n    /* キュー先頭にエンキュー */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"両端キューがいっぱいです\")\n            return\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(i: front - 1)\n        // num をキュー先頭に追加\n        nums[front] = num\n        _size += 1\n    }\n\n    /* キュー末尾にエンキュー */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"両端キューがいっぱいです\")\n            return\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        let rear = index(i: front + size())\n        // num をキュー末尾に追加\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* キュー先頭からデキュー */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* キュー末尾からデキュー */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return nums[front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        // 末尾要素のインデックスを計算\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    func toArray() -&gt; [Int] {\n        // 有効長の範囲内のリスト要素のみを変換\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    #nums; // 両端キューの要素を格納する配列\n    #front; // 先頭ポインタ。先頭要素を指す\n    #queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    index(i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('両端キューがいっぱいです');\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        this.#front = this.index(this.#front - 1);\n        // num をキュー先頭に追加\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('両端キューがいっぱいです');\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        const rear = this.index(this.#front + this.#queSize);\n        // num をキュー末尾に追加\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    popFirst() {\n        const num = this.peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 末尾要素のインデックスを計算\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private nums: number[]; // 両端キューの要素を格納する配列\n    private front: number; // 先頭ポインタ。先頭要素を指す\n    private queSize: number; // 両端キューの長さ\n\n    /* コンストラクタ */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    index(i: number): number {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('両端キューは満杯です');\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        this.front = this.index(this.front - 1);\n        // num をキュー先頭に追加\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('両端キューは満杯です');\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        const rear: number = this.index(this.front + this.queSize);\n        // num をキュー末尾に追加\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 末尾要素のインデックスを計算\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    toArray(): number[] {\n        // 有効長の範囲内のリスト要素のみを変換\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // 両端キューの要素を格納する配列\n  late int _front; // 先頭ポインタ。先頭要素を指す\n  late int _queSize; // 両端キューの長さ\n\n  /* コンストラクタ */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* 両端キューの容量を取得 */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* 両端キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 両端キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 循環配列のインデックスを計算 */\n  int index(int i) {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えて前に出たら末尾に戻る\n    return (i + capacity()) % capacity();\n  }\n\n  /* キュー先頭にエンキュー */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"両端キューがいっぱいです\");\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により _front が配列の先頭を越えたあと末尾に戻るようにする\n    _front = index(_front - 1);\n    // _num をキューの先頭に追加\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* キュー末尾にエンキュー */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"両端キューがいっぱいです\");\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    int rear = index(_front + _queSize);\n    // _num をキュー末尾に追加\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* キュー先頭からデキュー */\n  int popFirst() {\n    int _num = peekFirst();\n    // 先頭ポインタを右に 1 つ移動する\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー末尾からデキュー */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"両端キューが空です\");\n    }\n    return _nums[_front];\n  }\n\n  /* キュー末尾の要素にアクセス */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"両端キューが空です\");\n    }\n    // 末尾要素のインデックスを計算\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* 出力用の配列を返す */\n  List&lt;int&gt; toArray() {\n    // 有効長の範囲内のリスト要素のみを変換\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* 循環配列ベースの両端キュー */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // 両端キューの要素を格納する配列\n    front: usize,    // 先頭ポインタ。先頭要素を指す\n    que_size: usize, // 両端キューの長さ\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* コンストラクタ */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* 両端キューの容量を取得 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* 両端キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* キュー先頭にエンキュー */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"両端キューがいっぱいです\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        self.front = self.index(self.front as i32 - 1);\n        // num をキュー先頭に追加\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* キュー末尾にエンキュー */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"両端キューがいっぱいです\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // num をキュー末尾に追加\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* キュー先頭からデキュー */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // 先頭ポインタを 1 つ後ろへ進める\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー末尾からデキュー */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"両端キューが空です\")\n        };\n        self.nums[self.front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"両端キューが空です\")\n        };\n        // 末尾要素のインデックスを計算\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // 有効長の範囲内のリスト要素のみを変換\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* 循環配列ベースの両端キュー */\ntypedef struct {\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // 末尾ポインタ。キューの末尾 + 1 を指す\n    int queCapacity; // キューの容量\n} ArrayDeque;\n\n/* コンストラクタ */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // 配列を初期化\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* デストラクタ */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* 両端キューの容量を取得 */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* 両端キューの長さを取得 */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 両端キューが空かどうかを判定 */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* 循環配列のインデックスを計算 */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えたら末尾に戻る\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* キュー先頭にエンキュー */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"両端キューがいっぱいです\\r\\n\");\n        return;\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により front が配列の先頭を越えたあと末尾に戻るようにする\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // num をキューの先頭に追加\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* キュー末尾にエンキュー */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"両端キューがいっぱいです\\r\\n\");\n        return;\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // num をキュー末尾に追加\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* キュー先頭の要素にアクセス */\nint peekFirst(ArrayDeque *deque) {\n    // アクセス例外：双方向キューが空です\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* キュー末尾の要素にアクセス */\nint peekLast(ArrayDeque *deque) {\n    // アクセス例外：双方向キューが空です\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* キュー先頭からデキュー */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // 先頭ポインタを 1 つ後ろへ進める\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* キュー末尾からデキュー */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 出力用の配列を返す */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* コンストラクタ */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // 両端キューの要素を格納する配列\n    private var front: Int = 0 // 先頭ポインタ。先頭要素を指す\n    private var queSize: Int = 0 // 両端キューの長さ\n\n    /* 両端キューの容量を取得 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 両端キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private fun index(i: Int): Int {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity()\n    }\n\n    /* キュー先頭にエンキュー */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"双方向キューは満杯です\")\n            return\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1)\n        // num をキュー先頭に追加\n        nums[front] = num\n        queSize++\n    }\n\n    /* キュー末尾にエンキュー */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"双方向キューは満杯です\")\n            return\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        val rear = index(front + queSize)\n        // num をキュー末尾に追加\n        nums[rear] = num\n        queSize++\n    }\n\n    /* キュー先頭からデキュー */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* キュー末尾からデキュー */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 末尾要素のインデックスを計算\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    fun toArray(): IntArray {\n        // 有効長の範囲内のリスト要素のみを変換\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### 循環配列で実装した両端キュー ###\nclass ArrayDeque\n  ### 両端キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### 両端キューの容量を取得 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 両端キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### キュー先頭に追加 ###\n  def push_first(num)\n    if size == capacity\n      puts '両端キューがいっぱいです'\n      return\n    end\n\n    # 先頭ポインタを左に 1 つ移動する\n    # 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n    @front = index(@front - 1)\n    # num をキュー先頭に追加\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### キュー末尾に追加 ###\n  def push_last(num)\n    if size == capacity\n      puts '両端キューがいっぱいです'\n      return\n    end\n\n    # キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    rear = index(@front + size)\n    # num をキュー末尾に追加\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_first\n    num = peek_first\n    # 先頭ポインタを 1 つ後ろへ進める\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### キューの末尾から取り出す ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek_first\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### キュー末尾要素を参照 ###\n  def peek_last\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    # 末尾要素のインデックスを計算\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### 表示用の配列を返す ###\n  def to_array\n    # 有効長の範囲内のリスト要素のみを変換\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### 循環配列のインデックスを計算 ###\n  def index(i)\n    # 剰余演算により配列の先頭と末尾をつなげる\n    # i が配列の末尾を越えたら先頭に戻る\n    # i が配列の先頭を越えて前に出たら末尾に戻る\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   両端キューの応用","text":"<p>両端キューはスタックとキューの両方の論理を備えているため、これら 2 つのすべての応用場面を実現でき、さらに高い自由度を提供します。</p> <p>私たちが知っているように、ソフトウェアの「元に戻す」機能は通常スタックを使って実装されます。システムは変更操作を毎回スタックに <code>push</code> し、その後 <code>pop</code> によって取り消しを実現します。しかし、システム資源の制約を考慮すると、通常ソフトウェアは取り消し可能な手数を制限します（たとえば \\(50\\) 手まで保存可能）。スタックの長さが \\(50\\) を超えると、ソフトウェアはスタックの底部（先頭）で削除操作を行う必要があります。しかしスタックではこの機能を実現できないため、この場合はスタックの代わりに両端キューを使用する必要があります。なお、「元に戻す」の中核ロジック自体は依然としてスタックの後入れ先出し原則に従っており、両端キューは追加のロジックをより柔軟に実装できるだけです。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   キュー","text":"<p>キュー（queue）は、先入れ先出しの規則に従う線形データ構造です。名前のとおり、キューは順番待ちの現象を模したもので、新しく来た人は絶えずキュー末尾に加わり、キュー先頭にいる人から順に離れていきます。</p> <p>下図のように、キューの先頭を「キュー先頭」、末尾を「キュー末尾」と呼びます。要素をキュー末尾に加える操作を「エンキュー」、キュー先頭の要素を削除する操作を「デキュー」と呼びます。</p> <p></p> <p> 図 5-4   キューの先入れ先出し規則 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   キューの基本操作","text":"<p>キューの基本操作を以下の表に示します。なお、メソッド名はプログラミング言語によって異なる場合があります。ここではスタックと同じ命名を採用します。</p> <p> 表 5-2   キュー操作の効率 </p> メソッド名 説明 時間計算量 <code>push()</code> 要素をエンキューし、キュー末尾に追加する \\(O(1)\\) <code>pop()</code> キュー先頭の要素をデキューする \\(O(1)\\) <code>peek()</code> キュー先頭の要素にアクセスする \\(O(1)\\) <p>プログラミング言語に用意された既存のキュークラスをそのまま利用できます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# キューを初期化\n# Python では、通常は双方向キュークラス deque をキューとして使用する\n# queue.Queue() は純粋なキュークラスだが、やや使いにくいため非推奨\nque: deque[int] = deque()\n\n# 要素をエンキュー\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# キュー先頭の要素にアクセス\nfront: int = que[0]\n\n# 要素をデキュー\npop: int = que.popleft()\n\n# キューの長さを取得\nsize: int = len(que)\n\n# キューが空かどうかを判定\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* キューを初期化 */\nqueue&lt;int&gt; queue;\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nint front = queue.front();\n\n/* 要素をデキュー */\nqueue.pop();\n\n/* キューの長さを取得 */\nint size = queue.size();\n\n/* キューが空かどうかを判定 */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* キューを初期化 */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* 要素をエンキュー */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.peek();\n\n/* 要素をデキュー */\nint pop = queue.poll();\n\n/* キューの長さを取得 */\nint size = queue.size();\n\n/* キューが空かどうかを判定 */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* キューを初期化 */\nQueue&lt;int&gt; queue = new();\n\n/* 要素をエンキュー */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.Peek();\n\n/* 要素をデキュー */\nint pop = queue.Dequeue();\n\n/* キューの長さを取得 */\nint size = queue.Count;\n\n/* キューが空かどうかを判定 */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* キューを初期化 */\n// Go では、list をキューとして使用する\nqueue := list.New()\n\n/* 要素をエンキュー */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* キュー先頭の要素にアクセス */\npeek := queue.Front()\n\n/* 要素をデキュー */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* キューの長さを取得 */\nsize := queue.Len()\n\n/* キューが空かどうかを判定 */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* キューを初期化 */\n// Swift には組み込みのキュークラスがないため、Array をキューとして使える\nvar queue: [Int] = []\n\n/* 要素をエンキュー */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* キュー先頭の要素にアクセス */\nlet peek = queue.first!\n\n/* 要素をデキュー */\n// 配列であるため、removeFirst の計算量は O(n)\nlet pool = queue.removeFirst()\n\n/* キューの長さを取得 */\nlet size = queue.count\n\n/* キューが空かどうかを判定 */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* キューを初期化 */\n// JavaScript には組み込みのキューがないため、Array をキューとして使える\nconst queue = [];\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nconst peek = queue[0];\n\n/* 要素をデキュー */\n// 基盤は配列であるため、shift() メソッドの時間計算量は O(n)\nconst pop = queue.shift();\n\n/* キューの長さを取得 */\nconst size = queue.length;\n\n/* キューが空かどうかを判定 */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* キューを初期化 */\n// TypeScript には組み込みのキューがないため、Array をキューとして使える\nconst queue: number[] = [];\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nconst peek = queue[0];\n\n/* 要素をデキュー */\n// 基盤は配列であるため、shift() メソッドの時間計算量は O(n)\nconst pop = queue.shift();\n\n/* キューの長さを取得 */\nconst size = queue.length;\n\n/* キューが空かどうかを判定 */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* キューを初期化 */\n// Dart では、キュークラス Qeque は双方向キューであり、キューとしても使用できる\nQueue&lt;int&gt; queue = Queue();\n\n/* 要素をエンキュー */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.first;\n\n/* 要素をデキュー */\nint pop = queue.removeFirst();\n\n/* キューの長さを取得 */\nint size = queue.length;\n\n/* キューが空かどうかを判定 */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* 双方向キューを初期化 */\n// Rust では双方向キューを通常のキューとして使う\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 要素をエンキュー */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* キュー先頭の要素にアクセス */\nif let Some(front) = deque.front() {\n}\n\n/* 要素をデキュー */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* キューの長さを取得 */\nlet size = deque.len();\n\n/* キューが空かどうかを判定 */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C には組み込みのキューがない\n</code></pre> queue.kt<pre><code>/* キューを初期化 */\nval queue = LinkedList&lt;Int&gt;()\n\n/* 要素をエンキュー */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* キュー先頭の要素にアクセス */\nval peek = queue.peek()\n\n/* 要素をデキュー */\nval pop = queue.poll()\n\n/* キューの長さを取得 */\nval size = queue.size\n\n/* キューが空かどうかを判定 */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># キューを初期化\n# Ruby 組み込みのキュー（Thread::Queue) には peek と走査メソッドがないため、Array をキューとして使える\nqueue = []\n\n# 要素をエンキュー\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# キュー先頭の要素にアクセス\npeek = queue.first\n\n# 要素をデキュー\n# 注意：配列であるため、Array#shift メソッドの時間計算量は O(n)\npop = queue.shift\n\n# キューの長さを取得\nsize = queue.length\n\n# キューが空かどうかを判定\nis_empty = queue.empty?\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%98%9F%E5%88%97%0A%20%20%20%20%23%20%E5%9C%A8%20Python%20%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BB%AC%E4%B8%80%E8%88%AC%E5%B0%86%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%B1%BB%20deque%20%E7%9C%8B%E4%BD%9C%E9%98%9F%E5%88%97%E4%BD%BF%E7%94%A8%0A%20%20%20%20%23%20%E8%99%BD%E7%84%B6%20queue.Queue%28%29%20%E6%98%AF%E7%BA%AF%E6%AD%A3%E7%9A%84%E9%98%9F%E5%88%97%E7%B1%BB%EF%BC%8C%E4%BD%86%E4%B8%8D%E5%A4%AA%E5%A5%BD%E7%94%A8%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%90%8E%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   キューの実装","text":"<p>キューを実装するには、一方の端で要素を追加し、もう一方の端で要素を削除できるデータ構造が必要です。連結リストと配列はいずれもこの条件を満たします。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   連結リストに基づく実装","text":"<p>下図のように、連結リストの「先頭ノード」と「末尾ノード」をそれぞれ「キュー先頭」と「キュー末尾」とみなし、キュー末尾ではノードの追加のみ、キュー先頭ではノードの削除のみを行うようにします。</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> 図 5-5   連結リストでキューを実装したエンキューとデキュー操作 </p> <p>以下は連結リストでキューを実装するコードです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"連結リストベースのキュー\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._front: ListNode | None = None  # 先頭ノード front\n        self._rear: ListNode | None = None  # 末尾ノード rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"エンキュー\"\"\"\n        # 末尾ノードの後ろに num を追加\n        node = ListNode(num)\n        # キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"デキュー\"\"\"\n        num = self.peek()\n        # 先頭ノードを削除\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"キューが空です\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用にリストへ変換\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        freeMemoryLinkedList(front);\n    }\n\n    /* キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    void push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode *node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    int pop() {\n        int num = peek();\n        // 先頭ノードを削除\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // メモリを解放する\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"キューが空です\");\n        return front-&gt;val;\n    }\n\n    /* 連結リストを Vector に変換して返す */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private ListNode front, rear; // 先頭ノード front、末尾ノード rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー */\n    public void push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node;\n            rear = node;\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    public int pop() {\n        int num = peek();\n        // 先頭ノードを削除\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    ListNode? front, rear;  // 先頭ノード front、末尾ノード rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* エンキュー */\n    public void Push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode node = new(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node;\n            rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    public int Pop() {\n        int num = Peek();\n        // 先頭ノードを削除\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* 連結リストベースのキュー */\ntype linkedListQueue struct {\n    // 組み込みパッケージ list でキューを実装する\n    data *list.List\n}\n\n/* キューを初期化 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* エンキュー */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* デキュー */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* キューの長さを取得 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* キューが空かどうかを判定 */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private var front: ListNode? // 先頭ノード\n    private var rear: ListNode? // 末尾ノード\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー */\n    func push(num: Int) {\n        // 末尾ノードの後ろに num を追加\n        let node = ListNode(x: num)\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* デキュー */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 先頭ノードを削除\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"キューが空です\")\n        }\n        return front!.val\n    }\n\n    /* 連結リストを Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    #front; // 先頭ノード #front\n    #rear; // 末尾ノード #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* キューの長さを取得 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* エンキュー */\n    push(num) {\n        // 末尾ノードの後ろに num を追加\n        const node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* デキュー */\n    pop() {\n        const num = this.peek();\n        // 先頭ノードを削除\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek() {\n        if (this.size === 0) throw new Error('キューが空');\n        return this.#front.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private front: ListNode | null; // 先頭ノード front\n    private rear: ListNode | null; // 末尾ノード rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* キューの長さを取得 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* エンキュー */\n    push(num: number): void {\n        // 末尾ノードの後ろに num を追加\n        const node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* デキュー */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('キューが空です');\n        // 先頭ノードを削除\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek(): number {\n        if (this.size === 0) throw new Error('キューが空です');\n        return this.front!.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n  ListNode? _front; // 先頭ノード _front\n  ListNode? _rear; // 末尾ノード _rear\n  int _queSize = 0; // キューの長さ\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* エンキュー */\n  void push(int _num) {\n    // 末尾ノードの後ろに _num を追加\n    final node = ListNode(_num);\n    // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* デキュー */\n  int pop() {\n    final int _num = peek();\n    // 先頭ノードを削除\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('キューが空です');\n    }\n    return _front!.val;\n  }\n\n  /* 連結リストを Array に変換して返す */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* 連結リストベースのキュー */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノード front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 末尾ノード rear\n    que_size: usize,                         // キューの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* エンキュー */\n    pub fn push(&amp;mut self, num: T) {\n        // 末尾ノードの後ろに num を追加\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* デキュー */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* キュー先頭の要素にアクセス */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 連結リストを Array に変換して返す */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* 連結リストベースのキュー */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* コンストラクタ */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* デストラクタ */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // すべてのノードを解放\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // queue 構造体を解放する\n    free(queue);\n}\n\n/* キューの長さを取得 */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* エンキュー */\nvoid push(LinkedListQueue *queue, int num) {\n    // 末尾ノードに node を追加\n    ListNode *node = newListNode(num);\n    // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* キュー先頭の要素にアクセス */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* デキュー */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* キューを出力する */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // 連結リスト内のデータを配列にコピー\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue(\n    // 先頭ノード front、末尾ノード rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* エンキュー */\n    fun push(num: Int) {\n        // 末尾ノードの後ろに num を追加\n        val node = ListNode(num)\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node\n            rear = node\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* デキュー */\n    fun pop(): Int {\n        val num = peek()\n        // 先頭ノードを削除\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 連結リストを Array に変換して返す */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### 連結リストで実装したキュー ###\nclass LinkedListQueue\n  ### キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @front = nil  # 先頭ノード front\n    @rear = nil   # 末尾ノード rear\n    @size = 0\n  end\n\n  ### キューが空か判定 ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### エンキュー ###\n  def push(num)\n    # 末尾ノードの後ろに num を追加\n    node = ListNode.new(num)\n\n    # キューが空なら、先頭ノードと末尾ノードの両方をそのノードに向ける\n    if @front.nil?\n      @front = node\n      @rear = node\n    # キューが空でなければ、そのノードを末尾ノードの後ろに追加する\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### デキュー ###\n  def pop\n    num = peek\n    # 先頭ノードを削除\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek\n    raise IndexError, 'キューは空です' if is_empty?\n\n    @front.val\n  end\n\n  ### 連結リストを Array に変換して返す ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   配列に基づく実装","text":"<p>配列で先頭要素を削除する時間計算量は \\(O(n)\\) であり、そのままではデキュー操作の効率が低くなります。しかし、次の巧妙な方法によってこの問題を回避できます。</p> <p>変数 <code>front</code> を用いてキュー先頭要素のインデックスを指し、さらに変数 <code>size</code> でキューの長さを記録できます。<code>rear = front + size</code> と定義すると、この式で得られる <code>rear</code> はキュー末尾要素の次の位置を指します。</p> <p>この設計に基づくと、配列内で要素を含む有効区間は <code>[front, rear - 1]</code> となります。各種操作の実装方法を下図に示します。</p> <ul> <li>エンキュー操作：入力要素を <code>rear</code> の位置に代入し、<code>size</code> を 1 増やします。</li> <li>デキュー操作：<code>front</code> を 1 増やし、<code>size</code> を 1 減らすだけです。</li> </ul> <p>このように、エンキューとデキューはいずれも 1 回の操作だけで済み、時間計算量はともに \\(O(1)\\) です。</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> 図 5-6   配列でキューを実装したエンキューとデキュー操作 </p> <p>ここで 1 つ問題があります。エンキューとデキューを繰り返すと、<code>front</code> と <code>rear</code> はどちらも右へ移動し続け、配列の末尾に達するとそれ以上進めなくなります。この問題を解決するために、配列を先頭と末尾がつながった「環状配列」とみなします。</p> <p>環状配列では、<code>front</code> または <code>rear</code> が配列末尾を越えたときに、直ちに配列先頭へ戻って走査を続けられるようにする必要があります。この周期的な規則は「剰余演算」によって実現できます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"循環配列ベースのキュー\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"コンストラクタ\"\"\"\n        self._nums: list[int] = [0] * size  # キュー要素を格納する配列\n        self._front: int = 0  # 先頭ポインタ。先頭要素を指す\n        self._size: int = 0  # キューの長さ\n\n    def capacity(self) -&gt; int:\n        \"\"\"キューの容量を取得\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"エンキュー\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"キューがいっぱいです\")\n        # 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        # 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        rear: int = (self._front + self._size) % self.capacity()\n        # num をキュー末尾に追加\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"デキュー\"\"\"\n        num: int = self.peek()\n        # 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"キューが空です\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用のリストを返す\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n  private:\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // キューの長さ\n    int queCapacity; // キューの容量\n\n  public:\n    ArrayQueue(int capacity) {\n        // 配列を初期化\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* キューの容量を取得 */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % queCapacity;\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    int pop() {\n        int num = peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"キューが空です\");\n        return nums[front];\n    }\n\n    /* 配列を Vector に変換して返す */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private int[] nums; // キュー要素を格納する配列\n    private int front; // 先頭ポインタ。先頭要素を指す\n    private int queSize; // キューの長さ\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"キューは満杯です\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % capacity();\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    public int pop() {\n        int num = peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 配列を返す */\n    public int[] toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    int[] nums;  // キュー要素を格納する配列\n    int front;   // 先頭ポインタ。先頭要素を指す\n    int queSize; // キューの長さ\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"キューは満杯です\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % Capacity();\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    public int Pop() {\n        int num = Peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* 配列を返す */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* 循環配列ベースのキュー */\ntype arrayQueue struct {\n    nums        []int // キュー要素を格納する配列\n    front       int   // 先頭ポインタ。先頭要素を指す\n    queSize     int   // キューの長さ\n    queCapacity int   // キュー容量（格納できる要素数の上限）\n}\n\n/* キューを初期化 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* キューの長さを取得 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* キューが空かどうかを判定 */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* エンキュー */\nfunc (q *arrayQueue) push(num int) {\n    // rear == queCapacity のときキューは満杯\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    rear := (q.front + q.queSize) % q.queCapacity\n    // num をキュー末尾に追加\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* デキュー */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 表示用に Slice を取得 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private var nums: [Int] // キュー要素を格納する配列\n    private var front: Int // 先頭ポインタ。先頭要素を指す\n    private var _size: Int // キューの長さ\n\n    init(capacity: Int) {\n        // 配列を初期化\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* キューの容量を取得 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"キューがいっぱいです\")\n            return\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        let rear = (front + size()) % capacity()\n        // num をキュー末尾に追加\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* デキュー */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"キューが空です\")\n        }\n        return nums[front]\n    }\n\n    /* 配列を返す */\n    func toArray() -&gt; [Int] {\n        // 有効長の範囲内のリスト要素のみを変換\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    #nums; // キュー要素を格納する配列\n    #front = 0; // 先頭ポインタ。先頭要素を指す\n    #queSize = 0; // キューの長さ\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* キューの容量を取得 */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* キューの長さを取得 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* エンキュー */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('キューがいっぱいです');\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        const rear = (this.#front + this.size) % this.capacity;\n        // num をキュー末尾に追加\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* デキュー */\n    pop() {\n        const num = this.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek() {\n        if (this.isEmpty()) throw new Error('キューが空です');\n        return this.#nums[this.#front];\n    }\n\n    /* Array を返す */\n    toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private nums: number[]; // キュー要素を格納する配列\n    private front: number; // 先頭ポインタ。先頭要素を指す\n    private queSize: number; // キューの長さ\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* キューの長さを取得 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* エンキュー */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('キューは満杯です');\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        const rear = (this.front + this.queSize) % this.capacity;\n        // num をキュー末尾に追加\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* デキュー */\n    pop(): number {\n        const num = this.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('キューが空です');\n        return this.nums[this.front];\n    }\n\n    /* Array を返す */\n    toArray(): number[] {\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // キュー要素を格納する配列\n  late int _front; // 先頭ポインタ。先頭要素を指す\n  late int _queSize; // キューの長さ\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* キューの容量を取得 */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* エンキュー */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"キューは満杯です\");\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    int rear = (_front + _queSize) % capaCity();\n    // _num をキュー末尾に追加\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* デキュー */\n  int pop() {\n    int _num = peek();\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"キューが空です\");\n    }\n    return _nums[_front];\n  }\n\n  /* Array を返す */\n  List&lt;int&gt; toArray() {\n    // 有効長の範囲内のリスト要素のみを変換\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* 循環配列ベースのキュー */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // キュー要素を格納する配列\n    front: i32,        // 先頭ポインタ。先頭要素を指す\n    que_size: i32,     // キューの長さ\n    que_capacity: i32, // キューの容量\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* コンストラクタ */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* キューの容量を取得 */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* キューの長さを取得 */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* キューが空かどうかを判定 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* エンキュー */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"キューがいっぱいです\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // num をキュー末尾に追加\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* デキュー */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* 配列を返す */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* 循環配列ベースのキュー */\ntypedef struct {\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // 末尾ポインタ。キューの末尾 + 1 を指す\n    int queCapacity; // キューの容量\n} ArrayQueue;\n\n/* コンストラクタ */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // 配列を初期化\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* デストラクタ */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* キューの容量を取得 */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* キューの長さを取得 */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* キュー先頭の要素にアクセス */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* エンキュー */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"キューは満杯です\\r\\n\");\n        return;\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // num をキュー末尾に追加\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* デキュー */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 出力用の配列を返す */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // キュー要素を格納する配列\n    private var front: Int = 0 // 先頭ポインタ。先頭要素を指す\n    private var queSize: Int = 0 // キューの長さ\n\n    /* キューの容量を取得 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* エンキュー */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"キューは満杯です\")\n            return\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        val rear = (front + queSize) % capacity()\n        // num をキュー末尾に追加\n        nums[rear] = num\n        queSize++\n    }\n\n    /* デキュー */\n    fun pop(): Int {\n        val num = peek()\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 配列を返す */\n    fun toArray(): IntArray {\n        // 有効長の範囲内のリスト要素のみを変換\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### 循環配列で実装したキュー ###\nclass ArrayQueue\n  ### キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # キュー要素を格納する配列\n    @front = 0 # 先頭ポインタ。先頭要素を指す\n    @size = 0 # キューの長さ\n  end\n\n  ### キューの容量を取得 ###\n  def capacity\n    @nums.length\n  end\n\n  ### キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### エンキュー ###\n  def push(num)\n    raise IndexError, 'キューがいっぱいです' if size == capacity\n\n    # 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    # 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    rear = (@front + size) % capacity\n    # num をキュー末尾に追加\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### デキュー ###\n  def pop\n    num = peek\n    # 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek\n    raise IndexError, 'キューは空です' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 表示用のリストを返す ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上記の実装によるキューにも制約があり、長さを可変にできません。しかし、この問題の解決は難しくなく、配列を動的配列に置き換えれば容量拡張の仕組みを導入できます。興味があれば自分で実装してみてください。</p> <p>2 つの実装の比較に関する結論はスタックの場合と同じなので、ここでは繰り返しません。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   キューの典型的な応用","text":"<ul> <li>淘宝の注文。購入者が注文すると、その注文はキューに追加され、システムは順番に従って注文を処理します。ダブルイレブンの期間には短時間で膨大な注文が発生するため、高並行性がエンジニアにとって重点的に解決すべき課題になります。</li> <li>各種の待機事項。先着順の機能を実現する必要があるあらゆる場面、たとえばプリンターのジョブキューや飲食店の配膳キューなどでは、キューによって処理順序を効果的に維持できます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   スタック","text":"<p>スタック（stack）は、後入れ先出しの論理に従う線形データ構造です。</p> <p>スタックは机の上に積まれた皿の山にたとえられます。1回に1枚の皿しか動かせないとすると、いちばん下の皿を取り出すには、上にある皿を順番にどかす必要があります。この皿をさまざまな型の要素（整数、文字、オブジェクトなど）に置き換えたものが、スタックというデータ構造です。</p> <p>下図のように、積み重なった要素の上端を「スタックトップ」、下端を「スタックボトム」と呼びます。要素をスタックトップに追加する操作を「プッシュ」、スタックトップの要素を削除する操作を「ポップ」と呼びます。</p> <p></p> <p> 図 5-1   スタックの後入れ先出しの規則 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   スタックの基本操作","text":"<p>スタックの基本操作を以下の表に示します。具体的なメソッド名は使用するプログラミング言語によって異なります。ここでは、一般的な <code>push()</code>、<code>pop()</code>、<code>peek()</code> を例に挙げます。</p> <p> 表 5-1   スタックの操作効率 </p> メソッド 説明 時間計算量 <code>push()</code> 要素をプッシュする（スタックトップに追加） \\(O(1)\\) <code>pop()</code> スタックトップの要素をポップする \\(O(1)\\) <code>peek()</code> スタックトップの要素にアクセスする \\(O(1)\\) <p>通常は、プログラミング言語に組み込まれているスタッククラスをそのまま利用できます。ただし、専用のスタッククラスが用意されていない言語もあります。その場合は、その言語の「配列」や「連結リスト」をスタックとして用い、プログラムのロジック上でスタックに無関係な操作を無視します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># スタックを初期化\n# Python には組み込みのスタッククラスがないため、list をスタックとして使用できる\nstack: list[int] = []\n\n# 要素をプッシュ\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# スタックトップの要素にアクセス\npeek: int = stack[-1]\n\n# 要素をポップ\npop: int = stack.pop()\n\n# スタックの長さを取得\nsize: int = len(stack)\n\n# 空かどうかを判定\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* スタックを初期化 */\nstack&lt;int&gt; stack;\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nint top = stack.top();\n\n/* 要素をポップ */\nstack.pop(); // 戻り値なし\n\n/* スタックの長さを取得 */\nint size = stack.size();\n\n/* 空かどうかを判定 */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* スタックを初期化 */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.peek();\n\n/* 要素をポップ */\nint pop = stack.pop();\n\n/* スタックの長さを取得 */\nint size = stack.size();\n\n/* 空かどうかを判定 */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* スタックを初期化 */\nStack&lt;int&gt; stack = new();\n\n/* 要素をプッシュ */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.Peek();\n\n/* 要素をポップ */\nint pop = stack.Pop();\n\n/* スタックの長さを取得 */\nint size = stack.Count;\n\n/* 空かどうかを判定 */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* スタックを初期化 */\n// Go では、Slice をスタックとして使うのが一般的\nvar stack []int\n\n/* 要素をプッシュ */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* スタックトップの要素にアクセス */\npeek := stack[len(stack)-1]\n\n/* 要素をポップ */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* スタックの長さを取得 */\nsize := len(stack)\n\n/* 空かどうかを判定 */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* スタックを初期化 */\n// Swift には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nvar stack: [Int] = []\n\n/* 要素をプッシュ */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* スタックトップの要素にアクセス */\nlet peek = stack.last!\n\n/* 要素をポップ */\nlet pop = stack.removeLast()\n\n/* スタックの長さを取得 */\nlet size = stack.count\n\n/* 空かどうかを判定 */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* スタックを初期化 */\n// JavaScript には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nconst stack = [];\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nconst peek = stack[stack.length-1];\n\n/* 要素をポップ */\nconst pop = stack.pop();\n\n/* スタックの長さを取得 */\nconst size = stack.length;\n\n/* 空かどうかを判定 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* スタックを初期化 */\n// TypeScript には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nconst stack: number[] = [];\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nconst peek = stack[stack.length - 1];\n\n/* 要素をポップ */\nconst pop = stack.pop();\n\n/* スタックの長さを取得 */\nconst size = stack.length;\n\n/* 空かどうかを判定 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* スタックを初期化 */\n// Dart には組み込みのスタッククラスがないため、List をスタックとして使用できる\nList&lt;int&gt; stack = [];\n\n/* 要素をプッシュ */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.last;\n\n/* 要素をポップ */\nint pop = stack.removeLast();\n\n/* スタックの長さを取得 */\nint size = stack.length;\n\n/* 空かどうかを判定 */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* スタックを初期化 */\n// Vec をスタックとして使用する\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nlet top = stack.last().unwrap();\n\n/* 要素をポップ */\nlet pop = stack.pop().unwrap();\n\n/* スタックの長さを取得 */\nlet size = stack.len();\n\n/* 空かどうかを判定 */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C には組み込みのスタックがない\n</code></pre> stack.kt<pre><code>/* スタックを初期化 */\nval stack = Stack&lt;Int&gt;()\n\n/* 要素をプッシュ */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* スタックトップの要素にアクセス */\nval peek = stack.peek()\n\n/* 要素をポップ */\nval pop = stack.pop()\n\n/* スタックの長さを取得 */\nval size = stack.size\n\n/* 空かどうかを判定 */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># スタックを初期化\n# Ruby には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nstack = []\n\n# 要素をプッシュ\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# スタックトップの要素にアクセス\npeek = stack.last\n\n# 要素をポップ\npop = stack.pop\n\n# スタックの長さを取得\nsize = stack.length\n\n# 空かどうかを判定\nis_empty = stack.empty?\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%A0%88%0A%20%20%20%20%23%20Python%20%E6%B2%A1%E6%9C%89%E5%86%85%E7%BD%AE%E7%9A%84%E6%A0%88%E7%B1%BB%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%8A%8A%20list%20%E5%BD%93%E4%BD%9C%E6%A0%88%E6%9D%A5%E4%BD%BF%E7%94%A8%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E6%A0%88%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%E6%A0%88%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%20peek%20%3D%22,%20peek%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E6%A0%88%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%90%8E%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E6%A0%88%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   スタックの実装","text":"<p>スタックの動作の仕組みをより深く理解するために、自分でスタッククラスを実装してみましょう。</p> <p>スタックは後入れ先出しの原則に従うため、要素の追加や削除はスタックトップでしか行えません。一方、配列や連結リストでは任意の位置で要素を追加・削除できます。つまり、スタックは制限付きの配列または連結リストとみなせます。 言い換えると、配列や連結リストのうち無関係な操作を「隠蔽」することで、外から見た振る舞いをスタックの特性に合わせられます。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   連結リストによる実装","text":"<p>連結リストでスタックを実装する場合、連結リストの先頭ノードをスタックトップ、末尾ノードをスタックボトムとみなせます。</p> <p>下図のように、プッシュ操作では要素を連結リストの先頭に挿入するだけでよく、このノード挿入方法は「頭部挿入法」と呼ばれます。ポップ操作では、先頭ノードを連結リストから削除するだけです。</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> 図 5-2   連結リストによるスタック実装のプッシュ・ポップ操作 </p> <p>以下は、連結リストによってスタックを実装したコード例です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"連結リストベースのスタック\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"スタックの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"スタックが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"プッシュ\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"ポップ\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"スタックトップの要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用にリストへ変換\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // 先頭ノードをスタックトップとする\n    int stkSize;        // スタックの長さ\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* スタックの長さを取得 */\n    int size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // メモリを解放する\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"スタックが空です\");\n        return stackTop-&gt;val;\n    }\n\n    /* List を Array に変換して返す */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private ListNode stackPeek; // 先頭ノードをスタックトップとする\n    private int stkSize = 0; // スタックの長さ\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* List を Array に変換して返す */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    ListNode? stackPeek;  // 先頭ノードをスタックトップとする\n    int stkSize = 0;   // スタックの長さ\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* プッシュ */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* List を Array に変換して返す */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* 連結リストベースのスタック */\ntype linkedListStack struct {\n    // 組み込みパッケージ list でスタックを実装する\n    data *list.List\n}\n\n/* スタックを初期化 */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* プッシュ */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* ポップ */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* スタックトップの要素にアクセス */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* スタックの長さを取得 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* スタックが空かどうかを判定 */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private var _peek: ListNode? // 先頭ノードをスタックトップとする\n    private var _size: Int // スタックの長さ\n\n    init() {\n        _size = 0\n    }\n\n    /* スタックの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* スタックが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* プッシュ */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* ポップ */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* スタックトップの要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return _peek!.val\n    }\n\n    /* List を Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    #stackPeek; // 先頭ノードをスタックトップとする\n    #stkSize = 0; // スタックの長さ\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* プッシュ */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* ポップ */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    peek() {\n        if (!this.#stackPeek) throw new Error('スタックが空');\n        return this.#stackPeek.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // 先頭ノードをスタックトップとする\n    private stkSize: number = 0; // スタックの長さ\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* プッシュ */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* ポップ */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('スタックが空です');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('スタックが空です');\n        return this.stackPeek.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* 連結リストクラスに基づくスタック */\nclass LinkedListStack {\n  ListNode? _stackPeek; // 先頭ノードをスタックトップとする\n  int _stkSize = 0; // スタックの長さ\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* スタックの長さを取得 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* スタックが空かどうかを判定 */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* プッシュ */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* ポップ */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* スタックトップの要素にアクセス */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* 連結リストを List に変換して返す */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* 連結リストベースのスタック */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノードをスタックトップとする\n    stk_size: usize,                              // スタックの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* スタックの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* スタックが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* プッシュ */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* ポップ */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* スタックトップの要素にアクセス */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* List を Array に変換して返す */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* 連結リストベースのスタック */\ntypedef struct {\n    ListNode *top; // 先頭ノードをスタックトップとする\n    int size;      // スタックの長さ\n} LinkedListStack;\n\n/* コンストラクタ */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* デストラクタ */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* スタックの長さを取得 */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* スタックが空かどうかを判定 */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* プッシュ */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // 新しく追加したノードのポインタフィールドを更新\n    node-&gt;val = num;     // 新しく追加したノードのデータフィールドを更新\n    s-&gt;top = node;       // スタックトップを更新\n    s-&gt;size++;           // スタックサイズを更新\n}\n\n/* スタックトップの要素にアクセス */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"スタックは空です\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* ポップ */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // メモリを解放する\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // 先頭ノードをスタックトップとする\n    private var stkSize: Int = 0 // スタックの長さ\n) {\n\n    /* スタックの長さを取得 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* スタックが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* プッシュ */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* ポップ */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* スタックトップの要素にアクセス */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* List を Array に変換して返す */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### 連結リストで実装したスタック ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @size = 0\n  end\n\n  ### スタックが空か判定 ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### プッシュ ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### ポップ ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### スタックトップ要素を参照 ###\n  def peek\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @peek.val\n  end\n\n  ### 連結リストを Array に変換して返す ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   配列による実装","text":"<p>配列でスタックを実装する場合、配列の末尾をスタックトップとして扱えます。下図のように、プッシュとポップはそれぞれ配列末尾への要素追加と削除に対応し、どちらの時間計算量も \\(O(1)\\) です。</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> 図 5-3   配列によるスタック実装のプッシュ・ポップ操作 </p> <p>プッシュされる要素は際限なく増える可能性があるため、動的配列を使えば、配列の拡張を自前で処理する必要がありません。以下にコード例を示します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"配列ベースのスタック\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"スタックの長さを取得\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"スタックが空かどうかを判定\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"プッシュ\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"ポップ\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"スタックトップの要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用のリストを返す\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* スタックの長さを取得 */\n    int size() {\n        return stack.size();\n    }\n\n    /* スタックが空かどうかを判定 */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* プッシュ */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* ポップ */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"スタックが空です\");\n        return stack.back();\n    }\n\n    /* Vector を返す */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // リスト（動的配列）を初期化する\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* スタックの長さを取得 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* スタックが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* ポップ */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* List を Array に変換して返す */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // リスト（動的配列）を初期化する\n        stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* プッシュ */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* ポップ */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* List を Array に変換して返す */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* 配列ベースのスタック */\ntype arrayStack struct {\n    data []int // データ\n}\n\n/* スタックを初期化 */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // スタックの長さを 0、容量を 16 に設定\n        data: make([]int, 0, 16),\n    }\n}\n\n/* スタックの長さ */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* スタックが空かどうか */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* プッシュ */\nfunc (s *arrayStack) push(v int) {\n    // スライスは自動で拡張される\n    s.data = append(s.data, v)\n}\n\n/* ポップ */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* スタックトップ要素を取得する */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* 表示用に Slice を取得 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // リスト（動的配列）を初期化する\n        stack = []\n    }\n\n    /* スタックの長さを取得 */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* スタックが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* プッシュ */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* ポップ */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return stack.removeLast()\n    }\n\n    /* スタックトップの要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return stack.last!\n    }\n\n    /* List を Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* プッシュ */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* ポップ */\n    pop() {\n        if (this.isEmpty()) throw new Error('スタックが空');\n        return this.#stack.pop();\n    }\n\n    /* スタックトップの要素にアクセス */\n    top() {\n        if (this.isEmpty()) throw new Error('スタックが空');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Array を返す */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* プッシュ */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* ポップ */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('スタックが空です');\n        return this.stack.pop();\n    }\n\n    /* スタックトップの要素にアクセス */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('スタックが空です');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Array を返す */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* スタックの長さを取得 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* スタックが空かどうかを判定 */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* プッシュ */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* ポップ */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* スタックトップの要素にアクセス */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stack.last;\n  }\n\n  /* スタックを Array に変換して返す */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* 配列ベースのスタック */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* スタックを初期化 */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* スタックの長さを取得 */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* スタックが空かどうかを判定 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* プッシュ */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* ポップ */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* スタックトップの要素にアクセス */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"スタックが空です\")\n        };\n        self.stack.last()\n    }\n\n    /* &amp;Vec を返す */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* 配列ベースのスタック */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* コンストラクタ */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // 大きめの容量で初期化し、拡張を避ける\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* デストラクタ */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* スタックの長さを取得 */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* スタックが空かどうかを判定 */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* プッシュ */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"スタックは満杯です\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* スタックトップの要素にアクセス */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"スタックは空です\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* ポップ */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    // リスト（動的配列）を初期化する\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* スタックの長さを取得 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* スタックが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* プッシュ */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* ポップ */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* スタックトップの要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* List を Array に変換して返す */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### 配列で実装したスタック ###\nclass ArrayStack\n  ### コンストラクタ ###\n  def initialize\n    @stack = []\n  end\n\n  ### スタックの長さを取得 ###\n  def size\n    @stack.length\n  end\n\n  ### スタックが空か判定 ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### プッシュ ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### ポップ ###\n  def pop\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @stack.pop\n  end\n\n  ### スタックトップ要素を参照 ###\n  def peek\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @stack.last\n  end\n\n  ### 表示用のリストを返す ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513-2","level":2,"title":"5.1.3   2つの実装の比較","text":"<p>対応する操作</p> <p>どちらの実装も、スタックの定義に含まれる各種操作をサポートします。配列ベースの実装はランダムアクセスも可能ですが、これはスタックの定義範囲を超えているため、通常は利用しません。</p> <p>時間効率</p> <p>配列ベースの実装では、プッシュとポップの両方があらかじめ確保された連続メモリ上で行われるため、キャッシュ局所性が高く、効率に優れます。ただし、プッシュ時に配列容量を超えると拡張処理が発生し、その1回のプッシュの時間計算量は \\(O(n)\\) になります。</p> <p>連結リストベースの実装では、サイズ拡張が非常に柔軟であり、前述のような配列拡張による効率低下はありません。ただし、プッシュ時にはノードオブジェクトの初期化とポインタの更新が必要になるため、効率は相対的に低くなります。もっとも、プッシュする要素自体がノードオブジェクトであれば、初期化の手間を省けるため、効率を高められます。</p> <p>以上を踏まえると、プッシュおよびポップの対象が <code>int</code> や <code>double</code> のような基本データ型である場合、次の結論が得られます。</p> <ul> <li>配列ベースのスタックは拡張時に効率が低下しますが、拡張は低頻度の操作であるため、平均効率はより高くなります。</li> <li>連結リストベースのスタックは、より安定した効率を提供できます。</li> </ul> <p>空間効率</p> <p>リストを初期化するとき、システムは「初期容量」を割り当てますが、この容量は実際の必要量を上回ることがあります。また、拡張は通常、一定の倍率（たとえば2倍）で行われるため、拡張後の容量も実際の必要量を超える可能性があります。したがって、配列ベースのスタックは一定のメモリ浪費を招く可能性があります。</p> <p>一方で、連結リストのノードはポインタを追加で保持する必要があるため、連結リストノードは相対的に大きな領域を占有します。</p> <p>以上より、どちらの実装がより省メモリかを単純に断定することはできず、具体的な状況に応じて分析する必要があります。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   スタックの典型的な応用","text":"<ul> <li>ブラウザにおける戻ると進む、ソフトウェアにおける取り消しとやり直し。新しいWebページを開くたびに、ブラウザは直前のページをスタックにプッシュするため、戻る操作によって前のページに戻れます。戻る操作は実際にはポップに相当します。戻ると進むを同時にサポートするには、2つのスタックを組み合わせて実現する必要があります。</li> <li>プログラムのメモリ管理。関数を呼び出すたびに、システムはスタックトップにスタックフレームを追加し、関数のコンテキスト情報を記録します。再帰関数では、下向きに再帰していく段階でプッシュが繰り返され、上向きにバックトラックする段階でポップが繰り返されます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   まとめ","text":"","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>スタックは後入れ先出しの原則に従うデータ構造であり、配列または連結リストで実装できます。</li> <li>時間効率の面では、スタックの配列実装は平均効率が高い一方、拡張時には 1 回のプッシュ操作の時間計算量が \\(O(n)\\) まで悪化します。これに対して、スタックの連結リスト実装はより安定した効率を示します。</li> <li>空間効率の面では、スタックの配列実装はある程度の領域の無駄を生む可能性があります。ただし、連結リストのノードが占有するメモリは配列要素よりも大きい点に注意が必要です。</li> <li>キューは先入れ先出しの原則に従うデータ構造であり、同様に配列または連結リストで実装できます。時間効率と空間効率の比較における結論は、前述のスタックの場合と似ています。</li> <li>両端キューはより高い自由度を持つキューであり、両端で要素の追加と削除を行えます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ブラウザの進む・戻るは双方向連結リストで実装されているのですか？</p> <p>ブラウザの進む・戻る機能の本質は「スタック」の表れです。ユーザーが新しいページにアクセスすると、そのページはスタックの先頭に追加されます。ユーザーが戻るボタンをクリックすると、そのページはスタックの先頭から取り出されます。両端キューを使うといくつかの追加操作を簡単に実装でき、この点は「両端キュー」の章で触れています。</p> <p>Q：ポップした後、そのノードのメモリを解放する必要はありますか？</p> <p>後で取り出したノードを引き続き使うのであれば、メモリを解放する必要はありません。以降そのノードを使わない場合でも、<code>Java</code> や <code>Python</code> などの言語には自動ガベージコレクション機構があるため、手動でメモリを解放する必要はありません。一方、<code>C</code> と <code>C++</code> では手動でメモリを解放する必要があります。</p> <p>Q：両端キューは 2 つのスタックをつなげたように見えますが、用途は何ですか？</p> <p>両端キューは、スタックとキューの組み合わせ、あるいは 2 つのスタックをつなげたもののような構造です。表しているのはスタック + キューのロジックなので、スタックとキューのすべての応用を実現でき、しかもより柔軟です。</p> <p>Q：取り消し（undo）とやり直し（redo）は具体的にどのように実装されますか？</p> <p>2 つのスタックを使い、スタック <code>A</code> を取り消し用、スタック <code>B</code> をやり直し用に使います。</p> <ol> <li>ユーザーが操作を 1 つ実行するたびに、その操作をスタック <code>A</code> にプッシュし、スタック <code>B</code> を空にします。</li> <li>ユーザーが「取り消し」を実行したときは、スタック <code>A</code> から直近の操作をポップし、それをスタック <code>B</code> にプッシュします。</li> <li>ユーザーが「やり直し」を実行したときは、スタック <code>B</code> から直近の操作をポップし、それをスタック <code>A</code> にプッシュします。</li> </ol>","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"第 7 章   木","text":"<p>Abstract</p> <p>大樹は生命力に満ち、根は深く葉は生い茂り、枝は豊かに広がる。</p> <p>それはデータ分割統治の生き生きとした姿を私たちに示してくれる。</p>","path":["第 7 章 &nbsp; 木"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"章の内容","text":"<ul> <li>7.1   二分木</li> <li>7.2   二分木の走査</li> <li>7.3   二分木の配列表現</li> <li>7.4   二分探索木</li> <li>7.5   AVL 木 *</li> <li>7.6   まとめ</li> </ul>","path":["第 7 章 &nbsp; 木"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   二分木の配列表現","text":"<p>連結リスト表現では、二分木の記憶単位はノード <code>TreeNode</code> であり、ノード同士はポインタによって接続されます。前節では、連結リスト表現における二分木の各種基本操作を紹介しました。</p> <p>では、配列で二分木を表現できるでしょうか？答えはもちろん可能です。</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   充足二分木を表現する","text":"<p>まずは簡単な例を考えます。与えられた 1 本の充足二分木について、すべてのノードをレベル順走査の順に配列へ格納すると、各ノードは一意な配列インデックスに対応します。</p> <p>レベル順走査の性質に基づくと、親ノードのインデックスと子ノードのインデックスの間にある「対応式」を導けます。あるノードのインデックスが \\(i\\) なら、その左子ノードのインデックスは \\(2i + 1\\) 、右子ノードのインデックスは \\(2i + 2\\) です。以下の図は、各ノードインデックス間の対応関係を示しています。</p> <p></p> <p> 図 7-12   充足二分木の配列表現 </p> <p>対応式は、連結リストにおけるノード参照（ポインタ）と同じ役割を果たします。与えられた配列内の任意のノードについて、この対応式を使えばその左（右）子ノードにアクセスできます。</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   任意の二分木を表現する","text":"<p>充足二分木は特殊なケースであり、一般の二分木では中間層に多数の <code>None</code> が存在することがよくあります。レベル順走査の列にはこれらの <code>None</code> が含まれないため、その列だけから <code>None</code> の数や分布位置を推定することはできません。つまり、このレベル順走査列に一致する二分木構造は複数存在し得ます。</p> <p>次の図のように、非充足二分木が与えられると、上記の配列表現はすでに成り立ちません。</p> <p></p> <p> 図 7-13   レベル順走査列に対応する複数の二分木の可能性 </p> <p>この問題を解決するために、**レベル順走査列にすべての <code>None</code> を明示的に書き込む**ことを考えられます。次の図のように、このように処理すればレベル順走査列で二分木を一意に表現できます。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 二分木の配列表現\n# 空き位置を表すために None を使う\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int の最大値 INT_MAX を使って空き位置を示す\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int のラッパークラス Integer を使えば、null で空き位置を示せる\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な int? 型を使えば、null で空き位置を示せる\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// any 型のスライスを使えば、nil で空き位置を示せる\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な Int? 型を使えば、nil で空き位置を示せる\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な int? 型を使えば、null で空き位置を示せる\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// None を使って空き位置を示す\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int の最大値で空き位置を示すため、ノード値は INT_MAX であってはならない\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### 二分木の配列表現 ###\n# nil を使って空き位置を表す\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> 図 7-14   任意の二分木の配列表現 </p> <p>補足すると、完全二分木は配列による表現に非常に適しています。完全二分木の定義を振り返ると、<code>None</code> は最下層の右側にしか現れないため、すべての <code>None</code> は必ずレベル順走査列の末尾に現れます。</p> <p>つまり、完全二分木を配列で表す場合は、すべての <code>None</code> の格納を省略できるため、非常に便利です。次の図に例を示します。</p> <p></p> <p> 図 7-15   完全二分木の配列表現 </p> <p>以下のコードでは、配列ベースで表現した二分木を実装しており、次の操作を含みます。</p> <ul> <li>あるノードが与えられたとき、その値、左（右）子ノード、親ノードを取得する。</li> <li>前順走査、中順走査、後順走査、レベル順走査の列を取得する。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"配列表現による二分木クラス\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"コンストラクタ\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"リスト容量\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの値を取得\"\"\"\n        # インデックスが範囲外なら、空きを表す None を返す\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの左子ノードのインデックスを取得\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの右子ノードのインデックスを取得\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの親ノードのインデックスを取得\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"レベル順走査\"\"\"\n        self.res = []\n        # 配列を直接走査する\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"深さ優先探索\"\"\"\n        if self.val(i) is None:\n            return\n        # 先行順走査\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # 中順走査\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # 後順走査\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"先行順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"中順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"後順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n  public:\n    /* コンストラクタ */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* リスト容量 */\n    int size() {\n        return tree.size();\n    }\n\n    /* インデックス i のノードの値を取得 */\n    int val(int i) {\n        // インデックスが範囲外なら、空きを表す INT_MAX を返す\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // 配列を直接走査する\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* 先行順走査 */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* 深さ優先探索 */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // 空きスロットなら返す\n        if (val(i) == INT_MAX)\n            return;\n        // 先行順走査\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // 中順走査\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // 後順走査\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* コンストラクタ */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* リスト容量 */\n    public int size() {\n        return tree.size();\n    }\n\n    /* インデックス i のノードの値を取得 */\n    public Integer val(int i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // 配列を直接走査する\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // 空きスロットなら返す\n        if (val(i) == null)\n            return;\n        // 先行順走査\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // 中順走査\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // 後順走査\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* 先行順走査 */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* リスト容量 */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    public int? Val(int i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // 配列を直接走査する\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // 空きスロットなら返す\n        if (!Val(i).HasValue)\n            return;\n        // 先行順走査\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // 中順走査\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // 後順走査\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* 先行順走査 */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* 配列表現による二分木クラス */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* コンストラクタ */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* リスト容量 */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* インデックス i のノードの値を取得 */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // インデックスが範囲外なら、空きを表す null を返す\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* インデックス i のノードの左子ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* インデックス i のノードの右子ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* インデックス i のノードの親ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* レベル順走査 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // 配列を直接走査する\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* 深さ優先探索 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // 空きスロットなら返す\n    if abt.val(i) == nil {\n        return\n    }\n    // 先行順走査\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // 中順走査\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // 後順走査\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* 先行順走査 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* 中順走査 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* 後順走査 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* コンストラクタ */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* リスト容量 */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* インデックス i のノードの値を取得 */\n    func val(i: Int) -&gt; Int? {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // 配列を直接走査する\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* 深さ優先探索 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // 空きスロットなら返す\n        guard let val = val(i: i) else {\n            return\n        }\n        // 先行順走査\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // 中順走査\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // 後順走査\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* 先行順走査 */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* 中順走査 */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* 後順走査 */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* コンストラクタ */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* リスト容量 */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    val(i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // 切り捨て除算\n    }\n\n    /* レベル順走査 */\n    levelOrder() {\n        let res = [];\n        // 配列を直接走査する\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    #dfs(i, order, res) {\n        // 空きスロットなら返す\n        if (this.val(i) === null) return;\n        // 先行順走査\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中順走査\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後順走査\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 先行順走査 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中順走査 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後順走査 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* コンストラクタ */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* リスト容量 */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    val(i: number): number | null {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // 切り捨て除算\n    }\n\n    /* レベル順走査 */\n    levelOrder(): number[] {\n        let res = [];\n        // 配列を直接走査する\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // 空きスロットなら返す\n        if (this.val(i) === null) return;\n        // 先行順走査\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中順走査\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後順走査\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 先行順走査 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中順走査 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後順走査 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* コンストラクタ */\n  ArrayBinaryTree(this._tree);\n\n  /* リスト容量 */\n  int size() {\n    return _tree.length;\n  }\n\n  /* インデックス i のノードの値を取得 */\n  int? val(int i) {\n    // インデックスが範囲外なら、空きを表す null を返す\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* インデックス i のノードの左子ノードのインデックスを取得 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* インデックス i のノードの右子ノードのインデックスを取得 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* インデックス i のノードの親ノードのインデックスを取得 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* レベル順走査 */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* 深さ優先探索 */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // 空きスロットなら返す\n    if (val(i) == null) {\n      return;\n    }\n    // 先行順走査\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // 中順走査\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // 後順走査\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* 先行順走査 */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* 中順走査 */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* 後順走査 */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* 配列表現による二分木クラス */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* コンストラクタ */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* リスト容量 */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* インデックス i のノードの値を取得 */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // インデックスが範囲外なら、空きを表す None を返す\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* 深さ優先探索 */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // 先行順走査\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // 中順走査\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // 後順走査\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* 先行順走査 */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* 中順走査 */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* 後順走査 */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* 配列表現による二分木の構造体 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* コンストラクタ */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* デストラクタ */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* リスト容量 */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* インデックス i のノードの値を取得 */\nint val(ArrayBinaryTree *abt, int i) {\n    // インデックスが範囲外なら、空きを表す INT_MAX を返す\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* レベル順走査 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // 配列を直接走査する\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* 深さ優先探索 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // 空きスロットなら返す\n    if (val(abt, i) == INT_MAX)\n        return;\n    // 先行順走査\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // 中順走査\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // 後順走査\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* 先行順走査 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 中順走査 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 後順走査 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* リスト容量 */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* インデックス i のノードの値を取得 */\n    fun _val(i: Int): Int? {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // 配列を直接走査する\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* 深さ優先探索 */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // 空きスロットなら返す\n        if (_val(i) == null)\n            return\n        // 先行順走査\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // 中順走査\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // 後順走査\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* 先行順走査 */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* 中順走査 */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* 後順走査 */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### 配列表現の二分木クラス ###\nclass ArrayBinaryTree\n  ### コンストラクタ ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### リスト容量 ###\n  def size\n    @tree.length\n  end\n\n  ### インデックス i のノードの値を取得 ###\n  def val(i)\n    # インデックスが範囲外なら `nil` を返し、空きスロットを表す\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### インデックス i のノードの左子ノードのインデックスを取得 ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### インデックス i のノードの右子ノードのインデックスを取得 ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### インデックス i のノードの親ノードのインデックスを取得 ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### レベル順走査 ###\n  def level_order\n    @res = []\n\n    # 配列を直接走査する\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### 深さ優先探索 ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # 先行順走査\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # 中順走査\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # 後順走査\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### 前順走査 ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### 中順走査 ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### 後順走査 ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   利点と制約","text":"<p>二分木の配列表現には主に次の利点があります。</p> <ul> <li>配列は連続したメモリ空間に格納されるため、キャッシュ効率が高く、アクセスと走査が速い。</li> <li>ポインタを格納する必要がなく、比較的省スペースである。</li> <li>ノードへのランダムアクセスが可能である。</li> </ul> <p>ただし、配列表現にはいくつかの制約もあります。</p> <ul> <li>配列による格納には連続したメモリ空間が必要なため、データ量が大きすぎる木の格納には向かない。</li> <li>ノードの追加と削除は配列の挿入・削除操作で実現する必要があり、効率は低い。</li> <li>二分木に大量の <code>None</code> が存在すると、配列に占める実ノードデータの比率が低くなり、空間利用率も低下する。</li> </ul>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL 木 *","text":"<p>「二分探索木」章で述べたように、挿入と削除を何度も繰り返すと、二分探索木は連結リストへ退化する可能性があります。この場合、すべての操作の時間計算量は \\(O(\\log n)\\) から \\(O(n)\\) へ劣化します。</p> <p>以下の図に示すように、ノード削除を 2 回行うと、この二分探索木は連結リストへ退化します。</p> <p></p> <p> 図 7-24   AVL 木がノード削除後に退化する </p> <p>別の例として、以下の図に示す完全二分木に 2 つのノードを挿入すると、木は大きく左に傾き、探索操作の時間計算量もそれに伴って劣化します。</p> <p></p> <p> 図 7-25   AVL 木がノード挿入後に退化する </p> <p>1962 年、G. M. Adelson-Velsky と E. M. Landis は論文“An algorithm for the organization of information”の中で AVL 木 を提案しました。論文では一連の操作が詳しく説明されており、ノードの追加と削除を続けても AVL 木が退化しないようにして、各種操作の時間計算量を \\(O(\\log n)\\) の水準に保ちます。言い換えると、追加・削除・探索・更新を頻繁に行う場面でも、AVL 木は常に高いデータ操作性能を維持でき、実用価値の高い構造です。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl","level":2,"title":"7.5.1   AVL 木の基本用語","text":"<p>AVL 木は二分探索木であると同時に平衡二分木でもあり、これら 2 種類の二分木の性質をすべて満たします。したがって、平衡二分探索木（balanced binary search tree）の一種です。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   ノードの高さ","text":"<p>AVL 木の操作ではノードの高さを取得する必要があるため、ノードクラスに <code>height</code> 変数を追加します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL 木ノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # ノード値\n        self.height: int = 0                # ノードの高さ\n        self.left: TreeNode | None = None   # 左の子ノード参照\n        self.right: TreeNode | None = None  # 右の子ノード参照\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nstruct TreeNode {\n    int val{};          // ノード値\n    int height = 0;     // ノードの高さ\n    TreeNode *left{};   // 左の子ノード\n    TreeNode *right{};  // 右の子ノード\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    public int val;        // ノード値\n    public int height;     // ノードの高さ\n    public TreeNode left;  // 左の子ノード\n    public TreeNode right; // 右の子ノード\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode(int? x) {\n    public int? val = x;    // ノード値\n    public int height;      // ノードの高さ\n    public TreeNode? left;  // 左の子ノード参照\n    public TreeNode? right; // 右の子ノード参照\n}\n</code></pre> <pre><code>/* AVL 木ノード構造体 */\ntype TreeNode struct {\n    Val    int       // ノード値\n    Height int       // ノードの高さ\n    Left   *TreeNode // 左の子ノード参照\n    Right  *TreeNode // 右の子ノード参照\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    var val: Int // ノード値\n    var height: Int // ノードの高さ\n    var left: TreeNode? // 左の子ノード\n    var right: TreeNode? // 右の子ノード\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    val; // ノード値\n    height; //ノードの高さ\n    left; // 左の子ノードポインタ\n    right; // 右の子ノードポインタ\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    val: number;            // ノード値\n    height: number;         // ノードの高さ\n    left: TreeNode | null;  // 左の子ノードポインタ\n    right: TreeNode | null; // 右の子ノードポインタ\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n  int val;         // ノード値\n  int height;      // ノードの高さ\n  TreeNode? left;  // 左の子ノード\n  TreeNode? right; // 右の子ノード\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL 木ノード構造体 */\nstruct TreeNode {\n    val: i32,                               // ノード値\n    height: i32,                            // ノードの高さ\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左の子ノード\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右の子ノード\n}\n\nimpl TreeNode {\n    /* コンストラクタ */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノード構造体 */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* コンストラクタ */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode(val _val: Int) {  // ノード値\n    val height: Int = 0          // ノードの高さ\n    val left: TreeNode? = null   // 左の子ノード\n    val right: TreeNode? = null  // 右の子ノード\n}\n</code></pre> <pre><code>### AVL 木ノードクラス ###\nclass TreeNode\n  attr_accessor :val    # ノード値\n  attr_accessor :height # ノードの高さ\n  attr_accessor :left   # 左の子ノード参照\n  attr_accessor :right  # 右の子ノード参照\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>「ノードの高さ」とは、そのノードから最も遠い葉ノードまでの距離、すなわち通過する「辺」の本数を指します。特に、葉ノードの高さは \\(0\\)、空ノードの高さは \\(-1\\) です。ここでは、ノードの高さを取得・更新するための 2 つの補助関数を用意します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"ノードの高さを取得\"\"\"\n    # 空ノードの高さは -1、葉ノードの高さは 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"ノードの高さを更新する\"\"\"\n    # ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* ノードの高さを取得 */\nint height(TreeNode *node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode *node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードの高さを取得 */\nint height(TreeNode node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードの高さを取得 */\nint Height(TreeNode? node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid UpdateHeight(TreeNode node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードの高さを取得 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* ノードの高さを更新する */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードの高さを取得 */\nfunc height(node: TreeNode?) -&gt; Int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    node?.height ?? -1\n}\n\n/* ノードの高さを更新する */\nfunc updateHeight(node: TreeNode?) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* ノードの高さを取得 */\nheight(node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node === null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\n#updateHeight(node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードの高さを取得 */\nheight(node: TreeNode): number {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node === null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nupdateHeight(node: TreeNode): void {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードの高さを取得 */\nint height(TreeNode? node) {\n  // 空ノードの高さは -1、葉ノードの高さは 0\n  return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode? node) {\n  // ノードの高さは最も高い部分木の高さ + 1 に等しい\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードの高さを取得 */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* ノードの高さを更新する */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // ノードの高さは最も高い部分木の高さ + 1 に等しい\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードの高さを取得 */\nint height(TreeNode *node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードの高さを取得 */\nfun height(node: TreeNode?): Int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node?.height ?: -1\n}\n\n/* ノードの高さを更新する */\nfun updateHeight(node: TreeNode?) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### ノードの高さを取得 ###\ndef height(node)\n  # 空ノードの高さは -1、葉ノードの高さは 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### ノードの高さを更新 ###\ndef update_height(node)\n  # ノードの高さは最も高い部分木の高さ + 1 に等しい\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   ノードの平衡係数","text":"<p>ノードの平衡係数（balance factor）は、左部分木の高さから右部分木の高さを引いた値と定義し、空ノードの平衡係数は \\(0\\) とします。同様に、ノードの平衡係数を取得する機能も関数にカプセル化して、後続で使いやすくします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"平衡係数を取得\"\"\"\n    # 空ノードの平衡係数は 0\n    if node is None:\n        return 0\n    # ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode *node) {\n    // 空ノードの平衡係数は 0\n    if (node == nullptr)\n        return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode node) {\n    // 空ノードの平衡係数は 0\n    if (node == null)\n        return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* 平衡係数を取得 */\nint BalanceFactor(TreeNode? node) {\n    // 空ノードの平衡係数は 0\n    if (node == null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* 平衡係数を取得 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // 空ノードの平衡係数は 0\n    if node == nil {\n        return 0\n    }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* 平衡係数を取得 */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // 空ノードの平衡係数は 0\n    guard let node = node else { return 0 }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* 平衡係数を取得 */\nbalanceFactor(node) {\n    // 空ノードの平衡係数は 0\n    if (node === null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* 平衡係数を取得 */\nbalanceFactor(node: TreeNode): number {\n    // 空ノードの平衡係数は 0\n    if (node === null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode? node) {\n  // 空ノードの平衡係数は 0\n  if (node == null) return 0;\n  // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* 平衡係数を取得 */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // 空ノードの平衡係数は 0\n        None =&gt; 0,\n        // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode *node) {\n    // 空ノードの平衡係数は 0\n    if (node == NULL) {\n        return 0;\n    }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* 平衡係数を取得 */\nfun balanceFactor(node: TreeNode?): Int {\n    // 空ノードの平衡係数は 0\n    if (node == null) return 0\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### 平衡係数を取得 ###\ndef balance_factor(node)\n  # 空ノードの平衡係数は 0\n  return 0 if node.nil?\n\n  # ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>平衡係数を \\(f\\) とすると、AVL 木の任意のノードの平衡係数は常に \\(-1 \\le f \\le 1\\) を満たします。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl","level":2,"title":"7.5.2   AVL 木の回転","text":"<p>AVL 木の特徴は「回転」操作にあり、二分木の中順走査列を変えずに、不平衡ノードを再び平衡に戻せます。言い換えると、回転操作は「二分探索木」の性質を保ちながら、木を再び「平衡二分木」に戻すことができます。</p> <p>平衡係数の絶対値が \\(&gt; 1\\) のノードを「不平衡ノード」と呼びます。ノードの不平衡の形に応じて、回転操作は 4 種類に分かれます。右回転、左回転、右回転してから左回転、左回転してから右回転です。以下でこれらを順に説明します。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   右回転","text":"<p>以下の図では、ノードの下に平衡係数を示しています。下から上へ見ると、二分木で最初に不平衡になるのは「ノード 3」です。この不平衡ノードを根とする部分木に注目し、そのノードを <code>node</code>、左の子ノードを <code>child</code> として、「右回転」を行います。右回転後、部分木は平衡を回復し、なおかつ二分探索木の性質も保たれます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-26   右回転の手順 </p> <p>以下の図に示すように、ノード <code>child</code> に右の子ノード（<code>grand_child</code> と記す）がある場合、右回転には 1 ステップ追加する必要があります。すなわち、<code>grand_child</code> を <code>node</code> の左の子ノードにします。</p> <p></p> <p> 図 7-27   grand_child を持つ右回転 </p> <p>「右に回転する」というのはあくまでイメージしやすい表現であり、実際にはノードポインタを変更して実現します。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"右回転\"\"\"\n    child = node.left\n    grand_child = child.right\n    # child を支点として node を右回転させる\n    child.right = node\n    node.left = grand_child\n    # ノードの高さを更新する\n    self.update_height(node)\n    self.update_height(child)\n    # 回転後の部分木の根ノードを返す\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 右回転 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // child を支点として node を右回転させる\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 右回転 */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 右回転 */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 右回転 */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // child を支点として node を右回転させる\n    child.Right = node\n    node.Left = grandChild\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 右回転 */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // child を支点として node を右回転させる\n    child?.right = node\n    node?.left = grandChild\n    // ノードの高さを更新する\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 右回転 */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 右回転 */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 右回転 */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // child を支点として node を右回転させる\n  child.right = node;\n  node.left = grandChild;\n  // ノードの高さを更新する\n  updateHeight(node);\n  updateHeight(child);\n  // 回転後の部分木の根ノードを返す\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 右回転 */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // child を支点として node を右回転させる\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // ノードの高さを更新する\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 回転後の部分木の根ノードを返す\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 右回転 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // child を支点として node を右回転させる\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 右回転 */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // child を支点として node を右回転させる\n    child.right = node\n    node.left = grandChild\n    // ノードの高さを更新する\n    updateHeight(node)\n    updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 右回転操作 ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # child を支点として node を右回転させる\n  child.right = node\n  node.left = grand_child\n  # ノードの高さを更新する\n  update_height(node)\n  update_height(child)\n  # 回転後の部分木の根ノードを返す\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   左回転","text":"<p>対応する鏡像として、上記の不平衡二分木を左右反転して考えると、以下の図に示す「左回転」が必要になります。</p> <p></p> <p> 図 7-28   左回転 </p> <p>同様に、以下の図に示すように、ノード <code>child</code> に左の子ノード（<code>grand_child</code> と記す）がある場合、左回転にも 1 ステップ追加する必要があります。すなわち、<code>grand_child</code> を <code>node</code> の右の子ノードにします。</p> <p></p> <p> 図 7-29   grand_child を持つ左回転 </p> <p>分かるように、右回転と左回転は論理的に鏡像対称であり、それぞれが解決する 2 種類の不平衡も対称です。この対称性に基づけば、右回転の実装コードにあるすべての <code>left</code> を <code>right</code> に、すべての <code>right</code> を <code>left</code> に置き換えるだけで、左回転の実装コードが得られます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"左回転\"\"\"\n    child = node.right\n    grand_child = child.left\n    # child を支点として node を左回転させる\n    child.left = node\n    node.right = grand_child\n    # ノードの高さを更新する\n    self.update_height(node)\n    self.update_height(child)\n    # 回転後の部分木の根ノードを返す\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 左回転 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // child を支点として node を左回転させる\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 左回転 */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 左回転 */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 左回転 */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // child を支点として node を左回転させる\n    child.Left = node\n    node.Right = grandChild\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 左回転 */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // child を支点として node を左回転させる\n    child?.left = node\n    node?.right = grandChild\n    // ノードの高さを更新する\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 左回転 */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 左回転 */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 左回転 */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // child を支点として node を左回転させる\n  child.left = node;\n  node.right = grandChild;\n  // ノードの高さを更新する\n  updateHeight(node);\n  updateHeight(child);\n  // 回転後の部分木の根ノードを返す\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 左回転 */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // child を支点として node を左回転させる\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // ノードの高さを更新する\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 回転後の部分木の根ノードを返す\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 左回転 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // child を支点として node を左回転させる\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 左回転 */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // child を支点として node を左回転させる\n    child.left = node\n    node.right = grandChild\n    // ノードの高さを更新する\n    updateHeight(node)\n    updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 左回転操作 ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # child を支点として node を左回転させる\n  child.left = node\n  node.right = grand_child\n  # ノードの高さを更新する\n  update_height(node)\n  update_height(child)\n  # 回転後の部分木の根ノードを返す\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   左回転してから右回転","text":"<p>以下の図の不平衡ノード 3 では、左回転だけでも右回転だけでも部分木を平衡に戻せません。この場合は、まず <code>child</code> に「左回転」を行い、次に <code>node</code> に「右回転」を行います。</p> <p></p> <p> 図 7-30   左回転してから右回転 </p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   右回転してから左回転","text":"<p>以下の図に示すように、上記の不平衡二分木の鏡像のケースでは、まず <code>child</code> に「右回転」を行い、次に <code>node</code> に「左回転」を行います。</p> <p></p> <p> 図 7-31   右回転してから左回転 </p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   回転の選択","text":"<p>以下の図に示す 4 種類の不平衡は、上の各ケースにそれぞれ対応しており、必要な操作は順に右回転、左回転してから右回転、右回転してから左回転、左回転です。</p> <p></p> <p> 図 7-32   AVL 木の 4 つの回転ケース </p> <p>以下の表に示すように、不平衡ノードの平衡係数と、高い側の子ノードの平衡係数の符号を判定することで、その不平衡ノードが上図のどのケースに属するかを判断できます。</p> <p> 表 7-3   4 種類の回転ケースの選択条件 </p> 不平衡ノードの平衡係数 子ノードの平衡係数 採用すべき回転方法 \\(&gt; 1\\) （左に偏った木） \\(\\geq 0\\) 右回転 \\(&gt; 1\\) （左に偏った木） \\(&lt;0\\) 左回転してから右回転 \\(&lt; -1\\) （右に偏った木） \\(\\leq 0\\) 左回転 \\(&lt; -1\\) （右に偏った木） \\(&gt;0\\) 右回転してから左回転 <p>使いやすくするために、回転操作を 1 つの関数にカプセル化します。この関数があれば、さまざまな不平衡ケースに対して回転を行い、不平衡ノードを再び平衡に戻せます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"回転操作を行い、この部分木の平衡を回復する\"\"\"\n    # ノード node の平衡係数を取得\n    balance_factor = self.balance_factor(node)\n    # 左に偏った木\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # 右回転\n            return self.right_rotate(node)\n        else:\n            # 左回転してから右回転\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # 右に偏った木\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # 左回転\n            return self.left_rotate(node)\n        else:\n            # 右回転してから左回転\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # 平衡木なので回転不要、そのまま返す\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode *rotate(TreeNode *node) {\n    // ノード node の平衡係数を取得\n    int _balanceFactor = balanceFactor(node);\n    // 左に偏った木\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode rotate(TreeNode node) {\n    // ノード node の平衡係数を取得\n    int balanceFactor = balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode? Rotate(TreeNode? node) {\n    // ノード node の平衡係数を取得\n    int balanceFactorInt = BalanceFactor(node);\n    // 左に偏った木\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // 右回転\n            return RightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // 左回転\n            return LeftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // ノード `node` の平衡係数を取得する\n    // Go では短い変数名が推奨されるため、ここで `bf` は `t.balanceFactor` を表す\n    bf := t.balanceFactor(node)\n    // 左に偏った木\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // 右回転\n            return t.rightRotate(node)\n        } else {\n            // 左回転してから右回転\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // 右に偏った木\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // 左回転\n            return t.leftRotate(node)\n        } else {\n            // 右回転してから左回転\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // ノード node の平衡係数を取得\n    let balanceFactor = balanceFactor(node: node)\n    // 左に偏った木\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // 右回転\n            return rightRotate(node: node)\n        } else {\n            // 左回転してから右回転\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // 右に偏った木\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // 左回転\n            return leftRotate(node: node)\n        } else {\n            // 右回転してから左回転\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\n#rotate(node) {\n    // ノード node の平衡係数を取得\n    const balanceFactor = this.balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return this.#rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return this.#leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nrotate(node: TreeNode): TreeNode {\n    // ノード node の平衡係数を取得\n    const balanceFactor = this.balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return this.rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return this.leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode? rotate(TreeNode? node) {\n  // ノード node の平衡係数を取得\n  int factor = balanceFactor(node);\n  // 左に偏った木\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // 右回転\n      return rightRotate(node);\n    } else {\n      // 左回転してから右回転\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // 右に偏った木\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // 左回転\n      return leftRotate(node);\n    } else {\n      // 右回転してから左回転\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // 平衡木なので回転不要、そのまま返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // ノード node の平衡係数を取得\n    let balance_factor = Self::balance_factor(node.clone());\n    // 左に偏った木\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // 右回転\n            Self::right_rotate(Some(node))\n        } else {\n            // 左回転してから右回転\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // 右に偏った木\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // 左回転\n            Self::left_rotate(Some(node))\n        } else {\n            // 右回転してから左回転\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // 平衡木なので回転不要、そのまま返す\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode *rotate(TreeNode *node) {\n    // ノード node の平衡係数を取得\n    int bf = balanceFactor(node);\n    // 左に偏った木\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfun rotate(node: TreeNode): TreeNode {\n    // ノード node の平衡係数を取得\n    val balanceFactor = balanceFactor(node)\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node)\n        } else {\n            // 左回転してから右回転\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node)\n        } else {\n            // 右回転してから左回転\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 回転操作を行い、この部分木の平衡を回復する ###\ndef rotate(node)\n  # ノード node の平衡係数を取得\n  balance_factor = balance_factor(node)\n  # 左部分木をたどる\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # 右回転\n      return right_rotate(node)\n    else\n      # 左回転してから右回転\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # 右に偏った木\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # 左回転\n      return left_rotate(node)\n    else\n      # 右回転してから左回転\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # 平衡木なので回転不要、そのまま返す\n  node\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl","level":2,"title":"7.5.3   AVL 木の基本操作","text":"","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   ノードの挿入","text":"<p>AVL 木のノード挿入は、基本的には二分探索木と同じです。唯一の違いは、AVL 木ではノード挿入後に、そのノードから根ノードまでの経路上に複数の不平衡ノードが現れる可能性があることです。したがって、このノードから開始して、下から上へ回転操作を行い、すべての不平衡ノードを平衡に戻す必要があります。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"ノードを挿入\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"ノードを再帰的に挿入する（補助メソッド）\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. 挿入位置を探索してノードを挿入\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # 重複ノードは挿入せず、そのまま返す\n        return node\n    # ノードの高さを更新する\n    self.update_height(node)\n    # 2. 回転操作を行い、部分木の平衡を回復する\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードを挿入 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // 重複ノードは挿入せず、そのまま返す\n    UpdateHeight(node);  // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = Rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードを挿入 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* ノードを再帰的に挿入する（補助関数） */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // 重複ノードは挿入せず、そのまま返す\n        return node\n    }\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = t.rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードを挿入 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // 重複ノードは挿入せず、そのまま返す\n    }\n    updateHeight(node: node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node: node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* ノードを挿入 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // 重複ノードは挿入せず、そのまま返す\n    this.#updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.#rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードを挿入 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // 重複ノードは挿入せず、そのまま返す\n    }\n    this.updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. 挿入位置を探索してノードを挿入 */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // 重複ノードは挿入せず、そのまま返す\n  updateHeight(node); // ノードの高さを更新する\n  /* 2. 回転操作を行い、部分木の平衡を回復する */\n  node = rotate(node);\n  // 部分木の根ノードを返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードを挿入 */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 挿入位置を探索してノードを挿入 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // 重複ノードは挿入せず、そのまま返す\n                }\n            }\n            Self::update_height(Some(node.clone())); // ノードの高さを更新する\n\n            /* 2. 回転操作を行い、部分木の平衡を回復する */\n            node = Self::rotate(Some(node)).unwrap();\n            // 部分木の根ノードを返す\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードを挿入 */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* ノードを再帰的に挿入する（補助関数） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // 重複ノードは挿入せず、そのまま返す\n        return node;\n    }\n    // ノードの高さを更新する\n    updateHeight(node);\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードを挿入 */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### ノードを挿入 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### ノードを挿入 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n# ## ノードを再帰的に挿入（補助メソッド）###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. 挿入位置を探索してノードを挿入\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # 重複ノードは挿入せず、そのまま返す\n    return node\n  end\n  # ノードの高さを更新する\n  update_height(node)\n  # 2. 回転操作を行い、部分木の平衡を回復する\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_2","level":3,"title":"2.   ノードの削除","text":"<p>同様に、二分探索木のノード削除メソッドを土台として、下から上へ回転操作を行い、すべての不平衡ノードを平衡に戻す必要があります。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"ノードを削除\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"ノードを再帰的に削除する（補助メソッド）\"\"\"\n    if node is None:\n        return None\n    # 1. ノードを探索して削除\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if child is None:\n                return None\n            # 子ノード数 = 1 の場合、node をそのまま削除する\n            else:\n                node = child\n        else:\n            # 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # ノードの高さを更新する\n    self.update_height(node)\n    # 2. 回転操作を行い、部分木の平衡を回復する\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードを削除 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = Rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードを削除 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* ノードを再帰的に削除する（補助関数） */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. ノードを探索して削除 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // 子ノード数 = 0 の場合、node をそのまま削除して返す\n                return nil\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = t.rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードを削除 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. ノードを探索して削除 */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if child == nil {\n                return nil\n            }\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else {\n                node = child\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node: node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* ノードを削除 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child === null) return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.#rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードを削除 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child === null) {\n                return null;\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. ノードを探索して削除 */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // 子ノード数 = 0 の場合、node をそのまま削除して返す\n      if (child == null)\n        return null;\n      // 子ノード数 = 1 の場合、node をそのまま削除する\n      else\n        node = child;\n    } else {\n      // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // ノードの高さを更新する\n  /* 2. 回転操作を行い、部分木の平衡を回復する */\n  node = rotate(node);\n  // 部分木の根ノードを返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードを削除 */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. ノードを探索して削除 */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // 子ノード数 = 0 の場合、node をそのまま削除して返す\n                    None =&gt; {\n                        return None;\n                    }\n                    // 子ノード数 = 1 の場合、node をそのまま削除する\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // ノードの高さを更新する\n\n            /* 2. 回転操作を行い、部分木の平衡を回復する */\n            node = Self::rotate(Some(node)).unwrap();\n            // 部分木の根ノードを返す\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードを削除 */\n// stdio.h を導入しているため、ここでは remove 識別子を使えない\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* ノードを再帰的に削除する（補助関数） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // ノードの高さを更新する\n    updateHeight(node);\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードを削除 */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. ノードを探索して削除 */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### ノードを削除 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### ノードを削除 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n# ## ノードを再帰的に削除（補助メソッド）###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. ノードを探索して削除\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # 子ノード数 = 0 の場合、node をそのまま削除して返す\n      return if child.nil?\n      # 子ノード数 = 1 の場合、node をそのまま削除する\n      node = child\n    else\n      # 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # ノードの高さを更新する\n  update_height(node)\n  # 2. 回転操作を行い、部分木の平衡を回復する\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   ノードの探索","text":"<p>AVL 木のノード探索操作は二分探索木と同じなので、ここでは繰り返しません。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl","level":2,"title":"7.5.4   AVL 木の代表的な応用","text":"<ul> <li>大規模データの整理・格納に用いられ、高頻度の探索と低頻度の追加・削除に適しています。</li> <li>データベースのインデックスシステムの構築に使われます。</li> <li>赤黒木も代表的な平衡二分探索木の一つです。AVL 木と比べると、赤黒木は平衡条件がより緩く、ノードの挿入・削除に必要な回転操作が少ないため、平均的な更新効率はより高くなります。</li> </ul>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   二分探索木","text":"<p>以下の図に示すように、二分探索木（binary search tree）は次の条件を満たします。</p> <ol> <li>根ノードについて、左部分木のすべてのノードの値 \\(&lt;\\) 根ノードの値 \\(&lt;\\) 右部分木のすべてのノードの値。</li> <li>任意のノードの左部分木と右部分木も二分探索木であり、すなわち条件 <code>1.</code> も満たします。</li> </ol> <p></p> <p> 図 7-16   二分探索木 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   二分探索木の操作","text":"<p>二分探索木をクラス <code>BinarySearchTree</code> としてカプセル化し、木の根ノードを指すメンバ変数 <code>root</code> を宣言します。</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   ノードの探索","text":"<p>目標ノードの値 <code>num</code> が与えられたら、二分探索木の性質に基づいて探索できます。以下の図に示すように、ノード <code>cur</code> を宣言し、二分木の根ノード <code>root</code> から出発して、ノード値 <code>cur.val</code> と <code>num</code> の大小関係を繰り返し比較します。</p> <ul> <li><code>cur.val &lt; num</code> の場合、目標ノードは <code>cur</code> の右部分木にあるため、<code>cur = cur.right</code> を実行します。</li> <li><code>cur.val &gt; num</code> の場合、目標ノードは <code>cur</code> の左部分木にあるため、<code>cur = cur.left</code> を実行します。</li> <li><code>cur.val = num</code> の場合、目標ノードが見つかったことを表し、ループを抜けてそのノードを返します。</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-17   二分探索木のノード探索例 </p> <p>二分探索木の探索操作は二分探索アルゴリズムと同じ原理で動作し、各ラウンドで半分の候補を除外します。ループ回数の上限は二分木の高さであり、二分木が平衡であれば \\(O(\\log n)\\) 時間です。コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"ノードを探索\"\"\"\n    cur = self._root\n    # ループで探索し、葉ノードを越えたら抜ける\n    while cur is not None:\n        # 目標ノードは cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 目標ノードは cur の左部分木にある\n        elif cur.val &gt; num:\n            cur = cur.left\n        # 目標ノードが見つかったらループを抜ける\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを探索 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 目標ノードは cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを探索 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを探索 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを探索 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // ループで探索し、葉ノードを越えたら抜ける\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // 目標ノードは cur の右部分木にある\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // 目標ノードは cur の左部分木にある\n            node = node.Left\n        } else {\n            // 目標ノードが見つかったらループを抜ける\n            break\n        }\n    }\n    // 目標ノードを返す\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを探索 */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 目標ノードは cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 目標ノードは cur の左部分木にある\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // 目標ノードが見つかったらループを抜ける\n        else {\n            break\n        }\n    }\n    // 目標ノードを返す\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを探索 */\nsearch(num) {\n    let cur = this.root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num) cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを探索 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num) cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを探索 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 目標ノードは cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 目標ノードは cur の左部分木にある\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // 目標ノードが見つかったらループを抜ける\n    else\n      break;\n  }\n  // 目標ノードを返す\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを探索 */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 目標ノードは cur の右部分木にある\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // 目標ノードは cur の左部分木にある\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // 目標ノードが見つかったらループを抜ける\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // 目標ノードを返す\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを探索 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // 目標ノードは cur の右部分木にある\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // 目標ノードは cur の左部分木にある\n            cur = cur-&gt;left;\n        } else {\n            // 目標ノードが見つかったらループを抜ける\n            break;\n        }\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを探索 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 目標ノードは cur の左部分木にある\n        else if (cur._val &gt; num)\n            cur.left\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break\n    }\n    // 目標ノードを返す\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを検索 ###\ndef search(num)\n  cur = @root\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  while !cur.nil?\n    # 目標ノードは cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 目標ノードは cur の左部分木にある\n    elsif cur.val &gt; num\n      cur = cur.left\n    # 目標ノードが見つかったらループを抜ける\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   ノードの挿入","text":"<p>挿入する要素 <code>num</code> が与えられたとき、二分探索木の「左部分木 &lt; 根ノード &lt; 右部分木」という性質を保つため、挿入操作の流れは以下の図のようになります。</p> <ol> <li>挿入位置を探索する：探索操作と同様に、根ノードから出発し、現在のノード値と <code>num</code> の大小関係に基づいて下方向へ探索を繰り返し、葉ノードを越えて（<code>None</code> まで到達して）ループを抜けます。</li> <li>その位置にノードを挿入する：ノード <code>num</code> を初期化し、そのノードを <code>None</code> の位置に置きます。</li> </ol> <p></p> <p> 図 7-18   二分探索木にノードを挿入する </p> <p>コード実装では、次の 2 点に注意が必要です。</p> <ul> <li>二分探索木では重複ノードを許可しません。そうでないと定義に反するためです。したがって、挿入対象のノードが木内にすでに存在する場合は、挿入を行わずそのまま返します。</li> <li>ノード挿入を実現するために、ノード <code>pre</code> を用いて前回のループのノードを保持する必要があります。これにより、<code>None</code> までたどり着いたときにその親ノードを取得でき、ノード挿入を完了できます。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"ノードを挿入\"\"\"\n    # 木が空なら、根ノードを初期化する\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # ループで探索し、葉ノードを越えたら抜ける\n    cur, pre = self._root, None\n    while cur is not None:\n        # 重複ノードが見つかったら、直ちに返す\n        if cur.val == num:\n            return\n        pre = cur\n        # 挿入位置は cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 挿入位置は cur の左部分木にある\n        else:\n            cur = cur.left\n    # ノードを挿入\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを挿入 */\nvoid insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur-&gt;left;\n    }\n    // ノードを挿入\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを挿入 */\nvoid insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // ノードを挿入\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを挿入 */\nvoid Insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n\n    // ノードを挿入\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを挿入 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // 木が空なら、根ノードを初期化する\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // 挿入対象ノードの直前のノード位置\n    var pre *TreeNode = nil\n    // ループで探索し、葉ノードを越えたら抜ける\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // ノードを挿入\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを挿入 */\nfunc insert(num: Int) {\n    // 木が空なら、根ノードを初期化する\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 重複ノードが見つかったら、直ちに返す\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // 挿入位置は cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 挿入位置は cur の左部分木にある\n        else {\n            cur = cur?.left\n        }\n    }\n    // ノードを挿入\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを挿入 */\ninsert(num) {\n    // 木が空なら、根ノードを初期化する\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val === num) return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else cur = cur.left;\n    }\n    // ノードを挿入\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを挿入 */\ninsert(num: number): void {\n    // 木が空なら、根ノードを初期化する\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val === num) return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else cur = cur.left;\n    }\n    // ノードを挿入\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを挿入 */\nvoid insert(int _num) {\n  // 木が空なら、根ノードを初期化する\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 重複ノードが見つかったら、直ちに返す\n    if (cur.val == _num) return;\n    pre = cur;\n    // 挿入位置は cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 挿入位置は cur の左部分木にある\n    else\n      cur = cur.left;\n  }\n  // ノードを挿入\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを挿入 */\npub fn insert(&amp;mut self, num: i32) {\n    // 木が空なら、根ノードを初期化する\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 重複ノードが見つかったら、直ちに返す\n            Ordering::Equal =&gt; return,\n            // 挿入位置は cur の右部分木にある\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 挿入位置は cur の左部分木にある\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // ノードを挿入\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを挿入 */\nvoid insert(BinarySearchTree *bst, int num) {\n    // 木が空なら、根ノードを初期化する\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 挿入位置は cur の右部分木にある\n            cur = cur-&gt;right;\n        } else {\n            // 挿入位置は cur の左部分木にある\n            cur = cur-&gt;left;\n        }\n    }\n    // ノードを挿入\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを挿入 */\nfun insert(num: Int) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur._val == num)\n            return\n        pre = cur\n        // 挿入位置は cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 挿入位置は cur の左部分木にある\n        else\n            cur.left\n    }\n    // ノードを挿入\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを挿入 ###\ndef insert(num)\n  # 木が空なら、根ノードを初期化する\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 重複ノードが見つかったら、直ちに返す\n    return if cur.val == num\n\n    pre = cur\n    # 挿入位置は cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 挿入位置は cur の左部分木にある\n    else\n      cur = cur.left\n    end\n  end\n\n  # ノードを挿入\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>ノード探索と同様に、ノード挿入には \\(O(\\log n)\\) 時間を要します。</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   ノードの削除","text":"<p>まず二分木内で目標ノードを見つけ、その後で削除します。ノード挿入と同様に、削除操作の完了後も二分探索木の「左部分木 &lt; 根ノード &lt; 右部分木」という性質が保たれる必要があります。そのため、目標ノードの子ノード数に応じて、0、1、2 の 3 つのケースに分けて対応する削除操作を行います。</p> <p>以下の図に示すように、削除対象ノードの次数が \\(0\\) のとき、そのノードは葉ノードであり、直接削除できます。</p> <p></p> <p> 図 7-19   二分探索木でノードを削除する（次数 0 ） </p> <p>以下の図に示すように、削除対象ノードの次数が \\(1\\) のとき、削除対象ノードをその子ノードで置き換えれば十分です。</p> <p></p> <p> 図 7-20   二分探索木でノードを削除する（次数 1 ） </p> <p>削除対象ノードの次数が \\(2\\) のときは、直接削除できず、別のノードでそのノードを置き換える必要があります。二分探索木の「左部分木 \\(&lt;\\) 根ノード \\(&lt;\\) 右部分木」という性質を保つ必要があるため、このノードには右部分木の最小ノードまたは左部分木の最大ノードを使えます。</p> <p>右部分木の最小ノード（中順走査で次のノード）を選ぶと仮定すると、削除操作の流れは以下の図のようになります。</p> <ol> <li>削除対象ノードの「中順走査列」における次のノードを見つけ、<code>tmp</code> と記します。</li> <li><code>tmp</code> の値で削除対象ノードの値を上書きし、木の中でノード <code>tmp</code> を再帰的に削除します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-21   二分探索木でノードを削除する（次数 2 ） </p> <p>ノード削除操作も同様に \\(O(\\log n)\\) 時間を要します。削除対象ノードの探索に \\(O(\\log n)\\) 時間、中順走査の後続ノードの取得に \\(O(\\log n)\\) 時間が必要です。コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"ノードを削除\"\"\"\n    # 木が空なら、そのまま早期リターンする\n    if self._root is None:\n        return\n    # ループで探索し、葉ノードを越えたら抜ける\n    cur, pre = self._root, None\n    while cur is not None:\n        # 削除対象のノードが見つかったら、ループを抜ける\n        if cur.val == num:\n            break\n        pre = cur\n        # 削除対象ノードは cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 削除対象ノードは cur の左部分木にある\n        else:\n            cur = cur.left\n    # 削除対象ノードがなければそのまま返す\n    if cur is None:\n        return\n\n    # 子ノード数 = 0 or 1\n    if cur.left is None or cur.right is None:\n        # 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        child = cur.left or cur.right\n        # ノード cur を削除する\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # 削除ノードが根ノードなら、根ノードを再設定\n            self._root = child\n    # 子ノード数 = 2\n    else:\n        # 中順走査における cur の次ノードを取得\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # ノード tmp を再帰的に削除\n        self.remove(tmp.val)\n        # tmp で cur を上書きする\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを削除 */\nvoid remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur-&gt;left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == nullptr)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n        // メモリを解放する\n        delete cur;\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // ノード tmp を再帰的に削除\n        remove(tmp-&gt;val);\n        // tmp で cur を上書きする\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを削除 */\nvoid remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        remove(tmp.val);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを削除 */\nvoid Remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        TreeNode? child = cur.left ?? cur.right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        Remove(tmp.val!.Value);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを削除 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // 木が空なら、そのまま早期リターンする\n    if cur == nil {\n        return\n    }\n    // 削除対象ノードの直前のノード位置\n    var pre *TreeNode = nil\n    // ループで探索し、葉ノードを越えたら抜ける\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // 削除対象ノードは右部分木にある\n            cur = cur.Right\n        } else {\n            // 削除対象ノードは左部分木にある\n            cur = cur.Left\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur == nil {\n        return\n    }\n    // 子ノード数は 0 または 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // 削除対象ノードの子ノードを取り出す\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // ノード cur を削除する\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            bst.root = child\n        }\n        // 子ノード数は 2\n    } else {\n        // 中順走査で削除対象ノード `cur` の次のノードを取得する\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // ノード tmp を再帰的に削除\n        bst.remove(tmp.Val.(int))\n        // tmp で cur を上書きする\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを削除 */\nfunc remove(num: Int) {\n    // 木が空なら、そのまま早期リターンする\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // 削除対象ノードは cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 削除対象ノードは cur の左部分木にある\n        else {\n            cur = cur?.left\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur == nil {\n        return\n    }\n    // 子ノード数 = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        let child = cur?.left ?? cur?.right\n        // ノード cur を削除する\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // ノード tmp を再帰的に削除\n        remove(num: tmp!.val)\n        // tmp で cur を上書きする\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを削除 */\nremove(num) {\n    // 木が空なら、そのまま早期リターンする\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val === num) break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur === null) return;\n    // 子ノード数 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        const child = cur.left !== null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            this.root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        this.remove(tmp.val);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを削除 */\nremove(num: number): void {\n    // 木が空なら、そのまま早期リターンする\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val === num) break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur === null) return;\n    // 子ノード数 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            this.root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // ノード tmp を再帰的に削除\n        this.remove(tmp!.val);\n        // tmp で cur を上書きする\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを削除 */\nvoid remove(int _num) {\n  // 木が空なら、そのまま早期リターンする\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 削除対象のノードが見つかったら、ループを抜ける\n    if (cur.val == _num) break;\n    pre = cur;\n    // 削除対象ノードは cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 削除対象ノードは cur の左部分木にある\n    else\n      cur = cur.left;\n  }\n  // 削除対象ノードがない場合は、そのまま返す\n  if (cur == null) return;\n  // 子ノード数 = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n    TreeNode? child = cur.left ?? cur.right;\n    // ノード cur を削除する\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // 削除ノードが根ノードなら、根ノードを再設定\n      _root = child;\n    }\n  } else {\n    // 子ノード数 = 2\n    // 中順走査における cur の次のノードを取得\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // ノード tmp を再帰的に削除\n    remove(tmp.val);\n    // tmp で cur を上書きする\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを削除 */\npub fn remove(&amp;mut self, num: i32) {\n    // 木が空なら、そのまま早期リターンする\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 削除対象のノードが見つかったら、ループを抜ける\n            Ordering::Equal =&gt; break,\n            // 削除対象ノードは cur の右部分木にある\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 削除対象ノードは cur の左部分木にある\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // 子ノード数 = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // ノード cur を削除する\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // 削除ノードが根ノードなら、根ノードを再設定\n                self.root = child;\n            }\n        }\n        // 子ノード数 = 2\n        (Some(_), Some(_)) =&gt; {\n            // 中順走査における cur の次ノードを取得\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // ノード tmp を再帰的に削除\n            self.remove(tmp_val);\n            // tmp で cur を上書きする\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを削除 */\n// stdio.h を導入しているため、ここでは remove 識別子を使えない\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 削除対象ノードは root の右部分木にある\n            cur = cur-&gt;right;\n        } else {\n            // 削除対象ノードは root の左部分木にある\n            cur = cur-&gt;left;\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == NULL)\n        return;\n    // 削除対象ノードに子ノードがあるかを判定する\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* 子ノード数 = 0 or 1 */\n        // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // ノード cur を削除する\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // メモリを解放する\n        free(cur);\n    } else {\n        /* 子ノード数 = 2 */\n        // 中順走査における cur の次ノードを取得\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // ノード tmp を再帰的に削除\n        removeItem(bst, tmp-&gt;val);\n        // tmp で cur を上書きする\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを削除 */\nfun remove(num: Int) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur._val == num)\n            break\n        pre = cur\n        // 削除対象ノードは cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur.left\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child\n        }\n        // 子ノード数 = 2\n    } else {\n        // 中順走査における cur の次ノードを取得\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // ノード tmp を再帰的に削除\n        remove(tmp._val)\n        // tmp で cur を上書きする\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを削除 ###\ndef remove(num)\n  # 木が空なら、そのまま早期リターンする\n  return if @root.nil?\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 削除対象のノードが見つかったら、ループを抜ける\n    break if cur.val == num\n\n    pre = cur\n    # 削除対象ノードは cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 削除対象ノードは cur の左部分木にある\n    else\n      cur = cur.left\n    end\n  end\n  # 削除対象ノードがなければそのまま返す\n  return if cur.nil?\n\n  # 子ノード数 = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # 子ノード数が 0 / 1 のとき、child = null / その子ノード\n    child = cur.left || cur.right\n    # ノード cur を削除する\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # 削除ノードが根ノードなら、根ノードを再設定\n      @root = child\n    end\n  # 子ノード数 = 2\n  else\n    # 中順走査における cur の次ノードを取得\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # ノード tmp を再帰的に削除\n    remove(tmp.val)\n    # tmp で cur を上書きする\n    cur.val = tmp.val\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   中順走査は昇順","text":"<p>以下の図に示すように、二分木の中順走査は「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」という順序に従い、二分探索木は「左子ノード \\(&lt;\\) 根ノード \\(&lt;\\) 右子ノード」という大小関係を満たします。</p> <p>これは、二分探索木で中順走査を行うと常に次の最小ノードが優先して走査されることを意味し、そこから重要な性質が導かれます。二分探索木の中順走査列は昇順です。</p> <p>中順走査が昇順になる性質を利用すれば、二分探索木から整列済みデータを取得するのに必要な時間は \\(O(n)\\) のみで、追加のソート操作は不要です。非常に効率的です。</p> <p></p> <p> 図 7-22   二分探索木の中順走査列 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   二分探索木の効率","text":"<p>あるデータ集合が与えられたとき、配列または二分探索木で格納する場合を考えます。次の表を見ると、二分探索木の各操作の時間計算量はいずれも対数オーダーであり、安定して高効率です。高頻度の追加と低頻度の探索・削除という場面でのみ、配列のほうが二分探索木より効率的です。</p> <p> 表 7-2   配列と探索木の効率比較 </p> 無秩序配列 二分探索木 要素の探索 \\(O(n)\\) \\(O(\\log n)\\) 要素の挿入 \\(O(1)\\) \\(O(\\log n)\\) 要素の削除 \\(O(n)\\) \\(O(\\log n)\\) <p>理想的な状況では、二分探索木は「平衡」しており、その場合は \\(\\log n\\) 回のループ内で任意のノードを探索できます。</p> <p>しかし、二分探索木でノードの挿入と削除を繰り返すと、二分木が以下の図のような連結リストへ退化する可能性があり、このとき各操作の時間計算量も \\(O(n)\\) に退化します。</p> <p></p> <p> 図 7-23   二分探索木の退化 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   二分探索木の代表的な応用","text":"<ul> <li>システム内の多段インデックスとして用いられ、効率的な探索、挿入、削除操作を実現します。</li> <li>一部の探索アルゴリズムの基盤データ構造として使われます。</li> <li>データストリームを格納し、その順序状態を保つために使われます。</li> </ul>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   二分木","text":"<p>二分木（binary tree）は非線形データ構造の一種であり、「祖先」と「子孫」の派生関係を表し、「一つを二つに分ける」分割統治の考え方を体現しています。連結リストと同様に、二分木の基本単位はノードであり、各ノードは値、左子ノードへの参照、右子ノードへの参照を含みます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"二分木ノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # ノード値\n        self.left: TreeNode | None = None  # 左子ノード参照\n        self.right: TreeNode | None = None # 右子ノード参照\n</code></pre> <pre><code>/* 二分木ノード構造体 */\nstruct TreeNode {\n    int val;          // ノード値\n    TreeNode *left;   // 左子ノードポインタ\n    TreeNode *right;  // 右子ノードポインタ\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    int val;         // ノード値\n    TreeNode left;   // 左子ノード参照\n    TreeNode right;  // 右子ノード参照\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode(int? x) {\n    public int? val = x;    // ノード値\n    public TreeNode? left;  // 左子ノード参照\n    public TreeNode? right; // 右子ノード参照\n}\n</code></pre> <pre><code>/* 二分木ノード構造体 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* コンストラクタ */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // 左子ノードポインタ\n        Right: nil, // 右子ノードポインタ\n        Val:   v,   // ノード値\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    var val: Int // ノード値\n    var left: TreeNode? // 左子ノード参照\n    var right: TreeNode? // 右子ノード参照\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    val; // ノード値\n    left; // 左子ノードポインタ\n    right; // 右子ノードポインタ\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // ノード値\n        this.left = left === undefined ? null : left; // 左子ノード参照\n        this.right = right === undefined ? null : right; // 右子ノード参照\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n  int val;         // ノード値\n  TreeNode? left;  // 左子ノード参照\n  TreeNode? right; // 右子ノード参照\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 二分木ノード構造体 */\nstruct TreeNode {\n    val: i32,                               // ノード値\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子ノード参照\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子ノード参照\n}\n\nimpl TreeNode {\n    /* コンストラクタ */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* 二分木ノード構造体 */\ntypedef struct TreeNode {\n    int val;                // ノード値\n    int height;             // ノードの高さ\n    struct TreeNode *left;  // 左子ノードポインタ\n    struct TreeNode *right; // 右子ノードポインタ\n} TreeNode;\n\n/* コンストラクタ */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode(val _val: Int) {  // ノード値\n    val left: TreeNode? = null   // 左子ノード参照\n    val right: TreeNode? = null  // 右子ノード参照\n}\n</code></pre> <pre><code>### 二分木ノードクラス ###\nclass TreeNode\n  attr_accessor :val    # ノード値\n  attr_accessor :left   # 左子ノード参照\n  attr_accessor :right  # 右子ノード参照\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>各ノードは 2 つの参照（ポインタ）を持ち、それぞれ左子ノード（left-child node）と右子ノード（right-child node）を指します。このノードはこれら 2 つの子ノードの親ノード（parent node）と呼ばれます。二分木のあるノードが与えられたとき、そのノードの左子ノードとその配下のノードからなる木をそのノードの左部分木（left subtree）と呼び、同様に右部分木（right subtree）が定義されます。</p> <p>二分木では、葉ノードを除くすべてのノードが子ノードと空でない部分木を持ちます。以下の図に示すように、「ノード 2」を親ノードとみなすと、その左子ノードと右子ノードはそれぞれ「ノード 4」と「ノード 5」であり、左部分木は「ノード 4 とその配下のノードからなる木」、右部分木は「ノード 5 とその配下のノードからなる木」です。</p> <p></p> <p> 図 7-1   親ノード、子ノード、部分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   二分木のよく使われる用語","text":"<p>二分木でよく使われる用語を以下の図に示します。</p> <ul> <li>根ノード（root node）：二分木の最上位にあるノードで、親ノードを持ちません。</li> <li>葉ノード（leaf node）：子ノードを持たないノードで、2 本のポインタはいずれも <code>None</code> を指します。</li> <li>辺（edge）：2 つのノードを結ぶ線分、すなわちノード参照（ポインタ）です。</li> <li>ノードが属するレベル（level）：上から下へ向かって増加し、根ノードのレベルは 1 です。</li> <li>ノードの次数（degree）：ノードの子ノードの数。二分木では次数の取り得る値は 0、1、2 です。</li> <li>二分木の高さ（height）：根ノードから最も遠い葉ノードまでに通る辺の数。</li> <li>ノードの深さ（depth）：根ノードからそのノードまでに通る辺の数。</li> <li>ノードの高さ（height）：そのノードから最も遠い葉ノードまでに通る辺の数。</li> </ul> <p></p> <p> 図 7-2   二分木のよく使われる用語 </p> <p>Tip</p> <p>なお、通常「高さ」と「深さ」は「通過した辺の数」と定義しますが、問題や教材によっては「通過したノードの数」と定義する場合もあります。その場合、高さと深さはいずれも 1 を加える必要があります。</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   二分木の基本操作","text":"","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   二分木を初期化する","text":"<p>連結リストと同様に、まずノードを初期化し、その後で参照（ポインタ）を構築します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 二分木を初期化する\n# ノードを初期化する\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// ノードを初期化する\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// ノード間の参照（ポインタ）を構築する\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// ノードを初期化する\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// ノードを初期化する\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// ノード間の参照（ポインタ）を構築する\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// ノードを初期化する\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># 二分木を初期化する\n# ノードを初期化する\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   ノードの挿入と削除","text":"<p>連結リストと同様に、二分木でのノードの挿入と削除はポインタを変更することで実現できます。以下の図に 1 つの例を示します。</p> <p></p> <p> 図 7-3   二分木でノードを挿入・削除する </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># ノードの挿入と削除\np = TreeNode(0)\n# n1 -&gt; n2 の間にノード P を挿入する\nn1.left = p\np.left = n2\n# ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* ノードの挿入と削除 */\nTreeNode* P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1-&gt;left = P;\nP-&gt;left = n2;\n// ノード P を削除する\nn1-&gt;left = n2;\n// メモリを解放する\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* ノードの挿入と削除 */\nTreeNode P = new(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* ノードの挿入と削除 */\n// n1 -&gt; n2 の間にノード P を挿入する\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// ノード P を削除する\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P\nP.left = n2\n// ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* ノードの挿入と削除 */\nlet P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* ノードの挿入と削除 */\nconst P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* ノードの挿入と削除 */\nTreeNode P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// ノード p を削除する\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* ノードの挿入と削除 */\nTreeNode *P = newTreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1-&gt;left = P;\nP-&gt;left = n2;\n// ノード P を削除する\nn1-&gt;left = n2;\n// メモリを解放する\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P\nP.left = n2\n// ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># ノードの挿入と削除\n_p = TreeNode.new(0)\n# n1 -&gt; n2 の間にノード _p を挿入する\nn1.left = _p\n_p.left = n2\n# ノードを削除する\nn1.left = n2\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%E6%8F%92%E5%85%A5%E4%B8%8E%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%E5%9C%A8%20n1%20-%3E%20n2%20%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20n2&amp;cumulative=false&amp;curInstr=37&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Tip</p> <p>注意すべき点として、ノードの挿入は二分木の元の論理構造を変える可能性があり、ノードの削除は通常、そのノードと配下のすべての部分木の削除を意味します。そのため、二分木における挿入と削除は、実際に意味のある操作を実現するために、通常は一連の操作を組み合わせて行います。</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   一般的な二分木の種類","text":"","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   充足二分木","text":"<p>以下の図に示すように、充足二分木（perfect binary tree）ではすべてのレベルのノードが完全に埋まっています。充足二分木では、葉ノードの次数は \\(0\\) で、それ以外のすべてのノードの次数は \\(2\\) です。木の高さを \\(h\\) とすると、ノード総数は \\(2^{h+1} - 1\\) となり、標準的な指数関係を示して、自然界でよく見られる細胞分裂の現象を反映しています。</p> <p>Tip</p> <p>なお、中国語圏では充足二分木は満二分木と呼ばれることもあります。</p> <p></p> <p> 図 7-4   充足二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   完全二分木","text":"<p>以下の図に示すように、完全二分木（complete binary tree）では最下層のノードだけが完全に埋まっていなくてもよく、しかも最下層のノードは左から右へ連続して詰められていなければなりません。なお、充足二分木も完全二分木の一種です。</p> <p></p> <p> 図 7-5   完全二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   充満二分木","text":"<p>以下の図に示すように、充満二分木（full binary tree）では、葉ノードを除くすべてのノードが 2 つの子ノードを持ちます。</p> <p></p> <p> 図 7-6   充満二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   平衡二分木","text":"<p>以下の図に示すように、平衡二分木（balanced binary tree）では、任意のノードについて左部分木と右部分木の高さの差の絶対値が 1 を超えません。</p> <p></p> <p> 図 7-7   平衡二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   二分木の退化","text":"<p>以下の図は、二分木の理想的な構造と退化した構造を示しています。二分木の各レベルのノードがすべて埋まっていると「充足二分木」となり、すべてのノードが片側に偏ると二分木は「連結リスト」へ退化します。</p> <ul> <li>充足二分木は理想的なケースであり、二分木の「分割統治」の利点を十分に発揮できます。</li> <li>連結リストはその対極にあり、各種操作はすべて線形操作となり、時間計算量は \\(O(n)\\) まで退化します。</li> </ul> <p></p> <p> 図 7-8   二分木の最良構造と最悪構造 </p> <p>以下の表に示すように、最良構造と最悪構造では、二分木の葉ノード数、ノード総数、高さなどが極大または極小になります。</p> <p> 表 7-1   二分木の最良構造と最悪構造 </p> 充足二分木 連結リスト 第 \\(i\\) レベルのノード数 \\(2^{i-1}\\) \\(1\\) 高さ \\(h\\) の木の葉ノード数 \\(2^h\\) \\(1\\) 高さ \\(h\\) の木のノード総数 \\(2^{h+1} - 1\\) \\(h + 1\\) ノード総数 \\(n\\) の木の高さ \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   二分木の走査","text":"<p>物理構造の観点から見ると、木は連結リストを基盤としたデータ構造であり、その走査はポインタを通じてノードへ順にアクセスすることで行われます。しかし、木は非線形データ構造であるため、木の走査は連結リストの走査よりも複雑であり、検索アルゴリズムを用いて実現する必要があります。</p> <p>二分木の一般的な走査方法には、レベル順走査、先行順走査、中間順走査、後行順走査などがあります。</p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   レベル順走査","text":"<p>次の図に示すように、レベル順走査（level-order traversal）では、二分木を上から下へ層ごとに走査し、各層では左から右の順にノードへアクセスします。</p> <p>レベル順走査は本質的に幅優先走査（breadth-first traversal）に属し、幅優先探索（breadth-first search, BFS）とも呼ばれます。これは「同心円状に外側へ広がる」ような、層ごとの走査方法を表しています。</p> <p></p> <p> 図 7-9   二分木のレベル順走査 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   コードの実装","text":"<p>幅優先走査は通常「キュー」を用いて実装します。キューは「先入れ先出し」の規則に従い、幅優先走査は「層ごとに進む」という規則に従います。両者の背後にある考え方は一致しています。実装コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"レベル順走査\"\"\"\n    # キューを初期化し、ルートノードを追加する\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # 走査順序を保存するためのリストを初期化する\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # デキュー\n        res.append(node.val)  # ノードの値を保存する\n        if node.left is not None:\n            queue.append(node.left)  # 左子ノードをキューに追加\n        if node.right is not None:\n            queue.append(node.right)  # 右子ノードをキューに追加\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* レベル順走査 */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // キューを初期化し、ルートノードを追加する\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // 走査順序を保存するためのリストを初期化する\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // デキュー\n        vec.push_back(node-&gt;val); // ノードの値を保存する\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // 左子ノードをキューに追加\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // 右子ノードをキューに追加\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* レベル順走査 */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // キューを初期化し、ルートノードを追加する\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // 走査順序を保存するためのリストを初期化する\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // デキュー\n        list.add(node.val);           // ノードの値を保存する\n        if (node.left != null)\n            queue.offer(node.left);   // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.offer(node.right);  // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* レベル順走査 */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // キューを初期化し、ルートノードを追加する\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // 走査順序を保存するためのリストを初期化する\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // デキュー\n        list.Add(node.val!.Value);       // ノードの値を保存する\n        if (node.left != null)\n            queue.Enqueue(node.left);    // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.Enqueue(node.right);   // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* レベル順走査 */\nfunc levelOrder(root *TreeNode) []any {\n    // キューを初期化し、ルートノードを追加する\n    queue := list.New()\n    queue.PushBack(root)\n    // 走査順を保存するためのスライスを初期化する\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // デキュー\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // ノードの値を保存する\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // 左子ノードをキューに追加\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // 右子ノードをキューに追加\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* レベル順走査 */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // キューを初期化し、ルートノードを追加する\n    var queue: [TreeNode] = [root]\n    // 走査順序を保存するためのリストを初期化する\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // デキュー\n        list.append(node.val) // ノードの値を保存する\n        if let left = node.left {\n            queue.append(left) // 左子ノードをキューに追加\n        }\n        if let right = node.right {\n            queue.append(right) // 右子ノードをキューに追加\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* レベル順走査 */\nfunction levelOrder(root) {\n    // キューを初期化し、ルートノードを追加する\n    const queue = [root];\n    // 走査順序を保存するためのリストを初期化する\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // デキュー\n        list.push(node.val); // ノードの値を保存する\n        if (node.left) queue.push(node.left); // 左子ノードをキューに追加\n        if (node.right) queue.push(node.right); // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* レベル順走査 */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // キューを初期化し、ルートノードを追加する\n    const queue = [root];\n    // 走査順序を保存するためのリストを初期化する\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // デキュー\n        list.push(node.val); // ノードの値を保存する\n        if (node.left) {\n            queue.push(node.left); // 左子ノードをキューに追加\n        }\n        if (node.right) {\n            queue.push(node.right); // 右子ノードをキューに追加\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* レベル順走査 */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // キューを初期化し、ルートノードを追加する\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // 走査順序を保存するためのリストを初期化する\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // デキュー\n    res.add(node!.val); // ノードの値を保存する\n    if (node.left != null) queue.add(node.left); // 左子ノードをキューに追加\n    if (node.right != null) queue.add(node.right); // 右子ノードをキューに追加\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* レベル順走査 */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // キューを初期化し、ルートノードを追加する\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // 走査順序を保存するためのリストを初期化する\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // デキュー\n        vec.push(node.borrow().val); // ノードの値を保存する\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // 左子ノードをキューに追加\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // 右子ノードをキューに追加\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* レベル順走査 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* 補助キュー */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* 補助キュー */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // キューへのポインタ\n    front = 0, rear = 0;\n    // 根ノードを追加する\n    queue[rear++] = root;\n    // 走査順序を保存するためのリストを初期化する\n    /* 補助配列 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // 配列ポインタ\n    index = 0;\n    while (front &lt; rear) {\n        // デキュー\n        node = queue[front++];\n        // ノードの値を保存する\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // 左子ノードをキューに追加\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // 右子ノードをキューに追加\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // 配列長の値を更新\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // 補助配列の領域を解放する\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* レベル順走査 */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // キューを初期化し、ルートノードを追加する\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // 走査順序を保存するためのリストを初期化する\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // デキュー\n        list.add(node?._val!!)       // ノードの値を保存する\n        if (node.left != null)\n            queue.offer(node.left)   // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.offer(node.right)  // 右子ノードをキューに追加\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### レベル順走査 ###\ndef level_order(root)\n  # キューを初期化し、ルートノードを追加する\n  queue = [root]\n  # 走査順序を保存するためのリストを初期化する\n  res = []\n  while !queue.empty?\n    node = queue.shift # デキュー\n    res &lt;&lt; node.val # ノードの値を保存する\n    queue &lt;&lt; node.left unless node.left.nil? # 左子ノードをキューに追加\n    queue &lt;&lt; node.right unless node.right.nil? # 右子ノードをキューに追加\n  end\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   計算量","text":"<ul> <li>時間計算量は \\(O(n)\\) ：すべてのノードを1回ずつ訪問するため、計算量は \\(O(n)\\) です。ここで、\\(n\\) はノード数です。</li> <li>空間計算量は \\(O(n)\\) ：最悪の場合、すなわち完全二分木では、最下層に到達する前に、キュー内には最大で同時に \\((n + 1) / 2\\) 個のノードが存在し、\\(O(n)\\) の空間を使用します。</li> </ul>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   先行順・中間順・後行順走査","text":"<p>同様に、先行順・中間順・後行順走査はいずれも深度優先走査（depth-first traversal）に属し、深度優先探索（depth-first search, DFS）とも呼ばれます。これは「まず行き止まりまで進み、その後で戻って続ける」という走査方法を表しています。</p> <p>次の図は、二分木に対して深度優先走査を行う仕組みを示しています。深度優先走査は、二分木全体の外周をぐるりと「一周する」ようなものです。各ノードでは3つの位置に出会い、それぞれが先行順走査・中間順走査・後行順走査に対応します。</p> <p></p> <p> 図 7-10   二分探索木の先行順・中間順・後行順走査 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   コードの実装","text":"<p>深度優先探索は通常、再帰に基づいて実装されます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"先行順走査\"\"\"\n    if root is None:\n        return\n    # 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"中順走査\"\"\"\n    if root is None:\n        return\n    # 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"後順走査\"\"\"\n    if root is None:\n        return\n    # 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* 先行順走査 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* 中順走査 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* 後順走査 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* 先行順走査 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* 中順走査 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* 後順走査 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* 先行順走査 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* 中順走査 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* 後順走査 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* 先行順走査 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* 先行順走査 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* 先行順走査 */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 中順走査 */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 後順走査 */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* 先行順走査 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* 中順走査 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* 後順走査 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### 前順走査 ###\ndef pre_order(root)\n  return if root.nil?\n\n  # 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### 中順走査 ###\ndef in_order(root)\n  return if root.nil?\n\n  # 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### 後順走査 ###\ndef post_order(root)\n  return if root.nil?\n\n  # 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>Tip</p> <p>深度優先探索は反復によって実装することもできます。興味のある読者は自身で調べてみてください。</p> <p>次の図は、二分木の先行順走査における再帰の過程を示しており、「行き」と「帰り」という2つの逆向きの部分に分けられます。</p> <ol> <li>「行き」は新しいメソッドの開始を表し、この過程でプログラムは次のノードにアクセスします。</li> <li>「帰り」は関数の復帰を表し、現在のノードへのアクセスが完了したことを意味します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 7-11   先行順走査の再帰過程 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   計算量","text":"<ul> <li>時間計算量は \\(O(n)\\) ：すべてのノードを1回ずつ訪問するため、計算量は \\(O(n)\\) です。</li> <li>空間計算量は \\(O(n)\\) ：最悪の場合、すなわち木が連結リストに退化したとき、再帰の深さは \\(n\\) に達し、システムは \\(O(n)\\) のスタックフレーム空間を使用します。</li> </ul>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   まとめ","text":"","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>二分木は非線形データ構造の一種であり、「二分する」分割統治の考え方を体現している。各二分木ノードは 1 つの値と 2 本のポインタを持ち、それぞれ左子ノードと右子ノードを指す。</li> <li>二分木のあるノードについて、その左（右）子ノードおよびその配下から構成される木を、そのノードの左（右）部分木と呼ぶ。</li> <li>二分木に関する用語には、根ノード、葉ノード、レベル、次数、辺、高さ、深さなどがある。</li> <li>二分木の初期化、ノードの挿入、ノードの削除は、連結リストの操作方法と似ている。</li> <li>一般的な二分木の種類には、perfect 二分木、complete 二分木、full 二分木、平衡二分木がある。perfect 二分木が最も理想的な状態であり、連結リストは退化後の最悪の状態である。</li> <li>二分木は配列で表現できる。方法としては、ノード値と空き位置をレベル順走査の順に並べ、親ノードと子ノードのインデックス対応関係に基づいてポインタを実現する。</li> <li>二分木のレベル順走査は幅優先探索の一種であり、「同心円状に外へ広がる」ような逐次的な走査方式を表しており、通常はキューによって実装される。</li> <li>前順、中順、後順走査はいずれも深さ優先探索に属し、「まず末端まで進み、その後バックトラックして続ける」という走査方式を体現しており、通常は再帰で実装される。</li> <li>二分探索木は効率的な要素探索データ構造であり、探索、挿入、削除の時間計算量はいずれも \\(O(\\log n)\\) である。二分探索木が連結リストへ退化すると、各操作の時間計算量は \\(O(n)\\) まで悪化する。</li> <li>AVL 木は平衡二分探索木とも呼ばれ、回転操作によって、ノードの挿入と削除を繰り返した後も木が平衡を保つようにしている。</li> <li>AVL 木の回転操作には、右回転、左回転、右回転してから左回転、左回転してから右回転がある。ノードの挿入または削除の後、AVL 木は下から上へ回転操作を行い、木を再び平衡状態に戻す。</li> </ul>","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ノードが 1 つしかない二分木では、木の高さと根ノードの深さはどちらも \\(0\\) ですか？</p> <p>はい。高さと深さは通常「通過した辺の本数」として定義されるからです。</p> <p>Q：二分木における挿入と削除は通常一連の操作を組み合わせて完了しますが、ここでいう「一連の操作」とは何を指すのでしょうか？リソースの子ノードに対するリソース解放と理解できますか？</p> <p>二分探索木を例にすると、ノード削除は 3 つのケースに分けて処理する必要があり、各ケースで複数段階のノード操作が必要になります。</p> <p>Q：なぜ DFS による二分木走査には前順・中順・後順の 3 種類があり、それぞれどのような用途があるのですか？</p> <p>配列の順方向走査と逆方向走査に似て、前順・中順・後順走査は二分木の 3 つの走査方法であり、特定の順序で走査結果を得るために使えます。たとえば二分探索木では、ノードの大小関係が <code>左子ノードの値 &lt; 根ノードの値 &lt; 右子ノードの値</code> を満たすため、「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」の優先順で木を走査すれば、整列済みのノード列を得られます。</p> <p>Q：右回転操作は不平衡ノード <code>node</code>、<code>child</code>、<code>grand_child</code> の関係を処理するものですが、<code>node</code> の親ノードと <code>node</code> の元の接続は維持しなくてよいのですか？右回転後に切れてしまいませんか？</p> <p>この問題は再帰の視点から考える必要があります。右回転操作 <code>right_rotate(root)</code> に渡されるのは部分木の根ノードであり、最終的に <code>return child</code> によって回転後の部分木の根ノードを返します。部分木の根ノードとその親ノードの接続は、この関数の返却後に行われるため、右回転操作自身が管理する範囲には含まれません。</p> <p>Q：C++ では関数を <code>private</code> と <code>public</code> に分けますが、この設計にはどのような考えがありますか？なぜ <code>height()</code> 関数と <code>updateHeight()</code> 関数をそれぞれ <code>public</code> と <code>private</code> に置くのですか？</p> <p>主に、そのメソッドの利用範囲を見て決めます。メソッドがクラス内部でしか使われないなら、<code>private</code> に設計します。たとえば、利用者が <code>updateHeight()</code> を単独で呼び出しても意味はなく、これは挿入や削除の途中の 1 ステップにすぎません。一方で <code>height()</code> はノードの高さにアクセスするためのもので、<code>vector.size()</code> に似た役割を持つため、使いやすいように <code>public</code> に設定します。</p> <p>Q：入力データの集合から二分探索木をどのように構築しますか？根ノードの選び方は重要ですか？</p> <p>はい。木の構築方法は、二分探索木のコード中の <code>build_tree()</code> メソッドですでに示されています。根ノードの選択については、通常は入力データをソートし、その中央の要素を根ノードにしてから、左右の部分木を再帰的に構築します。こうすることで、木の平衡性を最大限に保てます。</p> <p>Q：Java では、文字列比較には必ず <code>equals()</code> メソッドを使うべきですか？</p> <p>Java では、基本データ型については <code>==</code> を使って 2 つの変数の値が等しいかどうかを比較します。参照型については、この 2 つの記法の働き方は異なります。</p> <ul> <li><code>==</code> ：2 つの変数が同じオブジェクトを指しているか、つまりメモリ上の位置が同じかどうかを比較するために使います。</li> <li><code>equals()</code>：2 つのオブジェクトの値が等しいかどうかを比較するために使います。</li> </ul> <p>したがって、値を比較したい場合は <code>equals()</code> を使うべきです。ただし、<code>String a = \"hi\"; String b = \"hi\";</code> によって初期化された文字列は文字列定数プールに格納され、同じオブジェクトを指すため、<code>a == b</code> でも 2 つの文字列の内容を比較できます。</p> <p>Q：幅優先走査で最下層に到達する前、キュー内のノード数は \\(2^h\\) ですか？</p> <p>はい。たとえば高さ \\(h = 2\\) の充足二分木では、ノード総数は \\(n = 7\\) であり、最下層のノード数は \\(4 = 2^h = (n + 1) / 2\\) です。</p>","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]}]}
\ No newline at end of file
+{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"第 16 章   付録","text":"","path":["第 16 章 &nbsp; 付録"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"章の内容","text":"<ul> <li>16.1   プログラミング環境のインストール</li> <li>16.2   一緒に制作に参加しましょう</li> <li>16.3   用語集</li> </ul>","path":["第 16 章 &nbsp; 付録"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   一緒に制作に参加しましょう","text":"<p>著者の力には限りがあるため、本書にはどうしても一部の漏れや誤りが含まれる可能性があります。ご了承ください。誤字、リンク切れ、内容の欠落、表現の曖昧さ、説明の不明瞭さ、文章構成の不適切さなどの問題を見つけた場合は、ぜひ修正にご協力ください。読者により良い学習リソースを提供できます。</p> <p>すべての寄稿者の GitHub ID は、本書のリポジトリ、Web 版、PDF 版のホームページに掲載され、オープンソースコミュニティへの惜しみない貢献に感謝を表します。</p> <p>オープンソースの魅力</p> <p>紙の書籍では、2 回の増刷の間隔が長くなりがちで、内容更新は非常に不便です。</p> <p>一方、このオープンソース書籍では、内容更新のサイクルは数日、場合によっては数時間にまで短縮されています。</p>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   内容の微調整","text":"<p>以下の図のように、各ページの右上には「編集アイコン」があります。次の手順で本文やコードを修正できます。</p> <ol> <li>「編集アイコン」をクリックし、「このリポジトリを Fork する必要があります」と表示された場合は、その操作を承認してください。</li> <li>Markdown のソースファイルを修正し、内容が正しいことを確認したうえで、できるだけ書式の統一を保ってください。</li> <li>ページ下部に修正内容の説明を入力し、その後「Propose file change」ボタンをクリックします。ページ遷移後、「Create pull request」ボタンをクリックするとプルリクエストを作成できます。</li> </ol> <p></p> <p> 図 16-3   ページ編集ボタン </p> <p>画像は直接修正できないため、新しい Issue を作成するかコメントで問題を説明してください。できるだけ早く描き直して差し替えます。</p>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   コンテンツ制作","text":"<p>コードを他のプログラミング言語へ翻訳することや、記事内容を拡充することなど、このオープンソースプロジェクトへの参加に興味がある場合は、以下の Pull Request ワークフローに従ってください。</p> <ol> <li>GitHub にログインし、本書のコードリポジトリを個人アカウントに Fork します。</li> <li>Fork したリポジトリのページに入り、<code>git clone</code> コマンドを使ってリポジトリをローカルにクローンします。</li> <li>ローカルでコンテンツを作成し、完全なテストを行ってコードの正しさを確認します。</li> <li>ローカルで行った変更を Commit し、その後リモートリポジトリへ Push します。</li> <li>リポジトリのページを更新し、「Create pull request」ボタンをクリックするとプルリクエストを作成できます。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Docker デプロイ","text":"<p><code>hello-algo</code> のルートディレクトリで以下の Docker スクリプトを実行すると、<code>http://localhost:8000</code> で本プロジェクトにアクセスできます。</p> <pre><code>docker-compose up -d\n</code></pre> <p>以下のコマンドでデプロイを削除できます。</p> <pre><code>docker-compose down\n</code></pre>","path":["第 16 章 &nbsp; 付録","16.2 &nbsp; 一緒に制作に参加しましょう"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   プログラミング環境のインストール","text":"","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   IDE のインストール","text":"<p>オープンソースで軽量な VS Code をローカルの統合開発環境（IDE）として使用することを推奨します。VS Code 公式サイト にアクセスし、使用している OS に応じたバージョンの VS Code をダウンロードしてインストールしてください。</p> <p></p> <p> 図 16-1   公式サイトから VS Code をダウンロード </p> <p>VS Code には強力な拡張機能のエコシステムがあり、ほとんどのプログラミング言語の実行とデバッグをサポートしています。Python を例にすると、「Python Extension Pack」拡張機能をインストールした後、Python コードをデバッグできるようになります。インストール手順を以下に示します。</p> <p></p> <p> 図 16-2   VS Code 拡張機能のインストール </p>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   言語環境のインストール","text":"","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Python 環境","text":"<ol> <li>Miniconda3 をダウンロードしてインストールします。Python 3.10 以降が必要です。</li> <li>VS Code の拡張機能マーケットプレイスで <code>python</code> を検索し、Python Extension Pack をインストールします。</li> <li>（任意）コマンドラインで <code>pip install black</code> を入力し、コード整形ツールをインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   C/C++ 環境","text":"<ol> <li>Windows システムでは MinGW をインストールする必要があります（設定チュートリアル）。MacOS には Clang が標準搭載されているため、追加インストールは不要です。</li> <li>VS Code の拡張機能マーケットプレイスで <code>c++</code> を検索し、C/C++ Extension Pack をインストールします。</li> <li>（任意）Settings ページを開き、コード整形オプション <code>Clang_format_fallback Style</code> を検索して、<code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code> に設定します。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Java 環境","text":"<ol> <li>OpenJDK をダウンロードしてインストールします（バージョンは JDK 9 より新しい必要があります）。</li> <li>VS Code の拡張機能マーケットプレイスで <code>java</code> を検索し、Extension Pack for Java をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   C# 環境","text":"<ol> <li>.Net 8.0 をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>C# Dev Kit</code> を検索し、C# Dev Kit をインストールします（設定チュートリアル）。</li> <li>Visual Studio を使用することもできます（インストール手順）。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Go 環境","text":"<ol> <li>go をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>go</code> を検索し、Go をインストールします。</li> <li>ショートカットキー <code>Ctrl + Shift + P</code> を押してコマンドパレットを開き、go と入力して <code>Go: Install/Update Tools</code> を選択し、すべてにチェックを入れてインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Swift 環境","text":"<ol> <li>Swift をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>swift</code> を検索し、Swift for Visual Studio Code をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   JavaScript 環境","text":"<ol> <li>Node.js をダウンロードしてインストールします。</li> <li>（任意）VS Code の拡張機能マーケットプレイスで <code>Prettier</code> を検索し、コード整形ツールをインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   TypeScript 環境","text":"<ol> <li>JavaScript 環境と同じ手順でインストールします。</li> <li>TypeScript Execute (tsx) をインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>typescript</code> を検索し、Pretty TypeScript Errors をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Dart 環境","text":"<ol> <li>Dart をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>dart</code> を検索し、Dart をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Rust 環境","text":"<ol> <li>Rust をダウンロードしてインストールします。</li> <li>VS Code の拡張機能マーケットプレイスで <code>rust</code> を検索し、rust-analyzer をインストールします。</li> </ol>","path":["第 16 章 &nbsp; 付録","16.1 &nbsp; プログラミング環境のインストール"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   用語集","text":"<p>以下の表は、本書に登場する重要な用語を一覧にしたものです。特に次の点に注意してください。</p> <ul> <li>名詞の英語表現も覚えておくと、英語文献を読む際に役立ちます。</li> <li>一部の名詞は、簡体字中国語と繁体字中国語で呼び方が異なります。</li> </ul> <p> 表 16-1   データ構造とアルゴリズムの重要用語 </p> English 日本語 日本語 algorithm アルゴリズム アルゴリズム data structure データ構造 データ構造 code コード コード file ファイル ファイル function 関数 関数 method メソッド メソッド variable 変数 変数 asymptotic complexity analysis 漸近計算量解析 漸近計算量解析 time complexity 時間計算量 時間計算量 space complexity 空間計算量 空間計算量 loop ループ ループ iteration 反復 反復 recursion 再帰 再帰 tail recursion 末尾再帰 末尾再帰 recursion tree 再帰木 再帰木 big-\\(O\\) notation ビッグオー記法 ビッグオー記法 asymptotic upper bound 漸近上界 漸近上界 sign-magnitude 符号絶対値表現 符号絶対値表現 1’s complement 1の補数 1の補数 2’s complement 2の補数 2の補数 array 配列 配列 index インデックス インデックス linked list 連結リスト 連結リスト linked list node, list node 連結リストノード 連結リストノード head node 先頭ノード 先頭ノード tail node 末尾ノード 末尾ノード list リスト リスト dynamic array 動的配列 動的配列 hard disk ハードディスク ハードディスク random-access memory (RAM) メモリ メモリ cache memory キャッシュ キャッシュ cache miss キャッシュミス キャッシュミス cache hit rate キャッシュヒット率 キャッシュヒット率 stack スタック スタック top of the stack スタックトップ スタックトップ bottom of the stack スタックボトム スタックボトム queue キュー キュー double-ended queue 両端キュー 両端キュー front of the queue キュー先頭 キュー先頭 rear of the queue キュー末尾 キュー末尾 hash table ハッシュテーブル ハッシュテーブル hash set ハッシュ集合 ハッシュ集合 bucket バケット バケット hash function ハッシュ関数 ハッシュ関数 hash collision ハッシュ衝突 ハッシュ衝突 load factor 負荷率 負荷率 separate chaining 連鎖アドレス法 連鎖アドレス法 open addressing オープンアドレス法 オープンアドレス法 linear probing 線形探索 線形探索 lazy deletion 遅延削除 遅延削除 binary tree 二分木 二分木 tree node ノード ノード left-child node 左子ノード 左子ノード right-child node 右子ノード 右子ノード parent node 親ノード 親ノード left subtree 左部分木 左部分木 right subtree 右部分木 右部分木 root node 根ノード 根ノード leaf node 葉ノード 葉ノード edge 辺 辺 level レベル レベル degree 次数 次数 height 高さ 高さ depth 深さ 深さ perfect binary tree 完備二分木 完備二分木 complete binary tree 完全二分木 完全二分木 full binary tree 満二分木 満二分木 balanced binary tree 平衡二分木 平衡二分木 binary search tree 二分探索木 二分探索木 AVL tree AVL 木 AVL 木 red-black tree 赤黒木 赤黒木 level-order traversal レベル順走査 レベル順走査 breadth-first traversal 幅優先走査 幅優先走査 depth-first traversal 深さ優先走査 深さ優先走査 binary search tree 二分探索木 二分探索木 balanced binary search tree 平衡二分探索木 平衡二分探索木 balance factor 平衡係数 平衡係数 heap ヒープ ヒープ max heap 最大ヒープ 最大ヒープ min heap 最小ヒープ 最小ヒープ priority queue 優先度付きキュー 優先度付きキュー heapify ヒープ化 ヒープ化 top-\\(k\\) problem Top-\\(k\\) 問題 Top-\\(k\\) 問題 graph グラフ グラフ vertex 頂点 頂点 undirected graph 無向グラフ 無向グラフ directed graph 有向グラフ 有向グラフ connected graph 連結グラフ 連結グラフ disconnected graph 非連結グラフ 非連結グラフ weighted graph 重み付きグラフ 重み付きグラフ adjacency 隣接 隣接 path 経路 経路 in-degree 入次数 入次数 out-degree 出次数 出次数 adjacency matrix 隣接行列 隣接行列 adjacency list 隣接リスト 隣接リスト breadth-first search 幅優先探索 幅優先探索 depth-first search 深さ優先探索 深さ優先探索 binary search 二分探索 二分探索 searching algorithm 探索アルゴリズム 探索アルゴリズム sorting algorithm ソートアルゴリズム ソートアルゴリズム selection sort 選択ソート 選択ソート bubble sort バブルソート バブルソート insertion sort 挿入ソート 挿入ソート quick sort クイックソート クイックソート merge sort マージソート マージソート heap sort ヒープソート ヒープソート bucket sort バケットソート バケットソート counting sort 計数ソート 計数ソート radix sort 基数ソート 基数ソート divide and conquer 分割統治 分割統治 hanota problem ハノイの塔問題 ハノイの塔問題 backtracking algorithm バックトラッキングアルゴリズム バックトラッキングアルゴリズム constraint 制約 制約 solution 解 解 state 状態 状態 pruning 枝刈り 枝刈り permutations problem 全順列問題 全順列問題 subset-sum problem 部分和問題 部分和問題 \\(n\\)-queens problem \\(n\\) クイーン問題 \\(n\\) クイーン問題 dynamic programming 動的計画法 動的計画法 initial state 初期状態 初期状態 state-transition equation 状態遷移方程式 状態遷移方程式 knapsack problem ナップサック問題 ナップサック問題 edit distance problem 編集距離問題 編集距離問題 greedy algorithm 貪欲法 貪欲法","path":["第 16 章 &nbsp; 付録","16.3 &nbsp; 用語集"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"第 4 章   配列と連結リスト","text":"<p>Abstract</p> <p>データ構造の世界は、まるで重厚なれんがの壁のようです。</p> <p>配列のれんがは整然と並び、一つひとつがぴったりと接しています。連結リストのれんがはあちこちに分散し、それらをつなぐつるがれんがのすき間を自由に行き交います。</p>","path":["第 4 章 &nbsp; 配列と連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"章の内容","text":"<ul> <li>4.1   配列</li> <li>4.2   連結リスト</li> <li>4.3   リスト</li> <li>4.4   メモリとキャッシュ *</li> <li>4.5   まとめ</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   配列","text":"<p>配列（array）は線形データ構造の一種であり、同じ型の要素を連続したメモリ領域に格納します。要素が配列内にある位置を、その要素のインデックス（index）と呼びます。下図は、配列の主要な概念と格納方式を示しています。</p> <p></p> <p> 図 4-1   配列の定義と格納方式 </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   配列の一般的な操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   配列の初期化","text":"<p>必要に応じて、配列の初期化方法として初期値なしと初期値ありの 2 種類を使い分けられます。初期値を指定しない場合、多くのプログラミング言語では配列要素は \\(0\\) に初期化されます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># 配列を初期化する\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* 配列を初期化する */\n// スタック上に格納\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// ヒープ上に格納（手動で領域を解放する必要がある）\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* 配列を初期化する */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* 配列を初期化する */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* 配列を初期化する */\nvar arr [5]int\n// Go では、長さを指定する場合（[5]int）は配列であり、長さを指定しない場合（[]int）はスライス\n// Go の配列はコンパイル時に長さが確定するよう設計されているため、長さの指定には定数しか使用できない\n// 拡張 extend() メソッドを実装しやすくするため、以下ではスライス（Slice）を配列（Array）として扱う\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* 配列を初期化する */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* 配列を初期化する */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* 配列を初期化する */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* 配列を初期化する */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* 配列を初期化する */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// Rust では、長さを指定する場合（[i32; 5]）は配列であり、長さを指定しない場合（&amp;[i32]）はスライス\n// Rust の配列はコンパイル時に長さが確定するよう設計されているため、長さの指定には定数しか使用できない\n// Vector は Rust で一般に動的配列として使われる型\n// 拡張 extend() メソッドを実装しやすくするため、以下では vector を配列（array）として扱う\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* 配列を初期化する */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* 配列を初期化する */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># 配列を初期化する\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0Aarr%20%3D%20%5B0%5D%20*%205%20%20%23%20%5B%200,%200,%200,%200,%200%20%5D%0Anums%20%3D%20%5B1,%203,%202,%205,%204%5D&amp;cumulative=false&amp;curInstr=0&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   要素へのアクセス","text":"<p>配列要素は連続したメモリ領域に格納されるため、要素のメモリアドレスの計算は非常に容易です。配列のメモリアドレス（先頭要素のメモリアドレス）とある要素のインデックスが与えられれば、下図の式を使ってその要素のメモリアドレスを計算でき、直接その要素にアクセスできます。</p> <p></p> <p> 図 4-2   配列要素のメモリアドレスの計算 </p> <p>上図を見ると、配列の最初の要素のインデックスは \\(0\\) であり、これは少し直感に反するように思えます。というのも、\\(1\\) から数え始めるほうが自然だからです。しかし、アドレス計算式の観点では、**インデックスの本質はメモリアドレスのオフセット**です。先頭要素のアドレスのオフセットは \\(0\\) であるため、そのインデックスが \\(0\\) なのは妥当です。</p> <p>配列では要素へのアクセスは非常に効率的であり、\\(O(1)\\) 時間で任意の要素にランダムアクセスできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"要素へランダムアクセス\"\"\"\n    # 区間 [0, len(nums)-1] からランダムに数字を 1 つ選ぶ\n    random_index = random.randint(0, len(nums) - 1)\n    # ランダムな要素を取得して返す\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int *nums, int size) {\n    // 区間 [0, size) からランダムに 1 つの数を選ぶ\n    int randomIndex = rand() % size;\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int[] nums) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* 要素へランダムアクセス */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // 区間 [0, nums.Length) からランダムに数字を 1 つ選ぶ\n    int randomIndex = random.Next(nums.Length);\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* 要素へランダムアクセス */\nfunc randomAccess(nums []int) (randomNum int) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    randomIndex := rand.Intn(len(nums))\n    // ランダムな要素を取得して返す\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* 要素へランダムアクセス */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // 区間 [0, nums.count) からランダムに数字を 1 つ選ぶ\n    let randomIndex = nums.indices.randomElement()!\n    // ランダムな要素を取得して返す\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* 要素へランダムアクセス */\nfunction randomAccess(nums) {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    const random_index = Math.floor(Math.random() * nums.length);\n    // ランダムな要素を取得して返す\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* 要素へランダムアクセス */\nfunction randomAccess(nums: number[]): number {\n    // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n    const random_index = Math.floor(Math.random() * nums.length);\n    // ランダムな要素を取得して返す\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* 要素へランダムアクセス */\nint randomAccess(List&lt;int&gt; nums) {\n  // 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n  int randomIndex = Random().nextInt(nums.length);\n  // ランダムな要素を取得して返す\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* 要素へランダムアクセス */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // 区間 [0, nums.len()) からランダムに数字を 1 つ選ぶ\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // ランダムな要素を取得して返す\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* 要素へランダムアクセス */\nint randomAccess(int *nums, int size) {\n    // 区間 [0, size) からランダムに 1 つの数を選ぶ\n    int randomIndex = rand() % size;\n    // ランダムな要素を取得して返す\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* 要素へランダムアクセス */\nfun randomAccess(nums: IntArray): Int {\n    // 区間 [0, nums.size) からランダムに数字を 1 つ選ぶ\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // ランダムな要素を取得して返す\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### 要素にランダムアクセス ###\ndef random_access(nums)\n  # 区間 [0, nums.length) からランダムに 1 つの数を選ぶ\n  random_index = Random.rand(0...nums.length)\n\n  # ランダムな要素を取得して返す\n  nums[random_index]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   要素の挿入","text":"<p>配列要素はメモリ内で「ぴったり隣接して」おり、その間にほかのデータを格納する余地はありません。下図のように、配列の途中に要素を挿入したい場合は、その要素より後ろにあるすべての要素を 1 つずつ後ろへずらし、その後でそのインデックスに要素を代入する必要があります。</p> <p></p> <p> 図 4-3   配列への要素挿入の例 </p> <p>注意すべき点として、配列の長さは固定であるため、要素を 1 つ挿入すると配列末尾の要素が必ず「失われ」ます。この問題の解決策は「リスト」の章で扱います。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"配列の index 番目に要素 num を挿入\"\"\"\n    # インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # index の要素に num を代入する\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int *nums, int size, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int[] nums, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid Insert(int[] nums, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunc insert(nums []int, num int, index int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunction insert(nums, num, index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfunction insert(nums: number[], num: number, index: number): void {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* 配列の添字 index に要素 _num を挿入 */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // インデックス index 以降の全要素を 1 つ後ろへ移動する\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // _num を index の位置の要素に代入\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* 配列の index 番目に要素 num を挿入 */\nvoid insert(int *nums, int size, int num, int index) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // index の要素に num を代入する\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* 配列の index 番目に要素 num を挿入 */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // インデックス index 以降の全要素を 1 つ後ろへ移動する\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // index の要素に num を代入する\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### 配列のインデックス index に要素 num を挿入 ###\ndef insert(nums, num, index)\n  # インデックス index 以降の全要素を 1 つ後ろへ移動する\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # index の要素に num を代入する\n  nums[index] = num\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   要素の削除","text":"<p>同様に、下図のように、インデックス \\(i\\) の要素を削除したい場合は、インデックス \\(i\\) より後ろの要素をすべて 1 つずつ前へずらす必要があります。</p> <p></p> <p> 図 4-4   配列からの要素削除の例 </p> <p>注意してください。要素の削除が完了すると、もともとの末尾要素は「意味を持たない」状態になるため、わざわざ変更する必要はありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"index の要素を削除する\"\"\"\n    # インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* index の要素を削除する */\nvoid remove(int *nums, int size, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* index の要素を削除する */\nvoid remove(int[] nums, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* index の要素を削除する */\nvoid Remove(int[] nums, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* index の要素を削除する */\nfunc remove(nums []int, index int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* index の要素を削除する */\nfunc remove(nums: inout [Int], index: Int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* index の要素を削除する */\nfunction remove(nums, index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* index の要素を削除する */\nfunction remove(nums: number[], index: number): void {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* index の要素を削除する */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // インデックス index より後ろの全要素を 1 つ前へ移動する\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* index の要素を削除する */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* index の要素を削除する */\n// 注意: stdio.h が remove 識別子を使用している\nvoid removeItem(int *nums, int size, int index) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* index の要素を削除する */\nfun remove(nums: IntArray, index: Int) {\n    // インデックス index より後ろの全要素を 1 つ前へ移動する\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### インデックス index の要素を削除 ###\ndef remove(nums, index)\n  # インデックス index より後ろの全要素を 1 つ前へ移動する\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>全体として見ると、配列の挿入と削除には次の欠点があります。</p> <ul> <li>時間計算量が高い：配列の挿入と削除の平均時間計算量はいずれも \\(O(n)\\) であり、ここで \\(n\\) は配列長です。</li> <li>要素が失われる：配列の長さは不変であるため、要素を挿入すると配列長の範囲を超えた要素は失われます。</li> <li>メモリの浪費：やや長めの配列を初期化して先頭部分だけを使うこともでき、この場合データ挿入時に失われる末尾要素はすべて「無意味」ですが、その代わり一部のメモリ領域が無駄になります。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   配列の走査","text":"<p>ほとんどのプログラミング言語では、インデックスを使って配列を走査することも、各要素を直接取り出しながら走査することもできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"配列を走査\"\"\"\n    count = 0\n    # インデックスで配列を走査\n    for i in range(len(nums)):\n        count += nums[i]\n    # 配列要素を直接走査\n    for num in nums:\n        count += num\n    # データのインデックスと要素を同時に走査する\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* 配列を走査 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* 配列を走査 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* 配列を走査 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* 配列を走査 */\nfunc traverse(nums []int) {\n    count := 0\n    // インデックスで配列を走査\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // 配列要素を直接走査\n    for _, num := range nums {\n        count += num\n    }\n    // データのインデックスと要素を同時に走査する\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* 配列を走査 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // インデックスで配列を走査\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // 配列要素を直接走査\n    for num in nums {\n        count += num\n    }\n    // データのインデックスと要素を同時に走査する\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* 配列を走査 */\nfunction traverse(nums) {\n    let count = 0;\n    // インデックスで配列を走査\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* 配列を走査 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // インデックスで配列を走査\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 配列要素を直接走査\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* 配列要素を走査する */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // インデックスで配列を走査\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // 配列要素を直接走査\n  for (int _num in nums) {\n    count += _num;\n  }\n  // forEach メソッドで配列を走査する\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* 配列を走査 */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // インデックスで配列を走査\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // 配列要素を直接走査\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* 配列を走査 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // インデックスで配列を走査\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* 配列を走査 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // インデックスで配列を走査\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // 配列要素を直接走査\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### 配列を走査 ###\ndef traverse(nums)\n  count = 0\n\n  # インデックスで配列を走査\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # 配列要素を直接走査\n  for num in nums\n    count += num\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   要素の検索","text":"<p>配列内で指定した要素を探すには、配列を走査し、各反復で要素値が一致するかを判定し、一致したら対応するインデックスを出力します。</p> <p>配列は線形データ構造であるため、上記の検索操作は「線形探索」と呼ばれます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"配列内で指定要素を探す\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* 配列内で指定要素を探す */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* 配列内で指定要素を探す */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* 配列内で指定要素を探す */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* 配列内で指定要素を探す */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* 配列内で指定要素を探す */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* 配列内で指定要素を探す */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* 配列内で指定要素を探す */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* 配列内で指定要素を探す */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* 配列内で指定要素を探す */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* 配列内で指定要素を探す */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* 配列内で指定要素を探す */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### 配列内の指定要素を検索 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   配列の拡張","text":"<p>複雑なシステム環境では、配列の後方にあるメモリ領域が利用可能であることをプログラム側で保証できず、そのため安全に配列容量を拡張できません。したがって、ほとんどのプログラミング言語では、配列の長さは不変です。</p> <p>配列を拡張したい場合は、より大きな新しい配列を作り、元の配列の要素を順に新配列へコピーする必要があります。これは \\(O(n)\\) の操作であり、配列が大きい場合は非常に時間がかかります。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"配列長を拡張する\"\"\"\n    # 拡張後の長さを持つ配列を初期化する\n    res = [0] * (len(nums) + enlarge)\n    # 元の配列の全要素を新しい配列にコピー\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # 拡張後の新しい配列を返す\n    return res\n</code></pre> array.cpp<pre><code>/* 配列長を拡張する */\nint *extend(int *nums, int size, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int *res = new int[size + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // メモリを解放する\n    delete[] nums;\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.java<pre><code>/* 配列長を拡張する */\nint[] extend(int[] nums, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int[] res = new int[nums.length + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.cs<pre><code>/* 配列長を拡張する */\nint[] Extend(int[] nums, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int[] res = new int[nums.Length + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.go<pre><code>/* 配列長を拡張する */\nfunc extend(nums []int, enlarge int) []int {\n    // 拡張後の長さを持つ配列を初期化する\n    res := make([]int, len(nums)+enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for i, num := range nums {\n        res[i] = num\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.swift<pre><code>/* 配列長を拡張する */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // 拡張後の長さを持つ配列を初期化する\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.js<pre><code>/* 配列長を拡張する */\n// JavaScript の Array は動的配列であり、直接拡張できます\n// 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\nfunction extend(nums, enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 元の配列の全要素を新しい配列にコピー\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.ts<pre><code>/* 配列長を拡張する */\n// TypeScript の Array は動的配列であり、直接拡張できます\n// 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\nfunction extend(nums: number[], enlarge: number): number[] {\n    // 拡張後の長さを持つ配列を初期化する\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 元の配列の全要素を新しい配列にコピー\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.dart<pre><code>/* 配列長を拡張する */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // 拡張後の長さを持つ配列を初期化する\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // 元の配列の全要素を新しい配列にコピー\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // 拡張後の新しい配列を返す\n  return res;\n}\n</code></pre> array.rs<pre><code>/* 配列長を拡張する */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // 拡張後の長さを持つ配列を初期化する\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // 元の配列の全要素を新しい配列にコピー\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // 拡張後の新しい配列を返す\n    res\n}\n</code></pre> array.c<pre><code>/* 配列長を拡張する */\nint *extend(int *nums, int size, int enlarge) {\n    // 拡張後の長さを持つ配列を初期化する\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // 元の配列の全要素を新しい配列にコピー\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 拡張後の領域を初期化する\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // 拡張後の新しい配列を返す\n    return res;\n}\n</code></pre> array.kt<pre><code>/* 配列長を拡張する */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // 拡張後の長さを持つ配列を初期化する\n    val res = IntArray(nums.size + enlarge)\n    // 元の配列の全要素を新しい配列にコピー\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // 拡張後の新しい配列を返す\n    return res\n}\n</code></pre> array.rb<pre><code>### 配列長を拡張 ###\n# Ruby の Array は動的配列であり、直接拡張できます\n# 学習しやすいよう、本関数では Array を長さ不変の配列として扱います\ndef extend(nums, enlarge)\n  # 拡張後の長さを持つ配列を初期化する\n  res = Array.new(nums.length + enlarge, 0)\n\n  # 元の配列の全要素を新しい配列にコピー\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # 拡張後の新しい配列を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   配列の利点と限界","text":"<p>配列は連続したメモリ領域に格納され、要素の型も同一です。この方法には豊富な事前情報が含まれており、システムはそれらを利用してデータ構造の操作効率を最適化できます。</p> <ul> <li>空間効率が高い：配列はデータに連続したメモリブロックを割り当てるため、追加の構造オーバーヘッドが不要です。</li> <li>ランダムアクセスをサポートする：配列では任意の要素に \\(O(1)\\) 時間でアクセスできます。</li> <li>キャッシュ局所性：配列要素にアクセスする際、コンピュータはその要素だけでなく周囲のデータもキャッシュするため、高速キャッシュを利用して後続操作の実行速度を高められます。</li> </ul> <p>連続領域への格納は諸刃の剣であり、次のような制約があります。</p> <ul> <li>挿入と削除の効率が低い：配列内の要素が多い場合、挿入や削除では大量の要素を移動する必要があります。</li> <li>長さが不変：配列は初期化後に長さが固定され、拡張するにはすべてのデータを新しい配列へコピーする必要があり、コストが大きくなります。</li> <li>空間の浪費：配列に割り当てたサイズが実際の必要量を上回る場合、余分な領域は無駄になります。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   配列の典型的な応用","text":"<p>配列は基礎的で一般的なデータ構造であり、さまざまなアルゴリズムで頻繁に使われるだけでなく、多様な複雑データ構造の実装にも利用できます。</p> <ul> <li>ランダムアクセス：いくつかのサンプルをランダムに抽出したい場合、配列に格納してランダムな系列を生成し、インデックスに基づいてランダムサンプリングを行えます。</li> <li>ソートと探索：配列はソートアルゴリズムと探索アルゴリズムで最もよく使われるデータ構造です。クイックソート、マージソート、二分探索などは主に配列上で行われます。</li> <li>ルックアップテーブル：ある要素やその対応関係を高速に調べる必要がある場合、配列をルックアップテーブルとして使えます。たとえば文字から ASCII コードへの対応を実装したいなら、文字の ASCII コード値をインデックスとし、対応する要素を配列の対応位置に格納できます。</li> <li>機械学習：ニューラルネットワークでは、ベクトル、行列、テンソル間の線形代数演算が大量に使われ、これらのデータはいずれも配列の形で構築されます。配列はニューラルネットワークプログラミングで最もよく使われるデータ構造です。</li> <li>データ構造の実装：配列はスタック、キュー、ハッシュテーブル、ヒープ、グラフなどのデータ構造の実装に利用できます。たとえば、グラフの隣接行列表現は実際には 2 次元配列です。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.1 &nbsp; 配列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   連結リスト","text":"<p>メモリ空間はすべてのプログラムに共通の資源であり、複雑なシステム実行環境では、空きメモリがメモリの各所に散在している可能性があります。配列を格納するメモリ空間は連続していなければなりませんが、配列が非常に大きい場合、メモリはそのような大きな連続領域を提供できないことがあります。このとき、連結リストの柔軟性という利点が現れます。</p> <p>連結リスト（linked list）は線形データ構造の一種であり、各要素はノードオブジェクトです。各ノードは「参照」によって接続されます。参照には次のノードのメモリアドレスが記録されており、これによって現在のノードから次のノードへアクセスできます。</p> <p>連結リストの設計では、各ノードをメモリの各所に分散して格納でき、それらのメモリアドレスは連続している必要がありません。</p> <p></p> <p> 図 4-5   連結リストの定義と格納方式 </p> <p>上図を見ると、連結リストの構成単位はノード（node）オブジェクトです。各ノードは 2 つのデータ、すなわちノードの「値」と次のノードを指す「参照」を含みます。</p> <ul> <li>連結リストの最初のノードを「先頭ノード」、最後のノードを「末尾ノード」と呼びます。</li> <li>末尾ノードが指す先は「空」であり、Java、C++、Python ではそれぞれ <code>null</code>、<code>nullptr</code>、<code>None</code> と表記します。</li> <li>C、C++、Go、Rust などポインタをサポートする言語では、上記の「参照」は「ポインタ」に置き換えるべきです。</li> </ul> <p>以下のコードが示すように、連結リストノード <code>ListNode</code> は値のほかに、追加で 1 つの参照（ポインタ）を保持する必要があります。そのため、同じデータ量であれば、連結リストは配列より多くのメモリ空間を消費します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"連結リストノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # ノードの値\n        self.next: ListNode | None = None # 次のノードへの参照\n</code></pre> <pre><code>/* 連結リストノード構造体 */\nstruct ListNode {\n    int val;         // ノードの値\n    ListNode *next;  // 次のノードへのポインタ\n    ListNode(int x) : val(x), next(nullptr) {}  // コンストラクタ\n};\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode next;  // 次のノードへの参照\n    ListNode(int x) { val = x; }  // コンストラクタ\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode(int x) {  //コンストラクタ\n    int val = x;         // ノードの値\n    ListNode? next;      // 次のノードへの参照\n}\n</code></pre> <pre><code>/* 連結リストノード構造体 */\ntype ListNode struct {\n    Val  int       // ノードの値\n    Next *ListNode // 次のノードへのポインタ\n}\n\n// NewListNode コンストラクタ。新しい連結リストを作成する\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    var val: Int // ノードの値\n    var next: ListNode? // 次のノードへの参照\n\n    init(x: Int) { // コンストラクタ\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // ノードの値\n        this.next = (next === undefined ? null : next); // 次のノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // ノードの値\n        this.next = next === undefined ? null : next;  // 次のノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\nclass ListNode {\n  int val; // ノードの値\n  ListNode? next; // 次のノードへの参照\n  ListNode(this.val, [this.next]); // コンストラクタ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* 連結リストノードクラス */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // ノードの値\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 次のノードへのポインタ\n}\n</code></pre> <pre><code>/* 連結リストノード構造体 */\ntypedef struct ListNode {\n    int val;               // ノードの値\n    struct ListNode *next; // 次のノードへのポインタ\n} ListNode;\n\n/* コンストラクタ */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 連結リストノードクラス */\n// コンストラクタ\nclass ListNode(x: Int) {\n    val _val: Int = x          // ノードの値\n    val next: ListNode? = null // 次のノードへの参照\n}\n</code></pre> <pre><code># 連結リストノードクラス\nclass ListNode\n  attr_accessor :val  # ノードの値\n  attr_accessor :next # 次のノードへの参照\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   連結リストの基本操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   連結リストの初期化","text":"<p>連結リストの構築は 2 つの手順に分かれます。第 1 に各ノードオブジェクトを初期化し、第 2 にノード間の参照関係を構築します。初期化が完了したら、連結リストの先頭ノードから出発し、参照で <code>next</code> をたどってすべてのノードに順にアクセスできます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化\n# 各ノードを初期化\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// ノード間の参照を構築\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// ノード間の参照を構築\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\\\n// 各ノードを初期化\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// ノード間の参照を構築\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// ノード間の参照を構築\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化 */\n// 各ノードを初期化\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// ノード間の参照を構築\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># 連結リスト 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 を初期化\n# 各ノードを初期化\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# ノード間の参照を構築\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%93%BE%E8%A1%A8%201%20-%3E%203%20-%3E%202%20-%3E%205%20-%3E%204%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%90%84%E4%B8%AA%E8%8A%82%E7%82%B9%0A%20%20%20%20n0%20%3D%20ListNode%281%29%0A%20%20%20%20n1%20%3D%20ListNode%283%29%0A%20%20%20%20n2%20%3D%20ListNode%282%29%0A%20%20%20%20n3%20%3D%20ListNode%285%29%0A%20%20%20%20n4%20%3D%20ListNode%284%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%0A%20%20%20%20n0.next%20%3D%20n1%0A%20%20%20%20n1.next%20%3D%20n2%0A%20%20%20%20n2.next%20%3D%20n3%0A%20%20%20%20n3.next%20%3D%20n4&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>配列全体は 1 つの変数であり、たとえば配列 <code>nums</code> には <code>nums[0]</code> や <code>nums[1]</code> などの要素が含まれます。一方、連結リストは複数の独立したノードオブジェクトで構成されます。通常、先頭ノードを連結リストの代名詞として扱います。たとえば上記のコードの連結リストは <code>n0</code> と表せます。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   ノードの挿入","text":"<p>連結リストへのノード挿入は非常に簡単です。下図に示すように、隣り合う 2 つのノード <code>n0</code> と <code>n1</code> の間に新しいノード <code>P</code> を挿入したいとします。このとき 2 つのノードの参照（ポインタ）を変更するだけでよく、時間計算量は \\(O(1)\\) です。</p> <p>これに対して、配列に要素を挿入する時間計算量は \\(O(n)\\) であり、データ量が大きい場合の効率は低くなります。</p> <p></p> <p> 図 4-6   連結リストへのノード挿入例 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"連結リストでノード n0 の後ろにノード P を挿入する\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストでノード n0 の後ろにノード P を挿入する */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストのノード n0 の後にノード _p を挿入 ###\n# Ruby の `p` は組み込み関数で、`P` は定数なので、代わりに `_p` を使える\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   ノードの削除","text":"<p>下図に示すように、連結リストでのノード削除も非常に簡単で、1 つのノードの参照（ポインタ）を変更するだけで済みます。</p> <p>なお、削除操作が完了した後もノード <code>P</code> は依然として <code>n1</code> を指していますが、実際にはこの連結リストをたどっても <code>P</code> へはアクセスできません。つまり、<code>P</code> はすでにこの連結リストには属していません。</p> <p></p> <p> 図 4-7   連結リストのノード削除 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"連結リストでノード n0 の直後のノードを削除する\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // メモリを解放する\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\n// 注意: stdio.h が remove 識別子を使用している\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // メモリを解放する\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストでノード n0 の直後のノードを削除する */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストのノード n0 の直後のノードを削除 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   ノードへのアクセス","text":"<p>**連結リストでノードにアクセスする効率は低い**です。前節で述べたように、配列では任意の要素へ \\(O(1)\\) 時間でアクセスできます。これに対して連結リストでは、プログラムは先頭ノードから出発し、1 つずつ後ろへたどって目的のノードを見つける必要があります。つまり、連結リストの第 \\(i\\) ノードにアクセスするには \\(i - 1\\) 回のループが必要であり、時間計算量は \\(O(n)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"連結リスト内で index 番目のノードにアクセス\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リスト内で index 番目のノードにアクセス */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### 連結リスト内の index 番目のノードにアクセス ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   ノードの探索","text":"<p>連結リストを走査し、その中から値が <code>target</code> のノードを探し、そのノードの連結リスト内でのインデックスを出力します。この処理も線形探索に属します。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"連結リストで値が target の最初のノードを探す\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* 連結リストで値が target の最初のノードを探す */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* 連結リストで値が target の最初のノードを探す */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* 連結リストで値が target の最初のノードを探す */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### 連結リストで値が target の最初のノードを探す ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","level":2,"title":"4.2.2   配列 vs. 連結リスト","text":"<p>次の表は、配列と連結リストの各種特徴と操作効率をまとめたものです。両者は互いに逆の格納戦略を採用しているため、各種性質や操作効率にも対照的な特徴が現れます。</p> <p> 表 4-1   配列と連結リストの効率比較 </p> 配列 連結リスト 格納方式 連続したメモリ空間 分散したメモリ空間 容量拡張 長さは不変 柔軟に拡張可能 メモリ効率 要素のメモリ消費は少ないが、空間を無駄にする可能性がある 要素のメモリ消費が多い 要素へのアクセス \\(O(1)\\) \\(O(n)\\) 要素の追加 \\(O(n)\\) \\(O(1)\\) 要素の削除 \\(O(n)\\) \\(O(1)\\)","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   一般的な連結リストの種類","text":"<p>下図に示すように、一般的な連結リストの種類は 3 つあります。</p> <ul> <li>単方向連結リスト：前述した通常の連結リストのことです。単方向連結リストのノードは、値と次のノードを指す参照の 2 つのデータを含みます。最初のノードを先頭ノード、最後のノードを末尾ノードと呼び、末尾ノードは空 <code>None</code> を指します。</li> <li>循環連結リスト：単方向連結リストの末尾ノードを先頭ノードへ向けると（先頭と末尾をつなぐと）、循環連結リストが得られます。循環連結リストでは、任意のノードを先頭ノードとみなせます。</li> <li>双方向連結リスト：単方向連結リストと比べて、双方向連結リストは 2 方向の参照を記録します。双方向連結リストのノード定義には、後続ノード（次のノード）と前駆ノード（前のノード）を指す参照（ポインタ）が含まれます。単方向連結リストより柔軟で、2 方向に連結リストを走査できますが、そのぶん多くのメモリ空間を必要とします。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"双方向連結リストノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # ノードの値\n        self.next: ListNode | None = None  # 後続ノードへの参照\n        self.prev: ListNode | None = None  # 前駆ノードへの参照\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\nstruct ListNode {\n    int val;         // ノードの値\n    ListNode *next;  // 後続ノードへのポインタ\n    ListNode *prev;  // 前駆ノードへのポインタ\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // コンストラクタ\n};\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode next;  // 後続ノードへの参照\n    ListNode prev;  // 前駆ノードへの参照\n    ListNode(int x) { val = x; }  // コンストラクタ\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode(int x) {  // コンストラクタ\n    int val = x;    // ノードの値\n    ListNode next;  // 後続ノードへの参照\n    ListNode prev;  // 前駆ノードへの参照\n}\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\ntype DoublyListNode struct {\n    Val  int             // ノードの値\n    Next *DoublyListNode // 後続ノードへのポインタ\n    Prev *DoublyListNode // 前駆ノードへのポインタ\n}\n\n// NewDoublyListNode の初期化\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    var val: Int // ノードの値\n    var next: ListNode? // 後続ノードへの参照\n    var prev: ListNode? // 前駆ノードへの参照\n\n    init(x: Int) { // コンストラクタ\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // ノードの値\n        this.next = next  ===  undefined ? null : next;  // 後続ノードへの参照\n        this.prev = prev  ===  undefined ? null : prev;  // 前駆ノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // ノードの値\n        this.next = next  ===  undefined ? null : next;  // 後続ノードへの参照\n        this.prev = prev  ===  undefined ? null : prev;  // 前駆ノードへの参照\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\nclass ListNode {\n    int val;        // ノードの値\n    ListNode? next;  // 後続ノードへの参照\n    ListNode? prev;  // 前駆ノードへの参照\n    ListNode(this.val, [this.next, this.prev]);  // コンストラクタ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 双方向連結リストノード型 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // ノードの値\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 後続ノードへのポインタ\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 前駆ノードへのポインタ\n}\n\n/* コンストラクタ */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* 双方向連結リストノード構造体 */\ntypedef struct ListNode {\n    int val;               // ノードの値\n    struct ListNode *next; // 後続ノードへのポインタ\n    struct ListNode *prev; // 前駆ノードへのポインタ\n} ListNode;\n\n/* コンストラクタ */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 双方向連結リストノードクラス */\n// コンストラクタ\nclass ListNode(x: Int) {\n    val _val: Int = x           // ノードの値\n    val next: ListNode? = null  // 後続ノードへの参照\n    val prev: ListNode? = null  // 前駆ノードへの参照\n}\n</code></pre> <pre><code># 双方向連結リストノードクラス\nclass ListNode\n  attr_accessor :val    # ノードの値\n  attr_accessor :next   # 後続ノードへの参照\n  attr_accessor :prev   # 前駆ノードへの参照\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> 図 4-8   一般的な連結リストの種類 </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   連結リストの典型的な応用","text":"<p>単方向連結リストは、スタック、キュー、ハッシュテーブル、グラフなどのデータ構造の実装によく用いられます。</p> <ul> <li>スタックとキュー：挿入と削除の両方の操作を連結リストの一端で行うと、その性質は後入れ先出しとなり、スタックに対応します。挿入を連結リストの一端で行い、削除をもう一端で行うと、その性質は先入れ先出しとなり、キューに対応します。</li> <li>ハッシュテーブル：連鎖アドレス法はハッシュ衝突を解決する主流の方式の 1 つであり、この方式では、衝突したすべての要素が 1 つの連結リストに格納されます。</li> <li>グラフ：隣接リストはグラフを表現する一般的な方法の 1 つであり、グラフの各頂点は 1 つの連結リストに関連付けられます。連結リスト内の各要素は、その頂点に接続されたほかの頂点を表します。</li> </ul> <p>双方向連結リストは、前後の要素をすばやく見つける必要がある場面でよく用いられます。</p> <ul> <li>高度なデータ構造：たとえば赤黒木や B 木では、ノードの親ノードへアクセスする必要があります。これは、ノード内に親ノードを指す参照を保持することで実現でき、双方向連結リストに似ています。</li> <li>ブラウザ履歴：Web ブラウザでユーザーが進むボタンや戻るボタンをクリックしたとき、ブラウザはユーザーが訪れた前後のページを知る必要があります。双方向連結リストの性質によって、この操作は簡単になります。</li> <li>LRU アルゴリズム：キャッシュ淘汰（LRU）アルゴリズムでは、最近最も使用されていないデータをすばやく見つける必要があり、さらにノードの高速な追加と削除も必要です。そのため、双方向連結リストが非常に適しています。</li> </ul> <p>循環連結リストは、オペレーティングシステムのリソーススケジューリングのように、周期的な操作が必要な場面でよく用いられます。</p> <ul> <li>ラウンドロビン時間片スケジューリングアルゴリズム：オペレーティングシステムにおいて、ラウンドロビン時間片スケジューリングは一般的な CPU スケジューリングアルゴリズムであり、一連のプロセスを循環的に処理する必要があります。各プロセスには 1 つの時間片が割り当てられ、その時間片を使い切ると、CPU は次のプロセスへ切り替わります。この循環操作は、循環連結リストで実現できます。</li> <li>データバッファ：一部のデータバッファ実装でも、循環連結リストが使われることがあります。たとえば音声・動画プレーヤーでは、データストリームを複数のバッファブロックに分割して循環連結リストへ格納し、シームレス再生を実現できます。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.2 &nbsp; 連結リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   リスト","text":"<p>リスト（list）は抽象的なデータ構造の概念であり、要素の順序付き集合を表す。要素のアクセス、更新、追加、削除、走査などの操作をサポートし、利用者は容量制限の問題を考慮する必要がない。リストは連結リストまたは配列に基づいて実装できる。</p> <ul> <li>連結リストは本質的にリストと見なすことができ、要素の追加・削除・参照・更新をサポートし、柔軟に動的拡張できる。</li> <li>配列も要素の追加・削除・参照・更新をサポートするが、長さが不変であるため、長さ制限のあるリストとしか見なせない。</li> </ul> <p>配列でリストを実装する場合、長さが不変である性質によってリストの実用性が低下する。これは、通常は事前にどれだけのデータを格納する必要があるかを決められず、適切なリスト長を選びにくいためである。長さが小さすぎると利用要件を満たせない可能性が高く、大きすぎるとメモリ空間の浪費を招く。</p> <p>この問題を解決するために、動的配列（dynamic array）を用いてリストを実装できる。これは配列の各種利点を引き継ぎつつ、プログラム実行中に動的な拡張を行える。</p> <p>実際には、多くのプログラミング言語の標準ライブラリが提供するリストは動的配列に基づいて実装されている。たとえば、Python の <code>list</code> 、Java の <code>ArrayList</code> 、C++ の <code>vector</code> 、C# の <code>List</code> などである。以降の議論では、「リスト」と「動的配列」を同じ概念として扱う。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   リストの基本操作","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   リストの初期化","text":"<p>通常は「初期値なし」と「初期値あり」の 2 つの初期化方法を用いる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストを初期化\n# 初期値なし\nnums1: list[int] = []\n# 初期値あり\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* リストを初期化 */\n// なお、C++ では vector が本稿でいう nums に相当する\n// 初期値なし\nvector&lt;int&gt; nums1;\n// 初期値あり\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// 初期値あり（配列の要素型は int[] のラッパークラスである Integer[] である必要があることに注意）\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;int&gt; nums1 = [];\n// 初期値あり\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* リストを初期化 */\n// 初期値なし\nnums1 := []int{}\n// 初期値あり\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* リストを初期化 */\n// 初期値なし\nlet nums1: [Int] = []\n// 初期値あり\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* リストを初期化 */\n// 初期値なし\nconst nums1 = [];\n// 初期値あり\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* リストを初期化 */\n// 初期値なし\nconst nums1: number[] = [];\n// 初期値あり\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* リストを初期化 */\n// 初期値なし\nList&lt;int&gt; nums1 = [];\n// 初期値あり\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* リストを初期化 */\n// 初期値なし\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// 初期値あり\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストを初期化 */\n// 初期値なし\nvar nums1 = listOf&lt;Int&gt;()\n// 初期値あり\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># リストを初期化\n# 初期値なし\nnums1 = []\n# 初期値あり\nnums = [1, 3, 2, 5, 4]\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20%23%20%E6%97%A0%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums1%20%3D%20%5B%5D%0A%20%20%20%20%23%20%E6%9C%89%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D&amp;cumulative=false&amp;curInstr=4&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   要素へのアクセス","text":"<p>リストの本質は配列であるため、要素へのアクセスと更新は \\(O(1)\\) 時間で行え、効率が高い。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 要素にアクセス\nnum: int = nums[1]  # インデックス 1 の要素にアクセス\n\n# 要素を更新\nnums[1] = 0    # インデックス 1 の要素を 0 に更新\n</code></pre> list.cpp<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.java<pre><code>/* 要素にアクセス */\nint num = nums.get(1);  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums.set(1, 0);  // インデックス 1 の要素を 0 に更新\n</code></pre> list.cs<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list_test.go<pre><code>/* 要素にアクセス */\nnum := nums[1]  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0     // インデックス 1 の要素を 0 に更新\n</code></pre> list.swift<pre><code>/* 要素にアクセス */\nlet num = nums[1] // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0 // インデックス 1 の要素を 0 に更新\n</code></pre> list.js<pre><code>/* 要素にアクセス */\nconst num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.ts<pre><code>/* 要素にアクセス */\nconst num: number = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.dart<pre><code>/* 要素にアクセス */\nint num = nums[1];  // インデックス 1 の要素にアクセス\n\n/* 要素を更新 */\nnums[1] = 0;  // インデックス 1 の要素を 0 に更新\n</code></pre> list.rs<pre><code>/* 要素にアクセス */\nlet num: i32 = nums[1];  // インデックス 1 の要素にアクセス\n/* 要素を更新 */\nnums[1] = 0;             // インデックス 1 の要素を 0 に更新\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* 要素にアクセス */\nval num = nums[1]       // インデックス 1 の要素にアクセス\n/* 要素を更新 */\nnums[1] = 0             // インデックス 1 の要素を 0 に更新\n</code></pre> list.rb<pre><code># 要素にアクセス\nnum = nums[1] # インデックス 1 の要素にアクセス\n# 要素を更新\nnums[1] = 0 # インデックス 1 の要素を 0 に更新\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20num%20%3D%20nums%5B1%5D%20%20%23%20%E8%AE%BF%E9%97%AE%E7%B4%A2%E5%BC%95%201%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0%0A%0A%20%20%20%20%23%20%E6%9B%B4%E6%96%B0%E5%85%83%E7%B4%A0%0A%20%20%20%20nums%5B1%5D%20%3D%200%20%20%20%20%23%20%E5%B0%86%E7%B4%A2%E5%BC%95%201%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0%E6%9B%B4%E6%96%B0%E4%B8%BA%200&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   要素の挿入と削除","text":"<p>配列と比べて、リストでは要素を自由に追加・削除できる。リスト末尾への要素追加の時間計算量は \\(O(1)\\) だが、要素の挿入と削除の効率は依然として配列と同じで、時間計算量は \\(O(n)\\) である。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストをクリア\nnums.clear()\n\n# 末尾に要素を追加\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# 途中に要素を挿入\nnums.insert(3, 6)  # インデックス 3 に数値 6 を挿入\n\n# 要素を削除\nnums.pop(3)        # インデックス 3 の要素を削除\n</code></pre> list.cpp<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* 途中に要素を挿入 */\nnums.insert(nums.begin() + 3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.erase(nums.begin() + 3);      // インデックス 3 の要素を削除\n</code></pre> list.java<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.add(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);  // インデックス 3 の要素を削除\n</code></pre> list.cs<pre><code>/* リストをクリア */\nnums.Clear();\n\n/* 末尾に要素を追加 */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* 途中に要素を挿入 */\nnums.Insert(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.RemoveAt(3);  // インデックス 3 の要素を削除\n</code></pre> list_test.go<pre><code>/* リストをクリア */\nnums = nil\n\n/* 末尾に要素を追加 */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* 途中に要素を挿入 */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums = append(nums[:3], nums[4:]...) // インデックス 3 の要素を削除\n</code></pre> list.swift<pre><code>/* リストをクリア */\nnums.removeAll()\n\n/* 末尾に要素を追加 */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* 途中に要素を挿入 */\nnums.insert(6, at: 3) // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(at: 3) // インデックス 3 の要素を削除\n</code></pre> list.js<pre><code>/* リストをクリア */\nnums.length = 0;\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.splice(3, 0, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.splice(3, 1);  // インデックス 3 の要素を削除\n</code></pre> list.ts<pre><code>/* リストをクリア */\nnums.length = 0;\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.splice(3, 0, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.splice(3, 1);  // インデックス 3 の要素を削除\n</code></pre> list.dart<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.insert(3, 6); // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.removeAt(3); // インデックス 3 の要素を削除\n</code></pre> list.rs<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 途中に要素を挿入 */\nnums.insert(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);    // インデックス 3 の要素を削除\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストをクリア */\nnums.clear();\n\n/* 末尾に要素を追加 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 途中に要素を挿入 */\nnums.add(3, 6);  // インデックス 3 に数値 6 を挿入\n\n/* 要素を削除 */\nnums.remove(3);  // インデックス 3 の要素を削除\n</code></pre> list.rb<pre><code># リストをクリア\nnums.clear\n\n# 末尾に要素を追加\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# 途中に要素を挿入\nnums.insert(3, 6) # インデックス 3 に数値 6 を挿入\n\n# 要素を削除\nnums.delete_at(3) # インデックス 3 の要素を削除\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E6%9C%89%E5%88%9D%E5%A7%8B%E5%80%BC%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B8%85%E7%A9%BA%E5%88%97%E8%A1%A8%0A%20%20%20%20nums.clear%28%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%9C%A8%E5%B0%BE%E9%83%A8%E6%B7%BB%E5%8A%A0%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.append%281%29%0A%20%20%20%20nums.append%283%29%0A%20%20%20%20nums.append%282%29%0A%20%20%20%20nums.append%285%29%0A%20%20%20%20nums.append%284%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%9C%A8%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.insert%283,%206%29%20%20%23%20%E5%9C%A8%E7%B4%A2%E5%BC%95%203%20%E5%A4%84%E6%8F%92%E5%85%A5%E6%95%B0%E5%AD%97%206%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E5%85%83%E7%B4%A0%0A%20%20%20%20nums.pop%283%29%20%20%20%20%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E7%B4%A2%E5%BC%95%203%20%E5%A4%84%E7%9A%84%E5%85%83%E7%B4%A0&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   リストの走査","text":"<p>配列と同様に、リストもインデックスに基づいて走査することも、各要素を直接走査することもできる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># インデックスでリストを走査\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# リストの要素を直接走査\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* リストの要素を直接走査 */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* インデックスでリストを走査 */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* インデックスでリストを走査 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* インデックスでリストを走査 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* インデックスでリストを走査 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* インデックスでリストを走査 */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* リストの要素を直接走査 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// インデックスでリストを走査\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// リストの要素を直接走査\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* インデックスでリストを走査 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* リストの要素を直接走査 */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># インデックスでリストを走査\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# リストの要素を直接走査\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%80%9A%E8%BF%87%E7%B4%A2%E5%BC%95%E9%81%8D%E5%8E%86%E5%88%97%E8%A1%A8%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20nums%5Bi%5D%0A%0A%20%20%20%20%23%20%E7%9B%B4%E6%8E%A5%E9%81%8D%E5%8E%86%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20num&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   リストの連結","text":"<p>新しいリスト <code>nums1</code> が与えられたとき、それを元のリストの末尾に連結できる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 2 つのリストを連結\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # リスト nums1 を nums の後ろに連結\n</code></pre> list.cpp<pre><code>/* 2 つのリストを連結 */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// リスト nums1 を nums の後ろに連結\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* 2 つのリストを連結 */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.cs<pre><code>/* 2 つのリストを連結 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list_test.go<pre><code>/* 2 つのリストを連結 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // リスト nums1 を nums の後ろに連結\n</code></pre> list.swift<pre><code>/* 2 つのリストを連結 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // リスト nums1 を nums の後ろに連結\n</code></pre> list.js<pre><code>/* 2 つのリストを連結 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.ts<pre><code>/* 2 つのリストを連結 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.dart<pre><code>/* 2 つのリストを連結 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // リスト nums1 を nums の後ろに連結\n</code></pre> list.rs<pre><code>/* 2 つのリストを連結 */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* 2 つのリストを連結 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // リスト nums1 を nums の後ろに連結\n</code></pre> list.rb<pre><code># 2 つのリストを連結\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%8B%BC%E6%8E%A5%E4%B8%A4%E4%B8%AA%E5%88%97%E8%A1%A8%0A%20%20%20%20nums1%20%3D%20%5B6,%208,%207,%2010,%209%5D%0A%20%20%20%20nums%20%2B%3D%20nums1%20%20%23%20%E5%B0%86%E5%88%97%E8%A1%A8%20nums1%20%E6%8B%BC%E6%8E%A5%E5%88%B0%20nums%20%E4%B9%8B%E5%90%8E&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   リストをソート","text":"<p>リストのソートが完了すると、配列系アルゴリズム問題でよく問われる「二分探索」や「両ポインタ」アルゴリズムを使えるようになる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># リストをソート\nnums.sort()  # ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.cpp<pre><code>/* リストをソート */\nsort(nums.begin(), nums.end());  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.java<pre><code>/* リストをソート */\nCollections.sort(nums);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.cs<pre><code>/* リストをソート */\nnums.Sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list_test.go<pre><code>/* リストをソート */\nsort.Ints(nums)  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.swift<pre><code>/* リストをソート */\nnums.sort() // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.js<pre><code>/* リストをソート */\nnums.sort((a, b) =&gt; a - b);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.ts<pre><code>/* リストをソート */\nnums.sort((a, b) =&gt; a - b);  // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.dart<pre><code>/* リストをソート */\nnums.sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.rs<pre><code>/* リストをソート */\nnums.sort(); // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.c<pre><code>// C には組み込みの動的配列がない\n</code></pre> list.kt<pre><code>/* リストをソート */\nnums.sort() // ソート後、リスト要素は小さい順に並ぶ\n</code></pre> list.rb<pre><code># リストをソート\nnums = nums.sort { |a, b| a &lt;=&gt; b } # ソート後、リスト要素は小さい順に並ぶ\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8%0A%20%20%20%20nums%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%8E%92%E5%BA%8F%E5%88%97%E8%A1%A8%0A%20%20%20%20nums.sort%28%29%20%20%23%20%E6%8E%92%E5%BA%8F%E5%90%8E%EF%BC%8C%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%E4%BB%8E%E5%B0%8F%E5%88%B0%E5%A4%A7%E6%8E%92%E5%88%97&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   リストの実装","text":"<p>多くのプログラミング言語にはリストが組み込まれており、たとえば Java、C++、Python などがある。それらの実装は比較的複雑で、初期容量や拡張倍率など各種パラメータの設定もよく考えられている。興味があればソースコードを参照して学べる。</p> <p>リストの動作原理への理解を深めるため、ここでは簡易版のリストを実装し、以下の 3 つの設計ポイントを含める。</p> <ul> <li>初期容量：妥当な配列の初期容量を選ぶ。この例では 10 を初期容量として選ぶ。</li> <li>要素数の記録：<code>size</code> という変数を宣言して、現在のリスト要素数を記録し、要素の挿入と削除に応じてリアルタイムに更新する。この変数により、リスト末尾の位置を特定し、拡張が必要かどうかを判断できる。</li> <li>拡張機構：要素を挿入する時点でリスト容量がいっぱいなら、拡張が必要になる。まず拡張倍率に応じてより大きな配列を作成し、次に現在の配列の全要素を順に新しい配列へ移す。この例では、配列を毎回以前の 2 倍に拡張する。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"リストクラス\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._capacity: int = 10  # リスト容量\n        self._arr: list[int] = [0] * self._capacity  # 配列（リスト要素を格納）\n        self._size: int = 0  # リストの長さ（現在の要素数）\n        self._extend_ratio: int = 2  # リスト拡張時の増加倍率\n\n    def size(self) -&gt; int:\n        \"\"\"リストの長さを取得（現在の要素数）\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"リスト容量を取得する\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"要素にアクセス\"\"\"\n        # インデックスが範囲外なら例外を送出する。以下同様\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"要素を更新\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"末尾に要素を追加\"\"\"\n        # 要素数が容量を超えると、拡張機構が発動する\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"中間に要素を挿入\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        # 要素数が容量を超えると、拡張機構が発動する\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # index 以降の要素をすべて 1 つ後ろへずらす\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # 要素数を更新\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"要素を削除\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"インデックスが範囲外です\")\n        num = self._arr[index]\n        # インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # 要素数を更新\n        self._size -= 1\n        # 削除された要素を返す\n        return num\n\n    def extend_capacity(self):\n        \"\"\"リストの拡張\"\"\"\n        # 元の配列の `_extend_ratio` 倍の長さを持つ新しい配列を作成し、元の配列を新しい配列にコピーする\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # リストの容量を更新\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"有効長のリストを返す\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* リストクラス */\nclass MyList {\n  private:\n    int *arr;             // 配列（リスト要素を格納）\n    int arrCapacity = 10; // リスト容量\n    int arrSize = 0;      // リストの長さ（現在の要素数）\n    int extendRatio = 2;   // リスト拡張時の増加倍率\n\n  public:\n    /* コンストラクタ */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* デストラクタメソッド */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    int size() {\n        return arrSize;\n    }\n\n    /* リスト容量を取得する */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* 要素にアクセス */\n    int get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    void add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 中間に要素を挿入 */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size() == capacity())\n            extendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 要素を削除 */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"インデックスが範囲外\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        arrSize--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    void extendCapacity() {\n        // 元の配列の `extendRatio` 倍の長さを持つ新しい配列を作成する\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // 元の配列の全要素を新しい配列にコピー\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // メモリを解放する\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* 出力用にリストを Vector に変換 */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* リストクラス */\nclass MyList {\n    private int[] arr; // 配列（リスト要素を格納）\n    private int capacity = 10; // リスト容量\n    private int size = 0; // リストの長さ（現在の要素数）\n    private int extendRatio = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public int size() {\n        return size;\n    }\n\n    /* リスト容量を取得する */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* 要素にアクセス */\n    public int get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public void add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // 要素数を更新\n        size++;\n    }\n\n    /* 中間に要素を挿入 */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        size++;\n    }\n\n    /* 要素を削除 */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"インデックスが範囲外です\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public void extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // リストの容量を更新\n        capacity = arr.length;\n    }\n\n    /* リストを配列に変換する */\n    public int[] toArray() {\n        int size = size();\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* リストクラス */\nclass MyList {\n    private int[] arr;           // 配列（リスト要素を格納）\n    private int arrCapacity = 10;    // リスト容量\n    private int arrSize = 0;         // リストの長さ（現在の要素数）\n    private readonly int extendRatio = 2;  // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* リスト容量を取得する */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* 要素にアクセス */\n    public int Get(int index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        return arr[index];\n    }\n\n    /* 要素を更新 */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public void Add(int num) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 中間に要素を挿入 */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 要素数を更新\n        arrSize++;\n    }\n\n    /* 要素を削除 */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"インデックスが範囲外です\");\n        int num = arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 要素数を更新\n        arrSize--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public void ExtendCapacity() {\n        // `arrCapacity * extendRatio` の長さを持つ配列を新規作成し、元の配列を新しい配列にコピーする\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // リストの容量を更新\n        arrCapacity = arr.Length;\n    }\n\n    /* リストを配列に変換する */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* リストクラス */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* コンストラクタ */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // リスト容量\n        arr:         make([]int, 10), // 配列（リスト要素を格納）\n        arrSize:     0,               // リストの長さ（現在の要素数）\n        extendRatio: 2,               // リスト拡張時の増加倍率\n    }\n}\n\n/* リストの長さを取得（現在の要素数） */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* リスト容量を取得する */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* 要素にアクセス */\nfunc (l *myList) get(index int) int {\n    // インデックスが範囲外なら例外を送出する。以下同様\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    return l.arr[index]\n}\n\n/* 要素を更新 */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    l.arr[index] = num\n}\n\n/* 末尾に要素を追加 */\nfunc (l *myList) add(num int) {\n    // 要素数が容量を超えると、拡張機構が発動する\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // 要素数を更新\n    l.arrSize++\n}\n\n/* 中間に要素を挿入 */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    // 要素数が容量を超えると、拡張機構が発動する\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // index 以降の要素をすべて 1 つ後ろへずらす\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // 要素数を更新\n    l.arrSize++\n}\n\n/* 要素を削除 */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"インデックスが範囲外です\")\n    }\n    num := l.arr[index]\n    // インデックス index より後の要素をすべて 1 つ前に移動する\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // 要素数を更新\n    l.arrSize--\n    // 削除された要素を返す\n    return num\n}\n\n/* リストの拡張 */\nfunc (l *myList) extendCapacity() {\n    // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // リストの容量を更新\n    l.arrCapacity = len(l.arr)\n}\n\n/* 有効長のリストを返す */\nfunc (l *myList) toArray() []int {\n    // 有効長の範囲内のリスト要素のみを変換\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* リストクラス */\nclass MyList {\n    private var arr: [Int] // 配列（リスト要素を格納）\n    private var _capacity: Int // リスト容量\n    private var _size: Int // リストの長さ（現在の要素数）\n    private let extendRatio: Int // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* リスト容量を取得する */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* 要素にアクセス */\n    func get(index: Int) -&gt; Int {\n        // インデックスが範囲外ならエラーを投げる。以下同様\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        return arr[index]\n    }\n\n    /* 要素を更新 */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        arr[index] = num\n    }\n\n    /* 末尾に要素を追加 */\n    func add(num: Int) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // 要素数を更新\n        _size += 1\n    }\n\n    /* 中間に要素を挿入 */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        // 要素数が容量を超えると、拡張機構が発動する\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // 要素数を更新\n        _size += 1\n    }\n\n    /* 要素を削除 */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"インデックスが範囲外\")\n        }\n        let num = arr[index]\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // 要素数を更新\n        _size -= 1\n        // 削除された要素を返す\n        return num\n    }\n\n    /* リストの拡張 */\n    func extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // リストの容量を更新\n        _capacity = arr.count\n    }\n\n    /* リストを配列に変換する */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* リストクラス */\nclass MyList {\n    #arr = new Array(); // 配列（リスト要素を格納）\n    #capacity = 10; // リスト容量\n    #size = 0; // リストの長さ（現在の要素数）\n    #extendRatio = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    size() {\n        return this.#size;\n    }\n\n    /* リスト容量を取得する */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* 要素にアクセス */\n    get(index) {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        return this.#arr[index];\n    }\n\n    /* 要素を更新 */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        this.#arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    add(num) {\n        // 長さが容量に等しい場合は拡張が必要\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 新しい要素をリストの末尾に追加する\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* 中間に要素を挿入 */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // 要素数を更新\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* 要素を削除 */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('インデックスが範囲外です');\n        let num = this.#arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // 要素数を更新\n        this.#size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // リストの容量を更新\n        this.#capacity = this.#arr.length;\n    }\n\n    /* リストを配列に変換する */\n    toArray() {\n        let size = this.size();\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* リストクラス */\nclass MyList {\n    private arr: Array&lt;number&gt;; // 配列（リスト要素を格納）\n    private _capacity: number = 10; // リスト容量\n    private _size: number = 0; // リストの長さ（現在の要素数）\n    private extendRatio: number = 2; // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    public size(): number {\n        return this._size;\n    }\n\n    /* リスト容量を取得する */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* 要素にアクセス */\n    public get(index: number): number {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        return this.arr[index];\n    }\n\n    /* 要素を更新 */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        this.arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    public add(num: number): void {\n        // 長さが容量に等しい場合は拡張が必要\n        if (this._size === this._capacity) this.extendCapacity();\n        // 新しい要素をリストの末尾に追加する\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* 中間に要素を挿入 */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // 要素数を更新\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* 要素を削除 */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('インデックスが範囲外です');\n        let num = this.arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // 要素数を更新\n        this._size--;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    public extendCapacity(): void {\n        // `size` の長さを持つ配列を新規作成し、元の配列を新しい配列にコピーする\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // リストの容量を更新\n        this._capacity = this.arr.length;\n    }\n\n    /* リストを配列に変換する */\n    public toArray(): number[] {\n        let size = this.size();\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* リストクラス */\nclass MyList {\n  late List&lt;int&gt; _arr; // 配列（リスト要素を格納）\n  int _capacity = 10; // リスト容量\n  int _size = 0; // リストの長さ（現在の要素数）\n  int _extendRatio = 2; // リスト拡張時の増加倍率\n\n  /* コンストラクタ */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* リストの長さを取得（現在の要素数） */\n  int size() =&gt; _size;\n\n  /* リスト容量を取得する */\n  int capacity() =&gt; _capacity;\n\n  /* 要素にアクセス */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    return _arr[index];\n  }\n\n  /* 要素を更新 */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    _arr[index] = _num;\n  }\n\n  /* 末尾に要素を追加 */\n  void add(int _num) {\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // 要素数を更新\n    _size++;\n  }\n\n  /* 中間に要素を挿入 */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (_size == _capacity) extendCapacity();\n    // index 以降の要素をすべて 1 つ後ろへずらす\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // 要素数を更新\n    _size++;\n  }\n\n  /* 要素を削除 */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('インデックスが範囲外です');\n    int _num = _arr[index];\n    // インデックス index より後の要素をすべて 1 つ前に移動する\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // 要素数を更新\n    _size--;\n    // 削除された要素を返す\n    return _num;\n  }\n\n  /* リストの拡張 */\n  void extendCapacity() {\n    // 元の配列の `_extendRatio` 倍の長さを持つ新しい配列を作成する\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // 元の配列を新しい配列にコピー\n    List.copyRange(_newNums, 0, _arr);\n    // `_arr` の参照を更新\n    _arr = _newNums;\n    // リストの容量を更新\n    _capacity = _arr.length;\n  }\n\n  /* リストを配列に変換する */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* リストクラス */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // 配列（リスト要素を格納）\n    capacity: usize,     // リスト容量\n    size: usize,         // リストの長さ（現在の要素数）\n    extend_ratio: usize, // リスト拡張時の増加倍率\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* コンストラクタ */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* リスト容量を取得する */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* 要素にアクセス */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if index &gt;= self.size {\n            panic!(\"インデックスが範囲外です\")\n        };\n        return self.arr[index];\n    }\n\n    /* 要素を更新 */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"インデックスが範囲外です\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* 末尾に要素を追加 */\n    pub fn add(&amp;mut self, num: i32) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // 要素数を更新\n        self.size += 1;\n    }\n\n    /* 中間に要素を挿入 */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"インデックスが範囲外です\")\n        };\n        // 要素数が容量を超えると、拡張機構が発動する\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // 要素数を更新\n        self.size += 1;\n    }\n\n    /* 要素を削除 */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"インデックスが範囲外です\")\n        };\n        let num = self.arr[index];\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // 要素数を更新\n        self.size -= 1;\n        // 削除された要素を返す\n        return num;\n    }\n\n    /* リストの拡張 */\n    pub fn extend_capacity(&amp;mut self) {\n        // 元の配列の extend_ratio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // リストの容量を更新\n        self.capacity = new_capacity;\n    }\n\n    /* リストを配列に変換する */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // 有効長の範囲内のリスト要素のみを変換\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* リストクラス */\ntypedef struct {\n    int *arr;        // 配列（リスト要素を格納）\n    int capacity;    // リスト容量\n    int size;        // リストのサイズ\n    int extendRatio; // リストが拡張されるたびの倍率\n} MyList;\n\n/* コンストラクタ */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* デストラクタ */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* リストの長さを取得 */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* リスト容量を取得する */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* 要素にアクセス */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* 要素を更新 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* 末尾に要素を追加 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 容量を拡張\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* 中間に要素を挿入 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // 要素数が容量を超えると、拡張機構が発動する\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 容量を拡張\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* 要素を削除 */\n// 注意: stdio.h が remove 識別子を使用している\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* リストの拡張 */\nvoid extendCapacity(MyList *nums) {\n    // 先に領域を確保する\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // 古いデータを新しいデータにコピー\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // 古いデータを解放する\n    free(temp);\n\n    // 新しいデータに更新\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* 出力用にリストを Array に変換 */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* リストクラス */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // 配列（リスト要素を格納）\n    private var capacity: Int = 10 // リスト容量\n    private var size: Int = 0 // リストの長さ（現在の要素数）\n    private var extendRatio: Int = 2 // リスト拡張時の増加倍率\n\n    /* コンストラクタ */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* リストの長さを取得（現在の要素数） */\n    fun size(): Int {\n        return size\n    }\n\n    /* リスト容量を取得する */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* 要素にアクセス */\n    fun get(index: Int): Int {\n        // インデックスが範囲外なら例外を送出する。以下同様\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        return arr[index]\n    }\n\n    /* 要素を更新 */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        arr[index] = num\n    }\n\n    /* 末尾に要素を追加 */\n    fun add(num: Int) {\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // 要素数を更新\n        size++\n    }\n\n    /* 中間に要素を挿入 */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        // 要素数が容量を超えると、拡張機構が発動する\n        if (size == capacity())\n            extendCapacity()\n        // index 以降の要素をすべて 1 つ後ろへずらす\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // 要素数を更新\n        size++\n    }\n\n    /* 要素を削除 */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"インデックスが範囲外\")\n        val num = arr[index]\n        // インデックス index より後の要素をすべて 1 つ前に移動する\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // 要素数を更新\n        size--\n        // 削除された要素を返す\n        return num\n    }\n\n    /* リストの拡張 */\n    fun extendCapacity() {\n        // 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n        arr = arr.copyOf(capacity() * extendRatio)\n        // リストの容量を更新\n        capacity = arr.size\n    }\n\n    /* リストを配列に変換する */\n    fun toArray(): IntArray {\n        val size = size()\n        // 有効長の範囲内のリスト要素のみを変換\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### リストクラス ###\nclass MyList\n  attr_reader :size       # リストの長さを取得（現在の要素数）\n  attr_reader :capacity   # リスト容量を取得する\n\n  ### コンストラクタ ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### 要素にアクセス ###\n  def get(index)\n    # インデックスが範囲外なら例外を送出する。以下同様\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### 要素にアクセス ###\n  def set(index, num)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### 末尾に要素を追加 ###\n  def add(num)\n    # 要素数が容量を超えると、拡張機構が発動する\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # 要素数を更新\n    @size += 1\n  end\n\n  ### 途中に要素を挿入 ###\n  def insert(index, num)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n\n    # 要素数が容量を超えると、拡張機構が発動する\n    extend_capacity if size == capacity\n\n    # index 以降の要素をすべて 1 つ後ろへずらす\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # 要素数を更新\n    @size += 1\n  end\n\n  ### 要素の削除 ###\n  def remove(index)\n    raise IndexError, \"インデックスが範囲外です\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # インデックス index より後の要素をすべて 1 つ前に移動する\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # 要素数を更新\n    @size -= 1\n\n    # 削除された要素を返す\n    num\n  end\n\n  ### リストの容量拡張 ###\n  def extend_capacity\n    # 元の配列の extend_ratio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # リストの容量を更新\n    @capacity = arr.length\n  end\n\n  ### リストを配列に変換 ###\n  def to_array\n    sz = size\n    # 有効長の範囲内のリスト要素のみを変換\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.3 &nbsp; リスト"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   メモリとキャッシュ *","text":"<p>本章の前二節では、配列と連結リストという二つの基礎的かつ重要なデータ構造を扱いました。これらはそれぞれ「連続格納」と「分散格納」という二つの物理構造を表しています。</p> <p>実際には、物理構造はプログラムにおけるメモリとキャッシュの利用効率を大きく左右し、ひいてはアルゴリズムプログラム全体の性能に影響します。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   コンピュータの記憶装置","text":"<p>コンピュータには三種類の記憶装置があります。ハードディスク（hard disk）、メモリ（random-access memory, RAM）、キャッシュ（cache memory）です。以下の表は、これらがコンピュータシステムで担う役割と性能上の特徴を示しています。</p> <p> 表 4-2   コンピュータの記憶装置 </p> ハードディスク メモリ キャッシュ 用途 OS、プログラム、ファイルなどを長期保存 実行中のプログラムや処理中のデータを一時保存 頻繁にアクセスされるデータや命令を保存し、CPU のメモリアクセス回数を減らす 揮発性 電源断後もデータは失われない 電源断後にデータは失われる 電源断後にデータは失われる 容量 大きい、TB 級 小さい、GB 級 非常に小さい、MB 級 速度 遅い、数百〜数千 MB/s 速い、数十 GB/s 非常に速い、数十〜数百 GB/s 価格（人民元） 比較的安価、数角〜数元 / GB 比較的高価、数十〜数百元 / GB 非常に高価、CPU と一体で価格設定される <p>コンピュータの記憶システムは、下図のようなピラミッド構造として捉えられます。ピラミッドの頂点に近い記憶装置ほど速度は速く、容量は小さく、コストは高くなります。この多層構造は偶然ではなく、コンピュータ科学者やエンジニアによる熟慮の末の設計です。</p> <ul> <li>ハードディスクはメモリで置き換えにくい。まず、メモリ内のデータは電源断後に失われるため、長期保存には向きません。次に、メモリのコストはハードディスクの数十倍であり、消費者市場で広く普及しにくいという問題があります。</li> <li>キャッシュは大容量と高速性を両立しにくい。L1、L2、L3 キャッシュの容量が段階的に増えるにつれて、物理サイズは大きくなり、CPU コアとの物理的距離も遠くなります。その結果、データ転送時間が増え、要素アクセスの遅延も大きくなります。現在の技術では、多層キャッシュ構造が容量、速度、コストの最適なバランスです。</li> </ul> <p></p> <p> 図 4-9   コンピュータの記憶システム </p> <p>Tip</p> <p>コンピュータの記憶階層は、速度、容量、コストの三者間にある巧妙なバランスを体現しています。実際、このようなトレードオフはあらゆる工業分野に広く存在しており、異なる利点と制約のあいだで最適な均衡点を見つけることが求められます。</p> <p>要するに、ハードディスクは大量データの長期保存に、メモリはプログラム実行中に処理しているデータの一時保存に、キャッシュは頻繁にアクセスされるデータや命令の保存に用いられ、プログラム実行効率を高めます。三者は協調して動作し、コンピュータシステムの高効率な運用を支えています。</p> <p>次の図に示すように、プログラム実行時にはデータがハードディスクからメモリへ読み込まれ、CPU の計算に使われます。キャッシュは CPU の一部と見なせ、メモリからデータを賢く読み込むことで、CPU に高速なデータ読み出しを提供し、プログラムの実行効率を大きく高め、低速なメモリへの依存を減らします。</p> <p></p> <p> 図 4-10   ハードディスク、メモリ、キャッシュ間のデータの流れ </p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   データ構造のメモリ効率","text":"<p>メモリ空間の利用という観点では、配列と連結リストにはそれぞれ利点と制約があります。</p> <p>一方で、メモリは有限であり、同じメモリ領域を複数のプログラムで共有することはできません。そのため、データ構造にはできるだけ効率よく空間を使うことが求められます。配列の要素は密に並んでおり、連結リストのノード間参照（ポインタ）を保持する追加領域が不要なため、空間効率は高くなります。しかし、配列は十分な連続メモリを一度に確保する必要があり、メモリ浪費を招くことがありますし、拡張時にも追加の時間と空間コストがかかります。これに対して連結リストは「ノード」単位で動的にメモリを割り当て・解放でき、より高い柔軟性を備えています。</p> <p>他方で、プログラムの実行中には、メモリの確保と解放を繰り返すにつれて、空きメモリの断片化はますます進み、メモリ利用効率の低下を招きます。配列は連続した格納方式を取るため、比較的メモリ断片化を起こしにくい構造です。反対に、連結リストの要素は分散して格納されるため、頻繁な挿入や削除を行うと、より断片化を招きやすくなります。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   データ構造のキャッシュ効率","text":"<p>キャッシュは容量こそメモリよりはるかに小さいものの、速度はメモリよりずっと速く、プログラム実行速度において極めて重要な役割を果たします。キャッシュ容量には限りがあり、頻繁にアクセスされる一部のデータしか保持できません。そのため、CPU がアクセスしようとするデータがキャッシュ内に存在しない場合、キャッシュミス（cache miss）が発生し、CPU は低速なメモリから必要なデータを読み込まなければなりません。</p> <p>当然ながら、「キャッシュミス」が少ないほど、CPU のデータ読み書き効率は高くなり、プログラム性能も向上します。CPU がキャッシュからデータを正常に取得できた割合をキャッシュヒット率（cache hit rate）と呼び、この指標は通常、キャッシュ効率の評価に用いられます。</p> <p>できるだけ高い効率を実現するため、キャッシュは次のようなデータ読み込みの仕組みを採用しています。</p> <ul> <li>キャッシュライン：キャッシュはデータを 1 バイト単位で保存・読み込みするのではなく、キャッシュライン単位で扱います。1 バイト単位の転送と比べて、キャッシュライン単位のほうが効率的です。</li> <li>プリフェッチ機構：プロセッサはデータアクセスのパターン（たとえば順次アクセス、一定ステップ幅のスキップアクセスなど）を予測し、そのパターンに応じてデータをキャッシュへ読み込むことで、ヒット率を高めます。</li> <li>空間的局所性：あるデータがアクセスされた場合、その近傍のデータも近いうちにアクセスされる可能性があります。そのため、キャッシュはあるデータを読み込む際に、その周辺のデータもあわせて読み込み、ヒット率を高めます。</li> <li>時間的局所性：あるデータがアクセスされた場合、そのデータは近い将来に再びアクセスされる可能性が高いです。キャッシュはこの性質を利用し、最近アクセスしたデータを保持することでヒット率を高めます。</li> </ul> <p>実際には、配列と連結リストではキャッシュの利用効率が異なり、主に次の点に表れます。</p> <ul> <li>使用空間：連結リストの要素は配列要素より多くの空間を占めるため、キャッシュに収まる有効データ量は少なくなります。</li> <li>キャッシュライン：連結リストのデータはメモリの各所に分散しており、キャッシュは「ライン単位で読み込む」ため、無効データまで読み込む割合が高くなります。</li> <li>プリフェッチ機構：配列のほうが連結リストよりもデータアクセスのパターンを「予測しやすく」、システムが次に読み込まれるデータを推測しやすくなります。</li> <li>空間的局所性：配列はまとまったメモリ空間に格納されるため、読み込まれたデータの近くにあるデータも、まもなくアクセスされる可能性が高くなります。</li> </ul> <p>全体として、配列はより高いキャッシュヒット率を持つため、操作効率では通常、連結リストより優れています。このため、アルゴリズム問題を解く際には、配列ベースで実装されたデータ構造のほうが好まれることが多くなります。</p> <p>注意すべきなのは、**キャッシュ効率が高いからといって、配列があらゆる状況で連結リストより優れているとは限らない**という点です。実際にどのデータ構造を選ぶかは、具体的な要件に応じて決めるべきです。たとえば、配列と連結リストはいずれも「スタック」データ構造を実装できますが（次章で詳しく説明します）、適した場面は異なります。</p> <ul> <li>アルゴリズム問題に取り組むときは、一般に配列ベースのスタックを選ぶ傾向があります。より高い操作効率とランダムアクセス能力を備えており、その代償は配列用に一定量のメモリを事前確保することだけです。</li> <li>データ量が非常に大きく、動的性が高く、スタックの想定サイズを見積もりにくい場合は、連結リストベースのスタックのほうが適しています。連結リストなら大量のデータをメモリの異なる場所に分散して保存でき、配列拡張による追加コストも回避できます。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.4 &nbsp; メモリとキャッシュ *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   まとめ","text":"","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>配列と連結リストは 2 種類の基本的なデータ構造であり、それぞれコンピュータメモリにおけるデータの 2 つの格納方式、すなわち連続領域への格納と分散領域への格納を表す。両者の特徴は相互補完的である。</li> <li>配列はランダムアクセスをサポートし、使用メモリも少ない。一方で、要素の挿入と削除の効率は低く、初期化後に長さを変更できない。</li> <li>連結リストは参照（ポインタ）を変更することでノードの挿入と削除を効率的に行え、長さも柔軟に調整できる。一方で、ノードへのアクセス効率は低く、メモリ使用量も多い。一般的な連結リストには単方向連結リスト、循環連結リスト、双方向連結リストがある。</li> <li>リストは、追加・削除・検索・更新をサポートする順序付き要素集合であり、通常は動的配列に基づいて実装される。配列の利点を保ちながら、長さを柔軟に調整できる。</li> <li>リストの登場により配列の実用性は大幅に高まったが、一部のメモリ領域が無駄になる可能性がある。</li> <li>プログラムの実行時、データは主にメモリに格納される。配列はより高いメモリ空間効率を提供でき、連結リストはメモリ利用の面でより柔軟である。</li> <li>キャッシュは、キャッシュライン、プリフェッチ機構、空間局所性と時間局所性といったデータ読み込み機構を通じて CPU に高速なデータアクセスを提供し、プログラムの実行効率を大きく向上させる。</li> <li>配列はキャッシュヒット率が高いため、通常は連結リストよりも高効率である。データ構造を選択する際は、具体的な要件や場面に応じて適切に選ぶべきである。</li> </ul>","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：配列をスタックに格納する場合とヒープに格納する場合では、時間効率と空間効率に影響がありますか？</p> <p>スタック上とヒープ上の配列はいずれも連続したメモリ領域に格納されるため、データ操作の効率は基本的に同じである。ただし、スタックとヒープにはそれぞれ特徴があり、以下の違いが生じる。</p> <ol> <li>確保と解放の効率：スタックは比較的小さなメモリ領域で、確保はコンパイラによって自動的に行われる。一方、ヒープメモリは相対的に大きく、コード内で動的に確保できる反面、断片化しやすい。そのため、ヒープ上での確保と解放は通常スタック上より遅い。</li> <li>サイズ制限：スタックメモリは比較的小さく、ヒープのサイズは一般に利用可能メモリに制限される。そのため、ヒープは大きな配列の格納により適している。</li> <li>柔軟性：スタック上の配列サイズはコンパイル時に確定している必要があるが、ヒープ上の配列サイズは実行時に動的に決定できる。</li> </ol> <p>Q：なぜ配列では同じ型の要素が求められるのに、連結リストでは同じ型であることが強調されないのですか？</p> <p>連結リストはノードで構成され、ノード同士は参照（ポインタ）で接続されている。各ノードには <code>int</code>、<code>double</code>、<code>string</code>、<code>object</code> など、異なる型のデータを格納できる。</p> <p>これに対して、配列要素は同じ型でなければならない。そうでなければ、オフセットを計算して対応する要素位置を取得できないからである。たとえば、配列に <code>int</code> と <code>long</code> の 2 種類が同時に含まれていて、各要素がそれぞれ 4 バイトと 8 バイトを占める場合、配列内に 2 種類の「要素長」が存在するため、次の式ではオフセットを計算できない。</p> <pre><code># 要素のメモリアドレス = 配列のメモリアドレス（先頭要素のメモリアドレス） + 要素長 * 要素インデックス\n</code></pre> <p>Q：ノード <code>P</code> を削除した後、<code>P.next</code> を <code>None</code> に設定する必要はありますか？</p> <p><code>P.next</code> を変更しなくてもよい。この連結リストの観点では、先頭ノードから末尾ノードまでたどっても、もはや <code>P</code> に出会うことはない。つまり、ノード <code>P</code> はすでに連結リストから削除されており、この時点で <code>P</code> がどこを指していても、この連結リストには影響しない。</p> <p>データ構造とアルゴリズム（問題を解くとき）の観点では、切り離さなくても問題はなく、プログラムのロジックが正しいことを保証すればよい。標準ライブラリの観点では、切り離したほうがより安全で、ロジックも明確である。切り離さない場合、削除されたノードが適切に回収されなかったとすると、後続ノードのメモリ回収に影響する可能性がある。</p> <p>Q：連結リストでの挿入と削除の時間計算量は \\(O(1)\\) です。しかし、追加や削除の前には要素を探すのに \\(O(n)\\) の時間が必要です。では、なぜ時間計算量は \\(O(n)\\) ではないのですか？</p> <p>要素を先に探してから削除するのであれば、時間計算量が \\(O(n)\\) であるのは確かである。しかし、連結リストの \\(O(1)\\) での追加・削除という利点は、ほかの用途で生かせる。たとえば、両端キューは連結リストで実装するのに適しており、先頭ノードと末尾ノードを常に指すポインタ変数を維持すれば、各挿入・削除操作はどれも \\(O(1)\\) になる。</p> <p>Q：図「連結リストの定義と格納方式」で、薄青色のノードポインタ部分は 1 つのメモリアドレスを占めているのですか？ それともノード値と半分ずつなのでしょうか？</p> <p>この模式図は定性的な表現にすぎず、定量的な表現は具体的な状況に応じて分析する必要がある。</p> <ul> <li>ノード値が占める領域は型によって異なり、たとえば <code>int</code>、<code>long</code>、<code>double</code>、インスタンスオブジェクトなどがある。</li> <li>ポインタ変数が占めるメモリ空間の大きさは、使用する OS やコンパイル環境によって異なり、多くは 8 バイトまたは 4 バイトである。</li> </ul> <p>Q：リストの末尾への要素追加は常に \\(O(1)\\) ですか？</p> <p>要素を追加する際にリスト長を超える場合は、先にリストを拡張してから追加する必要がある。システムは新しいメモリ領域を確保し、元のリストの全要素をそこへ移動するため、このとき時間計算量は \\(O(n)\\) になる。</p> <p>Q：「リストの登場により配列の実用性は大きく向上したが、一部のメモリ空間が無駄になる可能性がある」というのは、容量、長さ、拡張倍率のような追加変数が占めるメモリのことですか？</p> <p>ここでいう空間の無駄には主に 2 つの意味がある。一方では、リストには初期長が設定されるが、必ずしもそれだけ必要とは限らない。もう一方では、頻繁な拡張を防ぐため、拡張時には通常ある係数、たとえば \\(\\times 1.5\\) を掛ける。このため、多くの空きスロットが生じ、通常それらを完全に埋めることはできない。</p> <p>Q：Python で <code>n = [1, 2, 3]</code> を初期化した後、この 3 つの要素のアドレスは連続しています。しかし <code>m = [2, 1, 3]</code> を初期化すると、各要素の id は連続しておらず、それぞれ <code>n</code> 内の同じ値と一致していることがわかります。これらの要素のアドレスが連続していないなら、<code>m</code> も配列なのですか？</p> <p>仮にリスト要素を連結リストのノード <code>n = [n1, n2, n3, n4, n5]</code> に置き換えたとしても、通常この 5 つのノードオブジェクトもメモリ上の各所に分散して格納される。それでも、与えられたリストインデックスに対して、私たちは依然として \\(O(1)\\) 時間でノードのメモリアドレスを取得し、対応するノードにアクセスできる。これは、配列に格納されているのがノードそのものではなく、ノードへの参照だからである。</p> <p>多くの言語と異なり、Python では数値もオブジェクトとしてラップされており、リストに格納されているのは数値そのものではなく、数値への参照である。そのため、2 つの配列内の同じ数値が同一の id を持つことがあり、しかもそれらの数値のメモリアドレスは連続している必要がない。</p> <p>Q：C++ STL の <code>std::list</code> はすでに双方向連結リストを実装していますが、アルゴリズム本ではあまり直接使われないようです。何か制約があるのでしょうか？</p> <p>一方では、私たちは多くの場合、アルゴリズムの実装に配列を好み、必要なときにだけ連結リストを使う。その主な理由は 2 つある。</p> <ul> <li>空間オーバーヘッド：各要素には 2 つの追加ポインタ（前の要素用と次の要素用）が必要なため、<code>std::list</code> は通常 <code>std::vector</code> より多くの空間を消費する。</li> <li>キャッシュ非効率：データが連続して格納されていないため、<code>std::list</code> はキャッシュの利用効率が低い。一般には、<code>std::vector</code> のほうが性能がよい。</li> </ul> <p>もう一方では、連結リストを使う必要がある代表的な場面は主に二分木とグラフである。スタックやキューについては、連結リストではなく、たいてい言語が提供する <code>stack</code> と <code>queue</code> を使う。</p> <p>Q：<code>res = [[0]] * n</code> という操作で 2 次元リストを生成した場合、それぞれの <code>[0]</code> は独立していますか？</p> <p>独立していない。この 2 次元リストでは、すべての <code>[0]</code> は実際には同一オブジェクトへの参照である。そのうちの 1 つを変更すると、対応するすべての要素が一緒に変化することがわかる。</p> <p>2 次元リスト内の各 <code>[0]</code> を独立させたい場合は、<code>res = [[0] for _ in range(n)]</code> を使って実現できる。この方式の原理は、独立した <code>[0]</code> リストオブジェクトを \\(n\\) 個初期化していることにある。</p> <p>Q：<code>res = [0] * n</code> という操作で生成されたリストでは、それぞれの整数 0 は独立していますか？</p> <p>このリストでは、すべての整数 0 が同一オブジェクトへの参照である。これは、Python が小さな整数（通常は -5 から 256）に対してキャッシュプール機構を採用し、オブジェクトの再利用を最大化して性能を向上させているためである。</p> <p>それらは同じオブジェクトを指しているが、それでもリスト内の各要素は独立して変更できる。これは、Python の整数が「イミュータブルオブジェクト」だからである。ある要素を変更するとき、実際には別のオブジェクトへの参照に切り替わるのであって、元のオブジェクトそのものを変更しているわけではない。</p> <p>しかし、リスト要素が「ミュータブルオブジェクト」（たとえばリスト、辞書、クラスインスタンスなど）である場合は、ある要素を変更するとそのオブジェクト自体が直接変更され、そのオブジェクトを参照しているすべての要素に同じ変化が生じる。</p>","path":["第 4 章 &nbsp; 配列と連結リスト","4.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"第 13 章   バックトラッキング","text":"<p>Abstract</p> <p>私たちは迷宮の探検者のように、前へ進む道で困難に出会うことがあります。</p> <p>バックトラッキングの力によってやり直しができ、試行を重ね、最後には光へ通じる出口を見つけられます。</p>","path":["第 13 章 &nbsp; バックトラッキング"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"章の内容","text":"<ul> <li>13.1   バックトラッキングアルゴリズム</li> <li>13.2   全順列問題</li> <li>13.3   部分和問題</li> <li>13.4   n クイーン問題</li> <li>13.5   まとめ</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   バックトラッキングアルゴリズム","text":"<p>バックトラッキングアルゴリズム（backtracking algorithm）は、総当たりによって問題を解く手法です。その中核となる考え方は、初期状態から出発し、あり得るすべての解を力任せに探索し、正しい解に到達したらそれを記録し、解を見つけるか、考えられるすべての選択を試しても解が見つからなくなるまで続ける、というものです。</p> <p>バックトラッキングアルゴリズムでは、通常「深さ優先探索」を用いて解空間をたどります。「二分木」の章で述べたように、前順・中順・後順走査はいずれも深さ優先探索に属します。ここでは前順走査を使ってバックトラッキング問題を構成し、その仕組みを段階的に理解していきます。</p> <p>例題1</p> <p>1 本の二分木が与えられたとき、値が \\(7\\) のノードをすべて探索して記録し、そのノードのリストを返してください。</p> <p>この問題では、この木を前順走査し、現在のノードの値が \\(7\\) かどうかを判定します。該当する場合は、そのノードの値を結果リスト <code>res</code> に追加します。関連する処理は下図と次のコードのとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # 解を記録\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 解を記録\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* 前順走査：例題 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* 前順走査：例題 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // 解を記録\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* 前順走査：例題 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // 解を記録\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* 前順走査：例題 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 解を記録\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* 前順走査：例題 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 解を記録\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // 解を記録\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* 前順走査：例題 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* 前順走査：例題 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* 前順走査：例題 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### 前順走査：例題1 ###\ndef pre_order(root)\n  return unless root\n\n  # 解を記録\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 13-1   前順走査でノードを探索する </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   試行と戻る","text":"<p>バックトラッキングアルゴリズムと呼ばれるのは、解空間を探索する際に「試行」と「戻る」という戦略を取るためです。探索中に、ある状態から先へ進めない、または条件を満たす解を得られないと分かった場合、アルゴリズムは直前の選択を取り消して前の状態へ戻り、別の選択肢を試します。</p> <p>例題1では、各ノードへの訪問が 1 回の「試行」に対応し、葉ノードを越えるか親ノードへ戻る <code>return</code> は「戻る」を表します。</p> <p>ここで強調しておきたいのは、**戻るとは関数の return だけを指すわけではない**という点です。これを説明するために、例題1を少し拡張します。</p> <p>例題2</p> <p>二分木の中で値が \\(7\\) のノードをすべて探索し、根ノードからそれらのノードまでの経路を返してください。</p> <p>例題1のコードを土台に、訪問済みノードの経路を記録するためのリスト <code>path</code> を導入します。値が \\(7\\) のノードに到達したら、<code>path</code> をコピーして結果リスト <code>res</code> に追加します。走査が完了すると、<code>res</code> にはすべての解が保存されています。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 2\"\"\"\n    if root is None:\n        return\n    # 試す\n    path.append(root)\n    if root.val == 7:\n        # 解を記録\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # バックトラック\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // 試す\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // 試す\n    path.add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // バックトラック\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* 前順走査：例題 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // 試す\n    path.Add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // バックトラック\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* 前順走査：例題 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // 試す\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 解を記録\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // バックトラック\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* 前順走査：例題 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 試す\n    path.append(root)\n    if root.val == 7 {\n        // 解を記録\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // バックトラック\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* 前順走査：例題 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* 前順走査：例題 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // 試す\n  path.add(root);\n  if (root.val == 7) {\n    // 解を記録\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // バックトラック\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* 前順走査：例題 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // 試す\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // バックトラック\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* 前順走査：例題 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // 試す\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 解を記録\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* 前順走査：例題 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // 試す\n    path!!.add(root)\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // バックトラック\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### 前順走査：例題2 ###\ndef pre_order(root)\n  return unless root\n\n  # 試す\n  $path &lt;&lt; root\n\n  # 解を記録\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # バックトラック\n  $path.pop\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>各「試行」で現在のノードを <code>path</code> に追加して経路を記録し、「戻る」前にはそのノードを <code>path</code> から取り除き、**今回の試行前の状態を復元する**必要があります。</p> <p>次の図に示す過程を見ると、試行と戻るは「前進」と「取り消し」として理解できます。この 2 つの操作は互いに逆向きです。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 13-2   試行と戻る </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   枝刈り","text":"<p>複雑なバックトラッキング問題には、通常 1 つ以上の制約条件が含まれます。制約条件は多くの場合「枝刈り」に利用できます。</p> <p>例題3</p> <p>二分木の中で値が \\(7\\) のノードをすべて探索し、根ノードからそれらのノードまでの経路を返してください。ただし、経路には値が \\(3\\) のノードを含めてはいけません。</p> <p>上の制約条件を満たすために、枝刈り操作を追加する必要があります。探索中に値が \\(3\\) のノードに出会った場合は、そこで早めに return し、それ以上探索を続けません。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前順走査：例題 3\"\"\"\n    # 枝刈り\n    if root is None or root.val == 3:\n        return\n    # 試す\n    path.append(root)\n    if root.val == 7:\n        # 解を記録\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # バックトラック\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode *root) {\n    // 枝刈り\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // 試す\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 解を記録\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode root) {\n    // 枝刈り\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 試す\n    path.add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // バックトラック\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* 前順走査：例題 3 */\nvoid PreOrder(TreeNode? root) {\n    // 枝刈り\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 試す\n    path.Add(root);\n    if (root.val == 7) {\n        // 解を記録\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // バックトラック\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* 前順走査：例題 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // 枝刈り\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // 試す\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 解を記録\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // バックトラック\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* 前順走査：例題 3 */\nfunc preOrder(root: TreeNode?) {\n    // 枝刈り\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // 試す\n    path.append(root)\n    if root.val == 7 {\n        // 解を記録\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // バックトラック\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* 前順走査：例題 3 */\nfunction preOrder(root, path, res) {\n    // 枝刈り\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* 前順走査：例題 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 枝刈り\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 試す\n    path.push(root);\n    if (root.val === 7) {\n        // 解を記録\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // バックトラック\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // 試す\n  path.add(root);\n  if (root.val == 7) {\n    // 解を記録\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // バックトラック\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* 前順走査：例題 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // 枝刈り\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // 試す\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 解を記録\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // バックトラック\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* 前順走査：例題 3 */\nvoid preOrder(TreeNode *root) {\n    // 枝刈り\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // 試す\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 解を記録\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // バックトラック\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* 前順走査：例題 3 */\nfun preOrder(root: TreeNode?) {\n    // 枝刈り\n    if (root == null || root._val == 3) {\n        return\n    }\n    // 試す\n    path!!.add(root)\n    if (root._val == 7) {\n        // 解を記録\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // バックトラック\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### 前順走査：例題3 ###\ndef pre_order(root)\n  # 枝刈り\n  return if !root || root.val == 3\n\n  # 試す\n  $path.append(root)\n\n  # 解を記録\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # バックトラック\n  $path.pop\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>「枝刈り」は非常にイメージしやすい名称です。次の図のように、探索中に**制約条件を満たさない探索分岐を切り落とす**ことで、多くの無意味な試行を避け、探索効率を高められます。</p> <p></p> <p> 図 13-3   制約条件にもとづく枝刈り </p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   フレームワークコード","text":"<p>次に、バックトラッキングにおける「試行・戻る・枝刈り」の本体部分を抽出し、汎用性の高いコードフレームワークへまとめてみます。</p> <p>以下のフレームワークコードでは、<code>state</code> は問題の現在状態、<code>choices</code> はその状態で取り得る選択肢を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"バックトラッキングアルゴリズムのフレームワーク\"\"\"\n    # 解かどうかを判定\n    if is_solution(state):\n        # 解を記録\n        record_solution(state, res)\n        # これ以上探索しない\n        return\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り: 選択が妥当かを判定\n        if is_valid(state, choice):\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (Choice choice : choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (Choice choice : choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 解かどうかを判定\n    if (IsSolution(state)) {\n        // 解を記録\n        RecordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    foreach (Choice choice in choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (IsValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // 解かどうかを判定\n    if isSolution(state) {\n        // 解を記録\n        recordSolution(state, res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for _, choice := range choices {\n        // 枝刈り: 選択が妥当かを判定\n        if isValid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // 解かどうかを判定\n    if isSolution(state: state) {\n        // 解を記録\n        recordSolution(state: state, res: &amp;res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 選択が妥当かを判定\n        if isValid(state: state, choice: choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunction backtrack(state, choices, res) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (let choice of choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (let choice of choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // 解かどうかを判定\n  if (isSolution(state)) {\n    // 解を記録\n    recordSolution(state, res);\n    // これ以上探索しない\n    return;\n  }\n  // すべての選択肢を走査\n  for (Choice choice in choices) {\n    // 枝刈り: 選択が妥当かを判定\n    if (isValid(state, choice)) {\n      // 試行: 選択を行い、状態を更新\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // 戻る: 選択を取り消し、前の状態に戻す\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // 解かどうかを判定\n    if is_solution(state) {\n        // 解を記録\n        record_solution(state, res);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 選択が妥当かを判定\n        if is_valid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res, numRes);\n        // これ以上探索しない\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; numChoices; i++) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, &amp;choices[i])) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* バックトラッキングアルゴリズムのフレームワーク */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // 解かどうかを判定\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res)\n        // これ以上探索しない\n        return\n    }\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り: 選択が妥当かを判定\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 戻る: 選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### バックトラッキングアルゴリズムのフレームワーク ###\ndef backtrack(state, choices, res)\n    # 解かどうかを判定\n    if is_solution?(state)\n        # 解を記録\n        record_solution(state, res)\n        return\n    end\n\n    # すべての選択肢を走査\n    for choice in choices\n        # 枝刈り: 選択が妥当かを判定\n        if is_valid?(state, choice)\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 戻る: 選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>次に、このフレームワークコードを用いて例題3を解きます。状態 <code>state</code> はノードの走査経路、選択肢 <code>choices</code> は現在のノードの左子ノードと右子ノード、結果 <code>res</code> は経路のリストです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"現在の状態が解かどうかを判定\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"解を記録\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"現在の状態で、この選択が有効かどうかを判定\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"状態を更新\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"状態を元に戻す\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"バックトラッキング：例題 3\"\"\"\n    # 解かどうかを確認\n    if is_solution(state):\n        # 解を記録\n        record_solution(state, res)\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り：選択が妥当かを確認する\n        if is_valid(state, choice):\n            # 試行: 選択を行い、状態を更新\n            make_choice(state, choice)\n            # 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (TreeNode *choice : choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* 現在の状態が解かどうかを判定 */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (TreeNode choice : choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* 現在の状態が解かどうかを判定 */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* 解を記録 */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* 状態を元に戻す */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* バックトラッキング：例題 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 解かどうかを確認\n    if (IsSolution(state)) {\n        // 解を記録\n        RecordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    foreach (TreeNode choice in choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (IsValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            MakeChoice(state, choice);\n            // 次の選択へ進む\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* 現在の状態が解かどうかを判定 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* 解を記録 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* 状態を更新 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* 状態を元に戻す */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* バックトラッキング：例題 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // 解かどうかを確認\n    if isSolution(state) {\n        // 解を記録\n        recordSolution(state, res)\n    }\n    // すべての選択肢を走査\n    for _, choice := range *choices {\n        // 枝刈り：選択が妥当かを確認する\n        if isValid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            // 次の選択へ進む\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* 現在の状態が解かどうかを判定 */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* 解を記録 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* 状態を更新 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* 状態を元に戻す */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* バックトラッキング：例題 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // 解かどうかを確認\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り：選択が妥当かを確認する\n        if isValid(state: state, choice: choice) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state: &amp;state, choice: choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* 現在の状態が解かどうかを判定 */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 解を記録 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 状態を更新 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfunction backtrack(state, choices, res) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* 現在の状態が解かどうかを判定 */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 解を記録 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 状態を更新 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res);\n    }\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice);\n            // 次の選択へ進む\n            backtrack(state, [choice.left, choice.right], res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // 解かどうかを確認\n  if (isSolution(state)) {\n    // 解を記録\n    recordSolution(state, res);\n  }\n  // すべての選択肢を走査\n  for (TreeNode? choice in choices) {\n    // 枝刈り：選択が妥当かを確認する\n    if (isValid(state, choice)) {\n      // 試行: 選択を行い、状態を更新\n      makeChoice(state, choice);\n      // 次の選択へ進む\n      backtrack(state, [choice!.left, choice.right], res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* 現在の状態が解かどうかを判定 */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* 解を記録 */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* 状態を更新 */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* 状態を元に戻す */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* バックトラッキング：例題 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // 解かどうかを確認\n    if is_solution(state) {\n        // 解を記録\n        record_solution(state, res);\n    }\n    // すべての選択肢を走査\n    for &amp;choice in choices.iter() {\n        // 枝刈り：選択が妥当かを確認する\n        if is_valid(state, choice) {\n            // 試行: 選択を行い、状態を更新\n            make_choice(state, choice.unwrap().clone());\n            // 次の選択へ進む\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* 現在の状態が解かどうかを判定 */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* 解を記録 */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 状態を更新 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* 状態を元に戻す */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* バックトラッキング：例題 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // 解かどうかを確認\n    if (isSolution()) {\n        // 解を記録\n        recordSolution();\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(choice);\n            // 次の選択へ進む\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* 現在の状態が解かどうかを判定 */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* 解を記録 */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* 現在の状態で、この選択が有効かどうかを判定 */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* 状態を更新 */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* 状態を元に戻す */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* バックトラッキング：例題 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // 解かどうかを確認\n    if (isSolution(state)) {\n        // 解を記録\n        recordSolution(state, res)\n    }\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り：選択が妥当かを確認する\n        if (isValid(state, choice)) {\n            // 試行: 選択を行い、状態を更新\n            makeChoice(state, choice)\n            // 次の選択へ進む\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### 現在の状態が解かどうかを判定 ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### 解を記録 ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### 現在の状態で、この選択が妥当かを判定 ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### 状態を更新 ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### 状態を復元 ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### バックトラッキング法：例題3 ###\ndef backtrack(state, choices, res)\n  # 解かどうかを確認\n  record_solution(state, res) if is_solution?(state)\n\n  # すべての選択肢を走査\n  for choice in choices\n    # 枝刈り：選択が妥当かを確認する\n    if is_valid?(state, choice)\n      # 試行: 選択を行い、状態を更新\n      make_choice(state, choice)\n      # 次の選択へ進む\n      backtrack(state, [choice.left, choice.right], res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>問題の条件より、値が \\(7\\) のノードを見つけた後も探索を続ける必要があります。そのため、解を記録した後の <code>return</code> 文は削除しなければなりません。次の図は、<code>return</code> 文を残す場合と削除する場合の探索過程を比較したものです。</p> <p></p> <p> 図 13-4   return を残す場合と削除する場合の探索過程の比較 </p> <p>前順走査にもとづく実装と比べると、バックトラッキングアルゴリズムのフレームワークにもとづく実装はやや冗長に見えますが、汎用性に優れています。実際、多くのバックトラッキング問題はこのフレームワークで解けます。具体的な問題に応じて <code>state</code> と <code>choices</code> を定義し、各メソッドを実装すれば十分です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   よく使われる用語","text":"<p>アルゴリズム問題をより明確に分析するために、バックトラッキングでよく使われる用語の意味を整理し、例題3に対応する例を次の表にまとめます。</p> <p> 表 13-1   よく使われるバックトラッキング用語 </p> 用語 定義 例題3 解（solution） 問題の特定の条件を満たす答えであり、1 つまたは複数存在し得る 根ノードからノード \\(7\\) までの、制約条件を満たすすべての経路 制約条件（constraint） 解の実現可能性を制限する条件であり、通常は枝刈りに用いられる 経路にノード \\(3\\) を含まないこと 状態（state） ある時点における問題の状況を表し、すでに行った選択を含む 現在までに訪問したノードの経路、すなわち <code>path</code> ノードリスト 試行（attempt） 利用可能な選択肢にもとづいて解空間を探索する過程であり、選択、状態更新、解判定を含む 左右の子ノードを再帰的に訪問し、ノードを <code>path</code> に追加し、値が \\(7\\) か判定する 戻る（backtracking） 制約条件を満たさない状態に出会ったとき、それまでの選択を取り消して前の状態へ戻ること 葉ノードを越えたとき、ノード訪問を終えたとき、値が \\(3\\) のノードに出会ったときに探索を終了し、関数から戻る 枝刈り（pruning） 問題の性質や制約条件にもとづき、無意味な探索経路を避ける方法であり、探索効率を高める 値が \\(3\\) のノードに出会ったら、それ以上探索しない <p>Tip</p> <p>問題、解、状態などの概念は汎用的であり、分割統治、バックトラッキング、動的計画法、貪欲法などのアルゴリズムにも共通して現れます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   利点と限界","text":"<p>バックトラッキングアルゴリズムの本質は深さ優先探索です。条件を満たす解を見つけるまで、あり得るすべての解を試します。この方法の利点は、考えられるすべての解を見つけられることであり、適切な枝刈りを行えば高い効率を発揮します。</p> <p>しかし、大規模または複雑な問題を扱う場合、バックトラッキングアルゴリズムの実行効率は受け入れがたいことがあります。</p> <ul> <li>時間：バックトラッキングアルゴリズムでは通常、状態空間のすべての可能性をたどる必要があり、時間計算量は指数時間や階乗時間に達することがあります。</li> <li>空間：再帰呼び出しの過程では現在の状態（たとえば経路や枝刈り用の補助変数など）を保持する必要があり、深さが大きいと空間使用量も大きくなります。</li> </ul> <p>それでもなお、バックトラッキングアルゴリズムは一部の探索問題や制約充足問題に対する最良の解法です。この種の問題では、どの選択が有効な解を生むかを事前に予測できないため、可能な選択肢をすべてたどる必要があります。このときの鍵は**いかに効率を最適化するか**であり、代表的な方法は 2 つあります。</p> <ul> <li>枝刈り：解が生じないことが確実な経路を探索しないことで、時間と空間を節約する。</li> <li>ヒューリスティック探索：探索中に何らかの戦略や推定値を導入し、有効な解を生みやすい経路を優先的に探索する。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   バックトラッキングの典型例題","text":"<p>バックトラッキングアルゴリズムは、多くの探索問題、制約充足問題、組合せ最適化問題の解決に利用できます。</p> <p>探索問題：この種の問題の目標は、特定の条件を満たす解を見つけることです。</p> <ul> <li>全順列問題：ある集合が与えられたとき、考えられるすべての順列を求める。</li> <li>部分和問題：ある集合と目標和が与えられたとき、和が目標値となるすべての部分集合を見つける。</li> <li>ハノイの塔問題：3 本の柱と大きさの異なる複数の円盤が与えられたとき、すべての円盤を 1 本の柱から別の柱へ移動する。ただし 1 回に 1 枚しか動かせず、大きい円盤を小さい円盤の上に置いてはならない。</li> </ul> <p>制約充足問題：この種の問題の目標は、すべての制約条件を満たす解を見つけることです。</p> <ul> <li>\\(n\\) クイーン問題：\\(n \\times n\\) の盤面に \\(n\\) 個のクイーンを配置し、互いに攻撃し合わないようにする。</li> <li>数独：\\(9 \\times 9\\) のグリッドに数字 \\(1\\) ~ \\(9\\) を入れ、各行・各列・各 \\(3 \\times 3\\) の小区画で数字が重複しないようにする。</li> <li>グラフ彩色問題：無向グラフが与えられたとき、隣接する頂点が同じ色にならないように、できるだけ少ない色で各頂点を彩色する。</li> </ul> <p>組合せ最適化問題：この種の問題の目標は、組合せ空間の中で条件を満たす最適解を見つけることです。</p> <ul> <li>0-1 ナップサック問題：複数の品物とナップサックが与えられ、各品物には価値と重さがある。ナップサック容量の範囲内で総価値が最大になるように品物を選ぶ。</li> <li>巡回セールスマン問題：グラフ内のある頂点から出発し、他のすべての頂点をちょうど 1 回ずつ訪れて出発点へ戻るときの最短経路を求める。</li> <li>最大クリーク問題：無向グラフが与えられたとき、任意の 2 頂点間に辺が存在する最大の完全部分グラフを見つける。</li> </ul> <p>多くの組合せ最適化問題では、バックトラッキングは最適な解法ではない点に注意してください。</p> <ul> <li>0-1 ナップサック問題は通常、より高い時間効率を得るために動的計画法で解く。</li> <li>巡回セールスマン問題は著名な NP-Hard 問題であり、よく用いられる解法には遺伝的アルゴリズムや蟻コロニー最適化などがある。</li> <li>最大クリーク問題はグラフ理論における古典的問題であり、貪欲法などのヒューリスティックで解ける。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.1 &nbsp; バックトラッキングアルゴリズム"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   n クイーン問題","text":"<p>Question</p> <p>チェスのルールによれば、クイーンは同じ行、同じ列、または同じ斜線上にある駒を攻撃できます。\\(n\\) 個のクイーンと \\(n \\times n\\) サイズの盤面が与えられたとき、すべてのクイーンが互いに攻撃し合わない配置を求めます。</p> <p>下図に示すように、\\(n = 4\\) のとき、2 つの解を見つけることができます。バックトラッキングの観点から見ると、\\(n \\times n\\) サイズの盤面には合計 \\(n^2\\) 個のマスがあり、これがすべての選択肢 <code>choices</code> を与えます。クイーンを 1 つずつ配置していく過程で、盤面の状態は絶えず変化し、その各時点の盤面が状態 <code>state</code> です。</p> <p></p> <p> 図 13-15   4 クイーン問題の解 </p> <p>下図は本問題の 3 つの制約条件を示しています。複数のクイーンは同じ行、同じ列、同じ対角線上に置けません。なお、対角線には主対角線 <code>\\</code> と副対角線 <code>/</code> の 2 種類があります。</p> <p></p> <p> 図 13-16   n クイーン問題の制約条件 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   行ごとの配置戦略","text":"<p>クイーンの数と盤面の行数はいずれも \\(n\\) なので、次の推論を容易に得られます：盤面の各行にはクイーンを 1 つだけ配置できます。</p> <p>つまり、行ごとの配置戦略を採用できます：最初の行から始めて、各行に 1 つのクイーンを配置し、最後の行まで進みます。</p> <p>下図は 4 クイーン問題における行ごとの配置過程を示しています。図の大きさの都合上、下図では 1 行目における検索分岐の 1 つだけを展開し、列制約と対角線制約を満たさない案はすべて枝刈りしています。</p> <p></p> <p> 図 13-17   行ごとの配置戦略 </p> <p>本質的には、行ごとの配置戦略は枝刈りとして機能します。これにより、同じ行に複数のクイーンが現れるすべての探索分岐を回避できます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   列と対角線の枝刈り","text":"<p>列制約を満たすために、長さ \\(n\\) のブール配列 <code>cols</code> を用いて、各列にクイーンがあるかどうかを記録できます。配置を決めるたびに、<code>cols</code> を使って既存のクイーンがある列を枝刈りし、バックトラッキングの中で <code>cols</code> の状態を動的に更新します。</p> <p>Tip</p> <p>注意として、行列の原点は左上にあり、行インデックスは上から下へ、列インデックスは左から右へ増加します。</p> <p>では、対角線制約はどのように扱えばよいのでしょうか。盤面上のあるマスの行列インデックスを \\((row, col)\\) とし、行列内のある主対角線を選ぶと、その対角線上のすべてのマスで行インデックスから列インデックスを引いた値が等しいことが分かります。つまり、主対角線上のすべてのマスでは \\(row - col\\) が一定値になります。</p> <p>つまり、2 つのマスが \\(row_1 - col_1 = row_2 - col_2\\) を満たすなら、それらは必ず同じ主対角線上にあります。この性質を利用して、下図の配列 <code>diags1</code> により、各主対角線にクイーンがあるかどうかを記録できます。</p> <p>同様に、副対角線上のすべてのマスでは \\(row + col\\) が一定値です。副対角線制約も配列 <code>diags2</code> を使って処理できます。</p> <p></p> <p> 図 13-18   列制約と対角線制約の処理 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   コード実装","text":"<p>注意として、\\(n\\) 次正方行列では \\(row - col\\) の範囲は \\([-n + 1, n - 1]\\) 、\\(row + col\\) の範囲は \\([0, 2n - 2]\\) です。したがって、主対角線と副対角線の本数はいずれも \\(2n - 1\\) であり、配列 <code>diags1</code> と <code>diags2</code> の長さもともに \\(2n - 1\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"バックトラッキング：N クイーン\"\"\"\n    # すべての行への配置が完了したら、解を記録する\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # すべての列を走査\n    for col in range(n):\n        # このマスに対応する主対角線と副対角線を計算\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"N クイーンを解く\"\"\"\n    # n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # 列にクイーンがあるか記録\n    diags1 = [False] * (2 * n - 1)  # 主対角線にクイーンがあるかを記録\n    diags2 = [False] * (2 * n - 1)  # 副対角線にクイーンがあるかを記録\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // 列にクイーンがあるか記録\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // 主対角線にクイーンがあるかを記録\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // 副対角線にクイーンがあるかを記録\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // 列にクイーンがあるか記録\n    boolean[] diags1 = new boolean[2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    boolean[] diags2 = new boolean[2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* バックトラッキング：N クイーン */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // 列にクイーンがあるか記録\n    bool[] diags1 = new bool[2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    bool[] diags2 = new bool[2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* バックトラッキング：N クイーン */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // すべての列を走査\n    for col := 0; col &lt; n; col++ {\n        // このマスに対応する主対角線と副対角線を計算\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // 試行：そのマスにクイーンを置く\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // 次の行に配置する\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // 戻す：そのマスを空きマスに戻す\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunc nQueens(n int) [][][]string {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // 列にクイーンがあるか記録\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* バックトラッキング：N クイーン */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        res.append(state)\n        return\n    }\n    // すべての列を走査\n    for col in 0 ..&lt; n {\n        // このマスに対応する主対角線と副対角線を計算\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // 次の行に配置する\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // 列にクイーンがあるか記録\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // 主対角線にクイーンがあるかを記録\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // 副対角線にクイーンがあるかを記録\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* バックトラッキング：N クイーン */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // すべての列を走査\n    for (let col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunction nQueens(n) {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 列にクイーンがあるか記録\n    const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録\n    const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* バックトラッキング：N クイーン */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // すべての行への配置が完了したら、解を記録する\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // すべての列を走査\n    for (let col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nfunction nQueens(n: number): string[][][] {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 列にクイーンがあるか記録\n    const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録\n    const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // すべての行への配置が完了したら、解を記録する\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // すべての列を走査\n  for (int col = 0; col &lt; n; col++) {\n    // このマスに対応する主対角線と副対角線を計算\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // 試行：そのマスにクイーンを置く\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // 次の行に配置する\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // 戻す：そのマスを空きマスに戻す\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* N クイーンを解く */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // 列にクイーンがあるか記録\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // 主対角線にクイーンがあるかを記録\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // 副対角線にクイーンがあるかを記録\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* バックトラッキング：N クイーン */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // すべての行への配置が完了したら、解を記録する\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // すべての列を走査\n    for col in 0..n {\n        // このマスに対応する主対角線と副対角線を計算\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* N クイーンを解く */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // 列にクイーンがあるか記録\n    let mut diags1 = vec![false; 2 * n - 1]; // 主対角線にクイーンがあるかを記録\n    let mut diags2 = vec![false; 2 * n - 1]; // 副対角線にクイーンがあるかを記録\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* バックトラッキング：N クイーン */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての列を走査\n    for (int col = 0; col &lt; n; col++) {\n        // このマスに対応する主対角線と副対角線を計算\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* N クイーンを解く */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // 列にクイーンがあるか記録\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // 主対角線にクイーンがあるかを記録\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // 副対角線にクイーンがあるかを記録\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* バックトラッキング：N クイーン */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // すべての行への配置が完了したら、解を記録する\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // すべての列を走査\n    for (col in 0..&lt;n) {\n        // このマスに対応する主対角線と副対角線を計算\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 試行：そのマスにクイーンを置く\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // 次の行に配置する\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // 戻す：そのマスを空きマスに戻す\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* N クイーンを解く */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // 列にクイーンがあるか記録\n    val diags1 = BooleanArray(2 * n - 1) // 主対角線にクイーンがあるかを記録\n    val diags2 = BooleanArray(2 * n - 1) // 副対角線にクイーンがあるかを記録\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### バックトラッキング法：Nクイーン ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # すべての行への配置が完了したら、解を記録する\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # すべての列を走査\n  for col in 0...n\n    # このマスに対応する主対角線と副対角線を計算\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # 試行：そのマスにクイーンを置く\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # 次の行に配置する\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # 戻す：そのマスを空きマスに戻す\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Nクイーンを解く ###\ndef n_queens(n)\n  # n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # 列にクイーンがあるか記録\n  diags1 = Array.new(2 * n - 1, false) # 主対角線にクイーンがあるかを記録\n  diags2 = Array.new(2 * n - 1, false) # 副対角線にクイーンがあるかを記録\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>行ごとに \\(n\\) 回配置し、列制約を考慮すると、1 行目から最終行までの選択肢はそれぞれ \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 個となるため、時間計算量は \\(O(n!)\\) です。解を記録する際には、行列 <code>state</code> をコピーして <code>res</code> に追加する必要があり、このコピー操作には \\(O(n^2)\\) 時間を要します。したがって、全体の時間計算量は \\(O(n! \\cdot n^2)\\) です。実際には、対角線制約による枝刈りも探索空間を大きく縮小できるため、探索効率はしばしば上記の時間計算量より良くなります。</p> <p>配列 <code>state</code> は \\(O(n^2)\\) の空間を使用し、配列 <code>cols</code>、<code>diags1</code>、<code>diags2</code> はいずれも \\(O(n)\\) の空間を使用します。最大再帰深さは \\(n\\) で、スタックフレーム空間として \\(O(n)\\) を使用します。したがって、空間計算量は \\(O(n^2)\\) です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.4 &nbsp; n クイーン問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   全順列問題","text":"<p>全順列問題はバックトラッキングアルゴリズムの典型的な応用例です。これは、ある集合（配列や文字列など）が与えられたとき、その要素のあり得るすべての順列を求める問題です。</p> <p>下表に、入力配列とそれに対応するすべての順列から成る例をいくつか示します。</p> <p> 表 13-2   全順列の例 </p> 入力配列 すべての順列 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   等しい要素がない場合","text":"<p>Question</p> <p>重複要素を含まない整数配列を入力として受け取り、あり得るすべての順列を返します。</p> <p>バックトラッキングアルゴリズムの観点から見ると、順列生成の過程は一連の選択の結果として捉えられます。入力配列が \\([1, 2, 3]\\) だとすると、最初に \\(1\\) を選び、次に \\(3\\) を選び、最後に \\(2\\) を選べば、順列 \\([1, 3, 2]\\) が得られます。戻る操作は 1 つの選択を取り消し、その後で別の選択を試し続けることを表します。</p> <p>バックトラッキングコードの観点では、候補集合 <code>choices</code> は入力配列中のすべての要素であり、状態 <code>state</code> は現時点までに選ばれた要素です。各要素は 1 回しか選べないことに注意してください。したがって <code>state</code> 内の要素はすべて一意でなければなりません。</p> <p>下図のように、探索過程は再帰木として展開できます。木の各ノードは現在の状態 <code>state</code> を表します。根ノードから始めて 3 ラウンドの選択を経て葉ノードに到達し、各葉ノードが 1 つの順列に対応します。</p> <p></p> <p> 図 13-5   全順列の再帰木 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   重複選択の枝刈り","text":"<p>各要素が 1 回しか選ばれないようにするため、ブール配列 <code>selected</code> の導入を考えます。ここで <code>selected[i]</code> は <code>choices[i]</code> がすでに選ばれているかどうかを表し、これに基づいて次の枝刈りを行います。</p> <ul> <li>選択 <code>choice[i]</code> を行った後、<code>selected[i]</code> を \\(\\text{True}\\) に設定し、その要素が選択済みであることを表します。</li> <li>選択肢リスト <code>choices</code> を走査するとき、すでに選ばれたノードはすべてスキップします。これが枝刈りです。</li> </ul> <p>下図のように、1 回目に 1、2 回目に 3、3 回目に 2 を選ぶとします。このとき 2 回目では要素 1 の分岐を、3 回目では要素 1 と要素 3 の分岐を刈り取る必要があります。</p> <p></p> <p> 図 13-6   全順列の枝刈り例 </p> <p>上図から、この枝刈りにより探索空間の大きさは \\(O(n^n)\\) から \\(O(n!)\\) へ削減されることがわかります。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   コード実装","text":"<p>以上を整理できれば、フレームワークコードの「穴埋め」を行えます。全体のコードを短くするため、フレームワークコード中の各関数を個別には実装せず、これらを <code>backtrack()</code> 関数内に展開します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"バックトラッキング：順列 I\"\"\"\n    # 状態の長さが要素数に等しければ、解を記録\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    for i, choice in enumerate(choices):\n        # 枝刈り：要素の重複選択を許可しない\n        if not selected[i]:\n            # 試行: 選択を行い、状態を更新\n            selected[i] = True\n            state.append(choice)\n            # 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全順列 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push_back(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全順列 I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.add(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全順列 I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* バックトラッキング：順列 I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.Add(choice);\n            // 次の選択へ進む\n            Backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全順列 I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* バックトラッキング：順列 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // すべての選択肢を走査\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 枝刈り：要素の重複選択を許可しない\n        if !(*selected)[i] {\n            // 試行: 選択を行い、状態を更新\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 次の選択へ進む\n            backtrackI(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全順列 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* バックトラッキング：順列 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    for (i, choice) in choices.enumerated() {\n        // 枝刈り：要素の重複選択を許可しない\n        if !selected[i] {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true\n            state.append(choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全順列 I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* バックトラッキング：順列 I */\nfunction backtrack(state, choices, selected, res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* バックトラッキング：順列 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 状態の長さが要素数に等しければ、解を記録\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 枝刈り：要素の重複選択を許可しない\n    if (!selected[i]) {\n      // 試行: 選択を行い、状態を更新\n      selected[i] = true;\n      state.add(choice);\n      // 次の選択へ進む\n      backtrack(state, choices, selected, res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全順列 I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* バックトラッキング：順列 I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if !selected[i] {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state.clone(), choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全順列 I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // 状態（部分集合）\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* バックトラッキング：順列 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 次の選択へ進む\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全順列 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* バックトラッキング：順列 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 枝刈り：要素の重複選択を許可しない\n        if (!selected[i]) {\n            // 試行: 選択を行い、状態を更新\n            selected[i] = true\n            state.add(choice)\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全順列 I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### バックトラッキング法：全順列 I ###\ndef backtrack(state, choices, selected, res)\n  # 状態の長さが要素数に等しければ、解を記録\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  choices.each_with_index do |choice, i|\n    # 枝刈り：要素の重複選択を許可しない\n    unless selected[i]\n      # 試行: 選択を行い、状態を更新\n      selected[i] = true\n      state &lt;&lt; choice\n      # 次の選択へ進む\n      backtrack(state, choices, selected, res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全順列 I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   等しい要素を考慮する場合","text":"<p>Question</p> <p>整数配列を入力として受け取り、配列には重複要素が含まれる場合があります。重複しない順列をすべて返します。</p> <p>入力配列が \\([1, 1, 2]\\) だと仮定します。2 つの重複する要素 \\(1\\) を区別しやすくするため、2 つ目の \\(1\\) を \\(\\hat{1}\\) と記します。</p> <p>下図のように、上述の方法で生成される順列の半分は重複しています。</p> <p></p> <p> 図 13-7   重複した順列 </p> <p>では、重複した順列をどのように取り除けばよいのでしょうか。最も直接的なのは、ハッシュ集合を用いて順列結果をそのまま重複排除する方法です。しかしこのやり方は十分に洗練されていません。なぜなら、重複順列を生成する探索分岐はそもそも不要であり、事前に見つけて枝刈りすべきだからです。そうすることで、アルゴリズム効率をさらに高められます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   等しい要素の枝刈り","text":"<p>下図を見ると、1 回目のラウンドでは \\(1\\) を選ぶことと \\(\\hat{1}\\) を選ぶことは等価であり、これら 2 つの選択の下で生成される順列はすべて重複します。したがって \\(\\hat{1}\\) を枝刈りすべきです。</p> <p>同様に、1 回目で \\(2\\) を選んだ後では、2 回目のラウンドにおける \\(1\\) と \\(\\hat{1}\\) も重複分岐を生むため、2 回目の \\(\\hat{1}\\) も枝刈りすべきです。</p> <p>本質的には、各ラウンドの選択において、等しい複数の要素が 1 回しか選ばれないようにすることが目標です。</p> <p></p> <p> 図 13-8   重複順列の枝刈り </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   コード実装","text":"<p>前問のコードを土台として、各ラウンドの選択でハッシュ集合 <code>duplicated</code> を 1 つ用意し、そのラウンドですでに試した要素を記録して、重複要素を枝刈りすることを考えます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"バックトラッキング：順列 II\"\"\"\n    # 状態の長さが要素数に等しければ、解を記録\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if not selected[i] and choice not in duplicated:\n            # 試行: 選択を行い、状態を更新\n            duplicated.add(choice)  # 選択済みの要素値を記録\n            selected[i] = True\n            state.append(choice)\n            # 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            # バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全順列 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.emplace(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push_back(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全順列 II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.add(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全順列 II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* バックトラッキング：順列 II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.Add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.Add(choice);\n            // 次の選択へ進む\n            Backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全順列 II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* バックトラッキング：順列 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // すべての選択肢を走査\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // 試す: 選択を行って状態を更新\n            // 選択済みの要素値を記録\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 次の選択へ進む\n            backtrackII(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全順列 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* バックトラッキング：順列 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if !selected[i], !duplicated.contains(choice) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.insert(choice) // 選択済みの要素値を記録\n            selected[i] = true\n            state.append(choice)\n            // 次の選択へ進む\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全順列 II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* バックトラッキング：順列 II */\nfunction backtrack(state, choices, selected, res) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* バックトラッキング：順列 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全順列 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 状態の長さが要素数に等しければ、解を記録\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // 試行: 選択を行い、状態を更新\n      duplicated.add(choice); // 選択済みの要素値を記録\n      selected[i] = true;\n      state.add(choice);\n      // 次の選択へ進む\n      backtrack(state, choices, selected, res);\n      // バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全順列 II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* バックトラッキング：順列 II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // すべての選択肢を走査\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.insert(choice); // 選択済みの要素値を記録\n            selected[i] = true;\n            state.push(choice);\n            // 次の選択へ進む\n            backtrack(state.clone(), choices, selected, res);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全順列 II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* バックトラッキング：順列 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // すべての選択肢を走査\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // 試行: 選択を行い、状態を更新\n            duplicated[choice] = true; // 選択済みの要素値を記録\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 次の選択へ進む\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全順列 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* バックトラッキング：順列 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 状態の長さが要素数に等しければ、解を記録\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 試行: 選択を行い、状態を更新\n            duplicated.add(choice) // 選択済みの要素値を記録\n            selected[i] = true\n            state.add(choice)\n            // 次の選択へ進む\n            backtrack(state, choices, selected, res)\n            // バックトラック：選択を取り消し、前の状態に戻す\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全順列 II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### バックトラッキング法：全順列 II ###\ndef backtrack(state, choices, selected, res)\n  # 状態の長さが要素数に等しければ、解を記録\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # 試行: 選択を行い、状態を更新\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # 次の選択へ進む\n      backtrack(state, choices, selected, res)\n      # バックトラック：選択を取り消し、前の状態に戻す\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全順列 II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>要素どうしがすべて互いに異なると仮定すると、\\(n\\) 個の要素には全部で \\(n!\\)  通りの順列（階乗）があります。結果を記録する際には、長さ \\(n\\) のリストをコピーする必要があり、これに \\(O(n)\\) 時間を要します。したがって時間計算量は \\(O(n!n)\\) です。</p> <p>再帰の最大深さは \\(n\\) であり、\\(O(n)\\) のスタックフレーム空間を使います。<code>selected</code> は \\(O(n)\\) 空間を使用します。同時刻に存在する <code>duplicated</code> は最大で \\(n\\) 個であり、\\(O(n^2)\\) 空間を要します。したがって空間計算量は \\(O(n^2)\\) です。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3-2","level":3,"title":"3.   2 種類の枝刈りの比較","text":"<p><code>selected</code> と <code>duplicated</code> はどちらも枝刈りに用いられますが、目的は異なる点に注意してください。</p> <ul> <li>重複選択の枝刈り：探索全体を通して <code>selected</code> は 1 つだけです。これは現在の状態にどの要素が含まれているかを記録し、ある要素が <code>state</code> に重複して現れるのを防ぎます。</li> <li>等しい要素の枝刈り：各ラウンドの選択、すなわち各回の <code>backtrack</code> 呼び出しには <code>duplicated</code> が含まれます。これはそのラウンドの走査（<code>for</code> ループ）でどの要素がすでに選ばれたかを記録し、等しい要素が 1 回しか選ばれないことを保証します。</li> </ul> <p>下図は、2 つの枝刈り条件が有効になる範囲を示しています。木の各ノードは 1 つの選択を表し、根ノードから葉ノードまでの経路上の各ノードが 1 つの順列を構成することに注意してください。</p> <p></p> <p> 図 13-9   2 種類の枝刈り条件の作用範囲 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.2 &nbsp; 全順列問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   部分和問題","text":"","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   重複しない要素の場合","text":"<p>Question</p> <p>正整数配列 <code>nums</code> と目標の正整数 <code>target</code> が与えられたとき、要素の和が <code>target</code> に等しくなるすべての組合せを見つけてください。配列に重複要素はなく、各要素は複数回選択できます。これらの組合せをリスト形式で返してください。リストに重複する組合せを含めてはなりません。</p> <p>例えば、入力集合 \\(\\{3, 4, 5\\}\\) と目標整数 \\(9\\) に対する解は \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) です。次の 2 点に注意してください。</p> <ul> <li>入力集合内の要素は何度でも繰り返し選択できます。</li> <li>部分集合では要素の順序を区別しません。例えば \\(\\{4, 5\\}\\) と \\(\\{5, 4\\}\\) は同じ部分集合です。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   全順列の解法を参考にする","text":"<p>全順列問題と同様に、部分集合の生成過程を一連の選択結果として捉え、選択の過程で「要素の和」を逐次更新できます。そして要素の和が <code>target</code> に等しくなった時点で、その部分集合を結果リストに記録します。</p> <p>ただし全順列問題と異なるのは、**この問題では集合内の要素を無制限に選択できる**点です。そのため、要素がすでに選択されたかどうかを記録する <code>selected</code> ブール配列は不要です。全順列のコードに少し修正を加えると、まず次の解法コードが得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"バックトラッキング：部分和 I\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if total == target:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    for i in range(len(choices)):\n        # 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target:\n            continue\n        # 試行：選択を行い、要素と total を更新する\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 I を解く（重複部分集合を含む）\"\"\"\n    state = []  # 状態（部分集合）\n    total = 0  # 部分和\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // 状態（部分集合）\n    int total = 0;           // 部分和\n    vector&lt;vector&lt;int&gt;&gt; res; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    int total = 0; // 部分和\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* バックトラッキング：部分和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    int total = 0; // 部分和\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    for i := 0; i &lt; len(*choices); i++ {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    total := 0              // 部分和\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if total == target {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    for i in choices.indices {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let total = 0 // 部分和\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(state, target, total, choices, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // 状態（部分集合）\n    const total = 0; // 部分和\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    const total = 0; // 部分和\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  for (int i = 0; i &lt; choices.length; i++) {\n    // 枝刈り：部分和が target を超える場合はその選択をスキップする\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // 試行：選択を行い、要素と total を更新する\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  int total = 0; // 要素の合計\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* バックトラッキング：部分和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    for i in 0..choices.len() {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    let total = 0; // 部分和\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state[stateSize++] = choices[i];\n        // 次の選択へ進む\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // 解の個数を 0 に初期化する\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* バックトラッキング：部分和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    for (i in choices.indices) {\n        // 枝刈り：部分和が target を超える場合はその選択をスキップする\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // 試行：選択を行い、要素と total を更新する\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target, total + choices[i], choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 I を解く（重複部分集合を含む） */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    val total = 0 // 部分和\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  for i in 0...choices.length\n    # 枝刈り：部分和が target を超える場合はその選択をスキップする\n    next if total + choices[i] &gt; target\n    # 試行：選択を行い、要素と total を更新する\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  for i in 0...choices.length\n    # 枝刈り：部分和が target を超える場合はその選択をスキップする\n    next if total + choices[i] &gt; target\n    # 試行：選択を行い、要素と total を更新する\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target, total + choices[i], choices, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n# ## 部分和 I を解く（重複する部分集合を含む）###\ndef subset_sum_i_naive(nums, target)\n  state = [] # 状態（部分集合）\n  total = 0 # 部分和\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードに配列 \\([3, 4, 5]\\) と目標値 \\(9\\) を入力すると、出力は \\([3, 3, 3], [4, 5], [5, 4]\\) となります。和が \\(9\\) となる部分集合はすべて見つかっていますが、重複する部分集合 \\([4, 5]\\) と \\([5, 4]\\) が含まれています。</p> <p>これは、探索過程では選択順を区別する一方で、部分集合では選択順を区別しないためです。次の図のように、先に \\(4\\) を選んでから \\(5\\) を選ぶ場合と、先に \\(5\\) を選んでから \\(4\\) を選ぶ場合は別の分岐ですが、対応する部分集合は同じです。</p> <p></p> <p> 図 13-10   部分集合探索と境界超過の枝刈り </p> <p>重複する部分集合を取り除くために、**直接的な方法として結果リストの重複を除去する**ことが考えられます。しかし、この方法は効率が低く、その理由は次の 2 点です。</p> <ul> <li>配列要素が多い場合、特に <code>target</code> が大きい場合には、探索過程で大量の重複部分集合が生成されます。</li> <li>部分集合（配列）同士の違いを比較するのは非常に時間がかかり、まず配列をソートし、その後に各要素を比較する必要があります。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   重複部分集合の枝刈り","text":"<p>**探索過程で枝刈りを行って重複を除去する**ことを考えます。次の図を観察すると、重複部分集合は配列要素を異なる順序で選択したときに生じます。例えば次のような状況です。</p> <ol> <li>1 回目と 2 回目でそれぞれ \\(3\\) と \\(4\\) を選ぶと、これら 2 要素を含むすべての部分集合、すなわち \\([3, 4, \\dots]\\) が生成されます。</li> <li>その後、1 回目で \\(4\\) を選んだ場合、**2 回目では \\(3\\) をスキップすべき**です。というのも、この選択で生成される部分集合 \\([4, 3, \\dots]\\) は、手順 <code>1.</code> で生成された部分集合と完全に重複するからです。</li> </ol> <p>探索過程では、各階層の選択は左から右へ順に試されるため、右側にある分岐ほど多く枝刈りされます。</p> <ol> <li>最初の 2 回で \\(3\\) と \\(5\\) を選ぶと、部分集合 \\([3, 5, \\dots]\\) が生成されます。</li> <li>最初の 2 回で \\(4\\) と \\(5\\) を選ぶと、部分集合 \\([4, 5, \\dots]\\) が生成されます。</li> <li>もし 1 回目で \\(5\\) を選ぶなら、**2 回目では \\(3\\) と \\(4\\) をスキップすべき**です。なぜなら、部分集合 \\([5, 3, \\dots]\\) と \\([5, 4, \\dots]\\) は、手順 <code>1.</code> と手順 <code>2.</code> で述べた部分集合と完全に重複するからです。</li> </ol> <p></p> <p> 図 13-11   異なる選択順によって生じる重複部分集合 </p> <p>まとめると、入力配列 \\([x_1, x_2, \\dots, x_n]\\) が与えられ、探索過程における選択列を \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) とすると、この選択列は \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) を満たす必要があります。この条件を満たさない選択列は重複を生むため、枝刈りすべきです。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   コード実装","text":"<p>この枝刈りを実現するために、走査の開始位置を示す変数 <code>start</code> を初期化します。**選択 \\(x_{i}\\) を行った後、次のラウンドはインデックス \\(i\\) から走査を開始する**ように設定します。これにより、選択列が \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) を満たし、部分集合の一意性が保証されます。</p> <p>これに加えて、コードには次の 2 つの最適化も施しています。</p> <ul> <li>探索を始める前に、まず配列 <code>nums</code> をソートします。すべての選択肢を走査するとき、**部分集合の和が <code>target</code> を超えたら直ちにループを終了**します。後続の要素はさらに大きいため、その和も必ず <code>target</code> を超えるからです。</li> <li>要素和を保持する変数 <code>total</code> は省略し、**<code>target</code> から減算することで要素和を管理**します。<code>target</code> が \\(0\\) になったときに解を記録します。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"バックトラッキング：部分和 I\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if target == 0:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in range(start, len(choices)):\n        # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0:\n            break\n        # 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 I を解く\"\"\"\n    state = []  # 状態（部分集合）\n    nums.sort()  # nums をソート\n    start = 0  # 開始点を走査\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 I を解く */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 状態（部分集合）\n    sort(nums.begin(), nums.end()); // nums をソート\n    int start = 0;                  // 開始点を走査\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    Arrays.sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* バックトラッキング：部分和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    Array.Sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i := start; i &lt; len(*choices); i++ {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 I を解く */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    sort.Ints(nums)         // nums をソート\n    start := 0              // 開始点を走査\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* バックトラッキング：部分和 I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in choices.indices.dropFirst(start) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 I を解く */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let nums = nums.sorted() // nums をソート\n    let start = 0 // 開始点を走査\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(state, target, choices, start, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfunction subsetSumI(nums, target) {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* バックトラッキング：部分和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  for (int i = start; i &lt; choices.length; i++) {\n    // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 試す：選択を行い、target と start を更新\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 I を解く */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  nums.sort(); // nums をソート\n  int start = 0; // 開始点を走査\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* バックトラッキング：部分和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for i in start..choices.len() {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 I を解く */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    nums.sort(); // nums をソート\n    let start = 0; // 開始点を走査\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* バックトラッキング：部分和 I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 試す：選択を行い、target と start を更新\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 次の選択へ進む\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 I を解く */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // nums をソート\n    int start = 0;                           // 開始点を走査\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* バックトラッキング：部分和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    for (i in start..&lt;choices.size) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 I を解く */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    nums.sort() // nums をソート\n    val start = 0 // 開始点を走査\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### バックトラッキング: 部分和 I ###\ndef backtrack(state, target, choices, start, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # すべての選択肢を走査\n  # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  for i in start...choices.length\n    # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    break if target - choices[i] &lt; 0\n    # 試す：選択を行い、target と start を更新\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### 部分和 I を解く ###\ndef subset_sum_i(nums, target)\n  state = [] # 状態（部分集合）\n  nums.sort! # nums をソート\n  start = 0 # 開始点を走査\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、配列 \\([3, 4, 5]\\) と目標値 \\(9\\) を上のコードに入力したときの、全体のバックトラッキング過程を示しています。</p> <p></p> <p> 図 13-12   部分和 I のバックトラッキング過程 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   重複要素を考慮する場合","text":"<p>Question</p> <p>正整数配列 <code>nums</code> と目標の正整数 <code>target</code> が与えられたとき、要素の和が <code>target</code> に等しくなるすべての組合せを見つけてください。与えられた配列には重複要素が含まれる可能性があり、各要素は 1 回しか選択できません。これらの組合せをリスト形式で返してください。リストに重複する組合せを含めてはなりません。</p> <p>前問と比べると、この問題の入力配列には重複要素が含まれる可能性があります。そのため、新たな問題が生じます。例えば、配列 \\([4, \\hat{4}, 5]\\) と目標値 \\(9\\) が与えられると、既存コードの出力は \\([4, 5], [\\hat{4}, 5]\\) となり、重複部分集合が現れます。</p> <p>この重複が生じる原因は、同じ値の要素があるラウンドで複数回選ばれてしまうことにあります。次の図では、1 回目には 3 つの選択肢があり、そのうち 2 つはどちらも \\(4\\) です。これにより 2 本の重複した探索分岐が生じ、重複部分集合が出力されます。同様に、2 回目の 2 つの \\(4\\) も重複部分集合を生みます。</p> <p></p> <p> 図 13-13   等しい要素によって生じる重複部分集合 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   等しい要素の枝刈り","text":"<p>この問題を解決するには、各ラウンドで等しい要素が 1 回しか選ばれないように制限する必要があります。実装方法は巧妙です。配列はすでにソートされているため、等しい要素は必ず隣り合っています。したがって、あるラウンドの選択で現在の要素が左隣の要素と等しいなら、それはすでに選ばれたことを意味するので、その要素を直接スキップします。</p> <p>同時に、**この問題では各配列要素を 1 回しか選択できない**という制約もあります。幸い、この制約も変数 <code>start</code> を使って満たせます。すなわち、選択 \\(x_{i}\\) を行った後、次のラウンドはインデックス \\(i + 1\\) から後ろへ走査するよう設定します。これにより、重複部分集合を除去できるだけでなく、同じ要素を繰り返し選ぶことも防げます。</p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   コード実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"バックトラッキング：部分和 II\"\"\"\n    # 部分集合の和が target に等しければ、解を記録\n    if target == 0:\n        res.append(list(state))\n        return\n    # すべての選択肢を走査\n    # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    # 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in range(start, len(choices)):\n        # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0:\n            break\n        # 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        # 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # バックトラック：選択を取り消し、前の状態に戻す\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"部分和 II を解く\"\"\"\n    state = []  # 状態（部分集合）\n    nums.sort()  # nums をソート\n    start = 0  # 開始点を走査\n    res = []  # 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push_back(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop_back();\n    }\n}\n\n/* 部分和 II を解く */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 状態（部分集合）\n    sort(nums.begin(), nums.end()); // nums をソート\n    int start = 0;                  // 開始点を走査\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 状態（部分集合）\n    Arrays.sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* バックトラッキング：部分和 II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.Add(choices[i]);\n        // 次の選択へ進む\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 状態（部分集合）\n    Array.Sort(nums); // nums をソート\n    int start = 0; // 開始点を走査\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* バックトラッキング：部分和 II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i := start; i &lt; len(*choices); i++ {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        *state = append(*state, (*choices)[i])\n        // 次の選択へ進む\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 部分和 II を解く */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // 状態（部分集合）\n    sort.Ints(nums)         // nums をソート\n    start := 0              // 開始点を走査\n    res := make([][]int, 0) // 結果リスト（部分集合のリスト）\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* バックトラッキング：部分和 II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in choices.indices.dropFirst(start) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        state.append(choices[i])\n        // 次の選択へ進む\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeLast()\n    }\n}\n\n/* 部分和 II を解く */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 状態（部分集合）\n    let nums = nums.sorted() // nums をソート\n    let start = 0 // 開始点を走査\n    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* バックトラッキング：部分和 II */\nfunction backtrack(state, target, choices, start, res) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfunction subsetSumII(nums, target) {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* バックトラッキング：部分和 II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (let i = start; i &lt; choices.length; i++) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // 状態（部分集合）\n    nums.sort((a, b) =&gt; a - b); // nums をソート\n    const start = 0; // 開始点を走査\n    const res = []; // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 部分集合の和が target に等しければ、解を記録\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // すべての選択肢を走査\n  // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n  for (int i = start; i &lt; choices.length; i++) {\n    // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // 試す：選択を行い、target と start を更新\n    state.add(choices[i]);\n    // 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // バックトラック：選択を取り消し、前の状態に戻す\n    state.removeLast();\n  }\n}\n\n/* 部分和 II を解く */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 状態（部分集合）\n  nums.sort(); // nums をソート\n  int start = 0; // 開始点を走査\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* バックトラッキング：部分和 II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for i in start..choices.len() {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state.push(choices[i]);\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.pop();\n    }\n}\n\n/* 部分和 II を解く */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 状態（部分集合）\n    nums.sort(); // nums をソート\n    let start = 0; // 開始点を走査\n    let mut res = Vec::new(); // 結果リスト（部分集合のリスト）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* バックトラッキング：部分和 II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 枝刈り 1: 部分集合の和が target を超えたら、そのままスキップする\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 試す：選択を行い、target と start を更新\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 次の選択へ進む\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // バックトラック：選択を取り消し、前の状態に戻す\n        stateSize--;\n    }\n}\n\n/* 部分和 II を解く */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // nums をソート\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // バックトラッキングを開始\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* バックトラッキング：部分和 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 部分集合の和が target に等しければ、解を記録\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // すべての選択肢を走査\n    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n    for (i in start..&lt;choices.size) {\n        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // 試す：選択を行い、target と start を更新\n        state.add(choices[i])\n        // 次の選択へ進む\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // バックトラック：選択を取り消し、前の状態に戻す\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 部分和 II を解く */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 状態（部分集合）\n    nums.sort() // nums をソート\n    val start = 0 // 開始点を走査\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果リスト（部分集合のリスト）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### バックトラッキング法：部分和 II ###\ndef backtrack(state, target, choices, start, res)\n  # 部分集合の和が target に等しければ、解を記録\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # すべての選択肢を走査\n  # 枝刈り 2: start から走査し、重複する部分集合の生成を避ける\n  # 枝刈り 3: start から走査し、同じ要素の重複選択を避ける\n  for i in start...choices.length\n    # 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する\n    # 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため\n    break if target - choices[i] &lt; 0\n    # 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # 試す：選択を行い、target と start を更新\n    state &lt;&lt; choices[i]\n    # 次の選択へ進む\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # バックトラック：選択を取り消し、前の状態に戻す\n    state.pop\n  end\nend\n\n### 部分和 II を解く ###\ndef subset_sum_ii(nums, target)\n  state = [] # 状態（部分集合）\n  nums.sort! # nums をソート\n  start = 0 # 開始点を走査\n  res = [] # 結果リスト（部分集合のリスト）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、配列 \\([4, 4, 5]\\) と目標値 \\(9\\) に対するバックトラッキング過程を示しており、全部で 4 種類の枝刈り操作が含まれています。図とコードコメントを対応させながら、探索全体の流れと、各枝刈り操作がどのように機能するかを理解してください。</p> <p></p> <p> 図 13-14   部分和 II のバックトラッキング過程 </p>","path":["第 13 章 &nbsp; バックトラッキング","13.3 &nbsp; 部分和問題"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   まとめ","text":"","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>バックトラッキングアルゴリズムの本質は全探索法であり、解空間を深さ優先で走査することで条件を満たす解を探索します。探索の過程で条件を満たす解に出会ったら記録し、すべての解を見つけるか探索が完了するまで続けます。</li> <li>バックトラッキングアルゴリズムの探索過程は、試行と戻るという 2 つの部分から成ります。深さ優先探索によってさまざまな選択を試し、制約条件を満たさない状況に遭遇した場合は直前の選択を取り消して前の状態に戻り、ほかの選択を引き続き試します。試行と戻るは互いに逆方向の操作です。</li> <li>バックトラッキング問題には通常複数の制約条件が含まれており、それらを枝刈りに利用できます。枝刈りによって不要な探索分岐を早期に打ち切り、探索効率を大幅に高められます。</li> <li>バックトラッキングアルゴリズムは主に探索問題と制約充足問題の解決に用いられます。組合せ最適化問題もバックトラッキングで解けますが、より高効率またはより適した解法が存在することが少なくありません。</li> <li>全順列問題の目的は、与えられた集合要素のすべての可能な並べ方を探索することです。各要素が選択済みかどうかを配列で記録し、同じ要素を重複して選ぶ探索分岐を刈り取ることで、各要素が 1 度だけ選ばれるようにします。</li> <li>全順列問題では、集合内に重複要素があると最終結果にも重複した順列が現れます。各ラウンドで等しい要素は 1 回しか選べないように制約する必要があり、通常はハッシュ集合を用いて実現します。</li> <li>部分和問題の目標は、与えられた集合の中から和が目標値となるすべての部分集合を見つけることです。集合では要素順序を区別しませんが、探索過程では順序違いの結果も出力されるため、重複部分集合が生じます。そこで、バックトラッキング前にデータをソートし、各ラウンドの走査開始位置を示す変数を設定することで、重複部分集合を生成する探索分岐を枝刈りします。</li> <li>部分和問題では、配列中の等しい要素が重複集合を生みます。配列がソート済みであるという前提を利用し、隣接要素が等しいかどうかを判定して枝刈りすることで、等しい要素が各ラウンドで 1 回しか選ばれないようにします。</li> <li>\\(n\\) クイーン問題の目的は、\\(n \\times n\\) の盤面に \\(n\\) 個のクイーンを配置する方法を見つけることであり、どの 2 つのクイーンも互いに攻撃できないことが条件です。この問題の制約には行制約、列制約、主対角線制約、副対角線制約があります。行制約を満たすため、行ごとに配置する戦略を採用し、各行に 1 個のクイーンを置くことを保証します。</li> <li>列制約と対角線制約の扱い方は似ています。列制約については、各列にクイーンが存在するかどうかを配列で記録し、選択したマスが有効かどうかを判定します。対角線制約については、主対角線と副対角線それぞれにクイーンが存在するかを 2 つの配列で記録します。難点は、同じ主対角線または副対角線上にあるマスが満たす行列インデックスの規則を見つけることにあります。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：バックトラッキングと再帰の関係はどのように理解すればよいですか？</p> <p>全体として見ると、バックトラッキングは「アルゴリズム戦略」の一種であり、再帰はむしろ「道具」に近いものです。</p> <ul> <li>バックトラッキングアルゴリズムは通常、再帰に基づいて実装されます。ただし、バックトラッキングは再帰の応用場面の 1 つであり、探索問題における再帰の応用です。</li> <li>再帰の構造は「部分問題への分解」という問題解決パラダイムを表しており、分割統治、バックトラッキング、動的計画法（メモ化再帰）などの問題によく用いられます。</li> </ul>","path":["第 13 章 &nbsp; バックトラッキング","13.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"第 2 章   計算量解析","text":"<p>Abstract</p> <p>計算量解析は、広大なアルゴリズム宇宙における時空の案内人のようなものです。</p> <p>それは、時間と空間という二つの次元で私たちをより深く探求へ導き、より洗練された解決策を見つけ出します。</p>","path":["第 2 章 &nbsp; 計算量解析"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"章の内容","text":"<ul> <li>2.1   アルゴリズム効率の評価</li> <li>2.2   反復と再帰</li> <li>2.3   時間計算量</li> <li>2.4   空間計算量</li> <li>2.5   まとめ</li> </ul>","path":["第 2 章 &nbsp; 計算量解析"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   反復と再帰","text":"<p>アルゴリズムでは、ある処理を繰り返し実行することがよくあり、これは複雑度解析と密接に関係しています。そのため、時間計算量と空間計算量を紹介する前に、まずプログラム内で反復実行を実現する方法、つまり 2 つの基本的な制御構造である反復と再帰について見ていきます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   反復","text":"<p>反復（iteration）は、ある処理を繰り返し実行するための制御構造です。反復では、プログラムは一定の条件を満たす間、あるコード片を繰り返し実行し、その条件を満たさなくなるまで続けます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   for ループ","text":"<p><code>for</code> ループは最も一般的な反復形式の 1 つで、反復回数があらかじめ分かっている場合に適しています。</p> <p>次の関数は <code>for</code> ループを用いて \\(1 + 2 + \\dots + n\\) の総和を計算しており、その結果は変数 <code>res</code> に記録されます。なお、Python の <code>range(a, b)</code> に対応する区間は「左閉右開」であり、走査範囲は \\(a, a + 1, \\dots, b-1\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for ループ\"\"\"\n    res = 0\n    # 1, 2, ..., n-1, n を順に加算する\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for ループ */\nint ForLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for ループ */\nfunc forLoop(n int) int {\n    res := 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for ループ */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for ループ */\nfunction forLoop(n) {\n    let res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for ループ */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for ループ */\nint forLoop(int n) {\n  int res = 0;\n  // 1, 2, ..., n-1, n を順に加算する\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for ループ */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for ループ */\nint forLoop(int n) {\n    int res = 0;\n    // 1, 2, ..., n-1, n を順に加算する\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for ループ */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // 1, 2, ..., n-1, n を順に加算する\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for ループ ###\ndef for_loop(n)\n  res = 0\n\n  # 1, 2, ..., n-1, n を順に加算する\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、この総和関数のフローチャートです。</p> <p></p> <p> 図 2-1   総和関数のフローチャート </p> <p>この総和関数の操作回数は入力データサイズ \\(n\\) に比例し、言い換えれば「線形関係」にあります。実際、時間計算量が記述するのはこの「線形関係」そのものです。関連内容は次節で詳しく説明します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   while ループ","text":"<p><code>for</code> ループと同様に、<code>while</code> ループも反復を実現する方法の 1 つです。<code>while</code> ループでは、各反復のたびにまず条件を確認し、条件が真であれば実行を続け、そうでなければループを終了します。</p> <p>次に、<code>while</code> ループを使って \\(1 + 2 + \\dots + n\\) の総和を求めてみましょう。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while ループ\"\"\"\n    res = 0\n    i = 1  # 条件変数を初期化する\n    # 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n:\n        res += i\n        i += 1  # 条件変数を更新する\n    return res\n</code></pre> iteration.cpp<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while ループ */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while ループ */\nfunc whileLoop(n int) int {\n    res := 0\n    // 条件変数を初期化する\n    i := 1\n    // 1, 2, ..., n-1, n を順に加算する\n    for i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while ループ */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n {\n        res += i\n        i += 1 // 条件変数を更新する\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while ループ */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while ループ */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while ループ */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // 条件変数を初期化する\n  // 1, 2, ..., n-1, n を順に加算する\n  while (i &lt;= n) {\n    res += i;\n    i++; // 条件変数を更新する\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while ループ */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 条件変数を初期化する\n\n    // 1, 2, ..., n-1, n を順に加算する\n    while i &lt;= n {\n        res += i;\n        i += 1; // 条件変数を更新する\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while ループ */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        i++; // 条件変数を更新する\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while ループ */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 2, ..., n-1, n を順に加算する\n    while (i &lt;= n) {\n        res += i\n        i++ // 条件変数を更新する\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while ループ ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 2, ..., n-1, n を順に加算する\n  while i &lt;= n\n    res += i\n    i += 1 # 条件変数を更新する\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>**<code>while</code> ループは <code>for</code> ループより自由度が高い**です。<code>while</code> ループでは、条件変数の初期化や更新手順を柔軟に設計できます。</p> <p>たとえば次のコードでは、条件変数 \\(i\\) が各反復で 2 回更新されており、このようなケースは <code>for</code> ループではあまり扱いやすくありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while ループ（2回更新）\"\"\"\n    res = 0\n    i = 1  # 条件変数を初期化する\n    # 1, 4, 10, ... を順に加算する\n    while i &lt;= n:\n        res += i\n        # 条件変数を更新する\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while ループ（2回更新） */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while ループ（2回更新） */\nfunc whileLoopII(n int) int {\n    res := 0\n    // 条件変数を初期化する\n    i := 1\n    // 1, 4, 10, ... を順に加算する\n    for i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while ループ（2回更新） */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while i &lt;= n {\n        res += i\n        // 条件変数を更新する\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while ループ（2回更新） */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while ループ（2回更新） */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // 条件変数を初期化する\n  // 1, 4, 10, ... を順に加算する\n  while (i &lt;= n) {\n    res += i;\n    // 条件変数を更新する\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while ループ（2回更新） */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 条件変数を初期化する\n\n    // 1, 4, 10, ... を順に加算する\n    while i &lt;= n {\n        res += i;\n        // 条件変数を更新する\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while ループ（2回更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i;\n        // 条件変数を更新する\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while ループ（2回更新） */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // 条件変数を初期化する\n    // 1, 4, 10, ... を順に加算する\n    while (i &lt;= n) {\n        res += i\n        // 条件変数を更新する\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while ループ ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 2, ..., n-1, n を順に加算する\n  while i &lt;= n\n    res += i\n    i += 1 # 条件変数を更新する\n  end\n\n  res\nend\n\n# ## while ループ（2 回更新）###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # 条件変数を初期化する\n\n  # 1, 4, 10, ... を順に加算する\n  while i &lt;= n\n    res += i\n    # 条件変数を更新する\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>総じて、**<code>for</code> ループのコードはより簡潔で、<code>while</code> ループはより柔軟**です。どちらも反復構造を実現できますが、どちらを使うかは問題ごとの要件に応じて決めるべきです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   ネストしたループ","text":"<p>1 つのループ構造の中に別のループ構造を入れ子にできます。以下では <code>for</code> ループを例にします。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"二重 for ループ\"\"\"\n    res = \"\"\n    # i = 1, 2, ..., n-1, n とループする\n    for i in range(1, n + 1):\n        # j = 1, 2, ..., n-1, n とループする\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* 二重 for ループ */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; ++i) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* 二重 for ループ */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* 二重 for ループ */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* 二重 for ループ */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // i = 1, 2, ..., n-1, n とループする\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // j = 1, 2, ..., n-1, n とループする\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* 二重 for ループ */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // i = 1, 2, ..., n-1, n とループする\n    for i in 1 ... n {\n        // j = 1, 2, ..., n-1, n とループする\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* 二重 for ループ */\nfunction nestedForLoop(n) {\n    let res = '';\n    // i = 1, 2, ..., n-1, n とループする\n    for (let i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* 二重 for ループ */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // i = 1, 2, ..., n-1, n とループする\n    for (let i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* 二重 for ループ */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // i = 1, 2, ..., n-1, n とループする\n  for (int i = 1; i &lt;= n; i++) {\n    // j = 1, 2, ..., n-1, n とループする\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* 二重 for ループ */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // i = 1, 2, ..., n-1, n とループする\n    for i in 1..=n {\n        // j = 1, 2, ..., n-1, n とループする\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* 二重 for ループ */\nchar *nestedForLoop(int n) {\n    // n * n は対応する点の個数であり、\"(i, j), \" に対応する文字列長の最大は 6+10*2 で、さらに末尾の空文字 \\0 のための追加領域が必要\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // i = 1, 2, ..., n-1, n とループする\n    for (int i = 1; i &lt;= n; i++) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* 二重 for ループ */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // i = 1, 2, ..., n-1, n とループする\n    for (i in 1..n) {\n        // j = 1, 2, ..., n-1, n とループする\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### 二重 for ループ ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # i = 1, 2, ..., n-1, n とループする\n  for i in 1..n\n    # j = 1, 2, ..., n-1, n とループする\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、このネストしたループのフローチャートです。</p> <p></p> <p> 図 2-2   ネストしたループのフローチャート </p> <p>この場合、関数の操作回数は \\(n^2\\) に比例し、言い換えればアルゴリズムの実行時間は入力データサイズ \\(n\\) と「二次関係」にあります。</p> <p>さらにネストしたループを追加することもできます。ネストが 1 段増えるたびに「次元が 1 つ上がる」ことになり、時間計算量は「三次関係」「四次関係」へと高くなっていきます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   再帰","text":"<p>再帰（recursion）は、関数が自分自身を呼び出すことで問題を解決するアルゴリズム戦略です。主に 2 つの段階から成ります。</p> <ol> <li>再帰呼び出し：プログラムは自分自身をより深く呼び出し続け、通常はより小さい、またはより単純化された引数を渡し、「終了条件」に達するまで進みます。</li> <li>復帰： 「終了条件」が満たされると、プログラムは最も深い再帰関数から 1 層ずつ戻り、各層の結果をまとめていきます。</li> </ol> <p>実装の観点から見ると、再帰コードは主に 3 つの要素から成ります。</p> <ol> <li>終了条件：いつ再帰呼び出しから復帰へ切り替わるかを決めます。</li> <li>再帰呼び出し：再帰呼び出しに対応し、関数が自分自身を呼び出します。通常はより小さい、またはより単純化された引数を入力します。</li> <li>結果の返却：復帰に対応し、現在の再帰レベルの結果を 1 つ上の層へ返します。</li> </ol> <p>次のコードを見ると、関数 <code>recur(n)</code> を呼び出すだけで \\(1 + 2 + \\dots + n\\) を計算できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"再帰\"\"\"\n    # 終了条件\n    if n == 1:\n        return 1\n    # 再帰：再帰呼び出し\n    res = recur(n - 1)\n    # 帰りがけ：結果を返す\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* 再帰 */\nint Recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = Recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* 再帰 */\nfunc recur(n int) int {\n    // 終了条件\n    if n == 1 {\n        return 1\n    }\n    // 再帰：再帰呼び出し\n    res := recur(n - 1)\n    // 帰りがけ：結果を返す\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* 再帰 */\nfunc recur(n: Int) -&gt; Int {\n    // 終了条件\n    if n == 1 {\n        return 1\n    }\n    // 再帰：再帰呼び出し\n    let res = recur(n: n - 1)\n    // 帰りがけ：結果を返す\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* 再帰 */\nfunction recur(n) {\n    // 終了条件\n    if (n === 1) return 1;\n    // 再帰：再帰呼び出し\n    const res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* 再帰 */\nfunction recur(n: number): number {\n    // 終了条件\n    if (n === 1) return 1;\n    // 再帰：再帰呼び出し\n    const res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* 再帰 */\nint recur(int n) {\n  // 終了条件\n  if (n == 1) return 1;\n  // 再帰：再帰呼び出し\n  int res = recur(n - 1);\n  // 帰りがけ：結果を返す\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* 再帰 */\nfn recur(n: i32) -&gt; i32 {\n    // 終了条件\n    if n == 1 {\n        return 1;\n    }\n    // 再帰：再帰呼び出し\n    let res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* 再帰 */\nint recur(int n) {\n    // 終了条件\n    if (n == 1)\n        return 1;\n    // 再帰：再帰呼び出し\n    int res = recur(n - 1);\n    // 帰りがけ：結果を返す\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* 再帰 */\nfun recur(n: Int): Int {\n    // 終了条件\n    if (n == 1)\n        return 1\n    // 再帰: 再帰呼び出し\n    val res = recur(n - 1)\n    // 戻る: 結果を返す\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### 再帰 ###\ndef recur(n)\n  # 終了条件\n  return 1 if n == 1\n  # 再帰：再帰呼び出し\n  res = recur(n - 1)\n  # 帰りがけ：結果を返す\n  n + res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、この関数の再帰過程を示しています。</p> <p></p> <p> 図 2-3   総和関数の再帰過程 </p> <p>計算の観点では、反復と再帰は同じ結果を得られますが、それらは問題を考え解決するためのまったく異なる 2 つのパラダイムを表しています。</p> <ul> <li>反復：「ボトムアップ」で問題を解決します。最も基本的な手順から始め、それらを繰り返したり積み上げたりして、処理が完了するまで進めます。</li> <li>再帰：「トップダウン」で問題を解決します。元の問題をより小さな部分問題に分解し、それらの部分問題は元の問題と同じ形を持ちます。さらに部分問題をより小さな部分問題へと分解し、基本ケースに達したところで停止します（基本ケースの解は既知です）。</li> </ul> <p>前述の総和関数を例に、問題を \\(f(n) = 1 + 2 + \\dots + n\\) とします。</p> <ul> <li>反復：ループ内で総和の過程を模擬し、\\(1\\) から \\(n\\) まで走査して、各反復で加算を行えば \\(f(n)\\) を求められます。</li> <li>再帰：問題を部分問題 \\(f(n) = n + f(n-1)\\) に分解し、これを再帰的に分解し続け、基本ケース \\(f(1) = 1\\) に達したところで終了します。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   呼び出しスタック","text":"<p>再帰関数が自分自身を呼び出すたびに、システムは新たに開始された関数のためにメモリを割り当て、局所変数、呼び出し先アドレス、その他の情報を保存します。これにより 2 つの結果が生じます。</p> <ul> <li>関数のコンテキストデータは「スタックフレーム領域」と呼ばれるメモリ領域に保存され、関数が戻るまで解放されません。したがって、再帰は通常、反復より多くのメモリ空間を消費します。</li> <li>再帰による関数呼び出しには追加のオーバーヘッドが発生します。そのため再帰は通常、ループより時間効率が低くなります。</li> </ul> <p>次の図のように、終了条件が発動する前には、まだ戻っていない再帰関数が同時に \\(n\\) 個存在し、再帰の深さは \\(n\\) になります。</p> <p></p> <p> 図 2-4   再帰呼び出しの深さ </p> <p>実際には、プログラミング言語が許容する再帰の深さには通常上限があり、深すぎる再帰はスタックオーバーフローを引き起こす可能性があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   末尾再帰","text":"<p>興味深いことに、関数が返る直前の最後の処理で再帰呼び出しを行う場合、その関数はコンパイラやインタプリタによって最適化され、空間効率が反復と同程度になることがあります。これを末尾再帰（tail recursion）と呼びます。</p> <ul> <li>通常の再帰：関数が 1 つ上の階層の関数へ戻った後も、引き続きコードを実行する必要があるため、システムは 1 つ上の呼び出しのコンテキストを保存しておく必要があります。</li> <li>末尾再帰：再帰呼び出しが関数の返却前の最後の操作であるため、1 つ上の階層へ戻った後に他の処理を続ける必要がなく、システムは 1 つ上の関数のコンテキストを保存する必要がありません。</li> </ul> <p>\\(1 + 2 + \\dots + n\\) の計算を例にすると、結果変数 <code>res</code> を関数の引数にすることで、末尾再帰を実現できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"末尾再帰\"\"\"\n    # 終了条件\n    if n == 0:\n        return res\n    # 末尾再帰呼び出し\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* 末尾再帰 */\nint TailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* 末尾再帰 */\nfunc tailRecur(n int, res int) int {\n    // 終了条件\n    if n == 0 {\n        return res\n    }\n    // 末尾再帰呼び出し\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* 末尾再帰 */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // 終了条件\n    if n == 0 {\n        return res\n    }\n    // 末尾再帰呼び出し\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* 末尾再帰 */\nfunction tailRecur(n, res) {\n    // 終了条件\n    if (n === 0) return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* 末尾再帰 */\nfunction tailRecur(n: number, res: number): number {\n    // 終了条件\n    if (n === 0) return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n  // 終了条件\n  if (n == 0) return res;\n  // 末尾再帰呼び出し\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* 末尾再帰 */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // 終了条件\n    if n == 0 {\n        return res;\n    }\n    // 末尾再帰呼び出し\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* 末尾再帰 */\nint tailRecur(int n, int res) {\n    // 終了条件\n    if (n == 0)\n        return res;\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* 末尾再帰 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // `tailrec` キーワードを追加して末尾再帰最適化を有効にする\n    // 終了条件\n    if (n == 0)\n        return res\n    // 末尾再帰呼び出し\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### 末尾再帰 ###\ndef tail_recur(n, res)\n  # 終了条件\n  return res if n == 0\n  # 末尾再帰呼び出し\n  tail_recur(n - 1, res + n)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>末尾再帰の実行過程を次の図に示します。通常の再帰と末尾再帰を比べると、加算処理が実行されるタイミングが異なります。</p> <ul> <li>通常の再帰：加算処理は復帰の過程で実行され、各層が戻るたびにもう一度加算を行います。</li> <li>末尾再帰：加算処理は再帰呼び出しの過程で実行され、復帰の過程では各層が戻るだけで済みます。</li> </ul> <p></p> <p> 図 2-5   末尾再帰の過程 </p> <p>Tip</p> <p>多くのコンパイラやインタプリタは末尾再帰最適化をサポートしていない点に注意してください。たとえば、Python はデフォルトで末尾再帰最適化をサポートしていないため、関数が末尾再帰の形であっても、スタックオーバーフローが発生する可能性があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   再帰木","text":"<p>「分割統治」に関連するアルゴリズム問題を扱う際、再帰は反復よりも発想が直感的で、コードも読みやすいことがよくあります。「フィボナッチ数列」を例に見てみましょう。</p> <p>Question</p> <p>フィボナッチ数列 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) が与えられたとき、この数列の第 \\(n\\) 項を求めてください。</p> <p>フィボナッチ数列の第 \\(n\\) 項を \\(f(n)\\) とすると、次の 2 つが容易に分かります。</p> <ul> <li>数列の最初の 2 項は \\(f(1) = 0\\) と \\(f(2) = 1\\) です。</li> <li>数列中の各項は直前の 2 項の和であり、すなわち \\(f(n) = f(n - 1) + f(n - 2)\\) です。</li> </ul> <p>漸化式に従って再帰呼び出しを行い、最初の 2 項を終了条件とすれば、再帰コードを書けます。<code>fib(n)</code> を呼び出すことでフィボナッチ数列の第 \\(n\\) 項を得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"フィボナッチ数列：再帰\"\"\"\n    # 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    res = fib(n - 1) + fib(n - 2)\n    # 結果 f(n) を返す\n    return res\n</code></pre> recursion.cpp<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* フィボナッチ数列：再帰 */\nint Fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = Fib(n - 1) + Fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* フィボナッチ数列：再帰 */\nfunc fib(n int) int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    res := fib(n-1) + fib(n-2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* フィボナッチ数列：再帰 */\nfunc fib(n: Int) -&gt; Int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.js<pre><code>/* フィボナッチ数列：再帰 */\nfunction fib(n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    const res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* フィボナッチ数列：再帰 */\nfunction fib(n: number): number {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    const res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n  // 終了条件 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n  int res = fib(n - 1) + fib(n - 2);\n  // 結果 f(n) を返す\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* フィボナッチ数列：再帰 */\nfn fib(n: i32) -&gt; i32 {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    let res = fib(n - 1) + fib(n - 2);\n    // 結果を返す\n    res\n}\n</code></pre> recursion.c<pre><code>/* フィボナッチ数列：再帰 */\nint fib(int n) {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    int res = fib(n - 1) + fib(n - 2);\n    // 結果 f(n) を返す\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* フィボナッチ数列：再帰 */\nfun fib(n: Int): Int {\n    // 終了条件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n    val res = fib(n - 1) + fib(n - 2)\n    // 結果 f(n) を返す\n    return res\n}\n</code></pre> recursion.rb<pre><code>### フィボナッチ数列：再帰 ###\ndef fib(n)\n  # 終了条件 f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # f(n) = f(n-1) + f(n-2) を再帰的に呼び出す\n  res = fib(n - 1) + fib(n - 2)\n  # 結果 f(n) を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、関数内で 2 回の再帰呼び出しを行っています。これは 1 回の呼び出しから 2 つの呼び出し分岐が生じることを意味します。次の図のように、この再帰呼び出しを繰り返していくと、最終的に深さ \\(n\\) の再帰木（recursion tree）が生成されます。</p> <p></p> <p> 図 2-6   フィボナッチ数列の再帰木 </p> <p>本質的に見ると、再帰は「問題をより小さな部分問題へ分解する」という思考パラダイムを体現しており、この分割統治の戦略は非常に重要です。</p> <ul> <li>アルゴリズムの観点では、探索、ソート、バックトラッキング、分割統治、動的計画法など、多くの重要な戦略が直接または間接にこの考え方を用いています。</li> <li>データ構造の観点では、再帰は連結リスト、木、グラフに関する問題の処理に本質的に適しており、これらは分割統治の考え方で分析しやすいからです。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   両者の比較","text":"<p>以上をまとめると、次の表のように、反復と再帰は実装、性能、適用性の面で違いがあります。</p> <p> 表 2-1   反復と再帰の特徴の比較 </p> 反復 再帰 実装方法 ループ構造 関数が自分自身を呼び出す 時間効率 通常は効率が高く、関数呼び出しの負荷がない 関数呼び出しのたびにオーバーヘッドが発生する メモリ使用 通常は固定サイズのメモリ空間を使う 関数呼び出しの蓄積により大量のスタックフレーム領域を使う可能性がある 適用対象 単純な反復処理に適し、コードが直感的で読みやすい 木、グラフ、分割統治、バックトラッキングなどの部分問題分解に適し、コード構造が簡潔で明快 <p>Tip</p> <p>以下の内容が難しいと感じる場合は、「スタック」の章を読み終えた後に改めて復習してください。</p> <p>では、反復と再帰にはどのような内在的な関係があるのでしょうか。前述の再帰関数を例にすると、加算処理は再帰の復帰段階で行われます。これは、最初に呼び出された関数が実際には最後に加算を完了することを意味しており、この動作の仕組みはスタックの「後入れ先出し」の原則とよく似ています。</p> <p>実際、「呼び出しスタック」や「スタックフレーム領域」といった再帰の用語自体が、再帰とスタックの密接な関係を示唆しています。</p> <ol> <li>再帰呼び出し：関数が呼び出されると、システムは「呼び出しスタック」上にその関数のための新しいスタックフレームを割り当て、局所変数、引数、返却先アドレスなどのデータを保存します。</li> <li>復帰：関数の実行が完了して戻ると、対応するスタックフレームは「呼び出しスタック」から取り除かれ、前の関数の実行環境が復元されます。</li> </ol> <p>したがって、明示的なスタックを使って呼び出しスタックの振る舞いを模擬することができ、その結果として再帰を反復形式へ変換できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"反復で再帰を模擬する\"\"\"\n    # 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack = []\n    res = 0\n    # 再帰：再帰呼び出し\n    for i in range(n, 0, -1):\n        # 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.append(i)\n    # 帰りがけ：結果を返す\n    while stack:\n        # 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (!stack.empty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (!stack.isEmpty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 反復で再帰を模擬する */\nint ForLoopRecur(int n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.Push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.Count &gt; 0) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 反復で再帰を模擬する */\nfunc forLoopRecur(n int) int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    stack := list.New()\n    res := 0\n    // 再帰：再帰呼び出し\n    for i := n; i &gt; 0; i-- {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.PushBack(i)\n    }\n    // 帰りがけ：結果を返す\n    for stack.Len() != 0 {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 反復で再帰を模擬する */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    var stack: [Int] = []\n    var res = 0\n    // 再帰：再帰呼び出し\n    for i in (1 ... n).reversed() {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.append(i)\n    }\n    // 帰りがけ：結果を返す\n    while !stack.isEmpty {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 反復で再帰を模擬する */\nfunction forLoopRecur(n) {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    const stack = [];\n    let res = 0;\n    // 再帰：再帰呼び出し\n    for (let i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.length) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 反復で再帰を模擬する */\nfunction forLoopRecur(n: number): number {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    const stack: number[] = [];\n    let res: number = 0;\n    // 再帰：再帰呼び出し\n    for (let i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while (stack.length) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n  // 明示的なスタックを使ってシステムコールスタックを模擬する\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // 再帰：再帰呼び出し\n  for (int i = n; i &gt; 0; i--) {\n    // 「スタックへのプッシュ」で「再帰」を模擬する\n    stack.add(i);\n  }\n  // 帰りがけ：結果を返す\n  while (!stack.isEmpty) {\n    // 「スタックから取り出す操作」で「帰り」をシミュレート\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 反復で再帰を模擬する */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // 再帰：再帰呼び出し\n    for i in (1..=n).rev() {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i);\n    }\n    // 帰りがけ：結果を返す\n    while !stack.is_empty() {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* 反復で再帰を模擬する */\nint forLoopRecur(int n) {\n    int stack[1000]; // 大きな配列を使ってスタックを実装する\n    int top = -1;    // スタックトップのインデックス\n    int res = 0;\n    // 再帰：再帰呼び出し\n    for (int i = n; i &gt; 0; i--) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack[1 + top++] = i;\n    }\n    // 帰りがけ：結果を返す\n    while (top &gt;= 0) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 反復で再帰を模擬する */\nfun forLoopRecur(n: Int): Int {\n    // 明示的なスタックを使ってシステムコールスタックを模擬する\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // 再帰: 再帰呼び出し\n    for (i in n downTo 0) {\n        // 「スタックへのプッシュ」で「再帰」を模擬する\n        stack.push(i)\n    }\n    // 戻る: 結果を返す\n    while (stack.isNotEmpty()) {\n        // 「スタックから取り出す操作」で「帰り」をシミュレート\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 反復で再帰をシミュレート ###\ndef for_loop_recur(n)\n  # 明示的なスタックを使ってシステムコールスタックを模擬する\n  stack = []\n  res = 0\n\n  # 再帰：再帰呼び出し\n  for i in n.downto(0)\n    # 「スタックへのプッシュ」で「再帰」を模擬する\n    stack &lt;&lt; i\n  end\n  # 帰りがけ：結果を返す\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、再帰を反復へ変換すると、コードはより複雑になります。反復と再帰は多くの場合に相互変換できますが、常にそうする価値があるとは限りません。理由は次の 2 点です。</p> <ul> <li>変換後のコードは理解しにくくなり、可読性が下がる可能性があります。</li> <li>複雑な問題によっては、システムの呼び出しスタックの振る舞いを模擬すること自体が非常に難しい場合があります。</li> </ul> <p>要するに、反復を選ぶか再帰を選ぶかは、対象となる問題の性質によって決まります。実際のプログラミングでは、両者の長所と短所を見極め、状況に応じて適切な方法を選ぶことが重要です。</p>","path":["第 2 章 &nbsp; 計算量解析","2.2 &nbsp; 反復と再帰"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   アルゴリズム効率の評価","text":"<p>アルゴリズム設計では、次の 2 つのレベルの目標を順に追求します。</p> <ol> <li>問題の解法を見つける：アルゴリズムは、定められた入力範囲内で問題の正しい解を確実に求められる必要があります。</li> <li>最適な解法を追求する：同じ問題に対して複数の解法が存在する場合があり、私たちはできるだけ効率的なアルゴリズムを見つけたいと考えます。</li> </ol> <p>つまり、問題を解けることを前提として、アルゴリズム効率はその良し悪しを測る主要な評価指標となっており、次の 2 つの観点を含みます。</p> <ul> <li>時間効率：アルゴリズムの実行時間の長さ。</li> <li>空間効率：アルゴリズムが使用するメモリ空間の大きさ。</li> </ul> <p>簡単に言えば、**私たちの目標は「高速で省メモリ」なデータ構造とアルゴリズムを設計すること**です。そして、アルゴリズム効率を効果的に評価することは非常に重要です。そうすることで初めて、さまざまなアルゴリズムを比較し、さらにアルゴリズム設計と最適化の過程を導けるからです。</p> <p>効率の評価方法は主に 2 種類に分けられます。実測と理論的な見積もりです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   実測","text":"<p>いまアルゴリズム <code>A</code> とアルゴリズム <code>B</code> があり、どちらも同じ問題を解けるとします。この 2 つのアルゴリズムの効率を比較する必要がある場合、最も直接的な方法は 1 台のコンピュータで両者を実行し、その実行時間とメモリ使用量を監視して記録することです。この評価方法は実際の状況を反映できますが、大きな制約もあります。</p> <p>一方では、**テスト環境による干渉要因を排除しにくい**という問題があります。ハードウェア構成はアルゴリズムの性能に影響します。たとえば、並列度の高いアルゴリズムはマルチコア CPU での実行により適しており、メモリアクセスが集中的なアルゴリズムは高性能メモリ上でより良い性能を示します。つまり、異なるマシンでのテスト結果は一致しない可能性があります。これは、さまざまなマシンでテストして平均効率を統計的に求める必要があることを意味しますが、それは現実的ではありません。</p> <p>他方では、**完全なテストを実施するには非常に多くの資源が必要**です。入力データ量が変化すると、アルゴリズムは異なる効率を示します。たとえば、入力データ量が小さいときはアルゴリズム <code>A</code> の実行時間がアルゴリズム <code>B</code> より短くても、入力データ量が大きいときには結果がちょうど逆になるかもしれません。そのため、説得力のある結論を得るには、さまざまな規模の入力データでテストする必要があり、それには大量の計算資源を要します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   理論的な見積もり","text":"<p>実測には大きな制約があるため、いくつかの計算だけによってアルゴリズムの効率を評価することを考えられます。この見積もり方法は漸近計算量解析（asymptotic complexity analysis）と呼ばれ、略して計算量解析といいます。</p> <p>計算量解析は、アルゴリズムの実行に必要な時間資源と空間資源が入力データ規模とどのような関係にあるかを表します。これは、入力データ規模が増加するにつれて、アルゴリズムの実行に必要な時間と空間がどのように増加するかという傾向を記述するものです。この定義はややわかりにくいので、次の 3 つのポイントに分けて理解できます。</p> <ul> <li>「時間資源と空間資源」は、それぞれ時間計算量（time complexity）と空間計算量（space complexity）に対応します。</li> <li>「入力データ規模が増加するにつれて」とは、計算量がアルゴリズムの実行効率と入力データ規模との関係を反映していることを意味します。</li> <li>「時間と空間の増加傾向」とは、計算量解析が注目するのは実行時間や使用空間の具体的な値ではなく、時間や空間の増加の「速さ」であることを示します。</li> </ul> <p>計算量解析は実測という方法の欠点を克服しています。その点は次のように表れます。</p> <ul> <li>実際にコードを動かす必要がなく、より環境にやさしく省エネルギーです。</li> <li>テスト環境から独立しており、解析結果はすべての実行プラットフォームに適用できます。</li> <li>異なるデータ量におけるアルゴリズム効率を表せ、とくに大規模データ量での性能を反映できます。</li> </ul> <p>Tip</p> <p>それでも計算量の概念がまだわかりにくくても、心配はいりません。後続の章で詳しく説明します。</p> <p>計算量解析は、アルゴリズム効率を評価するための「物差し」を私たちに与えてくれます。これにより、あるアルゴリズムの実行に必要な時間資源と空間資源を測り、異なるアルゴリズム同士の効率を比較できます。</p> <p>計算量は数学的な概念であり、初学者にとってはやや抽象的で、学習の難度も比較的高いかもしれません。この観点から見ると、計算量解析は最初に紹介する内容としてはあまり適していない可能性があります。しかし、あるデータ構造やアルゴリズムの特徴を議論する際には、その実行速度や空間使用状況の分析を避けることはできません。</p> <p>以上を踏まえると、データ構造とアルゴリズムを深く学ぶ前に、**まず計算量解析について初歩的な理解を持ち、簡単なアルゴリズムの計算量解析ができるようにしておくこと**を勧めます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.1 &nbsp; アルゴリズム効率の評価"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   空間計算量","text":"<p>空間計算量（space complexity）は、アルゴリズムが占有するメモリ空間がデータ量の増加に伴ってどのように増えるかを測る指標です。この概念は時間計算量と非常によく似ており、「実行時間」を「占有メモリ空間」に置き換えるだけです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   アルゴリズムに関連する空間","text":"<p>アルゴリズムが実行中に使用するメモリ空間には、主に次の種類があります。</p> <ul> <li>入力空間：アルゴリズムの入力データを格納するための空間。</li> <li>一時空間：アルゴリズムの実行中に使用する変数、オブジェクト、関数コンテキストなどのデータを格納するための空間。</li> <li>出力空間：アルゴリズムの出力データを格納するための空間。</li> </ul> <p>一般に、空間計算量の集計範囲は「一時空間」と「出力空間」を合わせたものです。</p> <p>一時空間はさらに三つに分けられます。</p> <ul> <li>一時データ：アルゴリズム実行中の各種定数、変数、オブジェクトなどを保存するための空間。</li> <li>スタックフレーム空間：呼び出された関数のコンテキストデータを保存するための空間。システムは関数を呼び出すたびにスタックの先頭にスタックフレームを作成し、関数が戻るとその空間を解放します。</li> <li>命令空間：コンパイル後のプログラム命令を保存するための空間で、実際の集計では通常無視されます。</li> </ul> <p>プログラムの空間計算量を分析する際には、通常、一時データ、スタックフレーム空間、出力データの三つを数えます。以下の図に示すとおりです。</p> <p></p> <p> 図 2-15   アルゴリズムで使用される関連空間 </p> <p>関連するコードを以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"クラス\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # ノードの値\n        self.next: Node | None = None  # 次のノードへの参照\n\ndef function() -&gt; int:\n    \"\"\"関数\"\"\"\n    # いくつかの処理を実行...\n    return 0\n\ndef algorithm(n) -&gt; int:  # 入力データ\n    A = 0                 # 一時データ（定数。一般に大文字で表す）\n    b = 0                 # 一時データ（変数）\n    node = Node(0)        # 一時データ（オブジェクト）\n    c = function()        # スタックフレーム空間（関数呼び出し）\n    return A + b + c      # 出力データ\n</code></pre> <pre><code>/* 構造体 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* 関数 */\nint func() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) {        // 入力データ\n    const int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node* node = new Node(0); // 一時データ（オブジェクト）\n    int c = func();           // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* 関数 */\nint function() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) {        // 入力データ\n    final int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node node = new Node(0);  // 一時データ（オブジェクト）\n    int c = function();       // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* 関数 */\nint Function() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint Algorithm(int n) {        // 入力データ\n    const int a = 0;          // 一時データ（定数）\n    int b = 0;                // 一時データ（変数）\n    Node node = new(0);       // 一時データ（オブジェクト）\n    int c = Function();       // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* 構造体 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* node 構造体を作成 */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* 関数 */\nfunc function() int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfunc algorithm(n int) int { // 入力データ\n    const a = 0             // 一時データ（定数）\n    b := 0                  // 一時データ（変数）\n    newNode(0)              // 一時データ（オブジェクト）\n    c := function()         // スタックフレーム空間（関数呼び出し）\n    return a + b + c        // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* 関数 */\nfunc function() -&gt; Int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // 入力データ\n    let a = 0             // 一時データ（定数）\n    var b = 0             // 一時データ（変数）\n    let node = Node(x: 0) // 一時データ（オブジェクト）\n    let c = function()    // スタックフレーム空間（関数呼び出し）\n    return a + b + c      // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // ノードの値\n        this.next = null;                       // 次のノードへの参照\n    }\n}\n\n/* 関数 */\nfunction constFunc() {\n    // いくつかの処理を実行\n    return 0;\n}\n\nfunction algorithm(n) {       // 入力データ\n    const a = 0;              // 一時データ（定数）\n    let b = 0;                // 一時データ（変数）\n    const node = new Node(0); // 一時データ（オブジェクト）\n    const c = constFunc();    // スタックフレーム空間（関数呼び出し）\n    return a + b + c;         // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // ノードの値\n        this.next = null;                       // 次のノードへの参照\n    }\n}\n\n/* 関数 */\nfunction constFunc(): number {\n    // いくつかの処理を実行\n    return 0;\n}\n\nfunction algorithm(n: number): number { // 入力データ\n    const a = 0;                        // 一時データ（定数）\n    let b = 0;                          // 一時データ（変数）\n    const node = new Node(0);           // 一時データ（オブジェクト）\n    const c = constFunc();              // スタックフレーム空間（関数呼び出し）\n    return a + b + c;                   // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* 関数 */\nint function() {\n  // いくつかの処理を実行...\n  return 0;\n}\n\nint algorithm(int n) {  // 入力データ\n  const int a = 0;      // 一時データ（定数）\n  int b = 0;            // 一時データ（変数）\n  Node node = Node(0);  // 一時データ（オブジェクト）\n  int c = function();   // スタックフレーム空間（関数呼び出し）\n  return a + b + c;     // 出力データ\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 構造体 */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Node 構造体を作成 */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* 関数 */\nfn function() -&gt; i32 {      \n    // いくつかの処理を実行...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // 入力データ\n    const a: i32 = 0;               // 一時データ（定数）\n    let mut b = 0;                  // 一時データ（変数）\n    let node = Node::new(0);        // 一時データ（オブジェクト）\n    let c = function();             // スタックフレーム空間（関数呼び出し）\n    return a + b + c;               // 出力データ\n}\n</code></pre> <pre><code>/* 関数 */\nint func() {\n    // いくつかの処理を実行...\n    return 0;\n}\n\nint algorithm(int n) { // 入力データ\n    const int a = 0;   // 一時データ（定数）\n    int b = 0;         // 一時データ（変数）\n    int c = func();    // スタックフレーム空間（関数呼び出し）\n    return a + b + c;  // 出力データ\n}\n</code></pre> <pre><code>/* クラス */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* 関数 */\nfun function(): Int {\n    // いくつかの処理を実行...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // 入力データ\n    val a = 0                // 一時データ（定数）\n    var b = 0                // 一時データ（変数）\n    val node = Node(0)       // 一時データ（オブジェクト）\n    val c = function()       // スタックフレーム空間（関数呼び出し）\n    return a + b + c         // 出力データ\n}\n</code></pre> <pre><code>### クラス ###\nclass Node\n    attr_accessor :val      # ノードの値\n    attr_accessor :next     # 次のノードへの参照\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### 関数 ###\ndef function\n    # いくつかの処理を実行...\n    0\nend\n\n### アルゴリズム ###\ndef algorithm(n)        # 入力データ\n    a = 0               # 一時データ（定数）\n    b = 0               # 一時データ（変数）\n    node = Node.new(0)  # 一時データ（オブジェクト）\n    c = function        # スタックフレーム空間（関数呼び出し）\n    a + b + c           # 出力データ\nend\n</code></pre>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   推定方法","text":"<p>空間計算量の推定方法は時間計算量とおおむね同じで、数える対象を「操作回数」から「使用空間の大きさ」に変えるだけです。</p> <p>ただし時間計算量と異なり、通常は最悪空間計算量だけに注目します。メモリ空間は厳格な要件であり、どの入力データに対しても十分なメモリを確保できることを保証しなければならないからです。</p> <p>以下のコードを見ると、最悪空間計算量における「最悪」には二つの意味があります。</p> <ol> <li>最悪の入力データを基準にする：\\(n &lt; 10\\) のとき空間計算量は \\(O(1)\\) ですが、\\(n &gt; 10\\) のとき初期化される配列 <code>nums</code> が \\(O(n)\\) の空間を占有するため、最悪空間計算量は \\(O(n)\\) です。</li> <li>アルゴリズム実行中のメモリ使用量のピークを基準にする：例えば、プログラムは最後の行を実行する前までは \\(O(1)\\) の空間しか使いませんが、配列 <code>nums</code> を初期化するときには \\(O(n)\\) の空間を占有するため、最悪空間計算量は \\(O(n)\\) です。</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>再帰関数では、スタックフレーム空間の集計に注意が必要です。以下のコードを見てみましょう。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # いくつかの処理を実行\n    return 0\n\ndef loop(n: int):\n    \"\"\"ループの空間計算量は O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"再帰の空間計算量は O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // いくつかの処理を実行\n    return 0\n}\n\n/* ループの空間計算量は O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* 再帰の空間計算量は O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // いくつかの処理を実行\n    return 0\n}\n\n/* ループの空間計算量は O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* 再帰の空間計算量は O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // いくつかの処理を実行\n  return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // いくつかの処理を実行\n    return 0;\n}\n/* ループの空間計算量は O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 再帰の空間計算量は O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // いくつかの処理を実行\n    return 0\n}\n/* ループの空間計算量は O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* 再帰の空間計算量は O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # いくつかの処理を実行\n    0\nend\n\n### ループの空間計算量は O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### 再帰の空間計算量は O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>関数 <code>loop()</code> と <code>recur()</code> はどちらも時間計算量は \\(O(n)\\) ですが、空間計算量は異なります。</p> <ul> <li>関数 <code>loop()</code> はループの中で <code>function()</code> を \\(n\\) 回呼び出しますが、各反復での <code>function()</code> は戻るたびにスタックフレーム空間が解放されるため、空間計算量は依然として \\(O(1)\\) です。</li> <li>再帰関数 <code>recur()</code> は実行中に未返却の <code>recur()</code> が同時に \\(n\\) 個存在するため、\\(O(n)\\) のスタックフレーム空間を占有します。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   よくある型","text":"<p>入力データサイズを \\(n\\) とすると、以下の図はよくある空間計算量の型を低い順から高い順に示しています。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{定数階} &lt; \\text{対数階} &lt; \\text{線形階} &lt; \\text{平方階} &lt; \\text{指数階} \\end{aligned} \\] <p></p> <p> 図 2-16   よくある空間計算量の型 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   定数階 \\(O(1)\\)","text":"<p>定数階は、個数が入力データサイズ \\(n\\) に依存しない定数、変数、オブジェクトなどによく現れます。</p> <p>注意すべき点として、ループ内で変数を初期化したり関数を呼び出したりして使用されたメモリは、次の反復に入ると解放されるため、空間の占有は累積せず、空間計算量は依然として \\(O(1)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"関数\"\"\"\n    # 何らかの処理を行う\n    return 0\n\ndef constant(n: int):\n    \"\"\"定数階\"\"\"\n    # 定数、変数、オブジェクトは O(1) の空間を占める\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # ループ内の変数は O(1) の空間を占める\n    for _ in range(n):\n        c = 0\n    # ループ内の関数は O(1) の空間を占める\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* 関数 */\nint func() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 関数 */\nint function() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 関数 */\nint Function() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid Constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 関数 */\nfunc function() int {\n    // いくつかの操作を実行...\n    return 0\n}\n\n/* 定数階 */\nfunc spaceConstant(n int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // ループ内の変数は O(1) の空間を占める\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* 関数 */\n@discardableResult\nfunc function() -&gt; Int {\n    // 何らかの処理を行う\n    return 0\n}\n\n/* 定数階 */\nfunc constant(n: Int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // ループ内の変数は O(1) の空間を占める\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* 関数 */\nfunction constFunc() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nfunction constant(n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 関数 */\nfunction constFunc(): number {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nfunction constant(n: number): void {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // ループ内の変数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 関数 */\nint function() {\n  // 何らかの処理を行う\n  return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n  // 定数、変数、オブジェクトは O(1) の空間を占める\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // ループ内の変数は O(1) の空間を占める\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // ループ内の関数は O(1) の空間を占める\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 関数 */\nfn function() -&gt; i32 {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // ループ内の変数は O(1) の空間を占める\n    for i in 0..n {\n        let c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 関数 */\nint func() {\n    // 何らかの処理を行う\n    return 0;\n}\n\n/* 定数階 */\nvoid constant(int n) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // ループ内の変数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 関数 */\nfun function(): Int {\n    // 何らかの処理を行う\n    return 0\n}\n\n/* 定数階 */\nfun constant(n: Int) {\n    // 定数、変数、オブジェクトは O(1) の空間を占める\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // ループ内の変数は O(1) の空間を占める\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // ループ内の関数は O(1) の空間を占める\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 関数 ###\ndef function\n  # 何らかの処理を行う\n  0\nend\n\n### 定数階 ###\ndef constant(n)\n  # 定数、変数、オブジェクトは O(1) の空間を占める\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # ループ内の変数は O(1) の空間を占める\n  (0...n).each { c = 0 }\n  # ループ内の関数は O(1) の空間を占める\n  (0...n).each { function }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   線形階 \\(O(n)\\)","text":"<p>線形階は、要素数が \\(n\\) に比例する配列、連結リスト、スタック、キューなどによく現れます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"線形階\"\"\"\n    # 長さ n のリストは O(n) の空間を使用\n    nums = [0] * n\n    # 長さ n のハッシュテーブルは O(n) の空間を使用\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    vector&lt;int&gt; nums(n);\n    // 長さ n のリストは O(n) の空間を使用\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int[] nums = new int[n];\n    // 長さ n のリストは O(n) の空間を使用\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 線形階 */\nvoid Linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int[] nums = new int[n];\n    // 長さ n のリストは O(n) の空間を使用\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 線形階 */\nfunc spaceLinear(n int) {\n    // 長さ n の配列は O(n) の空間を使用\n    _ = make([]int, n)\n    // 長さ n のリストは O(n) の空間を使用\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 線形階 */\nfunc linear(n: Int) {\n    // 長さ n の配列は O(n) の空間を使用\n    let nums = Array(repeating: 0, count: n)\n    // 長さ n のリストは O(n) の空間を使用\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* 線形階 */\nfunction linear(n) {\n    // 長さ n の配列は O(n) の空間を使用\n    const nums = new Array(n);\n    // 長さ n のリストは O(n) の空間を使用\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 線形階 */\nfunction linear(n: number): void {\n    // 長さ n の配列は O(n) の空間を使用\n    const nums = new Array(n);\n    // 長さ n のリストは O(n) の空間を使用\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 線形階 */\nvoid linear(int n) {\n  // 長さ n の配列は O(n) の空間を使用\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // 長さ n のリストは O(n) の空間を使用\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // 長さ n のハッシュテーブルは O(n) の空間を使用\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 線形階 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // 長さ n の配列は O(n) の空間を使用\n    let mut nums = vec![0; n as usize];\n    // 長さ n のリストは O(n) の空間を使用\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* ハッシュテーブル */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // uthash.h を用いて実装\n} HashTable;\n\n/* 線形階 */\nvoid linear(int n) {\n    // 長さ n の配列は O(n) の空間を使用\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // 長さ n のリストは O(n) の空間を使用\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // メモリを解放する\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 線形階 */\nfun linear(n: Int) {\n    // 長さ n の配列は O(n) の空間を使用\n    val nums = Array(n) { 0 }\n    // 長さ n のリストは O(n) の空間を使用\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // 長さ n のハッシュテーブルは O(n) の空間を使用\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  # 長さ n のリストは O(n) の空間を使用\n  nums = Array.new(n, 0)\n\n  # 長さ n のハッシュテーブルは O(n) の空間を使用\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、この関数の再帰の深さは \\(n\\) であり、同時に \\(n\\) 個の未返却 <code>linear_recur()</code> 関数が存在するため、\\(O(n)\\) のスタックフレーム空間を使用します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"線形時間（再帰実装）\"\"\"\n    print(\"再帰 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"再帰 n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    System.out.println(\"再帰 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 線形時間（再帰実装） */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"再帰 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 線形時間（再帰実装） */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"再帰 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 線形時間（再帰実装） */\nfunc linearRecur(n: Int) {\n    print(\"再帰 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 線形時間（再帰実装） */\nfunction linearRecur(n) {\n    console.log(`再帰 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 線形時間（再帰実装） */\nfunction linearRecur(n: number): void {\n    console.log(`再帰 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n  print('再帰 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 線形時間（再帰実装） */\nfn linear_recur(n: i32) {\n    println!(\"再帰 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 線形時間（再帰実装） */\nvoid linearRecur(int n) {\n    printf(\"再帰 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* 線形時間（再帰実装） */\nfun linearRecur(n: Int) {\n    println(\"再帰 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  # 長さ n のリストは O(n) の空間を使用\n  nums = Array.new(n, 0)\n\n  # 長さ n のハッシュテーブルは O(n) の空間を使用\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n\n# ## 線形階（再帰実装）###\ndef linear_recur(n)\n  puts \"再帰 n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-17   再帰関数が生み出す線形階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階は、要素数が \\(n\\) の二乗に比例する行列やグラフによく現れます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"二乗階\"\"\"\n    # 二次元リストは O(n^2) の空間を使用\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 二次元リストは O(n^2) の空間を使用\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 行列は O(n^2) の空間を使用する\n    int[][] numMatrix = new int[n][n];\n    // 二次元リストは O(n^2) の空間を使用\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 二乗階 */\nvoid Quadratic(int n) {\n    // 行列は O(n^2) の空間を使用する\n    int[,] numMatrix = new int[n, n];\n    // 二次元リストは O(n^2) の空間を使用\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 二乗階 */\nfunc spaceQuadratic(n int) {\n    // 行列は O(n^2) の空間を使用する\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 二乗階 */\nfunc quadratic(n: Int) {\n    // 二次元リストは O(n^2) の空間を使用\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* 二乗階 */\nfunction quadratic(n) {\n    // 行列は O(n^2) の空間を使用する\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二次元リストは O(n^2) の空間を使用\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 二乗階 */\nfunction quadratic(n: number): void {\n    // 行列は O(n^2) の空間を使用する\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二次元リストは O(n^2) の空間を使用\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n  // 行列は O(n^2) の空間を使用する\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 二次元リストは O(n^2) の空間を使用\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 二乗階 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // 行列は O(n^2) の空間を使用する\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 二次元リストは O(n^2) の空間を使用\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 二乗階 */\nvoid quadratic(int n) {\n    // 二次元リストは O(n^2) の空間を使用\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* 二乗階 */\nfun quadratic(n: Int) {\n    // 行列は O(n^2) の空間を使用する\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 二次元リストは O(n^2) の空間を使用\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、この関数の再帰の深さは \\(n\\) であり、各再帰関数の中で長さがそれぞれ \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) の配列を初期化しています。平均長は \\(n / 2\\) なので、全体では \\(O(n^2)\\) の空間を占有します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"二次時間（再帰実装）\"\"\"\n    if n &lt;= 0:\n        return 0\n    # 配列 nums の長さは n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"再帰 n = \" &lt;&lt; n &lt;&lt; \" における nums の長さ = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"再帰 n = \" + n + \" における nums の長さ = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 二次時間（再帰実装） */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"再帰 n = \" + n + \" における nums の長さ = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 二次時間（再帰実装） */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"再帰 n = %d における nums の長さ = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 二次時間（再帰実装） */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"再帰 n = \\(n) における nums の長さ = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 二次時間（再帰実装） */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 二次時間（再帰実装） */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('再帰 n = $n における nums の長さ = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 二次時間（再帰実装） */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"再帰 n = {} における nums の長さ = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 二次時間（再帰実装） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"再帰 n = %d における nums の長さ = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* 二次時間（再帰実装） */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // 配列 nums の長さは n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"再帰 n = $n における nums の長さ = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## 平方階（再帰実装）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 配列 nums の長さは n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-18   再帰関数が生み出す平方階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   指数階 \\(O(2^n)\\)","text":"<p>指数階は二分木によく現れます。以下の図を見ると、高さが \\(n\\) の「満二分木」のノード数は \\(2^n - 1\\) であり、\\(O(2^n)\\) の空間を占有します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"指数時間（完全二分木の構築）\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* 指数時間（完全二分木の構築） */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* 指数時間（完全二分木の構築） */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* 指数時間（完全二分木の構築） */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* 指数時間（完全二分木の構築） */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* 指数時間（完全二分木の構築） */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* 指数時間（完全二分木の構築） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* 指数時間（完全二分木の構築） */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二次元リストは O(n^2) の空間を使用\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## 平方階（再帰実装）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 配列 nums の長さは n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n\n# ## 指数階（満二分木を構築）###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-19   満二分木が生み出す指数階の空間計算量 </p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   対数階 \\(O(\\log n)\\)","text":"<p>対数階は分割統治アルゴリズムによく現れます。例えばマージソートでは、長さ \\(n\\) の配列を入力として、各再帰で配列を中央から二つに分割するため、高さ \\(\\log n\\) の再帰木が形成され、\\(O(\\log n)\\) のスタックフレーム空間を使用します。</p> <p>また、数値を文字列に変換する場合を考えると、正の整数 \\(n\\) の桁数は \\(\\lfloor \\log_{10} n \\rfloor + 1\\) であり、対応する文字列長も \\(\\lfloor \\log_{10} n \\rfloor + 1\\) です。したがって空間計算量は \\(O(\\log_{10} n + 1) = O(\\log n)\\) となります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   時間と空間のトレードオフ","text":"<p>理想的には、アルゴリズムの時間計算量と空間計算量の両方を最適にしたいところです。しかし実際には、この二つを同時に最適化するのは通常きわめて困難です。</p> <p>時間計算量を下げるには、通常、空間計算量を増やす代償が必要であり、その逆も同様です。メモリ空間を犠牲にして実行速度を上げる考え方を「空間を時間と引き換えにする」と呼び、その逆を「時間を空間と引き換えにする」と呼びます。</p> <p>どちらの考え方を選ぶかは、何をより重視するかによって決まります。多くの場合、空間より時間のほうが貴重なので、「空間を時間と引き換えにする」戦略のほうが一般的です。もちろん、データ量が非常に大きい場合には、空間計算量を抑えることも同じくらい重要です。</p>","path":["第 2 章 &nbsp; 計算量解析","2.4 &nbsp; 空間計算量"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   まとめ","text":"","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<p>アルゴリズム効率の評価</p> <ul> <li>時間効率と空間効率は、アルゴリズムの良し悪しを測る二つの主要な評価指標です。</li> <li>実測によってアルゴリズム効率を評価できますが、テスト環境の影響を排除しにくく、多くの計算資源も消費します。</li> <li>複雑度分析は実測の欠点を補い、分析結果はすべての実行プラットフォームに適用でき、データ規模ごとの効率も明らかにできます。</li> </ul> <p>時間計算量</p> <ul> <li>時間計算量は、アルゴリズムの実行時間がデータ量の増加に伴ってどう変化するかを測るためのものであり、効率評価に有効です。ただし、入力データ量が小さい場合や時間計算量が同じ場合などには、効率の優劣を正確に比較できないことがあります。</li> <li>最悪時間計算量はビッグオー記法 \\(O\\) で表され、関数の漸近上界に対応し、\\(n\\) が正の無限大に近づくときの操作回数 \\(T(n)\\) の増加の度合いを表します。</li> <li>時間計算量の推定は二段階に分かれ、まず操作回数を数え、次に漸近上界を判断します。</li> <li>一般的な時間計算量を低い順から並べると、\\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n \\log n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\)、\\(O(n!)\\) などがあります。</li> <li>一部のアルゴリズムの時間計算量は固定ではなく、入力データの分布に関係します。時間計算量には最悪、最良、平均時間計算量がありますが、最良時間計算量は入力データが厳しい条件を満たす必要があるため、ほとんど使われません。</li> <li>平均時間計算量は、ランダムな入力データに対するアルゴリズムの実行効率を表し、実運用時の性能に最も近い指標です。平均時間計算量を求めるには、入力データの分布と、それを踏まえた数学的期待値を統計する必要があります。</li> </ul> <p>空間計算量</p> <ul> <li>空間計算量の役割は時間計算量に似ており、アルゴリズムが使用するメモリ空間がデータ量の増加に伴ってどう変化するかを測ります。</li> <li>アルゴリズム実行中に関係するメモリ空間は、入力空間、一時空間、出力空間に分けられます。通常、入力空間は空間計算量の計算に含めません。一時空間は一時データ、スタックフレーム空間、命令空間に分けられ、このうちスタックフレーム空間は通常、再帰関数でのみ空間計算量に影響します。</li> <li>私たちは通常、最悪空間計算量のみに注目し、最悪の入力データと最悪の実行時点における空間計算量を数えます。</li> <li>一般的な空間計算量を低い順から並べると、\\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\) などがあります。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：尾再帰の空間計算量は \\(O(1)\\) ですか？</p> <p>理論上、尾再帰関数の空間計算量は \\(O(1)\\) まで最適化できます。ただし、ほとんどのプログラミング言語（Java、Python、C++、Go、C# など）は尾再帰の自動最適化をサポートしていないため、通常は空間計算量を \\(O(n)\\) と見なします。</p> <p>Q：関数とメソッドという二つの用語の違いは何ですか？</p> <p>関数（function）は独立して実行でき、すべての引数は明示的に渡されます。メソッド（method）はオブジェクトに関連付けられ、それを呼び出すオブジェクトが暗黙的に渡され、クラスのインスタンスに含まれるデータを操作できます。</p> <p>以下では、いくつかの一般的なプログラミング言語を例に説明します。</p> <ul> <li>C 言語は手続き型プログラミング言語であり、オブジェクト指向の概念がないため、関数しかありません。ただし、構造体（struct）を作成してオブジェクト指向プログラミングを模倣でき、構造体に関連付けられた関数は、他のプログラミング言語におけるメソッドに相当します。</li> <li>Java と C# はオブジェクト指向のプログラミング言語であり、コードブロック（メソッド）は通常あるクラスの一部です。静的メソッドの振る舞いは関数に似ており、クラスに束縛され、特定のインスタンス変数にはアクセスできません。</li> <li>C++ と Python は、手続き型プログラミング（関数）にもオブジェクト指向プログラミング（メソッド）にも対応しています。</li> </ul> <p>Q：「一般的な空間計算量の種類」の図が表しているのは、使用空間の絶対量ですか？</p> <p>いいえ。この図が示しているのは空間計算量であり、表しているのは増加傾向であって、使用空間の絶対量ではありません。</p> <p>\\(n = 8\\) と仮定すると、各曲線の値が対応する関数と一致していないように見えるかもしれません。これは、各曲線に定数項が含まれており、値の範囲を視覚的に見やすい範囲へ圧縮しているためです。</p> <p>実際には、各手法の「定数項」の複雑度がどれほどか通常は分からないため、一般に複雑度だけを根拠に \\(n = 8\\) 以下で最適解を選ぶことはできません。ただし、\\(n = 8^5\\) であれば選びやすく、このときは増加傾向がすでに支配的になっています。</p> <p>Q 実際の利用場面に応じて、時間（または空間）を犠牲にしてアルゴリズムを設計することはありますか？</p> <p>実際の応用では、多くの場合、空間を犠牲にして時間を得る選択をします。たとえばデータベースのインデックスでは、通常 B+ 木やハッシュインデックスを構築し、大量のメモリ空間を使う代わりに、\\(O(\\log n)\\) あるいは \\(O(1)\\) の高速な検索を実現します。</p> <p>空間資源が貴重な場面では、時間を犠牲にして空間を得ることもあります。たとえば組み込み開発では、デバイスのメモリが非常に貴重なため、エンジニアはハッシュテーブルの使用をやめ、配列による順次探索を選んでメモリ使用量を節約することがあります。その代償として探索は遅くなります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   時間計算量","text":"<p>実行時間はアルゴリズムの効率を直感的かつ正確に反映します。あるコードの実行時間を正確に見積もりたい場合、どのようにすればよいでしょうか？</p> <ol> <li>実行プラットフォームを特定する。ハードウェア構成、プログラミング言語、システム環境などが含まれ、これらの要因はいずれもコードの実行効率に影響します。</li> <li>各種計算操作に必要な実行時間を評価する。例えば加算 <code>+</code> には 1 ns 、乗算 <code>*</code> には 10 ns 、出力 <code>print()</code> には 5 ns などが必要です。</li> <li>コード中のすべての計算操作を数える。そして各操作の実行時間を合計することで、実行時間を得ます。</li> </ol> <p>例えば次のコードでは、入力データサイズを \\(n\\) とします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># ある実行プラットフォーム上で\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # n 回ループ\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // n 回ループ\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // n 回ループ\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // n 回ループ\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // n 回ループ\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// ある実行プラットフォーム上で\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // n 回ループ\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># ある実行プラットフォーム上で\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # n 回ループ\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>上記の方法に基づくと、アルゴリズムの実行時間は \\((6n + 12)\\) ns になります：</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>しかし実際には、アルゴリズムの実行時間を統計的に求めることは合理的でも現実的でもありません。まず、見積もり時間を実行プラットフォームに縛りたくありません。アルゴリズムはさまざまな異なるプラットフォームで動作する必要があるからです。次に、各種操作の実行時間を知ること自体が難しく、見積もりの難易度を大きく引き上げます。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   実行時間の増加傾向を捉える","text":"<p>時間計算量の分析で扱うのはアルゴリズムの実行時間そのものではなく、**データ量が増えたときに実行時間がどう増加するかという傾向**です。</p> <p>「実行時間の増加傾向」という概念はやや抽象的なので、例を通して理解してみましょう。入力データサイズを \\(n\\) とし、3 つのアルゴリズム <code>A</code>、<code>B</code>、<code>C</code> を考えます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># アルゴリズム A の時間計算量：定数階\ndef algorithm_A(n: int):\n    print(0)\n# アルゴリズム B の時間計算量：線形階\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# アルゴリズム C の時間計算量：定数階\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// アルゴリズム B の時間計算量：線形階\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// アルゴリズム B の時間計算量：線形階\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// アルゴリズム C の時間計算量：定数階\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// アルゴリズム B の時間計算量：線形階\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// アルゴリズム B の時間計算量：線形階\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithmA(int n) {\n  print(0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// アルゴリズム B の時間計算量：線形階\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// アルゴリズム B の時間計算量：線形階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// アルゴリズム A の時間計算量：定数階\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// アルゴリズム B の時間計算量：線形階\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// アルゴリズム C の時間計算量：定数階\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># アルゴリズム A の時間計算量：定数階\ndef algorithm_A(n)\n    puts 0\nend\n\n# アルゴリズム B の時間計算量：線形階\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# アルゴリズム C の時間計算量：定数階\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>以下の図は、上記 3 つのアルゴリズム関数の時間計算量を示しています。</p> <ul> <li>アルゴリズム <code>A</code> には出力操作が \\(1\\) 回しかなく、実行時間は \\(n\\) が大きくなっても増加しません。このアルゴリズムの時間計算量を「定数階」と呼びます。</li> <li>アルゴリズム <code>B</code> の出力操作は \\(n\\) 回ループする必要があり、実行時間は \\(n\\) の増加に対して線形に増加します。このアルゴリズムの時間計算量は「線形階」と呼ばれます。</li> <li>アルゴリズム <code>C</code> の出力操作は \\(1000000\\) 回ループする必要があり、実行時間は長いものの、入力データサイズ \\(n\\) とは無関係です。したがって <code>C</code> の時間計算量は <code>A</code> と同じく、依然として「定数階」です。</li> </ul> <p></p> <p> 図 2-7   アルゴリズム A、B、C の時間増加傾向 </p> <p>アルゴリズムの実行時間を直接数える方法と比べて、時間計算量分析にはどのような特徴があるでしょうか？</p> <ul> <li>時間計算量はアルゴリズム効率を有効に評価できます。例えばアルゴリズム <code>B</code> の実行時間は線形に増加するため、\\(n &gt; 1\\) ではアルゴリズム <code>A</code> より遅く、\\(n &gt; 1000000\\) ではアルゴリズム <code>C</code> より遅くなります。実際、入力データサイズ \\(n\\) が十分に大きければ、「定数階」のアルゴリズムは必ず「線形階」のアルゴリズムより優れます。これが実行時間の増加傾向の意味です。</li> <li>時間計算量の見積もり方法はより簡潔です。実行プラットフォームや計算操作の種類は、アルゴリズム実行時間の増加傾向とは無関係です。そのため時間計算量分析では、すべての計算操作の実行時間を同じ「単位時間」とみなしてよく、「計算操作の実行時間を数える」作業を「計算操作の個数を数える」作業へ簡略化できます。これにより見積もりの難易度は大きく下がります。</li> <li>時間計算量には一定の限界もあります。例えばアルゴリズム <code>A</code> と <code>C</code> の時間計算量は同じでも、実際の実行時間には大きな差があります。同様に、アルゴリズム <code>B</code> の時間計算量は <code>C</code> より高いものの、入力データサイズ \\(n\\) が小さい場合にはアルゴリズム <code>B</code> のほうが明らかに優れます。このような場合、時間計算量だけでアルゴリズム効率の高低を判断するのは難しいことがあります。もっとも、こうした問題があっても、複雑度分析は依然としてアルゴリズム効率を評価する最も有効で一般的な方法です。</li> </ul>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   関数の漸近上界","text":"<p>入力サイズが \\(n\\) の次の関数を考えます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # n 回ループ\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // +1（各反復で i ++ を実行）\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // n 回ループ\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // n 回ループ\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++){ // +1（各反復で i ++ を実行）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // n 回ループ\n    for(let i = 0; i &lt; n; i++){ // +1（各反復で i ++ を実行）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // n 回ループ\n  for (int i = 0; i &lt; n; i++) { // +1（各反復で i ++ を実行）\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // n 回ループ\n    for _ in 0..n { // +1（各反復で i ++ を実行）\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // n 回ループ\n    for (int i = 0; i &lt; n; i++) {   // +1（各反復で i ++ を実行）\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // n 回ループ\n    for (i in 0..&lt;n) { // +1（各反復で i ++ を実行）\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # n 回ループ\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>アルゴリズムの操作回数を入力データサイズ \\(n\\) の関数とし、\\(T(n)\\) と表すと、上の関数の操作回数は次のようになります：</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) は一次関数であり、実行時間の増加傾向が線形であることを示しています。したがってその時間計算量は線形階です。</p> <p>線形階の時間計算量を \\(O(n)\\) と表します。この数学記号はビッグ \\(O\\) 記法（big-\\(O\\) notation）と呼ばれ、関数 \\(T(n)\\) の漸近上界（asymptotic upper bound）を表します。</p> <p>時間計算量の分析は本質的に「操作回数 \\(T(n)\\)」の漸近上界を求めることであり、明確な数学的定義があります。</p> <p>関数の漸近上界</p> <p>正の実数 \\(c\\) と実数 \\(n_0\\) が存在し、すべての \\(n &gt; n_0\\) について \\(T(n) \\leq c \\cdot f(n)\\) が成り立つならば、\\(f(n)\\) は \\(T(n)\\) の漸近上界の 1 つであるとみなせます。これを \\(T(n) = O(f(n))\\) と記します。</p> <p>下図のように、漸近上界を求めるとは関数 \\(f(n)\\) を探すことであり、\\(n\\) が無限大へ近づくときに \\(T(n)\\) と \\(f(n)\\) が同じ増加オーダーにあり、定数係数 \\(c\\) だけが異なる状態を表します。</p> <p></p> <p> 図 2-8   関数の漸近上界 </p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   求め方","text":"<p>漸近上界はやや数学色が強い概念ですが、完全に理解できていなくても心配はいりません。まずは求め方を押さえ、実践を重ねる中で徐々にその数学的意味をつかめば十分です。</p> <p>定義より、\\(f(n)\\) が定まれば時間計算量 \\(O(f(n))\\) が得られます。では、漸近上界 \\(f(n)\\) をどのように決めればよいのでしょうか。大きく 2 段階あります。まず操作回数を数え、その後で漸近上界を判断します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-1","level":3,"title":"1.   第 1 ステップ：操作回数を数える","text":"<p>コードについては、上から下へ 1 行ずつ数えれば十分です。しかし、前述の \\(c \\cdot f(n)\\) における定数係数 \\(c\\) は任意に大きく取れるため、操作回数 \\(T(n)\\) に含まれるさまざまな係数や定数項は無視できます。この原則から、次のような簡略化のコツが得られます。</p> <ol> <li>\\(T(n)\\) 中の定数を無視する。それらはすべて \\(n\\) と無関係なので、時間計算量には影響しません。</li> <li>すべての係数を省略する。例えば \\(2n\\) 回や \\(5n + 1\\) 回のループは、いずれも \\(n\\) 回と簡略化できます。\\(n\\) の前の係数は時間計算量に影響しないからです。</li> <li>ループが入れ子のときは乗算を使う。総操作回数は外側のループと内側のループの操作回数の積に等しく、各ループ層には引き続き <code>1.</code> と <code>2.</code> のコツをそれぞれ適用できます。</li> </ol> <p>次の関数では、上記のコツを使って操作回数を数えられます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0（コツ 1）\n    a = a + n  # +0（コツ 1）\n    # +n（コツ 2）\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n（コツ 3）\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0（コツ 1）\n    a = a + n  // +0（コツ 1）\n    // +n（コツ 2）\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n（コツ 3）\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0（コツ 1）\n    a = a + n // +0（コツ 1）\n    // +n（コツ 2）\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n（コツ 3）\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（コツ 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（コツ 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0（コツ 1）\n  a = a + n; // +0（コツ 1）\n  // +n（コツ 2）\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n（コツ 3）\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0（コツ 1）\n    a = a + n;        // +0（コツ 1）\n\n    // +n（コツ 2）\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n（コツ 3）\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（コツ 1）\n    a = a + n;  // +0（コツ 1）\n    // +n（コツ 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n（コツ 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0（コツ 1）\n    a = a + n   // +0（コツ 1）\n    // +n（コツ 2）\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n（コツ 3）\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0（コツ 1）\n    a = a + n   # +0（コツ 1）\n    # +n（コツ 2）\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n（コツ 3）\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>次の式は、上記のコツを使う前後の集計結果を示したもので、どちらから求めても時間計算量は \\(O(n^2)\\) です。</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{厳密集計 (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{手抜き集計 (o.O)} \\end{aligned} \\]","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-2","level":3,"title":"2.   第 2 ステップ：漸近上界を判断する","text":"<p>時間計算量は \\(T(n)\\) の最高次の項によって決まります。これは、\\(n\\) が無限大に近づくとき、最高次の項が支配的となり、他の項の影響は無視できるからです。</p> <p>以下の表はその例です。いくつか極端な値を入れているのは、「係数では次数は変わらない」という結論を強調するためです。\\(n\\) が無限大に近づくと、これらの定数は重要でなくなります。</p> <p> 表 2-2   異なる操作回数に対応する時間計算量 </p> 操作回数 \\(T(n)\\) 時間計算量 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   よくある種類","text":"<p>入力データサイズを \\(n\\) とすると、よくある時間計算量の種類は次図のとおりです（小さい順に並べています）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{定数階} &lt; \\text{対数階} &lt; \\text{線形階} &lt; \\text{線形対数階} &lt; \\text{平方階} &lt; \\text{指数階} &lt; \\text{階乗階} \\end{aligned} \\] <p></p> <p> 図 2-9   よくある時間計算量の種類 </p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   定数階 \\(O(1)\\)","text":"<p>定数階の操作回数は入力データサイズ \\(n\\) と無関係であり、\\(n\\) が変化しても増減しません。</p> <p>次の関数では、操作回数 <code>size</code> が大きい可能性はありますが、入力データサイズ \\(n\\) とは無関係なので、時間計算量は依然として \\(O(1)\\) です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"定数階\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 定数階 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 定数階 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 定数階 */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 定数階 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 定数階 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 定数階 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 定数階 */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 定数階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 定数階 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 定数階 ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   線形階 \\(O(n)\\)","text":"<p>線形階の操作回数は入力データサイズ \\(n\\) に対して線形に増加します。線形階は通常、単一ループに現れます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"線形階\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形階 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形階 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形階 */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形階 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形階 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形階 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形階 */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線形階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形階 */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>配列走査や連結リスト走査などの操作の時間計算量はいずれも \\(O(n)\\) であり、ここでの \\(n\\) は配列または連結リストの長さです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"線形時間（配列を走査）\"\"\"\n    count = 0\n    # ループ回数は配列長に比例する\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形時間（配列を走査） */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形時間（配列を走査） */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // ループ回数は配列長に比例する\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形時間（配列を走査） */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // ループ回数は配列長に比例する\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形時間（配列を走査） */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // ループ回数は配列長に比例する\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形時間（配列を走査） */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // ループ回数は配列長に比例する\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // ループ回数は配列長に比例する\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形時間（配列を走査） */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // ループ回数は配列長に比例する\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線形時間（配列を走査） */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // ループ回数は配列長に比例する\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形時間（配列を走査） */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // ループ回数は配列長に比例する\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n\n# ## 線形階（配列を走査）###\ndef array_traversal(nums)\n  count = 0\n\n  # ループ回数は配列長に比例する\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>注意すべきなのは、**入力データサイズ \\(n\\) は入力データの型に応じて具体的に定める必要がある**ということです。例えば 1 つ目の例では変数 \\(n\\) が入力データサイズであり、2 つ目の例では配列長 \\(n\\) がデータサイズです。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階の操作回数は入力データサイズ \\(n\\) に対して二乗のオーダーで増加します。平方階は通常、入れ子ループに現れ、外側のループと内側のループの時間計算量がともに \\(O(n)\\) であるため、全体の時間計算量は \\(O(n^2)\\) になります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"二乗階\"\"\"\n    count = 0\n    # ループ回数はデータサイズ n の二乗に比例する\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 二乗階 */\nint Quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 二乗階 */\nfunc quadratic(n int) int {\n    count := 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 二乗階 */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 二乗階 */\nfunction quadratic(n) {\n    let count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 二乗階 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 二乗階 */\nint quadratic(int n) {\n  int count = 0;\n  // ループ回数はデータサイズ n の二乗に比例する\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 二乗階 */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 二乗階 */\nint quadratic(int n) {\n    int count = 0;\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 二乗階 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // ループ回数はデータサイズ n の二乗に比例する\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図は、定数階・線形階・平方階の 3 種類の時間計算量を比較したものです。</p> <p></p> <p> 図 2-10   定数階、線形階、平方階の時間計算量 </p> <p>バブルソートを例にとると、外側のループは \\(n - 1\\) 回実行され、内側のループは \\(n-1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 回実行され、平均すると \\(n / 2\\) 回です。したがって時間計算量は \\(O((n - 1) n / 2) = O(n^2)\\) となります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"二次時間（バブルソート）\"\"\"\n    count = 0  # カウンタ\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # 要素交換には 3 回の単位操作が含まれる\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(int[] nums) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 二次時間（バブルソート） */\nint BubbleSort(int[] nums) {\n    int count = 0;  // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 二次時間（バブルソート） */\nfunc bubbleSort(nums []int) int {\n    count := 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 二次時間（バブルソート） */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 二次時間（バブルソート） */\nfunction bubbleSort(nums) {\n    let count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 二次時間（バブルソート） */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // カウンタ\n  // 外側のループ：未ソート区間は [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // 要素交換には 3 回の単位操作が含まれる\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 二次時間（バブルソート） */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // カウンタ\n\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 二次時間（バブルソート） */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 二次時間（バブルソート） */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // カウンタ\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // 要素交換には 3 回の単位操作が含まれる\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   指数階 \\(O(2^n)\\)","text":"<p>生物学における「細胞分裂」は指数階増加の典型例です。初期状態では細胞が \\(1\\) 個あり、1 回分裂すると \\(2\\) 個、2 回分裂すると \\(4\\) 個となり、以下同様に、\\(n\\) 回分裂すると \\(2^n\\) 個の細胞になります。</p> <p>以下の図とコードは細胞分裂の過程を模擬したもので、時間計算量は \\(O(2^n)\\) です。なお、入力の \\(n\\) は分裂回数を表し、戻り値 <code>count</code> は総分裂回数を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"指数時間（ループ実装）\"\"\"\n    count = 0\n    base = 1\n    # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指数時間（ループ実装） */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 指数時間（ループ実装） */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 指数時間（ループ実装） */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 指数時間（ループ実装） */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指数時間（ループ実装） */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指数時間（ループ実装） */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 指数時間（ループ実装） */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指数時間（ループ実装） */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-11   指数階の時間計算量 </p> <p>実際のアルゴリズムでも、指数階は再帰関数によく現れます。例えば次のコードでは、再帰的に 2 つへ分岐し、\\(n\\) 回分裂した後に停止します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"指数時間（再帰実装）\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指数時間（再帰実装） */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 指数時間（再帰実装） */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 指数時間（再帰実装） */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 指数時間（再帰実装） */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指数時間（再帰実装） */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指数時間（再帰実装） */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 指数時間（再帰実装） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指数時間（再帰実装） */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>指数階の増加は非常に速く、全探索法（ブルートフォース、バックトラッキングなど）によく見られます。データ規模が大きい問題では、指数階は受け入れられず、通常は動的計画法や貪欲法などを使って解く必要があります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   対数階 \\(O(\\log n)\\)","text":"<p>指数階とは逆に、対数階は「各ラウンドで半分になる」状況を表します。入力データサイズを \\(n\\) とすると、各ラウンドで半減するため、ループ回数は \\(\\log_2 n\\)、すなわち \\(2^n\\) の逆関数になります。</p> <p>以下の図とコードは、「各ラウンドで半分になる」過程を模擬したもので、時間計算量は \\(O(\\log_2 n)\\)、簡潔には \\(O(\\log n)\\) と書きます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"対数時間（ループ実装）\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 対数時間（ループ実装） */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 対数時間（ループ実装） */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 対数時間（ループ実装） */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 対数時間（ループ実装） */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 対数時間（ループ実装） */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 対数時間（ループ実装） */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 対数時間（ループ実装） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 対数時間（ループ実装） */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## 対数階（ループ実装）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-12   対数階の時間計算量 </p> <p>指数階と同様に、対数階も再帰関数によく現れます。次のコードは高さ \\(\\log_2 n\\) の再帰木を形成します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"対数時間（再帰実装）\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 対数時間（再帰実装） */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 対数時間（再帰実装） */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 対数時間（再帰実装） */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 対数時間（再帰実装） */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 対数時間（再帰実装） */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 対数時間（再帰実装） */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 対数時間（再帰実装） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 対数時間（再帰実装） */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # ループ回数はデータサイズ n の二乗に比例する\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## 平方階（バブルソート）###\ndef bubble_sort(nums)\n  count = 0  # カウンタ\n\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 要素交換には 3 回の単位操作が含まれる\n      end\n    end\n  end\n\n  count\nend\n\n# ## 指数階（ループ実装）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## 指数階（再帰実装）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## 対数階（ループ実装）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n\n# ## 対数階（再帰実装）###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>対数階は分割統治に基づくアルゴリズムによく現れ、「1 つを複数に分ける」「複雑なものを単純化する」という考え方を体現しています。増加は緩やかで、定数階に次いで理想的な時間計算量です。</p> <p>\\(O(\\log n)\\) の底は何か？</p> <p>正確には、「\\(m\\) 個に分ける」場合に対応する時間計算量は \\(O(\\log_m n)\\) です。そして対数の底の変換公式により、底が異なっても同値な時間計算量が得られます：</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>つまり、底 \\(m\\) は複雑度に影響を与えずに変換できます。そのため通常は底 \\(m\\) を省略し、対数階を単に \\(O(\\log n)\\) と記します。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   線形対数階 \\(O(n \\log n)\\)","text":"<p>線形対数階は入れ子ループによく現れ、2 層のループの時間計算量はそれぞれ \\(O(\\log n)\\) と \\(O(n)\\) です。関連するコードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"線形対数時間\"\"\"\n    if n &lt;= 1:\n        return 1\n    # 二つに分割すると、部分問題の規模は半分になる\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # 現在の部分問題には n 個の操作が含まれる\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線形対数時間 */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線形対数時間 */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線形対数時間 */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線形対数時間 */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線形対数時間 */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線形対数時間 */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* 線形対数時間 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線形対数時間 */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形対数時間 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は線形対数階がどのように生じるかを示しています。二分木の各層の操作総数はすべて \\(n\\) であり、木全体は \\(\\log_2 n + 1\\) 層あるため、時間計算量は \\(O(n \\log n)\\) です。</p> <p></p> <p> 図 2-13   線形対数階の時間計算量 </p> <p>主なソートアルゴリズムの時間計算量は通常 \\(O(n \\log n)\\) であり、例えばクイックソート、マージソート、ヒープソートなどがあります。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   階乗階 \\(O(n!)\\)","text":"<p>階乗階は、数学における「全順列」の問題に対応します。互いに重複しない \\(n\\) 個の要素が与えられたとき、そのすべての並べ方を求めると、通り数は次のようになります：</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>階乗は通常、再帰で実装されます。以下の図とコードのように、第 1 層では \\(n\\) 個に分岐し、第 2 層では \\(n - 1\\) 個に分岐し、以下同様に、第 \\(n\\) 層で分岐が停止します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"階乗時間（再帰実装）\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # 1個から n 個に分裂\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 階乗時間（再帰実装） */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // 1個から n 個に分裂\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 階乗時間（再帰実装） */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // 1個から n 個に分裂\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 階乗時間（再帰実装） */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // 1個から n 個に分裂\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 階乗時間（再帰実装） */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // 1個から n 個に分裂\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 階乗時間（再帰実装） */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // 1個から n 個に分裂\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // 1個から n 個に分裂\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 階乗時間（再帰実装） */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // 1個から n 個に分裂\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 階乗時間（再帰実装） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 階乗時間（再帰実装） */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // 1個から n 個に分裂\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線形対数時間 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n\n# ## 階乗階（再帰実装）###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # 1個から n 個に分裂\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 2-14   階乗階の時間計算量 </p> <p>注意すべき点として、\\(n \\geq 4\\) なら常に \\(n! &gt; 2^n\\) なので、階乗階は指数階よりもさらに速く増加し、\\(n\\) が大きい場合にはやはり受け入れられません。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   最悪・最良・平均時間計算量","text":"<p>アルゴリズムの時間効率は固定ではなく、入力データの分布に左右されることが多いです。長さ \\(n\\) の配列 <code>nums</code> を考えます。<code>nums</code> は \\(1\\) から \\(n\\) までの数字で構成され、各数字は 1 回だけ現れます。ただし要素の順序はランダムにシャッフルされており、目標は要素 \\(1\\) のインデックスを返すことです。ここから次の結論が得られます。</p> <ul> <li><code>nums = [?, ?, ..., 1]</code>、つまり末尾の要素が \\(1\\) の場合は、配列全体を最後まで走査する必要があり、最悪時間計算量 \\(O(n)\\) になります。</li> <li><code>nums = [1, ?, ?, ...]</code>、つまり先頭要素が \\(1\\) の場合は、配列がどれだけ長くてもそれ以上走査する必要がなく、最良時間計算量 \\(\\Omega(1)\\) になります。</li> </ul> <p>「最悪時間計算量」は関数の漸近上界に対応し、ビッグ \\(O\\) 記法で表します。同様に、「最良時間計算量」は関数の漸近下界に対応し、\\(\\Omega\\) 記法で表します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"要素が 1, 2, ..., n で順序がシャッフルされた配列を生成する\"\"\"\n    # 配列 nums =: 1, 2, 3, ..., n を生成する\n    nums = [i for i in range(1, n + 1)]\n    # 配列要素をランダムにシャッフル\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"配列 nums 内で数値 1 のインデックスを探す\"\"\"\n    for i in range(len(nums)):\n        # 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        # 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // システム時刻を使って乱数シードを生成する\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // 配列要素をランダムにシャッフル\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // 配列要素をランダムにシャッフル\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // 配列要素をランダムにシャッフル\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    var nums = Array(1 ... n)\n    // 配列要素をランダムにシャッフル\n    nums.shuffle()\n    return nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // 配列 nums = { 1, 2, 3, ..., n } を生成\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // 配列要素をランダムにシャッフル\n  nums.shuffle();\n\n  return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n    // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // 配列要素をランダムにシャッフル\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nint *randomNumbers(int n) {\n    // ヒープ領域にメモリを確保する（要素数 n、要素型 int の一次元可変長配列を作成）\n    int *nums = (int *)malloc(n * sizeof(int));\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 配列要素をランダムにシャッフル\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // 配列 nums = { 1, 2, 3, ..., n } を生成\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // 配列要素をランダムにシャッフル\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* 配列 nums 内で数値 1 のインデックスを探す */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### 1, 2, ..., n を要素とする配列を生成し、順序をシャッフルする ###\ndef random_numbers(n)\n  # 配列 nums =: 1, 2, 3, ..., n を生成する\n  nums = Array.new(n) { |i| i + 1 }\n  # 配列要素をランダムにシャッフル\n  nums.shuffle!\nend\n\n### 配列 nums 内の数値 1 のインデックスを探す ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる\n    # 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>実際には、最良時間計算量を使うことはあまりありません。通常それが実現する確率はごく低く、誤解を招く可能性があるからです。**一方で最悪時間計算量はより実用的で、効率の安全側の目安を与えてくれる**ため、安心してアルゴリズムを使えます。</p> <p>上の例から分かるように、最悪時間計算量と最良時間計算量は「特殊なデータ分布」でのみ現れ、その発生確率は低いことが多く、アルゴリズムの実行効率をそのまま正確に反映するわけではありません。それに対して、**平均時間計算量はランダム入力におけるアルゴリズムの実行効率を表せる**ため、\\(\\Theta\\) 記法で表します。</p> <p>一部のアルゴリズムでは、ランダムなデータ分布における平均的な状況を比較的簡単に求められます。例えば上の例では、入力配列はシャッフルされているため、要素 \\(1\\) が任意のインデックスに現れる確率は等しいです。したがってアルゴリズムの平均ループ回数は配列長の半分 \\(n / 2\\) となり、平均時間計算量は \\(\\Theta(n / 2) = \\Theta(n)\\) です。</p> <p>しかし、より複雑なアルゴリズムでは、平均時間計算量を計算するのはしばしば困難です。データ分布に対する全体の数学的期待値を分析するのが難しいからです。そのような場合、通常は最悪時間計算量をアルゴリズム効率の評価基準として用います。</p> <p>なぜ \\(\\Theta\\) 記号をあまり見かけないのか？</p> <p>おそらく \\(O\\) 記号のほうが口にしやすいため、平均時間計算量を表すのにもよく使われます。ただし厳密には、この用法は正確ではありません。本書や他の資料で「平均時間計算量 \\(O(n)\\)」のような表現を見かけた場合は、そのまま \\(\\Theta(n)\\) と理解してください。</p>","path":["第 2 章 &nbsp; 計算量解析","2.3 &nbsp; 時間計算量"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"第 3 章   データ構造","text":"<p>Abstract</p> <p>データ構造は、堅固で多様な枠組みのようなものである。</p> <p>それはデータを秩序立てて組織するための青写真を示し、アルゴリズムはその上で生き生きと動き出す。</p>","path":["第 3 章 &nbsp; データ構造"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"章の内容","text":"<ul> <li>3.1   データ構造の分類</li> <li>3.2   基本データ型</li> <li>3.3   数値エンコーディング *</li> <li>3.4   文字エンコーディング *</li> <li>3.5   まとめ</li> </ul>","path":["第 3 章 &nbsp; データ構造"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   基本データ型","text":"<p>コンピュータ内のデータについて考えるとき、テキスト、画像、動画、音声、3D モデルなど、さまざまな形態を思い浮かべます。これらのデータの構成形式はそれぞれ異なりますが、いずれも各種の基本データ型によって成り立っています。</p> <p>**基本データ型は CPU が直接演算できる型**であり、アルゴリズムの中で直接使われます。主なものは次のとおりです。</p> <ul> <li>整数型 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> 。</li> <li>浮動小数点数型 <code>float</code>、<code>double</code> ，小数を表すために使います。</li> <li>文字型 <code>char</code> ，各言語の文字、句読点、さらには絵文字などを表すために使います。</li> <li>真偽値型 <code>bool</code> ，真か偽かの判定を表すために使います。</li> </ul> <p>基本データ型はコンピュータ内で 2 進数の形で格納されます。1 つの二進桁は \\(1\\) ビットです。現代のほとんどのオペレーティングシステムでは、\\(1\\) バイト（byte）は \\(8\\) ビット（bit）で構成されます。</p> <p>基本データ型の値域は、その型が占める領域の大きさによって決まります。以下では Java を例に取ります。</p> <ul> <li>整数型 <code>byte</code> は \\(1\\) バイト = \\(8\\) ビットを占め、\\(2^{8}\\) 個の数を表せます。</li> <li>整数型 <code>int</code> は \\(4\\) バイト = \\(32\\) ビットを占め、\\(2^{32}\\) 個の数を表せます。</li> </ul> <p>下表は、Java における各種基本データ型の使用領域、値域、デフォルト値を示したものです。この表を丸暗記する必要はなく、大まかに理解しておけば十分であり、必要になったときに参照すればかまいません。</p> <p> 表 3-1   基本データ型の使用領域と値域 </p> 型 記号 使用領域 最小値 最大値 デフォルト値 整数 <code>byte</code> 1 バイト \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 バイト \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 バイト \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 バイト \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) 浮動小数点数 <code>float</code> 4 バイト \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 バイト \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) 文字 <code>char</code> 2 バイト \\(0\\) \\(2^{16} - 1\\) \\(0\\) 真偽値 <code>bool</code> 1 バイト \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>注意してください。上表は Java の基本データ型に対するものです。各プログラミング言語にはそれぞれ独自のデータ型定義があり、使用領域、値域、デフォルト値は異なる場合があります。</p> <ul> <li>Python では、整数型 <code>int</code> は利用可能なメモリに制限されるだけで任意の大きさを取れます。浮動小数点数 <code>float</code> は倍精度 64 ビットです。<code>char</code> 型はなく、1 文字は実際には長さ 1 の文字列 <code>str</code> です。</li> <li>C と C++ では基本データ型の大きさは明確に規定されておらず、実装やプラットフォームによって異なります。上表は LP64 データモデル に従っており、Linux や macOS を含む Unix 系 64 ビット OS で用いられています。</li> <li><code>char</code> の大きさは C と C++ では 1 バイトですが、多くのプログラミング言語では採用する文字エンコーディング方式によって決まります。詳しくは「文字エンコーディング」の章を参照してください。</li> <li>真偽値を表すのに必要なのは 1 ビット（\\(0\\) または \\(1\\)）だけですが、メモリ上では通常 1 バイトとして格納されます。これは、現代のコンピュータ CPU が通常 1 バイトを最小のアドレス指定可能なメモリ単位としているためです。</li> </ul> <p>では、基本データ型とデータ構造の間にはどのような関係があるのでしょうか。データ構造とは、コンピュータ内でデータを組織し格納する方法のことです。この言葉で主役なのは「データ」ではなく「構造」です。</p> <p>「数字の並び」を表したいなら、自然に配列の使用を思い浮かべるでしょう。これは、配列の線形構造が数字どうしの隣接関係や順序関係を表せるからです。しかし、格納する内容が整数 <code>int</code> なのか、小数 <code>float</code> なのか、文字 <code>char</code> なのかは、「データ構造」とは関係ありません。</p> <p>言い換えると、基本データ型はデータの「内容の型」を提供し、データ構造はデータの「組織方法」を提供します。たとえば次のコードでは、同じデータ構造（配列）を使って <code>int</code>、<code>float</code>、<code>char</code>、<code>bool</code> など異なる基本データ型を格納・表現しています。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># さまざまな基本データ型で配列を初期化する\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python の文字は実際には長さ 1 の文字列\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python のリストはさまざまな基本データ型とオブジェクト参照を自由に格納できる\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript の配列はさまざまな基本データ型とオブジェクトを自由に格納できる\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// さまざまな基本データ型で配列を初期化する\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby のリストはさまざまな基本データ型とオブジェクト参照を自由に格納できる\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E4%BD%BF%E7%94%A8%E5%A4%9A%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20*%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%AD%97%E7%AC%A6%E5%AE%9E%E9%99%85%E4%B8%8A%E6%98%AF%E9%95%BF%E5%BA%A6%E4%B8%BA%201%20%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2%0A%20%20%20%20characters%20%3D%20%5B'0'%5D%20*%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20*%205%0A%20%20%20%20%23%20Python%20%E7%9A%84%E5%88%97%E8%A1%A8%E5%8F%AF%E4%BB%A5%E8%87%AA%E7%94%B1%E5%AD%98%E5%82%A8%E5%90%84%E7%A7%8D%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%AF%B9%E8%B1%A1%E5%BC%95%E7%94%A8%0A%20%20%20%20data%20%3D%20%5B0,%200.0,%20'a',%20False,%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 3 章 &nbsp; データ構造","3.2 &nbsp; 基本データ型"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   文字エンコーディング *","text":"<p>コンピュータでは、すべてのデータは二進数の形で保存されており、文字 <code>char</code> も例外ではありません。文字を表すためには、「文字セット」を定義し、各文字と二進数の間の一対一の対応関係を定める必要があります。文字セットがあれば、コンピュータは対応表を参照して二進数から文字への変換を行えます。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   ASCII 文字セット","text":"<p>ASCII コードは最も早く登場した文字セットで、その正式名称は American Standard Code for Information Interchange（米国標準情報交換コード）です。これは 7 ビットの二進数（1 バイトの下位 7 ビット）で 1 文字を表し、最大で 128 種類の異なる文字を表現できます。下図のように、ASCII コードには英字の大文字と小文字、数字 0 ~ 9、いくつかの句読点、そしていくつかの制御文字（改行やタブなど）が含まれます。</p> <p></p> <p> 図 3-6   ASCII コード </p> <p>しかし、ASCII コードで表現できるのは英語だけです。コンピュータのグローバル化に伴い、より多くの言語を表せる EASCII 文字セットが生まれました。これは ASCII の 7 ビットを 8 ビットへ拡張したもので、256 種類の異なる文字を表現できます。</p> <p>世界では、さまざまな地域に適した EASCII 文字セットが次々に登場しました。これらの文字セットでは、前半の 128 文字は ASCII コードで統一され、後半の 128 文字は各言語の要件に合わせて個別に定義されています。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   GBK 文字セット","text":"<p>その後、人々は**EASCII コードでも多くの言語に必要な文字数を満たせない**ことに気づきました。たとえば漢字は 10 万字近くあり、日常的に使うものだけでも数千字あります。中国国家標準総局は 1980 年に GB2312 文字セットを公開し、6763 字の漢字を収録して、漢字のコンピュータ処理の基本的な需要を満たしました。</p> <p>しかし、GB2312 では一部の珍しい字や繁体字を扱えません。GBK 文字セットは GB2312 を基に拡張されたもので、合計 21886 字の漢字を収録しています。GBK のエンコーディング方式では、ASCII 文字は 1 バイト、漢字は 2 バイトで表されます。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Unicode 文字セット","text":"<p>コンピュータ技術が急速に発展するにつれて、文字セットと符号化規格は百花繚乱の状態となり、それに伴って多くの問題も生じました。一方では、これらの文字セットは通常、特定の言語の文字しか定義しておらず、多言語環境では正常に動作できませんでした。もう一方では、同じ言語にも複数の文字セット規格が存在し、2 台のコンピュータが異なる符号化規格を使っていると、情報伝達の際に文字化けが発生しました。</p> <p>当時の研究者たちはこう考えました。十分に完全な文字セットを打ち出して、世界中のあらゆる言語と記号をそこに収録すれば、多言語環境や文字化けの問題を解決できるのではないか。この発想に後押しされて、大規模で包括的な文字セット Unicode が誕生しました。</p> <p>Unicode の中国語名は「統一コード」であり、理論上は 100 万を超える文字を収容できます。Unicode は世界中の文字を 1 つの文字セットに統合することを目指し、さまざまな言語の文字を処理・表示できる汎用文字セットを提供することで、符号化規格の違いによる文字化けを減らそうとしています。</p> <p>1991 年の公開以来、Unicode は新しい言語と文字を継続的に拡充してきました。2022 年 9 月時点で、Unicode にはすでに 149186 文字が含まれており、各種言語の文字、記号、さらには絵文字まで収録されています。巨大な Unicode 文字セットでは、よく使われる文字は 2 バイトを占め、一部の珍しい文字は 3 バイト、さらには 4 バイトを占めます。</p> <p>Unicode は汎用文字セットであり、本質的には各文字に番号（「コードポイント」）を割り当てるものですが、それらのコードポイントをコンピュータ内でどのように保存するかまでは規定していません。ここで疑問が生じます。長さの異なる Unicode コードポイントが同じテキストに現れたとき、システムはどのように文字を解析するのでしょうか。たとえば長さ 2 バイトの符号が与えられたとき、それが 2 バイトの 1 文字なのか、1 バイトの 2 文字なのかをどう判定するのでしょうか。</p> <p>この問題に対して、**すべての文字を固定長の符号として保存する**という直接的な解決策があります。下図のように、「Hello」の各文字は 1 バイト、「アルゴリズム」の各文字は 2 バイトを占めます。上位ビットを 0 で埋めることで、「Hello アルゴリズム」のすべての文字を 2 バイト長にエンコードできます。こうすれば、システムは 2 バイトごとに 1 文字を解析して、この語句の内容を復元できます。</p> <p></p> <p> 図 3-7   Unicode エンコーディングの例 </p> <p>しかし ASCII コードはすでに、英語の符号化には 1 バイトで十分であることを示しています。上記の方式を採用すると、英語のテキストが占める空間は ASCII エンコーディング時の 2 倍になり、メモリ空間の浪費が大きくなります。そのため、より効率的な Unicode エンコーディング方式が必要です。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   UTF-8 エンコーディング","text":"<p>現在、UTF-8 は国際的に最も広く使われている Unicode エンコーディング方式になっています。**これは可変長のエンコーディング**であり、1 文字を 1 〜 4 バイトで表し、文字の複雑さに応じて長さが変わります。ASCII 文字は 1 バイト、ラテン文字とギリシャ文字は 2 バイト、一般的な漢字は 3 バイト、そのほかの一部の珍しい文字は 4 バイト必要です。</p> <p>UTF-8 の符号化規則はそれほど複雑ではなく、次の 2 つのケースに分けられます。</p> <ul> <li>長さ 1 バイトの文字では、最上位ビットを \\(0\\) にし、残りの 7 ビットを Unicode コードポイントに設定します。ここで注意すべきなのは、ASCII 文字が Unicode 文字セットの先頭 128 個のコードポイントを占めていることです。つまり、UTF-8 エンコーディングは ASCII コードと下位互換性があります。このため、UTF-8 を使って古い ASCII コードのテキストを解析できます。</li> <li>長さ \\(n\\) バイトの文字（ただし \\(n &gt; 1\\)）では、先頭バイトの上位 \\(n\\) ビットをすべて \\(1\\) にし、第 \\(n + 1\\) ビットを \\(0\\) に設定します。2 バイト目以降では、各バイトの上位 2 ビットをいずれも \\(10\\) にし、残りのすべてのビットで文字の Unicode コードポイントを埋めます。</li> </ul> <p>下図は「Helloアルゴリズム」に対応する UTF-8 エンコーディングを示しています。観察すると、上位 \\(n\\) ビットがすべて \\(1\\) に設定されているため、システムは先頭から連続する \\(1\\) の個数を読むことで、その文字の長さが \\(n\\) であると解析できます。</p> <p>では、なぜ残りのすべてのバイトの上位 2 ビットを \\(10\\) にするのでしょうか。実は、この \\(10\\) は検査用の印として機能します。システムが誤ったバイト位置からテキストを解析し始めたとしても、バイト先頭の \\(10\\) によって異常を素早く判定できます。</p> <p>この \\(10\\) を検査用の印とする理由は、UTF-8 の符号化規則では上位 2 ビットが \\(10\\) になる文字は存在しないからです。この結論は背理法で証明できます。ある文字の上位 2 ビットが \\(10\\) だと仮定すると、その文字の長さは \\(1\\) であり、ASCII コードに対応することになります。しかし ASCII コードの最上位ビットは \\(0\\) であるはずなので、仮定と矛盾します。</p> <p></p> <p> 図 3-8   UTF-8 エンコーディングの例 </p> <p>UTF-8 以外にも、一般的なエンコーディング方式として次の 2 つがあります。</p> <ul> <li>UTF-16 エンコーディング：1 文字を 2 バイトまたは 4 バイトで表します。すべての ASCII 文字と一般的な非英語文字は 2 バイトで表し、一部の文字だけが 4 バイトを必要とします。2 バイトの文字については、UTF-16 エンコーディングは Unicode コードポイントと等しくなります。</li> <li>UTF-32 エンコーディング：各文字を必ず 4 バイトで表します。つまり UTF-32 は UTF-8 や UTF-16 よりも多くの領域を消費し、とくに ASCII 文字の比率が高いテキストでその傾向が顕著です。</li> </ul> <p>記憶領域の使用量という観点では、UTF-8 は英語文字の表現に非常に効率的で、必要なのは 1 バイトだけです。一方、UTF-16 は一部の非英語文字（たとえば中国語の文字）の符号化でより効率的になることがあり、必要なのは 2 バイトだけで、UTF-8 では 3 バイト必要になる場合があります。</p> <p>互換性という観点では、UTF-8 の汎用性が最も高く、多くのツールやライブラリが UTF-8 を優先的にサポートしています。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   プログラミング言語の文字エンコーディング","text":"<p>従来の多くのプログラミング言語では、実行中の文字列に UTF-16 や UTF-32 のような固定長エンコーディングが使われています。固定長エンコーディングでは、文字列を配列のように扱えるため、次のような利点があります。</p> <ul> <li>ランダムアクセス：UTF-16 で符号化された文字列はランダムアクセスが容易です。UTF-8 は可変長エンコーディングなので、第 \\(i\\) 文字を見つけるには文字列の先頭から第 \\(i\\) 文字まで走査する必要があり、\\(O(n)\\) の時間がかかります。</li> <li>文字数の計算：ランダムアクセスと同様に、UTF-16 で符号化された文字列の長さを計算するのも \\(O(1)\\) の操作です。しかし、UTF-8 で符号化された文字列の長さを計算するには、文字列全体を走査する必要があります。</li> <li>文字列操作：UTF-16 で符号化された文字列では、多くの文字列操作（分割、連結、挿入、削除など）をより簡単に行えます。UTF-8 で符号化された文字列では、これらの操作を行う際に、無効な UTF-8 エンコーディングを生じさせないための追加計算が通常必要になります。</li> </ul> <p>実際、プログラミング言語における文字エンコーディング方式の設計は、とても興味深い話題であり、多くの要因が関わっています。</p> <ul> <li>Java の <code>String</code> 型は UTF-16 エンコーディングを使用し、各文字は 2 バイトを占めます。これは Java 言語の設計当初、人々が 16 ビットあればあらゆる文字を表現するのに十分だと考えていたためです。しかし、これは誤った判断でした。その後 Unicode 規格は 16 ビットを超える範囲へ拡張されたため、現在の Java では 1 文字が 16 ビット値の組（「サロゲートペア」）で表されることがあります。</li> <li>JavaScript と TypeScript の文字列が UTF-16 エンコーディングを使う理由も Java と似ています。1995 年に Netscape 社が初めて JavaScript 言語を公開した当時、Unicode はまだ発展初期にあり、16 ビットの符号化で十分すべての Unicode 文字を表せると考えられていました。</li> <li>C# が UTF-16 エンコーディングを使う主な理由は、.NET プラットフォームが Microsoft によって設計され、Microsoft の多くの技術（Windows オペレーティングシステムを含む）で UTF-16 エンコーディングが広く使われているためです。</li> </ul> <p>以上のプログラミング言語は文字数を過小評価していたため、16 ビットを超える長さの Unicode 文字を表すために「サロゲートペア」を採用せざるを得ませんでした。これはやむを得ない妥協策です。一方では、サロゲートペアを含む文字列では、1 文字が 2 バイトまたは 4 バイトを占める可能性があり、固定長エンコーディングの利点が失われます。もう一方では、サロゲートペアの処理には追加のコードが必要となり、プログラミングの複雑さとデバッグの難しさが増します。</p> <p>こうした理由から、一部のプログラミング言語では別のエンコーディング方式が採用されました。</p> <ul> <li>Python の <code>str</code> は Unicode エンコーディングを使用し、柔軟な文字列表現を採用しています。保存される文字の長さは、その文字列中で最大の Unicode コードポイントに依存します。文字列がすべて ASCII 文字であれば各文字は 1 バイト、ASCII の範囲を超える文字があってもすべてが基本多言語面（BMP）内であれば各文字は 2 バイト、BMP を超える文字があれば各文字は 4 バイトを占めます。</li> <li>Go 言語の <code>string</code> 型は内部で UTF-8 エンコーディングを使用します。Go 言語には単一の Unicode コードポイントを表す <code>rune</code> 型も用意されています。</li> <li>Rust 言語の <code>str</code> と <code>String</code> 型は内部で UTF-8 エンコーディングを使用します。Rust にも単一の Unicode コードポイントを表す <code>char</code> 型があります。</li> </ul> <p>注意すべきなのは、ここまでの議論はすべて、プログラミング言語内での文字列の保存方法についてであり、**文字列をファイルに保存したりネットワークで転送したりする方法とは別の問題である**ということです。ファイル保存やネットワーク転送では、通常、互換性と空間効率を最適化するために文字列を UTF-8 形式にエンコードします。</p>","path":["第 3 章 &nbsp; データ構造","3.4 &nbsp; 文字エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   データ構造の分類","text":"<p>代表的なデータ構造には、配列、連結リスト、スタック、キュー、ハッシュテーブル、木、ヒープ、グラフがあり、これらは「論理構造」と「物理構造」の 2 つの観点から分類できます。</p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   論理構造：線形と非線形","text":"<p>論理構造はデータ要素間の論理的な関係を示します。配列と連結リストでは、データは一定の順序で並び、データ間の線形関係を表します。一方、木ではデータは上から下へ階層的に並び、「祖先」と「子孫」の派生関係を示します。グラフはノードと辺で構成され、複雑なネットワーク関係を反映します。</p> <p>以下の図に示すように、論理構造は「線形」と「非線形」の 2 つに大別できます。線形構造は比較的直感的で、データが論理関係において線形に並ぶことを指します。非線形構造はその逆で、非線形に配置されます。</p> <ul> <li>線形データ構造：配列、連結リスト、スタック、キュー、ハッシュテーブルであり、要素間は 1 対 1 の順序関係です。</li> <li>非線形データ構造：木、ヒープ、グラフ、ハッシュテーブル。</li> </ul> <p>非線形データ構造は、さらに木構造と網状構造に分けられます。</p> <ul> <li>木構造：木、ヒープ、ハッシュテーブルであり、要素間は 1 対多の関係です。</li> <li>網状構造：グラフであり、要素間は多対多の関係です。</li> </ul> <p></p> <p> 図 3-1   線形データ構造と非線形データ構造 </p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   物理構造：連続と分散","text":"<p>アルゴリズムのプログラムが実行されるとき、処理中のデータは主にメモリに格納されます。下図はコンピュータのメモリモジュールを示しており、各黒い四角はそれぞれ 1 つのメモリ空間を表しています。メモリは巨大な Excel の表のようなものだと考えることができ、各セルには一定量のデータを格納できます。</p> <p>システムはメモリアドレスを通じて目的の位置にあるデータへアクセスします。下図に示すように、コンピュータは特定の規則に従って表内の各セルに番号を割り当て、各メモリ空間が一意のメモリアドレスを持つようにします。これらのアドレスがあれば、プログラムはメモリ内のデータにアクセスできます。</p> <p></p> <p> 図 3-2   メモリモジュール、メモリ空間、メモリアドレス </p> <p>Tip</p> <p>補足すると、メモリを Excel の表にたとえるのは単純化した比喩であり、実際のメモリの動作機構はより複雑で、アドレス空間、メモリ管理、キャッシュ機構、仮想メモリ、物理メモリなどの概念が関わります。</p> <p>メモリはすべてのプログラムで共有される資源であり、あるメモリ領域が 1 つのプログラムに占有されると、通常は他のプログラムが同時に利用できません。したがって、データ構造とアルゴリズムの設計では、メモリ資源は重要な考慮要素です。たとえば、アルゴリズムが使用するメモリ使用量のピークは、システムに残っている空きメモリを超えてはなりません。大きな連続メモリ領域が不足している場合、選択するデータ構造は分散したメモリ空間に格納できる必要があります。</p> <p>下図に示すように、物理構造はデータがコンピュータメモリ内にどのように格納されるかを表します。これは連続空間への格納（配列）と分散空間への格納（連結リスト）に分けられます。物理構造は低レベルでデータのアクセス、更新、追加、削除などの操作方法を決定し、2 種類の物理構造は時間効率と空間効率の面で相補的な特徴を持ちます。</p> <p></p> <p> 図 3-3   連続空間格納と分散空間格納 </p> <p>補足すると、すべてのデータ構造は配列、連結リスト、またはその両者の組み合わせに基づいて実装されます。たとえば、スタックとキューは配列でも連結リストでも実装できます。一方、ハッシュテーブルの実装には配列と連結リストの両方が含まれる場合があります。</p> <ul> <li>配列に基づいて実装可能：スタック、キュー、ハッシュテーブル、木、ヒープ、グラフ、行列、テンソル（次元 \\(\\geq 3\\) の配列）など。</li> <li>連結リストに基づいて実装可能：スタック、キュー、ハッシュテーブル、木、ヒープ、グラフなど。</li> </ul> <p>連結リストは初期化後も、プログラムの実行中に長さを調整できるため、「動的データ構造」とも呼ばれます。配列は初期化後に長さを変更できないため、「静的データ構造」とも呼ばれます。なお、配列もメモリを再割り当てすることで長さを変更でき、ある程度の「動的性」を持たせることができます。</p> <p>Tip</p> <p>物理構造の理解が難しいと感じる場合は、先に次の章を読んでから本節を振り返ることを勧めます。</p>","path":["第 3 章 &nbsp; データ構造","3.1 &nbsp; データ構造の分類"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   数値エンコーディング *","text":"<p>Tip</p> <p>本書では、タイトルに * 記号が付いている章は選読です。時間が限られている場合や理解が難しいと感じる場合は、いったん読み飛ばし、必読章を終えてから個別に取り組んでください。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331-1-2","level":2,"title":"3.3.1   符号付き絶対値表現、1 の補数、2 の補数","text":"<p>前節の表を見ると、すべての整数型で表せる負数の個数は正数より 1 つ多く、たとえば <code>byte</code> の値域は \\([-128, 127]\\) です。この現象は直感に反するように見えますが、その背景には符号付き絶対値表現、1 の補数、2 の補数に関する知識があります。</p> <p>まず押さえておくべきなのは、**数値はコンピュータ内で「2 の補数」の形で保存される**ということです。その理由を説明する前に、まずはこの 3 つの定義を示します。</p> <ul> <li>符号付き絶対値表現：数値の二進表現の最上位ビットを符号ビットとみなし、\\(0\\) は正数、\\(1\\) は負数を表し、残りのビットが数値の値を表します。</li> <li>1 の補数：正数の 1 の補数は符号付き絶対値表現と同じで、負数の 1 の補数は符号ビットを除くすべてのビットを反転したものです。</li> <li>2 の補数：正数の 2 の補数は符号付き絶対値表現と同じで、負数の 2 の補数は 1 の補数に \\(1\\) を加えたものです。</li> </ul> <p>下図は、符号付き絶対値表現、1 の補数、2 の補数の変換方法を示しています。</p> <p></p> <p> 図 3-4   符号付き絶対値表現、1 の補数、2 の補数の相互変換 </p> <p>符号付き絶対値表現（sign-magnitude）は最も直感的ですが、いくつかの制約があります。まず、負数の符号付き絶対値表現はそのまま演算に使えません。たとえば符号付き絶対値表現で \\(1 + (-2)\\) を計算すると、結果は \\(-3\\) になってしまい、これは明らかに誤りです。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>この問題を解決するために、コンピュータには1 の補数（1's complement）が導入されました。まず符号付き絶対値表現を 1 の補数に変換し、1 の補数で \\(1 + (-2)\\) を計算してから、結果を 1 の補数から符号付き絶対値表現へ戻すと、正しい結果 \\(-1\\) が得られます。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(符号付き絶対値表現)} + 1000 \\; 0010 \\; \\text{(符号付き絶対値表現)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(1 の補数)} + 1111  \\; 1101 \\; \\text{(1 の補数)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(1 の補数)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(符号付き絶対値表現)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>一方、数値 0 の符号付き絶対値表現には \\(+0\\) と \\(-0\\) の 2 つの表し方があります。つまり、数値 0 に対して異なる 2 つの二進コードが対応しており、これは曖昧さの原因になります。たとえば条件判定で正のゼロと負のゼロを区別しないと、誤った判定結果になる可能性があります。また、この曖昧さを解消しようとすると追加の判定処理が必要になり、計算効率が下がるおそれがあります。</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>符号付き絶対値表現と同様に、1 の補数にも正負のゼロの曖昧さがあります。そこでコンピュータはさらに2 の補数（2's complement）を導入しました。まずは負のゼロについて、符号付き絶対値表現、1 の補数、2 の補数の変換を見てみましょう。</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(符号付き絶対値表現)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(1 の補数)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(2 の補数)} \\newline \\end{aligned} \\] <p>負のゼロの 1 の補数に \\(1\\) を加えると桁上がりが発生しますが、<code>byte</code> 型の長さは 8 ビットしかないため、第 9 ビットへあふれた \\(1\\) は捨てられます。つまり、負のゼロの 2 の補数は \\(0000 \\; 0000\\) であり、正のゼロの 2 の補数と同じです。そのため、2 の補数表現ではゼロは 1 つしか存在せず、正負のゼロの曖昧さは解消されます。</p> <p>最後にもう 1 つ疑問が残ります。<code>byte</code> 型の値域は \\([-128, 127]\\) ですが、余分にある負数 \\(-128\\) はどのように得られるのでしょうか。区間 \\([-127, +127]\\) にあるすべての整数には、それぞれ対応する符号付き絶対値表現、1 の補数、2 の補数があり、符号付き絶対値表現と 2 の補数の間は相互に変換できます。</p> <p>しかし、2 の補数 \\(1000 \\; 0000\\) だけは例外で、対応する符号付き絶対値表現を持ちません。変換規則に従うと、この 2 の補数に対応する符号付き絶対値表現は \\(0000 \\; 0000\\) になります。これは明らかに矛盾しています。なぜなら、この符号付き絶対値表現は数値 \\(0\\) を表し、その 2 の補数は自分自身であるはずだからです。コンピュータでは、この特別な 2 の補数 \\(1000 \\; 0000\\) を \\(-128\\) と定めています。実際、2 の補数での \\((-1) + (-127)\\) の計算結果はちょうど \\(-128\\) になります。</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(符号付き絶対値表現)} + 1000 \\; 0001 \\; \\text{(符号付き絶対値表現)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(1 の補数)} + 1111  \\; 1110 \\; \\text{(1 の補数)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(2 の補数)} + 1111  \\; 1111 \\; \\text{(2 の補数)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(2 の補数)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>すでにお気づきかもしれませんが、上の計算はすべて加算です。これは重要な事実を示しています。**コンピュータ内部のハードウェア回路は、主として加算を基準に設計されている**のです。なぜなら、加算はほかの演算（乗算、除算、減算など）に比べてハードウェアで実装しやすく、並列化もしやすく、演算速度も速いからです。</p> <p>ただし、これはコンピュータが加算しかできないという意味ではありません。加算といくつかの基本的な論理演算を組み合わせることで、コンピュータはさまざまな数学演算を実現できます。たとえば減算 \\(a - b\\) は加算 \\(a + (-b)\\) に変換できますし、乗算や除算も繰り返しの加算または減算に変換できます。</p> <p>これで、コンピュータが 2 の補数を使う理由をまとめられます。2 の補数表現に基づけば、コンピュータは同じ回路と操作で正数と負数の加算を扱うことができ、減算専用の特別なハードウェア回路を設計する必要がなく、正負のゼロの曖昧さも特別に処理しなくて済みます。これにより、ハードウェア設計は大幅に簡略化され、演算効率も向上します。</p> <p>2 の補数の設計は非常に巧妙ですが、紙幅の都合上ここまでにします。興味のある読者は、さらに深く調べてみてください。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   浮動小数点数のエンコーディング","text":"<p>注意深い人なら気づくかもしれません。<code>int</code> と <code>float</code> はどちらも長さが 4 バイトで同じなのに、なぜ <code>float</code> の値域は <code>int</code> よりはるかに広いのでしょうか。これはかなり直感に反します。というのも、<code>float</code> は小数を表す必要があるので、本来なら値域は狭くなるはずだからです。</p> <p>実際には、これは浮動小数点数 <code>float</code> が異なる表現方法を採用しているためです。32 ビット長の二進数を次のように表します。</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>IEEE 754 標準によれば、32-bit 長の <code>float</code> は次の 3 つの部分から構成されます。</p> <ul> <li>符号部 \\(\\mathrm{S}\\) ：1 ビットを占め、\\(b_{31}\\) に対応します。</li> <li>指数部 \\(\\mathrm{E}\\) ：8 ビットを占め、\\(b_{30} b_{29} \\ldots b_{23}\\) に対応します。</li> <li>仮数部 \\(\\mathrm{N}\\) ：23 ビットを占め、\\(b_{22} b_{21} \\ldots b_0\\) に対応します。</li> </ul> <p>二進数 <code>float</code> に対応する値は次式で計算されます。</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>十進数に直すと、計算式は次のようになります。</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>各項の取り得る範囲は次のとおりです。</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> 図 3-5   IEEE 754 標準における float の計算例 </p> <p>上図を見ると、例として \\(\\mathrm{S} = 0\\) 、 \\(\\mathrm{E} = 124\\) 、\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) が与えられた場合、次のようになります。</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>これで最初の疑問に答えられます。**<code>float</code> の表現方法には指数部が含まれているため、その値域は <code>int</code> よりはるかに広い**のです。上の計算より、<code>float</code> が表せる最大の正数は \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) であり、符号ビットを切り替えれば最小の負数が得られます。</p> <p>浮動小数点数 <code>float</code> は値域を広げる一方で、その代償として精度を犠牲にしています。整数型 <code>int</code> は 32 ビットすべてを数値の表現に使うため、数値は一様に分布します。しかし指数部があるため、浮動小数点数 <code>float</code> は値が大きくなるほど、隣り合う 2 つの数の差も大きくなる傾向があります。</p> <p>次の表のとおり、指数部 \\(\\mathrm{E} = 0\\) と \\(\\mathrm{E} = 255\\) には特別な意味があり、ゼロ、無限大、\\(\\mathrm{NaN}\\) などを表すために使われます。</p> <p> 表 3-2   指数部の意味 </p> 指数部 E 仮数部 \\(\\mathrm{N} = 0\\) 仮数部 \\(\\mathrm{N} \\ne 0\\) 計算式 \\(0\\) \\(\\pm 0\\) 非正規化数 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) 正規化数 正規化数 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>なお、非正規化数によって浮動小数点数の精度は大きく向上します。最小の正の正規化数は \\(2^{-126}\\) であり、最小の正の非正規化数は \\(2^{-126} \\times 2^{-23}\\) です。</p> <p>倍精度 <code>double</code> も <code>float</code> と同様の表現方法を採用しているため、ここでは詳述しません。</p>","path":["第 3 章 &nbsp; データ構造","3.3 &nbsp; 数値エンコーディング *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   まとめ","text":"","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li>データ構造は、論理構造と物理構造という 2 つの観点から分類できます。論理構造はデータ要素間の論理的関係を記述し、物理構造はデータのコンピュータメモリ上での格納方法を記述します。</li> <li>代表的な論理構造には、線形、木構造、網状構造などがあります。通常、論理構造に基づいてデータ構造を線形（配列、連結リスト、スタック、キュー）と非線形（木、グラフ、ヒープ）の 2 種類に分類します。ハッシュテーブルの実装には、線形データ構造と非線形データ構造が同時に含まれる場合があります。</li> <li>プログラムの実行時、データはコンピュータメモリに格納されます。各メモリ空間には対応するメモリアドレスがあり、プログラムはそれらのメモリアドレスを通じてデータにアクセスします。</li> <li>物理構造は主に連続領域への格納（配列）と分散領域への格納（連結リスト）に分けられます。すべてのデータ構造は、配列、連結リスト、またはその両方の組み合わせによって実装されます。</li> <li>コンピュータにおける基本データ型には、整数 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code>、浮動小数点数 <code>float</code>、<code>double</code>、文字 <code>char</code>、真偽値 <code>bool</code> があります。これらの値域は、使用する記憶領域の大きさと表現方式によって決まります。</li> <li>符号付き絶対値表現、1 の補数、2 の補数は、コンピュータで数値を符号化する 3 つの方法であり、相互に変換できます。整数の符号付き絶対値表現では最上位ビットが符号ビットで、残りのビットが数値の値です。</li> <li>整数はコンピュータ内では 2 の補数の形式で格納されます。2 の補数表現では、コンピュータは正数と負数の加算を同じように扱うことができ、減算のために特別なハードウェア回路を別途設計する必要がなく、さらに正負のゼロが重複する問題もありません。</li> <li>浮動小数点数の符号化は、1 ビットの符号部、8 ビットの指数部、23 ビットの仮数部で構成されます。指数部があるため、浮動小数点数の値域は整数よりはるかに広くなりますが、その代償として精度が犠牲になります。</li> <li>ASCII コードは最も早く登場した英字文字集合で、長さは 1 バイト、収録文字数は 127 です。GBK 文字集合はよく使われる中国語文字集合で、2 万字以上の漢字を収録しています。Unicode は完全な文字集合標準を提供することを目指しており、世界中のさまざまな言語の文字を収録することで、文字コード方式の不一致によって生じる文字化けの問題を解決します。</li> <li>UTF-8 は最も広く使われている Unicode の符号化方式で、汎用性が非常に高いです。可変長の符号化方式であり、拡張性に優れ、記憶領域の利用効率を効果的に高めます。UTF-16 と UTF-32 は固定長の符号化方式です。中国語を符号化する場合、UTF-16 は UTF-8 よりも使用領域が小さくなります。Java や C# などのプログラミング言語は、デフォルトで UTF-16 を使用します。</li> </ul>","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：なぜハッシュテーブルには線形データ構造と非線形データ構造が同時に含まれるのですか？</p> <p>ハッシュテーブルの基盤は配列であり、ハッシュ衝突を解決するために「チェイン法」（後続の「ハッシュ衝突」の章で説明します）を使うことがあります。配列内の各バケットは 1 つの連結リストを指し、その連結リストの長さがある閾値を超えると、木（通常は赤黒木）に変換されることもあります。</p> <p>格納の観点から見ると、ハッシュテーブルの基盤は配列であり、各バケットスロットには値が入ることもあれば、連結リストや木が入ることもあります。したがって、ハッシュテーブルには線形データ構造（配列、連結リスト）と非線形データ構造（木）が同時に含まれる場合があります。</p> <p>Q：<code>char</code> 型の長さは 1 バイトですか？</p> <p><code>char</code> 型の長さは、プログラミング言語が採用する符号化方式によって決まります。たとえば、Java、JavaScript、TypeScript、C# はいずれも UTF-16 符号化（Unicode コードポイントを保持）を採用しているため、<code>char</code> 型の長さは 2 バイトです。</p> <p>Q：配列ベースで実装されたデータ構造を「静的データ構造」と呼ぶのは曖昧ではありませんか？ スタックも push や pop などの操作ができ、これらの操作はどれも「動的」です。</p> <p>スタックは確かに動的なデータ操作を実現できますが、データ構造自体は依然として「静的」（長さが不変）です。配列ベースのデータ構造でも要素を動的に追加または削除できますが、その容量は固定です。データ量が事前に確保した大きさを超えた場合は、より大きな新しい配列を作成し、古い配列の内容を新しい配列にコピーする必要があります。</p> <p>Q：スタック（キュー）を構築するときにサイズを指定していないのに、なぜそれらは「静的データ構造」なのですか？</p> <p>高水準プログラミング言語では、スタック（キュー）の初期容量を人手で指定する必要はなく、この作業はクラス内部で自動的に行われます。たとえば、Java の <code>ArrayList</code> の初期容量は通常 10 です。また、容量拡張も自動的に実装されています。詳しくは後続の「リスト」の章を参照してください。</p> <p>Q：符号付き絶対値表現から 2 の補数への変換方法は「先にビット反転してから 1 を加える」ですが、2 の補数から符号付き絶対値表現への変換は逆演算である「先に 1 を引いてからビット反転する」べきなのに、同じく「先にビット反転してから 1 を加える」でも求められます。これはなぜですか？</p> <p>これは、符号付き絶対値表現と 2 の補数の相互変換が、実際には「補数」を計算する過程だからです。まず補数の定義を示します。\\(a + b = c\\) とすると、\\(a\\) を \\(b\\) から \\(c\\) への補数と呼び、逆に \\(b\\) も \\(a\\) から \\(c\\) への補数と呼びます。</p> <p>長さ \\(n = 4\\) ビットの 2 進数 \\(0010\\) が与えられたとします。この数を符号付き絶対値表現（符号ビットは考慮しない）とみなすと、その 2 の補数は「先にビット反転してから 1 を加える」ことで得られます。</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>ここで、符号付き絶対値表現と 2 の補数の和は \\(0010 + 1110 = 10000\\) となります。つまり、2 の補数 \\(1110\\) は符号付き絶対値表現 \\(0010\\) から \\(10000\\) への「補数」です。これは、上記の「先にビット反転してから 1 を加える」が、実際には \\(10000\\) への補数を計算する過程であることを意味します。</p> <p>では、2 の補数 \\(1110\\) から \\(10000\\) への「補数」はいくつでしょうか。これもやはり「先にビット反転してから 1 を加える」ことで求められます。</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>言い換えると、符号付き絶対値表現と 2 の補数は互いに相手から \\(10000\\) への「補数」なので、「符号付き絶対値表現から 2 の補数への変換」と「2 の補数から符号付き絶対値表現への変換」は同じ操作（先にビット反転してから 1 を加える）で実現できます。</p> <p>もちろん、逆演算を用いて 2 の補数 \\(1110\\) の符号付き絶対値表現を求めることもでき、その場合は「先に 1 を引いてからビット反転する」ことになります。</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>まとめると、「先にビット反転してから 1 を加える」と「先に 1 を引いてからビット反転する」の 2 つの演算は、どちらも \\(10000\\) への補数を計算しており、等価です。</p> <p>本質的には、「ビット反転」という操作は実際には \\(1111\\) への補数を求めています（常に <code>符号付き絶対値表現 + 1 の補数 = 1111</code> が成り立つため）。そして、1 の補数にさらに 1 を加えて得られる 2 の補数が、\\(10000\\) への補数です。</p> <p>上記では \\(n = 4\\) を例にしましたが、この考え方は任意のビット長の 2 進数に一般化できます。</p>","path":["第 3 章 &nbsp; データ構造","3.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"第 12 章   分割統治","text":"<p>Abstract</p> <p>難題は段階的に分解され、そのたびにより単純になっていく。</p> <p>分割統治は一つの重要な事実を示している。単純なことから始めれば、すべてはもはや複雑ではない。</p>","path":["第 12 章 &nbsp; 分割統治"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"章の内容","text":"<ul> <li>12.1   分割統治法</li> <li>12.2   分割統治探索戦略</li> <li>12.3   二分木の構築問題</li> <li>12.4   ハノイの塔の問題</li> <li>12.5   まとめ</li> </ul>","path":["第 12 章 &nbsp; 分割統治"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   分割統治探索戦略","text":"<p>私たちはすでに学んだように、探索アルゴリズムは大きく二つに分けられる。</p> <ul> <li>力ずく探索：データ構造を走査することで実現され、時間計算量は \\(O(n)\\) である。</li> <li>適応的探索：固有のデータ構造や事前情報を利用し、時間計算量は \\(O(\\log n)\\) 、さらには \\(O(1)\\) に達しうる。</li> </ul> <p>実際、時間計算量が \\(O(\\log n)\\) の探索アルゴリズムは通常、分割統治戦略に基づいて実装される。たとえば二分探索や木構造である。</p> <ul> <li>二分探索の各ステップでは、問題（配列内で目標要素を探索すること）を小さな問題（配列の半分で目標要素を探索すること）に分解し、この過程は配列が空になるか目標要素が見つかるまで続く。</li> <li>木構造は分割統治の考え方を代表するものであり、二分探索木、AVL 木、ヒープなどのデータ構造では、さまざまな操作の時間計算量はいずれも \\(O(\\log n)\\) である。</li> </ul> <p>二分探索の分割統治戦略は以下のとおりである。</p> <ul> <li>問題は分解できる：二分探索は、元の問題（配列内で探索すること）を部分問題（配列の半分で探索すること）へ再帰的に分解する。これは中央要素と目標要素を比較することで実現される。</li> <li>部分問題は独立している：二分探索では、各ラウンドで一つの部分問題だけを処理し、ほかの部分問題の影響を受けない。</li> <li>部分問題の解を統合する必要はない：二分探索は特定の要素を探すことを目的としているため、部分問題の解を統合する必要がない。部分問題が解決されると、元の問題も同時に解決される。</li> </ul> <p>分割統治が探索効率を高められる本質的な理由は、力ずく探索では各ラウンドで一つの候補しか除外できないのに対し、**分割統治による探索では各ラウンドで候補の半分を除外できる**からである。</p>","path":["第 12 章 &nbsp; 分割統治","12.2 &nbsp; 分割統治探索戦略"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   分割統治に基づく二分探索","text":"<p>前の章では、二分探索を漸化式（反復）に基づいて実装した。ここでは分割統治（再帰）に基づいてこれを実装する。</p> <p>Question</p> <p>長さ \\(n\\) の昇順配列 <code>nums</code> が与えられ、そのすべての要素は一意である。要素 <code>target</code> を探索せよ。</p> <p>分割統治の観点から、探索区間 \\([i, j]\\) に対応する部分問題を \\(f(i, j)\\) と記す。</p> <p>元の問題 \\(f(0, n-1)\\) を出発点として、次の手順で二分探索を行う。</p> <ol> <li>探索区間 \\([i, j]\\) の中点 \\(m\\) を計算し、それに基づいて探索区間の半分を除外する。</li> <li>規模が半分に縮小された部分問題を再帰的に解く。候補は \\(f(i, m-1)\\) または \\(f(m+1, j)\\) である。</li> <li><code>1.</code> と <code>2.</code> の手順を繰り返し、<code>target</code> が見つかるか区間が空になったら返す。</li> </ol> <p>次の図は、配列内で要素 \\(6\\) を二分探索する分割統治の過程を示している。</p> <p></p> <p> 図 12-4   二分探索の分割統治の過程 </p> <p>実装コードでは、再帰関数 <code>dfs()</code> を宣言して問題 \\(f(i, j)\\) を解く。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"二分探索：問題 f(i, j)\"\"\"\n    # 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j:\n        return -1\n    # 中点インデックス m を計算\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1)\n    else:\n        # 目標要素が見つかったらそのインデックスを返す\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索\"\"\"\n    n = len(nums)\n    # 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* 二分探索：問題 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // 問題 f(0, n-1) を解く\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* 二分探索：問題 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // 区間が空なら対象要素は存在しないため、-1 を返す\n    if i &gt; j {\n        return -1\n    }\n    // 中点インデックスを計算する\n    m := i + ((j - i) &gt;&gt; 1)\n    // 中点の要素と目標要素の大小を判定する\n    if nums[m] &lt; target {\n        // 小さければ右半分の配列を再帰\n        // 部分問題 f(m+1, j) を解く\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // 大きければ左半分の配列を再帰\n        // 部分問題 f(i, m-1) を解く\n        return dfs(nums, target, i, m-1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m\n    }\n}\n\n/* 二分探索 */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* 二分探索：問題 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j {\n        return -1\n    }\n    // 中点インデックス m を計算\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m\n    }\n}\n\n/* 二分探索 */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 問題 f(0, n-1) を解く\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* 二分探索：問題 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* 二分探索：問題 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // 区間が空なら対象要素は存在しないので -1 を返す\n  if (i &gt; j) {\n    return -1;\n  }\n  // 中点インデックス m を計算\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // 部分問題 f(m+1, j) を再帰的に解く\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // 部分問題 f(i, m-1) を再帰的に解く\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // 目標要素が見つかったらそのインデックスを返す\n    return m;\n  }\n}\n\n/* 二分探索 */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // 問題 f(0, n-1) を解く\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* 二分探索：問題 f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // 問題 f(0, n-1) を解く\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* 二分探索：問題 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1;\n    }\n    // 中点インデックス m を計算\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        return m;\n    }\n}\n\n/* 二分探索 */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* 二分探索：問題 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // 区間が空なら対象要素は存在しないので -1 を返す\n    if (i &gt; j) {\n        return -1\n    }\n    // 中点インデックス m を計算\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // 部分問題 f(m+1, j) を再帰的に解く\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // 部分問題 f(i, m-1) を再帰的に解く\n        dfs(nums, target, i, m - 1)\n    } else {\n        // 目標要素が見つかったらそのインデックスを返す\n        m\n    }\n}\n\n/* 二分探索 */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // 問題 f(0, n-1) を解く\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### 二分探索: 問題 f(i, j) ###\ndef dfs(nums, target, i, j)\n  # 区間が空なら対象要素は存在しないので -1 を返す\n  return -1 if i &gt; j\n\n  # 中点インデックス m を計算\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # 部分問題 f(m+1, j) を再帰的に解く\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # 部分問題 f(i, m-1) を再帰的に解く\n    return dfs(nums, target, i, m - 1)\n  else\n    # 目標要素が見つかったらそのインデックスを返す\n    return m\n  end\nend\n\n### 二分探索 ###\ndef binary_search(nums, target)\n  n = nums.length\n  # 問題 f(0, n-1) を解く\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 12 章 &nbsp; 分割統治","12.2 &nbsp; 分割統治探索戦略"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   二分木の構築問題","text":"<p>Question</p> <p>二分木の前順走査 <code>preorder</code> と中順走査 <code>inorder</code> が与えられたとき、これらから二分木を構築し、その根ノードを返してください。二分木には値が重複するノードが存在しないものとします（下図のとおり）。</p> <p></p> <p> 図 12-5   二分木を構築する例のデータ </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   分割統治問題かどうかを判断する","text":"<p>元の問題は <code>preorder</code> と <code>inorder</code> から二分木を構築することであり、典型的な分割統治問題です。</p> <ul> <li>問題は分解できる：分割統治の観点から見ると、元の問題は 2 つの部分問題、すなわち左部分木の構築と右部分木の構築に分けられ、さらに根ノードを初期化する 1 ステップが加わります。各部分木（部分問題）に対しても、同じ分割方法を再利用してより小さな部分木（部分問題）へと分けていき、最小の部分問題（空部分木）に達した時点で終了します。</li> <li>部分問題は独立している：左部分木と右部分木は互いに独立しており、両者の間に重なりはありません。左部分木を構築するときは、中順走査と前順走査のうち左部分木に対応する部分だけを見れば十分です。右部分木も同様です。</li> <li>部分問題の解は統合できる：左部分木と右部分木（部分問題の解）が得られたら、それらを根ノードに接続することで元の問題の解を得られます。</li> </ul>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   部分木をどのように分割するか","text":"<p>以上の分析より、この問題は分割統治で解けます。では、前順走査 <code>preorder</code> と中順走査 <code>inorder</code> を使って左部分木と右部分木をどのように分割すればよいのでしょうか？</p> <p>定義に従うと、<code>preorder</code> と <code>inorder</code> はいずれも 3 つの部分に分けられます。</p> <ul> <li>前順走査：<code>[ 根ノード | 左部分木 | 右部分木 ]</code> ，例えば上図の木は <code>[ 3 | 9 | 2 1 7 ]</code> に対応します。</li> <li>中順走査：<code>[ 左部分木 | 根ノード ｜ 右部分木 ]</code> ，例えば上図の木は <code>[ 9 | 3 | 1 2 7 ]</code> に対応します。</li> </ul> <p>上図のデータを例にすると、下図の手順によって分割結果を得られます。</p> <ol> <li>前順走査の先頭要素 3 が根ノードの値です。</li> <li>根ノード 3 の <code>inorder</code> におけるインデックスを探すと、そのインデックスを用いて <code>inorder</code> を <code>[ 9 | 3 ｜ 1 2 7 ]</code> に分割できます。</li> <li><code>inorder</code> の分割結果から、左部分木と右部分木のノード数はそれぞれ 1 と 3 であることがわかり、したがって <code>preorder</code> を <code>[ 3 | 9 | 2 1 7 ]</code> に分割できます。</li> </ol> <p></p> <p> 図 12-6   前順走査と中順走査で部分木を分割する </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   変数を用いて部分木区間を記述する","text":"<p>以上の分割方法により、**根ノード、左部分木、右部分木が <code>preorder</code> と <code>inorder</code> の中で占めるインデックス区間**が得られました。これらのインデックス区間を表すために、いくつかのポインタ変数を導入します。</p> <ul> <li>現在の木の根ノードが <code>preorder</code> に現れるインデックスを \\(i\\) とします。</li> <li>現在の木の根ノードが <code>inorder</code> に現れるインデックスを \\(m\\) とします。</li> <li>現在の木が <code>inorder</code> において占めるインデックス区間を \\([l, r]\\) とします。</li> </ul> <p>次の表のように、これらの変数を用いれば根ノードの <code>preorder</code> におけるインデックスと、部分木の <code>inorder</code> におけるインデックス区間を表せます。</p> <p> 表 12-1   根ノードと部分木の前順走査・中順走査におけるインデックス </p> 根ノードの <code>preorder</code> におけるインデックス 部分木の <code>inorder</code> におけるインデックス区間 現在の木 \\(i\\) \\([l, r]\\) 左部分木 \\(i + 1\\) \\([l, m-1]\\) 右部分木 \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>右部分木の根ノードのインデックスにある \\((m-l)\\) は「左部分木のノード数」を意味します。下図と合わせて理解することを勧めます。</p> <p></p> <p> 図 12-7   根ノードと左右部分木のインデックス区間の表し方 </p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   コードの実装","text":"<p>\\(m\\) の検索効率を高めるために、ハッシュテーブル <code>hmap</code> を用いて配列 <code>inorder</code> の要素からインデックスへの対応を保存します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"二分木を構築：分割統治\"\"\"\n    # 部分木区間が空なら終了する\n    if r - l &lt; 0:\n        return None\n    # ルートノードを初期化する\n    root = TreeNode(preorder[i])\n    # m を求めて左右部分木を分割する\n    m = inorder_map[preorder[i]]\n    # 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # 根ノードを返す\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"二分木を構築\"\"\"\n    # inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* 二分木を構築：分割統治 */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return NULL;\n    // ルートノードを初期化する\n    TreeNode *root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* 二分木を構築：分割統治 */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return null;\n    // ルートノードを初期化する\n    TreeNode root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* 二分木を構築：分割統治 */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return null;\n    // ルートノードを初期化する\n    TreeNode root = new(preorder[i]);\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* 二分木を構築：分割統治 */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // 部分木区間が空なら終了する\n    if r-l &lt; 0 {\n        return nil\n    }\n    // ルートノードを初期化する\n    root := NewTreeNode(preorder[i])\n    // m を求めて左右部分木を分割する\n    m := inorderMap[preorder[i]]\n    // 部分問題：左部分木を構築する\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // 部分問題：右部分木を構築する\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* 二分木を構築：分割統治 */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // 部分木区間が空なら終了する\n    if r - l &lt; 0 {\n        return nil\n    }\n    // ルートノードを初期化する\n    let root = TreeNode(x: preorder[i])\n    // m を求めて左右部分木を分割する\n    let m = inorderMap[preorder[i]]!\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* 二分木を構築：分割統治 */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null;\n    // ルートノードを初期化する\n    const root = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    const m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nfunction buildTree(preorder, inorder) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* 二分木を構築：分割統治 */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null;\n    // ルートノードを初期化する\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // m を求めて左右部分木を分割する\n    const m = inorderMap.get(preorder[i]);\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* 二分木を構築：分割統治 */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // 部分木区間が空なら終了する\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // ルートノードを初期化する\n  TreeNode? root = TreeNode(preorder[i]);\n  // m を求めて左右部分木を分割する\n  int m = inorderMap[preorder[i]]!;\n  // 部分問題：左部分木を構築する\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // 部分問題：右部分木を構築する\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // 根ノードを返す\n  return root;\n}\n\n/* 二分木を構築 */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* 二分木を構築：分割統治 */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 部分木区間が空なら終了する\n    if r - l &lt; 0 {\n        return None;\n    }\n    // ルートノードを初期化する\n    let root = TreeNode::new(preorder[i as usize]);\n    // m を求めて左右部分木を分割する\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // 部分問題：左部分木を構築する\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // 部分問題：右部分木を構築する\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // 根ノードを返す\n    Some(root)\n}\n\n/* 二分木を構築 */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* 二分木を構築：分割統治 */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0)\n        return NULL;\n    // ルートノードを初期化する\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // m を求めて左右部分木を分割する\n    int m = inorderMap[preorder[i]];\n    // 部分問題：左部分木を構築する\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // 部分問題：右部分木を構築する\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // 根ノードを返す\n    return root;\n}\n\n/* 二分木を構築 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* 二分木を構築：分割統治 */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // 部分木区間が空なら終了する\n    if (r - l &lt; 0) return null\n    // ルートノードを初期化する\n    val root = TreeNode(preorder[i])\n    // m を求めて左右部分木を分割する\n    val m = inorderMap[preorder[i]]!!\n    // 部分問題：左部分木を構築する\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // 部分問題：右部分木を構築する\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // 根ノードを返す\n    return root\n}\n\n/* 二分木を構築 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### 二分木を構築：分割統治 ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # 部分木区間が空なら終了する\n  return if r - l &lt; 0\n\n  # ルートノードを初期化する\n  root = TreeNode.new(preorder[i])\n  # m を求めて左右部分木を分割する\n  m = inorder_map[preorder[i]]\n  # 部分問題：左部分木を構築する\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # 部分問題：右部分木を構築する\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # 根ノードを返す\n  root\nend\n\n### 二分木を構築 ###\ndef build_tree(preorder, inorder)\n  # inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は二分木を構築する再帰過程を示しています。各ノードは下向きに「再帰していく」過程で生成され、各辺（参照）は上向きに「戻る」過程で張られます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 12-8   二分木を構築する再帰過程 </p> <p>各再帰関数における前順走査 <code>preorder</code> と中順走査 <code>inorder</code> の分割結果を下図に示します。</p> <p></p> <p> 図 12-9   各再帰関数での分割結果 </p> <p>木のノード数を \\(n\\) とすると、各ノードの初期化（再帰関数 <code>dfs()</code> の 1 回の実行）には \\(O(1)\\) 時間かかります。したがって、全体の時間計算量は \\(O(n)\\) です。</p> <p>ハッシュテーブルには <code>inorder</code> の要素からインデックスへの対応を保存するため、空間計算量は \\(O(n)\\) です。最悪の場合、すなわち二分木が連結リストに退化すると、再帰の深さは \\(n\\) に達し、\\(O(n)\\) のスタックフレーム空間を使用します。したがって、全体の空間計算量は \\(O(n)\\) です。</p>","path":["第 12 章 &nbsp; 分割統治","12.3 &nbsp; 二分木の構築問題"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   分割統治法","text":"<p>分割統治法（divide and conquer）は、問題を分けて統べるという意味であり、非常に重要で一般的なアルゴリズム戦略です。分割統治法は通常、再帰に基づいて実装され、「分」と「治」の 2 つのステップから構成されます。</p> <ol> <li>分（分割段階）：元の問題を 2 つ以上の部分問題へ再帰的に分解し、最小の部分問題に到達した時点で停止します。</li> <li>治（統合段階）：解が既知である最小の部分問題から始めて、部分問題の解を下から上へ統合し、元の問題の解を構築します。</li> </ol> <p>以下の図に示すように、「マージソート」は分割統治戦略の典型的な応用の一つです。</p> <ol> <li>分：元の配列（元の問題）を 2 つの部分配列（部分問題）へ再帰的に分割し、部分配列に要素が 1 つだけ残るまで続けます。</li> <li>治：整列済みの部分配列（部分問題の解）を下から上へ統合し、整列済みの元の配列（元の問題の解）を得ます。</li> </ol> <p></p> <p> 図 12-1   マージソートの分割統治戦略 </p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   分割統治法の問題を見極めるには","text":"<p>ある問題が分割統治法で解くのに適しているかどうかは、通常、次の判断基準を参考にできます。</p> <ol> <li>問題は分解できる：元の問題は、より小さく類似した部分問題に分解でき、同じ方法で再帰的に分割できます。</li> <li>部分問題は独立している：部分問題同士に重複がなく、相互依存もないため、独立して解決できます。</li> <li>部分問題の解は統合できる：元の問題の解は、部分問題の解を統合することで得られます。</li> </ol> <p>明らかに、マージソートは以上の 3 つの判断基準を満たしています。</p> <ol> <li>問題は分解できる：配列（元の問題）を 2 つの部分配列（部分問題）へ再帰的に分割します。</li> <li>部分問題は独立している：各部分配列は独立にソートできます（部分問題は独立に解けます）。</li> <li>部分問題の解は統合できる：2 つの整列済み部分配列（部分問題の解）は、1 つの整列済み配列（元の問題の解）に統合できます。</li> </ol>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   分割統治法で効率を高める","text":"<p>分割統治法はアルゴリズムの問題を効果的に解けるだけでなく、多くの場合アルゴリズムの効率も高められます。ソートアルゴリズムでは、クイックソート、マージソート、ヒープソートが選択ソート、バブルソート、挿入ソートより高速ですが、これは分割統治戦略を適用しているためです。</p> <p>ここで次の疑問が生じます。なぜ分割統治法はアルゴリズム効率を高められるのでしょうか。その根本的な仕組みは何でしょうか？言い換えると、大きな問題を複数の部分問題に分解し、部分問題を解き、それらの解を統合して元の問題の解にするという手順は、なぜ元の問題を直接解くより効率的なのでしょうか。この問題は、操作回数と並列計算の 2 つの観点から議論できます。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   操作回数の最適化","text":"<p>「バブルソート」を例に取ると、長さ \\(n\\) の配列を処理するのに \\(O(n^2)\\) の時間がかかります。以下の図のように、配列を中央で 2 つの部分配列に分けると仮定すると、分割には \\(O(n)\\) の時間、各部分配列のソートには \\(O((n / 2)^2)\\) の時間、2 つの部分配列の統合には \\(O(n)\\) の時間が必要で、全体の時間計算量は次のようになります：</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> 図 12-2   配列分割前後のバブルソート </p> <p>次に、以下の不等式を計算します。左辺と右辺はそれぞれ、分割前と分割後の操作総数です：</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>これは、\\(n &gt; 4\\) のときに分割後の操作回数の方が少なくなり、ソート効率が高くなることを意味します。ただし、分割後の時間計算量は依然として 2 次の \\(O(n^2)\\) であり、計算量の定数項が小さくなっただけです。</p> <p>さらに考えると、部分配列を中央からさらに 2 つの部分配列へと分割し続け、部分配列に要素が 1 つだけ残るまで分割を止めないとしたらどうでしょうか。この考え方がまさに「マージソート」であり、時間計算量は \\(O(n \\log n)\\) です。</p> <p>さらに、分割点をいくつか増やして、元の配列を平均的に \\(k\\) 個の部分配列に分けるとしたらどうでしょうか。この状況は「バケットソート」と非常によく似ており、大量データのソートに非常に適しています。理論上の時間計算量は \\(O(n + k)\\) に達します。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   並列計算の最適化","text":"<p>分割統治法で生成される部分問題は互いに独立しているため、通常は並列に解くことができます。つまり、分割統治法はアルゴリズムの時間計算量を下げられるだけでなく、オペレーティングシステムの並列最適化にも有利です。</p> <p>並列最適化は、マルチコアまたはマルチプロセッサ環境で特に有効です。システムが複数の部分問題を同時に処理でき、計算資源をより十分に活用できるため、全体の実行時間を大幅に短縮できます。</p> <p>たとえば、以下の図に示す「バケットソート」では、大量のデータを各バケットに均等に割り当てることで、すべてのバケットのソート処理を各計算ユニットに分散し、完了後に結果を統合できます。</p> <p></p> <p> 図 12-3   バケットソートの並列計算 </p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   分割統治法の代表的な応用","text":"<p>一方では、分割統治法は多くの古典的なアルゴリズム問題を解くのに使えます。</p> <ul> <li>最近点対探索：このアルゴリズムは、まず点集合を 2 つに分け、それぞれの部分における最近点対を求め、最後に 2 つの部分をまたぐ最近点対を求めます。</li> <li>大整数乗算：たとえば Karatsuba 法では、大整数の乗算を、より小さな整数どうしのいくつかの乗算と加算に分解します。</li> <li>行列乗算：たとえば Strassen 法では、大きな行列の乗算を、複数の小さな行列の乗算と加算に分解します。</li> <li>ハノイの塔問題：ハノイの塔問題は再帰によって解くことができ、これは典型的な分割統治戦略の応用です。</li> <li>反転対の計算：ある数列で前の数が後ろの数より大きい場合、その 2 つの数は反転対を構成します。反転対の問題は、分割統治の考え方を利用し、マージソートを用いて解けます。</li> </ul> <p>他方で、分割統治法はアルゴリズムとデータ構造の設計にも非常に広く応用されています。</p> <ul> <li>二分探索：二分探索では、整列済み配列を中央のインデックスで 2 つに分け、目標値と中央要素の比較結果に基づいてどちらの半区間を除外するかを決め、残った区間で同じ二分操作を行います。</li> <li>マージソート：本節の冒頭で紹介したため、ここでは繰り返しません。</li> <li>クイックソート：クイックソートは基準値を 1 つ選び、配列を、基準値より小さい要素の部分配列と、基準値より大きい要素の部分配列に分け、その後それぞれに対して同じ分割操作を行い、部分配列に要素が 1 つだけ残るまで続けます。</li> <li>バケットソート：バケットソートの基本的な考え方は、データを複数のバケットに分散し、各バケット内の要素をソートしたうえで、各バケットの要素を順に取り出して整列済み配列を得ることです。</li> <li>木構造：たとえば二分探索木、AVL 木、赤黒木、B 木、B+ 木などでは、探索・挿入・削除などの操作をいずれも分割統治戦略の応用とみなせます。</li> <li>ヒープ：ヒープは特殊な完全二分木であり、挿入、削除、ヒープ化などの各種操作には、実際には分割統治の考え方が含まれています。</li> <li>ハッシュテーブル：ハッシュテーブル自体は分割統治を直接適用しているわけではありませんが、いくつかのハッシュ衝突解決法では間接的に分割統治戦略が使われています。たとえば、連鎖アドレス法における長い連結リストは、検索効率を高めるために赤黒木へ変換されます。</li> </ul> <p>このように、**分割統治法は「静かに物を潤す」ようなアルゴリズム思想**であり、さまざまなアルゴリズムやデータ構造の中に潜んでいます。</p>","path":["第 12 章 &nbsp; 分割統治","12.1 &nbsp; 分割統治法"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   ハノイの塔の問題","text":"<p>マージソートや二分木の構築では、いずれも元の問題を元問題の半分の規模をもつ 2 つの部分問題に分解していました。しかし、ハノイの塔の問題では、異なる分解戦略を採用します。</p> <p>Question</p> <p>3 本の柱があり、それぞれを <code>A</code>、<code>B</code>、<code>C</code> とします。初期状態では、柱 <code>A</code> に \\(n\\) 枚の円盤が通されており、上から下へ小さい順に並んでいます。私たちの課題は、この \\(n\\) 枚の円盤を柱 <code>C</code> に移し、元の順序を保つことです（以下の図のとおり）。円盤を移動する際には、次のルールに従う必要があります。</p> <ol> <li>円盤は 1 本の柱の頂上から取り出し、別の柱の頂上に置くことしかできません。</li> <li>1 回に移動できる円盤は 1 枚だけです。</li> <li>小さい円盤は常に大きい円盤の上になければなりません。</li> </ol> <p></p> <p> 図 12-10   ハノイの塔の問題の例 </p> <p>規模が \\(i\\) のハノイの塔の問題を \\(f(i)\\) と表します 。たとえば \\(f(3)\\) は、\\(3\\) 枚の円盤を <code>A</code> から <code>C</code> へ移動するハノイの塔の問題を表します。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   基本ケースを考える","text":"<p>以下の図に示すように、問題 \\(f(1)\\) 、すなわち円盤が 1 枚だけの場合は、それを <code>A</code> から <code>C</code> へ直接移動すれば済みます。</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> 図 12-11   規模 1 の問題の解 </p> <p>以下の図に示すように、問題 \\(f(2)\\) 、すなわち円盤が 2 枚ある場合は、小さい円盤が常に大きい円盤の上にある条件を満たすため、<code>B</code> を借りて移動を行う必要があります。</p> <ol> <li>まず上の小さい円盤を <code>A</code> から <code>B</code> へ移します。</li> <li>次に大きい円盤を <code>A</code> から <code>C</code> へ移します。</li> <li>最後に小さい円盤を <code>B</code> から <code>C</code> へ移します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 12-12   規模 2 の問題の解 </p> <p>問題 \\(f(2)\\) を解く過程は、**2 枚の円盤を <code>B</code> を介して <code>A</code> から <code>C</code> へ移す**と要約できます。このとき、<code>C</code> を目標の柱、<code>B</code> を補助の柱と呼びます。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   部分問題への分解","text":"<p>問題 \\(f(3)\\) 、すなわち円盤が 3 枚ある場合になると、状況はやや複雑になります。</p> <p>\\(f(1)\\) と \\(f(2)\\) の解が既知なので、分割統治の観点から、<code>A</code> の上部にある 2 枚の円盤をひとまとまりとみなして、次の図の手順を実行できます。こうして 3 枚の円盤を <code>A</code> から <code>C</code> へ順調に移動できます。</p> <ol> <li><code>B</code> を目標の柱、<code>C</code> を補助の柱として、2 枚の円盤を <code>A</code> から <code>B</code> へ移します。</li> <li><code>A</code> に残った 1 枚の円盤を <code>A</code> から <code>C</code> へ直接移動します。</li> <li><code>C</code> を目標の柱、<code>A</code> を補助の柱として、2 枚の円盤を <code>B</code> から <code>C</code> へ移します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 12-13   規模 3 の問題の解 </p> <p>本質的には、問題 \\(f(3)\\) を 2 つの部分問題 \\(f(2)\\) と 1 つの部分問題 \\(f(1)\\) に分けています 。この 3 つの部分問題を順に解けば、元の問題も解決されます。これは、部分問題が独立しており、解を組み合わせられることを示しています。</p> <p>ここまでで、次の図に示すハノイの塔の問題を解く分割統治戦略をまとめられます。元の問題 \\(f(n)\\) を 2 つの部分問題 \\(f(n-1)\\) と 1 つの部分問題 \\(f(1)\\) に分け、次の順序でこの 3 つの部分問題を解きます。</p> <ol> <li>\\(n-1\\) 枚の円盤を <code>C</code> を介して <code>A</code> から <code>B</code> へ移します。</li> <li>残り \\(1\\) 枚の円盤を <code>A</code> から <code>C</code> へ直接移します。</li> <li>\\(n-1\\) 枚の円盤を <code>A</code> を介して <code>B</code> から <code>C</code> へ移します。</li> </ol> <p>この 2 つの部分問題 \\(f(n-1)\\) は、同じ方法で再帰的に分割できます。最小の部分問題 \\(f(1)\\) に到達するまでこれを続けます。一方、\\(f(1)\\) の解は既知であり、1 回の移動操作だけで済みます。</p> <p></p> <p> 図 12-14   ハノイの塔の問題を解く分割統治戦略 </p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   コードの実装","text":"<p>コードでは、再帰関数 <code>dfs(i, src, buf, tar)</code> を定義します。その役割は、柱 <code>src</code> の上部にある \\(i\\) 枚の円盤を、補助の柱 <code>buf</code> を使って目標の柱 <code>tar</code> へ移動することです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"円盤を 1 枚移動\"\"\"\n    # src の上から円盤を1枚取り出す\n    pan = src.pop()\n    # 円盤を tar の上に置く\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"ハノイの塔の問題 f(i) を解く\"\"\"\n    # src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1:\n        move(src, tar)\n        return\n    # 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf)\n    # 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    # 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"ハノイの塔を解く\"\"\"\n    n = len(A)\n    # A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* 円盤を 1 枚移動 */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // src の上から円盤を1枚取り出す\n    int pan = src.back();\n    src.pop_back();\n    // 円盤を tar の上に置く\n    tar.push_back(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* 円盤を 1 枚移動 */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // src の上から円盤を1枚取り出す\n    Integer pan = src.remove(src.size() - 1);\n    // 円盤を tar の上に置く\n    tar.add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* 円盤を 1 枚移動 */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // src の上から円盤を1枚取り出す\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // 円盤を tar の上に置く\n    tar.Add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    DFS(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    Move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    DFS(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* 円盤を 1 枚移動 */\nfunc move(src, tar *list.List) {\n    // src の上から円盤を1枚取り出す\n    pan := src.Back()\n    // 円盤を tar の上に置く\n    tar.PushBack(pan.Value)\n    // `src` の最上部の円盤を取り外す\n    src.Remove(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfsHanota(i-1, src, tar, buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* ハノイの塔を解く */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* 円盤を 1 枚移動 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // src の上から円盤を1枚取り出す\n    let pan = src.popLast()!\n    // 円盤を tar の上に置く\n    tar.append(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src: &amp;src, tar: &amp;tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* ハノイの塔を解く */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // リストの末尾が柱の上端に対応する\n    // src の上から n 個の円盤を、B を介して C に移動する\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* 円盤を 1 枚移動 */\nfunction move(src, tar) {\n    // src の上から円盤を1枚取り出す\n    const pan = src.pop();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunction dfs(i, src, buf, tar) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* 円盤を 1 枚移動 */\nfunction move(src: number[], tar: number[]): void {\n    // src の上から円盤を1枚取り出す\n    const pan = src.pop();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* 円盤を 1 枚移動 */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // src の上から円盤を1枚取り出す\n  int pan = src.removeLast();\n  // 円盤を tar の上に置く\n  tar.add(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n  dfs(i - 1, src, tar, buf);\n  // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n  move(src, tar);\n  // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n  dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // A の上から n 枚の円盤を B を介して C へ移す\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* 円盤を 1 枚移動 */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // src の上から円盤を1枚取り出す\n    let pan = src.pop().unwrap();\n    // 円盤を tar の上に置く\n    tar.push(pan);\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move_pan(src, tar);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar);\n}\n\n/* ハノイの塔を解く */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* 円盤を 1 枚移動 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // src の上から円盤を1枚取り出す\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // 円盤を tar の上に置く\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, srcSize, tar, tarSize);\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* ハノイの塔を解く */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* 円盤を 1 枚移動 */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // src の上から円盤を1枚取り出す\n    val pan = src.removeAt(src.size - 1)\n    // 円盤を tar の上に置く\n    tar.add(pan)\n}\n\n/* ハノイの塔の問題 f(i) を解く */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n    dfs(i - 1, src, tar, buf)\n    // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n    move(src, tar)\n    // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n    dfs(i - 1, buf, src, tar)\n}\n\n/* ハノイの塔を解く */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // A の上から n 枚の円盤を B を介して C へ移す\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### 円盤を1枚移動 ###\ndef move(src, tar)\n  # src の上から円盤を1枚取り出す\n  pan = src.pop\n  # 円盤を tar の上に置く\n  tar &lt;&lt; pan\nend\n\n### ハノイの塔 f(i) を解く ###\ndef dfs(i, src, buf, tar)\n  # src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す\n  dfs(i - 1, src, tar, buf)\n  # 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す\n  move(src, tar)\n  # 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す\n  dfs(i - 1, buf, src, tar)\nend\n\n### ハノイの塔を解く ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # A の上から n 枚の円盤を B を介して C へ移す\n  dfs(n, _A, _B, _C)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図に示すように、ハノイの塔の問題は高さ \\(n\\) の再帰木を形成し、各ノードは 1 つの部分問題、すなわち 1 つ起動された <code>dfs()</code> 関数に対応します。したがって時間計算量は \\(O(2^n)\\) 、空間計算量は \\(O(n)\\) です。</p> <p></p> <p> 図 12-15   ハノイの塔の問題の再帰木 </p> <p>Quote</p> <p>ハノイの塔の問題は古い伝説に由来します。古代インドのある寺院で、僧侶たちは 3 本の高いダイヤモンドの柱と、\\(64\\) 枚の大きさの異なる金の円盤を持っていました。僧侶たちは絶えず円盤を動かし、最後の 1 枚が正しく置かれた瞬間に世界が終わると信じていました。</p> <p>しかし、たとえ僧侶たちが 1 秒に 1 回移動するとしても、合計でおよそ \\(2^{64} \\approx 1.84×10^{19}\\) 秒、約 \\(5850\\) 億年が必要で、現在推定されている宇宙の年齢をはるかに上回ります。したがって、この伝説が本当だったとしても、世界の終わりを心配する必要はなさそうです。</p>","path":["第 12 章 &nbsp; 分割統治","12.4 &nbsp; ハノイの塔の問題"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   まとめ","text":"","path":["第 12 章 &nbsp; 分割統治","12.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>分割統治法は一般的なアルゴリズム設計戦略であり、分（分割）と治（統合）の 2 つの段階からなり、通常は再帰に基づいて実装されます。</li> <li>それが分割統治法の問題かどうかを判断する基準には、問題を分解できるか、部分問題が独立しているか、部分問題を統合できるかが含まれます。</li> <li>マージソートは分割統治法の典型的な応用であり、配列を再帰的に同じ長さの 2 つの部分配列に分割し、要素が 1 つだけになるまで続け、その後で各層を順に統合してソートを完了します。</li> <li>分割統治法を導入すると、多くの場合アルゴリズムの効率を高められます。一方では操作回数が減り、他方では分割後にシステムの並列最適化を行いやすくなります。</li> <li>分割統治法は多くのアルゴリズム問題を解決できるだけでなく、データ構造やアルゴリズム設計にも広く応用されており、至る所でその姿を見ることができます。</li> <li>総当たり探索と比べて、適応的な探索のほうが効率的です。時間計算量が \\(O(\\log n)\\) の探索アルゴリズムは、通常は分割統治法に基づいて実装されます。</li> <li>二分探索は分割統治法のもう 1 つの典型的な応用であり、部分問題の解を統合する手順を含みません。再帰的な分割統治によって二分探索を実現できます。</li> <li>二分木を構築する問題では、木の構築（元の問題）を左部分木と右部分木の構築（部分問題）に分けられます。これは、先行順序走査と中間順序走査のインデックス区間を分割することで実現できます。</li> <li>ハノイの塔の問題では、規模 \\(n\\) の問題を、規模 \\(n-1\\) の 2 つの部分問題と規模 \\(1\\) の 1 つの部分問題に分けられます。これら 3 つの部分問題を順に解くと、元の問題も解決されます。</li> </ul>","path":["第 12 章 &nbsp; 分割統治","12.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"第 14 章   動的計画法","text":"<p>Abstract</p> <p>小川は川へと注ぎ、河川は大海へと注ぐ。</p> <p>動的計画法は小さな問題の解を集めて大きな問題の答えとし、一歩ずつ私たちを問題解決の彼岸へと導く。</p>","path":["第 14 章 &nbsp; 動的計画法"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"章の内容","text":"<ul> <li>14.1   動的計画法入門</li> <li>14.2   動的計画法の問題特性</li> <li>14.3   動的計画法の問題解決の考え方</li> <li>14.4   0-1 ナップサック問題</li> <li>14.5   完全ナップサック問題</li> <li>14.6   編集距離問題</li> <li>14.7   まとめ</li> </ul>","path":["第 14 章 &nbsp; 動的計画法"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   動的計画法の問題特性","text":"<p>前節では、動的計画法が部分問題への分解によってどのように元の問題を解くのかを学びました。実際、部分問題への分解は汎用的なアルゴリズムの考え方であり、分割統治法、動的計画法、バックトラッキングでは重視点が異なります。</p> <ul> <li>分割統治法は、元の問題を再帰的に複数の互いに独立した部分問題へ分割し、最小の部分問題に至るまで分解したうえで、バックトラック時に部分問題の解を統合し、最終的に元の問題の解を得ます。</li> <li>動的計画法も問題を再帰的に分解しますが、分割統治法との主な違いは、動的計画法における部分問題が相互依存しており、分解の過程で多数の重複部分問題が現れることです。</li> <li>バックトラッキング法は、試行と巻き戻しの中ですべての可能な解を列挙し、枝刈りによって不要な探索分岐を避けます。元の問題の解は一連の意思決定ステップから構成されるため、各決定ステップ以前の部分系列を一つの部分問題と見なせます。</li> </ul> <p>実際、動的計画法は最適化問題を解くためによく用いられます。これらは重複部分問題を含むだけでなく、さらに二つの大きな特性、すなわち最適部分構造と無後効性を備えています。</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   最適部分構造","text":"<p>階段昇り問題を少し変更し、最適部分構造の概念をより示しやすくします。</p> <p>階段昇りの最小コスト</p> <p>階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。各段には非負整数が貼られており、その段に到達するために支払う必要があるコストを表します。非負整数配列 \\(cost\\) が与えられ、\\(cost[i]\\) は第 \\(i\\) 段で支払うコストを表し、\\(cost[0]\\) は地面（開始地点）です。頂上に到達するために必要な最小コストを求めてください。</p> <p>下図に示すように、第 \\(1\\)、\\(2\\)、\\(3\\) 段のコストがそれぞれ \\(1\\)、\\(10\\)、\\(1\\) である場合、地面から第 \\(3\\) 段まで上る最小コストは \\(2\\) です。</p> <p></p> <p> 図 14-6   第 3 段まで上る最小コスト </p> <p>\\(dp[i]\\) を第 \\(i\\) 段まで上るのに累積して支払ったコストとします。第 \\(i\\) 段には \\(i - 1\\) 段または \\(i - 2\\) 段からしか到達できないため、\\(dp[i]\\) は \\(dp[i - 1] + cost[i]\\) または \\(dp[i - 2] + cost[i]\\) のいずれかになります。コストをできるだけ小さくするには、この二つのうち小さいほうを選べばよいです。</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>ここから最適部分構造の意味を導けます。**元の問題の最適解は、部分問題の最適解から構築される**ということです。</p> <p>この問題が最適部分構造を持つことは明らかです。二つの部分問題の最適解 \\(dp[i-1]\\) と \\(dp[i-2]\\) からより良いほうを選び、それを用いて元の問題 \\(dp[i]\\) の最適解を構築しています。</p> <p>では、前節の階段昇り問題には最適部分構造があるのでしょうか。その目的は方法数を求めることで、一見すると計数問題です。しかし問い方を変えて「最大の方法数を求める」とすると、意外にも、問題の変更前後は等価であるにもかかわらず、最適部分構造が現れます。すなわち、第 \\(n\\) 段の最大方法数は第 \\(n-1\\) 段と第 \\(n-2\\) 段の最大方法数の和に等しいのです。このように、最適部分構造の解釈は比較的柔軟であり、問題によって意味合いが異なります。</p> <p>状態遷移方程式と初期状態 \\(dp[1] = cost[1]\\) および \\(dp[2] = cost[2]\\) に基づいて、次の動的計画法コードが得られます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"階段登りの最小コスト：動的計画法\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [0] * (n + 1)\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1], dp[2] = cost[1], cost[2]\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;int&gt; dp(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![-1; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 階段登りの最小コスト：動的計画法 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int *dp = calloc(n + 1, sizeof(int));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 階段登りの最小コスト：動的計画法 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = IntArray(n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 階段登りの最小コスト：動的計画法 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = cost[1], cost[2]\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図は上記コードの動的計画法の過程を示しています。</p> <p></p> <p> 図 14-7   階段昇り最小コストの動的計画法の過程 </p> <p>この問題では空間最適化も可能であり、一次元をゼロ次元まで圧縮することで、空間計算量を \\(O(n)\\) から \\(O(1)\\) に削減できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"階段昇りの最小コスト：空間最適化後の動的計画法\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    a, b := cost[1], cost[2]\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 階段昇りの最小コスト：空間最適化後の動的計画法 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 階段登りの最小コスト：動的計画法 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = cost[1], cost[2]\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# 階段昇りの最小コスト：空間最適化後の動的計画法\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   無後効性","text":"<p>無後効性は、動的計画法が問題を効率よく解ける重要な特性の一つであり、その定義は次のとおりです。ある確定した状態が与えられたとき、その後の発展は現在の状態のみに依存し、過去に経たすべての状態には依存しない。</p> <p>階段昇り問題を例にすると、状態 \\(i\\) が与えられたとき、そこから状態 \\(i+1\\) と状態 \\(i+2\\) へ発展し、それぞれ \\(1\\) 段進む場合と \\(2\\) 段進む場合に対応します。この二つの選択を行う際、状態 \\(i\\) より前の状態を考慮する必要はなく、それらは状態 \\(i\\) の将来に影響を与えません。</p> <p>しかし、階段昇り問題に制約を一つ追加すると、状況は変わります。</p> <p>制約付き階段昇り</p> <p>全部で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。ただし、連続する 2 回で \\(1\\) 段ずつ上ることはできません。頂上まで上る方法は何通りあるでしょうか。</p> <p>下図に示すように、第 \\(3\\) 段まで上る実行可能な方法は \\(2\\) 通りしか残りません。そのうち、\\(1\\) 段ずつ 3 回連続で上る方法は制約を満たさないため除外されます。</p> <p></p> <p> 図 14-8   制約付きで第 3 段まで上る方法数 </p> <p>この問題では、前回が \\(1\\) 段上りだった場合、次回は必ず \\(2\\) 段上らなければなりません。これは、**次の一手が現在の状態（現在いる階段の段数）だけでは独立に決まらず、一つ前の状態（前回いた段数）にも関係する**ことを意味します。</p> <p>容易に分かるように、この問題はもはや無後効性を満たしておらず、状態遷移方程式 \\(dp[i] = dp[i-1] + dp[i-2]\\) も成立しません。というのも、\\(dp[i-1]\\) は今回 \\(1\\) 段上る場合を表しますが、その中には「前回も \\(1\\) 段上ってきた」方法が多数含まれており、制約を満たすためには \\(dp[i-1]\\) をそのまま \\(dp[i]\\) に加えることができないからです。</p> <p>このため、状態定義を拡張する必要があります。**状態 \\([i, j]\\) は、第 \\(i\\) 段にいて前回に \\(j\\) 段上ったことを表す**とし、ここで \\(j \\in \\{1, 2\\}\\) です。この状態定義により、前回が \\(1\\) 段上りか \\(2\\) 段上りかを有効に区別でき、現在の状態がどこから来たのかを判断できます。</p> <ul> <li>前回に \\(1\\) 段上った場合、その前の回は \\(2\\) 段上りしか選べないため、\\(dp[i, 1]\\) は \\(dp[i-1, 2]\\) からのみ遷移できます。</li> <li>前回に \\(2\\) 段上った場合、その前の回は \\(1\\) 段上りまたは \\(2\\) 段上りを選べるため、\\(dp[i, 2]\\) は \\(dp[i-2, 1]\\) または \\(dp[i-2, 2]\\) から遷移できます。</li> </ul> <p>下図に示すように、この定義のもとでは \\(dp[i, j]\\) は状態 \\([i, j]\\) に対応する方法数を表します。このとき状態遷移方程式は次のようになります。</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> 図 14-9   制約を考慮した漸化関係 </p> <p>最終的に、\\(dp[n, 1] + dp[n, 2]\\) を返せば十分であり、その和が第 \\(n\\) 段まで上る方法の総数を表します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"制約付き階段登り：動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[][] dp = new int[n + 1][3];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* 制約付き階段登り：動的計画法 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[,] dp = new int[n + 1, 3];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* 制約付き階段登り：動的計画法 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([][3]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* 制約付き階段登り：動的計画法 */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* 制約付き階段登り：動的計画法 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* 制約付き階段登り：動的計画法 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* 制約付き階段登り：動的計画法 */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* 制約付き階段登り：動的計画法 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* 制約付き階段登り：動的計画法 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(3) }\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### 制約付き階段登り：動的計画法 ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上の例では、追加で考慮すべきなのは一つ前の状態だけであるため、状態定義を拡張することで問題を再び無後効性に適合させることができます。しかし、問題によっては非常に強い「後効性」があります。</p> <p>階段昇りと障害物生成</p> <p>全部で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。**第 \\(i\\) 段に到達すると、システムは自動的に第 \\(2i\\) 段に障害物を置き、それ以降はどの回でも第 \\(2i\\) 段へ跳ぶことができない**とします。例えば、最初の 2 回でそれぞれ第 \\(2\\) 段、第 \\(3\\) 段に到達した場合、その後は第 \\(4\\) 段と第 \\(6\\) 段に跳ぶことはできません。頂上まで上る方法は何通りあるでしょうか。</p> <p>この問題では、次の跳躍が過去のすべての状態に依存します。なぜなら、各跳躍がより高い段に障害物を設置し、将来の跳躍に影響するからです。この種の問題は、動的計画法では解きにくいことが多いです。</p> <p>実際、多くの複雑な組合せ最適化問題（例えば巡回セールスマン問題）は無後効性を満たしません。このような問題に対しては、通常、ヒューリスティック探索、遺伝的アルゴリズム、強化学習などの他の方法を用いて、限られた時間内に実用的な局所最適解を得ます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.2 &nbsp; 動的計画法の問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   動的計画法の問題解決の考え方","text":"<p>前の 2 節では動的計画法の問題の主要な特徴を紹介しました。ここからは、さらに実用的な 2 つの問題を一緒に考えていきます。</p> <ol> <li>ある問題が動的計画法の問題かどうかを、どのように判断すればよいでしょうか？</li> <li>動的計画法の問題を解くには、どこから着手し、完全な手順はどのようなものでしょうか？</li> </ol>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   問題の判定","text":"<p>一般に、ある問題が重複部分問題と最適部分構造を含み、さらに無後效性を満たしているなら、通常は動的計画法で解くのに適しています。しかし、問題文からこれらの性質を直接読み取るのは簡単ではありません。そのため通常は条件を少し緩めて、**まずその問題がバックトラッキング（全探索）で解くのに適しているか**を観察します。</p> <p>バックトラッキングで解くのに適した問題は、通常「決定木モデル」を満たします。この種の問題は木構造で表現でき、各ノードは 1 つの決定を表し、各経路は 1 つの決定列を表します。</p> <p>言い換えると、問題に明確な決定の概念が含まれており、解が一連の決定によって生成されるなら、その問題は決定木モデルを満たし、通常はバックトラッキングで解くことができます。</p> <p>これに加えて、動的計画法の問題には判定のための「加点要素」もあります。</p> <ul> <li>問題文に最大（最小）や最多（最少）などの最適化に関する記述がある。</li> <li>問題の状態が配列、多次元行列、または木で表現でき、ある状態とその周辺の状態の間に漸化的な関係がある。</li> </ul> <p>反対に、「減点要素」もあります。</p> <ul> <li>問題の目的が最適解を求めることではなく、あり得るすべての解を列挙することである。</li> <li>問題文に明確な順列・組合せの特徴があり、具体的な複数の解を返す必要がある。</li> </ul> <p>ある問題が決定木モデルを満たし、さらに比較的明確な「加点要素」を備えているなら、その問題は動的計画法の問題であると仮定し、解く過程でそれを検証できます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   問題を解く手順","text":"<p>動的計画法の解法の流れは問題の性質や難易度によって異なりますが、通常は次の手順に従います。すなわち、決定を記述し、状態を定義し、\\(dp\\) テーブルを構築し、状態遷移方程式を導出し、境界条件を定めます。</p> <p>解法の手順をより具体的に示すために、ここでは古典的な問題である「最小経路和」を例にします。</p> <p>Question</p> <p>\\(n \\times m\\) の 2 次元グリッド <code>grid</code> が与えられます。グリッドの各セルには非負整数が格納されており、そのセルのコストを表します。ロボットは左上のセルを始点とし、毎回下または右に 1 マスだけ移動して、右下のセルまで進みます。左上から右下までの最小経路和を返してください。</p> <p>次の図は 1 つの例を示しており、このグリッドの最小経路和は \\(13\\) です。</p> <p></p> <p> 図 14-10   最小経路和のサンプルデータ </p> <p>ステップ 1：各ラウンドの決定を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>この問題における各ラウンドの決定は、現在のマスから下または右へ 1 マス進むことです。現在のマスの行・列インデックスを \\([i, j]\\) とすると、下または右へ 1 マス進んだ後のインデックスは \\([i+1, j]\\) または \\([i, j+1]\\) になります。したがって、状態には行インデックスと列インデックスの 2 つの変数を含め、\\([i, j]\\) と表します。</p> <p>状態 \\([i, j]\\) に対応する部分問題は、始点 \\([0, 0]\\) から \\([i, j]\\) まで進む最小経路和であり、その解を \\(dp[i, j]\\) と記します。</p> <p>これで、次の図に示す 2 次元の \\(dp\\) 行列が得られます。そのサイズは入力グリッド \\(grid\\) と同じです。</p> <p></p> <p> 図 14-11   状態の定義と dp テーブル </p> <p>Note</p> <p>動的計画法とバックトラッキングの過程は、いずれも 1 つの決定列として記述できます。そして状態は、すべての決定変数から構成されます。状態には解法の進行状況を表すすべての変数が含まれているべきであり、次の状態を導くのに十分な情報を持っている必要があります。</p> <p>各状態は 1 つの部分問題に対応しており、すべての部分問題の解を保存するために \\(dp\\) テーブルを定義します。状態の各独立変数は、\\(dp\\) テーブルの 1 つの次元に対応します。本質的に、\\(dp\\) テーブルは状態と部分問題の解との対応関係です。</p> <p>ステップ 2：最適部分構造を見つけ、状態遷移方程式を導出する</p> <p>状態 \\([i, j]\\) は、上のマス \\([i-1, j]\\) または左のマス \\([i, j-1]\\) からしか遷移してきません。したがって最適部分構造は、\\([i, j]\\) に到達する最小経路和が、\\([i, j-1]\\) の最小経路和と \\([i-1, j]\\) の最小経路和のうち小さい方によって決まる、ということです。</p> <p>以上の分析から、次の図に示す状態遷移方程式を導くことができます。</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> 図 14-12   最適部分構造と状態遷移方程式 </p> <p>Note</p> <p>定義済みの \\(dp\\) テーブルに基づいて、元の問題と部分問題の関係を考え、部分問題の最適解から元の問題の最適解を構成する方法、すなわち最適部分構造を見つけます。</p> <p>ひとたび最適部分構造が見つかれば、それを使って状態遷移方程式を構築できます。</p> <p>ステップ 3：境界条件と状態遷移の順序を決める</p> <p>この問題では、先頭行にある状態は左の状態からしか得られず、先頭列にある状態は上の状態からしか得られません。したがって、先頭行 \\(i = 0\\) と先頭列 \\(j = 0\\) が境界条件になります。</p> <p>次の図に示すように、各マスは左のマスと上のマスから遷移してくるため、ループを用いて行列を走査します。外側のループで各行を、内側のループで各列を走査します。</p> <p></p> <p> 図 14-13   境界条件と状態遷移の順序 </p> <p>Note</p> <p>境界条件は、動的計画法では \\(dp\\) テーブルの初期化に使われ、探索では枝刈りに使われます。</p> <p>状態遷移の順序で重要なのは、現在の問題の解を計算するときに、それが依存するより小さな部分問題の解がすべてすでに正しく計算済みであることを保証する点です。</p> <p>以上の分析により、すでに動的計画法のコードを直接書くことができます。しかし、部分問題への分解はトップダウンの考え方であるため、「力任せ探索 \\(\\rightarrow\\) メモ化探索 \\(\\rightarrow\\) 動的計画法」の順に実装するほうが、思考の流れにはより自然です。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-1","level":3,"title":"1.   方法 1：力任せ探索","text":"<p>状態 \\([i, j]\\) から探索を開始し、より小さな状態 \\([i-1, j]\\) と \\([i, j-1]\\) へと分解していきます。再帰関数には次の要素が含まれます。</p> <ul> <li>再帰引数：状態 \\([i, j]\\) 。</li> <li>戻り値：\\([0, 0]\\) から \\([i, j]\\) までの最小経路和 \\(dp[i, j]\\) 。</li> <li>終了条件：\\(i = 0\\) かつ \\(j = 0\\) のとき、コスト \\(grid[0, 0]\\) を返す。</li> <li>枝刈り：\\(i &lt; 0\\) または \\(j &lt; 0\\) でインデックスが範囲外になった場合、コスト \\(+\\infty\\) を返し、実行不可能であることを表す。</li> </ul> <p>実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"最小経路和：全探索\"\"\"\n    # 左上のセルなら探索を終了する\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：全探索 */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：全探索 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：全探索 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // 左上のセルなら探索を終了する\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：全探索 */\nfunction minPathSumDFS(grid, i, j) {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：全探索 */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // 左上のセルなら探索を終了する\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  if (i &lt; 0 || j &lt; 0) {\n    // Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // 左上隅から (i, j) までの最小経路コストを返す\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：全探索 */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：全探索 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：全探索 */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // 左上隅から (i, j) までの最小経路コストを返す\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：全探索 ###\ndef min_path_sum_dfs(grid, i, j)\n  # 左上のセルなら探索を終了する\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # 左上隅から (i, j) までの最小経路コストを返す\n  [left, up].min + grid[i][j]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、\\(dp[2, 1]\\) を根ノードとする再帰木を示しています。この中にはいくつかの重複部分問題が含まれており、その数はグリッド <code>grid</code> のサイズが大きくなるにつれて急激に増加します。</p> <p>本質的に、重複部分問題が生じる理由は、**左上からあるセルへ到達する経路が複数存在すること**にあります。</p> <p></p> <p> 図 14-14   力任せ探索の再帰木 </p> <p>各状態には下と右の 2 通りの選択肢があり、左上から右下まで進むには合計で \\(m + n - 2\\) 歩必要です。したがって最悪時間計算量は \\(O(2^{m + n})\\) です。ここで、\\(n\\) と \\(m\\) はそれぞれグリッドの行数と列数を表します。なお、この見積もりではグリッド境界付近の状況を考慮していません。境界に達すると選択肢は 1 つだけになるため、実際の経路数はこれより少なくなります。</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-2","level":3,"title":"2.   方法 2：メモ化探索","text":"<p>グリッド <code>grid</code> と同じサイズのメモ配列 <code>mem</code> を導入し、各部分問題の解を記録して、重複部分問題を枝刈りします。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"最小経路和：メモ化探索\"\"\"\n    # 左上のセルなら探索を終了する\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 既に記録があればそのまま返す\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # 左と上のセルからの最小経路コスト\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：メモ化探索 */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：メモ化探索 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：メモ化探索 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // 左上のセルなら探索を終了する\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：メモ化探索 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：メモ化探索 */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 左上のセルなら探索を終了する\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // 左上のセルなら探索を終了する\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  if (i &lt; 0 || j &lt; 0) {\n    // Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 既に記録があればそのまま返す\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // 左と上のセルからの最小経路コスト\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // 左上から (i, j) までの最小経路コストを記録して返す\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：メモ化探索 */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 左上のセルなら探索を終了する\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 既に記録があればそのまま返す\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // 左と上のセルからの最小経路コスト\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：メモ化探索 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左と上のセルからの最小経路コスト\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：メモ化探索 */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // 左上のセルなら探索を終了する\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 行または列のインデックスが範囲外なら、コスト +∞ を返す\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // 左と上のセルからの最小経路コスト\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // 左上から (i, j) までの最小経路コストを記録して返す\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：メモ化探索 ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # 左上のセルなら探索を終了する\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # 行または列のインデックスが範囲外なら、コスト +∞ を返す\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 既に記録があればそのまま返す\n  return mem[i][j] if mem[i][j] != -1\n  # 左と上のセルからの最小経路コスト\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # 左上から (i, j) までの最小経路コストを記録して返す\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図に示すように、メモ化を導入すると、すべての部分問題の解は 1 回だけ計算すればよくなります。したがって時間計算量は状態総数、すなわちグリッドサイズの \\(O(nm)\\) に依存します。</p> <p></p> <p> 図 14-15   メモ化探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-3","level":3,"title":"3.   方法 3：動的計画法","text":"<p>反復に基づいて動的計画法の解法を実装すると、コードは次のようになります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小経路和：動的計画法\"\"\"\n    n, m = len(grid), len(grid[0])\n    # dp テーブルを初期化\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # 状態遷移：先頭行\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # 状態遷移：先頭列\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # 状態遷移: 残りの行と列\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：動的計画法 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：動的計画法 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // dp テーブルを初期化\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：動的計画法 */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：動的計画法 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：動的計画法 */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // 状態遷移：先頭行\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // 状態遷移：先頭列\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：動的計画法 */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：動的計画法 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // dp テーブルを初期化\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 状態遷移：先頭列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // メモリを解放する\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：動的計画法 */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // dp テーブルを初期化\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // 状態遷移：先頭行\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 状態遷移：先頭列\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：動的計画法 ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # dp テーブルを初期化\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # 状態遷移：先頭行\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # 状態遷移：先頭列\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # 状態遷移: 残りの行と列\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は最小経路和の状態遷移の過程を示しています。グリッド全体を走査するため、時間計算量は \\(O(nm)\\) です。</p> <p>配列 <code>dp</code> のサイズは \\(n \\times m\\) であるため、空間計算量は \\(O(nm)\\) です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-16   最小経路和の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   空間最適化","text":"<p>各マスは左のマスと上のマスにのみ関係するため、1 行の配列だけを使って \\(dp\\) テーブルを実装できます。</p> <p>ただし、配列 <code>dp</code> は 1 行分の状態しか表せないため、先頭列の状態を事前に初期化することはできず、各行を走査するときに更新する必要があります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小経路和：空間最適化後の動的計画法\"\"\"\n    n, m = len(grid), len(grid[0])\n    # dp テーブルを初期化\n    dp = [0] * m\n    # 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # 状態遷移：残りの行\n    for i in range(1, n):\n        # 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        # 状態遷移：残りの列\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // dp テーブルを初期化\n    int[] dp = new int[m];\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // dp テーブルを初期化\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // dp テーブルを初期化\n    dp := make([]int, m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt; n; i++ {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 状態遷移：残りの行\n    for i in 1 ..&lt; n {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = new Array(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // dp テーブルを初期化\n    const dp = new Array(m);\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // 状態遷移：残りの行\n  for (int i = 1; i &lt; n; i++) {\n    // 状態遷移：先頭列\n    dp[0] = dp[0] + grid[i][0];\n    // 状態遷移：残りの列\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // dp テーブルを初期化\n    let mut dp = vec![0; m];\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for i in 1..n {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // dp テーブルを初期化\n    int *dp = calloc(m, sizeof(int));\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt; n; i++) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0];\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小経路和：空間最適化後の動的計画法 */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // dp テーブルを初期化\n    val dp = IntArray(m)\n    // 状態遷移：先頭行\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 状態遷移：残りの行\n    for (i in 1..&lt;n) {\n        // 状態遷移：先頭列\n        dp[0] = dp[0] + grid[i][0]\n        // 状態遷移：残りの列\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小経路和：空間最適化後の動的計画法 ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # dp テーブルを初期化\n  dp = Array.new(m, 0)\n  # 状態遷移：先頭行\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # 状態遷移：残りの行\n  for i in 1...n\n    # 状態遷移：先頭列\n    dp[0] = dp[0] + grid[i][0]\n    # 状態遷移：残りの列\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.3 &nbsp; 動的計画法の問題解決の考え方"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   編集距離問題","text":"<p>編集距離は、Levenshtein 距離とも呼ばれ、2つの文字列の相互変換に必要な最小の編集回数を指し、通常は情報検索や自然言語処理において2つの系列の類似度を測るために用いられます。</p> <p>Question</p> <p>2つの文字列 \\(s\\) と \\(t\\) を入力し、\\(s\\) を \\(t\\) に変換するのに必要な最小編集回数を返してください。</p> <p>1つの文字列に対して3種類の編集操作を行えます。1文字の挿入、1文字の削除、任意の文字への置換です。</p> <p>下図に示すように、<code>kitten</code> を <code>sitting</code> に変換するには 3 回の編集が必要で、内訳は 2 回の置換と 1 回の挿入です。<code>hello</code> を <code>algo</code> に変換する場合も 3 回必要で、内訳は 2 回の置換と 1 回の削除です。</p> <p></p> <p> 図 14-27   編集距離のサンプルデータ </p> <p>編集距離問題は決定木モデルで自然に説明できます。文字列が木のノードに対応し、1回の決定（1回の編集操作）が木の1本の辺に対応します。</p> <p>下図に示すように、操作に制限がない場合、各ノードからは多くの辺を派生でき、それぞれの辺が1種類の操作に対応します。これは <code>hello</code> から <code>algo</code> への変換に多くの経路があり得ることを意味します。</p> <p>決定木の観点から見ると、本問の目標はノード <code>hello</code> とノード <code>algo</code> の間の最短経路を求めることです。</p> <p></p> <p> 図 14-28   決定木モデルに基づく編集距離問題の表現 </p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   動的計画法の考え方","text":"<p>第1ステップ：各ラウンドの決定を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>各ラウンドの決定は、文字列 \\(s\\) に対して1回の編集操作を行うことです。</p> <p>編集操作の過程で問題の規模が徐々に小さくなることを期待します。そうして初めて部分問題を構築できます。文字列 \\(s\\) と \\(t\\) の長さをそれぞれ \\(n\\) と \\(m\\) とし、まず両文字列の末尾の文字 \\(s[n-1]\\) と \\(t[m-1]\\) を考えます。</p> <ul> <li>\\(s[n-1]\\) と \\(t[m-1]\\) が同じなら、それらをスキップして、直接 \\(s[n-2]\\) と \\(t[m-2]\\) を考えます。</li> <li>\\(s[n-1]\\) と \\(t[m-1]\\) が異なるなら、\\(s\\) に対して1回の編集（挿入、削除、置換）を行い、両文字列の末尾の文字を同じにします。そうすることでそれらをスキップし、より小さい問題を考えられます。</li> </ul> <p>つまり、文字列 \\(s\\) に対する各ラウンドの決定（編集操作）は、\\(s\\) と \\(t\\) における残りの未一致文字を変化させます。したがって、状態は現在 \\(s\\) と \\(t\\) で考えている第 \\(i\\) と第 \\(j\\) 文字とし、\\([i, j]\\) と記します。</p> <p>状態 \\([i, j]\\) に対応する部分問題は、**\\(s\\) の先頭 \\(i\\) 文字を \\(t\\) の先頭 \\(j\\) 文字に変換するのに必要な最小編集回数**です。</p> <p>これにより、サイズが \\((i+1) \\times (j+1)\\) の2次元 \\(dp\\) テーブルが得られます。</p> <p>第2ステップ：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>部分問題 \\(dp[i, j]\\) を考えます。これに対応する2つの文字列の末尾文字は \\(s[i-1]\\) と \\(t[j-1]\\) であり、編集操作の違いに応じて下図の3つの場合に分けられます。</p> <ol> <li>\\(s[i-1]\\) の後ろに \\(t[j-1]\\) を追加する。このとき残る部分問題は \\(dp[i, j-1]\\) です。</li> <li>\\(s[i-1]\\) を削除する。このとき残る部分問題は \\(dp[i-1, j]\\) です。</li> <li>\\(s[i-1]\\) を \\(t[j-1]\\) に置き換える。このとき残る部分問題は \\(dp[i-1, j-1]\\) です。</li> </ol> <p></p> <p> 図 14-29   編集距離の状態遷移 </p> <p>以上の分析から、最適部分構造は次のように得られます。\\(dp[i, j]\\) の最小編集回数は、\\(dp[i, j-1]\\)、\\(dp[i-1, j]\\)、\\(dp[i-1, j-1]\\) の3つのうち最小の編集回数に、今回の編集回数 \\(1\\) を加えたものです。対応する状態遷移方程式は次のとおりです：</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>注意すべき点として、\\(s[i-1]\\) と \\(t[j-1]\\) が同じ場合、現在の文字を編集する必要はありません。この場合の状態遷移方程式は次のとおりです：</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>第3ステップ：境界条件と状態遷移の順序を決める</p> <p>2つの文字列がともに空のとき、編集回数は \\(0\\)、すなわち \\(dp[0, 0] = 0\\) です。\\(s\\) が空で \\(t\\) が空でないとき、最小編集回数は \\(t\\) の長さに等しいため、先頭行は \\(dp[0, j] = j\\) です。\\(s\\) が空でなく \\(t\\) が空のとき、最小編集回数は \\(s\\) の長さに等しいため、先頭列は \\(dp[i, 0] = i\\) です。</p> <p>状態遷移方程式を観察すると、\\(dp[i, j]\\) の解は左、上、左上の解に依存します。そのため、2重ループで \\(dp\\) テーブル全体を順方向に走査すれば十分です。</p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   コードの実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"編集距離：動的計画法\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # 状態遷移：先頭行と先頭列\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # 状態遷移: 残りの行と列\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編集距離：動的計画法 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編集距離：動的計画法 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // 状態遷移：先頭行と先頭列\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編集距離：動的計画法 */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // 状態遷移：先頭行と先頭列\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編集距離：動的計画法 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // 状態遷移：先頭行と先頭列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編集距離：動的計画法 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // 状態遷移：先頭行と先頭列\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編集距離：動的計画法 */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // 状態遷移：先頭行と先頭列\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編集距離：動的計画法 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // 状態遷移：先頭行と先頭列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編集距離：動的計画法 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // 状態遷移：先頭行と先頭列\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編集距離：動的計画法 ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # 状態遷移：先頭行と先頭列\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # 状態遷移: 残りの行と列\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>下図に示すように、編集距離問題の状態遷移の過程はナップサック問題と非常によく似ており、どちらも2次元グリッドを埋めていく過程とみなせます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-30   編集距離の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   空間最適化","text":"<p>\\(dp[i,j]\\) は上の \\(dp[i-1, j]\\)、左の \\(dp[i, j-1]\\)、左上の \\(dp[i-1, j-1]\\) から遷移されますが、順方向走査では左上の \\(dp[i-1, j-1]\\) を失い、逆方向走査では \\(dp[i, j-1]\\) を事前に構築できません。そのため、どちらの走査順序も適切ではありません。</p> <p>そのため、変数 <code>leftup</code> を用いて左上の解 \\(dp[i-1, j-1]\\) を一時保存し、左と上の解だけを考えればよくなります。このときの状況は完全ナップサック問題と同じであり、順方向走査を用いることができます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"編集距離：空間最適化した動的計画法\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # 状態遷移：先頭行\n    for j in range(1, m + 1):\n        dp[j] = j\n    # 状態遷移：残りの行\n    for i in range(1, n + 1):\n        # 状態遷移：先頭列\n        leftup = dp[0]  # dp[i-1, j-1] を一時保存する\n        dp[0] += 1\n        # 状態遷移：残りの列\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            else:\n                # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # 次の反復の dp[i-1, j-1] に更新する\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // 状態遷移：先頭行\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for i := 1; i &lt;= n; i++ {\n        // 状態遷移：先頭列\n        leftUp := dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftUp\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // 状態遷移：先頭行\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for i in 1 ... n {\n        // 状態遷移：先頭列\n        var leftup = dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        let leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 状態遷移：先頭行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (let i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        let leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // 状態遷移：先頭行\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // 状態遷移：残りの行\n  for (int i = 1; i &lt;= n; i++) {\n    // 状態遷移：先頭列\n    int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n    dp[0] = i;\n    // 状態遷移：残りの列\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[j] = leftup;\n      } else {\n        // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // 状態遷移：先頭行\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // 状態遷移：残りの行\n    for i in 1..=n {\n        // 状態遷移：先頭列\n        let mut leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i as i32;\n        // 状態遷移：残りの列\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編集距離：空間最適化した動的計画法 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // 状態遷移：先頭行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 状態遷移：残りの行\n    for (int i = 1; i &lt;= n; i++) {\n        // 状態遷移：先頭列\n        int leftup = dp[0]; // dp[i-1, j-1] を一時保存する\n        dp[0] = i;\n        // 状態遷移：残りの列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup;\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    int res = dp[m];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編集距離：空間最適化した動的計画法 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // 状態遷移：先頭行\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // 状態遷移：残りの行\n    for (i in 1..n) {\n        // 状態遷移：先頭列\n        var leftup = dp[0] // dp[i-1, j-1] を一時保存する\n        dp[0] = i\n        // 状態遷移：残りの列\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // 2 つの文字が等しければ、その 2 文字をそのままスキップする\n                dp[j] = leftup\n            } else {\n                // 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 次の反復の dp[i-1, j-1] に更新する\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編集距離：空間最適化した動的計画法 ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # 状態遷移：先頭行\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # 状態遷移：残りの行\n  for i in 1...(n + 1)\n    # 状態遷移：先頭列\n    leftup = dp.first # dp[i-1, j-1] を一時保存する\n    dp[0] += 1\n    # 状態遷移：残りの列\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # 2 つの文字が等しければ、その 2 文字をそのままスキップする\n        dp[j] = leftup\n      else\n        # 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # 次の反復の dp[i-1, j-1] に更新する\n    end\n  end\n  dp[m]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.6 &nbsp; 編集距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   動的計画法入門","text":"<p>動的計画法（dynamic programming）は重要なアルゴリズムパラダイムであり、問題をより小さな部分問題の列に分解し、それらの解を保存して重複計算を避けることで、時間効率を大幅に向上させます。</p> <p>本節では、古典的な例題から始めて、まずその力任せのバックトラッキング解法を示し、そこに含まれる重複部分問題を観察したうえで、より効率的な動的計画法の解法を段階的に導きます。</p> <p>階段を上る</p> <p>全体で \\(n\\) 段ある階段が与えられ、各ステップで \\(1\\) 段または \\(2\\) 段上ることができます。頂上まで到達する方法は何通りあるでしょうか？</p> <p>次の図に示すように、\\(3\\) 段の階段では、頂上まで到達する方法は全部で \\(3\\) 通りあります。</p> <p></p> <p> 図 14-1   3 段の階段を上る方法の数 </p> <p>この問題の目的は方法の総数を求めることです。考えられるすべての可能性をバックトラッキングで総当たりすることができます。具体的には、階段を上ることを複数ラウンドの選択過程とみなし、地面から出発して各ラウンドで \\(1\\) 段または \\(2\\) 段上ります。階段の頂上に到達するたびに方法数を \\(1\\) 増やし、頂上を越えた場合は枝刈りします。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"バックトラッキング\"\"\"\n    # 第 n 段に到達したら、方法数を 1 増やす\n    if state == n:\n        res[0] += 1\n    # すべての選択肢を走査\n    for choice in choices:\n        # 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n:\n            continue\n        # 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res)\n        # バックトラック\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"階段登り：バックトラッキング\"\"\"\n    choices = [1, 2]  # 1 段または 2 段上ることを選べる\n    state = 0  # 第 0 段から上り始める\n    res = [0]  # res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* バックトラッキング */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    for (auto &amp;choice : choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // 1 段または 2 段上ることを選べる\n    int state = 0;                // 第 0 段から上り始める\n    vector&lt;int&gt; res = {0};        // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* バックトラッキング */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (Integer choice : choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // 1 段または 2 段上ることを選べる\n    int state = 0; // 第 0 段から上り始める\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* バックトラッキング */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    foreach (int choice in choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        Backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    int state = 0; // 第 0 段から上り始める\n    List&lt;int&gt; res = [0]; // res[0] を使って方法数を記録する\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* バックトラッキング */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // すべての選択肢を走査\n    for _, choice := range choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state+choice &gt; n {\n            continue\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state+choice, n, res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunc climbingStairsBacktrack(n int) int {\n    // 1 段または 2 段上ることを選べる\n    choices := []int{1, 2}\n    // 第 0 段から上り始める\n    state := 0\n    res := make([]int, 1)\n    // res[0] を使って方法数を記録する\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* バックトラッキング */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] += 1\n    }\n    // すべての選択肢を走査\n    for choice in choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n {\n            continue\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // 1 段または 2 段上ることを選べる\n    let state = 0 // 第 0 段から上り始める\n    var res: [Int] = []\n    res.append(0) // res[0] を使って方法数を記録する\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* バックトラッキング */\nfunction backtrack(choices, state, n, res) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state === n) res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    const state = 0; // 第 0 段から上り始める\n    const res = new Map();\n    res.set(0, 0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* バックトラッキング */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state === n) res.set(0, res.get(0) + 1);\n    // すべての選択肢を走査\n    for (const choice of choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // 1 段または 2 段上ることを選べる\n    const state = 0; // 第 0 段から上り始める\n    const res = new Map();\n    res.set(0, 0); // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* バックトラッキング */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // 第 n 段に到達したら、方法数を 1 増やす\n  if (state == n) {\n    res[0]++;\n  }\n  // すべての選択肢を走査\n  for (int choice in choices) {\n    // 枝刈り: 第 n 段を超えないようにする\n    if (state + choice &gt; n) continue;\n    // 試行: 選択を行い、状態を更新\n    backtrack(choices, state + choice, n, res);\n    // バックトラック\n  }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // 1 段または 2 段上ることを選べる\n  int state = 0; // 第 0 段から上り始める\n  List&lt;int&gt; res = [];\n  res.add(0); // res[0] を使って方法数を記録する\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* バックトラッキング */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // すべての選択肢を走査\n    for &amp;choice in choices {\n        // 枝刈り: 第 n 段を超えないようにする\n        if state + choice &gt; n {\n            continue;\n        }\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // 1 段または 2 段上ることを選べる\n    let state = 0; // 第 0 段から上り始める\n    let mut res = Vec::new();\n    res.push(0); // res[0] を使って方法数を記録する\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* バックトラッキング */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0]++;\n    // すべての選択肢を走査\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n)\n            continue;\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res, len);\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // 1 段または 2 段上ることを選べる\n    int state = 0;           // 第 0 段から上り始める\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // res[0] を使って方法数を記録する\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* バックトラッキング */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // 第 n 段に到達したら、方法数を 1 増やす\n    if (state == n)\n        res[0] = res[0] + 1\n    // すべての選択肢を走査\n    for (choice in choices) {\n        // 枝刈り: 第 n 段を超えないようにする\n        if (state + choice &gt; n) continue\n        // 試行: 選択を行い、状態を更新\n        backtrack(choices, state + choice, n, res)\n        // バックトラック\n    }\n}\n\n/* 階段登り：バックトラッキング */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // 1 段または 2 段上ることを選べる\n    val state = 0 // 第 0 段から上り始める\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // res[0] を使って方法数を記録する\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### バックトラッキング ###\ndef backtrack(choices, state, n, res)\n  # 第 n 段に到達したら、方法数を 1 増やす\n  res[0] += 1 if state == n\n  # すべての選択肢を走査\n  for choice in choices\n    # 枝刈り: 第 n 段を超えないようにする\n    next if state + choice &gt; n\n\n    # 試行: 選択を行い、状態を更新\n    backtrack(choices, state + choice, n, res)\n  end\n  # バックトラック\nend\n\n### 階段登り：バックトラッキング ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # 1 段または 2 段上ることを選べる\n  state = 0 # 第 0 段から上り始める\n  res = [0] # res[0] を使って方法数を記録する\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-1","level":2,"title":"14.1.1   方法 1：総当たり探索","text":"<p>バックトラッキング法は通常、問題を明示的に分解するのではなく、問題解決を一連の意思決定ステップとみなし、試行と枝刈りによってあらゆる可能な解を探索します。</p> <p>この問題を問題分解の観点から分析してみましょう。\\(i\\) 段目まで上る方法が全部で \\(dp[i]\\) 通りあるとすると、\\(dp[i]\\) が元の問題であり、その部分問題には次が含まれます：</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>各ラウンドでは \\(1\\) 段または \\(2\\) 段しか上れないため、\\(i\\) 段目の階段に立っているとき、直前のラウンドでは \\(i - 1\\) 段目または \\(i - 2\\) 段目にしか立てません。言い換えると、\\(i -1\\) 段目または \\(i - 2\\) 段目からしか \\(i\\) 段目へ進めません。</p> <p>ここから重要な帰結が得られます。**\\(i - 1\\) 段目まで上る方法数と \\(i - 2\\) 段目まで上る方法数の和が、\\(i\\) 段目まで上る方法数に等しい**のです。式は次のとおりです：</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>これは、階段を上る問題では各部分問題の間に漸化関係があり、**元の問題の解は部分問題の解から構築できる**ことを意味します。次の図はこの漸化関係を示しています。</p> <p></p> <p> 図 14-2   方法数の漸化関係 </p> <p>漸化式に基づいて総当たり探索の解法を得ることができます。\\(dp[n]\\) を出発点とし、**より大きな問題を再帰的に 2 つのより小さな問題の和へ分解**していき、最小部分問題 \\(dp[1]\\) と \\(dp[2]\\) に到達したら返します。ここで最小部分問題の解は既知であり、\\(dp[1] = 1\\)、\\(dp[2] = 2\\) です。これは、第 \\(1\\) 段目と第 \\(2\\) 段目まで上る方法がそれぞれ \\(1\\) 通り、\\(2\\) 通りであることを表します。</p> <p>次のコードを見ると、標準的なバックトラッキングコードと同じく深さ優先探索に属しますが、より簡潔です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"検索\"\"\"\n    # dp[1] と dp[2] は既知なので返す\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"階段登り：探索\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* 検索 */\nint DFS(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* 検索 */\nfunc dfs(i int) int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* 階段登り：探索 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* 検索 */\nfunc dfs(i: Int) -&gt; Int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* 階段登り：探索 */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* 検索 */\nfunction dfs(i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* 検索 */\nfunction dfs(i: number): number {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* 検索 */\nint dfs(int i) {\n  // dp[1] と dp[2] は既知なので返す\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* 検索 */\nfn dfs(i: usize) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* 階段登り：探索 */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* 検索 */\nint dfs(int i) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 階段登り：探索 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* 検索 */\nfun dfs(i: Int): Int {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* 階段登り：探索 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### 探索 ###\ndef dfs(i)\n  # dp[1] と dp[2] は既知なので返す\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### 階段登り：探索 ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は総当たり探索によって形成される再帰木を示しています。問題 \\(dp[n]\\) に対して、その再帰木の深さは \\(n\\)、時間計算量は \\(O(2^n)\\) です。指数オーダーは爆発的に増加するため、比較的大きな \\(n\\) を入力すると長時間待たされることになります。</p> <p></p> <p> 図 14-3   階段上りに対応する再帰木 </p> <p>上の図を見ると、指数オーダーの時間計算量は「重複部分問題」によって生じています。たとえば \\(dp[9]\\) は \\(dp[8]\\) と \\(dp[7]\\) に分解され、\\(dp[8]\\) は \\(dp[7]\\) と \\(dp[6]\\) に分解されるため、どちらにも部分問題 \\(dp[7]\\) が含まれています。</p> <p>このように、部分問題の中にはさらに小さな重複部分問題が含まれ、それが際限なく続いていきます。計算資源の大部分は、こうした重複部分問題に浪費されています。</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-2","level":2,"title":"14.1.2   方法 2：メモ化探索","text":"<p>アルゴリズム効率を高めるため、**すべての重複部分問題を 1 回だけ計算したい**と考えます。そのために、各部分問題の解を記録する配列 <code>mem</code> を宣言し、探索の過程で重複部分問題を枝刈りします。</p> <ol> <li>\\(dp[i]\\) を初めて計算したとき、その結果を <code>mem[i]</code> に記録して後で使えるようにします。</li> <li>再び \\(dp[i]\\) を計算する必要が生じたときは、<code>mem[i]</code> から直接結果を取得し、その部分問題の重複計算を避けます。</li> </ol> <p>コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"メモ化探索\"\"\"\n    # dp[1] と dp[2] は既知なので返す\n    if i == 1 or i == 2:\n        return i\n    # dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # dp[i] を記録する\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"階段登り：メモ化探索\"\"\"\n    # mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* メモ化探索 */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* メモ化探索 */\nint dfs(int i, int[] mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* メモ化探索 */\nint DFS(int i, int[] mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* メモ化探索 */\nfunc dfsMem(i int, mem []int) int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* メモ化探索 */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* メモ化探索 */\nfunction dfs(i, mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* メモ化探索 */\nfunction dfs(i: number, mem: number[]): number {\n    // dp[1] と dp[2] は既知なので返す\n    if (i === 1 || i === 2) return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* メモ化探索 */\nint dfs(int i, List&lt;int&gt; mem) {\n  // dp[1] と dp[2] は既知なので返す\n  if (i == 1 || i == 2) return i;\n  // dp[i] の記録があれば、それをそのまま返す\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // dp[i] を記録する\n  mem[i] = count;\n  return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n  // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* メモ化探索 */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] の記録があれば、それをそのまま返す\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    count\n}\n\n/* 階段登り：メモ化探索 */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* メモ化探索 */\nint dfs(int i, int *mem) {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // dp[i] を記録する\n    mem[i] = count;\n    return count;\n}\n\n/* 階段登り：メモ化探索 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* メモ化探索 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // dp[1] と dp[2] は既知なので返す\n    if (i == 1 || i == 2) return i\n    // dp[i] の記録があれば、それをそのまま返す\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // dp[i] を記録する\n    mem[i] = count\n    return count\n}\n\n/* 階段登り：メモ化探索 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### メモ化探索 ###\ndef dfs(i, mem)\n  # dp[1] と dp[2] は既知なので返す\n  return i if i == 1 || i == 2\n  # dp[i] の記録があれば、それをそのまま返す\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # dp[i] を記録する\n  mem[i] = count\nend\n\n### 階段登り：メモ化探索 ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図を見ると、メモ化を行うことで、すべての重複部分問題は 1 回だけ計算すればよくなり、時間計算量は \\(O(n)\\) まで改善されます。これは大きな飛躍です。</p> <p></p> <p> 図 14-4   メモ化探索に対応する再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-3","level":2,"title":"14.1.3   方法 3：動的計画法","text":"<p>**メモ化探索は「トップダウン」の方法**です。元の問題（根ノード）から始めて、より大きな部分問題を再帰的により小さな部分問題へ分解し、解が既知である最小部分問題（葉ノード）に至ります。その後、バックトラックしながら各層で部分問題の解を集め、元の問題の解を構築します。</p> <p>これとは対照的に、**動的計画法は「ボトムアップ」の方法**です。最小部分問題の解から始めて、より大きな部分問題の解を反復的に構築し、最終的に元の問題の解を得ます。</p> <p>動的計画法にはバックトラックの過程が含まれないため、再帰を使う必要はなく、ループによる反復だけで実装できます。次のコードでは、部分問題の解を保存する配列 <code>dp</code> を初期化しており、これはメモ化探索における配列 <code>mem</code> と同じ記録の役割を果たします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"階段登り：動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # 部分問題の解を保存するために dp テーブルを初期化\n    dp = [0] * (n + 1)\n    # 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1], dp[2] = 1, 2\n    # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    vector&lt;int&gt; dp(n + 1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 階段登り：動的計画法 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int[] dp = new int[n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 階段登り：動的計画法 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    dp := make([]int, n+1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 階段登り：動的計画法 */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 階段登り：動的計画法 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1).fill(-1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 階段登り：動的計画法 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    const dp = new Array(n + 1).fill(-1);\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // 部分問題の解を保存するために dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1] = 1;\n  dp[2] = 2;\n  // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 階段登り：動的計画法 */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // dp[1] と dp[2] は既知なので返す\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // 部分問題の解を保存するために dp テーブルを初期化\n    let mut dp = vec![-1; n + 1];\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 階段登り：動的計画法 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 部分問題の解を保存するために dp テーブルを初期化\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1;\n    dp[2] = 2;\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 階段登り：動的計画法 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // 部分問題の解を保存するために dp テーブルを初期化\n    val dp = IntArray(n + 1)\n    // 初期状態：最小部分問題の解をあらかじめ設定\n    dp[1] = 1\n    dp[2] = 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 階段登り：動的計画法 ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # 部分問題の解を保存するために dp テーブルを初期化\n  dp = Array.new(n + 1, 0)\n  # 初期状態：最小部分問題の解をあらかじめ設定\n  dp[1], dp[2] = 1, 2\n  # 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、以上のコードの実行過程をシミュレートしたものです。</p> <p></p> <p> 図 14-5   階段上りの動的計画法の過程 </p> <p>バックトラッキング法と同様に、動的計画法でも問題解決の特定段階を表すために「状態」という概念を用います。各状態は 1 つの部分問題と、それに対応する局所最適解に対応します。たとえば、階段を上る問題では、状態は現在いる階段の段数 \\(i\\) と定義されます。</p> <p>以上を踏まえると、動的計画法のよく使われる用語を次のようにまとめられます。</p> <ul> <li>配列 <code>dp</code> を dp テーブル と呼び、\\(dp[i]\\) は状態 \\(i\\) に対応する部分問題の解を表します。</li> <li>最小部分問題に対応する状態（第 \\(1\\) 段目と第 \\(2\\) 段目の階段）を初期状態と呼びます。</li> <li>漸化式 \\(dp[i] = dp[i-1] + dp[i-2]\\) を状態遷移方程式と呼びます。</li> </ul>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   空間最適化","text":"<p>注意深い読者は気づいたかもしれません。\\(dp[i]\\) は \\(dp[i-1]\\) と \\(dp[i-2]\\) にしか依存しないため、すべての部分問題の解を保存するために配列 <code>dp</code> を使う必要はありません。2 つの変数を順に更新していくだけで十分です。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"階段登り：空間最適化した動的計画法\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // 状態遷移：小さい部分問題から大きい部分問題へ順に解く\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 階段登り：空間最適化した動的計画法 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 階段登り：空間最適化した動的計画法 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 階段登り：空間最適化後の動的計画法 ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上のコードを見ると、配列 <code>dp</code> が占めていた領域を省けるため、空間計算量は \\(O(n)\\) から \\(O(1)\\) へと下がります。</p> <p>動的計画法の問題では、現在の状態はしばしば直前の限られた個数の状態にしか関係しません。このような場合は、必要な状態だけを保持し、「次元削減」によってメモリ空間を節約できます。この空間最適化の技巧は「ローリング変数」または「ローリング配列」と呼ばれます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.1 &nbsp; 動的計画法入門"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 ナップサック問題","text":"<p>ナップサック問題は、動的計画法の入門として非常に適した問題であり、動的計画法で最もよく見られる問題形式の1つです。これには 0-1 ナップサック問題、完全ナップサック問題、多重ナップサック問題など、多くの派生があります。</p> <p>本節では、まず最も一般的な 0-1 ナップサック問題を解いていきます。</p> <p>Question</p> <p>\\(n\\) 個の品物が与えられ、\\(i\\) 番目の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量 \\(cap\\) のナップサックがあります。各品物は1回しか選べないとき、ナップサック容量の制約下で入れられる品物の最大価値を求めてください。</p> <p>以下の図を見てみましょう。品物番号 \\(i\\) は \\(1\\) から始まり、配列のインデックスは \\(0\\) から始まるため、品物 \\(i\\) は重さ \\(wgt[i-1]\\)、価値 \\(val[i-1]\\) に対応します。</p> <p></p> <p> 図 14-17   0-1 ナップサックのサンプルデータ </p> <p>0-1 ナップサック問題は、\\(n\\) 回の意思決定からなる過程とみなせます。各品物について「入れない」「入れる」という2つの選択肢があるため、この問題は決定木モデルを満たします。</p> <p>この問題の目的は「ナップサック容量の制約下で入れられる品物の最大価値」を求めることなので、動的計画法の問題である可能性が高いです。</p> <p>ステップ1：各ラウンドの選択を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>各品物について、ナップサックに入れなければ容量は変わらず、入れれば容量は減少します。ここから状態を、現在の品物番号 \\(i\\) とナップサック容量 \\(c\\) として定義し、\\([i, c]\\) と表せます。</p> <p>状態 \\([i, c]\\) に対応する部分問題は、先頭 \\(i\\) 個の品物を容量 \\(c\\) のナップサックに入れるときの最大価値 であり、これを \\(dp[i, c]\\) と記します。</p> <p>求めるべきものは \\(dp[n, cap]\\) なので、サイズ \\((n+1) \\times (cap+1)\\) の2次元 \\(dp\\) テーブルが必要です。</p> <p>ステップ2：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>品物 \\(i\\) に対する選択を行った後に残るのは、先頭 \\(i-1\\) 個の品物に対する部分問題であり、次の2つのケースに分けられます。</p> <ul> <li>品物 \\(i\\) を入れない ：ナップサック容量は変わらず、状態は \\([i-1, c]\\) に変化します。</li> <li>品物 \\(i\\) を入れる ：ナップサック容量は \\(wgt[i-1]\\) だけ減少し、価値は \\(val[i-1]\\) だけ増加して、状態は \\([i-1, c-wgt[i-1]]\\) に変化します。</li> </ul> <p>以上の分析から、この問題の最適部分構造が分かります。すなわち、最大価値 \\(dp[i, c]\\) は、品物 \\(i\\) を入れない場合と入れる場合のうち、より価値の大きい方に等しい ということです。これにより、次の状態遷移方程式を導けます。</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>注意すべき点として、現在の品物の重さ \\(wgt[i - 1]\\) が残りのナップサック容量 \\(c\\) を超える場合は、入れない選択しかできません。</p> <p>ステップ3：境界条件と状態遷移の順序を決める</p> <p>品物がない場合、またはナップサック容量が \\(0\\) の場合、最大価値は \\(0\\) です。すなわち、先頭列 \\(dp[i, 0]\\) と先頭行 \\(dp[0, c]\\) はいずれも \\(0\\) になります。</p> <p>現在の状態 \\([i, c]\\) は、上側の状態 \\([i-1, c]\\) と左上の状態 \\([i-1, c-wgt[i-1]]\\) から遷移してくるため、2重ループで \\(dp\\) テーブル全体を順方向に走査すれば十分です。</p> <p>以上の分析に基づき、次に全探索、メモ化探索、動的計画法の順で実装していきます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-1","level":3,"title":"1.   方法1：全探索","text":"<p>探索コードには次の要素が含まれます。</p> <ul> <li>再帰引数：状態 \\([i, c]\\) です。</li> <li>戻り値：部分問題の解 \\(dp[i, c]\\) です。</li> <li>終了条件：品物番号が範囲外である \\(i = 0\\)、またはナップサックの残り容量が \\(0\\) のとき、再帰を終了して価値 \\(0\\) を返します。</li> <li>枝刈り：現在の品物の重さがナップサックの残り容量を超える場合、入れない選択しかできません。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 ナップサック：総当たり探索\"\"\"\n    # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 or c == 0:\n        return 0\n    # ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // 2つの案のうち価値が大きいほうを返す\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // ナップサック容量を超える場合は、入れない選択しかできない\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // 品物 i を入れない場合と入れる場合の最大価値を計算する\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 2つの案のうち価値が大きいほうを返す\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：総当たり探索 */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2つの案のうち価値が大きいほうを返す\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：総当たり探索 */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 2つの案のうち価値が大きいほうを返す\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 全探索 ###\ndef knapsack_dfs(wgt, val, i, c)\n  # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  return 0 if i == 0 || c == 0\n  # ナップサック容量を超える場合は、入れない選択しかできない\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # 品物 i を入れない場合と入れる場合の最大価値を計算する\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 2つの案のうち価値が大きいほうを返す\n  [no, yes].max\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図のように、各品物ごとに「選ばない」「選ぶ」の2つの探索分岐が生じるため、時間計算量は \\(O(2^n)\\) です。</p> <p>再帰木を観察すると、\\(dp[1, 10]\\) などの重複部分問題が存在することが分かります。品物数が多く、ナップサック容量が大きく、特に同じ重さの品物が多い場合には、重複部分問題の数は大幅に増加します。</p> <p></p> <p> 図 14-18   0-1 ナップサック問題の全探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-2","level":3,"title":"2.   方法2：メモ化探索","text":"<p>重複部分問題が一度だけ計算されるようにするため、メモ配列 <code>mem</code> を用いて部分問題の解を記録します。ここで <code>mem[i][c]</code> は \\(dp[i, c]\\) に対応します。</p> <p>メモ化を導入すると、時間計算量は部分問題の数に依存し、すなわち \\(O(n \\times cap)\\) になります。実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 ナップサック：メモ化探索\"\"\"\n    # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 or c == 0:\n        return 0\n    # 既に記録があればそのまま返す\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // 2つの案のうち価値が大きいほうを返す\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 既に記録があればそのまま返す\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // ナップサック容量を超える場合は、入れない選択しかできない\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // 品物 i を入れない場合と入れる場合の最大価値を計算する\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 2 つの案のうち価値が大きい方を記録して返す\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：メモ化探索 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：メモ化探索 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 既に記録があればそのまま返す\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // ナップサック容量を超える場合は、入れない選択しかできない\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // 品物 i を入れない場合と入れる場合の最大価値を計算する\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 2 つの案のうち価値が大きい方を記録して返す\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: メモ化探索 ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す\n  return 0 if i == 0 || c == 0\n  # 既に記録があればそのまま返す\n  return mem[i][c] if mem[i][c] != -1\n  # ナップサック容量を超える場合は、入れない選択しかできない\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # 品物 i を入れない場合と入れる場合の最大価値を計算する\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 2 つの案のうち価値が大きい方を記録して返す\n  mem[i][c] = [no, yes].max\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は、メモ化探索で剪定された探索分岐を示しています。</p> <p></p> <p> 図 14-19   0-1 ナップサック問題のメモ化探索の再帰木 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-3","level":3,"title":"3.   方法3：動的計画法","text":"<p>動的計画法の本質は、状態遷移に従って \\(dp\\) テーブルを埋めていく過程です。コードは次のようになります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 ナップサック：動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 状態遷移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：動的計画法 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：動的計画法 */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：動的計画法 */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：動的計画法 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：動的計画法 */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 動的計画法 ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>以下の図のように、時間計算量と空間計算量はいずれも配列 <code>dp</code> のサイズによって決まり、\\(O(n \\times cap)\\) です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-20   0-1 ナップサック問題の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   空間最適化","text":"<p>各状態は直前の行の状態にしか依存しないため、2つの配列をローテーションして用いることで、空間計算量を \\(O(n^2)\\) から \\(O(n)\\) に削減できます。</p> <p>さらに考えると、1つの配列だけで空間最適化を実現できるでしょうか。観察すると、各状態は真上または左上のマスから遷移してきます。配列が1つしかないと仮定すると、\\(i\\) 行目の走査を開始した時点では、その配列にはまだ \\(i-1\\) 行目の状態が格納されています。</p> <ul> <li>順方向に走査すると、\\(dp[i, j]\\) に到達した時点で、左上にある \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) の値がすでに上書きされている可能性があり、正しい状態遷移結果を得られません。</li> <li>逆方向に走査すれば、上書きの問題は発生せず、状態遷移を正しく行えます。</li> </ul> <p>次の図は、単一配列のもとで \\(i = 1\\) 行目から \\(i = 2\\) 行目へ変換する過程を示しています。順方向走査と逆方向走査の違いを考えてみてください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-21   0-1 ナップサックの空間最適化後の動的計画法の過程 </p> <p>コード実装では、配列 <code>dp</code> の第1次元 \\(i\\) をそのまま削除し、内側のループを逆方向走査に変更するだけで済みます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 ナップサック：空間最適化後の動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [0] * (cap + 1)\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 逆順に走査する\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([]int, cap+1)\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 逆順に走査する\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        // 逆順に走査する\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(cap + 1).fill(0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array(cap + 1).fill(0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    // 逆順に走査する\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; cap + 1];\n    // 状態遷移\n    for i in 1..=n {\n        // 逆順に走査する\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        // 逆順に走査する\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 ナップサック：空間最適化後の動的計画法 */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = IntArray(cap + 1)\n    // 状態遷移\n    for (i in 1..n) {\n        // 逆順に走査する\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 ナップサック: 空間最適化後の動的計画法 ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(cap + 1, 0)\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 逆順に走査する\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.4 &nbsp; 0-1 ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   まとめ","text":"","path":["第 14 章 &nbsp; 動的計画法","14.7 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>動的計画法は問題を分解し、部分問題の解を保存することで重複計算を避け、計算効率を高めます。</li> <li>時間を考慮しなければ、すべての動的計画法の問題はバックトラッキング（総当たり探索）で解けますが、再帰木には大量の重複部分問題が存在するため、効率はきわめて低くなります。メモ化配列を導入すると、計算済みのすべての部分問題の解を保存でき、重複部分問題が 1 回だけ計算されることを保証できます。</li> <li>メモ化探索はトップダウンの再帰的解法であり、それに対応する動的計画法はボトムアップの漸化式による解法で、ちょうど「表を埋める」ようなものです。現在の状態は一部の局所状態にのみ依存するため、\\(dp\\) 表の 1 次元を削減して空間計算量を下げることができます。</li> <li>部分問題への分解は汎用的なアルゴリズムの考え方であり、分割統治、動的計画法、バックトラッキングではそれぞれ異なる性質を持ちます。</li> <li>動的計画法の問題には 3 つの大きな特徴があります。重複部分問題、最適部分構造、無後効性です。</li> <li>元の問題の最適解が部分問題の最適解から構築できるなら、その問題は最適部分構造を持ちます。</li> <li>無後効性とは、ある状態の将来の発展がその状態のみに関係し、過去に経たすべての状態とは無関係であることを指します。多くの組合せ最適化問題は無後効性を持たず、動的計画法で高速に解くことはできません。</li> </ul> <p>ナップサック問題</p> <ul> <li>ナップサック問題は最も典型的な動的計画法の問題の 1 つであり、0-1 ナップサック、完全ナップサック、多重ナップサックなどの派生があります。</li> <li>0-1 ナップサックの状態は、容量 \\(c\\) のナップサックに対して、前 \\(i\\) 個の品物で得られる最大価値として定義されます。ナップサックに入れない場合と入れる場合の 2 つの判断から最適部分構造を得て、状態遷移方程式を構築できます。空間最適化では、各状態が真上と左上の状態に依存するため、左上の状態が上書きされるのを避けるために配列を逆順に走査する必要があります。</li> <li>完全ナップサック問題では各品物の選択数に制限がないため、品物を入れる場合の状態遷移は 0-1 ナップサック問題とは異なります。状態は真上と真左の状態に依存するので、空間最適化では順方向に走査するべきです。</li> <li>コイン両替問題は完全ナップサック問題の変種です。「最大」価値を求める問題から「最小」の硬貨枚数を求める問題へ変わるため、状態遷移方程式の \\(\\max()\\) は \\(\\min()\\) に置き換える必要があります。また、ナップサック容量を「超えない」ことを目指すのではなく、目標金額を「ちょうど」作ることを目指すため、\\(amt + 1\\) を「目標金額を作れない」無効解の表現として用います。</li> <li>コイン両替問題 II では、「最少硬貨枚数」を求める問題から「硬貨の組合せ数」を求める問題へ変わるため、状態遷移方程式も \\(\\min()\\) から総和演算子へ対応して変わります。</li> </ul> <p>編集距離問題</p> <ul> <li>編集距離（Levenshtein 距離）は 2 つの文字列間の類似度を測るために用いられ、ある文字列を別の文字列へ変換するための最小編集回数として定義されます。編集操作には追加、削除、置換が含まれます。</li> <li>編集距離問題の状態は、\\(s\\) の前 \\(i\\) 文字を \\(t\\) の前 \\(j\\) 文字へ変更するのに必要な最小編集回数として定義されます。\\(s[i] \\ne t[j]\\) のときは、追加、削除、置換の 3 つの判断があり、それぞれに対応する残りの部分問題があります。これにより最適部分構造を見いだし、状態遷移方程式を構築できます。一方、\\(s[i] = t[j]\\) のときは現在の文字を編集する必要はありません。</li> <li>編集距離では、状態は真上、真左、左上の状態に依存します。そのため、空間最適化後は順方向でも逆方向でも正しく状態遷移できません。そこで、変数を 1 つ用いて左上の状態を一時保存し、完全ナップサック問題と等価な形へ変換することで、空間最適化後に順方向走査を行えるようにします。</li> </ul>","path":["第 14 章 &nbsp; 動的計画法","14.7 &nbsp; まとめ"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   完全ナップサック問題","text":"<p>本節では、まずもう 1 つの代表的なナップサック問題である完全ナップサック問題を解き、その特殊例である硬貨交換問題について見ていきます。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   完全ナップサック問題","text":"<p>Question</p> <p>\\(n\\) 個の品物が与えられ、\\(i\\) 番目の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量 \\(cap\\) のナップサックがあります。各品物は繰り返し選択できます。ナップサック容量の制約下で入れられる品物の最大価値を求めてください。例を以下の図に示します。</p> <p></p> <p> 図 14-22   完全ナップサック問題のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   動的計画法の考え方","text":"<p>完全ナップサック問題は 0-1 ナップサック問題と非常によく似ています。違いは、品物の選択回数に制限がない点だけです。</p> <ul> <li>0-1 ナップサック問題では、各品物は 1 つしかないため、品物 \\(i\\) をナップサックに入れた後は先頭 \\(i-1\\) 個の品物からしか選べません。</li> <li>完全ナップサック問題では、各品物の数は無限であるため、品物 \\(i\\) をナップサックに入れた後も、引き続き先頭 \\(i\\) 個の品物から選べます。</li> </ul> <p>完全ナップサック問題では、状態 \\([i, c]\\) の変化は 2 つの場合に分けられます。</p> <ul> <li>品物 \\(i\\) を入れない ：0-1 ナップサック問題と同様に、\\([i-1, c]\\) へ遷移します。</li> <li>品物 \\(i\\) を入れる ：0-1 ナップサック問題とは異なり、\\([i, c-wgt[i-1]]\\) へ遷移します。</li> </ul> <p>したがって、状態遷移方程式は次のようになります。</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   コード実装","text":"<p>2 つの問題のコードを比較すると、状態遷移の中で 1 か所だけ \\(i-1\\) が \\(i\\) に変わり、それ以外は完全に同じです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全ナップサック問題：動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 状態遷移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全ナップサック問題：動的計画法 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全ナップサック問題：動的計画法 */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全ナップサック問題：動的計画法 */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全ナップサック問題：動的計画法 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全ナップサック問題：動的計画法 */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全ナップサック：動的計画法 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   空間最適化","text":"<p>現在の状態は左側と上側の状態から遷移してくるため、空間最適化後は \\(dp\\) テーブルの各行を順方向に走査する必要があります。</p> <p>この走査順序は 0-1 ナップサックとはちょうど逆です。両者の違いは次の図を用いて理解してください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-23   完全ナップサック問題における空間最適化後の動的計画法の過程 </p> <p>コード実装は比較的簡単で、配列 <code>dp</code> の第 1 次元を削除するだけです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全ナップサック問題：空間最適化後の動的計画法\"\"\"\n    n = len(wgt)\n    # dp テーブルを初期化\n    dp = [0] * (cap + 1)\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            else:\n                # 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[cap + 1];\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // dp テーブルを初期化\n    dp := make([]int, cap+1)\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 状態遷移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c];\n      } else {\n        // 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; cap + 1];\n    // 状態遷移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // dp テーブルを初期化\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c];\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全ナップサック問題：空間最適化後の動的計画法 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // dp テーブルを初期化\n    val dp = IntArray(cap + 1)\n    // 状態遷移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // ナップサック容量を超えるなら品物 i は選ばない\n                dp[c] = dp[c]\n            } else {\n                // 品物 i を選ばない場合と選ぶ場合の大きい方\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全ナップサック：動的計画法 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n# ## 完全ナップサック: 空間最適化後の動的計画法 ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # dp テーブルを初期化\n  dp = Array.new(cap + 1, 0)\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # ナップサック容量を超えるなら品物 i は選ばない\n        dp[c] = dp[c]\n      else\n        # 品物 i を選ばない場合と選ぶ場合の大きい方\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   硬貨交換問題","text":"<p>ナップサック問題は動的計画法の代表的な問題群であり、多くの派生問題があります。硬貨交換問題もその 1 つです。</p> <p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は繰り返し選択できます。目標金額を作るために必要な最小の硬貨枚数を求めてください。目標金額を作れない場合は \\(-1\\) を返します。例を以下の図に示します。</p> <p></p> <p> 図 14-24   硬貨交換問題のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   動的計画法の考え方","text":"<p>硬貨交換は完全ナップサック問題の特殊なケースとみなせます。両者には次の対応関係と相違点があります。</p> <ul> <li>2 つの問題は相互に変換でき、「品物」は「硬貨」、「品物の重さ」は「硬貨の額面」、「ナップサック容量」は「目標金額」に対応します。</li> <li>最適化の目標は逆であり、完全ナップサック問題は品物価値の最大化、硬貨交換問題は硬貨枚数の最小化を目指します。</li> <li>完全ナップサック問題はナップサック容量を「超えない」解を求めますが、硬貨交換は目標金額に「ちょうど」一致する解を求めます。</li> </ul> <p>ステップ 1：各ラウンドの選択を考え、状態を定義して、\\(dp\\) テーブルを得る</p> <p>状態 \\([i, a]\\) に対応する部分問題は、**先頭 \\(i\\) 種類の硬貨で金額 \\(a\\) を作るための最小硬貨枚数**であり、これを \\(dp[i, a]\\) と表します。</p> <p>2 次元 \\(dp\\) テーブルのサイズは \\((n+1) \\times (amt+1)\\) です。</p> <p>ステップ 2：最適部分構造を見つけ、状態遷移方程式を導く</p> <p>本問の状態遷移方程式は、完全ナップサック問題と比べて次の 2 点が異なります。</p> <ul> <li>本問では最小値を求めるため、演算子 \\(\\max()\\) を \\(\\min()\\) に変更する必要があります。</li> <li>最適化の対象は品物価値ではなく硬貨枚数であるため、硬貨を選んだときは \\(+1\\) すれば十分です。</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>ステップ 3：境界条件と状態遷移順序を決める</p> <p>目標金額が \\(0\\) のとき、それを作るための最小硬貨枚数は \\(0\\) です。つまり、先頭列のすべての \\(dp[i, 0]\\) は \\(0\\) になります。</p> <p>硬貨が 1 枚もない場合、任意の \\(&gt; 0\\) の目標金額を作ることはできません。これは無効解です。状態遷移方程式内の \\(\\min()\\) 関数が無効解を識別して除外できるように、それらを \\(+ \\infty\\) で表すことを考えます。すなわち、先頭行のすべての \\(dp[0, a]\\) を \\(+ \\infty\\) とします。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   コード実装","text":"<p>多くのプログラミング言語には \\(+ \\infty\\) を表す変数が用意されていないため、通常は整数型 <code>int</code> の最大値で代用します。しかし、その場合は大きな数のオーバーフローが起こり得ます。状態遷移方程式中の \\(+ 1\\) 操作で桁あふれが発生する可能性があるためです。</p> <p>そのため、ここでは数値 \\(amt + 1\\) を無効解の表現として用います。金額 \\(amt\\) を作るための硬貨枚数は最大でも \\(amt\\) 枚だからです。最後に返す前に、\\(dp[n, amt]\\) が \\(amt + 1\\) に等しいかを判定し、等しければ \\(-1\\) を返して目標金額を作れないことを表します。コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替：動的計画法\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # dp テーブルを初期化\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 状態遷移：先頭行と先頭列\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # 状態遷移: 残りの行と列\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][amt + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* コイン両替：動的計画法 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, amt + 1];\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 状態遷移：先頭行と先頭列\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 状態遷移：先頭行と先頭列\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* コイン両替：動的計画法 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* コイン両替：動的計画法 */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 状態遷移：先頭行と先頭列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 状態遷移：先頭行と先頭列\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // 状態遷移: 残りの行と列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* コイン両替：動的計画法 */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 状態遷移：先頭行と先頭列\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // 状態遷移: 残りの行と列\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* コイン両替：動的計画法 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 状態遷移：先頭行と先頭列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 状態遷移: 残りの行と列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* コイン両替：動的計画法 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 状態遷移：先頭行と先頭列\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // 状態遷移: 残りの行と列\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### コイン両替：動的計画法 ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 状態遷移：先頭行と先頭列\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # 状態遷移: 残りの行と列\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図は硬貨交換の動的計画法の過程を示しており、完全ナップサック問題と非常によく似ています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 14-25   硬貨交換問題の動的計画法の過程 </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   空間最適化","text":"<p>硬貨交換の空間最適化の方法は、完全ナップサック問題と同じです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン交換：空間最適化後の動的計画法\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # dp テーブルを初期化\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            else:\n                # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* コイン両替：動的計画法 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // dp テーブルを初期化\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 順方向に走査する\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // dp テーブルを初期化\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a];\n      } else {\n        // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // dp テーブルを初期化\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // dp テーブルを初期化\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* コイン交換：空間最適化後の動的計画法 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // dp テーブルを初期化\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // 硬貨 i を選ばない場合と選ぶ場合の小さい方\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### コイン両替：空間最適化した動的計画法 ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # dp テーブルを初期化\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a]\n      else\n        # 硬貨 i を選ばない場合と選ぶ場合の小さい方\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   硬貨交換問題 II","text":"<p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は繰り返し選択できるとして、**目標金額を作る硬貨の組合せ数**を求めてください。例を以下の図に示します。</p> <p></p> <p> 図 14-26   硬貨交換問題 II のサンプルデータ </p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   動的計画法の考え方","text":"<p>前問と比べて、本問の目的は組合せ数を求めることです。そのため、部分問題は 先頭 \\(i\\) 種類の硬貨で金額 \\(a\\) を作れる組合せ数 になります。一方、\\(dp\\) テーブルは引き続きサイズ \\((n+1) \\times (amt + 1)\\) の 2 次元行列です。</p> <p>現在の状態における組合せ数は、現在の硬貨を選ばない場合と選ぶ場合の 2 つの選択肢の組合せ数の和に等しくなります。状態遷移方程式は次のとおりです。</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>目標金額が \\(0\\) のときは、どの硬貨も選ばなくても目標金額を作れるため、先頭列のすべての \\(dp[i, 0]\\) を \\(1\\) に初期化します。硬貨がないときは、任意の \\(&gt;0\\) の目標金額を作れないため、先頭行のすべての \\(dp[0, a]\\) は \\(0\\) になります。</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   コード実装","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替 II：動的計画法\"\"\"\n    n = len(coins)\n    # dp テーブルを初期化\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 先頭列を初期化する\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # 状態遷移\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // dp テーブルを初期化\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // dp テーブルを初期化\n    int[][] dp = new int[n + 1][amt + 1];\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* コイン両替 II：動的計画法 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // dp テーブルを初期化\n    int[,] dp = new int[n + 1, amt + 1];\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* コイン両替 II：動的計画法 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // dp テーブルを初期化\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 先頭列を初期化する\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // 状態遷移: 残りの行と列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* コイン両替 II：動的計画法 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 先頭列を初期化する\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* コイン両替 II：動的計画法 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 先頭列を初期化する\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* コイン両替 II：動的計画法 */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 先頭列を初期化する\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // dp テーブルを初期化\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 先頭列を初期化する\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // コイン i を選ばない場合と選ぶ場合の和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* コイン両替 II：動的計画法 */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // dp テーブルを初期化\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 先頭列を初期化する\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* コイン両替 II：動的計画法 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // dp テーブルを初期化\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 先頭列を初期化する\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // メモリを解放する\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* コイン両替 II：動的計画法 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // dp テーブルを初期化\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 先頭列を初期化する\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### コイン両替 II：動的計画法 ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # dp テーブルを初期化\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 先頭列を初期化する\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # 状態遷移\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[i][a] = dp[i - 1][a]\n      else\n        # コイン i を選ばない場合と選ぶ場合の和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   空間最適化","text":"<p>空間最適化の方法も同様で、硬貨の次元を削除するだけです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン両替 II：空間最適化した動的計画法\"\"\"\n    n = len(coins)\n    # dp テーブルを初期化\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # 状態遷移\n    for i in range(1, n + 1):\n        # 順方向に走査する\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            else:\n                # コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // dp テーブルを初期化\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // dp テーブルを初期化\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // dp テーブルを初期化\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // 状態遷移\n    for i := 1; i &lt;= n; i++ {\n        // 順方向に走査する\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // dp テーブルを初期化\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // 状態遷移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // dp テーブルを初期化\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 状態遷移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // dp テーブルを初期化\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // 状態遷移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a];\n      } else {\n        // コイン i を選ばない場合と選ぶ場合の和\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // dp テーブルを初期化\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // 状態遷移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // dp テーブルを初期化\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // 状態遷移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a];\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // メモリを解放する\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* コイン両替 II：空間最適化した動的計画法 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // dp テーブルを初期化\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // 状態遷移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 目標金額を超えるなら硬貨 i は選ばない\n                dp[a] = dp[a]\n            } else {\n                // コイン i を選ばない場合と選ぶ場合の和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### コイン両替 II：空間最適化した動的計画法 ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # dp テーブルを初期化\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # 状態遷移\n  for i in 1...(n + 1)\n    # 順方向に走査する\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 目標金額を超えるなら硬貨 i は選ばない\n        dp[a] = dp[a]\n      else\n        # コイン i を選ばない場合と選ぶ場合の和\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 14 章 &nbsp; 動的計画法","14.5 &nbsp; 完全ナップサック問題"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"第 9 章   グラフ","text":"<p>Abstract</p> <p>人生の旅路において、私たちはそれぞれ一つひとつのノードのようなものであり、無数の見えない辺によって結ばれています。</p> <p>出会いと別れのたびに、この巨大なネットワークグラフの中に固有の足跡が刻まれます。</p>","path":["第 9 章 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"章の内容","text":"<ul> <li>9.1   グラフ</li> <li>9.2   グラフの基本操作</li> <li>9.3   グラフの走査</li> <li>9.4   まとめ</li> </ul>","path":["第 9 章 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   グラフ","text":"<p>グラフ（graph）は、頂点（vertex）と辺（edge）から構成される非線形データ構造です。グラフ \\(G\\) は、頂点集合 \\(V\\) と辺集合 \\(E\\) からなる集合として抽象的に表せます。以下の例は、5 個の頂点と 7 本の辺を含むグラフを示しています。</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>頂点をノード、辺を各ノードをつなぐ参照（ポインタ）とみなせば、グラフは連結リストを拡張したデータ構造の一種と捉えられます。次の図に示すように、線形関係（連結リスト）や分治関係（木）と比べて、ネットワーク関係（グラフ）は自由度が高く、そのぶん複雑です。</p> <p></p> <p> 図 9-1   連結リスト、木、グラフの関係 </p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   グラフの一般的な種類と用語","text":"<p>辺が方向性を持つかどうかに応じて、無向グラフ（undirected graph）と有向グラフ（directed graph）に分けられます。次の図のとおりです。</p> <ul> <li>無向グラフでは、辺は 2 つの頂点間の「双方向」の接続関係を表します。例えば WeChat や QQ における「友だち関係」です。</li> <li>有向グラフでは、辺は方向性を持ち、すなわち \\(A \\rightarrow B\\) と \\(A \\leftarrow B\\) の 2 方向の辺は互いに独立です。例えば Weibo や Douyin における「フォロー」と「フォロワー」の関係です。</li> </ul> <p></p> <p> 図 9-2   有向グラフと無向グラフ </p> <p>すべての頂点が連結しているかどうかに応じて、連結グラフ（connected graph）と非連結グラフ（disconnected graph）に分けられます。次の図のとおりです。</p> <ul> <li>連結グラフでは、ある頂点から出発すると、ほかの任意の頂点に到達できます。</li> <li>非連結グラフでは、ある頂点から出発すると、少なくとも 1 つの頂点には到達できません。</li> </ul> <p></p> <p> 図 9-3   連結グラフと非連結グラフ </p> <p>辺に「重み」の変数を追加すると、次の図に示すような重み付きグラフ（weighted graph）が得られます。例えば『Honor of Kings』のようなモバイルゲームでは、システムが共にプレイした時間に基づいてプレイヤー間の「親密度」を計算します。この親密度ネットワークは重み付きグラフで表せます。</p> <p></p> <p> 図 9-4   重み付きグラフと重みなしグラフ </p> <p>グラフというデータ構造には、次のような基本用語があります。</p> <ul> <li>隣接（adjacency）：2 つの頂点の間に辺が存在するとき、この 2 つの頂点は「隣接している」といいます。上図では、頂点 1 に隣接する頂点は 2、3、5 です。</li> <li>経路（path）：頂点 A から頂点 B までに通過する辺で構成された列を、A から B への「経路」と呼びます。上図では、辺の列 1-5-2-4 は頂点 1 から頂点 4 への 1 本の経路です。</li> <li>次数（degree）：ある頂点が持つ辺の本数です。有向グラフでは、入次数（in-degree）はその頂点に向かう辺の本数を表し、出次数（out-degree）はその頂点から出る辺の本数を表します。</li> </ul>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   グラフの表現","text":"<p>グラフの一般的な表現方法には「隣接行列」と「隣接リスト」があります。以下では無向グラフを例に説明します。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   隣接行列","text":"<p>グラフの頂点数を \\(n\\) とすると、隣接行列（adjacency matrix）は \\(n \\times n\\) の行列を用いてグラフを表します。各行（列）は 1 つの頂点を表し、行列要素は辺を表します。\\(1\\) または \\(0\\) を用いて、2 つの頂点の間に辺があるかどうかを示します。</p> <p>次の図のように、隣接行列を \\(M\\)、頂点リストを \\(V\\) とすると、行列要素 \\(M[i, j] = 1\\) は頂点 \\(V[i]\\) から頂点 \\(V[j]\\) への辺が存在することを表し、逆に \\(M[i, j] = 0\\) は 2 つの頂点の間に辺がないことを表します。</p> <p></p> <p> 図 9-5   グラフの隣接行列による表現 </p> <p>隣接行列には次の特徴があります。</p> <ul> <li>単純グラフでは、頂点は自分自身とは接続できないため、このとき隣接行列の主対角線上の要素には意味がありません。</li> <li>無向グラフでは、2 方向の辺は等価であるため、このとき隣接行列は主対角線に関して対称です。</li> <li>隣接行列の要素を \\(1\\) と \\(0\\) から重みに置き換えると、重み付きグラフを表せます。</li> </ul> <p>隣接行列でグラフを表す場合、行列要素に直接アクセスして辺を取得できるため、追加・削除・検索・更新の操作効率は高く、時間計算量はいずれも \\(O(1)\\) です。しかし、行列の空間計算量は \\(O(n^2)\\) であり、メモリ使用量は多くなります。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   隣接リスト","text":"<p>隣接リスト（adjacency list）は、\\(n\\) 本の連結リストを使ってグラフを表します。連結リストのノードは頂点を表します。第 \\(i\\) 本の連結リストは頂点 \\(i\\) に対応し、その頂点に隣接するすべての頂点（その頂点と接続された頂点）を格納します。次の図は、隣接リストで保存したグラフの例です。</p> <p></p> <p> 図 9-6   グラフの隣接リストによる表現 </p> <p>隣接リストは実際に存在する辺だけを格納し、辺の総数は通常 \\(n^2\\) よりはるかに小さいため、より省スペースです。しかし、隣接リストでは辺を見つけるために連結リストを走査する必要があるため、時間効率は隣接行列に及びません。</p> <p>上図を見ると、隣接リストの構造はハッシュテーブルにおける「連鎖アドレス法」と非常によく似ているため、同様の方法で効率を最適化できます。例えば、連結リストが長い場合は AVL 木や赤黒木に変換して時間効率を \\(O(n)\\) から \\(O(\\log n)\\) に改善できます。さらに、連結リストをハッシュテーブルに変換すれば、時間計算量を \\(O(1)\\) まで下げられます。</p>","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   グラフの一般的な応用","text":"<p>次の表のように、多くの現実のシステムはグラフでモデル化でき、対応する問題もグラフ計算の問題に帰着できます。</p> <p> 表 9-1   現実世界でよく見られるグラフ </p> 頂点 辺 グラフ計算問題 ソーシャルネットワーク ユーザー 友だち関係 潜在的な友だちの推薦 地下鉄路線 駅 駅間の接続性 最短経路の推薦 太陽系 天体 天体間の万有引力作用 惑星軌道の計算","path":["第 9 章 &nbsp; グラフ","9.1 &nbsp; グラフ"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   グラフの基本操作","text":"<p>グラフの基本操作は、「辺」に対する操作と「頂点」に対する操作に分けられます。「隣接行列」と「隣接リスト」の 2 つの表現方法では、実装方法が異なります。</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   隣接行列に基づく実装","text":"<p>頂点数が \\(n\\) の無向グラフを与えると、各種操作の実装方法は次図のとおりです。</p> <ul> <li>辺の追加または削除：隣接行列で指定した辺を直接変更すればよく、\\(O(1)\\) 時間です。無向グラフであるため、2 方向の辺を同時に更新する必要があります。</li> <li>頂点の追加：隣接行列の末尾に 1 行 1 列を追加し、すべてを \\(0\\) で埋めればよく、\\(O(n)\\) 時間です。</li> <li>頂点の削除：隣接行列から 1 行 1 列を削除します。先頭行と先頭列を削除する場合が最悪で、\\((n-1)^2\\) 個の要素を「左上へ移動」させる必要があるため、\\(O(n^2)\\) 時間です。</li> <li>初期化：\\(n\\) 個の頂点を受け取り、長さ \\(n\\) の頂点リスト <code>vertices</code> を初期化するのに \\(O(n)\\) 時間、サイズ \\(n \\times n\\) の隣接行列 <code>adjMat</code> を初期化するのに \\(O(n^2)\\) 時間かかります。</li> </ul> 隣接行列の初期化辺の追加辺の削除頂点の追加頂点の削除 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-7   隣接行列の初期化、辺の追加と削除、頂点の追加と削除 </p> <p>以下は、隣接行列でグラフを表した実装コードです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"隣接行列に基づく無向グラフクラス\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"コンストラクタ\"\"\"\n        # 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n        self.vertices: list[int] = []\n        # 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n        self.adj_mat: list[list[int]] = []\n        # 頂点を追加\n        for val in vertices:\n            self.add_vertex(val)\n        # 辺を追加\n        # 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"頂点数を取得\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"頂点を追加\"\"\"\n        n = self.size()\n        # 頂点リストに新しい頂点の値を追加\n        self.vertices.append(val)\n        # 隣接行列に 1 行追加\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # 隣接行列に 1 列追加\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"頂点を削除\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # 頂点リストから index の頂点を削除する\n        self.vertices.pop(index)\n        # 隣接行列で index 行を削除する\n        self.adj_mat.pop(index)\n        # 隣接行列で index 列を削除する\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"辺を追加\"\"\"\n        # パラメータ i, j は vertices の要素インデックスに対応する\n        # 範囲外と同値の場合の処理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"辺を削除\"\"\"\n        # パラメータ i, j は vertices の要素インデックスに対応する\n        # 範囲外と同値の場合の処理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"隣接行列を出力\"\"\"\n        print(\"頂点リスト =\", self.vertices)\n        print(\"隣接行列 =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n  public:\n    /* コンストラクタ */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // 頂点を追加\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* 頂点を追加 */\n    void addVertex(int val) {\n        int n = size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.push_back(val);\n        // 隣接行列に 1 行追加\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // 隣接行列に 1 列追加\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        // 頂点リストから index の頂点を削除する\n        vertices.erase(vertices.begin() + index);\n        // 隣接行列で index 行を削除する\n        adjMat.erase(adjMat.begin() + index);\n        // 隣接行列で index 列を削除する\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    void addEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    void removeEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂点が存在しません\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    void print() {\n        cout &lt;&lt; \"頂点リスト = \";\n        printVector(vertices);\n        cout &lt;&lt; \"隣接行列 =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // 頂点を追加\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* 頂点を追加 */\n    public void addVertex(int val) {\n        int n = size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.add(val);\n        // 隣接行列に 1 行追加\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // 隣接行列に 1 列追加\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // 頂点リストから index の頂点を削除する\n        vertices.remove(index);\n        // 隣接行列で index 行を削除する\n        adjMat.remove(index);\n        // 隣接行列で index 列を削除する\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void addEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void removeEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* 隣接行列を出力 */\n    public void print() {\n        System.out.print(\"頂点リスト = \");\n        System.out.println(vertices);\n        System.out.println(\"隣接行列 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    List&lt;List&lt;int&gt;&gt; adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* 頂点を追加 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // 頂点リストに新しい頂点の値を追加\n        vertices.Add(val);\n        // 隣接行列に 1 行追加\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // 隣接行列に 1 列追加\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // 頂点リストから index の頂点を削除する\n        vertices.RemoveAt(index);\n        // 隣接行列で index 行を削除する\n        adjMat.RemoveAt(index);\n        // 隣接行列で index 列を削除する\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void AddEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    public void RemoveEdge(int i, int j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    public void Print() {\n        Console.Write(\"頂点リスト = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"隣接行列 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* 隣接行列に基づく無向グラフクラス */\ntype graphAdjMat struct {\n    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    vertices []int\n    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    adjMat [][]int\n}\n\n/* コンストラクタ */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // 頂点を追加\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // グラフを初期化する\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // 辺を追加\n    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* 頂点数を取得 */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* 頂点を追加 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // 頂点リストに新しい頂点の値を追加\n    g.vertices = append(g.vertices, val)\n    // 隣接行列に 1 行追加\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // 隣接行列に 1 列追加\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* 頂点を削除 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // 頂点リストから index の頂点を削除する\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // 隣接行列で index 行を削除する\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // 隣接行列で index 列を削除する\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* 辺を追加 */\n// 引数 i, j は vertices の要素インデックスに対応する\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // インデックスの範囲外と等値の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* 辺を削除 */\n// 引数 i, j は vertices の要素インデックスに対応する\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // インデックスの範囲外と等値の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* 隣接行列を出力 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t頂点リスト = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t隣接行列 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    private var vertices: [Int] // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    private var adjMat: [[Int]] // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // 頂点を追加\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* 頂点を追加 */\n    func addVertex(val: Int) {\n        let n = size()\n        // 頂点リストに新しい頂点の値を追加\n        vertices.append(val)\n        // 隣接行列に 1 行追加\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // 隣接行列に 1 列追加\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* 頂点を削除 */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"範囲外\")\n        }\n        // 頂点リストから index の頂点を削除する\n        vertices.remove(at: index)\n        // 隣接行列で index 行を削除する\n        adjMat.remove(at: index)\n        // 隣接行列で index 列を削除する\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    func addEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"範囲外\")\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    func removeEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"範囲外\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 隣接行列を出力 */\n    func print() {\n        Swift.print(\"頂点リスト = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"隣接行列 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vertices; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    adjMat; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* 頂点を追加 */\n    addVertex(val) {\n        const n = this.size();\n        // 頂点リストに新しい頂点の値を追加\n        this.vertices.push(val);\n        // 隣接行列に 1 行追加\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 隣接行列に 1 列追加\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 頂点リストから index の頂点を削除する\n        this.vertices.splice(index, 1);\n\n        // 隣接行列で index 行を削除する\n        this.adjMat.splice(index, 1);\n        // 隣接行列で index 列を削除する\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    addEdge(i, j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    removeEdge(i, j) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    print() {\n        console.log('頂点リスト = ', this.vertices);\n        console.log('隣接行列 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n    vertices: number[]; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    adjMat: number[][]; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 頂点を追加\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* 頂点を追加 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // 頂点リストに新しい頂点の値を追加\n        this.vertices.push(val);\n        // 隣接行列に 1 行追加\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 隣接行列に 1 列追加\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 頂点リストから index の頂点を削除する\n        this.vertices.splice(index, 1);\n\n        // 隣接行列で index 行を削除する\n        this.adjMat.splice(index, 1);\n        // 隣接行列で index 列を削除する\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    addEdge(i: number, j: number): void {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    removeEdge(i: number, j: number): void {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    print(): void {\n        console.log('頂点リスト = ', this.vertices);\n        console.log('隣接行列 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // 頂点要素。要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n  /* コンストラクタ */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // 頂点を追加\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // 辺を追加\n    // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* 頂点数を取得 */\n  int size() {\n    return vertices.length;\n  }\n\n  /* 頂点を追加 */\n  void addVertex(int val) {\n    int n = size();\n    // 頂点リストに新しい頂点の値を追加\n    vertices.add(val);\n    // 隣接行列に 1 行追加\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // 隣接行列に 1 列追加\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* 頂点を削除 */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // 頂点リストから index の頂点を削除する\n    vertices.removeAt(index);\n    // 隣接行列で index 行を削除する\n    adjMat.removeAt(index);\n    // 隣接行列で index 列を削除する\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* 辺を追加 */\n  // 引数 i, j は vertices の要素インデックスに対応する\n  void addEdge(int i, int j) {\n    // インデックスの範囲外と等値の処理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* 辺を削除 */\n  // 引数 i, j は vertices の要素インデックスに対応する\n  void removeEdge(int i, int j) {\n    // インデックスの範囲外と等値の処理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* 隣接行列を出力 */\n  void printAdjMat() {\n    print(\"頂点リスト = $vertices\");\n    print(\"隣接行列 = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* 隣接行列に基づく無向グラフ型 */\npub struct GraphAdjMat {\n    // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    pub vertices: Vec&lt;i32&gt;,\n    // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* コンストラクタ */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // 頂点を追加\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* 頂点数を取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* 頂点を追加 */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // 頂点リストに新しい頂点の値を追加\n        self.vertices.push(val);\n        // 隣接行列に 1 行追加\n        self.adj_mat.push(vec![0; n]);\n        // 隣接行列に 1 列追加\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* 頂点を削除 */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // 頂点リストから index の頂点を削除する\n        self.vertices.remove(index);\n        // 隣接行列で index 行を削除する\n        self.adj_mat.remove(index);\n        // 隣接行列で index 列を削除する\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* 辺を追加 */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // パラメータ i, j は vertices の要素インデックスに対応する\n        // 範囲外と同値の場合の処理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // パラメータ i, j は vertices の要素インデックスに対応する\n        // 範囲外と同値の場合の処理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* 隣接行列を出力 */\n    pub fn print(&amp;self) {\n        println!(\"頂点リスト = {:?}\", self.vertices);\n        println!(\"隣接行列 =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* 隣接行列に基づく無向グラフ構造体 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* コンストラクタ */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* デストラクタ */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* 頂点を追加 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"グラフの頂点数が最大値に達しました\\n\");\n        return;\n    }\n    // n 番目の頂点を追加し、n 行目と n 列目を 0 にする\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* 頂点を削除 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"頂点インデックスが範囲外です\\n\");\n        return;\n    }\n    // 頂点リストから index の頂点を削除する\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // 隣接行列で index 行を削除する\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // 隣接行列で index 列を削除する\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* 辺を追加 */\n// 引数 i, j は vertices の要素インデックスに対応する\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"辺インデックスが範囲外であるか、同一です\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* 辺を削除 */\n// 引数 i, j は vertices の要素インデックスに対応する\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"辺インデックスが範囲外であるか、同一です\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* 隣接行列を出力 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"頂点リスト = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"隣接行列 =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* 隣接行列に基づく無向グラフクラス */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n\n    /* コンストラクタ */\n    init {\n        // 頂点を追加\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // 辺を追加\n        // 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* 頂点を追加 */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // 頂点リストに新しい頂点の値を追加\n        vertices.add(_val)\n        // 隣接行列に 1 行追加\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // 隣接行列に 1 列追加\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* 頂点を削除 */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // 頂点リストから index の頂点を削除する\n        vertices.removeAt(index)\n        // 隣接行列で index 行を削除する\n        adjMat.removeAt(index)\n        // 隣接行列で index 列を削除する\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* 辺を追加 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    fun addEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 辺を削除 */\n    // 引数 i, j は vertices の要素インデックスに対応する\n    fun removeEdge(i: Int, j: Int) {\n        // インデックスの範囲外と等値の処理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 隣接行列を出力 */\n    fun print() {\n        print(\"頂点リスト = \")\n        println(vertices)\n        println(\"隣接行列 =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### 隣接行列で実装した無向グラフクラス ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### コンストラクタ ###\n    # 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す\n    @vertices = []\n    # 隣接行列。行・列のインデックスは「頂点インデックス」に対応\n    @adj_mat = []\n    # 頂点を追加\n    vertices.each { |val| add_vertex(val) }\n    # 辺を追加\n    # 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### 頂点数を取得 ###\n  def size\n    @vertices.length\n  end\n\n  ### 頂点を追加 ###\n  def add_vertex(val)\n    n = size\n    # 頂点リストに新しい頂点の値を追加\n    @vertices &lt;&lt; val\n    # 隣接行列に 1 行追加\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # 隣接行列に 1 列追加\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### 頂点を削除 ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # 頂点リストから index の頂点を削除する\n    @vertices.delete_at(index)\n    # 隣接行列で index 行を削除する\n    @adj_mat.delete_at(index)\n    # 隣接行列で index 列を削除する\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### 辺を追加 ###\n  def add_edge(i, j)\n    # パラメータ i, j は vertices の要素インデックスに対応する\n    # 範囲外と同値の場合の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### 辺を削除 ###\n  def remove_edge(i, j)\n    # パラメータ i, j は vertices の要素インデックスに対応する\n    # 範囲外と同値の場合の処理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### 隣接行列を出力 ###\n  def __print__\n    puts \"頂点リスト = #{@vertices}\"\n    puts '隣接行列 ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   隣接リストに基づく実装","text":"<p>無向グラフの頂点総数を \\(n\\)、辺総数を \\(m\\) とすると、各種操作は次図の方法で実装できます。</p> <ul> <li>辺の追加：頂点に対応する連結リストの末尾に辺を追加すればよく、\\(O(1)\\) 時間です。無向グラフなので、2 方向の辺を同時に追加する必要があります。</li> <li>辺の削除：頂点に対応する連結リストから指定した辺を探して削除するため、\\(O(m)\\) 時間です。無向グラフでは、2 方向の辺を同時に削除する必要があります。</li> <li>頂点の追加：隣接リストに 1 つの連結リストを追加し、新しい頂点をその連結リストの先頭ノードとするため、\\(O(1)\\) 時間です。</li> <li>頂点の削除：隣接リスト全体を走査し、指定した頂点を含むすべての辺を削除する必要があるため、\\(O(n + m)\\) 時間です。</li> <li>初期化：隣接リストに \\(n\\) 個の頂点と \\(2m\\) 本の辺を作成するため、\\(O(n + m)\\) 時間です。</li> </ul> 隣接リストの初期化辺の追加辺の削除頂点の追加頂点の削除 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-8   隣接リストの初期化、辺の追加と削除、頂点の追加と削除 </p> <p>以下は隣接リストのコード実装です。上図と比べると、実際のコードには次の違いがあります。</p> <ul> <li>頂点の追加と削除を容易にし、コードを簡潔にするため、連結リストの代わりにリスト（動的配列）を使用しています。</li> <li>ハッシュテーブルを用いて隣接リストを格納しており、<code>key</code> は頂点インスタンス、<code>value</code> はその頂点に隣接する頂点のリスト（連結リスト）です。</li> </ul> <p>また、隣接リストでは頂点を表すために <code>Vertex</code> クラスを使用しています。その理由は、もし隣接行列と同様にリストのインデックスで異なる頂点を区別すると、インデックス \\(i\\) の頂点を削除する場合、隣接リスト全体を走査して、\\(i\\) より大きいすべてのインデックスを \\(1\\) 減らす必要があり、効率が非常に低いためです。これに対して、各頂点が一意な <code>Vertex</code> インスタンスであれば、ある頂点を削除しても他の頂点を変更する必要はありません。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"隣接リストに基づく無向グラフクラス\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"コンストラクタ\"\"\"\n        # 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # すべての頂点と辺を追加\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"頂点数を取得\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"辺を追加\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 辺 vet1 - vet2 を追加\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"辺を削除\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 辺 vet1 - vet2 を削除\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"頂点を追加\"\"\"\n        if vet in self.adj_list:\n            return\n        # 隣接リストに新しいリストを追加\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"頂点を削除\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # 隣接リストから頂点 vet に対応するリストを削除\n        self.adj_list.pop(vet)\n        # 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"隣接リストを出力\"\"\"\n        print(\"隣接リスト =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n  public:\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* vector 内の指定ノードを削除 */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* コンストラクタ */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // すべての頂点と辺を追加\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int size() {\n        return adjList.size();\n    }\n\n    /* 辺を追加 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"頂点が存在しません\");\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* 辺を削除 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"頂点が存在しません\");\n        // 辺 vet1 - vet2 を削除\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* 頂点を追加 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* 頂点を削除 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"頂点が存在しません\");\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.erase(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    void print() {\n        cout &lt;&lt; \"隣接リスト =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* コンストラクタ */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // すべての頂点と辺を追加\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* 辺を追加 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 辺 vet1 - vet2 を追加\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* 辺を削除 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 辺 vet1 - vet2 を削除\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* 頂点を追加 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* 頂点を削除 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.remove(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public void print() {\n        System.out.println(\"隣接リスト =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* コンストラクタ */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // すべての頂点と辺を追加\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* 辺を追加 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* 辺を削除 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* 頂点を追加 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // 隣接リストに新しいリストを追加\n        adjList.Add(vet, []);\n    }\n\n    /* 頂点を削除 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.Remove(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public void Print() {\n        Console.WriteLine(\"隣接リスト =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* 隣接リストに基づく無向グラフクラス */\ntype graphAdjList struct {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList map[Vertex][]Vertex\n}\n\n/* コンストラクタ */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // すべての頂点と辺を追加\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* 頂点数を取得 */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* 辺を追加 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 辺 `vet1 - vet2` を追加し、無名 `struct{}` を追加する\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* 辺を削除 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 辺 vet1 - vet2 を削除\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* 頂点を追加 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // 隣接リストに新しいリストを追加\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* 頂点を削除 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // 隣接リストから頂点 vet に対応するリストを削除\n    delete(g.adjList, vet)\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* 隣接リストを出力 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"隣接リスト = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* コンストラクタ */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // すべての頂点と辺を追加\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* 頂点数を取得 */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* 辺を追加 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"引数エラー\")\n        }\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* 辺を削除 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"引数エラー\")\n        }\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* 頂点を追加 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = []\n    }\n\n    /* 頂点を削除 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"引数エラー\")\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.removeValue(forKey: vet)\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    public func print() {\n        Swift.print(\"隣接リスト =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList;\n\n    /* コンストラクタ */\n    constructor(edges) {\n        this.adjList = new Map();\n        // すべての頂点と辺を追加\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* 辺を追加 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を追加\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 辺を削除 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を削除\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 頂点を追加 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // 隣接リストに新しいリストを追加\n        this.adjList.set(vet, []);\n    }\n\n    /* 頂点を削除 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        this.adjList.delete(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    print() {\n        console.log('隣接リスト =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* コンストラクタ */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // すべての頂点と辺を追加\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 頂点数を取得 */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* 辺を追加 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を追加\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 辺を削除 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 辺 vet1 - vet2 を削除\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 頂点を追加 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // 隣接リストに新しいリストを追加\n        this.adjList.set(vet, []);\n    }\n\n    /* 頂点を削除 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 隣接リストから頂点 vet に対応するリストを削除\n        this.adjList.delete(vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 隣接リストを出力 */\n    print(): void {\n        console.log('隣接リスト =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList {\n  // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* コンストラクタ */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* 頂点数を取得 */\n  int size() {\n    return adjList.length;\n  }\n\n  /* 辺を追加 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 辺 vet1 - vet2 を追加\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* 辺を削除 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 辺 vet1 - vet2 を削除\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* 頂点を追加 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // 隣接リストに新しいリストを追加\n    adjList[vet] = [];\n  }\n\n  /* 頂点を削除 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // 隣接リストから頂点 vet に対応するリストを削除\n    adjList.remove(vet);\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* 隣接リストを出力 */\n  void printAdjList() {\n    print(\"隣接リスト =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* 隣接リストに基づく無向グラフ型 */\npub struct GraphAdjList {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* コンストラクタ */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // すべての頂点と辺を追加\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* 頂点数を取得 */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* 辺を追加 */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 辺 vet1 - vet2 を追加\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* 辺を削除 */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 辺 vet1 - vet2 を削除\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* 頂点を追加 */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // 隣接リストに新しいリストを追加\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* 頂点を削除 */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // 隣接リストから頂点 vet に対応するリストを削除\n        self.adj_list.remove(&amp;vet);\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* 隣接リストを出力 */\n    pub fn print(&amp;self) {\n        println!(\"隣接リスト =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* ノード構造体 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // 頂点\n    struct AdjListNode *next; // 後続ノード\n} AdjListNode;\n\n/* 頂点に対応するノードを検索 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 辺を追加する補助関数 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // 先頭挿入法\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* 辺削除の補助関数 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // 連結リスト内で vet に対応するノードを探索\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // vet に対応するノードを連結リストから削除\n    pre-&gt;next = cur-&gt;next;\n    // メモリを解放する\n    free(cur);\n}\n\n/* 隣接リストに基づく無向グラフクラス */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // ノード配列\n    int size;                     // ノード数\n} GraphAdjList;\n\n/* コンストラクタ */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* デストラクタ */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* 頂点に対応するノードを検索 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 辺を追加 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // 辺 vet1 - vet2 を追加\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* 辺を削除 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // 辺 vet1 - vet2 を削除\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* 頂点を追加 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // 隣接リストに新しいリストを追加\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* 頂点を削除 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // 隣接リストから頂点 vet に対応するリストを削除\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // この頂点より後ろの頂点を前に詰めて欠損を埋める\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* 隣接リストに基づく無向グラフクラス */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* コンストラクタ */\n    init {\n        // すべての頂点と辺を追加\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* 頂点数を取得 */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* 辺を追加 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 辺 vet1 - vet2 を追加\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* 辺を削除 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 辺 vet1 - vet2 を削除\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* 頂点を追加 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // 隣接リストに新しいリストを追加\n        adjList[vet] = mutableListOf()\n    }\n\n    /* 頂点を削除 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // 隣接リストから頂点 vet に対応するリストを削除\n        adjList.remove(vet)\n        // 他の頂点のリストを走査し、vet を含むすべての辺を削除\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* 隣接リストを出力 */\n    fun print() {\n        println(\"隣接リスト =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### 隣接リストで実装した無向グラフクラス ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### コンストラクタ ###\n  def initialize(edges)\n    # 隣接リスト。key は頂点、value はその頂点に隣接する全頂点\n    @adj_list = {}\n    # すべての頂点と辺を追加\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### 頂点数を取得 ###\n  def size\n    @adj_list.length\n  end\n\n  ### 辺を追加 ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### 辺を削除 ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # 辺 vet1 - vet2 を削除\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### 頂点を追加 ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # 隣接リストに新しいリストを追加\n    @adj_list[vet] = []\n  end\n\n  ### 頂点を削除 ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # 隣接リストから頂点 vet に対応するリストを削除\n    @adj_list.delete(vet)\n    # 他の頂点のリストを走査し、vet を含むすべての辺を削除\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### 隣接リストを出力 ###\n  def __print__\n    puts '隣接リスト ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   効率の比較","text":"<p>グラフに \\(n\\) 個の頂点と \\(m\\) 本の辺があるとすると、次の表は隣接行列と隣接リストの時間効率および空間効率を比較したものです。なお、隣接リスト（連結リスト）は本記事の実装に対応し、隣接リスト（ハッシュテーブル）はすべての連結リストをハッシュテーブルに置き換えた実装を指します。</p> <p> 表 9-2   隣接行列と隣接リストの比較 </p> 隣接行列 隣接リスト（連結リスト） 隣接リスト（ハッシュテーブル） 隣接判定 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 辺の追加 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 辺の削除 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 頂点の追加 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) 頂点の削除 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) メモリ使用量 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>上表を見ると、隣接リスト（ハッシュテーブル）の時間効率と空間効率が最も優れているように見えます。しかし実際には、隣接行列のほうが辺の操作効率は高く、必要なのは 1 回の配列アクセスまたは代入だけです。総合的に見ると、隣接行列は「空間を時間と引き換えにする」原則を体現し、隣接リストは「時間を空間と引き換えにする」原則を体現しています。</p>","path":["第 9 章 &nbsp; グラフ","9.2 &nbsp; グラフの基本操作"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   グラフの走査","text":"<p>木は「一対多」の関係を表すのに対し、グラフはより高い自由度を持ち、任意の「多対多」の関係を表現できます。したがって、木はグラフの一種の特殊な場合とみなせます。明らかに、木の走査操作もグラフの走査操作の一種の特殊な場合です。</p> <p>グラフと木はいずれも、走査操作を実現するために探索アルゴリズムを用いる必要があります。グラフの走査方法も、幅優先走査と深さ優先走査の 2 種類に分けられます。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   幅優先走査","text":"<p>幅優先走査は、近いところから遠いところへ向かう走査方法であり、ある頂点から出発して、常に最も近い頂点を優先して訪問し、層ごとに外側へ広がっていきます。以下の図に示すように、左上の頂点から出発し、まずその頂点のすべての隣接頂点を走査し、次に次の頂点のすべての隣接頂点を走査し、これを繰り返して、すべての頂点を訪問するまで続けます。</p> <p></p> <p> 図 9-9   グラフの幅優先走査 </p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   アルゴリズムの実装","text":"<p>BFS は通常キューを用いて実装され、コードは以下のとおりです。キューは「先入れ先出し」という性質を持ち、これは BFS の「近いところから遠いところへ」という考え方と本質的に一致しています。</p> <ol> <li>走査の開始頂点 <code>startVet</code> をキューに追加し、ループを開始します。</li> <li>ループの各反復で、キュー先頭の頂点を取り出して訪問を記録し、その後その頂点のすべての隣接頂点をキューの末尾に追加します。</li> <li>手順 <code>2.</code> を繰り返し、すべての頂点が訪問されると終了します。</li> </ol> <p>頂点の重複走査を防ぐために、どの頂点が訪問済みかを記録するハッシュ集合 <code>visited</code> を用います。</p> <p>Tip</p> <p>ハッシュ集合は、<code>value</code> を持たず <code>key</code> だけを格納するハッシュテーブルとみなせます。これは \\(O(1)\\) の時間計算量で <code>key</code> の追加・削除・検索・更新を行えます。<code>key</code> の一意性にもとづき、ハッシュ集合は通常、データの重複排除などの場面で用いられます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"幅優先探索\"\"\"\n    # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n    # 頂点の走査順序\n    res = []\n    # 訪問済み頂点を記録するためのハッシュ集合\n    visited = set[Vertex]([start_vet])\n    # BFS の実装にキューを用いる\n    que = deque[Vertex]([start_vet])\n    # 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while len(que) &gt; 0:\n        vet = que.popleft()  # 先頭の頂点をデキュー\n        res.append(vet)  # 訪問した頂点を記録\n        # この頂点のすべての隣接頂点を走査\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # 訪問済みの頂点をスキップ\n            que.append(adj_vet)  # 未訪問の頂点のみをキューに追加\n            visited.add(adj_vet)  # この頂点を訪問済みにする\n    # 頂点の走査順を返す\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂点の走査順序\n    vector&lt;Vertex *&gt; res;\n    // 訪問済み頂点を記録するためのハッシュ集合\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // BFS の実装にキューを用いる\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // 先頭の頂点をデキュー\n        res.push_back(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // 訪問済みの頂点をスキップ\n            que.push(adjVet);        // 未訪問の頂点のみをキューに追加\n            visited.emplace(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 訪問済み頂点を記録するためのハッシュ集合\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // 先頭の頂点をデキュー\n        res.add(vet);            // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // 訪問済みの頂点をスキップ\n            que.offer(adjVet);   // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // BFS の実装にキューを用いる\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // 先頭の頂点をデキュー\n        res.Add(vet);               // 訪問した頂点を記録\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // 訪問済みの頂点をスキップ\n            }\n            que.Enqueue(adjVet);   // 未訪問の頂点のみをキューに追加\n            visited.Add(adjVet);   // この頂点を訪問済みにする\n        }\n    }\n\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂点の走査順序\n    res := make([]Vertex, 0)\n    // 訪問済み頂点を記録するためのハッシュ集合\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // キューは BFS の実装に用い、スライスでキューをシミュレートする\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    for len(queue) &gt; 0 {\n        // 先頭の頂点をデキュー\n        vet := queue[0]\n        queue = queue[1:]\n        // 訪問した頂点を記録\n        res = append(res, vet)\n        // この頂点のすべての隣接頂点を走査\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // 未訪問の頂点のみをキューに追加\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂点の走査順序\n    var res: [Vertex] = []\n    // 訪問済み頂点を記録するためのハッシュ集合\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // BFS の実装にキューを用いる\n    var que: [Vertex] = [startVet]\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while !que.isEmpty {\n        let vet = que.removeFirst() // 先頭の頂点をデキュー\n        res.append(vet) // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // 訪問済みの頂点をスキップ\n            }\n            que.append(adjVet) // 未訪問の頂点のみをキューに追加\n            visited.insert(adjVet) // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphBFS(graph, startVet) {\n    // 頂点の走査順序\n    const res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited = new Set();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    const que = [startVet];\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.length) {\n        const vet = que.shift(); // 先頭の頂点をデキュー\n        res.push(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            que.push(adjVet); // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂点の走査順序\n    const res: Vertex[] = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // BFS の実装にキューを用いる\n    const que = [startVet];\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (que.length) {\n        const vet = que.shift(); // 先頭の頂点をデキュー\n        res.push(vet); // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            que.push(adjVet); // 未訪問のものだけをキューに入れる\n            visited.add(adjVet); // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* 幅優先探索 */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  // 頂点の走査順序\n  List&lt;Vertex&gt; res = [];\n  // 訪問済み頂点を記録するためのハッシュ集合\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // BFS の実装にキューを用いる\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // 先頭の頂点をデキュー\n    res.add(vet); // 訪問した頂点を記録\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // 訪問済みの頂点をスキップ\n      }\n      que.add(adjVet); // 未訪問の頂点のみをキューに追加\n      visited.add(adjVet); // この頂点を訪問済みにする\n    }\n  }\n  // 頂点の走査順を返す\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂点の走査順序\n    let mut res = vec![];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // BFS の実装にキューを用いる\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // 訪問した頂点を記録\n\n        // この頂点のすべての隣接頂点を走査\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // 訪問済みの頂点をスキップ\n                }\n                que.push_back(adj_vet); // 未訪問の頂点のみをキューに追加\n                visited.insert(adj_vet); // この頂点を訪問済みにする\n            }\n        }\n    }\n    // 頂点の走査順を返す\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* ノードキュー構造体 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* コンストラクタ */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* キューが空かどうかを判定 */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* エンキュー操作 */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* デキュー操作 */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* 頂点が訪問済みかを確認 */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // 走査してノードを探すため、O(n) 時間を要する\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // BFS の実装にキューを用いる\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // 先頭の頂点をデキュー\n        res[(*resSize)++] = vet;      // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // 訪問済みの頂点をスキップ\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // 未訪問の頂点のみをキューに追加\n                visited[(*visitedSize)++] = node-&gt;vertex; // この頂点を訪問済みにする\n            }\n            node = node-&gt;next;\n        }\n    }\n    // メモリを解放する\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* 幅優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // 頂点の走査順序\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 訪問済み頂点を記録するためのハッシュ集合\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // BFS の実装にキューを用いる\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n    while (!que.isEmpty()) {\n        val vet = que.poll() // 先頭の頂点をデキュー\n        res.add(vet)         // 訪問した頂点を記録\n        // この頂点のすべての隣接頂点を走査\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // 訪問済みの頂点をスキップ\n            que.offer(adjVet)   // 未訪問の頂点のみをキューに追加\n            visited.add(adjVet) // この頂点を訪問済みにする\n        }\n    }\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### 幅優先探索 ###\ndef graph_bfs(graph, start_vet)\n  # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  # 頂点の走査順序\n  res = []\n  # 訪問済み頂点を記録するためのハッシュ集合\n  visited = Set.new([start_vet])\n  # BFS の実装にキューを用いる\n  que = [start_vet]\n  # 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す\n  while que.length &gt; 0\n    vet = que.shift # 先頭の頂点をデキュー\n    res &lt;&lt; vet # 訪問した頂点を記録\n    # この頂点のすべての隣接頂点を走査\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # 訪問済みの頂点をスキップ\n      que &lt;&lt; adj_vet # 未訪問の頂点のみをキューに追加\n      visited.add(adj_vet) # この頂点を訪問済みにする\n    end\n  end\n  # 頂点の走査順を返す\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>コードはやや抽象的なので、以下の図と照らし合わせて理解を深めることを勧めます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-10   グラフの幅優先走査の手順 </p> <p>幅優先走査の順序列は一意ですか？</p> <p>一意ではありません。幅優先走査は「近いところから遠いところへ」の順で走査することだけを要求し、同じ距離にある複数の頂点の走査順は任意に入れ替えて構いません。上図を例にすると、頂点 \\(1\\) と \\(3\\) の訪問順は交換でき、頂点 \\(2\\)、\\(4\\)、\\(6\\) の訪問順も任意に入れ替えられます。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   計算量の分析","text":"<p>時間計算量：すべての頂点は 1 回ずつキューに入り、1 回ずつキューから出るため、\\(O(|V|)\\) 時間です。隣接頂点を走査する過程では、無向グラフであるため、すべての辺が \\(2\\) 回訪問され、\\(O(2|E|)\\) 時間です。したがって全体では \\(O(|V| + |E|)\\) 時間です。</p> <p>空間計算量：リスト <code>res</code>、ハッシュ集合 <code>visited</code>、キュー <code>que</code> に含まれる頂点数は最大で \\(|V|\\) であるため、\\(O(|V|)\\) 空間です。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   深さ優先走査","text":"<p>深さ優先走査は、まず行けるところまで進み、進めなくなったら戻る走査方法です。以下の図に示すように、左上の頂点から出発し、現在の頂点のある隣接頂点を訪問して、行き止まりに達するまで進んだら戻り、再び別の方向へ進んで行き止まりまで進んで戻る、ということを繰り返し、すべての頂点の走査が完了するまで続けます。</p> <p></p> <p> 図 9-11   グラフの深さ優先走査 </p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   アルゴリズムの実装","text":"<p>この「行き止まりまで進んでから戻る」アルゴリズムのパターンは、通常再帰にもとづいて実装されます。幅優先走査と同様に、深さ優先走査でも、頂点の重複訪問を避けるために、訪問済みの頂点を記録するハッシュ集合 <code>visited</code> を用います。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"深さ優先走査の補助関数\"\"\"\n    res.append(vet)  # 訪問した頂点を記録\n    visited.add(vet)  # この頂点を訪問済みにする\n    # この頂点のすべての隣接頂点を走査\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # 訪問済みの頂点をスキップ\n        # 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"深さ優先探索\"\"\"\n    # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n    # 頂点の走査順序\n    res = []\n    # 訪問済み頂点を記録するためのハッシュ集合\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // 訪問した頂点を記録\n    visited.emplace(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂点の走査順序\n    vector&lt;Vertex *&gt; res;\n    // 訪問済み頂点を記録するためのハッシュ集合\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 訪問済み頂点を記録するためのハッシュ集合\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* 深さ優先走査の補助関数 */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // 訪問した頂点を記録\n    visited.Add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂点の走査順序\n    List&lt;Vertex&gt; res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* 深さ優先走査の補助関数 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append 操作は新しい参照を返すため、元の参照を新しい slice の参照で再代入する必要がある\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // この頂点のすべての隣接頂点を走査\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // 隣接頂点を再帰的に訪問\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂点の走査順序\n    res := make([]Vertex, 0)\n    // 訪問済み頂点を記録するためのハッシュ集合\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // 頂点の走査順を返す\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* 深さ優先走査の補助関数 */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // 訪問した頂点を記録\n    visited.insert(vet) // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂点の走査順序\n    var res: [Vertex] = []\n    // 訪問済み頂点を記録するためのハッシュ集合\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphDFS(graph, startVet) {\n    // 頂点の走査順序\n    const res = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* 深さ優先走査の補助関数 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // 訪問した頂点を記録\n    visited.add(vet); // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 訪問済みの頂点をスキップ\n        }\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂点の走査順序\n    const res: Vertex[] = [];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* 深さ優先走査の補助関数 */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // 訪問した頂点を記録\n  visited.add(vet); // この頂点を訪問済みにする\n  // この頂点のすべての隣接頂点を走査\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // 訪問済みの頂点をスキップ\n    }\n    // 隣接頂点を再帰的に訪問\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* 深さ優先探索 */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // 頂点の走査順序\n  List&lt;Vertex&gt; res = [];\n  // 訪問済み頂点を記録するためのハッシュ集合\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* 深さ優先走査の補助関数 */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // 訪問した頂点を記録\n    visited.insert(vet); // この頂点を訪問済みにする\n                         // この頂点のすべての隣接頂点を走査\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // 訪問済みの頂点をスキップ\n            }\n            // 隣接頂点を再帰的に訪問\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂点の走査順序\n    let mut res = vec![];\n    // 訪問済み頂点を記録するためのハッシュ集合\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* 頂点が訪問済みかを確認 */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // 走査してノードを探すため、O(n) 時間を要する\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* 深さ優先走査の補助関数 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // 訪問した頂点を記録\n    res[(*resSize)++] = vet;\n    // この頂点のすべての隣接頂点を走査\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // 訪問済みの頂点をスキップ\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // 隣接頂点を再帰的に訪問\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* 深さ優先走査の補助関数 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // 訪問した頂点を記録\n    visited.add(vet) // この頂点を訪問済みにする\n    // この頂点のすべての隣接頂点を走査\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // 訪問済みの頂点をスキップ\n        // 隣接頂点を再帰的に訪問\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* 深さ優先探索 */\n// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // 頂点の走査順序\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 訪問済み頂点を記録するためのハッシュ集合\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### 深さ優先探索の補助関数 ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # 訪問した頂点を記録\n  visited.add(vet) # この頂点を訪問済みにする\n  # この頂点のすべての隣接頂点を走査\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # 訪問済みの頂点をスキップ\n    # 隣接頂点を再帰的に訪問\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### 深さ優先探索 ###\ndef graph_dfs(graph, start_vet)\n  # 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する\n  # 頂点の走査順序\n  res = []\n  # 訪問済み頂点を記録するためのハッシュ集合\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>深さ優先走査のアルゴリズムの流れは以下の図のとおりです。</p> <ul> <li>**直線の破線は下向きの再帰呼び出し**を表し、新しい頂点を訪問するために新たな再帰メソッドが開始されたことを意味します。</li> <li>**曲線の破線は上向きのバックトラック**を表し、この再帰メソッドがすでに戻って、呼び出し元の位置までたどり着いたことを意味します。</li> </ul> <p>理解を深めるために、以下の図とコードを結びつけて、DFS 全体の過程を頭の中でシミュレーションする（あるいは紙に書き出す）ことを勧めます。各再帰メソッドがいつ開始し、いつ戻るかも含めて追ってみてください。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 9-12   グラフの深さ優先走査の手順 </p> <p>深さ優先走査の順序列は一意ですか？</p> <p>幅優先走査と同様に、深さ優先走査の順序列も一意ではありません。ある頂点が与えられたとき、どの方向を先に探索してもよく、つまり隣接頂点の順序は任意に入れ替えられ、それでも深さ優先走査になります。</p> <p>木の走査を例にすると、「根 \\(\\rightarrow\\) 左 \\(\\rightarrow\\) 右」「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」「左 \\(\\rightarrow\\) 右 \\(\\rightarrow\\) 根」は、それぞれ先行順、中間順、後行順走査に対応します。これらは 3 種類の走査優先順位を示していますが、いずれも深さ優先走査に属します。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   計算量の分析","text":"<p>時間計算量：すべての頂点は \\(1\\) 回ずつ訪問されるため、\\(O(|V|)\\) 時間です。すべての辺は \\(2\\) 回ずつ訪問されるため、\\(O(2|E|)\\) 時間です。したがって全体では \\(O(|V| + |E|)\\) 時間です。</p> <p>空間計算量：リスト <code>res</code> とハッシュ集合 <code>visited</code> に含まれる頂点数は最大で \\(|V|\\) であり、再帰の深さも最大で \\(|V|\\) であるため、\\(O(|V|)\\) 空間です。</p>","path":["第 9 章 &nbsp; グラフ","9.3 &nbsp; グラフの走査"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   まとめ","text":"","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>グラフは頂点と辺から構成され、一組の頂点と一組の辺からなる集合として表せます。</li> <li>線形関係（連結リスト）や分治関係（木）と比べて、ネットワーク関係（グラフ）は自由度が高く、そのぶん複雑です。</li> <li>有向グラフの辺は方向性を持ち、連結グラフでは任意の頂点に到達でき、重み付きグラフの各辺は重み変数を含みます。</li> <li>隣接行列は行列を用いてグラフを表し、各行（列）が 1 つの頂点を表し、行列要素が辺を表します。\\(1\\) または \\(0\\) を用いて、2 つの頂点の間に辺があるかないかを示します。隣接行列は追加・削除・検索・更新の操作効率が高い一方で、より多くの空間を消費します。</li> <li>隣接リストは複数の連結リストを使ってグラフを表し、第 \\(i\\) 個の連結リストが頂点 \\(i\\) に対応し、その頂点に隣接するすべての頂点を格納します。隣接リストは隣接行列よりも省スペースですが、辺を探すために連結リストを走査する必要があるため、時間効率は低くなります。</li> <li>隣接リスト内の連結リストが長くなりすぎた場合は、赤黒木やハッシュテーブルに変換することで、検索効率を高められます。</li> <li>アルゴリズムの考え方という観点では、隣接行列は「空間を時間と引き換えにする」ことを体現し、隣接リストは「時間を空間と引き換えにする」ことを体現します。</li> <li>グラフは、ソーシャルネットワークや地下鉄路線など、さまざまな現実のシステムをモデル化するために使えます。</li> <li>木はグラフの特殊な一例であり、木の走査もグラフ走査の特殊な一例です。</li> <li>グラフの幅優先探索は、近いところから遠いところへ、層ごとに広がっていく探索方法であり、通常はキューを使って実装します。</li> <li>グラフの深さ優先探索は、まず行けるところまで進み、進めなくなったらバックトラックする探索方法であり、通常は再帰に基づいて実装します。</li> </ul>","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：経路の定義は頂点列ですか、それとも辺列ですか？</p> <p>Wikipedia では言語版ごとに定義が一致していません。英語版では「経路は辺の列」であり、中国語版では「経路は頂点の列」です。以下は英語版の原文です：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>本書では、経路を頂点列ではなく辺列とみなします。これは、2 つの頂点の間に複数の辺が存在する可能性があり、その場合は各辺がそれぞれ 1 本の経路に対応するためです。</p> <p>Q：非連結グラフには到達できない頂点がありますか？</p> <p>非連結グラフでは、ある頂点から出発すると、少なくとも 1 つの頂点には到達できません。非連結グラフ全体を走査するには、グラフ内のすべての連結成分をたどれるように複数の始点を設定する必要があります。</p> <p>Q：隣接リストにおいて、「その頂点に接続されたすべての頂点」の順序に決まりはありますか？</p> <p>順序は任意でかまいません。ただし実際の応用では、頂点を追加した順序や頂点値の大小順など、特定の規則に従って並べ替える必要がある場合があります。そうすることで、「ある種の極値を持つ」頂点をすばやく見つけやすくなります。</p>","path":["第 9 章 &nbsp; グラフ","9.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"第 15 章   貪欲法","text":"<p>Abstract</p> <p>ヒマワリは太陽に向かって回り、自らが最も大きく成長できる可能性を常に追い求める。</p> <p>貪欲戦略は、一回ごとの単純な選択を通じて、徐々に最適な答えへと導く。</p>","path":["第 15 章 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"章の内容","text":"<ul> <li>15.1   貪欲法</li> <li>15.2   分数ナップサック問題</li> <li>15.3   最大容量問題</li> <li>15.4   最大積分割問題</li> <li>15.5   まとめ</li> </ul>","path":["第 15 章 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   分数ナップサック問題","text":"<p>Question</p> <p>\\(n\\) 個の品物が与えられ、第 \\(i\\) 個の品物の重さは \\(wgt[i-1]\\)、価値は \\(val[i-1]\\) であり、容量が \\(cap\\) のナップサックがある。各品物は 1 回だけ選択できるが、品物の一部を選ぶこともでき、価値は選択した重量の割合に応じて計算される。容量制限の下でナップサック内の品物の最大価値を求めよ。例を以下に示す。</p> <p></p> <p> 図 15-3   分数ナップサック問題の例データ </p> <p>分数ナップサック問題は 0-1 ナップサック問題と全体として非常によく似ており、状態には現在の品物 \\(i\\) と容量 \\(c\\) が含まれ、目標は容量制限下での最大価値を求めることである。</p> <p>異なる点は、本問では品物の一部だけを選べることである。以下に示すように、品物は任意に分割でき、対応する価値は重量の割合に応じて計算される。</p> <ol> <li>品物 \\(i\\) について、単位重量あたりの価値は \\(val[i-1] / wgt[i-1]\\) であり、これを単位価値と呼ぶ。</li> <li>品物 \\(i\\) の一部を重さ \\(w\\) だけ入れると、ナップサックに増える価値は \\(w \\times val[i-1] / wgt[i-1]\\) となる。</li> </ol> <p></p> <p> 図 15-4   品物の単位重量あたりの価値 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>ナップサック内の品物の総価値を最大化することは、**本質的には単位重量あたりの品物価値を最大化すること**である。そこから、以下に示す貪欲戦略を導ける。</p> <ol> <li>品物を単位価値の高い順にソートする。</li> <li>すべての品物を走査し、各回で単位価値が最も高い品物を貪欲に選択する。</li> <li>残りのナップサック容量が足りない場合は、現在の品物の一部を使ってナップサックを満たす。</li> </ol> <p></p> <p> 図 15-5   分数ナップサック問題の貪欲戦略 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   コード実装","text":"<p>品物を単位価値でソートできるように、<code>Item</code> クラスを定義する。貪欲選択を繰り返し、ナップサックが満杯になったら終了して解を返す。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"品物\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # 品物の重さ\n        self.v = v  # 品物の価値\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"分数ナップサック：貪欲法\"\"\"\n    # 重さと価値の 2 属性を持つ品物リストを作成\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # 単位価値 item.v / item.w の高い順にソートする\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # 貪欲選択を繰り返す\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v\n            cap -= item.w\n        else:\n            # 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap\n            # 残り容量がないため、ループを抜ける\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* 品物 */\nclass Item {\n  public:\n    int w; // 品物の重さ\n    int v; // 品物の価値\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // 貪欲選択を繰り返す\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double)item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* 品物 */\nclass Item {\n    int w; // 品物の重さ\n    int v; // 品物の価値\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // 貪欲選択を繰り返す\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double) item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* 品物 */\nclass Item(int w, int v) {\n    public int w = w; // 品物の重さ\n    public int v = v; // 品物の価値\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // 貪欲選択を繰り返す\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (double)item.v / item.w * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* 品物 */\ntype Item struct {\n    w int // 品物の重さ\n    v int // 品物の価値\n}\n\n/* 分数ナップサック：貪欲法 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // 貪欲選択を繰り返す\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* 品物 */\nclass Item {\n    var w: Int // 品物の重さ\n    var v: Int // 品物の価値\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // 貪欲選択を繰り返す\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* 品物 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // 品物の重さ\n        this.v = v; // 品物の価値\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 貪欲選択を繰り返す\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* 品物 */\nclass Item {\n    w: number; // 品物の重さ\n    v: number; // 品物の価値\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 貪欲選択を繰り返す\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (item.v / item.w) * cap;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* 品物 */\nclass Item {\n  int w; // 品物の重さ\n  int v; // 品物の価値\n\n  Item(this.w, this.v);\n}\n\n/* 分数ナップサック：貪欲法 */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // 重さと価値の 2 属性を持つ品物リストを作成\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // 単位価値 item.v / item.w の高い順にソートする\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // 貪欲選択を繰り返す\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n      res += item.v / item.w * cap;\n      // 残り容量がないため、ループを抜ける\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* 品物 */\nstruct Item {\n    w: i32, // 品物の重さ\n    v: i32, // 品物の価値\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* 分数ナップサック：貪欲法 */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // 貪欲選択を繰り返す\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // 残り容量がないため、ループを抜ける\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* 品物 */\ntypedef struct {\n    int w; // 品物の重さ\n    int v; // 品物の価値\n} Item;\n\n/* 分数ナップサック：貪欲法 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // 貪欲選択を繰り返す\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* 品物 */\nclass Item(\n    val w: Int, // 品物\n    val v: Int  // 品物の価値\n)\n\n/* 分数ナップサック：貪欲法 */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // 重さと価値の 2 属性を持つ品物リストを作成\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // 単位価値 item.v / item.w の高い順にソートする\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // 貪欲選択を繰り返す\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n            res += item.v\n            cap -= item.w\n        } else {\n            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n            res += item.v.toDouble() / item.w * cap\n            // 残り容量がないため、ループを抜ける\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### アイテム ###\nclass Item\n  attr_accessor :w # 品物の重さ\n  attr_accessor :v # 品物の価値\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### 分数ナップサック：貪欲法 ###\ndef fractional_knapsack(wgt, val, cap)\n  # 重さと価値の 2 属性を持つ品物リストを作成する\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # 単位価値 item.v / item.w の高い順にソートする\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # 貪欲選択を繰り返す\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる\n      res += item.v\n      cap -= item.w\n    else\n      # 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる\n      res += (item.v.to_f / item.w) * cap\n      # 残り容量がないため、ループを抜ける\n      break\n    end\n  end\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>組み込みのソートアルゴリズムの時間計算量は通常 \\(O(\\log n)\\)、空間計算量は通常 \\(O(\\log n)\\) または \\(O(n)\\) であり、具体的な値はプログラミング言語の実装に依存する。</p> <p>ソートを除けば、最悪の場合は品物リスト全体を走査する必要があるため、時間計算量は \\(O(n)\\) であり、ここで \\(n\\) は品物数である。</p> <p><code>Item</code> オブジェクトのリストを初期化しているため、空間計算量は \\(O(n)\\) である。</p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>背理法を用いる。品物 \\(x\\) が単位価値最大の品物であり、あるアルゴリズムで得られた最大価値を <code>res</code> とするが、その解には品物 \\(x\\) が含まれていないと仮定する。</p> <p>ここでナップサックから単位重量の任意の品物を取り出し、単位重量の品物 \\(x\\) に置き換える。品物 \\(x\\) の単位価値が最大であるため、置き換え後の総価値は必ず <code>res</code> より大きくなる。これは <code>res</code> が最適解であることに矛盾し、最適解には必ず品物 \\(x\\) が含まれなければならないことを示す。</p> <p>この解に含まれる他の品物についても、同様の矛盾を構成できる。要するに、単位価値がより大きい品物は常により良い選択である。これは貪欲戦略が有効であることを示している。</p> <p>以下に示すように、品物の重さと品物の単位価値をそれぞれ二次元グラフの横軸と縦軸とみなすと、分数ナップサック問題は「有限な横軸区間で囲まれる最大面積を求める問題」に変換できる。この類比は、幾何学的な観点から貪欲戦略の有効性を理解する助けになる。</p> <p></p> <p> 図 15-6   分数ナップサック問題の幾何学的表現 </p>","path":["第 15 章 &nbsp; 貪欲法","15.2 &nbsp; 分数ナップサック問題"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   貪欲法","text":"<p>貪欲法（greedy algorithm）は、最適化問題を解くための一般的なアルゴリズムです。その基本的な考え方は、問題の各意思決定段階において、その時点で最善に見える選択を行い、すなわち貪欲に局所最適な決定を下すことで、大域最適解を得ようとするものです。貪欲法は簡潔で効率的であり、多くの実際の問題で広く用いられています。</p> <p>貪欲法と動的計画法は、どちらも最適化問題を解く際によく用いられます。両者には、最適部分構造に依存するなどの共通点がありますが、その動作原理は異なります。</p> <ul> <li>動的計画法は、前の段階までのすべての決定に基づいて現在の決定を考え、過去の部分問題の解を用いて現在の部分問題の解を構築します。</li> <li>貪欲法は過去の決定を考慮せず、ひたすら前に進みながら貪欲な選択を行い、問題の範囲を縮小し続けて、最終的に問題を解決します。</li> </ul> <p>まずは例題「コイン両替」を通して、貪欲法の仕組みを理解しましょう。この問題はすでに「完全ナップサック問題」の節で紹介しているので、見覚えがあるはずです。</p> <p>Question</p> <p>\\(n\\) 種類の硬貨が与えられ、\\(i\\) 番目の硬貨の額面は \\(coins[i - 1]\\) 、目標金額は \\(amt\\) です。各硬貨は何度でも選べるとき、目標金額を作るために必要な最小の硬貨枚数を求めてください。目標金額を作れない場合は \\(-1\\) を返します。</p> <p>この問題で採用する貪欲戦略は下図のとおりです。目標金額が与えられたら、それを超えず、かつ最も近い硬貨を貪欲に選択し、この手順を目標金額を作り切るまで繰り返します。</p> <p></p> <p> 図 15-1   コイン両替の貪欲戦略 </p> <p>実装コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"コイン交換：貪欲法\"\"\"\n    # coins リストはソート済みと仮定する\n    i = len(coins) - 1\n    count = 0\n    # 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0:\n        # 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # coins[i] を選択する\n        amt -= coins[i]\n        count += 1\n    # 実行可能な解が見つからなければ -1 を返す\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.size() - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.length - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* コイン交換：貪欲法 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = coins.Length - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* コイン交換：貪欲法 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // coins リストはソート済みと仮定する\n    i := len(coins) - 1\n    count := 0\n    // 残額がなくなるまで貪欲選択を繰り返す\n    for amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // coins[i] を選択する\n        amt -= coins[i]\n        count++\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* コイン交換：貪欲法 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // coins リストはソート済みと仮定する\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // coins[i] を選択する\n        amt -= coins[i]\n        count += 1\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* コイン交換：貪欲法 */\nfunction coinChangeGreedy(coins, amt) {\n    // coins 配列はソート済みと仮定する\n    let i = coins.length - 1;\n    let count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* コイン交換：貪欲法 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // coins 配列はソート済みと仮定する\n    let i = coins.length - 1;\n    let count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // coins リストはソート済みと仮定する\n  int i = coins.length - 1;\n  int count = 0;\n  // 残額がなくなるまで貪欲選択を繰り返す\n  while (amt &gt; 0) {\n    // 残額以下で最も近い硬貨を見つける\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // coins[i] を選択する\n    amt -= coins[i];\n    count++;\n  }\n  // 実行可能な解が見つからなければ -1 を返す\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* コイン交換：貪欲法 */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // coins リストはソート済みと仮定する\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while amt &gt; 0 {\n        // 残額以下で最も近い硬貨を見つける\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count += 1;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* コイン交換：貪欲法 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // coins リストはソート済みと仮定する\n    int i = size - 1;\n    int count = 0;\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (amt &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // coins[i] を選択する\n        amt -= coins[i];\n        count++;\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* コイン交換：貪欲法 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // coins リストはソート済みと仮定する\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // 残額がなくなるまで貪欲選択を繰り返す\n    while (am &gt; 0) {\n        // 残額以下で最も近い硬貨を見つける\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // coins[i] を選択する\n        am -= coins[i]\n        count++\n    }\n    // 実行可能な解が見つからなければ -1 を返す\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### コイン両替：貪欲法 ###\ndef coin_change_greedy(coins, amt)\n  # coins リストはソート済みと仮定する\n  i = coins.length - 1\n  count = 0\n  # 残額がなくなるまで貪欲選択を繰り返す\n  while amt &gt; 0\n    # 残額以下で最も近い硬貨を見つける\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # coins[i] を選択する\n    amt -= coins[i]\n    count += 1\n  end\n  # 実行可能な解が見つからなければ `-1` を返す\n  amt == 0 ? count : -1\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>思わずこう言いたくなるかもしれません。So clean！貪欲法はわずか十行ほどのコードでコイン両替問題を解いてしまいます。</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   貪欲法の利点と限界","text":"<p>**貪欲法は操作が直接的で実装が簡単なだけでなく、通常は効率も高い**です。上のコードでは、硬貨の最小額面を \\(\\min(coins)\\) とすると、貪欲選択のループ回数は高々 \\(amt / \\min(coins)\\) 回であり、時間計算量は \\(O(amt / \\min(coins))\\) です。これは動的計画法による解法の時間計算量 \\(O(n \\times amt)\\) より 1 桁小さいオーダーです。</p> <p>しかし、硬貨の額面の組み合わせによっては、貪欲法では最適解を見つけられません。下図に 2 つの例を示します。</p> <ul> <li>正例 \\(coins = [1, 5, 10, 20, 50, 100]\\)：この硬貨の組み合わせでは、任意の \\(amt\\) に対して貪欲法で最適解を見つけられます。</li> <li>反例 \\(coins = [1, 20, 50]\\)：\\(amt = 60\\) とすると、貪欲法では \\(50 + 1 \\times 10\\) という両替しか見つからず、硬貨は合計 \\(11\\) 枚になります。しかし動的計画法なら最適解 \\(20 + 20 + 20\\) を見つけられ、必要なのはわずか \\(3\\) 枚です。</li> <li>反例 \\(coins = [1, 49, 50]\\)：\\(amt = 98\\) とすると、貪欲法では \\(50 + 1 \\times 48\\) という両替しか見つからず、硬貨は合計 \\(49\\) 枚になります。しかし動的計画法なら最適解 \\(49 + 49\\) を見つけられ、必要なのはわずか \\(2\\) 枚です。</li> </ul> <p></p> <p> 図 15-2   貪欲法では最適解を見つけられない例 </p> <p>つまり、コイン両替問題に対して、貪欲法は大域最適解を保証できず、非常に悪い解を見つけてしまうこともあります。この問題は動的計画法で解くほうが適しています。</p> <p>一般に、貪欲法が適用できる状況は次の 2 つに分けられます。</p> <ol> <li>最適解を保証できる場合：この場合、貪欲法はしばしば最良の選択です。多くの場合、バックトラッキングや動的計画法より効率的だからです。</li> <li>近似最適解を見つけられる場合：この場合も貪欲法は有効です。多くの複雑な問題では、大域最適解を求めること自体が非常に難しく、より高い効率で準最適解を得られるだけでも十分価値があります。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   貪欲法の特性","text":"<p>では、どのような問題が貪欲法に適しているのでしょうか。言い換えると、貪欲法はどのような場合に最適解を保証できるのでしょうか。</p> <p>動的計画法と比べると、貪欲法の適用条件はより厳しく、主に次の 2 つの性質に注目します。</p> <ul> <li>貪欲選択性：局所最適な選択が常に大域最適解につながる場合にのみ、貪欲法は最適解を保証できます。</li> <li>最適部分構造：元の問題の最適解が、部分問題の最適解を含むことです。</li> </ul> <p>最適部分構造については「動的計画法」の節ですでに紹介したので、ここでは繰り返しません。なお、問題によっては最適部分構造が明確でなくても、貪欲法で解ける場合があります。</p> <p>ここでは主に、貪欲選択性をどのように判定するかを考えます。説明だけを見ると単純そうですが、実際には多くの問題で、貪欲選択性を証明するのは容易ではありません。</p> <p>たとえばコイン両替問題では、反例を挙げて貪欲選択性が成り立たないことを示すのは簡単ですが、成り立つことを証明するのは難しいです。もし、**どのような条件を満たす硬貨の組み合わせなら貪欲法で解けるのか**と問われると、直感や例示に頼った曖昧な答えしか出せず、厳密な数学的証明を与えるのは困難です。</p> <p>Quote</p> <p>ある論文では、ある硬貨の組み合わせについて、任意の金額に対する最適解を貪欲法で求められるかどうかを判定する、時間計算量 \\(O(n^3)\\) のアルゴリズムが示されています。</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   貪欲法の問題解決手順","text":"<p>貪欲法による問題解決の流れは、おおむね次の 3 段階に分けられます。</p> <ol> <li>問題分析：状態の定義、最適化目標、制約条件などを整理し、問題の性質を理解します。この段階はバックトラッキングや動的計画法でも共通して現れます。</li> <li>貪欲戦略の決定：各ステップでどのように貪欲選択を行うかを定めます。この戦略により各ステップで問題規模を縮小し、最終的に問題全体を解決します。</li> <li>正しさの証明：通常は、その問題が貪欲選択性と最適部分構造を持つことを示す必要があります。この段階では、帰納法や背理法などの数学的証明が必要になることがあります。</li> </ol> <p>貪欲戦略を定めることは問題解決の核心ですが、実際には簡単ではないことも多く、主な理由は次のとおりです。</p> <ul> <li>問題ごとに貪欲戦略の差が大きい。多くの問題では貪欲戦略は比較的わかりやすく、おおまかな考察や試行だけで見つけられます。しかし複雑な問題では、貪欲戦略が非常に見えにくいことがあり、その場合は解法経験やアルゴリズム力が大きく問われます。</li> <li>一見もっともらしい貪欲戦略もある。自信を持って貪欲戦略を設計し、コードを書いて提出しても、一部のテストケースを通過できないことがあります。これは、その貪欲戦略が「部分的にしか正しくない」ためであり、先ほどのコイン両替は典型例です。</li> </ul> <p>正しさを保証するためには、貪欲戦略に対して厳密な数学的証明を行うべきであり、通常は背理法や数学的帰納法が必要になります。</p> <p>しかし、正しさの証明もまた簡単とは限りません。手がかりがない場合には、テストケースを使ってコードをデバッグしながら、貪欲戦略を少しずつ修正して検証していくことがよくあります。</p>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   貪欲法の典型問題","text":"<p>貪欲法は、貪欲選択性と最適部分構造を満たす最適化問題によく用いられます。以下に典型的な貪欲法の問題をいくつか挙げます。</p> <ul> <li>硬貨のお釣り問題：ある種の硬貨の組み合わせでは、貪欲法で常に最適解が得られます。</li> <li>区間スケジューリング問題：いくつかのタスクがあり、それぞれがある時間区間で実行されるとします。できるだけ多くのタスクを完了することが目標で、毎回終了時刻が最も早いタスクを選ぶなら、貪欲法で最適解を得られます。</li> <li>分数ナップサック問題：一群の品物と積載容量が与えられたとき、総重量が容量を超えず、かつ総価値が最大になるように品物を選ぶ問題です。毎回、価値対重量比（価値 / 重量）が最も高い品物を選ぶなら、ある条件下で貪欲法は最適解を得られます。</li> <li>株式売買問題：株価の履歴が与えられ、複数回の売買が可能ですが、すでに株を保有している場合は売却前に再度購入することはできません。目標は最大利益を得ることです。</li> <li>ハフマン符号化：ハフマン符号化は、可逆データ圧縮に用いられる貪欲法です。ハフマン木を構築する際、毎回出現頻度が最も低い 2 つのノードを選んで併合すると、最終的に得られるハフマン木の重み付きパス長（符号長）は最小になります。</li> <li>Dijkstra アルゴリズム：与えられた始点から他の各頂点への最短経路問題を解く貪欲法です。</li> </ul>","path":["第 15 章 &nbsp; 貪欲法","15.1 &nbsp; 貪欲法"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   最大容量問題","text":"<p>Question</p> <p>配列 \\(ht\\) が与えられ、各要素は垂直な仕切り板の高さを表します。配列内の任意の 2 枚の仕切り板と、その間の空間で容器を構成できます。</p> <p>容器の容量は高さと幅の積（面積）に等しく、高さは短い方の仕切り板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。</p> <p>配列から 2 枚の仕切り板を選び、構成される容器の容量が最大となるようにしてください。最大容量を返します。例を以下の図に示します。</p> <p></p> <p> 図 15-7   最大容量問題のサンプルデータ </p> <p>容器は任意の 2 枚の仕切り板で囲まれるため、本問の状態は 2 枚の仕切り板のインデックスで表され、\\([i, j]\\) と記します。</p> <p>問題の条件より、容量は高さと幅の積に等しく、高さは短い板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。容量を \\(cap[i, j]\\) とすると、計算式は次のようになります。</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>配列の長さを \\(n\\) とすると、2 枚の仕切り板の組合せ数（状態総数）は \\(C_n^2 = \\frac{n(n - 1)}{2}\\) 個です。最も直接的には、すべての状態を総当たりできます。これにより最大容量を求められ、時間計算量は \\(O(n^2)\\) です。</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>この問題にはさらに効率的な解法があります。以下の図のように、状態 \\([i, j]\\) を 1 つ選び、インデックスが \\(i &lt; j\\) かつ高さが \\(ht[i] &lt; ht[j]\\) を満たすとします。つまり、\\(i\\) が短い板、\\(j\\) が長い板です。</p> <p></p> <p> 図 15-8   初期状態 </p> <p>以下の図のように、このとき長い板 \\(j\\) を短い板 \\(i\\) に近づけると、容量は必ず小さくなります。</p> <p>これは、長い板 \\(j\\) を動かした後は幅 \\(j-i\\) が必ず小さくなるためです。また、高さは短い板で決まるので、高さは変わらない（ \\(i\\) が依然として短い板）か、小さくなる（移動後の \\(j\\) が短い板になる）ことしかありません。</p> <p></p> <p> 図 15-9   長い板を内側へ動かした後の状態 </p> <p>逆に考えると、短い板 \\(i\\) を内側へ縮めた場合にのみ、容量が大きくなる可能性があります。幅は必ず小さくなりますが、**高さは大きくなる可能性がある**からです（移動後の短い板 \\(i\\) がより長くなる可能性があります）。たとえば次の図では、短い板を動かした後に面積が大きくなっています。</p> <p></p> <p> 図 15-10   短い板を内側へ動かした後の状態 </p> <p>以上から、本問の貪欲戦略を導けます。2 本のポインタを初期化して容器の両端に置き、各ラウンドで短い板に対応するポインタを内側へ縮め、2 本のポインタが出会うまで続けます。</p> <p>以下の図は、貪欲戦略の実行過程を示しています。</p> <ol> <li>初期状態では、ポインタ \\(i\\) と \\(j\\) は配列の両端にあります。</li> <li>現在の状態の容量 \\(cap[i, j]\\) を計算し、最大容量を更新します。</li> <li>板 \\(i\\) と板 \\(j\\) の高さを比較し、短い板を内側へ 1 マス移動します。</li> <li><code>2.</code> と <code>3.</code> を繰り返し実行し、\\(i\\) と \\(j\\) が出会ったら終了します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 15-11   最大容量問題の貪欲な過程 </p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   コード実装","text":"<p>コードのループ回数は最大でも \\(n\\) 回であるため、時間計算量は \\(O(n)\\) です。</p> <p>変数 \\(i\\)、\\(j\\)、\\(res\\) が使う追加領域は定数サイズなので、空間計算量は \\(O(1)\\) です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"最大容量：貪欲法\"\"\"\n    # i, j を初期化し、それぞれ配列の両端に置く\n    i, j = 0, len(ht) - 1\n    # 初期の最大容量は 0\n    res = 0\n    # 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j:\n        # 最大容量を更新する\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # 短い方を内側へ動かす\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.size() - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(int[] ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.length - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* 最大容量：貪欲法 */\nint MaxCapacity(int[] ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0, j = ht.Length - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* 最大容量：貪欲法 */\nfunc maxCapacity(ht []int) int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    i, j := 0, len(ht)-1\n    // 初期の最大容量は 0\n    res := 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    for i &lt; j {\n        // 最大容量を更新する\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* 最大容量：貪欲法 */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // 初期の最大容量は 0\n    var res = 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j {\n        // 最大容量を更新する\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* 最大容量：貪欲法 */\nfunction maxCapacity(ht) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let i = 0,\n        j = ht.length - 1;\n    // 初期の最大容量は 0\n    let res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* 最大容量：貪欲法 */\nfunction maxCapacity(ht: number[]): number {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let i = 0,\n        j = ht.length - 1;\n    // 初期の最大容量は 0\n    let res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(List&lt;int&gt; ht) {\n  // i, j を初期化し、それぞれ配列の両端に置く\n  int i = 0, j = ht.length - 1;\n  // 初期の最大容量は 0\n  int res = 0;\n  // 2 枚の板が出会うまで貪欲選択を繰り返す\n  while (i &lt; j) {\n    // 最大容量を更新する\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // 短い方を内側へ動かす\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* 最大容量：貪欲法 */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // 初期の最大容量は 0\n    let mut res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while i &lt; j {\n        // 最大容量を更新する\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // 短い方を内側へ動かす\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* 最大容量：貪欲法 */\nint maxCapacity(int ht[], int htLength) {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    int i = 0;\n    int j = htLength - 1;\n    // 初期の最大容量は 0\n    int res = 0;\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* 最大容量：貪欲法 */\nfun maxCapacity(ht: IntArray): Int {\n    // i, j を初期化し、それぞれ配列の両端に置く\n    var i = 0\n    var j = ht.size - 1\n    // 初期の最大容量は 0\n    var res = 0\n    // 2 枚の板が出会うまで貪欲選択を繰り返す\n    while (i &lt; j) {\n        // 最大容量を更新する\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 短い方を内側へ動かす\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### 最大容量：貪欲法 ###\ndef max_capacity(ht)\n  # i, j を初期化し、それぞれ配列の両端に置く\n  i, j = 0, ht.length - 1\n  # 初期の最大容量は 0\n  res = 0\n\n  # 2 枚の板が出会うまで貪欲選択を繰り返す\n  while i &lt; j\n    # 最大容量を更新する\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # 短い方を内側へ動かす\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>貪欲法が総当たりより速いのは、各ラウンドの貪欲な選択がいくつかの状態を「スキップ」するためです。</p> <p>たとえば状態 \\(cap[i, j]\\) において、\\(i\\) が短い板、\\(j\\) が長い板だとします。貪欲に短い板 \\(i\\) を内側へ 1 マス動かすと、次の図に示す状態が「スキップ」されます。これは、その後それらの状態の容量を検証できないことを意味します。</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> 図 15-12   短い板の移動によってスキップされる状態 </p> <p>観察すると、これらのスキップされた状態は、実際には長い板 \\(j\\) を内側へ動かしたすべての状態そのものです。前述のとおり、長い板を内側へ動かすと容量は必ず小さくなります。つまり、スキップされた状態はいずれも最適解にはなりえず、それらを飛ばしても最適解を逃すことはありません。</p> <p>以上の分析から、短い板を動かす操作は「安全」であり、貪欲戦略は有効であると分かります。</p>","path":["第 15 章 &nbsp; 貪欲法","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   最大積分割問題","text":"<p>Question</p> <p>正整数 \\(n\\) が与えられたとき、それを少なくとも 2 つの正整数の和に分割し、分割後のすべての整数の積の最大値を求めよ。下図に示す。</p> <p></p> <p> 図 15-13   最大積分割問題の定義 </p> <p>仮に \\(n\\) を \\(m\\) 個の整数因子に分割し、そのうち第 \\(i\\) 個の因子を \\(n_i\\) と記すと、</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>本問題の目的は、すべての整数因子の積の最大値を求めることであり、すなわち</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>考えるべきことは、分割数 \\(m\\) をいくつにすべきか、各 \\(n_i\\) をいくつにすべきかである。</p>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   貪欲戦略の決定","text":"<p>経験的に、2 つの整数の積はその和より大きくなることが多い。\\(n\\) から因子 \\(2\\) を 1 つ切り出すと、それらの積は \\(2(n-2)\\) となる。この積を \\(n\\) と比較すると、</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>下図のように、\\(n \\geq 4\\) のとき、\\(2\\) を 1 つ切り出すと積は大きくなる。これは、\\(4\\) 以上の整数はすべて分割すべきことを意味する。</p> <p>貪欲戦略一：分割方法に \\(\\geq 4\\) の因子が含まれるなら、それはさらに分割すべきである。最終的な分割方法に現れる因子は \\(1\\)、\\(2\\)、\\(3\\) の 3 種類だけである。</p> <p></p> <p> 図 15-14   分割により積が大きくなる </p> <p>次に、どの因子が最適かを考える。\\(1\\)、\\(2\\)、\\(3\\) の 3 つの因子のうち、明らかに \\(1\\) が最も悪い。なぜなら \\(1 \\times (n-1) &lt; n\\) は常に成り立ち、\\(1\\) を切り出すとかえって積が小さくなるからである。</p> <p>下図のように、\\(n = 6\\) のとき、\\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\) が成り立つ。これは、\\(2\\) を切り出すより \\(3\\) を切り出すほうが有利であることを意味する。</p> <p>貪欲戦略二：分割方法の中に存在してよい \\(2\\) は高々 2 つである。なぜなら、3 つの \\(2\\) は常に 2 つの \\(3\\) に置き換えられ、より大きな積を得られるからである。</p> <p></p> <p> 図 15-15   最適な分割因子 </p> <p>以上より、次の貪欲戦略が導かれる。</p> <ol> <li>整数 \\(n\\) を入力し、余りが \\(0\\)、\\(1\\)、\\(2\\) になるまで、そこから因子 \\(3\\) を繰り返し切り出す。</li> <li>余りが \\(0\\) のとき、\\(n\\) は \\(3\\) の倍数であることを表すため、何も処理しない。</li> <li>余りが \\(2\\) のときは、それ以上分割せず、そのまま残す。</li> <li>余りが \\(1\\) のとき、\\(2 \\times 2 &gt; 1 \\times 3\\) であるため、最後の \\(3\\) を \\(2\\) に置き換えるべきである。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   コード実装","text":"<p>下図のように、ループで整数を分割する必要はなく、切り捨て除算によって \\(3\\) の個数 \\(a\\) を、剰余演算によって余り \\(b\\) を得られる。このとき、</p> \\[ n = 3 a + b \\] <p>なお、\\(n \\leq 3\\) の境界ケースでは、必ず \\(1\\) を 1 つ分割する必要があり、積は \\(1 \\times (n - 1)\\) となる。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"最大切断積：貪欲法\"\"\"\n    # n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    a, b = n // 3, n % 3\n    if b == 1:\n        # 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # 余りが 2 のときは、そのままにする\n        return int(math.pow(3, a)) * 2\n    # 余りが 0 のときは、そのままにする\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int)pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int) Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* 最大切断積：貪欲法 */\nint MaxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* 最大切断積：貪欲法 */\nfunc maxProductCutting(n int) int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* 最大切断積：貪欲法 */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        return pow(3, a) * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* 最大切断積：貪欲法 */\nfunction maxProductCutting(n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 余りが 2 のときは、そのままにする\n        return Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* 最大切断積：貪欲法 */\nfunction maxProductCutting(n: number): number {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 余りが 2 のときは、そのままにする\n        return Math.pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n  // n &lt;= 3 のときは、必ず 1 を切り出す\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // 余りが 2 のときは、そのままにする\n    return (pow(3, a) * 2).toInt();\n  }\n  // 余りが 0 のときは、そのままにする\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* 最大切断積：貪欲法 */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // 余りが 2 のときは、そのままにする\n        3_i32.pow(a as u32) * 2\n    } else {\n        // 余りが 0 のときは、そのままにする\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* 最大切断積：貪欲法 */\nint maxProductCutting(int n) {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return pow(3, a) * 2;\n    }\n    // 余りが 0 のときは、そのままにする\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* 最大切断積：貪欲法 */\nfun maxProductCutting(n: Int): Int {\n    // n &lt;= 3 のときは、必ず 1 を切り出す\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // 余りが 2 のときは、そのままにする\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // 余りが 0 のときは、そのままにする\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### 最大分割積：貪欲法 ###\ndef max_product_cutting(n)\n  # n &lt;= 3 のときは、必ず 1 を切り出す\n  return 1 * (n - 1) if n &lt;= 3\n  # 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする\n  a, b = n / 3, n % 3\n  # 余りが 1 のときは、1 * 3 を 2 * 2 に変える\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # 余りが 2 のときは、そのままにする\n  return (3.pow(a) * 2).to_i if b == 2\n  # 余りが 0 のときは、そのままにする\n  3.pow(a).to_i\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p></p> <p> 図 15-16   最大積分割の計算方法 </p> <p>時間計算量は、プログラミング言語におけるべき乗演算の実装方法に依存する。Python を例に取ると、よく使われるべき乗計算関数は 3 種類ある。</p> <ul> <li>演算子 <code>**</code> と関数 <code>pow()</code> の時間計算量はいずれも \\(O(\\log⁡ a)\\) である。</li> <li>関数 <code>math.pow()</code> は内部で C 言語ライブラリの <code>pow()</code> 関数を呼び出し、浮動小数点のべき乗を実行するため、時間計算量は \\(O(1)\\) である。</li> </ul> <p>変数 \\(a\\) と \\(b\\) が使う追加領域は定数サイズであり、したがって空間計算量は \\(O(1)\\) である。</p>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   正しさの証明","text":"<p>背理法を用い、\\(n \\geq 4\\) の場合のみを考える。</p> <ol> <li>すべての因子は \\(\\leq 3\\) ：最適な分割方法に \\(\\geq 4\\) の因子 \\(x\\) が存在すると仮定すると、それは必ずさらに \\(2(x-2)\\) に分割でき、より大きい（または等しい）積が得られる。これは仮定に矛盾する。</li> <li>分割方法に \\(1\\) は含まれない ：最適な分割方法に因子 \\(1\\) が 1 つ存在すると仮定すると、それは必ず別の因子に併合でき、より大きい積を得られる。これは仮定に矛盾する。</li> <li>分割方法に含まれる \\(2\\) は高々 2 つ ：最適な分割方法に 3 つの \\(2\\) が含まれると仮定すると、それは必ず 2 つの \\(3\\) に置き換えられ、積はより大きくなる。これは仮定に矛盾する。</li> </ol>","path":["第 15 章 &nbsp; 貪欲法","15.4 &nbsp; 最大積分割問題"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   まとめ","text":"","path":["第 15 章 &nbsp; 貪欲法","15.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   重要な振り返り","text":"<ul> <li>貪欲法は通常、最適化問題を解くために用いられ、その原理は各意思決定段階で局所最適な決定を行い、全体最適解を得ることを目指すというものである。</li> <li>貪欲法は反復的に次々と貪欲な選択を行い、各ラウンドで問題をより小さな部分問題へと変換し、最終的に問題を解決する。</li> <li>貪欲法は実装が簡単であるだけでなく、問題を解く効率も高い。動的計画法と比べると、貪欲法の時間計算量は通常より低い。</li> <li>硬貨両替問題では、ある種の硬貨の組み合わせに対しては貪欲法で最適解を保証できるが、別の組み合わせではそうではなく、非常に悪い解を見つけてしまう可能性がある。</li> <li>貪欲法による解法に適した問題は、貪欲選択性と最適部分構造という 2 つの性質を備えている。貪欲選択性は、貪欲戦略の有効性を表している。</li> <li>一部の複雑な問題では、貪欲選択性を証明するのは容易ではない。相対的には、反例による否定のほうが簡単であり、硬貨両替問題がその一例である。</li> <li>貪欲法の問題を解く流れは主に 3 段階に分かれる。すなわち、問題分析、貪欲戦略の決定、正しさの証明である。このうち、貪欲戦略の決定が中核であり、正しさの証明はしばしば難所となる。</li> <li>分数ナップサック問題は 0-1 ナップサックを基に、品物の一部を選ぶことを許しているため、貪欲法で解くことができる。貪欲戦略の正しさは背理法で証明できる。</li> <li>最大容量問題は全探索で解くことができ、時間計算量は \\(O(n^2)\\) である。貪欲戦略を設計し、各ラウンドで短い板を内側へ動かすことで、時間計算量を \\(O(n)\\) に最適化できる。</li> <li>最大分割積問題では、2 つの貪欲戦略を順に導いた。すなわち、\\(\\geq 4\\) の整数はすべてさらに分割すべきであり、最適な分割因子は \\(3\\) である。コードにはべき乗演算が含まれており、時間計算量はその実装方法に依存し、通常は \\(O(1)\\) または \\(O(\\log n)\\) である。</li> </ul>","path":["第 15 章 &nbsp; 貪欲法","15.5 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"第 6 章   ハッシュテーブル","text":"<p>Abstract</p> <p>コンピュータの世界では、ハッシュテーブルは聡明な図書館員のような存在です。</p> <p>彼は請求記号の計算方法を知っており、そのため目的の本を素早く見つけられます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"章の内容","text":"<ul> <li>6.1   ハッシュテーブル</li> <li>6.2   ハッシュ衝突</li> <li>6.3   ハッシュアルゴリズム</li> <li>6.4   まとめ</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   ハッシュアルゴリズム","text":"<p>前の 2 節では、ハッシュテーブルの動作原理とハッシュ衝突の処理方法を紹介しました。しかし、オープンアドレス法であれ連鎖方式であれ、それらが保証できるのは衝突発生時でもハッシュテーブルが正常に動作することだけであり、ハッシュ衝突そのものを減らすことはできません。</p> <p>ハッシュ衝突があまりにも頻繁に発生すると、ハッシュテーブルの性能は急激に劣化します。下図のように、連鎖方式のハッシュテーブルでは、理想的な場合にはキーと値のペアが各バケットに均等に分布し、最良の検索効率を達成します。最悪の場合には、すべてのキーと値のペアが同じバケットに格納され、時間計算量は \\(O(n)\\) に劣化します。</p> <p></p> <p> 図 6-8   ハッシュ衝突の最良ケースと最悪ケース </p> <p>キーと値のペアの分布はハッシュ関数によって決まります。ハッシュ関数の計算手順を思い出すと、まずハッシュ値を計算し、その後で配列長に対して剰余を取ります。</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>上の式から分かるように、ハッシュテーブルの容量 <code>capacity</code> が固定されているとき、出力値を決めるのはハッシュアルゴリズム <code>hash()</code> です。したがって、それがキーと値のペアのハッシュテーブル内での分布も決定します。</p> <p>これは、ハッシュ衝突の発生確率を下げるには、ハッシュアルゴリズム <code>hash()</code> の設計に注目すべきだということを意味します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631","level":2,"title":"6.3.1   ハッシュアルゴリズムの目標","text":"<p>「高速かつ安定した」ハッシュテーブルというデータ構造を実現するために、ハッシュアルゴリズムは次の特徴を備える必要があります。</p> <ul> <li>決定性：同じ入力に対して、ハッシュアルゴリズムは常に同じ出力を生成しなければなりません。そうして初めて、ハッシュテーブルの信頼性が保たれます。</li> <li>高効率：ハッシュ値の計算過程は十分に高速であるべきです。計算コストが小さいほど、ハッシュテーブルの実用性は高くなります。</li> <li>均一分布：ハッシュアルゴリズムは、キーと値のペアがハッシュテーブル内に均等に分布するようにすべきです。分布が均一であるほど、ハッシュ衝突の確率は低くなります。</li> </ul> <p>実際には、ハッシュアルゴリズムはハッシュテーブルの実装だけでなく、ほかの多くの分野でも広く利用されています。</p> <ul> <li>パスワード保存：ユーザーのパスワードを保護するために、システムは通常、平文パスワードを直接保存せず、そのハッシュ値を保存します。ユーザーがパスワードを入力すると、システムは入力内容のハッシュ値を計算し、保存済みのハッシュ値と比較します。一致すれば、そのパスワードは正しいと見なされます。</li> <li>データ完全性検査：送信側はデータのハッシュ値を計算してデータと一緒に送信できます。受信側は受け取ったデータのハッシュ値を再計算し、受信したハッシュ値と比較できます。両者が一致すれば、そのデータは完全だと見なされます。</li> </ul> <p>暗号分野の応用では、ハッシュ値から元のパスワードを推測するといった逆解析を防ぐために、ハッシュアルゴリズムにはさらに高いレベルの安全性が求められます。</p> <ul> <li>一方向性：ハッシュ値から入力データに関するいかなる情報も逆算できないこと。</li> <li>耐衝突性：異なる 2 つの入力で同じハッシュ値になるものを見つけることが、極めて困難であること。</li> <li>アバランシェ効果：入力のわずかな変化が、出力の大きく予測不能な変化を引き起こすこと。</li> </ul> <p>注意してほしいのは、**「均一分布」と「耐衝突性」は独立した 2 つの概念である**という点です。均一分布を満たしていても、耐衝突性を満たすとは限りません。たとえば、入力 <code>key</code> がランダムである場合、ハッシュ関数 <code>key % 100</code> は均一に分布した出力を生成できます。しかし、このハッシュアルゴリズムはあまりにも単純で、下 2 桁が同じ <code>key</code> はすべて同じ出力になります。そのため、ハッシュ値から利用可能な <code>key</code> を容易に逆算でき、結果としてパスワードが破られてしまいます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632","level":2,"title":"6.3.2   ハッシュアルゴリズムの設計","text":"<p>ハッシュアルゴリズムの設計は、多くの要素を考慮しなければならない複雑な問題です。しかし、要求の高くない場面であれば、いくつかの単純なハッシュアルゴリズムを設計することもできます。</p> <ul> <li>加算ハッシュ：入力の各文字の ASCII コードを足し合わせ、その合計をハッシュ値とします。</li> <li>乗算ハッシュ：乗算の非相関性を利用し、各ラウンドで定数を掛けながら、各文字の ASCII コードをハッシュ値に累積します。</li> <li>XOR ハッシュ：入力データの各要素を XOR 演算で 1 つのハッシュ値に累積します。</li> <li>回転ハッシュ：各文字の ASCII コードを 1 つのハッシュ値に累積し、各回の累積前にハッシュ値を回転させます。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"加算ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"乗算ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"回転ハッシュ\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* 加算ハッシュ */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* 加算ハッシュ */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* 加算ハッシュ */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* 加算ハッシュ */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 乗算ハッシュ */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR ハッシュ */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* 回転ハッシュ */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* 加算ハッシュ */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 乗算ハッシュ */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR ハッシュ */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* 回転ハッシュ */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* 加算ハッシュ */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乗算ハッシュ */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR ハッシュ */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 回転ハッシュ */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* 加算ハッシュ */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乗算ハッシュ */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR ハッシュ */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 回転ハッシュ */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* 加算ハッシュ */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* 加算ハッシュ */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 乗算ハッシュ */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR ハッシュ */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* 回転ハッシュ */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* 加算ハッシュ */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乗算ハッシュ */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR ハッシュ */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 回転ハッシュ */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* 加算ハッシュ */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 乗算ハッシュ */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR ハッシュ */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* 回転ハッシュ */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### 加算ハッシュ ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### 乗算ハッシュ ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR ハッシュ ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### 回転ハッシュ ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>見て分かるように、各ハッシュアルゴリズムの最後のステップでは、大きな素数 \\(1000000007\\) で剰余を取り、ハッシュ値が適切な範囲に収まるようにしています。ここで考えてみる価値があるのは、なぜ素数での剰余を強調するのか、あるいは合成数で剰余を取ることにどんな欠点があるのか、という点です。これは興味深い問題です。</p> <p>先に結論を述べると、法として大きな素数を使うと、ハッシュ値が均一に分布することを最大限に保証できます。素数はほかの数と公約数を持たないため、剰余演算によって生じる周期的なパターンを減らし、ハッシュ衝突を避けやすくなります。</p> <p>たとえば、法として合成数 \\(9\\) を選ぶとします。これは \\(3\\) で割り切れるため、\\(3\\) で割り切れるすべての <code>key</code> は、\\(0\\)、\\(3\\)、\\(6\\) の 3 つのハッシュ値に写像されます。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>入力 <code>key</code> がたまたまこのような等差数列の分布をしていると、ハッシュ値に偏りが生じ、ハッシュ衝突がさらに深刻になります。そこで <code>modulus</code> を素数 \\(13\\) に置き換えると仮定すると、<code>key</code> と <code>modulus</code> の間に公約数が存在しないため、出力されるハッシュ値の均一性は明らかに向上します。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>補足すると、<code>key</code> がランダムかつ均一に分布していると保証できるなら、法に素数を選んでも合成数を選んでも構いません。どちらでも均一に分布したハッシュ値を出力できます。しかし、<code>key</code> の分布に何らかの周期性がある場合、合成数で剰余を取るほうが偏りが生じやすくなります。</p> <p>要するに、通常は法として素数を選び、その素数はできるだけ大きいほうが望ましいです。そうすることで周期的なパターンをできる限り取り除き、ハッシュアルゴリズムの堅牢性を高められます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633","level":2,"title":"6.3.3   一般的なハッシュアルゴリズム","text":"<p>上で紹介した単純なハッシュアルゴリズムは、どれも比較的「脆弱」であり、ハッシュアルゴリズムの設計目標にはほど遠いことが分かります。たとえば、加算と XOR は交換法則を満たすため、加算ハッシュと XOR ハッシュでは、内容が同じで順序だけ異なる文字列を区別できません。これはハッシュ衝突を悪化させ、一部の安全上の問題を引き起こす可能性があります。</p> <p>実際には、MD5、SHA-1、SHA-2、SHA-3 などの標準的なハッシュアルゴリズムを用いることが一般的です。これらは任意長の入力データを、固定長のハッシュ値へ写像できます。</p> <p>ここ 1 世紀近くの間、ハッシュアルゴリズムは継続的に改良と最適化が進められてきました。ある研究者たちは性能向上に取り組み、別の研究者やハッカーたちは安全性の弱点を探し続けてきました。次の表は、実際の応用でよく使われるハッシュアルゴリズムを示したものです。</p> <ul> <li>MD5 と SHA-1 は何度も攻撃に成功されているため、各種のセキュリティ用途では廃止されています。</li> <li>SHA-2 系列の SHA-256 は最も安全なハッシュアルゴリズムの 1 つであり、いまだに成功した攻撃例がないため、多くのセキュリティ用途やプロトコルで広く使われています。</li> <li>SHA-3 は SHA-2 と比べて実装コストが低く、計算効率も高い一方で、現時点での普及度は SHA-2 系列に及びません。</li> </ul> <p> 表 6-2   一般的なハッシュアルゴリズム </p> MD5 SHA-1 SHA-2 SHA-3 発表年 1992 1995 2002 2008 出力長 128 bit 160 bit 256/512 bit 224/256/384/512 bit ハッシュ衝突 多い 多い 非常に少ない 非常に少ない セキュリティレベル 低く、攻撃に成功されている 低く、攻撃に成功されている 高い 高い 用途 廃止済みだが、データ完全性検査には使われる 廃止済み 暗号資産の取引検証、デジタル署名など SHA-2 の代替に使える","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634","level":2,"title":"6.3.4   データ構造のハッシュ値","text":"<p>ご存じのように、ハッシュテーブルの <code>key</code> には整数、小数、文字列などのデータ型を使えます。プログラミング言語は通常、これらのデータ型に対して組み込みのハッシュアルゴリズムを提供し、ハッシュテーブル内のバケットインデックス計算に利用します。Python を例にすると、<code>hash()</code> 関数を呼び出して各種データ型のハッシュ値を計算できます。</p> <ul> <li>整数と真理値のハッシュ値は、その値自身です。</li> <li>浮動小数点数と文字列のハッシュ値の計算はやや複雑なので、興味がある読者は自分で調べてみてください。</li> <li>タプルのハッシュ値は、各要素のハッシュ値を求めてから、それらを組み合わせて 1 つのハッシュ値にしたものです。</li> <li>オブジェクトのハッシュ値は、そのメモリアドレスに基づいて生成されます。オブジェクトのハッシュメソッドをオーバーライドすれば、内容に基づくハッシュ値を実装できます。</li> </ul> <p>Tip</p> <p>注意してください。組み込みのハッシュ値計算関数の定義や方法は、プログラミング言語ごとに異なります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# 整数 3 のハッシュ値は 3\n\nbol = True\nhash_bol = hash(bol)\n# 真理値 True のハッシュ値は 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# 小数 3.14159 のハッシュ値は 326484311674566659\n\nstr = \"Hello アルゴリズム\"\nhash_str = hash(str)\n# 文字列「Hello アルゴリズム」のハッシュ値は 4617003410720528961\n\ntup = (12836, \"シャオハ\")\nhash_tup = hash(tup)\n# タプル (12836, 'シャオハ') のハッシュ値は 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# ノードオブジェクト &lt;ListNode object at 0x1058fd810&gt; のハッシュ値は 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// 整数 3 のハッシュ値は 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// 真理値 1 のハッシュ値は 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// 小数 3.14159 のハッシュ値は 4614256650576692846\n\nstring str = \"Hello アルゴリズム\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// 文字列「Hello アルゴリズム」のハッシュ値は 15466937326284535026\n\n// C++ では、組み込みの std:hash() は基本データ型のハッシュ値計算のみを提供する\n// 配列やオブジェクトのハッシュ値計算は自分で実装する必要がある\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// 整数 3 のハッシュ値は 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// 真理値 true のハッシュ値は 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// 小数 3.14159 のハッシュ値は -1340954729\n\nString str = \"Hello アルゴリズム\";\nint hashStr = str.hashCode();\n// 文字列「Hello アルゴリズム」のハッシュ値は -727081396\n\nObject[] arr = { 12836, \"シャオハ\" };\nint hashTup = Arrays.hashCode(arr);\n// 配列 [12836, シャオハ] のハッシュ値は 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// ノードオブジェクト utils.ListNode@7dc5e7b4 のハッシュ値は 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// 整数 3 のハッシュ値は 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// 真理値 true のハッシュ値は 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// 小数 3.14159 のハッシュ値は -1340954729;\n\nstring str = \"Hello アルゴリズム\";\nint hashStr = str.GetHashCode();\n// 文字列「Hello アルゴリズム」のハッシュ値は -586107568;\n\nobject[] arr = [12836, \"シャオハ\"];\nint hashTup = arr.GetHashCode();\n// 配列 [12836, シャオハ] のハッシュ値は 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// ノードオブジェクト 0 のハッシュ値は 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// 整数 3 のハッシュ値は 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// 真理値 true のハッシュ値は -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// 小数 3.14159 のハッシュ値は -2465384235396674631\n\nlet str = \"Hello アルゴリズム\"\nlet hashStr = str.hashValue\n// 文字列「Hello アルゴリズム」のハッシュ値は -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"シャオハ\")]\nlet hashTup = arr.hashValue\n// 配列 [AnyHashable(12836), AnyHashable(\"シャオハ\")] のハッシュ値は -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// ノードオブジェクト utils.ListNode のハッシュ値は -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.ts<pre><code>// TypeScript は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// 整数 3 のハッシュ値は 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// 真理値 true のハッシュ値は 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// 小数 3.14159 のハッシュ値は 2570631074981783\n\nString str = \"Hello アルゴリズム\";\nint hashStr = str.hashCode;\n// 文字列「Hello アルゴリズム」のハッシュ値は 468167534\n\nList arr = [12836, \"シャオハ\"];\nint hashArr = arr.hashCode;\n// 配列 [12836, シャオハ] のハッシュ値は 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// ノードオブジェクト Instance of 'ListNode' のハッシュ値は 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// 整数 3 のハッシュ値は 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// 真理値 true のハッシュ値は 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// 小数 3.14159 のハッシュ値は 2566941990314602357\n\nlet str = \"Hello アルゴリズム\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// 文字列「Hello アルゴリズム」のハッシュ値は 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"シャオハ\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// タプル (12836, \"シャオハ\") のハッシュ値は 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// ノードオブジェクト RefCell { value: ListNode { val: 42, next: None } } のハッシュ値は15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C は組み込みの hash code 関数を提供していない\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// 整数 3 のハッシュ値は 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// 真理値 true のハッシュ値は 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// 小数 3.14159 のハッシュ値は -1340954729\n\nval str = \"Hello アルゴリズム\"\nval hashStr = str.hashCode()\n// 文字列「Hello アルゴリズム」のハッシュ値は -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"シャオハ\")\nval hashTup = arr.hashCode()\n// 配列 [12836, シャオハ] のハッシュ値は 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// ノードオブジェクト utils.ListNode@1d81eb93 のハッシュ値は 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# 整数 3 のハッシュ値は -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# 真理値 true のハッシュ値は -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# 小数 3.14159 のハッシュ値は -1479186995943067893\n\nstr = \"Hello アルゴリズム\"\nhash_str = str.hash\n# 文字列「Hello アルゴリズム」のハッシュ値は -4075943250025831763\n\ntup = [12836, 'シャオハ']\nhash_tup = tup.hash\n# タプル (12836, 'シャオハ') のハッシュ値は 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# ノードオブジェクト #&lt;ListNode:0x000078133140ab70&gt; のハッシュ値は 4302940560806366381\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%E6%95%B4%E6%95%B0%203%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%E5%B8%83%E5%B0%94%E9%87%8F%20True%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%E5%B0%8F%E6%95%B0%203.14159%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20%E7%AE%97%E6%B3%95%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%E5%AD%97%E7%AC%A6%E4%B8%B2%E2%80%9CHello%20%E7%AE%97%E6%B3%95%E2%80%9D%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836,%20%22%E5%B0%8F%E5%93%88%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%E5%85%83%E7%BB%84%20%2812836,%20'%E5%B0%8F%E5%93%88'%29%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%AF%B9%E8%B1%A1%20%3CListNode%20object%20at%200x1058fd810%3E%20%E7%9A%84%E5%93%88%E5%B8%8C%E5%80%BC%E4%B8%BA%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>多くのプログラミング言語では、不変オブジェクトだけがハッシュテーブルの <code>key</code> として使えます。仮にリスト（動的配列）を <code>key</code> とすると、その内容が変化したときにハッシュ値も変わってしまうため、もとの <code>value</code> をハッシュテーブルから検索できなくなります。</p> <p>カスタムオブジェクト（たとえば連結リストのノード）のメンバ変数は可変ですが、それでもハッシュ可能です。これは、オブジェクトのハッシュ値が通常はメモリアドレスに基づいて生成されるためです。オブジェクトの内容が変化しても、メモリアドレスが変わらなければ、ハッシュ値も変わりません。</p> <p>注意深い人なら、異なるコンソールでプログラムを実行したときに、出力されるハッシュ値が異なることに気づくかもしれません。これは、Python インタプリタが起動のたびに文字列ハッシュ関数へランダムな salt 値を追加しているためです。この方法によって HashDoS 攻撃を効果的に防ぎ、ハッシュアルゴリズムの安全性を高めています。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.3 &nbsp; ハッシュアルゴリズム"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   ハッシュ衝突","text":"<p>前節で述べたように、**通常、ハッシュ関数の入力空間は出力空間よりもはるかに大きい**ため、理論上ハッシュ衝突は避けられません。例えば、入力空間がすべての整数で、出力空間が配列の容量サイズである場合、必然的に複数の整数が同じバケットインデックスに写像されます。</p> <p>ハッシュ衝突は検索結果の誤りを招き、ハッシュテーブルの利用可能性に深刻な影響を与えます。この問題を解決するために、ハッシュ衝突が発生するたびにハッシュテーブルを拡張し、衝突が消えるまで続けることが考えられます。この方法は単純で効果的ですが、効率が低すぎます。なぜなら、ハッシュテーブルの拡張には大量のデータ移動とハッシュ値の計算が必要だからです。効率を高めるために、次の戦略を採用できます。</p> <ol> <li>ハッシュテーブルのデータ構造を改良し、ハッシュ衝突が発生してもハッシュテーブルが正常に動作できるようにする。</li> <li>必要な場合、すなわちハッシュ衝突が比較的深刻なときにのみ、拡張操作を実行する。</li> </ol> <p>ハッシュテーブルの構造改善方法には、主に「チェイン法」と「オープンアドレッシング」があります。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   チェイン法","text":"<p>元のハッシュテーブルでは、各バケットには 1 つのキーと値のペアしか格納できません。チェイン法（separate chaining）では、単一要素を連結リストに置き換え、キーと値のペアを連結リストのノードとして扱い、衝突したすべてのキーと値のペアを同じ連結リストに格納します。下図はチェイン法によるハッシュテーブルの例を示しています。</p> <p></p> <p> 図 6-5   チェイン法ハッシュテーブル </p> <p>チェイン法で実装されたハッシュテーブルでは、操作方法が次のように変わります。</p> <ul> <li>要素の検索：入力 <code>key</code> をハッシュ関数に通してバケットインデックスを得ると、連結リストの先頭ノードにアクセスできます。その後、連結リストを走査して <code>key</code> を比較し、目的のキーと値のペアを探します。</li> <li>要素の追加：まずハッシュ関数で連結リストの先頭ノードにアクセスし、その後ノード（キーと値のペア）を連結リストに追加します。</li> <li>要素の削除：ハッシュ関数の結果に基づいて連結リストの先頭にアクセスし、続いて連結リストを走査して対象ノードを探し、削除します。</li> </ul> <p>チェイン法には次の制約があります。</p> <ul> <li>使用メモリの増加：連結リストにはノードポインタが含まれるため、配列よりも多くのメモリを消費します。</li> <li>検索効率の低下：対応する要素を見つけるために連結リストを線形走査する必要があるためです。</li> </ul> <p>以下のコードはチェイン法ハッシュテーブルの簡単な実装を示しています。注意すべき点は 2 つあります。</p> <ul> <li>連結リストの代わりにリスト（動的配列）を使って、コードを簡潔にしています。この設定では、ハッシュテーブル（配列）は複数のバケットを含み、各バケットは 1 つのリストです。</li> <li>以下の実装にはハッシュテーブルの拡張メソッドが含まれています。負荷率が \\(\\frac{2}{3}\\) を超えたとき、ハッシュテーブルを元の \\(2\\) 倍に拡張します。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"チェイン法ハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self.size = 0  # キーと値のペア数\n        self.capacity = 4  # ハッシュテーブル容量\n        self.load_thres = 2.0 / 3.0  # リサイズを発動する負荷率のしきい値\n        self.extend_ratio = 2  # 拡張倍率\n        self.buckets = [[] for _ in range(self.capacity)]  # バケット配列\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負荷率\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"検索操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査し、key が見つかれば対応する val を返す\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # key が見つからない場合は None を返す\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"追加操作\"\"\"\n        # 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # その key が存在しなければ、キーと値のペアを末尾に追加\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # バケットを走査してキーと値のペアを削除\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"ハッシュテーブルを拡張\"\"\"\n        # 元のハッシュテーブルを一時保存\n        buckets = self.buckets\n        # リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n  private:\n    int size;                       // キーと値のペア数\n    int capacity;                   // ハッシュテーブル容量\n    double loadThres;               // リサイズを発動する負荷率のしきい値\n    int extendRatio;                // 拡張倍率\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // バケット配列\n\n  public:\n    /* コンストラクタ */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* デストラクタメソッド */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // メモリを解放する\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // key が見つからない場合は空文字列を返す\n        return \"\";\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // そこからキーと値の組を削除する\n                delete tmp;                       // メモリを解放する\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // メモリを解放する\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    int size; // キーと値のペア数\n    int capacity; // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio; // 拡張倍率\n    List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n    /* コンストラクタ */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 検索操作 */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    void put(int key, String val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // バケットを走査してキーと値のペアを削除\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    int size; // キーと値のペア数\n    int capacity; // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio; // 拡張倍率\n    List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n    /* コンストラクタ */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // バケットを走査し、key が見つかれば対応する val を返す\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // バケットを走査してキーと値のペアを削除\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void Extend() {\n        // 元のハッシュテーブルを一時保存\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* チェイン法ハッシュテーブル */\ntype hashMapChaining struct {\n    size        int      // キーと値のペア数\n    capacity    int      // ハッシュテーブル容量\n    loadThres   float64  // リサイズを発動する負荷率のしきい値\n    extendRatio int      // 拡張倍率\n    buckets     [][]pair // バケット配列\n}\n\n/* コンストラクタ */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* ハッシュ関数 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* 負荷率 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* 検索操作 */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // バケットを走査し、key が見つかれば対応する val を返す\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // key が見つからない場合は空文字列を返す\n    return \"\"\n}\n\n/* 追加操作 */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // その key が存在しなければ、キーと値のペアを末尾に追加\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* 削除操作 */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // バケットを走査してキーと値のペアを削除\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // スライスから削除する\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nfunc (m *hashMapChaining) extend() {\n    // 元のハッシュテーブルを一時保存\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // リサイズ後の新しいハッシュテーブルを初期化\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* ハッシュテーブルを出力 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    var loadThres: Double // リサイズを発動する負荷率のしきい値\n    var extendRatio: Int // 拡張倍率\n    var buckets: [[Pair]] // バケット配列\n\n    /* コンストラクタ */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* ハッシュ関数 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負荷率 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // `key` が見つからなければ `nil` を返す\n        return nil\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // バケットを走査してキーと値のペアを削除\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    func extend() {\n        // 元のハッシュテーブルを一時保存\n        let bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    #size; // キーと値のペア数\n    #capacity; // ハッシュテーブル容量\n    #loadThres; // リサイズを発動する負荷率のしきい値\n    #extendRatio; // 拡張倍率\n    #buckets; // バケット配列\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key, val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend() {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    #size: number; // キーと値のペア数\n    #capacity: number; // ハッシュテーブル容量\n    #loadThres: number; // リサイズを発動する負荷率のしきい値\n    #extendRatio: number; // 拡張倍率\n    #buckets: Pair[][]; // バケット配列\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* 検索操作 */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // key が見つからない場合は null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key: number, val: string): void {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // バケットを走査してキーと値のペアを削除\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend(): void {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n  late int size; // キーと値のペア数\n  late int capacity; // ハッシュテーブル容量\n  late double loadThres; // リサイズを発動する負荷率のしきい値\n  late int extendRatio; // 拡張倍率\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // バケット配列\n\n  /* コンストラクタ */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* ハッシュ関数 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* 負荷率 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査し、key が見つかれば対応する val を返す\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // key が見つからない場合は null を返す\n    return null;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // その key が存在しなければ、キーと値のペアを末尾に追加\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // バケットを走査してキーと値のペアを削除\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* ハッシュテーブルを拡張 */\n  void extend() {\n    // 元のハッシュテーブルを一時保存\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* チェイン法ハッシュテーブル */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* コンストラクタ */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* 負荷率 */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* 削除操作 */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // バケットを走査してキーと値のペアを削除\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // key が見つからない場合は None を返す\n        None\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fn extend(&amp;mut self) {\n        // 元のハッシュテーブルを一時保存\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* 追加操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* 検索操作 */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // key が見つからない場合は None を返す\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* 連結リストノード */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* チェイン法ハッシュテーブル */\ntypedef struct {\n    int size;         // キーと値のペア数\n    int capacity;     // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio;  // 拡張倍率\n    Node **buckets;   // バケット配列\n} HashMapChaining;\n\n/* コンストラクタ */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* デストラクタ */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* ハッシュ関数 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負荷率 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 検索操作 */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // バケットを走査し、key が見つかれば対応する val を返す\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // key が見つからない場合は空文字列を返す\n}\n\n/* 追加操作 */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // 指定した `key` に遭遇したら、対応する `val` を更新して返す\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // 該当する `key` がなければ、キーと値のペアを連結リストの先頭に追加する\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* ハッシュテーブルを拡張 */\nvoid extend(HashMapChaining *hashMap) {\n    // 元のハッシュテーブルを一時保存\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // メモリを解放する\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* 削除操作 */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // そこからキーと値の組を削除する\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // メモリを解放する\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* チェイン法ハッシュテーブル */\nclass HashMapChaining {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    val loadThres: Double // リサイズを発動する負荷率のしきい値\n    val extendRatio: Int // 拡張倍率\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // バケット配列\n\n    /* コンストラクタ */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負荷率 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査し、key が見つかれば対応する val を返す\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // key が見つからない場合は null を返す\n        return null\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // その key が存在しなければ、キーと値のペアを末尾に追加\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // バケットを走査してキーと値のペアを削除\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fun extend() {\n        // 元のハッシュテーブルを一時保存\n        val bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        // mutablelist には固定サイズがない\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### キーアドレス法ハッシュテーブル ###\nclass HashMapChaining\n  ### コンストラクタ ###\n  def initialize\n    @size = 0 # キーと値のペア数\n    @capacity = 4 # ハッシュテーブル容量\n    @load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値\n    @extend_ratio = 2 # 拡張倍率\n    @buckets = Array.new(@capacity) { [] } # バケット配列\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負荷率 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査し、key が見つかれば対応する val を返す\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # `key` が見つからなければ `nil` を返す\n    nil\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    # 負荷率がしきい値を超えたら、リサイズを実行\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査し、指定した key が見つかれば対応する val を更新して返す\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # その key が存在しなければ、キーと値のペアを末尾に追加\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # バケットを走査してキーと値のペアを削除\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### ハッシュテーブルを拡張 ###\n  def extend\n    # 元のハッシュテーブルを一時保存\n    buckets = @buckets\n    # リサイズ後の新しいハッシュテーブルを初期化\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>注意すべきなのは、連結リストが長い場合、検索効率 \\(O(n)\\) は非常に低いことです。このとき、連結リストを「AVL 木」または「赤黒木」に変換することで、検索操作の時間計算量を \\(O(\\log n)\\) に最適化できます。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   オープンアドレッシング","text":"<p>オープンアドレッシング（open addressing）では追加のデータ構造を導入せず、「複数回の探索」によってハッシュ衝突を処理します。探索方法には主に線形探索、二次探索、多重ハッシュなどがあります。</p> <p>以下では線形探索を例に、オープンアドレッシングハッシュテーブルの動作の仕組みを説明します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   線形探索","text":"<p>線形探索では、固定ステップ長の線形探索によって探索を行います。その操作方法は通常のハッシュテーブルとは異なります。</p> <ul> <li>要素の挿入：ハッシュ関数によってバケットインデックスを計算し、バケット内にすでに要素がある場合は、衝突位置から後方へ線形に走査し（ステップ長は通常 \\(1\\) ）、空のバケットが見つかるまで進み、その中に要素を挿入します。</li> <li>要素の検索：ハッシュ衝突が見つかった場合は、同じステップ長で後方へ線形走査を行い、対応する要素が見つかるまで続け、 <code>value</code> を返します。空のバケットに遭遇した場合は、対象要素がハッシュテーブル内に存在しないことを意味するため、 <code>None</code> を返します。</li> </ul> <p>下図はオープンアドレッシング（線形探索）ハッシュテーブルにおけるキーと値のペアの分布を示しています。このハッシュ関数では、末尾 2 桁が同じ <code>key</code> はすべて同じバケットに写像されます。線形探索によって、それらはそのバケットとその後続のバケットに順に格納されます。</p> <p></p> <p> 図 6-6   オープンアドレッシング（線形探索）ハッシュテーブルにおけるキーと値のペアの分布 </p> <p>しかし、**線形探索では「クラスタリング現象」が起こりやすい**です。具体的には、配列内で連続して占有された位置が長いほど、それらの連続位置でハッシュ衝突が発生する可能性が高くなり、さらにその位置の集積成長を促して悪循環を生み、最終的には追加・削除・検索・更新操作の効率低下を招きます。</p> <p>注意すべきなのは、**オープンアドレッシングハッシュテーブルでは要素を直接削除できない**ことです。これは、要素を削除すると配列内に空バケット <code>None</code> が生じ、要素を検索するときに線形探索がその空バケットに到達した時点で返ってしまうため、その空バケットより後ろの要素には二度とアクセスできなくなるからです。結果として、プログラムがそれらの要素を存在しないと誤判定する可能性があります。下図のとおりです。</p> <p></p> <p> 図 6-7   オープンアドレッシングで要素を削除したことによる検索問題 </p> <p>この問題を解決するために、遅延削除（lazy deletion）の仕組みを採用できます。これは要素をハッシュテーブルから直接取り除かず、代わりに定数 <code>TOMBSTONE</code> を使ってこのバケットをマークします。この仕組みでは、<code>None</code> と <code>TOMBSTONE</code> はどちらも空バケットを表し、どちらにもキーと値のペアを配置できます。ただし異なるのは、線形探索が <code>TOMBSTONE</code> に到達した場合は、その先にキーと値のペアが存在する可能性があるため、探索を続けるべきだという点です。</p> <p>しかし、遅延削除はハッシュテーブルの性能劣化を加速させる可能性があります。これは、削除操作のたびに削除マークが 1 つ生成され、<code>TOMBSTONE</code> が増えるにつれて探索時間も増加するためです。線形探索では、対象要素を見つけるまでに複数の <code>TOMBSTONE</code> を飛び越える必要があるかもしれません。</p> <p>そのため、線形探索では、遭遇した最初の <code>TOMBSTONE</code> のインデックスを記録し、見つかった対象要素とその <code>TOMBSTONE</code> を交換することを考えます。こうする利点は、要素を検索または追加するたびに、要素が理想位置（探索開始点）により近いバケットへ移動し、検索効率が向上することです。</p> <p>以下のコードは、遅延削除を含むオープンアドレッシング（線形探索）ハッシュテーブルを実装したものです。ハッシュテーブルの空間をより十分に活用するために、ハッシュテーブルを「環状配列」とみなし、配列末尾を越えたら先頭に戻って探索を続けます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"オープンアドレス法ハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self.size = 0  # キーと値のペア数\n        self.capacity = 4  # ハッシュテーブル容量\n        self.load_thres = 2.0 / 3.0  # リサイズを発動する負荷率のしきい値\n        self.extend_ratio = 2  # 拡張倍率\n        self.buckets: list[Pair | None] = [None] * self.capacity  # バケット配列\n        self.TOMBSTONE = Pair(-1, \"-1\")  # 削除済みマーク\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負荷率\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"key に対応するバケットインデックスを探す\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # 線形プロービングを行い、空バケットに達したら終了\n        while self.buckets[index] is not None:\n            # key が見つかったら、対応するバケットのインデックスを返す\n            if self.buckets[index].key == key:\n                # 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # 移動後のバケットインデックスを返す\n                return index  # バケットのインデックスを返す\n            # 最初に見つかった削除マークを記録\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % self.capacity\n        # key が存在しない場合は追加位置のインデックスを返す\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"検索操作\"\"\"\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、対応する val を返す\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # キーと値のペアが存在しない場合は `None` を返す\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"追加操作\"\"\"\n        # 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、val を上書きして返す\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # キーと値の組が存在しない場合は、その組を追加する\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        # key に対応するバケットインデックスを探す\n        index = self.find_bucket(key)\n        # キーと値の組が見つかったら、削除マーカーで上書きする\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"ハッシュテーブルを拡張\"\"\"\n        # 元のハッシュテーブルを一時保存\n        buckets_tmp = self.buckets\n        # リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // キーと値のペア数\n    int capacity = 4;                     // ハッシュテーブル容量\n    const double loadThres = 2.0 / 3.0;     // リサイズを発動する負荷率のしきい値\n    const int extendRatio = 2;            // 拡張倍率\n    vector&lt;Pair *&gt; buckets;               // バケット配列\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // 削除済みマーク\n\n  public:\n    /* コンストラクタ */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* デストラクタメソッド */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != nullptr) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index]-&gt;key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // キーと値の組が存在しない場合は空文字列を返す\n        return \"\";\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void extend() {\n        // 元のハッシュテーブルを一時保存\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private int size; // キーと値のペア数\n    private int capacity = 4; // ハッシュテーブル容量\n    private final double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n    private final int extendRatio = 2; // 拡張倍率\n    private Pair[] buckets; // バケット配列\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // 削除済みマーク\n\n    /* コンストラクタ */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* ハッシュ関数 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index].key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    public String get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void put(int key, String val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    public void remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    private void extend() {\n        // 元のハッシュテーブルを一時保存\n        Pair[] bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    int size; // キーと値のペア数\n    int capacity = 4; // ハッシュテーブル容量\n    double loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n    int extendRatio = 2; // 拡張倍率\n    Pair[] buckets; // バケット配列\n    Pair TOMBSTONE = new(-1, \"-1\"); // 削除済みマーク\n\n    /* コンストラクタ */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負荷率 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index].key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        // key に対応するバケットインデックスを探す\n        int index = FindBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    void Extend() {\n        // 元のハッシュテーブルを一時保存\n        Pair[] bucketsTmp = buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* オープンアドレス法ハッシュテーブル */\ntype hashMapOpenAddressing struct {\n    size        int     // キーと値のペア数\n    capacity    int     // ハッシュテーブル容量\n    loadThres   float64 // リサイズを発動する負荷率のしきい値\n    extendRatio int     // 拡張倍率\n    buckets     []*pair // バケット配列\n    TOMBSTONE   *pair   // 削除済みマーク\n}\n\n/* コンストラクタ */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* ハッシュ関数 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // キーに基づいてハッシュ値を計算\n}\n\n/* 負荷率 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // 現在の負荷率を計算\n}\n\n/* key に対応するバケットインデックスを探す */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // 初期インデックスを取得\n    firstTombstone := -1     // 最初に遭遇した `TOMBSTONE` の位置を記録する\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // 移動後のバケットインデックスを返す\n            }\n            return index // 見つかったインデックスを返す\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // 最初に遭遇した削除マークの位置を記録する\n        }\n        index = (index + 1) % h.capacity // 線形探索を行い、末尾を越えたら先頭に戻る\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* 検索操作 */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // キーと値の組が見つかったら、対応する val を返す\n    }\n    return \"\" // キーと値のペアが存在しない場合は `\"\"` を返す\n}\n\n/* 追加操作 */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // 負荷率がしきい値を超えたら、リサイズを実行\n    }\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // キーと値の組が存在しない場合は、その組を追加する\n        h.size++\n    } else {\n        h.buckets[index].val = val // キーと値のペアが見つかった場合は、`val` を上書きする\n    }\n}\n\n/* 削除操作 */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // key に対応するバケットインデックスを探す\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // キーと値の組が見つかったら、削除マーカーで上書きする\n        h.size--\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // 元のハッシュテーブルを一時保存\n    h.capacity *= h.extendRatio           // 容量を更新\n    h.buckets = make([]*pair, h.capacity) // リサイズ後の新しいハッシュテーブルを初期化\n    h.size = 0                            // サイズをリセットする\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* ハッシュテーブルを出力 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    var size: Int // キーと値のペア数\n    var capacity: Int // ハッシュテーブル容量\n    var loadThres: Double // リサイズを発動する負荷率のしきい値\n    var extendRatio: Int // 拡張倍率\n    var buckets: [Pair?] // バケット配列\n    var TOMBSTONE: Pair // 削除済みマーク\n\n    /* コンストラクタ */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* ハッシュ関数 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負荷率 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // 線形プロービングを行い、空バケットに達したら終了\n        while buckets[index] != nil {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if buckets[index]!.key == key {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 移動後のバケットインデックスを返す\n                }\n                return index // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、対応する val を返す\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // キーと値の組が存在しなければ null を返す\n        return nil\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、val を上書きして返す\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        // key に対応するバケットインデックスを探す\n        let index = findBucket(key: key)\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    func extend() {\n        // 元のハッシュテーブルを一時保存\n        let bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    #size; // キーと値のペア数\n    #capacity; // ハッシュテーブル容量\n    #loadThres; // リサイズを発動する負荷率のしきい値\n    #extendRatio; // 拡張倍率\n    #buckets; // バケット配列\n    #TOMBSTONE; // 削除済みマーク\n\n    /* コンストラクタ */\n    constructor() {\n        this.#size = 0; // キーと値のペア数\n        this.#capacity = 4; // ハッシュテーブル容量\n        this.#loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n        this.#extendRatio = 2; // 拡張倍率\n        this.#buckets = Array(this.#capacity).fill(null); // バケット配列\n        this.#TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負荷率 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (this.#buckets[index] !== null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (this.#buckets[index].key === key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % this.#capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key, val) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* 削除操作 */\n    remove(key) {\n        // key に対応するバケットインデックスを探す\n        const index = this.#findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    #extend() {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.#buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private size: number; // キーと値のペア数\n    private capacity: number; // ハッシュテーブル容量\n    private loadThres: number; // リサイズを発動する負荷率のしきい値\n    private extendRatio: number; // 拡張倍率\n    private buckets: Array&lt;Pair | null&gt;; // バケット配列\n    private TOMBSTONE: Pair; // 削除済みマーク\n\n    /* コンストラクタ */\n    constructor() {\n        this.size = 0; // キーと値のペア数\n        this.capacity = 4; // ハッシュテーブル容量\n        this.loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n        this.extendRatio = 2; // 拡張倍率\n        this.buckets = Array(this.capacity).fill(null); // バケット配列\n        this.TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク\n    }\n\n    /* ハッシュ関数 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* 負荷率 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (this.buckets[index] !== null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (this.buckets[index]!.key === key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % this.capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 検索操作 */\n    get(key: number): string | null {\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null;\n    }\n\n    /* 追加操作 */\n    put(key: number, val: string): void {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* 削除操作 */\n    remove(key: number): void {\n        // key に対応するバケットインデックスを探す\n        const index = this.findBucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    private extend(): void {\n        // 元のハッシュテーブルを一時保存\n        const bucketsTmp = this.buckets;\n        // リサイズ後の新しいハッシュテーブルを初期化\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n  late int _size; // キーと値のペア数\n  int _capacity = 4; // ハッシュテーブル容量\n  double _loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値\n  int _extendRatio = 2; // 拡張倍率\n  late List&lt;Pair?&gt; _buckets; // バケット配列\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // 削除済みマーク\n\n  /* コンストラクタ */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* ハッシュ関数 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* 負荷率 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* key に対応するバケットインデックスを探す */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // 線形プロービングを行い、空バケットに達したら終了\n    while (_buckets[index] != null) {\n      // key が見つかったら、対応するバケットのインデックスを返す\n      if (_buckets[index]!.key == key) {\n        // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // 移動後のバケットインデックスを返す\n        }\n        return index; // バケットのインデックスを返す\n      }\n      // 最初に見つかった削除マークを記録\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n      index = (index + 1) % _capacity;\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、対応する val を返す\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // キーと値の組が存在しなければ null を返す\n    return null;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、val を上書きして返す\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // キーと値の組が存在しない場合は、その組を追加する\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(key);\n    // キーと値の組が見つかったら、削除マーカーで上書きする\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* ハッシュテーブルを拡張 */\n  void extend() {\n    // 元のハッシュテーブルを一時保存\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* オープンアドレス法ハッシュテーブル */\nstruct HashMapOpenAddressing {\n    size: usize,                // キーと値のペア数\n    capacity: usize,            // ハッシュテーブル容量\n    load_thres: f64,            // リサイズを発動する負荷率のしきい値\n    extend_ratio: usize,        // 拡張倍率\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // バケット配列\n    TOMBSTONE: Option&lt;Pair&gt;,    // 削除済みマーク\n}\n\nimpl HashMapOpenAddressing {\n    /* コンストラクタ */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* 負荷率 */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // 線形プロービングを行い、空バケットに達したら終了\n        while self.buckets[index].is_some() {\n            // `key` に遭遇したら、対応するバケットのインデックスを返す\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // 以前に削除マークに遭遇していた場合は、キーと値のペアをそのインデックスへ移動する\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // 移動後のバケットインデックスを返す\n                }\n                return index; // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % self.capacity;\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* 検索操作 */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、対応する val を返す\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // キーと値の組が存在しなければ null を返す\n        None\n    }\n\n    /* 追加操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、val を上書きして返す\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* 削除操作 */\n    fn remove(&amp;mut self, key: i32) {\n        // key に対応するバケットインデックスを探す\n        let index = self.find_bucket(key);\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fn extend(&amp;mut self) {\n        // 元のハッシュテーブルを一時保存\n        let buckets_tmp = self.buckets.clone();\n        // リサイズ後の新しいハッシュテーブルを初期化\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* ハッシュテーブルを出力 */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* オープンアドレス法ハッシュテーブル */\ntypedef struct {\n    int size;         // キーと値のペア数\n    int capacity;     // ハッシュテーブル容量\n    double loadThres; // リサイズを発動する負荷率のしきい値\n    int extendRatio;  // 拡張倍率\n    Pair **buckets;   // バケット配列\n    Pair *TOMBSTONE;  // 削除済みマーク\n} HashMapOpenAddressing;\n\n/* コンストラクタ */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* デストラクタ */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* ハッシュ関数 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負荷率 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* key に対応するバケットインデックスを探す */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // 線形プロービングを行い、空バケットに達したら終了\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // key が見つかったら、対応するバケットのインデックスを返す\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // 移動後のバケットインデックスを返す\n            }\n            return index; // バケットのインデックスを返す\n        }\n        // 最初に見つかった削除マークを記録\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // key が存在しない場合は追加位置のインデックスを返す\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* 検索操作 */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、対応する val を返す\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // キーと値の組が存在しない場合は空文字列を返す\n    return \"\";\n}\n\n/* 追加操作 */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // 負荷率がしきい値を超えたら、リサイズを実行\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、val を上書きして返す\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // キーと値の組が存在しない場合は、その組を追加する\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* 削除操作 */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // key に対応するバケットインデックスを探す\n    int index = findBucket(hashMap, key);\n    // キーと値の組が見つかったら、削除マーカーで上書きする\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* ハッシュテーブルを拡張 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // 元のハッシュテーブルを一時保存\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // リサイズ後の新しいハッシュテーブルを初期化\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* オープンアドレス法ハッシュテーブル */\nclass HashMapOpenAddressing {\n    private var size: Int               // キーと値のペア数\n    private var capacity: Int           // ハッシュテーブル容量\n    private val loadThres: Double       // リサイズを発動する負荷率のしきい値\n    private val extendRatio: Int        // 拡張倍率\n    private var buckets: Array&lt;Pair?&gt;   // バケット配列\n    private val TOMBSTONE: Pair         // 削除済みマーク\n\n    /* コンストラクタ */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負荷率 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* key に対応するバケットインデックスを探す */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // 線形プロービングを行い、空バケットに達したら終了\n        while (buckets[index] != null) {\n            // key が見つかったら、対応するバケットのインデックスを返す\n            if (buckets[index]?.key == key) {\n                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 移動後のバケットインデックスを返す\n                }\n                return index // バケットのインデックスを返す\n            }\n            // 最初に見つかった削除マークを記録\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n            index = (index + 1) % capacity\n        }\n        // key が存在しない場合は追加位置のインデックスを返す\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、対応する val を返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // キーと値の組が存在しなければ null を返す\n        return null\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        // 負荷率がしきい値を超えたら、リサイズを実行\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、val を上書きして返す\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // キーと値の組が存在しない場合は、その組を追加する\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        // key に対応するバケットインデックスを探す\n        val index = findBucket(key)\n        // キーと値の組が見つかったら、削除マーカーで上書きする\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* ハッシュテーブルを拡張 */\n    fun extend() {\n        // 元のハッシュテーブルを一時保存\n        val bucketsTmp = buckets\n        // リサイズ後の新しいハッシュテーブルを初期化\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### オープンアドレス法ハッシュテーブル ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # 削除済みマーク\n\n  ### コンストラクタ ###\n  def initialize\n    @size = 0 # キーと値のペア数\n    @capacity = 4 # ハッシュテーブル容量\n    @load_thres = 2.0 / 3.0 # リサイズを発動する負荷率のしきい値\n    @extend_ratio = 2 # 拡張倍率\n    @buckets = Array.new(@capacity) # バケット配列\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負荷率 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### key に対応するバケットインデックスを検索 ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # 線形プロービングを行い、空バケットに達したら終了\n    while !@buckets[index].nil?\n      # key が見つかったら、対応するバケットのインデックスを返す\n      if @buckets[index].key == key\n        # 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # 移動後のバケットインデックスを返す\n        end\n        return index # バケットのインデックスを返す\n      end\n      # 最初に見つかった削除マークを記録\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # バケットのインデックスを計算し、末尾を越えたら先頭に戻る\n      index = (index + 1) % @capacity\n    end\n    # key が存在しない場合は追加位置のインデックスを返す\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値の組が見つかったら、対応する val を返す\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # キーと値のペアが存在しない場合は `nil` を返す\n    nil\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    # 負荷率がしきい値を超えたら、リサイズを実行\n    extend if load_factor &gt; @load_thres\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値のペアが見つかった場合は、`val` を上書きして返す\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # キーと値の組が存在しない場合は、その組を追加する\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    # key に対応するバケットインデックスを探す\n    index = find_bucket(key)\n    # キーと値の組が見つかったら、削除マーカーで上書きする\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### ハッシュテーブルを拡張 ###\n  def extend\n    # 元のハッシュテーブルを一時保存\n    buckets_tmp = @buckets\n    # リサイズ後の新しいハッシュテーブルを初期化\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   二次探索","text":"<p>二次探索は線形探索に似ており、オープンアドレッシングの一般的な戦略の 1 つです。衝突が発生したとき、二次探索では単純に固定歩数を飛ばすのではなく、「探索回数の二乗」に相当する歩数、すなわち \\(1, 4, 9, \\dots\\) 歩を飛ばします。</p> <p>二次探索には主に次の利点があります。</p> <ul> <li>二次探索は、探索回数の二乗の距離を飛ばすことで、線形探索のクラスタリング効果を緩和しようとします。</li> <li>二次探索はより大きな距離を飛ばして空き位置を探すため、データ分布がより均一になるのに役立ちます。</li> </ul> <p>しかし、二次探索は完璧ではありません。</p> <ul> <li>依然としてクラスタリング現象は存在し、ある位置が他の位置より占有されやすいことがあります。</li> <li>二乗の増加により、二次探索はハッシュテーブル全体を探索できない可能性があります。これは、ハッシュテーブルに空バケットがあっても、二次探索ではそこに到達できないことがあることを意味します。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   多重ハッシュ","text":"<p>その名のとおり、多重ハッシュ法では複数のハッシュ関数 \\(f_1(x)\\)、\\(f_2(x)\\)、\\(f_3(x)\\)、\\(\\dots\\) を使って探索を行います。</p> <ul> <li>要素の挿入：ハッシュ関数 \\(f_1(x)\\) で衝突が発生した場合は、\\(f_2(x)\\) を試し、以下同様に、空き位置が見つかるまで続けてから要素を挿入します。</li> <li>要素の検索：同じハッシュ関数の順序で探索し、対象要素が見つかった時点で返します。空き位置に遭遇するか、すべてのハッシュ関数を試しても見つからない場合は、ハッシュテーブル内にその要素は存在しないため、 <code>None</code> を返します。</li> </ul> <p>線形探索と比べると、多重ハッシュ法はクラスタリングを起こしにくい一方で、複数のハッシュ関数により追加の計算量が発生します。</p> <p>Tip</p> <p>注意してください。オープンアドレッシング（線形探索、二次探索、多重ハッシュ）のハッシュテーブルには、いずれも「要素を直接削除できない」という問題があります。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   プログラミング言語の選択","text":"<p>各種プログラミング言語は異なるハッシュテーブル実装戦略を採用しています。以下にいくつか例を挙げます。</p> <ul> <li>Python はオープンアドレッシングを採用しています。辞書 <code>dict</code> は疑似乱数を用いて探索します。</li> <li>Java はチェイン法を採用しています。JDK 1.8 以降、<code>HashMap</code> 内の配列長が 64 に達し、かつ連結リスト長が 8 に達すると、連結リストは検索性能を高めるため赤黒木に変換されます。</li> <li>Go はチェイン法を採用しています。Go では各バケットに最大 8 個のキーと値のペアを格納でき、容量を超えるとオーバーフローバケットを連結します。オーバーフローバケットが多すぎる場合は、性能を確保するために特殊な等量拡張操作を実行します。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.2 &nbsp; ハッシュ衝突"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   ハッシュテーブル","text":"<p>ハッシュテーブル（hash table）は、散列表とも呼ばれ、キー <code>key</code> と値 <code>value</code> の対応関係を構築することで、高効率な要素検索を実現します。具体的には、ハッシュテーブルにキー <code>key</code> を入力すると、対応する値 <code>value</code> を \\(O(1)\\) 時間で取得できます。</p> <p>以下の図に示すように、\\(n\\) 人の学生がいるとし、各学生は「名前」と「学籍番号」の 2 つの情報を持っています。もし「学籍番号を入力すると対応する名前を返す」という検索機能を実現したいなら、下図のようなハッシュテーブルを用いることができます。</p> <p></p> <p> 図 6-1   ハッシュテーブルの抽象表現 </p> <p>ハッシュテーブルのほかに、配列や連結リストでも検索機能を実現できます。それらの効率比較を次の表に示します。</p> <ul> <li>要素の追加：要素を配列（連結リスト）の末尾に追加するだけでよく、\\(O(1)\\) 時間です。</li> <li>要素の検索：配列（連結リスト）は無秩序なので、すべての要素を走査する必要があり、\\(O(n)\\) 時間かかります。</li> <li>要素の削除：先に要素を検索してから配列（連結リスト）から削除する必要があり、\\(O(n)\\) 時間かかります。</li> </ul> <p> 表 6-1   要素検索効率の比較 </p> 配列 連結リスト ハッシュテーブル 要素の検索 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) 要素の追加 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 要素の削除 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>以上から分かるように、ハッシュテーブルにおける追加・削除・検索・更新の時間計算量はいずれも \\(O(1)\\) であり、非常に高効率です。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#611","level":2,"title":"6.1.1   ハッシュテーブルの基本操作","text":"<p>ハッシュテーブルの一般的な操作には、初期化、検索、キーと値のペアの追加、キーと値のペアの削除などがあります。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># ハッシュテーブルを初期化\nhmap: dict = {}\n\n# 追加操作\n# ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n# 検索操作\n# ハッシュテーブルにキー key を入力し、値 value を取得\nname: str = hmap[15937]\n\n# 削除操作\n# ハッシュテーブルからキーと値のペア (key, value) を削除\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* ハッシュテーブルを初期化 */\nunordered_map&lt;int, string&gt; map;\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\";\nmap[15937] = \"シャオルオ\";\nmap[16750] = \"シャオスワン\";\nmap[13276] = \"シャオファ\";\nmap[10583] = \"シャオヤー\";\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nstring name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* ハッシュテーブルを初期化 */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.put(12836, \"シャオハ\");\nmap.put(15937, \"シャオルオ\");\nmap.put(16750, \"シャオスワン\");\nmap.put(13276, \"シャオファ\");\nmap.put(10583, \"シャオヤー\");\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nString name = map.get(15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* ハッシュテーブルを初期化 */\nDictionary&lt;int, string&gt; map = new() {\n    /* 追加操作 */\n    // ハッシュテーブルにキーと値のペア (key, value) を追加\n    { 12836, \"シャオハ\" },\n    { 15937, \"シャオルオ\" },\n    { 16750, \"シャオスワン\" },\n    { 13276, \"シャオファ\" },\n    { 10583, \"シャオヤー\" }\n};\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nstring name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* ハッシュテーブルを初期化 */\nhmap := make(map[int]string)\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nname := hmap[15937]\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* ハッシュテーブルを初期化 */\nvar map: [Int: String] = [:]\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\"\nmap[15937] = \"シャオルオ\"\nmap[16750] = \"シャオスワン\"\nmap[13276] = \"シャオファ\"\nmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map[15937]!\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* ハッシュテーブルを初期化 */\nconst map = new Map();\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.set(12836, 'シャオハ');\nmap.set(15937, 'シャオルオ');\nmap.set(16750, 'シャオスワン');\nmap.set(13276, 'シャオファ');\nmap.set(10583, 'シャオヤー');\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map.get(15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* ハッシュテーブルを初期化 */\nconst map = new Map&lt;number, string&gt;();\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.set(12836, 'シャオハ');\nmap.set(15937, 'シャオルオ');\nmap.set(16750, 'シャオスワン');\nmap.set(13276, 'シャオファ');\nmap.set(10583, 'シャオヤー');\nconsole.info('\\n追加後のハッシュテーブルは次のとおりです\\nKey -&gt; Value');\nconsole.info(map);\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet name = map.get(15937);\nconsole.info('\\n学籍番号 15937 を入力し、名前を検索: ' + name);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.delete(10583);\nconsole.info('\\n10583 を削除した後のハッシュテーブル\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* ハッシュテーブルを初期化 */\nMap&lt;int, String&gt; map = {};\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\";\nmap[15937] = \"シャオルオ\";\nmap[16750] = \"シャオスワン\";\nmap[13276] = \"シャオファ\";\nmap[10583] = \"シャオヤー\";\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nString name = map[15937];\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* ハッシュテーブルを初期化 */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap.insert(12836, \"シャオハ\".to_string());\nmap.insert(15937, \"シャオルオ\".to_string());\nmap.insert(16750, \"シャオスワン\".to_string());\nmap.insert(13279, \"シャオファ\".to_string());\nmap.insert(10583, \"シャオヤー\".to_string());\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C には組み込みのハッシュテーブルはありません\n</code></pre> hash_map.kt<pre><code>/* ハッシュテーブルを初期化 */\nval map = HashMap&lt;Int,String&gt;()\n\n/* 追加操作 */\n// ハッシュテーブルにキーと値のペア (key, value) を追加\nmap[12836] = \"シャオハ\"\nmap[15937] = \"シャオルオ\"\nmap[16750] = \"シャオスワン\"\nmap[13276] = \"シャオファ\"\nmap[10583] = \"シャオヤー\"\n\n/* 検索操作 */\n// ハッシュテーブルにキー key を入力し、値 value を取得\nval name = map[15937]\n\n/* 削除操作 */\n// ハッシュテーブルからキーと値のペア (key, value) を削除\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># ハッシュテーブルを初期化\nhmap = {}\n\n# 追加操作\n# ハッシュテーブルにキーと値のペア (key, value) を追加\nhmap[12836] = \"シャオハ\"\nhmap[15937] = \"シャオルオ\"\nhmap[16750] = \"シャオスワン\"\nhmap[13276] = \"シャオファ\"\nhmap[10583] = \"シャオヤー\"\n\n# 検索操作\n# ハッシュテーブルにキー key を入力し、値 value を取得\nname = hmap[15937]\n\n# 削除操作\n# ハッシュテーブルからキーと値のペア (key, value) を削除\nhmap.delete(10583)\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%9F%A5%E8%AF%A2%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%90%91%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E8%BE%93%E5%85%A5%E9%94%AE%20key%20%EF%BC%8C%E5%BE%97%E5%88%B0%E5%80%BC%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E5%88%A0%E9%99%A4%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>ハッシュテーブルには、キーと値のペア、キー、値を走査する 3 つの一般的な方法があります。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># ハッシュテーブルを走査\n# キーと値のペア key-&gt;value を走査\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# キー key のみを走査\nfor key in hmap.keys():\n    print(key)\n# 値 value のみを走査\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// イテレータを使って key-&gt;value を走査\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// キー key のみを走査\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// 値 value のみを走査\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// キー key のみを走査\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// 値 value のみを走査\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// キー key のみを走査\nfor key := range hmap {\n    fmt.Println(key)\n}\n// 値 value のみを走査\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// キー Key のみを走査\nfor key in map.keys {\n    print(key)\n}\n// 値 Value のみを走査\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* ハッシュテーブルを走査 */\nconsole.info('\\nキーと値のペア Key-&gt;Value を走査');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nキー Key のみを走査');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n値 Value のみを走査');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* ハッシュテーブルを走査 */\nconsole.info('\\nキーと値のペア Key-&gt;Value を走査');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nキー Key のみを走査');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n値 Value のみを走査');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// キー Key のみを走査\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// 値 Value のみを走査\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア Key-&gt;Value を走査\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// キー Key のみを走査\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// 値 Value のみを走査\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C には組み込みのハッシュテーブルはありません\n</code></pre> hash_map.kt<pre><code>/* ハッシュテーブルを走査 */\n// キーと値のペア key-&gt;value を走査\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// キー key のみを走査\nfor (key in map.keys) {\n    println(key)\n}\n// 値 value のみを走査\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># ハッシュテーブルを走査\n# キーと値のペア key-&gt;value を走査\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# キー key のみを走査\nhmap.keys.each { |key| puts key }\n\n# 値 value のみを走査\nhmap.values.each { |val| puts val }\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E9%94%AE%E5%80%BC%E5%AF%B9%20key-%3Evalue%0A%20%20%20%20for%20key,%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key,%20%22-%3E%22,%20value%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E9%94%AE%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E5%80%BC%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#612","level":2,"title":"6.1.2   ハッシュテーブルの簡単な実装","text":"<p>まずは最も単純なケースとして、**1 つの配列だけでハッシュテーブルを実装する**ことを考えます。ハッシュテーブルでは、配列中の各空き位置をバケット（bucket）と呼び、各バケットには 1 つのキーと値のペアを格納できます。したがって、検索操作とは <code>key</code> に対応するバケットを見つけ、そのバケットから <code>value</code> を取得することです。</p> <p>では、<code>key</code> に基づいて対応するバケットをどのように特定するのでしょうか。これはハッシュ関数（hash function）によって実現されます。ハッシュ関数の役割は、大きな入力空間をより小さな出力空間に写像することです。ハッシュテーブルでは、入力空間はすべての <code>key</code> 、出力空間はすべてのバケット（配列インデックス）です。言い換えると、<code>key</code> を入力すると、ハッシュ関数によってその <code>key</code> に対応するキーと値のペアの配列内での格納位置を求められます。</p> <p><code>key</code> を入力したとき、ハッシュ関数の計算過程は次の 2 段階に分かれます。</p> <ol> <li>あるハッシュアルゴリズム <code>hash()</code> を用いてハッシュ値を計算します。</li> <li>ハッシュ値をバケット数（配列長）<code>capacity</code> で剰余し、その <code>key</code> に対応するバケット（配列インデックス）<code>index</code> を求めます。</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>その後、<code>index</code> を使ってハッシュテーブル内の対応するバケットにアクセスし、<code>value</code> を取得できます。</p> <p>配列長を <code>capacity = 100</code> 、ハッシュアルゴリズムを <code>hash(key) = key</code> とすると、ハッシュ関数は <code>key % 100</code> となります。次の図では、<code>key</code> を学籍番号、<code>value</code> を名前の例として、ハッシュ関数の動作原理を示します。</p> <p></p> <p> 図 6-2   ハッシュ関数の動作原理 </p> <p>以下のコードは、単純なハッシュテーブルを実装したものです。ここでは、キーと値のペアを表すために <code>key</code> と <code>value</code> をクラス <code>Pair</code> にまとめています。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"キーと値の組\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"配列ベースのハッシュテーブル\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        # 100 個のバケットを含む配列を初期化\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"ハッシュ関数\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"検索操作\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"追加と更新の操作\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"削除操作\"\"\"\n        index: int = self.hash_func(key)\n        # None に設定し、削除を表す\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"すべてのキーと値のペアを取得\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"すべてのキーを取得\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"すべての値を取得\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"ハッシュテーブルを出力\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* キーと値の組 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // メモリを解放する\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* ハッシュ関数 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* 追加操作 */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 削除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // メモリを解放して nullptr に設定する\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* キーと値の組 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* ハッシュ関数 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* 削除操作 */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // null に設定し、削除を表す\n        buckets.set(index, null);\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* キーと値の組 int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* ハッシュ関数 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 検索操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 削除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // null に設定し、削除を表す\n        buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* すべてのキーを取得 */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* すべての値を取得 */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* キーと値の組 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* 配列ベースのハッシュテーブル */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* ハッシュテーブルを初期化 */\nfunc newArrayHashMap() *arrayHashMap {\n    // 100 個のバケットを含む配列を初期化\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* ハッシュ関数 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* 検索操作 */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* 追加操作 */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* 削除操作 */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // nil に設定し、削除を表す\n    a.buckets[index] = nil\n}\n\n/* すべてのキーのペアを取得する */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* すべてのキーを取得 */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* すべての値を取得 */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* ハッシュテーブルを出力 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* キーと値の組 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // 100 個のバケットを含む配列を初期化\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* ハッシュ関数 */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* 検索操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* 追加操作 */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* 削除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // nil に設定し、削除を表す\n        buckets[index] = nil\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* すべてのキーを取得 */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* すべての値を取得 */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* ハッシュテーブルを出力 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* キーと値の組 Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // 100 個のバケットを含む配列を初期化\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* ハッシュ関数 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* 検索操作 */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* 削除操作 */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // null に設定し、削除を表す\n        this.#buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* すべてのキーを取得 */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* すべての値を取得 */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* ハッシュテーブルを出力 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* キーと値の組 Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // 100 個のバケットを含む配列を初期化\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* ハッシュ関数 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* 検索操作 */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 追加操作 */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* 削除操作 */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // null に設定し、削除を表す\n        this.buckets[index] = null;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* すべてのキーを取得 */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* すべての値を取得 */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* ハッシュテーブルを出力 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* キーと値の組 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // 100 個のバケットを含む配列を初期化\n    _buckets = List.filled(100, null);\n  }\n\n  /* ハッシュ関数 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* 検索操作 */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* 追加操作 */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* 削除操作 */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* すべてのキーと値のペアを取得 */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* すべてのキーを取得 */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* すべての値を取得 */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* ハッシュテーブルを出力 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* キーと値の組 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* 配列ベースのハッシュテーブル */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // 100 個のバケットを含む配列を初期化\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* ハッシュ関数 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* 検索操作 */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* 追加操作 */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* 削除操作 */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // None に設定し、削除を表す\n        self.buckets[index] = None;\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* すべてのキーを取得 */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* すべての値を取得 */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* ハッシュテーブルを出力 */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* キーと値の組 int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* 配列ベースのハッシュテーブル */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* コンストラクタ */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* デストラクタ */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* 追加操作 */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* 削除操作 */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* すべてのキーと値のペアを取得 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* すべてのキーを取得 */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* すべての値を取得 */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 有効なキーと値のペア数を集計 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* ハッシュテーブルを出力 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* キーと値の組 */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* 配列ベースのハッシュテーブル */\nclass ArrayHashMap {\n    // 100 個のバケットを含む配列を初期化\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* ハッシュ関数 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* 検索操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* 追加操作 */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* 削除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // null に設定し、削除を表す\n        buckets[index] = null\n    }\n\n    /* すべてのキーと値のペアを取得 */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* すべてのキーを取得 */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* すべての値を取得 */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* ハッシュテーブルを出力 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### キーと値のペア ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### 配列で実装したハッシュテーブル ###\nclass ArrayHashMap\n  ### コンストラクタ ###\n  def initialize\n    # 100 個のバケットを含む配列を初期化\n    @buckets = Array.new(100)\n  end\n\n  ### ハッシュ関数 ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### 検索操作 ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### 追加操作 ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### 削除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    # nil に設定し、削除を表す\n    @buckets[index] = nil\n  end\n\n  ### すべてのキーと値のペアを取得 ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### すべてのキーを取得 ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### すべての値を取得 ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### ハッシュテーブルを出力 ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/hash_map/#613","level":2,"title":"6.1.3   ハッシュ衝突と拡張","text":"<p>本質的には、ハッシュ関数の役割は、すべての <code>key</code> からなる入力空間を、配列のすべてのインデックスからなる出力空間に写像することです。しかし、入力空間は多くの場合、出力空間よりはるかに大きいため、理論上は必ず「複数の入力が同じ出力に対応する」状況が存在します。</p> <p>上の例のハッシュ関数では、入力 <code>key</code> の下 2 桁が同じであれば、出力結果も同じになります。たとえば、学籍番号 12836 と 20336 の 2 人の学生を検索すると、次の結果を得ます：</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>次の図に示すように、2 つの学籍番号が同じ名前を指してしまっており、これは明らかに誤りです。このような、複数の入力が同じ出力に対応する状況をハッシュ衝突（hash collision）と呼びます。</p> <p></p> <p> 図 6-3   ハッシュ衝突の例 </p> <p>容易に分かるように、ハッシュテーブルの容量 \\(n\\) が大きいほど、複数の <code>key</code> が同じバケットに割り当てられる確率は低くなり、衝突も少なくなります。したがって、ハッシュテーブルを拡張することでハッシュ衝突を減らせます。</p> <p>次の図に示すように、拡張前はキーと値のペア <code>(136, A)</code> と <code>(236, D)</code> が衝突していますが、拡張後は衝突が解消されます。</p> <p></p> <p> 図 6-4   ハッシュテーブルの拡張 </p> <p>配列の拡張と同様に、ハッシュテーブルの拡張ではすべてのキーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移し替える必要があり、非常に時間がかかります。また、ハッシュテーブルの容量 <code>capacity</code> が変わるため、ハッシュ関数を使ってすべてのキーと値のペアの格納位置を再計算しなければならず、これによって拡張過程の計算コストがさらに増加します。そのため、プログラミング言語では通常、頻繁な拡張を防ぐために十分大きなハッシュテーブル容量をあらかじめ確保します。</p> <p>負荷率（load factor）はハッシュテーブルにおける重要な概念であり、ハッシュテーブル内の要素数をバケット数で割ったものとして定義され、ハッシュ衝突の深刻さを測るために用いられます。また、ハッシュテーブル拡張の発動条件としてもよく使われます。例えば Java では、負荷率が \\(0.75\\) を超えると、システムはハッシュテーブルを元の \\(2\\) 倍に拡張します。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.1 &nbsp; ハッシュテーブル"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   まとめ","text":"","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li><code>key</code> を入力すると、ハッシュテーブルは \\(O(1)\\) 時間で <code>value</code> を検索でき、非常に高効率である。</li> <li>一般的なハッシュテーブルの操作には、検索、キーと値のペアの追加、キーと値のペアの削除、ハッシュテーブルの走査などがある。</li> <li>ハッシュ関数は <code>key</code> を配列インデックスに写像し、それによって対応するバケットにアクセスして <code>value</code> を取得する。</li> <li>異なる 2 つの <code>key</code> が、ハッシュ関数を通した後に同じ配列インデックスになることがあり、検索結果の誤りを引き起こす。この現象をハッシュ衝突と呼ぶ。</li> <li>ハッシュテーブルの容量が大きいほど、ハッシュ衝突の確率は低くなる。そのため、ハッシュテーブルを拡張することでハッシュ衝突を緩和できる。配列の拡張と同様に、ハッシュテーブルの拡張操作のコストは大きい。</li> <li>負荷率は、ハッシュテーブル内の要素数をバケット数で割ったものと定義され、ハッシュ衝突の深刻さを反映する。ハッシュテーブル拡張を発動する条件としてよく用いられる。</li> <li>連鎖方式では、単一要素を連結リストに変換し、衝突したすべての要素を同じ連結リストに格納する。しかし、連結リストが長すぎると検索効率が低下するため、さらに連結リストを赤黒木に変換して効率を高めることができる。</li> <li>オープンアドレス法は複数回の探索によってハッシュ衝突を処理する。線形探索は固定のステップ幅を用いるが、要素を削除できず、クラスタリングが発生しやすいという欠点がある。二重ハッシュは複数のハッシュ関数を用いて探索するため、線形探索に比べてクラスタリングが起きにくいが、複数のハッシュ関数によって計算量が増える。</li> <li>プログラミング言語ごとに、異なるハッシュテーブル実装が採用されている。たとえば、Java の <code>HashMap</code> は連鎖方式を使用し、Python の <code>Dict</code> はオープンアドレス法を採用している。</li> <li>ハッシュテーブルでは、ハッシュアルゴリズムに決定性、高効率、均一分布という特徴が求められる。暗号学では、ハッシュアルゴリズムはさらに耐衝突性とアバランシェ効果も備えるべきである。</li> <li>ハッシュアルゴリズムは通常、大きな素数を法として用い、ハッシュ値の均一分布を最大限に保証してハッシュ衝突を減らす。</li> <li>一般的なハッシュアルゴリズムには MD5、SHA-1、SHA-2、SHA-3 などがある。MD5 はファイル完全性の検証によく用いられ、SHA-2 はセキュリティ用途やプロトコルでよく用いられる。</li> <li>プログラミング言語は通常、データ型に対して組み込みのハッシュアルゴリズムを提供し、ハッシュテーブル内のバケットインデックスの計算に用いる。通常、ハッシュ可能なのは不変オブジェクトだけである。</li> </ul>","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ハッシュテーブルの時間計算量が \\(O(n)\\) になるのはどのような場合ですか？</p> <p>ハッシュ衝突が深刻な場合、ハッシュテーブルの時間計算量は \\(O(n)\\) に劣化する。ハッシュ関数の設計が適切で、容量設定が合理的で、衝突が比較的均等な場合、時間計算量は \\(O(1)\\) である。プログラミング言語組み込みのハッシュテーブルを使うとき、通常は時間計算量を \\(O(1)\\) とみなす。</p> <p>Q：なぜハッシュ関数 \\(f(x) = x\\) を使わないのですか？ そうすれば衝突は起きません。</p> <p>\\(f(x) = x\\) というハッシュ関数では、各要素は一意のバケットインデックスに対応し、これは配列と等価である。しかし、入力空間は通常、出力空間（配列長）よりはるかに大きいため、ハッシュ関数の最後のステップはたいてい配列長での剰余になる。言い換えると、ハッシュテーブルの目的は、大きな状態空間をより小さな空間に写像し、\\(O(1)\\) の検索効率を提供することである。</p> <p>Q：ハッシュテーブルの基礎実装は配列、連結リスト、二分木なのに、なぜそれらより高効率になり得るのですか？</p> <p>まず、ハッシュテーブルは時間効率が高くなる一方で、空間効率は低くなる。ハッシュテーブルには、かなりの部分で未使用のメモリが存在する。</p> <p>次に、時間効率が高くなるのは特定の利用場面に限られる。ある機能が同じ時間計算量で配列や連結リストによって実装できるなら、通常はハッシュテーブルより速い。これは、ハッシュ関数の計算にコストがかかり、時間計算量の定数項がより大きいからである。</p> <p>最後に、ハッシュテーブルの時間計算量は劣化する可能性がある。たとえば連鎖方式では、連結リストや赤黒木で検索操作を行うため、なお \\(O(n)\\) 時間に劣化するリスクがある。</p> <p>Q：二重ハッシュにも要素を直接削除できない欠点がありますか？ 削除済みとマークした領域は再利用できますか？</p> <p>二重ハッシュはオープンアドレス法の一種であり、オープンアドレス法はいずれも要素を直接削除できないという欠点があるため、削除のマーク付けが必要になる。削除済みとマークされた領域は再利用できる。新しい要素をハッシュテーブルに挿入し、ハッシュ関数によって削除済みとマークされた位置を見つけた場合、その位置は新しい要素に使用できる。こうすることで、ハッシュテーブルの探索系列を変えずに保ちつつ、空間利用率も確保できる。</p> <p>Q：なぜ線形探索では、要素を探すときにハッシュ衝突が発生するのですか？</p> <p>探索時には、ハッシュ関数で対応するバケットとキーと値のペアを見つけ、<code>key</code> が一致しないことが分かると、それはハッシュ衝突を意味する。そのため、線形探索法では事前に設定したステップ幅に従って順に探索し、正しいキーと値のペアを見つけるか、見つからずに終了するまで続ける。</p> <p>Q：なぜハッシュテーブルの拡張でハッシュ衝突を緩和できるのですか？</p> <p>ハッシュ関数の最後のステップは、たいてい配列長 \\(n\\) での剰余を取り、出力値を配列インデックスの範囲内に収めることである。拡張後は配列長 \\(n\\) が変化し、<code>key</code> に対応するインデックスも変化する可能性がある。もともと同じバケットに入っていた複数の <code>key</code> は、拡張後には複数のバケットに割り当てられる可能性があり、それによってハッシュ衝突が緩和される。</p> <p>Q：高効率な読み書きのためなら、配列を直接使えばよいのではないですか？</p> <p>データの <code>key</code> が連続した小範囲の整数であれば、配列を直接使えばよく、単純で高効率である。しかし <code>key</code> が別の型（たとえば文字列）の場合は、ハッシュ関数を用いて <code>key</code> を配列インデックスに写像し、さらにバケット配列を通じて要素を格納する必要がある。このような構造がハッシュテーブルである。</p>","path":["第 6 章 &nbsp; ハッシュテーブル","6.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"第 8 章   ヒープ","text":"<p>Abstract</p> <p>ヒープは連なる山々の峰のように、幾重にも重なり、さまざまな形をしている。</p> <p>いくつもの山の高さはまちまちだが、最も高い峰がいつも最初に目に入る。</p>","path":["第 8 章 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"章の内容","text":"<ul> <li>8.1   ヒープ</li> <li>8.2   ヒープ構築</li> <li>8.3   Top-k 問題</li> <li>8.4   まとめ</li> </ul>","path":["第 8 章 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   ヒープ構築","text":"<p>場合によっては、リスト内のすべての要素を使ってヒープを構築したいことがあります。この過程を「ヒープ構築」と呼びます。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   ヒープへの挿入操作による実現","text":"<p>まず空のヒープを作成し、次にリストを走査して、各要素に対して順に「ヒープへの挿入操作」を実行します。つまり、要素をヒープの末尾に追加してから、その要素に対して「下から上へ」のヒープ化を行います。</p> <p>要素が1つヒープに挿入されるたびに、ヒープの長さは1増加します。ノードは上から下へ順に二分木へ追加されるため、ヒープは「上から下へ」構築されます。</p> <p>要素数を \\(n\\) とすると、各要素のヒープへの挿入操作には \\(O(\\log{n})\\) の時間がかかるため、このヒープ構築法の時間計算量は \\(O(n \\log n)\\) です。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   走査によるヒープ化で実現","text":"<p>実際には、より効率的なヒープ構築法を実現でき、全体は2つの手順に分かれます。</p> <ol> <li>リストのすべての要素をそのままヒープに追加します。この時点では、ヒープの性質はまだ満たされていません。</li> <li>ヒープを逆順で走査し（レベル順走査の逆順）、各非葉ノードに対して順に「上から下へ」のヒープ化を実行します。</li> </ol> <p>あるノードをヒープ化するたびに、そのノードを根とする部分木は合法な部分ヒープになります。また、逆順で走査するため、ヒープは「下から上へ」構築されます。</p> <p>逆順走査を選ぶのは、この方法なら現在のノードの下にある部分木がすでに合法な部分ヒープであることを保証でき、そのうえで現在のノードをヒープ化してはじめて有効になるからです。</p> <p>なお、葉ノードには子ノードがないため、それ自体が自然に合法な部分ヒープであり、ヒープ化は不要です。以下のコードが示すように、最後の非葉ノードは最後のノードの親ノードであり、そこから逆順に走査してヒープ化を実行します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"コンストラクタ。入力リストに基づいてヒープを構築する\"\"\"\n    # リスト要素をそのままヒープに追加\n    self.max_heap = nums\n    # 葉ノード以外のすべてのノードをヒープ化\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(vector&lt;int&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = nums;\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築 */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = new List&lt;int&gt;(nums);\n    // 葉ノード以外のすべてのノードをヒープ化\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* コンストラクタ。スライスからヒープを構築する */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // リスト要素をそのままヒープに追加\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // 葉ノード以外のすべてのノードをヒープ化\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\ninit(nums: [Int]) {\n    // リスト要素をそのままヒープに追加\n    maxHeap = nums\n    // 葉ノード以外のすべてのノードをヒープ化\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* コンストラクタ。空のヒープを作成するか、入力リストからヒープを構築する */\nconstructor(nums) {\n    // リスト要素をそのままヒープに追加\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* コンストラクタ。空のヒープを作成するか、入力リストからヒープを構築する */\nconstructor(nums?: number[]) {\n    // リスト要素をそのままヒープに追加\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // 葉ノード以外のすべてのノードをヒープ化\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nMaxHeap(List&lt;int&gt; nums) {\n  // リスト要素をそのままヒープに追加\n  _maxHeap = nums;\n  // 葉ノード以外のすべてのノードをヒープ化\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* コンストラクタ。入力リストに基づいてヒープを構築する */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // リスト要素をそのままヒープに追加\n    let mut heap = MaxHeap { max_heap: nums };\n    // 葉ノード以外のすべてのノードをヒープ化\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* コンストラクタ。スライスからヒープを構築する */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // すべての要素をヒープに入れる\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // 葉ノード以外のすべてのノードをヒープ化\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* 最大ヒープ */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // 配列ではなくリストを使うことで、拡張を考慮する必要がない\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* コンストラクタ。入力リストに基づいてヒープを構築する */\n    init {\n        // リスト要素をそのままヒープに追加\n        maxHeap.addAll(nums!!)\n        // 葉ノード以外のすべてのノードをヒープ化\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* 左子ノードのインデックスを取得 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 右子ノードのインデックスを取得 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 親ノードのインデックスを取得 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // 切り捨て除算\n    }\n\n    /* 要素を交換 */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* ヒープのサイズを取得 */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* ヒープが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        /* ヒープが空かどうかを判定 */\n        return size() == 0\n    }\n\n    /* ヒープ先頭要素にアクセス */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* 要素をヒープに追加 */\n    fun push(_val: Int) {\n        // ノードを追加\n        maxHeap.add(_val)\n        // 下から上へヒープ化\n        siftUp(size() - 1)\n    }\n\n    /* ノード i から始めて、下から上へヒープ化 */\n    private fun siftUp(it: Int) {\n        // Kotlin の関数引数は不変のため、一時変数を作成する\n        var i = it\n        while (true) {\n            // ノード i の親ノードを取得\n            val p = parent(i)\n            // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // 2 つのノードを交換\n            swap(i, p)\n            // ループで下から上へヒープ化\n            i = p\n        }\n    }\n\n    /* 要素をヒープから取り出す */\n    fun pop(): Int {\n        // 空判定の処理\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        swap(0, size() - 1)\n        // ノードを削除\n        val _val = maxHeap.removeAt(size() - 1)\n        // 上から下へヒープ化\n        siftDown(0)\n        // ヒープ先頭要素を返す\n        return _val\n    }\n\n    /* ノード i から始めて、上から下へヒープ化 */\n    private fun siftDown(it: Int) {\n        // Kotlin の関数引数は不変のため、一時変数を作成する\n        var i = it\n        while (true) {\n            // ノード i, l, r のうち値が最大のノードを ma とする\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n            if (ma == i) break\n            // 2 つのノードを交換\n            swap(i, ma)\n            // ループで上から下へヒープ化\n            i = ma\n        }\n    }\n\n    /* ヒープ（二分木）を出力 */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### コンストラクタ。入力リストに基づいてヒープを構築 ###\ndef initialize(nums)\n  # リスト要素をそのままヒープに追加\n  @max_heap = nums\n  # 葉ノード以外のすべてのノードをヒープ化\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   計算量の分析","text":"<p>以下では、2つ目のヒープ構築法の時間計算量を求めてみましょう。</p> <ul> <li>完全二分木のノード数を \\(n\\) とすると、葉ノード数は \\((n + 1) / 2\\) です。ここで \\(/\\) は切り捨て除算を表します。したがって、ヒープ化が必要なノード数は \\((n - 1) / 2\\) です。</li> <li>上から下へのヒープ化の過程では、各ノードは最大で葉ノードまでヒープ化されるため、最大反復回数は二分木の高さ \\(\\log n\\) です。</li> </ul> <p>上の2つを掛け合わせると、ヒープ構築過程の時間計算量は \\(O(n \\log n)\\) となります。しかし、この見積もりは正確ではありません。二分木では下層のノード数が上層よりはるかに多いという性質を考慮していないためです。</p> <p>次に、より正確な計算を行います。計算を簡単にするため、ノード数が \\(n\\) 、高さが \\(h\\) の「満二分木」を仮定します。この仮定は計算結果の正しさに影響しません。</p> <p></p> <p> 図 8-5   満二分木の各層のノード数 </p> <p>上図に示すように、ノードを「上から下へヒープ化」する最大反復回数は、そのノードから葉ノードまでの距離に等しく、この距離こそが「ノードの高さ」です。したがって、各層の「ノード数 \\(\\times\\) ノードの高さ」を合計すれば、**すべてのノードのヒープ化反復回数の総和**が得られます。</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>上式を簡約するには中学の数列の知識を用います。まず \\(T(h)\\) に \\(2\\) を掛けると、次のようになります。</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>ずらして引く方法を用い、下式の \\(2 T(h)\\) から上式の \\(T(h)\\) を引くと、次が得られます。</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>上式を見ると、\\(T(h)\\) は等比数列であることがわかるため、和の公式を直接用いて、時間計算量は次のように求められます。</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>さらに、高さ \\(h\\) の満二分木のノード数は \\(n = 2^{h+1} - 1\\) であるため、計算量は容易に \\(O(2^h) = O(n)\\) とわかります。以上の導出は、**入力リストからヒープを構築する時間計算量が \\(O(n)\\) であり、非常に効率的である**ことを示しています。</p>","path":["第 8 章 &nbsp; ヒープ","8.2 &nbsp; ヒープ構築"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   ヒープ","text":"<p>ヒープ（heap）は、特定の条件を満たす完全二分木であり、主に次の 2 種類に分けられます。</p> <ul> <li>最小ヒープ（min heap）：任意のノードの値 \\(\\leq\\) その子ノードの値。</li> <li>最大ヒープ（max heap）：任意のノードの値 \\(\\geq\\) その子ノードの値。</li> </ul> <p></p> <p> 図 8-1   最小ヒープと最大ヒープ </p> <p>ヒープは完全二分木の特殊な例であり、次の性質を持ちます。</p> <ul> <li>最下層のノードは左から順に埋められ、ほかの層のノードはすべて埋まっています。</li> <li>二分木の根ノードを「ヒープ頂点」、最下層で最も右にあるノードを「ヒープ底」と呼びます。</li> <li>最大ヒープ（最小ヒープ）では、ヒープ頂点の要素（根ノード）の値が最大（最小）です。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   ヒープの基本操作","text":"<p>ここで注意したいのは、多くのプログラミング言語が提供しているのは優先度付きキュー（priority queue）であり、これは優先度順に並ぶキューとして定義される抽象データ構造だということです。</p> <p>実際には、ヒープは通常、優先度付きキューの実装に用いられ、最大ヒープは要素が大きい順に取り出される優先度付きキューに相当します。利用の観点では、「優先度付きキュー」と「ヒープ」は等価なデータ構造とみなせます。そのため、本書では両者を特に区別せず、まとめて「ヒープ」と呼びます。</p> <p>ヒープの基本操作を以下の表に示します。メソッド名はプログラミング言語によって異なります。</p> <p> 表 8-1   ヒープの操作効率 </p> メソッド名 説明 時間計算量 <code>push()</code> 要素をヒープに追加 \\(O(\\log n)\\) <code>pop()</code> ヒープ頂点の要素を取り出す \\(O(\\log n)\\) <code>peek()</code> ヒープ頂点の要素にアクセス（最大 / 最小ヒープではそれぞれ最大 / 最小値） \\(O(1)\\) <code>size()</code> ヒープ内の要素数を取得 \\(O(1)\\) <code>isEmpty()</code> ヒープが空かどうかを判定 \\(O(1)\\) <p>実際の応用では、プログラミング言語が提供するヒープクラス（または優先度付きキュークラス）をそのまま使えます。</p> <p>ソートアルゴリズムにおける「昇順」と「降順」と同様に、<code>flag</code> を設定したり <code>Comparator</code> を変更したりすることで、「最小ヒープ」と「最大ヒープ」を切り替えられます。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># 最小ヒープを初期化\nmin_heap, flag = [], 1\n# 最大ヒープを初期化\nmax_heap, flag = [], -1\n\n# Python の heapq モジュールはデフォルトで最小ヒープを実装している\n# 「要素を負にして」からヒープに追加すると、大小関係を反転させて最大ヒープを実現できる\n# この例では、flag = 1 のときは最小ヒープ、flag = -1 のときは最大ヒープに対応する\n\n# 要素をヒープに追加\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# ヒープ頂点の要素を取得\npeek: int = flag * max_heap[0] # 5\n\n# ヒープ頂点の要素を取り出す\n# 取り出された要素は大きい順の列になる\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# ヒープのサイズを取得\nsize: int = len(max_heap)\n\n# ヒープが空かどうかを判定\nis_empty: bool = not max_heap\n\n# 入力リストからヒープを構築\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// 最大ヒープを初期化\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* 要素をヒープに追加 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.top(); // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.size();\n\n/* ヒープが空かどうかを判定 */\nbool isEmpty = maxHeap.empty();\n\n/* 入力リストからヒープを構築 */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// 最大ヒープを初期化（lambda 式で Comparator を変更すればよい）\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* 要素をヒープに追加 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.peek(); // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.size();\n\n/* ヒープが空かどうかを判定 */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* 入力リストからヒープを構築 */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// 最大ヒープを初期化（lambda 式で Comparer を変更すればよい）\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* 要素をヒープに追加 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* ヒープ頂点の要素を取得 */\nint peek = maxHeap.Peek();//5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* ヒープのサイズを取得 */\nint size = maxHeap.Count;\n\n/* ヒープが空かどうかを判定 */\nbool isEmpty = maxHeap.Count == 0;\n\n/* 入力リストからヒープを構築 */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// Go では、heap.Interface を実装することで整数の最大ヒープを構築できる\n// heap.Interface を実装するには、同時に sort.Interface も実装する必要がある\ntype intHeap []any\n\n// Push は heap.Interface のメソッドで、要素をヒープに追加する\nfunc (h *intHeap) Push(x any) {\n    // Push と Pop は pointer receiver を引数に取る\n    // スライスの内容を調整するだけでなく、スライスの長さも変更するため。\n    *h = append(*h, x.(int))\n}\n\n// Pop は heap.Interface のメソッドで、ヒープ頂点の要素を取り出す\nfunc (h *intHeap) Pop() any {\n    // 取り出す要素は末尾に格納されている\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len は sort.Interface のメソッド\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less は sort.Interface のメソッド\nfunc (h *intHeap) Less(i, j int) bool {\n    // 最小ヒープを実装する場合は、不等号を小なりに変更する\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap は sort.Interface のメソッド\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top はヒープ頂点の要素を取得\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* ヒープを初期化 */\n    // 最大ヒープを初期化\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* 要素をヒープに追加 */\n    // heap.Interface のメソッドを呼び出して要素を追加する\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* ヒープ頂点の要素を取得 */\n    top := maxHeap.Top()\n    fmt.Printf(\"ヒープ頂点の要素は %d\\n\", top)\n\n    /* ヒープ頂点の要素を取り出す */\n    // heap.Interface のメソッドを呼び出して要素を削除する\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* ヒープのサイズを取得 */\n    size := len(*maxHeap)\n    fmt.Printf(\"ヒープ内の要素数は %d\\n\", size)\n\n    /* ヒープが空かどうかを判定 */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"ヒープは空か %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* ヒープを初期化 */\n// Swift の Heap 型は最大ヒープと最小ヒープの両方をサポートしており、swift-collections の導入が必要\nvar heap = Heap&lt;Int&gt;()\n\n/* 要素をヒープに追加 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* ヒープ頂点の要素を取得 */\nvar peek = heap.max()!\n\n/* ヒープ頂点の要素を取り出す */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* ヒープのサイズを取得 */\nlet size = heap.count\n\n/* ヒープが空かどうかを判定 */\nlet isEmpty = heap.isEmpty\n\n/* 入力リストからヒープを構築 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript には組み込みの Heap クラスがない\n</code></pre> heap.ts<pre><code>// TypeScript には組み込みの Heap クラスがない\n</code></pre> heap.dart<pre><code>// Dart には組み込みの Heap クラスがない\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* ヒープを初期化 */\n// 最小ヒープを初期化\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// 最大ヒープを初期化\nlet mut max_heap = BinaryHeap::new();\n\n/* 要素をヒープに追加 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* ヒープ頂点の要素を取得 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* ヒープのサイズを取得 */\nlet size = max_heap.len();\n\n/* ヒープが空かどうかを判定 */\nlet is_empty = max_heap.is_empty();\n\n/* 入力リストからヒープを構築 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C には組み込みの Heap クラスがない\n</code></pre> heap.kt<pre><code>/* ヒープを初期化 */\n// 最小ヒープを初期化\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// 最大ヒープを初期化（lambda 式で Comparator を変更すればよい）\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* 要素をヒープに追加 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* ヒープ頂点の要素を取得 */\nvar peek = maxHeap.peek() // 5\n\n/* ヒープ頂点の要素を取り出す */\n// 取り出された要素は大きい順の列になる\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* ヒープのサイズを取得 */\nval size = maxHeap.size\n\n/* ヒープが空かどうかを判定 */\nval isEmpty = maxHeap.isEmpty()\n\n/* 入力リストからヒープを構築 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby には組み込みの Heap クラスがない\n</code></pre> 実行を可視化 <p>https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   ヒープの実装","text":"<p>以下では最大ヒープを実装します。最小ヒープに変換したい場合は、すべての大小比較ロジックを反転させるだけです（たとえば、\\(\\geq\\) を \\(\\leq\\) に置き換えます）。興味のある読者は自分で実装してみてください。</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   ヒープの格納と表現","text":"<p>「二分木」の章で述べたように、完全二分木は配列で表現するのに非常に適しています。ヒープはまさに完全二分木の一種なので、ここでは配列を使ってヒープを格納します。</p> <p>配列で二分木を表す場合、要素はノードの値を表し、インデックスは二分木におけるノードの位置を表します。ノード間の参照関係はインデックスの対応式によって実現できます。</p> <p>次の図に示すように、インデックス \\(i\\) に対して、左子ノードのインデックスは \\(2i + 1\\) 、右子ノードのインデックスは \\(2i + 2\\) 、親ノードのインデックスは \\((i - 1) / 2\\)（切り捨て除算）です。インデックスが範囲外であれば、空ノードまたはノードが存在しないことを表します。</p> <p></p> <p> 図 8-2   ヒープの表現と格納 </p> <p>インデックスの対応式は関数にまとめておくと、後続で使いやすくなります：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"左子ノードのインデックスを取得\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"右子ノードのインデックスを取得\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"親ノードのインデックスを取得\"\"\"\n    return (i - 1) // 2  # 切り捨て除算\n</code></pre> my_heap.cpp<pre><code>/* 左子ノードのインデックスを取得 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.java<pre><code>/* 左子ノードのインデックスを取得 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.cs<pre><code>/* 左子ノードのインデックスを取得 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint Parent(int i) {\n    return (i - 1) / 2; // 切り捨て除算\n}\n</code></pre> my_heap.go<pre><code>/* 左子ノードのインデックスを取得 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfunc (h *maxHeap) parent(i int) int {\n    // 切り捨て除算\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* 左子ノードのインデックスを取得 */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.js<pre><code>/* 左子ノードのインデックスを取得 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // 切り捨て除算\n}\n</code></pre> my_heap.ts<pre><code>/* 左子ノードのインデックスを取得 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // 切り捨て除算\n}\n</code></pre> my_heap.dart<pre><code>/* 左子ノードのインデックスを取得 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // 切り捨て除算\n}\n</code></pre> my_heap.rs<pre><code>/* 左子ノードのインデックスを取得 */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.c<pre><code>/* 左子ノードのインデックスを取得 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* 右子ノードのインデックスを取得 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* 親ノードのインデックスを取得 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // 切り捨て\n}\n</code></pre> my_heap.kt<pre><code>/* 左子ノードのインデックスを取得 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* 右子ノードのインデックスを取得 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* 親ノードのインデックスを取得 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // 切り捨て除算\n}\n</code></pre> my_heap.rb<pre><code>### 左子ノードのインデックスを取得 ###\ndef left(i)\n  2 * i + 1\nend\n\n### 右子ノードのインデックスを取得 ###\ndef right(i)\n  2 * i + 2\nend\n\n### 親ノードのインデックスを取得 ###\ndef parent(i)\n  (i - 1) / 2     # 切り捨て除算\nend\n</code></pre>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   ヒープ頂点の要素にアクセス","text":"<p>ヒープ頂点の要素は二分木の根ノード、すなわちリストの先頭要素です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"ヒープ先頭要素にアクセス\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* ヒープ先頭要素にアクセス */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* ヒープ先頭要素にアクセス */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* ヒープ先頭要素にアクセス */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* ヒープ先頭要素にアクセス */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* ヒープ先頭要素にアクセス */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* ヒープ先頭要素にアクセス */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* ヒープ先頭要素にアクセス */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* ヒープ先頭要素にアクセス */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* ヒープ先頭要素にアクセス */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### ヒープ先頭要素を参照 ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   要素をヒープに追加","text":"<p>与えられた要素 <code>val</code> を、まずヒープの底に追加します。追加後、<code>val</code> がヒープ内のほかの要素より大きい可能性があるため、ヒープ条件が崩れているかもしれません。そのため、挿入ノードから根ノードまでの経路上にある各ノードを修復する必要があります。この操作をヒープ化（heapify）と呼びます。</p> <p>ヒープへ追加したノードから始めて、**下から上へヒープ化**を行います。次の図のように、挿入ノードとその親ノードの値を比較し、挿入ノードのほうが大きければそれらを交換します。その後もこの操作を繰り返し、下から上へ各ノードを修復して、根ノードを越えるか交換不要のノードに達した時点で終了します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-3   要素をヒープに追加する手順 </p> <p>ノード総数を \\(n\\) とすると、木の高さは \\(O(\\log n)\\) です。したがって、ヒープ化操作のループ回数は高々 \\(O(\\log n)\\) であり、要素をヒープに追加する操作の時間計算量は \\(O(\\log n)\\) です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"要素をヒープに追加\"\"\"\n    # ノードを追加\n    self.max_heap.append(val)\n    # 下から上へヒープ化\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"ノード i から始めて、下から上へヒープ化\"\"\"\n    while True:\n        # ノード i の親ノードを取得\n        p = self.parent(i)\n        # 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # 2 つのノードを交換\n        self.swap(i, p)\n        # ループで下から上へヒープ化\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n    // ノードを追加\n    maxHeap.push_back(val);\n    // 下から上へヒープ化\n    siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 2 つのノードを交換\n        swap(maxHeap[i], maxHeap[p]);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n    // ノードを追加\n    maxHeap.add(val);\n    // 下から上へヒープ化\n    siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // 2 つのノードを交換\n        swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 要素をヒープに追加 */\nvoid Push(int val) {\n    // ノードを追加\n    maxHeap.Add(val);\n    // 下から上へヒープ化\n    SiftUp(Size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid SiftUp(int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = Parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」な場合は、ヒープ化を終了する\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 2 つのノードを交換\n        Swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 要素をヒープに追加 */\nfunc (h *maxHeap) push(val any) {\n    // ノードを追加\n    h.data = append(h.data, val)\n    // 下から上へヒープ化\n    h.siftUp(len(h.data) - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // ノード i の親ノードを取得\n        p := h.parent(i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // 2 つのノードを交換\n        h.swap(i, p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 要素をヒープに追加 */\nfunc push(val: Int) {\n    // ノードを追加\n    maxHeap.append(val)\n    // 下から上へヒープ化\n    siftUp(i: size() - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // ノード i の親ノードを取得\n        let p = parent(i: i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // 2 つのノードを交換\n        swap(i: i, j: p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 要素をヒープに追加 */\npush(val) {\n    // ノードを追加\n    this.#maxHeap.push(val);\n    // 下から上へヒープ化\n    this.#siftUp(this.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\n#siftUp(i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        const p = this.#parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // 2 つのノードを交換\n        this.#swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 要素をヒープに追加 */\npush(val: number): void {\n    // ノードを追加\n    this.maxHeap.push(val);\n    // 下から上へヒープ化\n    this.siftUp(this.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nsiftUp(i: number): void {\n    while (true) {\n        // ノード i の親ノードを取得\n        const p = this.parent(i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // 2 つのノードを交換\n        this.swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 要素をヒープに追加 */\nvoid push(int val) {\n  // ノードを追加\n  _maxHeap.add(val);\n  // 下から上へヒープ化\n  siftUp(size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(int i) {\n  while (true) {\n    // ノード i の親ノードを取得\n    int p = _parent(i);\n    // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // 2 つのノードを交換\n    _swap(i, p);\n    // ループで下から上へヒープ化\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 要素をヒープに追加 */\nfn push(&amp;mut self, val: i32) {\n    // ノードを追加\n    self.max_heap.push(val);\n    // 下から上へヒープ化\n    self.sift_up(self.size() - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // ノード i はすでにヒープの先頭ノードなので、ヒープ化を終了する\n        if i == 0 {\n            break;\n        }\n        // ノード i の親ノードを取得\n        let p = Self::parent(i);\n        // 「ノードの修復が不要」になったら、ヒープ化を終了\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // 2 つのノードを交換\n        self.swap(i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 要素をヒープに追加 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // 通常は、これほど多くのノードを追加すべきではない\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // ノードを追加\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // 下から上へヒープ化\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // ノード i の親ノードを取得\n        int p = parent(maxHeap, i);\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(maxHeap, i, p);\n        // ループで下から上へヒープ化\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 要素をヒープに追加 */\nfun push(_val: Int) {\n    // ノードを追加\n    maxHeap.add(_val)\n    // 下から上へヒープ化\n    siftUp(size() - 1)\n}\n\n/* ノード i から始めて、下から上へヒープ化 */\nfun siftUp(it: Int) {\n    // Kotlin の関数引数は不変のため、一時変数を作成する\n    var i = it\n    while (true) {\n        // ノード i の親ノードを取得\n        val p = parent(i)\n        // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // 2 つのノードを交換\n        swap(i, p)\n        // ループで下から上へヒープ化\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 要素をヒープに挿入 ###\ndef push(val)\n  # ノードを追加\n  @max_heap &lt;&lt; val\n  # 下から上へヒープ化\n  sift_up(size - 1)\nend\n\n### ノード i から下から上へヒープ化 ###\ndef sift_up(i)\n  loop do\n    # ノード i の親ノードを取得\n    p = parent(i)\n    # 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # 2 つのノードを交換\n    swap(i, p)\n    # ループで下から上へヒープ化\n    i = p\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   ヒープ頂点の要素を取り出す","text":"<p>ヒープ頂点の要素は二分木の根ノード、すなわちリストの先頭要素です。もし先頭要素をそのまま削除すると、二分木内のすべてのノードのインデックスが変化してしまい、その後のヒープ化による修復が困難になります。要素インデックスの変動をできるだけ小さくするため、次の手順を取ります。</p> <ol> <li>ヒープ頂点の要素とヒープ底の要素を交換する（根ノードと最も右の葉ノードを交換する）。</li> <li>交換後、ヒープ底をリストから削除する（すでに交換済みであるため、実際に削除されるのは元のヒープ頂点の要素であることに注意）。</li> <li>根ノードから開始し、**上から下へヒープ化**を行う。</li> </ol> <p>次の図のように、**「上から下へのヒープ化」の方向は「下から上へのヒープ化」と逆**です。根ノードの値を 2 つの子ノードと比較し、最大の子ノードと根ノードを交換します。その後、この操作を繰り返し、葉ノードを越えるか交換不要のノードに達した時点で終了します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-4   ヒープ頂点の要素を取り出す手順 </p> <p>要素をヒープに追加する操作と同様に、ヒープ頂点の要素を取り出す操作の時間計算量も \\(O(\\log n)\\) です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"要素をヒープから取り出す\"\"\"\n    # 空判定の処理\n    if self.is_empty():\n        raise IndexError(\"ヒープが空です\")\n    # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    self.swap(0, self.size() - 1)\n    # ノードを削除\n    val = self.max_heap.pop()\n    # 上から下へヒープ化\n    self.sift_down(0)\n    # ヒープ先頭要素を返す\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"ノード i から始めて、上から下へヒープ化\"\"\"\n    while True:\n        # ノード i, l, r のうち値が最大のノードを ma とする\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i:\n            break\n        # 2 つのノードを交換\n        self.swap(i, ma)\n        # ループで上から下へヒープ化\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* 要素をヒープから取り出す */\nvoid pop() {\n    // 空判定の処理\n    if (isEmpty()) {\n        throw out_of_range(\"ヒープが空です\");\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // ノードを削除\n    maxHeap.pop_back();\n    // 上から下へヒープ化\n    siftDown(0);\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 要素をヒープから取り出す */\nint pop() {\n    // 空判定の処理\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(0, size() - 1);\n    // ノードを削除\n    int val = maxHeap.remove(size() - 1);\n    // 上から下へヒープ化\n    siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 要素をヒープから取り出す */\nint Pop() {\n    // 空判定の処理\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    Swap(0, Size() - 1);\n    // ノードを削除\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // 上から下へヒープ化\n    SiftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid SiftDown(int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 「ノード i が最大」または「葉ノードを越えた」場合は、ヒープ化を終了する\n        if (ma == i) break;\n        // 2 つのノードを交換\n        Swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 要素をヒープから取り出す */\nfunc (h *maxHeap) pop() any {\n    // 空判定の処理\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    h.swap(0, h.size()-1)\n    // ノードを削除\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // 上から下へヒープ化\n    h.siftDown(0)\n\n    // ヒープ先頭要素を返す\n    return val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // ノード i, l, r のうち値が最大のノードを max とする\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if max == i {\n            break\n        }\n        // 2 つのノードを交換\n        h.swap(i, max)\n        // ループで上から下へヒープ化\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 要素をヒープから取り出す */\nfunc pop() -&gt; Int {\n    // 空判定の処理\n    if isEmpty() {\n        fatalError(\"ヒープが空です\")\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(i: 0, j: size() - 1)\n    // ノードを削除\n    let val = maxHeap.remove(at: size() - 1)\n    // 上から下へヒープ化\n    siftDown(i: 0)\n    // ヒープ先頭要素を返す\n    return val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        swap(i: i, j: ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 要素をヒープから取り出す */\npop() {\n    // 空判定の処理\n    if (this.isEmpty()) throw new Error('ヒープが空です');\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    this.#swap(0, this.size() - 1);\n    // ノードを削除\n    const val = this.#maxHeap.pop();\n    // 上から下へヒープ化\n    this.#siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\n#siftDown(i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) break;\n        // 2 つのノードを交換\n        this.#swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 要素をヒープから取り出す */\npop(): number {\n    // 空判定の処理\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    this.swap(0, this.size() - 1);\n    // ノードを削除\n    const val = this.maxHeap.pop();\n    // 上から下へヒープ化\n    this.siftDown(0);\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nsiftDown(i: number): void {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) break;\n        // 2 つのノードを交換\n        this.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 要素をヒープから取り出す */\nint pop() {\n  // 空判定の処理\n  if (isEmpty()) throw Exception('ヒープが空です');\n  // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n  _swap(0, size() - 1);\n  // ノードを削除\n  int val = _maxHeap.removeLast();\n  // 上から下へヒープ化\n  siftDown(0);\n  // ヒープ先頭要素を返す\n  return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(int i) {\n  while (true) {\n    // ノード i, l, r のうち値が最大のノードを ma とする\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    if (ma == i) break;\n    // 2 つのノードを交換\n    _swap(i, ma);\n    // ループで上から下へヒープ化\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 要素をヒープから取り出す */\nfn pop(&amp;mut self) -&gt; i32 {\n    // 空判定の処理\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    self.swap(0, self.size() - 1);\n    // ノードを削除\n    let val = self.max_heap.pop().unwrap();\n    // 上から下へヒープ化\n    self.sift_down(0);\n    // ヒープ先頭要素を返す\n    val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break;\n        }\n        // 2 つのノードを交換\n        self.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 要素をヒープから取り出す */\nint pop(MaxHeap *maxHeap) {\n    // 空判定の処理\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // ノードを削除\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // 上から下へヒープ化\n    siftDown(maxHeap, 0);\n\n    // ヒープ先頭要素を返す\n    return val;\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを max とする\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (max == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(maxHeap, i, max);\n        // ループで上から下へヒープ化\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 要素をヒープから取り出す */\nfun pop(): Int {\n    // 空判定の処理\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    swap(0, size() - 1)\n    // ノードを削除\n    val _val = maxHeap.removeAt(size() - 1)\n    // 上から下へヒープ化\n    siftDown(0)\n    // ヒープ先頭要素を返す\n    return _val\n}\n\n/* ノード i から始めて、上から下へヒープ化 */\nfun siftDown(it: Int) {\n    // Kotlin の関数引数は不変のため、一時変数を作成する\n    var i = it\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) break\n        // 2 つのノードを交換\n        swap(i, ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 要素をヒープから取り出す ###\ndef pop\n  # 空判定の処理\n  raise IndexError, \"ヒープが空です\" if is_empty?\n  # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n  swap(0, size - 1)\n  # ノードを削除\n  val = @max_heap.pop\n  # 上から下へヒープ化\n  sift_down(0)\n  # ヒープ先頭要素を返す\n  val\nend\n\n### ノード i から上から下へヒープ化 ###\ndef sift_down(i)\n  loop do\n    # ノード i, l, r のうち値が最大のノードを ma とする\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    break if ma == i\n\n    # 2 つのノードを交換\n    swap(i, ma)\n    # ループで上から下へヒープ化\n    i = ma\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   ヒープの代表的な応用","text":"<ul> <li>優先度付きキュー：ヒープは、優先度付きキューを実装するための代表的なデータ構造です。キューへの追加と取り出しの時間計算量はいずれも \\(O(\\log n)\\) で、ヒープ構築は \\(O(n)\\) であり、これらの操作はいずれも非常に効率的です。</li> <li>ヒープソート：与えられたデータ群からヒープを構築し、要素の取り出しを繰り返すことで整列済みデータを得られます。ただし、通常はより洗練された方法でヒープソートを実装します。詳しくは「ヒープソート」の章を参照してください。</li> <li>最大の \\(k\\) 個の要素を取得：これは古典的なアルゴリズム問題であると同時に、典型的な応用でもあります。たとえば、人気上位 10 件のニュースをホットトピックとして選んだり、売上上位 10 件の商品を選んだりする場面です。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.1 &nbsp; ヒープ"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   まとめ","text":"","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>ヒープは完全二分木であり、条件の違いによって最大ヒープと最小ヒープに分けられる。最大（最小）ヒープの根の要素は最大値（最小値）である。</li> <li>優先度付きキューとは、取り出し時に優先度が考慮されるキューであり、通常はヒープを用いて実装される。</li> <li>ヒープの代表的な操作とそれに対応する時間計算量には、要素の挿入 \\(O(\\log n)\\)、根の要素の削除 \\(O(\\log n)\\)、根の要素へのアクセス \\(O(1)\\) などがある。</li> <li>完全二分木は配列で表現するのに非常に適しているため、通常は配列を使ってヒープを格納する。</li> <li>ヒープ化操作はヒープの性質を保つために用いられ、挿入操作と削除操作の両方で使用される。</li> <li>\\(n\\) 個の要素を入力してヒープを構築する時間計算量は \\(O(n)\\) まで最適化でき、非常に効率的である。</li> <li>Top-k は古典的なアルゴリズム問題であり、ヒープ構造を用いることで効率的に解くことができ、時間計算量は \\(O(n \\log k)\\) である。</li> </ul>","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：データ構造の「ヒープ」とメモリ管理の「ヒープ」は同じ概念ですか？</p> <p>両者は同じ概念ではなく、たまたまどちらも「ヒープ」と呼ばれているだけである。コンピュータシステムのメモリにおけるヒープは動的メモリ割り当ての一部であり、プログラムは実行時にこれを使ってデータを格納できる。プログラムは一定量のヒープメモリを要求し、オブジェクトや配列などの複雑な構造を保存できる。これらのデータが不要になったときは、メモリリークを防ぐためにそのメモリを解放する必要がある。スタックメモリと比べると、ヒープメモリの管理と使用にはより慎重さが求められ、不適切に扱うとメモリリークやダングリングポインタなどの問題を引き起こす可能性がある。</p>","path":["第 8 章 &nbsp; ヒープ","8.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-k 問題","text":"<p>Question</p> <p>長さ \\(n\\) の未整列配列 <code>nums</code> が与えられたとき、配列内で最大の \\(k\\) 個の要素を返してください。</p> <p>この問題について、まずは発想が比較的直接的な 2 つの解法を紹介し、その後でより効率の高いヒープ解法を紹介します。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#831","level":2,"title":"8.3.1   方法一：走査による選択","text":"<p>以下の図に示すように \\(k\\) 回の走査を行い、各ラウンドでそれぞれ第 \\(1\\)、\\(2\\)、\\(\\dots\\)、\\(k\\) 位の要素を取り出すことができます。時間計算量は \\(O(nk)\\) です。</p> <p>この方法は \\(k \\ll n\\) の場合にしか適していません。\\(k\\) が \\(n\\) にかなり近いと、時間計算量は \\(O(n^2)\\) に近づき、非常に時間がかかるためです。</p> <p></p> <p> 図 8-6   走査によって最大の k 個の要素を探す </p> <p>Tip</p> <p>\\(k = n\\) のとき、完全な昇順列を得ることができ、この場合は「選択ソート」アルゴリズムと等価になります。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#832","level":2,"title":"8.3.2   方法二：ソート","text":"<p>以下の図に示すように、まず配列 <code>nums</code> をソートし、その後で右端の \\(k\\) 個の要素を返すことができます。時間計算量は \\(O(n \\log n)\\) です。</p> <p>明らかに、この方法は必要以上の処理を行っています。なぜなら、必要なのは最大の \\(k\\) 個の要素を見つけることだけであり、他の要素をソートする必要はないからです。</p> <p></p> <p> 図 8-7   ソートによって最大の k 個の要素を探す </p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#833","level":2,"title":"8.3.3   方法三：ヒープ","text":"<p>ヒープを用いることで、Top-k 問題をより効率的に解くことができます。手順は以下の図のとおりです。</p> <ol> <li>最小ヒープを初期化し、そのヒープ頂点の要素が最小となるようにします。</li> <li>まず配列の先頭 \\(k\\) 個の要素を順にヒープへ挿入します。</li> <li>\\(k + 1\\) 番目の要素から開始し、現在の要素がヒープ頂点の要素より大きければ、ヒープ頂点の要素を取り出し、現在の要素をヒープへ挿入します。</li> <li>走査が完了した後、ヒープに保持されているのが最大の \\(k\\) 個の要素です。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 8-8   ヒープに基づいて最大の k 個の要素を探す </p> <p>サンプルコードは以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"ヒープに基づいて配列中の最大の k 個の要素を探す\"\"\"\n    # 最小ヒープを初期化\n    heap = []\n    # 配列の先頭 k 個の要素をヒープに追加\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i in range(k, len(nums)):\n        # 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // 最小ヒープを初期化\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.size(); i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // 最小ヒープを初期化\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // 最小ヒープを初期化\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; nums.Length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // 最小ヒープを初期化\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // 配列の先頭 k 個の要素をヒープに追加\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i := k; i &lt; len(nums); i++ {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // 最小ヒープを初期化し、先頭 k 個の要素でヒープを構築する\n    var heap = Heap(nums.prefix(k))\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for i in nums.indices.dropFirst(k) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* 要素をヒープに追加 */\nfunction pushMinHeap(maxHeap, val) {\n    // 要素を反転する\n    maxHeap.push(-val);\n}\n\n/* 要素をヒープから取り出す */\nfunction popMinHeap(maxHeap) {\n    // 要素を反転する\n    return -maxHeap.pop();\n}\n\n/* ヒープ先頭要素にアクセス */\nfunction peekMinHeap(maxHeap) {\n    // 要素を反転する\n    return -maxHeap.peek();\n}\n\n/* ヒープから要素を取り出す */\nfunction getMinHeap(maxHeap) {\n    // 要素を反転する\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunction topKHeap(nums, k) {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    const maxHeap = new MaxHeap([]);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (let i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // ヒープ内の要素を返す\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* 要素をヒープに追加 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // 要素を反転する\n    maxHeap.push(-val);\n}\n\n/* 要素をヒープから取り出す */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // 要素を反転する\n    return -maxHeap.pop();\n}\n\n/* ヒープ先頭要素にアクセス */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // 要素を反転する\n    return -maxHeap.peek();\n}\n\n/* ヒープから要素を取り出す */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // 要素を反転する\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    const maxHeap = new MaxHeap([]);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (let i = k; i &lt; nums.length; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // ヒープ内の要素を返す\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // 最小ヒープを初期化し、配列の先頭 k 個の要素をヒープに入れる\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // k+1 番目の要素から開始し、ヒープ長を k に保つ\n  for (int i = k; i &lt; nums.length; i++) {\n    // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap は最大ヒープであり、Reverse で要素の順序を反転することで最小ヒープを実現する\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // 配列の先頭 k 個の要素をヒープに追加\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for &amp;num in nums.iter().skip(k) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* 要素をヒープに追加 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // 要素を反転する\n    push(maxHeap, -val);\n}\n\n/* 要素をヒープから取り出す */\nint popMinHeap(MaxHeap *maxHeap) {\n    // 要素を反転する\n    return -pop(maxHeap);\n}\n\n/* ヒープ先頭要素にアクセス */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // 要素を反転する\n    return -peek(maxHeap);\n}\n\n/* ヒープから要素を取り出す */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // ヒープ内のすべての要素を反転して res 配列に格納\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* ヒープから要素を取り出す */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // ヒープ内のすべての要素を反転して res 配列に格納\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// ヒープに基づいて配列中の最大の k 個の要素を求める関数\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // 最小ヒープを初期化する\n    // 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (int i = k; i &lt; sizeNums; i++) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // メモリを解放する\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* ヒープに基づいて配列中の最大の k 個の要素を探す */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // 最小ヒープを初期化\n    val heap = PriorityQueue&lt;Int&gt;()\n    // 配列の先頭 k 個の要素をヒープに追加\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // k+1 番目の要素から開始し、ヒープ長を k に保つ\n    for (i in k..&lt;nums.size) {\n        // 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### ヒープに基づいて配列中の最大 k 個の要素を探す ###\ndef top_k_heap(nums, k)\n  # 最小ヒープを初期化する\n  # 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする\n  max_heap = MaxHeap.new([])\n\n  # 配列の先頭 k 個の要素をヒープに追加\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # k+1 番目の要素から開始し、ヒープ長を k に保つ\n  for i in k...nums.length\n    # 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>合計で \\(n\\) 回のヒープ挿入と取り出しを行い、ヒープの最大長は \\(k\\) であるため、時間計算量は \\(O(n \\log k)\\) です。この方法は非常に効率が高く、\\(k\\) が小さいときは時間計算量が \\(O(n)\\) に近づき、\\(k\\) が大きいときでも \\(O(n \\log n)\\) を超えることはありません。</p> <p>さらに、この方法は動的データストリームの利用シーンにも適しています。データが継続的に追加される場合でも、ヒープ内の要素を保ち続けることで、最大の \\(k\\) 個の要素を動的に更新できます。</p>","path":["第 8 章 &nbsp; ヒープ","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"はじめに","text":"<p>数年前、私は LeetCode 中国版で「剣指 Offer」シリーズの解説を共有し、多くの読者から励ましと支持をいただきました。読者との交流の中で、最もよく聞かれた質問の一つが「アルゴリズムをどう学び始めればよいか」でした。次第に、私はこの問題に強い関心を抱くようになりました。</p> <p>手探りでひたすら問題を解くことは、最も人気のある方法のようです。単純で、直接的で、しかも効果的です。しかし問題演習は「マインスイーパー」を遊ぶことに似ており、独学力の高い人は地雷を一つずつうまく取り除ける一方で、基礎が十分でない人は大きな痛手を受け、挫折の中で少しずつ後退してしまいがちです。教材を通読するのもよくある方法ですが、就職を目指す人にとっては、卒業論文、履歴書の提出、筆記試験や面接の準備ですでに大半の力を使い果たしており、分厚い本を読み込むことはしばしば困難な挑戦になってしまいます。</p> <p>もしあなたも同じような悩みを抱えているなら、この本があなたのもとに“たどり着いた”のは幸運なことです。本書は、この問いに対して私が示す答えです。たとえ最良の解ではなくても、少なくとも前向きな試みではあります。本書だけで直接内定を得られるわけではありませんが、データ構造とアルゴリズムの「知識地図」を探る手助けをし、さまざまな「地雷」の形や大きさ、分布を理解し、いろいろな「地雷除去の方法」を身につけられるよう導きます。こうした力があれば、問題演習や文献読解をより自在に進め、やがて完整な知識体系を築いていけると信じています。</p> <p>私はファインマン教授の言葉に深く賛同しています。「Knowledge isn't free. You have to pay attention.」この意味において、本書は完全に「無料」ではありません。本書のためにあなたが払ってくれる貴重な「注意」に応えるため、私はできる限りの力を尽くし、最大限の「注意」を注いで本書を書き上げます。</p> <p>私は自らの学識と力量の浅さをよく承知しています。本書の内容はある程度磨きをかけてきたものの、なお多くの誤りが残っているはずです。先生方、そして学習者の皆さまからのご批判とご指摘を心よりお願いいたします。</p> <p></p> Hello、アルゴリズム！ <p>コンピュータの登場は世界に大きな変革をもたらしました。高速な計算能力と優れたプログラム可能性によって、アルゴリズムの実行とデータ処理の理想的な媒体となったのです。ビデオゲームのリアルな映像、自動運転の知的な意思決定、AlphaGo の見事な対局、ChatGPT の自然な対話に至るまで、これらの応用はいずれもコンピュータ上でアルゴリズムが巧みに表現されたものです。</p> <p>実際には、コンピュータが誕生する以前から、アルゴリズムとデータ構造は世界のいたるところに存在していました。初期のアルゴリズムは比較的単純で、たとえば古代の数え方や道具作りの手順などがそれに当たります。文明の進歩とともに、アルゴリズムは次第により精緻で複雑なものになっていきました。匠の巧みな技から、生産力を解放する工業製品、さらには宇宙の運行を支配する科学法則に至るまで、ほとんどあらゆる平凡なもの、あるいは驚嘆すべきものの背後には、精妙なアルゴリズムの思想が潜んでいます。</p> <p>同様に、データ構造も至るところに存在します。社会ネットワークのような大きなものから地下鉄路線のような小さなものまで、多くのシステムは「グラフ」としてモデル化できます。国家のような大きな単位から家庭のような小さな単位まで、社会の主な組織形態には「木」の特徴があります。冬服は「スタック」のように、最初に着たものが最後に脱がれます。バドミントンシャトルの筒は「キュー」のように、一方から入れて他方から取り出します。辞書は「ハッシュテーブル」のようなもので、目的の見出し語を素早く探せます。</p> <p>本書は、わかりやすいアニメーション図解と実行可能なコード例を通じて、読者がアルゴリズムとデータ構造の核心概念を理解し、さらにプログラミングによってそれらを実装できるようになることを目指しています。そのうえで、本書は複雑な世界の中にあるアルゴリズムの生き生きとした現れを明らかにし、アルゴリズムの美しさを示そうとしています。本書があなたの助けになれば幸いです。</p>","path":["はじめに"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"第 1 章   アルゴリズム入門","text":"<p>Abstract</p> <p>一人の少女が軽やかに舞い、データと織り重なり合いながら、スカートの裾にはアルゴリズムの旋律がたなびいています。</p> <p>彼女はあなたをこの舞いへと誘います。その足取りに続いて、論理と美しさに満ちたアルゴリズムの世界へ踏み入りましょう。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","第 1 章 &nbsp; アルゴリズム入門"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"章の内容","text":"<ul> <li>1.1   アルゴリズムは至るところにある</li> <li>1.2   アルゴリズムとは</li> <li>1.3   まとめ</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","第 1 章 &nbsp; アルゴリズム入門"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   アルゴリズムは至るところにある","text":"<p>「アルゴリズム」という言葉を聞くと、自然に数学を思い浮かべます。しかし実際には、多くのアルゴリズムは複雑な数学を必要とせず、むしろ基本的な論理に依存しており、その論理は私たちの日常生活のいたるところで見られます。</p> <p>アルゴリズムを本格的に議論する前に、ひとつ面白い事実を共有しておきます。あなたはすでに知らず知らずのうちに多くのアルゴリズムを身につけ、それらを日常生活に応用することに慣れているのです。以下では、いくつかの具体例を挙げてこれを示します。</p> <p>例1：辞書を引く。辞書では、各漢字に対応するピンインがあり、辞書はピンインのアルファベット順に並んでいます。ピンインの先頭文字が \\(r\\) の字を探すと仮定すると、通常は次の図のような方法で行います。</p> <ol> <li>辞書をおよそ半分のところまで開き、そのページの先頭文字を確認し、先頭文字が \\(m\\) だとします。</li> <li>ピンインのアルファベット表では \\(r\\) は \\(m\\) の後にあるため、辞書の前半を除外し、探索範囲を後半に絞ります。</li> <li>ピンインの先頭文字が \\(r\\) のページを見つけるまで、手順 <code>1.</code> と手順 <code>2.</code> を繰り返します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 1-1   辞書を引く手順 </p> <p>辞書を引くという小学生の必須スキルは、実は有名な「二分探索」アルゴリズムそのものです。データ構造の観点では、辞書を整列済みの「配列」とみなせます。アルゴリズムの観点では、上記の一連の辞書引きの操作を「二分探索」とみなせます。</p> <p>例2：トランプを整理する。カードゲームをするとき、毎回手札のトランプを小さい順に並べ替える必要があります。その流れは次の図のとおりです。</p> <ol> <li>トランプを「整列済み」と「未整列」の2つの部分に分け、初期状態では一番左の1枚がすでに整列済みだとします。</li> <li>未整列部分から1枚のトランプを取り出し、整列済み部分の正しい位置に挿入します。完了すると、左端の2枚は整列済みになります。</li> <li>手順 <code>2.</code> を繰り返し、各ラウンドで未整列部分から1枚を整列済み部分へ挿入し、すべてのトランプが整列済みになるまで続けます。</li> </ol> <p></p> <p> 図 1-2   トランプを並べ替える手順 </p> <p>上記のトランプ整理の方法は、本質的には「挿入ソート」アルゴリズムです。これは小規模なデータ集合を処理する際に非常に効率的で、多くのプログラミング言語のソートライブラリ関数にも挿入ソートが使われています。</p> <p>例3：お釣りを出す。スーパーで \\(69\\) 元の商品を購入し、店員に \\(100\\) 元渡したとすると、店員は \\(31\\) 元のお釣りを返す必要があります。店員は自然に次の図のような考え方をします。</p> <ol> <li>選択肢は \\(31\\) 元より小さい額面の貨幣で、\\(1\\) 元、\\(5\\) 元、\\(10\\) 元、\\(20\\) 元があります。</li> <li>選択肢の中から最大の \\(20\\) 元を取り出すと、残りは \\(31 - 20 = 11\\) 元です。</li> <li>残りの選択肢の中から最大の \\(10\\) 元を取り出すと、残りは \\(11 - 10 = 1\\) 元です。</li> <li>残りの選択肢の中から最大の \\(1\\) 元を取り出すと、残りは \\(1 - 1 = 0\\) 元です。</li> <li>お釣りは完了し、内訳は \\(20 + 10 + 1 = 31\\) 元です。</li> </ol> <p></p> <p> 図 1-3   お釣りの過程 </p> <p>以上の手順では、各ステップでその時点で最善と思われる選択肢を取っています。つまり、できるだけ額面の大きい貨幣を使い、最終的に実行可能なお釣りの方案を得ています。データ構造とアルゴリズムの観点から見ると、この方法は本質的に「貪欲法」です。</p> <p>料理を一品作ることから星間航行に至るまで、ほとんどあらゆる問題の解決にアルゴリズムは欠かせません。コンピュータの登場によって、プログラミングを通じてデータ構造をメモリに格納し、さらにコードを書いて CPU や GPU にアルゴリズムを実行させることが可能になりました。こうして、生活の中の問題をコンピュータに移し、より効率的な方法でさまざまな複雑な問題を解決できるのです。</p> <p>Tip</p> <p>データ構造、アルゴリズム、配列、二分探索といった概念がまだ少し曖昧でも、そのまま読み進めてください。本書がデータ構造とアルゴリズムの知識の世界へと案内します。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.1 &nbsp; アルゴリズムは至るところにある"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   まとめ","text":"","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>アルゴリズムは日常生活の至る所にあり、決して手の届かない難解な知識ではありません。実際、私たちは気づかないうちに多くのアルゴリズムを身につけ、生活のさまざまな問題を解決しています。</li> <li>辞書を引く原理は二分探索アルゴリズムと一致しています。二分探索アルゴリズムは分割統治という重要なアルゴリズム思想を体現しています。</li> <li>トランプを整理する過程は挿入ソートアルゴリズムと非常によく似ています。挿入ソートアルゴリズムは小規模なデータ集合のソートに適しています。</li> <li>貨幣の釣り銭を求める手順の本質は貪欲アルゴリズムであり、各ステップでその時点で最善と思われる選択を取ります。</li> <li>アルゴリズムとは、限られた時間内に特定の問題を解決するための一連の命令または操作手順であり、データ構造とは、コンピュータ内でデータを組織し保存する方法です。</li> <li>データ構造とアルゴリズムは密接に結びついています。データ構造はアルゴリズムの土台であり、アルゴリズムはデータ構造に生命を吹き込みます。</li> <li>データ構造とアルゴリズムは積み木の組み立てにたとえることができます。積み木はデータを表し、積み木の形や接続方法などはデータ構造を表し、積み木を組み立てる手順がアルゴリズムに対応します。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：プログラマーとして、私は日常業務でアルゴリズムを使って問題を解決したことがありません。よく使うアルゴリズムはプログラミング言語にすべてカプセル化されており、そのまま使えばよいです。これは、仕事上の問題がまだアルゴリズムを必要とする段階に達していないことを意味するのでしょうか？</p> <p>具体的な仕事のスキルを武術の「型」にたとえるなら、基礎科目はむしろ「内功」に近いものです。</p> <p>私は、アルゴリズム（およびその他の基礎科目）を学ぶ意義は、仕事でそれをゼロから実装することではなく、学んだ知識に基づいて問題解決の際に専門的な反応や判断を下せるようになり、その結果として仕事全体の品質を高めることにあると考えています。簡単な例を挙げると、どのプログラミング言語にもソート関数が組み込まれています。</p> <ul> <li>もしデータ構造とアルゴリズムを学んでいなければ、どんなデータが与えられても、そのソート関数に任せてしまうかもしれません。問題なく動き、性能も悪くなく、一見すると特に問題はありません。</li> <li>しかしアルゴリズムを学んでいれば、組み込みのソート関数の時間計算量が \\(O(n \\log n)\\) であることを知っています。さらに、与えられたデータが固定桁数の整数（例えば学籍番号）であれば、より効率の高い「基数ソート」を使って、時間計算量を \\(O(nk)\\) に下げることができます。ここで \\(k\\) は桁数です。データ量が非常に大きい場合、節約できた実行時間は大きな価値を生みます（コスト削減、体験向上など）。</li> </ul> <p>工学分野では、多くの問題で最適解に到達することは難しく、少なくない問題は「だいたい」解決されているにすぎません。問題の難しさは、一方では問題そのものの性質に依存し、他方ではそれを観測する人の知識の蓄積にも依存します。知識が充実し、経験が豊富であるほど、問題分析はより深くなり、問題はより洗練された形で解決できるようになります。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   アルゴリズムとは","text":"","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   アルゴリズムの定義","text":"<p>アルゴリズム（algorithm）とは、限られた時間内に特定の問題を解決するための一連の命令または操作手順であり、次のような特徴を持ちます。</p> <ul> <li>問題が明確であり、入力と出力の定義がはっきりしています。</li> <li>実行可能であり、有限の手順、時間、メモリ空間で完了できます。</li> <li>各手順の意味が確定しており、同じ入力と実行条件では常に同じ出力になります。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   データ構造の定義","text":"<p>データ構造（data structure）とは、データを整理して保存する方式であり、データの内容、データ間の関係、データの操作方法を含み、次のような設計目標があります。</p> <ul> <li>使用する空間をできるだけ少なくし、コンピュータのメモリを節約します。</li> <li>データの操作をできるだけ高速にし、アクセス、追加、削除、更新などを含みます。</li> <li>簡潔なデータ表現と論理情報を提供し、アルゴリズムが効率よく動作できるようにします。</li> </ul> <p>データ構造の設計はトレードオフに満ちた過程です。ある面を改善したい場合、別の面で妥協が必要になることがよくあります。以下に 2 つの例を示します。</p> <ul> <li>連結リストは配列に比べてデータの追加や削除がしやすい一方で、データアクセス速度を犠牲にしています。</li> <li>グラフは連結リストに比べてより豊富な論理情報を提供しますが、より大きなメモリ空間を必要とします。</li> </ul>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   データ構造とアルゴリズムの関係","text":"<p>以下の図のように、データ構造とアルゴリズムは高度に関連し、密接に結び付いており、具体的には次の 3 つの点に表れます。</p> <ul> <li>データ構造はアルゴリズムの土台です。データ構造はアルゴリズムに対して、構造化して格納されたデータと、そのデータを操作する方法を提供します。</li> <li>アルゴリズムはデータ構造に命を吹き込みます。データ構造そのものはデータ情報を保存するだけであり、アルゴリズムと組み合わせて初めて特定の問題を解決できます。</li> <li>アルゴリズムは通常、異なるデータ構造に基づいて実装できますが、実行効率が大きく異なる場合があり、適切なデータ構造を選ぶことが重要です。</li> </ul> <p></p> <p> 図 1-4   データ構造とアルゴリズムの関係 </p> <p>データ構造とアルゴリズムは、以下の図に示す組み立てブロックのようなものです。1 セットのブロックには多くの部品が含まれるだけでなく、詳しい組み立て説明書も付いています。説明書に従って一歩ずつ操作すれば、精巧なブロック模型を組み立てられます。</p> <p></p> <p> 図 1-5   組み立てブロック </p> <p>両者の詳細な対応関係を次の表に示します。</p> <p> 表 1-1   データ構造とアルゴリズムを組み立てブロックにたとえる </p> データ構造とアルゴリズム 組み立てブロック 入力データ まだ組み立てていないブロック データ構造 ブロックの構成形式。形状、大きさ、接続方法などを含む アルゴリズム ブロックを目標の形に組み上げる一連の操作手順 出力データ ブロック模型 <p>特筆すべき点として、データ構造とアルゴリズムはプログラミング言語から独立しています。だからこそ、本書では複数のプログラミング言語に基づく実装を提供できます。</p> <p>慣習的な略称</p> <p>実際の議論では、私たちは通常「データ構造とアルゴリズム」を略して「アルゴリズム」と呼びます。たとえば広く知られている LeetCode のアルゴリズム問題は、実際にはデータ構造とアルゴリズムの両方の知識を同時に問うています。</p>","path":["第 1 章 &nbsp; アルゴリズムを知る","1.2 &nbsp; アルゴリズムとは"],"tags":[]},{"location":"chapter_paperbook/","level":1,"title":"紙の書籍","text":"<p>長い時間をかけて磨き上げた『Hello アルゴリズム』の紙の書籍が、ついに発売されました！今の気持ちは、次の一節で表せます：</p> <p>風を追い月を追って立ち止まるな、草原の果てには春の山がある。</p> <p></p> <p>以下の動画では紙の書籍を紹介しており、私の考えもいくつか含まれています：</p> <ul> <li>データ構造とアルゴリズムを学ぶ重要性。</li> <li>なぜ紙の書籍で Python を選んだのか。</li> <li>知識共有に対する理解。</li> </ul> <p>新人 UP 主ですので、ぜひ応援と高評価・チャンネル登録をお願いします～ありがとうございます！</p> <p>紙の書籍のスナップショット：</p> <p></p> <p></p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_2","level":2,"title":"長所と短所","text":"<p>紙の書籍ならではの魅力を、簡単にまとめると次のとおりです：</p> <ul> <li>フルカラー印刷を採用し、本書の「アニメーション図解」の強みをそのまま活かせます。</li> <li>紙の素材にもこだわり、色彩を高い精度で再現しつつ、紙の書籍ならではの質感も残しています。</li> <li>紙の書籍版は Web 版よりも書式が整っており、たとえば図中の数式には斜体を用いています。</li> <li>価格を上げずに、マインドマップの折り込みページやしおりも付属します。</li> <li>紙の書籍、Web 版、PDF 版で内容は同期しており、自由に切り替えて読めます。</li> </ul> <p>Tip</p> <p>紙の書籍と Web 版を同期させるのは難しいため、細かな違いが生じる場合があります。ご了承ください！</p> <p>もちろん、購入前に検討しておくべき点もいくつかあります：</p> <ul> <li>Python 言語を使用しているため、あなたの主言語と合わない可能性があります（Python は疑似コードと捉え、考え方の理解を重視してください）。</li> <li>フルカラー印刷は図解やコードの読みやすさを大きく高める一方で、白黒印刷より価格はやや高くなります。</li> </ul> <p>Tip</p> <p>「印刷品質」と「価格」は、アルゴリズムにおける「時間効率」と「空間効率」のようなもので、両立は容易ではありません。そして私は、「印刷品質」は「時間効率」に当たるため、より重視すべきだと考えています。</p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_3","level":2,"title":"購入リンク","text":"<p>紙の書籍に興味があれば、ぜひ一冊ご検討ください。新刊の 5 割引を用意していただきましたので、こちらのリンクをご覧いただくか、以下の QR コードをスキャンしてください：</p> <p></p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_paperbook/#_4","level":2,"title":"あとがき","text":"<p>当初、私は紙の書籍出版に必要な作業量を甘く見ていて、オープンソースプロジェクトをきちんと保守していれば、紙の書籍版も何らかの自動化手段で生成できると思っていました。実際には、紙の書籍の制作フローとオープンソースプロジェクトの更新の仕組みには大きな違いがあり、その間をつなぐには多くの追加作業が必要でした。</p> <p>一冊の本の初稿と出版基準を満たす完成稿との間には、なお大きな隔たりがあります。出版社（企画、編集、デザイン、マーケティングなど）と著者が力を合わせ、長い時間をかけて磨き上げていく必要があります。ここで、図霊の企画編集者である王軍花さん、そして人民郵電出版社と図霊コミュニティで本書の出版工程に携わってくださったすべての皆さまに感謝いたします！</p> <p>この本があなたの助けになれば幸いです！</p>","path":["紙の書籍"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"第 0 章   はじめに","text":"<p>Abstract</p> <p>アルゴリズムは美しい交響曲のようであり、コードの一行一行が旋律のように流れていきます。</p> <p>この本があなたの心の中でそっと響き、独自で深い旋律を残してくれることを願っています。</p>","path":["第 0 章 &nbsp; 前書き","第 0 章 &nbsp; はじめに"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"章の内容","text":"<ul> <li>0.1   本書について</li> <li>0.2   本書の使い方</li> <li>0.3   まとめ</li> </ul>","path":["第 0 章 &nbsp; 前書き","第 0 章 &nbsp; はじめに"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   本書について","text":"<p>本プロジェクトは、オープンソースで無料、かつ初心者にやさしいデータ構造とアルゴリズムの入門書を作ることを目的としています。</p> <ul> <li>全編でアニメーション付きの図解を採用し、内容は明快で理解しやすく、学習曲線もなだらかで、初心者がデータ構造とアルゴリズムの知識地図を探求できるよう導きます。</li> <li>ソースコードはワンクリックで実行でき、読者が演習を通じてプログラミング能力を高め、アルゴリズムの動作原理とデータ構造の内部実装を理解する助けとなります。</li> <li>読者どうしの助け合いによる学習を推奨しており、コメント欄で質問や見解を共有し、対話と議論を通じてともに成長していくことを歓迎します。</li> </ul>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   対象読者","text":"<p>もしあなたがアルゴリズム初心者で、これまでアルゴリズムに触れたことがない、あるいはすでに多少の問題演習の経験はあるものの、データ構造とアルゴリズムについてはまだ曖昧な理解にとどまり、できるかできないかの間を行き来しているなら、本書はまさにあなたのために作られています！</p> <p>もしすでに一定量の問題演習を積み、ほとんどの問題パターンに慣れているなら、本書はアルゴリズム知識体系の復習と整理に役立ちます。リポジトリのソースコードは「問題演習ツール集」や「アルゴリズム辞典」として活用できます。</p> <p>もしあなたがアルゴリズムの「達人」なら、貴重なご提案をいただけることを楽しみにしています。あるいは一緒に執筆に参加してください。</p> <p>前提条件</p> <p>少なくともいずれか一つの言語でのプログラミング基礎があり、簡単なコードを読んだり書いたりできる必要があります。</p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   内容構成","text":"<p>本書の主な内容は以下の図のとおりです。</p> <ul> <li>計算量解析：データ構造とアルゴリズムを評価する観点と方法。時間計算量と空間計算量の求め方、代表的な種類、例など。</li> <li>データ構造：基本データ型とデータ構造の分類方法。配列、連結リスト、スタック、キュー、ハッシュテーブル、木、ヒープ、グラフなどのデータ構造の定義、長所と短所、基本操作、代表的な種類、典型的な応用、実装方法など。</li> <li>アルゴリズム：探索、ソート、分割統治、バックトラッキング、動的計画法、貪欲法などのアルゴリズムの定義、長所と短所、効率、適用場面、問題を解く手順、例題など。</li> </ul> <p></p> <p> 図 0-1   本書の主な内容 </p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   謝辞","text":"<p>本書は、オープンソースコミュニティの多くの貢献者による共同の努力のもとで、継続的に改善されています。時間と労力を注いでくださったすべての執筆者の皆さんに感謝します。お名前は次のとおりです（GitHub により自動生成された順序）：krahets、coderonion、Gonglja、nuomi1、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、rongyi、msk397、gvenusleo、khoaxuantu、rivertwilight、K3v123、gyt95、zhuoqinyue、yuelinxin、Zuoxun、mingXta、Phoenix0415、FangYuan33、GN-Yu、longsizhuo、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、pengchzn、QiLOL、magentaqin、hello-ikun、JoseHung、qualifier1024、thomasq0、sunshinesDL、L-Super、Guanngxu、Transmigration-zhou、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、Shyam-Chen、theNefelibatas、longranger2、codeberg-user、xiongsp、JeffersonHuang、prinpal、seven1240、Wonderdch、malone6、xiaomiusa87、gaofer、bluebean-cloud、a16su、SamJin98、hongyun-robot、nanlei、XiaChuerwu、yd-j、iron-irax、mgisr、steventimes、junminhong、heshuyue、danny900714、MolDuM、Nigh、Dr-XYZ、XC-Zero、reeswell、PXG-XPG、NI-SW、Horbin-Magician、Enlightenus、YangXuanyi、beatrix-chan、DullSword、xjr7670、jiaxianhua、qq909244296、iStig、boloboloda、hts0000、gledfish、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、linyejoe2、liuxjerry、llql1211、fbigm、echo1937、szu17dmy、dshlstarr、Yucao-cy、coderlef、czruby、bongbongbakudan、beintentional、ZongYangL、ZhongYuuu、ZhongGuanbin、hezhizhen、linzeyan、ZJKung、luluxia、xb534、ztkuaikuai、yw-1021、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yanedie、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、sslmj2020、smilelsb、siqyka、selear、sdshaoda、Xi-Row、popozhu、nuquist19、noobcodemaker、XiaoK29、chadyi、lyl625760、lucaswangdev、0130w、shanghai-Jerry、EJackYang、Javesun99、eltociear、lipusheng、KNChiu、BlindTerran、ShiMaRing、lovelock、FreddieLi、FloranceYeh、fanchenggang、gltianwen、goerll、nedchu、curly210102、CuB3y0nd、KraHsu、CarrotDLaw、youshaoXG、bubble9um、Asashishi、Asa0oo0o0o、fanenr、eagleanurag、akshiterate、52coder、foursevenlove、KorsChen、GaochaoZhu、hopkings2008、yang-le、realwujing、Evilrabbit520、Umer-Jahangir、Turing-1024-Lee、Suremotoo、paoxiaomooo、Chieko-Seren、Allen-Scai、ymmmas、Risuntsy、Richard-Zhang1019、RafaelCaso、qingpeng9802、primexiao、Urbaner3、zhongfq、nidhoggfgg、MwumLi、CreatorMetaSky、martinx、ZnYang2018、hugtyftg、logan-qiu、psychelzh、Keynman、KeiichiKasai と KawaiiAsh。</p> <p>本書のコードレビューは coderonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、khoaxuantu、krahets、night-cruise、nuomi1、Reanon と rongyi によって行われました（アルファベット順）。彼らが費やしてくれた時間と労力に感謝します。各言語のコードの規範性と統一性が保たれているのは、まさに彼らのおかげです。</p> <p>本書の繁体字中国語版は Shyam-Chen と Dr-XYZ がレビューし、英語版は yuelinxin、K3v123、QiLOL、Phoenix0415、SamJin98、yanedie、RafaelCaso、pengchzn、thomasq0 と magentaqin がレビューし、日本語版は eltociear がレビューしました。彼らの継続的な貢献があってこそ、本書はより幅広い読者に届けられています。感謝いたします。</p> <p>本書の ePub 電子書籍生成ツールは zhongfq によって開発されました。彼の貢献に感謝します。読者により自由な読書方法を提供してくれました。</p> <p>本書の執筆過程で、私は多くの方々の助けを得ました。</p> <ul> <li>会社での私の指導教員である李汐博士に感謝します。ある対話の中で「すぐに行動しよう」と励ましてくださり、この本を書く決意を固めることができました；</li> <li>私の恋人であり、本書の最初の読者でもある泡泡に感謝します。アルゴリズム初心者の視点から多くの貴重な提案をしてくれたおかげで、本書はより初心者に適したものになりました；</li> <li>腾宝、琦宝、飞宝が本書に創造性あふれる名前を付けてくれたことに感謝します。みんなが最初のコード行「Hello World!」を書いた美しい記憶を呼び起こしてくれました；</li> <li>校铨が知的財産の面で専門的な支援をしてくれたことに感謝します。これは本オープンソース書籍の改善に重要な役割を果たしました；</li> <li>苏潼が本書の美しい表紙と logo をデザインし、私の完璧主義につき合って何度も辛抱強く修正してくれたことに感謝します；</li> <li>@squidfunk が組版に関する助言を提供してくれたこと、そして彼が開発したオープンソースのドキュメントテーマ Material-for-MkDocs に感謝します。</li> </ul> <p>執筆の過程で、私はデータ構造とアルゴリズムに関する多くの教材や記事を読みました。これらの作品は本書に優れた手本を与え、本書の内容の正確性と品質を支えてくれました。ここに、すべての先生方と先人たちの卓越した貢献に感謝します！</p> <p>本書は手と頭を同時に使う学習方法を提唱しています。この点で私は『手を動かして学ぶ深層学習』から大きな啓発を受けました。ここで読者の皆さんにこの優れた著作を強くお勧めします。</p> <p>心から両親に感謝します。いつも支え励ましてくれたからこそ、私はこの興味深いことに取り組む機会を得ることができました。</p>","path":["第 0 章 &nbsp; 前書き","0.1 &nbsp; 本書について"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   本書の使い方","text":"<p>Tip</p> <p>最適な読書体験を得るために、本節の内容を一通り読むことをおすすめします。</p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   文章スタイルの約束","text":"<ul> <li>見出しの後に <code>*</code> が付いているのは選読章で、内容は比較的難しめです。時間が限られている場合は、先に読み飛ばしてもかまいません。</li> <li>専門用語は太字（紙書籍版と PDF 版）または下線付き（Web 版）で示します。たとえば配列（array）のようなものです。文献を読む際に役立つため、覚えておくことをおすすめします。</li> <li>重要な内容やまとめの文は 太字 で示します。これらの文章には特に注意してください。</li> <li>特定の意味を持つ語句には“引用符”を付け、曖昧さを避けます。</li> <li>プログラミング言語ごとに用語が一致しない場合、本書では Python を基準とします。たとえば、“空”を表すのに <code>None</code> を使います。</li> <li>本書では、よりコンパクトなレイアウトのために、言語ごとのコメント規約を一部省略しています。コメントは主に3種類あります。タイトルコメント、内容コメント、複数行コメントです。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"タイトルコメント。関数、クラス、テストケースなどを示すために使います\"\"\"\n\n# 内容コメント。コードを詳しく説明するために使います\n\n\"\"\"\n複数行\nコメント\n\"\"\"\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n// 複数行\n// コメント\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>/* タイトルコメント。関数、クラス、テストケースなどを示すために使います */\n\n// 内容コメント。コードを詳しく説明するために使います\n\n/**\n * 複数行\n * コメント\n */\n</code></pre> <pre><code>### タイトルコメント。関数、クラス、テストケースなどを示すために使います ###\n\n# 内容コメント。コードを詳しく説明するために使います\n\n# 複数行\n# コメント\n</code></pre>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   アニメーション図解で効率よく学ぶ","text":"<p>文字と比べて、動画や画像は情報密度と構造化の度合いが高く、理解しやすいものです。本書では、重要かつ難解な知識は主にアニメーションによる図解で示し、文章は説明と補足を担います。</p> <p>本書を読んでいて、ある内容に以下の図のようなアニメーション図解がある場合は、図を主、文章を従として、両方を合わせて理解してください。</p> <p></p> <p> 図 0-2   アニメーション図解の例 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   コード実践で理解を深める","text":"<p>本書のサンプルコードは GitHub リポジトリ で管理されています。以下の図のように、ソースコードにはテストケースが付いており、ワンクリックで実行できます。</p> <p>時間に余裕があれば、コードを見ながら自分で一度書いてみることをおすすめします。学習時間が限られている場合でも、少なくともすべてのコードに目を通し、実行してください。</p> <p>コードを読むのに比べて、書く過程のほうが得られるものは多いものです。手を動かしてこそ、本当に学んだことになります。</p> <p></p> <p> 図 0-3   コード実行例 </p> <p>コードを実行する前準備は主に3ステップです。</p> <p>第1ステップ：ローカルのプログラミング環境をインストールする。付録のチュートリアルを参照してインストールしてください。すでにインストール済みであれば、この手順は省略できます。</p> <p>第2ステップ：コードリポジトリをクローンまたはダウンロードする。 GitHub リポジトリ にアクセスしてください。すでに Git をインストールしている場合は、次のコマンドでこのリポジトリをクローンできます：</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>もちろん、以下の図に示す場所で“Download ZIP”ボタンをクリックし、コードの圧縮ファイルを直接ダウンロードしてローカルで展開することもできます。</p> <p></p> <p> 図 0-4   リポジトリのクローンとコードのダウンロード </p> <p>第3ステップ：ソースコードを実行する。以下の図のように、上部にファイル名が表示されているコードブロックについては、リポジトリの <code>codes</code> フォルダ内に対応するソースコードファイルがあります。ソースコードファイルはワンクリックで実行できるため、不要なデバッグ時間を減らし、学習内容に集中できます。</p> <p></p> <p> 図 0-5   コードブロックと対応するソースコードファイル </p> <p>ローカルでコードを実行するだけでなく、Web 版では Python コードの可視化実行にも対応しています（pythontutor を利用）。以下の図のように、コードブロックの下にある“可視化実行”をクリックすると表示を展開し、アルゴリズムコードの実行過程を観察できます。また、“全画面表示”をクリックすると、より見やすい閲覧体験が得られます。</p> <p></p> <p> 図 0-6   Python コードの可視化実行 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   質問と議論を通じてともに成長する","text":"<p>本書を読んでいて、理解できていない知識点を安易に読み飛ばさないでください。コメント欄で気軽に質問してください。私と仲間たちが誠意をもって回答し、通常は 2 日以内に返信します。</p> <p>以下の図のように、Web 版では各章の下部にコメント欄があります。ぜひコメント欄の内容にも目を通してください。一方では、みんなが直面した問題を知ることで知識の抜けを補い、より深い思考を促せます。もう一方では、ほかの仲間の質問にも積極的に答え、見解を共有し、互いの成長を助けてほしいと思います。</p> <p></p> <p> 図 0-7   コメント欄の例 </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   アルゴリズム学習ロードマップ","text":"<p>全体として見ると、データ構造とアルゴリズムの学習過程は 3 つの段階に分けられます。</p> <ol> <li>第 1 段階：アルゴリズム入門。さまざまなデータ構造の特徴と使い方に慣れ、異なるアルゴリズムの原理、流れ、用途、効率などを学ぶ必要があります。</li> <li>第 2 段階：アルゴリズム問題を解く。まずは人気の高い問題から取り組み、少なくとも 100 問は蓄積して、主流のアルゴリズム問題に慣れることをおすすめします。最初のうちは、“知識の忘却”が課題になるかもしれませんが、心配はいりません。これはごく自然なことです。“エビングハウスの忘却曲線”に沿って問題を復習すれば、通常は 3～5 回繰り返すことでしっかり記憶に定着します。おすすめの問題リストと学習計画は、この GitHub リポジトリ を参照してください。</li> <li>第 3 段階：知識体系を構築する。学習面では、アルゴリズムの連載記事、解法フレームワーク、教材などを読むことで、知識体系を継続的に充実させられます。問題演習の面では、トピック別分類、1 問多解、1 解多題といった発展的な戦略も試せます。関連する学習ノウハウは各コミュニティで見つけられます。</li> </ol> <p>以下の図のように、本書の内容は主に“第 1 段階”を扱っており、第 2 段階と第 3 段階の学習をより効率的に進める助けとなることを目的としています。</p> <p></p> <p> 図 0-8   アルゴリズム学習ロードマップ </p>","path":["第 0 章 &nbsp; 前書き","0.2 &nbsp; 本書の使い方"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   まとめ","text":"","path":["第 0 章 &nbsp; 前書き","0.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   重要ポイントの振り返り","text":"<ul> <li>本書の主な対象読者はアルゴリズム初学者です。すでにある程度の基礎がある場合でも、本書はアルゴリズム知識を体系的に振り返る助けとなり、書中のソースコードは「問題演習用ツール集」としても利用できます。</li> <li>本書の内容は主に計算量解析、データ構造、アルゴリズムの三部からなり、この分野の大部分のテーマを網羅しています。</li> <li>アルゴリズム初心者にとって、学習初期の段階で入門書を読むことは非常に重要であり、多くの遠回りを避けられます。</li> <li>本書のアニメーション図解は通常、重要な知識や難しい知識を紹介するために用いられます。本書を読む際は、これらの内容により多く注意を払うべきです。</li> <li>実践はプログラミングを学ぶ最良の方法です。ソースコードを実行し、実際に自分でコードを書くことを強く勧めます。</li> <li>本書のWeb版の各章にはコメント欄が設けられており、疑問や見解をいつでも共有することを歓迎します。</li> </ul>","path":["第 0 章 &nbsp; 前書き","0.3 &nbsp; まとめ"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"参考文献","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] 严蔚敏. データ構造（C 言語版）.</p> <p>[5] 邓俊辉. データ構造（C++ 言語版、第3版）.</p> <p>[6] マーク・アレン・ワイス著，陈越訳. データ構造とアルゴリズム解析：Java言語による記述（第3版）.</p> <p>[7] 程杰. データ構造の話.</p> <p>[8] 王争. データ構造とアルゴリズムの美.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["参考文献"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"第 10 章   探索","text":"<p>Abstract</p> <p>探索は未知の冒険であり、私たちは神秘的な空間の隅々まで歩き回る必要があるかもしれず、あるいは素早く目標を特定できるかもしれません。</p> <p>この探索の旅において、すべての探求が思いもよらなかった答えをもたらすかもしれません。</p>","path":["第 10 章 &nbsp; 探索"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"章の内容","text":"<ul> <li>10.1   二分探索</li> <li>10.2   二分探索の挿入位置</li> <li>10.3   二分探索の境界</li> <li>10.4   ハッシュによる最適化戦略</li> <li>10.5   探索アルゴリズム再考</li> <li>10.6   まとめ</li> </ul>","path":["第 10 章 &nbsp; 探索"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   二分探索","text":"<p>二分探索（binary search）は分割統治法に基づく効率的な探索アルゴリズムです。データが整列済みである性質を利用し、各ラウンドで探索範囲を半分に縮小し、目標要素を見つけるか探索区間が空になるまで続けます。</p> <p>Question</p> <p>長さ \\(n\\) の配列 <code>nums</code> が与えられます。要素は小さい順に並んでおり、重複しません。要素 <code>target</code> がこの配列内にある場合はそのインデックスを返し、含まれない場合は \\(-1\\) を返してください。例を次の図に示します。</p> <p></p> <p> 図 10-1   二分探索の例 </p> <p>次の図に示すように、まずポインタ \\(i = 0\\) と \\(j = n - 1\\) を初期化し、それぞれ配列の先頭要素と末尾要素を指すようにして、探索区間 \\([0, n - 1]\\) を表します。角括弧は閉区間を表し、境界値自体を含むことに注意してください。</p> <p>次に、以下の 2 つの手順を繰り返します。</p> <ol> <li>中央のインデックス \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) を計算します。ここで \\(\\lfloor \\: \\rfloor\\) は切り捨てを表します。</li> <li><code>nums[m]</code> と <code>target</code> の大小関係を判定し、次の 3 つの場合に分かれます。<ol> <li><code>nums[m] &lt; target</code> のとき、<code>target</code> は区間 \\([m + 1, j]\\) にあるため、\\(i = m + 1\\) を実行します。</li> <li><code>nums[m] &gt; target</code> のとき、<code>target</code> は区間 \\([i, m - 1]\\) にあるため、\\(j = m - 1\\) を実行します。</li> <li><code>nums[m] = target</code> のとき、<code>target</code> が見つかったので、インデックス \\(m\\) を返します。</li> </ol> </li> </ol> <p>配列に目標要素が含まれない場合、探索区間は最終的に空まで縮小されます。このとき \\(-1\\) を返します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 10-2   二分探索の流れ </p> <p>注意すべき点として、\\(i\\) と \\(j\\) はどちらも <code>int</code> 型であるため、\\(i + j\\) が <code>int</code> 型の範囲を超える可能性があります。大きな数によるオーバーフローを避けるため、通常は式 \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) を用いて中点を計算します。</p> <p>コードは次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索（両閉区間）\"\"\"\n    # 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    i, j = 0, len(nums) - 1\n    # ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j:\n        # 理論上、Python の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # この場合、target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # この場合、target は区間 [i, m-1] にある\n        else:\n            return m  # 目標要素が見つかったらそのインデックスを返す\n    return -1  # 目標要素が見つからなければ -1 を返す\n</code></pre> binary_search.cpp<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.size() - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(int[] nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分探索（両閉区間） */\nint BinarySearch(int[] nums, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = nums.Length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // 中点インデックス m を計算\n        if (nums[m] &lt; target)      // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else                       // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分探索（両閉区間） */\nfunc binarySearch(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    i, j := 0, len(nums)-1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    for i &lt;= j {\n        m := i + (j-i)/2      // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分探索（両閉区間） */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分探索（両閉区間） */\nfunction binarySearch(nums, target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let i = 0,\n        j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        // 中点インデックス `m` を計算し、`parseInt()` で切り捨てる\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else return m; // 目標要素が見つかったらそのインデックスを返す\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分探索（両閉区間） */\nfunction binarySearch(nums: number[], target: number): number {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let i = 0,\n        j = nums.length - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        // 中点インデックス m を計算\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    return -1; // 目標要素が見つからなければ -1 を返す\n}\n</code></pre> binary_search.dart<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n  int i = 0, j = nums.length - 1;\n  // ループし、探索区間が空になったら終了する（i &gt; j で空）\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      // この場合、target は区間 [m+1, j] にある\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // この場合、target は区間 [i, m-1] にある\n      j = m - 1;\n    } else {\n      // 目標要素が見つかったらそのインデックスを返す\n      return m;\n    }\n  }\n  // 目標要素が見つからなければ -1 を返す\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分探索（両閉区間） */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分探索（両閉区間） */\nint binarySearch(int *nums, int len, int target) {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    int i = 0, j = len - 1;\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j] にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分探索（両閉区間） */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n    var i = 0\n    var j = nums.size - 1\n    // ループし、探索区間が空になったら終了する（i &gt; j で空）\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j] にある\n            i = m + 1\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m-1] にある\n            j = m - 1\n        else  // 目標要素が見つかったらそのインデックスを返す\n            return m\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分探索（両閉区間） ###\ndef binary_search(nums, target)\n  # 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す\n  i, j = 0, nums.length - 1\n\n  # ループし、探索区間が空になったら終了する（i &gt; j で空）\n  while i &lt;= j\n    # 理論上、Ruby の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない\n    m = (i + j) / 2   # 中点インデックス m を計算\n\n    if nums[m] &lt; target\n      i = m + 1 # この場合、target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # この場合、target は区間 [i, m-1] にある\n    else\n      return m  # 目標要素が見つかったらそのインデックスを返す\n    end\n  end\n\n  -1  # 目標要素が見つからなければ -1 を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>時間計算量は \\(O(\\log n)\\) ：二分探索のループでは各ラウンドで区間が半分になるため、ループ回数は \\(\\log_2 n\\) です。</p> <p>空間計算量は \\(O(1)\\) ：ポインタ \\(i\\) と \\(j\\) に必要なのは定数サイズの空間だけです。</p>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   区間の表し方","text":"<p>上記の両閉区間のほかに、一般的な区間表現として「左閉右開」区間があり、\\([0, n)\\) と定義されます。つまり左端は含み、右端は含みません。この表現では、区間 \\([i, j)\\) は \\(i = j\\) のとき空です。</p> <p>この表現に基づいて、同じ機能を持つ二分探索アルゴリズムを実装できます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索（左閉右開区間）\"\"\"\n    # 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    i, j = 0, len(nums)\n    # ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # この場合、target は区間 [m+1, j) にある\n        elif nums[m] &gt; target:\n            j = m  # この場合、target は区間 [i, m) にある\n        else:\n            return m  # 目標要素が見つかったらそのインデックスを返す\n    return -1  # 目標要素が見つからなければ -1 を返す\n</code></pre> binary_search.cpp<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.size();\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(int[] nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分探索（左閉右開区間） */\nint BinarySearchLCRO(int[] nums, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = nums.Length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // 中点インデックス m を計算\n        if (nums[m] &lt; target)      // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else                       // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分探索（左閉右開区間） */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    i, j := 0, len(nums)\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    for i &lt; j {\n        m := i + (j-i)/2      // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m) にある\n            j = m\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分探索（左閉右開区間） */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target { // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        } else if nums[m] &gt; target { // この場合、target は区間 [i, m) にある\n            j = m\n        } else { // 目標要素が見つかったらそのインデックスを返す\n            return m\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分探索（左閉右開区間） */\nfunction binarySearchLCRO(nums, target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let i = 0,\n        j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        // 中点インデックス `m` を計算し、`parseInt()` で切り捨てる\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        // 目標要素が見つかったらそのインデックスを返す\n        else return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分探索（左閉右開区間） */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let i = 0,\n        j = nums.length;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        // 中点インデックス m を計算\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    return -1; // 目標要素が見つからなければ -1 を返す\n}\n</code></pre> binary_search.dart<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n  int i = 0, j = nums.length;\n  // ループし、探索区間が空になったら終了する（i = j で空）\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      // この場合、target は区間 [m+1, j) にある\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // この場合、target は区間 [i, m) にある\n      j = m;\n    } else {\n      // 目標要素が見つかったらそのインデックスを返す\n      return m;\n    }\n  }\n  // 目標要素が見つからなければ -1 を返す\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分探索（左閉右開区間） */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while i &lt; j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // この場合、target は区間 [i, m) にある\n            j = m;\n        } else {\n            // 目標要素が見つかったらそのインデックスを返す\n            return m;\n        }\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分探索（左閉右開区間） */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    int i = 0, j = len;\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target)    // この場合、target は区間 [m+1, j) にある\n            i = m + 1;\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m;\n        else // 目標要素が見つかったらそのインデックスを返す\n            return m;\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分探索（左閉右開区間） */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n    var i = 0\n    var j = nums.size\n    // ループし、探索区間が空になったら終了する（i = j で空）\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) // この場合、target は区間 [m+1, j) にある\n            i = m + 1\n        else if (nums[m] &gt; target) // この場合、target は区間 [i, m) にある\n            j = m\n        else  // 目標要素が見つかったらそのインデックスを返す\n            return m\n    }\n    // 目標要素が見つからなければ -1 を返す\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分探索（左閉右開区間） ###\ndef binary_search_lcro(nums, target)\n  # 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す\n  i, j = 0, nums.length\n\n  # ループし、探索区間が空になったら終了する（i = j で空）\n  while i &lt; j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # この場合、target は区間 [m+1, j) にある\n    elsif nums[m] &gt; target\n      j = m - 1 # この場合、target は区間 [i, m) にある\n    else\n      return m  # 目標要素が見つかったらそのインデックスを返す\n    end\n  end\n\n  -1  # 目標要素が見つからなければ -1 を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>次の図に示すように、2 種類の区間表現では、二分探索アルゴリズムの初期化、ループ条件、区間の縮小操作がそれぞれ異なります。</p> <p>「両閉区間」の表現では左右の境界がどちらも閉区間として定義されるため、ポインタ \\(i\\) とポインタ \\(j\\) による区間縮小の操作も対称になります。このほうがミスをしにくいため、一般には「両閉区間」の書き方を推奨します。</p> <p></p> <p> 図 10-3   2 種類の区間定義 </p>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   利点と限界","text":"<p>二分探索は時間と空間の両面で優れた性能を持ちます。</p> <ul> <li>二分探索は時間効率が高いです。データ量が大きい場合、対数時間計算量は大きな優位性を持ちます。たとえば、データサイズ \\(n = 2^{20}\\) のとき、線形探索では \\(2^{20} = 1048576\\) 回のループが必要ですが、二分探索では \\(\\log_2 2^{20} = 20\\) 回で済みます。</li> <li>二分探索は追加の空間を必要としません。追加領域を要する探索アルゴリズム（たとえばハッシュ探索）と比べて、二分探索はより省メモリです。</li> </ul> <p>しかし、二分探索があらゆる状況に適しているわけではなく、主な理由は次のとおりです。</p> <ul> <li>二分探索は整列済みデータにしか適用できません。入力データが無秩序な場合、二分探索を使うためだけにソートするのは割に合いません。ソートアルゴリズムの時間計算量は通常 \\(O(n \\log n)\\) であり、線形探索や二分探索よりも高いからです。要素を頻繁に挿入する場面では、配列の整列性を保つために特定位置へ挿入する必要があり、その時間計算量は \\(O(n)\\) と高コストです。</li> <li>二分探索は配列にしか適していません。二分探索では要素へ飛び飛びにアクセスする必要がありますが、連結リストでそのようなアクセスを行う効率は低いため、連結リストやそれを基に実装されたデータ構造には向きません。</li> <li>データ量が小さい場合は線形探索のほうが高性能です。線形探索では各ラウンドで 1 回の比較だけで済みますが、二分探索では 1 回の加算、1 回の除算、1 ~ 3 回の比較、1 回の加算（減算）が必要で、合計 4 ~ 6 個の基本操作になります。したがって、データ量 \\(n\\) が小さいときは、線形探索のほうがかえって速くなります。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.1 &nbsp; 二分探索"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   二分探索の境界","text":"","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   左端境界を探す","text":"<p>Question</p> <p>長さ \\(n\\) のソート済み配列 <code>nums</code> が与えられ、その中には重複要素が含まれる可能性があります。配列内で最も左にある要素 <code>target</code> のインデックスを返してください。配列にこの要素が含まれない場合は、\\(-1\\) を返します。</p> <p>二分探索で挿入位置を求める方法を思い出すと、探索完了後に \\(i\\) は最も左にある <code>target</code> を指します。したがって、挿入位置を探すことの本質は、最も左にある <code>target</code> のインデックスを探すことです。</p> <p>挿入位置を探す関数を使って左端境界を求めることを考えます。なお、配列に <code>target</code> が含まれない場合があり、そのときは次の 2 つの結果が起こりえます。</p> <ul> <li>挿入位置のインデックス \\(i\\) が範囲外になる。</li> <li>要素 <code>nums[i]</code> が <code>target</code> と等しくない。</li> </ul> <p>上の 2 つの状況に当てはまる場合は、直接 \\(-1\\) を返せば十分です。コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"最も左の target を二分探索\"\"\"\n    # target の挿入位置を探すのと等価\n    i = binary_search_insertion(nums, target)\n    # target が見つからなければ、-1 を返す\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # target が見つかったら、インデックス i を返す\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 最も左の target を二分探索 */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 最も左の target を二分探索 */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // target の挿入位置を探すのと等価\n    i := binarySearchInsertion(nums, target)\n    // target が見つからなければ、-1 を返す\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 最も左の target を二分探索 */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // target の挿入位置を探すのと等価\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // target が見つからなければ、-1 を返す\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* 最も左の target を二分探索 */\nfunction binarySearchLeftEdge(nums, target) {\n    // target の挿入位置を探すのと等価\n    const i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 最も左の target を二分探索 */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // target の挿入位置を探すのと等価\n    const i = binarySearchInsertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // target の挿入位置を探すのと等価\n  int i = binarySearchInsertion(nums, target);\n  // target が見つからなければ、-1 を返す\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // target が見つかったら、インデックス i を返す\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 最も左の target を二分探索 */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // target の挿入位置を探すのと等価\n    let i = binary_search_insertion(nums, target);\n    // target が見つからなければ、-1 を返す\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* 最も左の target を二分探索 */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // target の挿入位置を探すのと等価\n    int i = binarySearchInsertion(nums, numSize, target);\n    // target が見つからなければ、-1 を返す\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス i を返す\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 最も左の target を二分探索 */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // target の挿入位置を探すのと等価\n    val i = binarySearchInsertion(nums, target)\n    // target が見つからなければ、-1 を返す\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // target が見つかったら、インデックス i を返す\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### target の最左位置を二分探索 ###\ndef binary_search_left_edge(nums, target)\n  # target の挿入位置を探すのと等価\n  i = binary_search_insertion(nums, target)\n\n  # target が見つからなければ、-1 を返す\n  return -1 if i == nums.length || nums[i] != target\n\n  i # target が見つかったら、インデックス i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   右端境界を探す","text":"<p>では、最も右にある <code>target</code> はどのように探せるでしょうか。最も直接的な方法はコードを修正し、<code>nums[m] == target</code> の場合のポインタの縮小操作を置き換えることです。ここではコードを省略するので、興味があれば自分で実装してみてください。</p> <p>ここでは、より巧妙な 2 つの方法を紹介します。</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   左端境界探索を再利用する","text":"<p>実際には、最も左の要素を探す関数を利用して最も右の要素を探せます。具体的には、最も右にある <code>target</code> を探すことを、最も左にある <code>target + 1</code> を探すことに変換します。</p> <p>下図のように、探索完了後、ポインタ \\(i\\) は最も左にある <code>target + 1</code>（存在する場合）を指し、\\(j\\) は最も右にある <code>target</code> を指します。したがって \\(j\\) を返せばよいです。</p> <p></p> <p> 図 10-7   右端境界の探索を左端境界の探索に変換する </p> <p>返される挿入位置は \\(i\\) なので、そこから \\(1\\) を引いて \\(j\\) を得る必要があることに注意してください：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"最も右の target を二分探索\"\"\"\n    # 最左の target + 1 を探す問題に変換する\n    i = binary_search_insertion(nums, target + 1)\n    # j は最も右の target を指し、i は target より大きい最初の要素を指す\n    j = i - 1\n    # target が見つからなければ、-1 を返す\n    if j == -1 or nums[j] != target:\n        return -1\n    # target が見つかったら、インデックス j を返す\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(int[] nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 最も右の target を二分探索 */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 最も右の target を二分探索 */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // 最左の target + 1 を探す問題に変換する\n    i := binarySearchInsertion(nums, target+1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    j := i - 1\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 最も右の target を二分探索 */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // 最左の target + 1 を探す問題に変換する\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    let j = i - 1\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* 最も右の target を二分探索 */\nfunction binarySearchRightEdge(nums, target) {\n    // 最左の target + 1 を探す問題に変換する\n    const i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    const j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 最も右の target を二分探索 */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 最左の target + 1 を探す問題に変換する\n    const i = binarySearchInsertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    const j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // 最左の target + 1 を探す問題に変換する\n  int i = binarySearchInsertion(nums, target + 1);\n  // j は最も右の target を指し、i は target より大きい最初の要素を指す\n  int j = i - 1;\n  // target が見つからなければ、-1 を返す\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // target が見つかったら、インデックス j を返す\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 最も右の target を二分探索 */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 最左の target + 1 を探す問題に変換する\n    let i = binary_search_insertion(nums, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    let j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* 最も右の target を二分探索 */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // 最左の target + 1 を探す問題に変換する\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    int j = i - 1;\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // target が見つかったら、インデックス j を返す\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 最も右の target を二分探索 */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // 最左の target + 1 を探す問題に変換する\n    val i = binarySearchInsertion(nums, target + 1)\n    // j は最も右の target を指し、i は target より大きい最初の要素を指す\n    val j = i - 1\n    // target が見つからなければ、-1 を返す\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // target が見つかったら、インデックス j を返す\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### target の最右位置を二分探索 ###\ndef binary_search_right_edge(nums, target)\n  # 最左の target + 1 を探す問題に変換する\n  i = binary_search_insertion(nums, target + 1)\n\n  # j は最も右の target を指し、i は target より大きい最初の要素を指す\n  j = i - 1\n\n  # target が見つからなければ、-1 を返す\n  return -1 if j == -1 || nums[j] != target\n\n  j # target が見つかったら、インデックス j を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   要素探索に変換する","text":"<p>配列に <code>target</code> が含まれない場合、最終的に \\(i\\) と \\(j\\) はそれぞれ <code>target</code> より大きい最初の要素と、<code>target</code> より小さい最初の要素を指すことになります。</p> <p>したがって、下図のように、配列中に存在しない要素を構成して、それを使って左右の境界を探せます。</p> <ul> <li>最も左にある <code>target</code> の探索：<code>target - 0.5</code> を探すことに変換でき、ポインタ \\(i\\) を返します。</li> <li>最も右にある <code>target</code> の探索：<code>target + 0.5</code> を探すことに変換でき、ポインタ \\(j\\) を返します。</li> </ul> <p></p> <p> 図 10-8   境界の探索を要素の探索に変換する </p> <p>ここではコードを省略しますが、次の 2 点に注意が必要です。</p> <ul> <li>与えられた配列には小数が含まれないため、等しい場合をどう処理するかを気にする必要はありません。</li> <li>この方法では小数を導入するため、関数内の変数 <code>target</code> を浮動小数点数型に変更する必要があります（Python は変更不要です）。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.3 &nbsp; 二分探索の境界"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   二分探索の挿入位置","text":"<p>二分探索は目標要素の検索だけでなく、目標要素の挿入位置を探すなど、多くの派生問題の解決にも利用できます。</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   重複要素がない場合","text":"<p>Question</p> <p>長さ \\(n\\) の整列済み配列 <code>nums</code> と要素 <code>target</code> が与えられます。配列には重複要素は存在しません。ここで <code>target</code> を配列 <code>nums</code> に挿入し、その順序を保ちます。配列中にすでに要素 <code>target</code> が存在する場合は、その左側に挿入します。挿入後の配列における <code>target</code> のインデックスを返してください。例を以下の図に示します。</p> <p></p> <p> 図 10-4   二分探索の挿入位置の例データ </p> <p>前節の二分探索コードを再利用したい場合は、次の二つの問題に答える必要があります。</p> <p>問題 1：配列に <code>target</code> が含まれる場合、挿入位置のインデックスはその要素のインデックスですか？</p> <p>問題では <code>target</code> を等しい要素の左側に挿入するよう求めているため、新しく挿入された <code>target</code> は元の <code>target</code> の位置に入ります。つまり、配列に <code>target</code> が含まれる場合、挿入位置のインデックスはその <code>target</code> のインデックスです。</p> <p>問題 2：配列に <code>target</code> が存在しない場合、挿入位置はどの要素のインデックスですか？</p> <p>二分探索の過程をさらに考えると、<code>nums[m] &lt; target</code> のときは \\(i\\) が移動します。これは、ポインタ \\(i\\) が <code>target</code> 以上の要素へ近づいていることを意味します。同様に、ポインタ \\(j\\) は常に <code>target</code> 以下の要素へ近づいています。</p> <p>したがって二分探索の終了時には、\\(i\\) は最初の <code>target</code> より大きい要素を指し、\\(j\\) は最初の <code>target</code> より小さい要素を指します。よって、配列に <code>target</code> が含まれない場合、挿入インデックスは \\(i\\) です。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索で挿入位置を探す（重複要素なし）\"\"\"\n    i, j = 0, len(nums) - 1  # 両閉区間 [0, n-1] を初期化\n    while i &lt;= j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # target は区間 [i, m-1] にある\n        else:\n            return m  # target が見つかったら、挿入位置 m を返す\n    # target が見つからなければ、挿入位置 i を返す\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 中点インデックス m を計算\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target は区間 [i, m-1] にある\n            j = m - 1\n        } else {\n            // target が見つかったら、挿入位置 m を返す\n            return m\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if nums[m] &gt; target {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            return m // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      i = m + 1; // target は区間 [m+1, j] にある\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target は区間 [i, m-1] にある\n    } else {\n      return m; // target が見つかったら、挿入位置 m を返す\n    }\n  }\n  // target が見つからなければ、挿入位置 i を返す\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 両閉区間 [0, n-1] を初期化\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m;\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            return m; // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分探索で挿入位置を探す（重複要素なし） */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            return m // target が見つかったら、挿入位置 m を返す\n        }\n    }\n    // target が見つからなければ、挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分探索の挿入位置（重複要素なし） ###\ndef binary_search_insertion_simple(nums, target)\n  # 両閉区間 [0, n-1] を初期化\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # target は区間 [i, m-1] にある\n    else\n      return m  # target が見つかったら、挿入位置 m を返す\n    end\n  end\n\n  i # target が見つからなければ、挿入位置 i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   重複要素がある場合","text":"<p>Question</p> <p>前問を踏まえ、配列には重複要素が含まれる可能性があるものとし、それ以外の条件は変わりません。</p> <p>配列中に複数の <code>target</code> が存在する場合、通常の二分探索ではそのうち一つの <code>target</code> のインデックスしか返せず、その要素の左側と右側にあといくつ <code>target</code> があるかは分かりません。</p> <p>問題では目標要素を最も左に挿入する必要があるため、配列中で最も左にある <code>target</code> のインデックスを探す必要があります。まずは以下の図に示す手順で実現することを考えます。</p> <ol> <li>二分探索を実行し、任意の <code>target</code> のインデックスを得て、これを \\(k\\) とします。</li> <li>インデックス \\(k\\) から始めて左へ線形探索し、最も左の <code>target</code> を見つけたら返します。</li> </ol> <p></p> <p> 図 10-5   線形探索による重複要素の挿入位置 </p> <p>この方法は使用できますが、線形探索を含むため、時間計算量は \\(O(n)\\) です。配列中に重複した <code>target</code> が多い場合、この方法の効率は低くなります。</p> <p>次に、二分探索のコードを拡張することを考えます。以下の図に示すように、全体の流れは変えず、各反復でまず中点インデックス \\(m\\) を計算し、その後 <code>target</code> と <code>nums[m]</code> の大小関係を判定して、次のいくつかの状況に分けます。</p> <ul> <li><code>nums[m] &lt; target</code> または <code>nums[m] &gt; target</code> のときは、まだ <code>target</code> を見つけていないことを意味するため、通常の二分探索と同じ区間縮小を行い、ポインタ \\(i\\) と \\(j\\) を <code>target</code> に近づけます。</li> <li><code>nums[m] == target</code> のときは、<code>target</code> より小さい要素が区間 \\([i, m - 1]\\) にあることを意味するため、\\(j = m - 1\\) として区間を縮小し、ポインタ \\(j\\) を <code>target</code> より小さい要素に近づけます。</li> </ul> <p>ループ終了後、\\(i\\) は最も左の <code>target</code> を指し、\\(j\\) は最初の <code>target</code> より小さい要素を指すため、インデックス \\(i\\) が挿入位置です。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 10-6   重複要素に対する二分探索の挿入位置の手順 </p> <p>以下のコードを観察すると、分岐 <code>nums[m] &gt; target</code> と <code>nums[m] == target</code> の処理は同じであるため、両者はまとめることができます。</p> <p>それでも、判定条件を分けたままにしておくことは可能であり、そのほうがロジックがより明確で、可読性も高くなります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分探索で挿入位置を探す（重複要素あり）\"\"\"\n    i, j = 0, len(nums) - 1  # 両閉区間 [0, n-1] を初期化\n    while i &lt;= j:\n        m = (i + j) // 2  # 中点インデックス m を計算\n        if nums[m] &lt; target:\n            i = m + 1  # target は区間 [m+1, j] にある\n        elif nums[m] &gt; target:\n            j = m - 1  # target は区間 [i, m-1] にある\n        else:\n            j = m - 1  # target より小さい最初の要素は区間 [i, m-1] にある\n    # 挿入位置 i を返す\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // 両閉区間 [0, n-1] を初期化\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 中点インデックス m を計算\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target は区間 [m+1, j] にある\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target は区間 [i, m-1] にある\n            j = m - 1\n        } else {\n            // target より小さい最初の要素は区間 [i, m-1] にある\n            j = m - 1\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // 両閉区間 [0, n-1] を初期化\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 中点インデックス m を計算\n        if nums[m] &lt; target {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if nums[m] &gt; target {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1 // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 中点インデックス m を計算\n    if (nums[m] &lt; target) {\n      i = m + 1; // target は区間 [m+1, j] にある\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target は区間 [i, m-1] にある\n    } else {\n      j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n    }\n  }\n  // 挿入位置 i を返す\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 両閉区間 [0, n-1] を初期化\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 中点インデックス m を計算\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1; // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分探索で挿入位置を探す（重複要素あり） */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 両閉区間 [0, n-1] を初期化\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 中点インデックス m を計算\n        if (nums[m] &lt; target) {\n            i = m + 1 // target は区間 [m+1, j] にある\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target は区間 [i, m-1] にある\n        } else {\n            j = m - 1 // target より小さい最初の要素は区間 [i, m-1] にある\n        }\n    }\n    // 挿入位置 i を返す\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分探索の挿入位置（重複要素あり） ###\ndef binary_search_insertion(nums, target)\n  # 両閉区間 [0, n-1] を初期化\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 中点インデックス m を計算\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target は区間 [m+1, j] にある\n    elsif nums[m] &gt; target\n      j = m - 1 # target は区間 [i, m-1] にある\n    else\n      j = m - 1 # target より小さい最初の要素は区間 [i, m-1] にある\n    end\n  end\n\n  i # 挿入位置 i を返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>Tip</p> <p>本節のコードはすべて「両閉区間」の書き方です。興味のある読者は「左閉右開」の書き方を自分で実装してみてください。</p> <p>要するに、二分探索とはポインタ \\(i\\) と \\(j\\) にそれぞれ探索目標を設定することにほかなりません。目標は具体的な要素（たとえば <code>target</code>）である場合もあれば、要素の範囲（たとえば <code>target</code> より小さい要素）である場合もあります。</p> <p>繰り返される二分のループの中で、ポインタ \\(i\\) と \\(j\\) はどちらも事前に定めた目標へ徐々に近づいていきます。最終的に、それらは答えを見つけるか、境界を越えたところで停止します。</p>","path":["第 10 章 &nbsp; 探索","10.2 &nbsp; 二分探索の挿入位置"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   ハッシュによる最適化戦略","text":"<p>アルゴリズムの問題では，線形探索をハッシュ探索に置き換えることでアルゴリズムの時間計算量を下げることがよくあります。ここでは，あるアルゴリズム問題を通じて理解を深めましょう。</p> <p>Question</p> <p>整数配列 <code>nums</code> と目標要素 <code>target</code> が与えられたとき，配列内から和が <code>target</code> となる 2 つの要素を探索し，それらの配列インデックスを返してください。任意の 1 つの解を返せば十分です。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   線形探索：時間と引き換えに空間を節約","text":"<p>考えられるすべての組み合わせを直接走査することを考えます。次の図に示すように，2 重ループを開始し，各ラウンドで 2 つの整数の和が <code>target</code> であるかを判定します。そうであれば，それらのインデックスを返します。</p> <p></p> <p> 図 10-9   線形探索で 2 数の和を求める </p> <p>コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法 1：総当たり列挙\"\"\"\n    # 2重ループのため、時間計算量は O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法 1：総当たり列挙 */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法 1：総当たり列挙 */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法 1：総当たり列挙 */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法 1：総当たり列挙 */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // 2重ループのため、時間計算量は O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法 1：総当たり列挙 */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // 2重ループのため、時間計算量は O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法 1：総当たり列挙 */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法 1：総当たり列挙 */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // 2重ループのため、時間計算量は O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法1: 総当たり列挙 */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 2重ループのため、時間計算量は O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法 1：総当たり列挙 */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // 2重ループのため、時間計算量は O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 方法 1：総当たり列挙 */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法 1：総当たり列挙 */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 2重ループのため、時間計算量は O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法1：総当たり列挙 ###\ndef two_sum_brute_force(nums, target)\n  # 2重ループのため、時間計算量は O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>この方法の時間計算量は \\(O(n^2)\\) ，空間計算量は \\(O(1)\\) であり，大規模データでは非常に時間がかかります。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042","level":2,"title":"10.4.2   ハッシュ探索：空間と引き換えに時間を節約","text":"<p>ハッシュテーブルを利用し，キーと値をそれぞれ配列要素と要素のインデックスにします。配列をループで走査し，各ラウンドで次の図に示す手順を実行します。</p> <ol> <li>数値 <code>target - nums[i]</code> がハッシュテーブル内にあるかを判定します。あれば，この 2 つの要素のインデックスを直接返します。</li> <li>キーと値の組 <code>nums[i]</code> とインデックス <code>i</code> をハッシュテーブルに追加します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> 図 10-10   補助ハッシュテーブルで 2 数の和を求める </p> <p>実装コードは次のとおりで，単一ループだけで済みます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法 2：補助ハッシュテーブル\"\"\"\n    # 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    dic = {}\n    # 単一ループで、時間計算量は O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法 2：補助ハッシュテーブル */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法 2：補助ハッシュテーブル */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法 2：補助ハッシュテーブル */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // 単一ループで、時間計算量は O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    hashTable := map[int]int{}\n    // 単一ループで、時間計算量は O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    var dic: [Int: Int] = [:]\n    // 単一ループで、時間計算量は O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunction twoSumHashTable(nums, target) {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let m = {};\n    // 単一ループで、時間計算量は O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法 2：補助ハッシュテーブル */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // 単一ループで、時間計算量は O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法2: 補助ハッシュテーブル */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // 単一ループで、時間計算量は O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法 2：補助ハッシュテーブル */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    let mut dic = HashMap::new();\n    // 単一ループで、時間計算量は O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* ハッシュテーブル */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // uthash.h を用いて実装\n} HashTable;\n\n/* ハッシュテーブルを検索する */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* ハッシュテーブルに要素を挿入する */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* 方法 2：補助ハッシュテーブル */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法 2：補助ハッシュテーブル */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 補助ハッシュテーブルを使用し、空間計算量は O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // 単一ループで、時間計算量は O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法2：補助ハッシュテーブル ###\ndef two_sum_hash_table(nums, target)\n  # 補助ハッシュテーブルを使用し、空間計算量は O(n)\n  dic = {}\n  # 単一ループで、時間計算量は O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>この方法ではハッシュ探索によって時間計算量を \\(O(n^2)\\) から \\(O(n)\\) に下げ，実行効率を大幅に向上させます。</p> <p>追加のハッシュテーブルを維持する必要があるため，空間計算量は \\(O(n)\\) です。それでも，この方法は全体として時間と空間の効率のバランスがより良く，本問の最適解です。</p>","path":["第 10 章 &nbsp; 探索","10.4 &nbsp; ハッシュによる最適化戦略"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   探索アルゴリズム再考","text":"<p>探索アルゴリズム（searching algorithm）は、データ構造（配列、連結リスト、木、グラフなど）の中から、特定の条件を満たす 1 つまたは複数の要素を探索するために用いられます。</p> <p>探索アルゴリズムは、実装の考え方に応じて次の 2 種類に分けられます。</p> <ul> <li>データ構造を走査して目標要素を特定する方法。配列、連結リスト、木、グラフの走査などがこれに当たります。</li> <li>データの構成やデータに含まれる事前情報を利用して、要素を効率よく探す方法。二分探索、ハッシュ探索、二分探索木による探索などがこれに当たります。</li> </ul> <p>これらのトピックはすでに前の章で扱っているため、探索アルゴリズムは私たちにとって見慣れたものです。本節では、より体系的な視点から探索アルゴリズムをあらためて見直します。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   総当たり探索","text":"<p>総当たり探索は、データ構造の各要素を順に調べて目標要素を特定します。</p> <ul> <li>“線形探索”は配列や連結リストなどの線形データ構造に適しています。データ構造の一端から始めて、要素を 1 つずつ調べ、目標要素が見つかるか、もう一方の端に達しても見つからないまで続けます。</li> <li>“幅優先探索”と“深さ優先探索”は、グラフと木における 2 つの走査戦略です。幅優先探索は初期ノードから始めて層ごとに探索し、近いところから遠いところへ各ノードを訪れます。深さ優先探索は初期ノードから始めて 1 本の経路を最後までたどり、その後でバックトラックしてほかの経路を試し、データ構造全体を走査し終えるまで続けます。</li> </ul> <p>総当たり探索の利点は、単純で汎用性が高く、**データの前処理や追加のデータ構造を必要としない**ことです。</p> <p>しかし、この種のアルゴリズムの時間計算量は \\(O(n)\\) です。ここで \\(n\\) は要素数であり、そのためデータ量が大きい場合は性能が低くなります。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   適応的な探索","text":"<p>適応的な探索は、データが持つ固有の性質（整列性など）を利用して探索過程を最適化し、目標要素をより効率よく特定します。</p> <ul> <li>“二分探索”は、データの順序性を利用して効率的な探索を行う方法で、配列にしか適用できません。</li> <li>“ハッシュ探索”は、ハッシュ表を用いて探索対象のデータと目標データをキーと値の対応にし、問い合わせ操作を実現します。</li> <li>“木探索”は、特定の木構造（たとえば二分探索木）の中で、ノード値の比較に基づいて不要なノードをすばやく除外し、目標要素を特定します。</li> </ul> <p>この種のアルゴリズムの利点は効率が高く、**時間計算量が \\(O(\\log n)\\) あるいは \\(O(1)\\) に達する**ことです。</p> <p>しかし、これらのアルゴリズムを使うには、たいていデータの前処理が必要です。たとえば、二分探索では事前に配列をソートする必要があり、ハッシュ探索と木探索では追加のデータ構造が必要です。これらのデータ構造を維持するにも、追加の時間と空間のコストがかかります。</p> <p>Tip</p> <p>適応的な探索アルゴリズムは、しばしば検索アルゴリズムとも呼ばれ、主に特定のデータ構造の中で目標要素を高速に取得するために用いられます。</p>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   探索手法の選択","text":"<p>大きさ \\(n\\) のデータ集合が与えられたとき、線形探索、二分探索、木探索、ハッシュ探索など、さまざまな方法で目標要素を探索できます。各手法の動作原理を下図に示します。</p> <p></p> <p> 図 10-11   複数の探索戦略 </p> <p>上記のいくつかの手法について、操作効率と特性を次の表に示します。</p> <p> 表 10-1   探索アルゴリズムの効率比較 </p> 線形探索 二分探索 木探索 ハッシュ探索 要素探索 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) 要素挿入 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 要素削除 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 追加領域 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) データ前処理 / ソート \\(O(n \\log n)\\) 木構築 \\(O(n \\log n)\\) ハッシュ表構築 \\(O(n)\\) データの順序性 なし あり あり なし <p>探索アルゴリズムの選択は、規模、探索性能の要求、データの問い合わせ頻度や更新頻度などにも左右されます。</p> <p>線形探索</p> <ul> <li>汎用性が高く、データの前処理をまったく必要としません。データを 1 回だけ問い合わせればよい場合、ほか 3 つの手法では前処理にかかる時間のほうが、線形探索そのものより長くなることがあります。</li> <li>規模の小さいデータに適しています。この場合、時間計算量が効率に与える影響は比較的小さいです。</li> <li>データ更新頻度が高い場面に適しています。この手法では、データに対する追加の保守が不要だからです。</li> </ul> <p>二分探索</p> <ul> <li>大規模データに適しており、効率が安定しています。最悪時間計算量は \\(O(\\log n)\\) です。</li> <li>データ量が大きすぎる場合には向きません。配列の格納には連続したメモリ領域が必要だからです。</li> <li>頻繁な挿入・削除がある場面には向きません。整列配列を維持するコストが高いためです。</li> </ul> <p>ハッシュ探索</p> <ul> <li>問い合わせ性能への要求が高い場面に適しており、平均時間計算量は \\(O(1)\\) です。</li> <li>順序付きデータや範囲探索が必要な場面には向きません。ハッシュ表ではデータの順序性を維持できないからです。</li> <li>ハッシュ関数とハッシュ衝突処理戦略への依存度が高く、性能劣化のリスクが大きいです。</li> <li>データ量が大きすぎる場合には向きません。ハッシュ表は衝突をできるだけ減らして良好な問い合わせ性能を出すために、追加の空間を必要とするからです。</li> </ul> <p>木探索</p> <ul> <li>巨大データに適しています。木ノードはメモリ上に分散して格納されるためです。</li> <li>順序付きデータの維持や範囲探索が必要な場面に適しています。</li> <li>ノードの挿入・削除を続ける過程で、二分探索木は偏ることがあり、時間計算量は \\(O(n)\\) まで劣化する可能性があります。</li> <li>AVL 木や赤黒木を使えば、各種操作を \\(O(\\log n)\\) の効率で安定して実行できますが、木の平衡を保つ処理による追加コストが発生します。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.5 &nbsp; 探索アルゴリズム再考"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   まとめ","text":"","path":["第 10 章 &nbsp; 探索","10.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>二分探索はデータの順序性に依存し、ループによって探索区間を半分ずつ縮小しながら探索を行う。入力データがソート済みであることを前提とし、配列または配列ベースで実装されたデータ構造にのみ適用できる。</li> <li>総当たり探索はデータ構造を走査してデータを特定する。線形探索は配列と連結リストに適しており、幅優先探索と深さ優先探索はグラフと木に適している。この種のアルゴリズムは汎用性が高く、データの前処理を必要としないが、時間計算量 \\(O(n)\\) は高い。</li> <li>ハッシュ探索、木探索、二分探索は高効率な探索手法であり、特定のデータ構造内で目的の要素を高速に特定できる。この種のアルゴリズムは効率が高く、時間計算量は \\(O(\\log n)\\) あるいは \\(O(1)\\) に達するが、通常は追加のデータ構造を必要とする。</li> <li>実際には、データ規模、探索性能の要件、データの問い合わせ頻度や更新頻度などの要因を具体的に分析し、そのうえで適切な探索手法を選択する必要がある。</li> <li>線形探索は小規模または頻繁に更新されるデータに適している。二分探索は大規模でソート済みのデータに適している。ハッシュ探索は問い合わせ効率への要求が高く、範囲検索を必要としないデータに適している。木探索は順序の維持と範囲検索のサポートが必要な大規模動的データに適している。</li> <li>ハッシュ探索で線形探索を置き換えることは、実行時間を最適化するための一般的な戦略であり、時間計算量を \\(O(n)\\) から \\(O(1)\\) へと下げられる。</li> </ul>","path":["第 10 章 &nbsp; 探索","10.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"第 11 章   ソート","text":"<p>Abstract</p> <p>ソートは、混沌を秩序へと変える魔法の鍵のようなものであり、データをより効率的に理解し処理することを可能にします。</p> <p>単純な昇順であれ、複雑な分類配列であれ、ソートはデータの調和のとれた美しさを私たちに示してくれます。</p>","path":["第 11 章 &nbsp; ソート"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"章の内容","text":"<ul> <li>11.1   ソートアルゴリズム</li> <li>11.2   選択ソート</li> <li>11.3   バブルソート</li> <li>11.4   挿入ソート</li> <li>11.5   クイックソート</li> <li>11.6   マージソート</li> <li>11.7   ヒープソート</li> <li>11.8   バケットソート</li> <li>11.9   計数ソート</li> <li>11.10   基数ソート</li> <li>11.11   まとめ</li> </ul>","path":["第 11 章 &nbsp; ソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   バブルソート","text":"<p>バブルソート（bubble sort）は、隣接する要素を繰り返し比較して交換することで整列を行います。この過程が泡のように下から上へ浮かび上がることから、バブルソートと呼ばれます。</p> <p>次の図に示すように、バブル処理は要素の交換操作によってシミュレートできます。配列の最も左の端から右へ走査し、隣接する要素の大小を順に比較して、「左要素 &gt; 右要素」であれば両者を交換します。走査が終わると、最大の要素は配列の最も右端へ移動します。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-4   要素の交換操作でバブル処理をシミュレート </p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   アルゴリズムの流れ","text":"<p>配列の長さを \\(n\\) とすると、バブルソートの手順は次の図のとおりです。</p> <ol> <li>まず、\\(n\\) 個の要素に対して「バブル処理」を行い、配列中の最大要素を正しい位置へ交換します。</li> <li>次に、残りの \\(n - 1\\) 個の要素に対して「バブル処理」を行い、2 番目に大きい要素を正しい位置へ交換します。</li> <li>このようにして、\\(n - 1\\) 回の「バブル処理」を終えると、大きいほうから \\(n - 1\\) 個の要素がすべて正しい位置へ交換されます。</li> <li>残った 1 つの要素は必ず最小要素なので、並べ替える必要はなく、これで配列のソートが完了します。</li> </ol> <p></p> <p> 図 11-5   バブルソートの流れ </p> <p>コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"バブルソート\"\"\"\n    n = len(nums)\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(n - 1, 0, -1):\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* バブルソート */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換する\n                // ここでは std::swap() 関数を使用する\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* バブルソート */\nvoid bubbleSort(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* バブルソート */\nvoid BubbleSort(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* バブルソート */\nfunc bubbleSort(nums []int) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* バブルソート */\nfunc bubbleSort(nums: inout [Int]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* バブルソート */\nfunction bubbleSort(nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* バブルソート */\nfunction bubbleSort(nums: number[]): void {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* バブルソート */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // 外側のループ：未ソート区間は [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* バブルソート */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* バブルソート */\nvoid bubbleSort(int nums[], int size) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* バブルソート */\nfun bubbleSort(nums: IntArray) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### バブルソート ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   効率の最適化","text":"<p>ある回の「バブル処理」で交換操作が一度も行われなければ、配列はすでにソート済みであり、結果をそのまま返せることがわかります。したがって、この状況を検出するためのフラグ <code>flag</code> を追加し、発生した時点で直ちに返すようにできます。</p> <p>最適化後も、バブルソートの最悪時間計算量と平均時間計算量は依然として \\(O(n^2)\\) です。ただし、入力配列が完全に整列済みであれば、最良時間計算量は \\(O(n)\\) に達します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"バブルソート（フラグ最適化）\"\"\"\n    n = len(nums)\n    # 外側のループ：未ソート区間は [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # フラグを初期化する\n        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # nums[j] と nums[j + 1] を交換\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # 交換する要素を記録\n        if not flag:\n            break  # このバブル処理で要素交換が一度もなければそのまま終了\n</code></pre> bubble_sort.cpp<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換する\n                // ここでは std::swap() 関数を使用する\n                swap(nums[j], nums[j + 1]);\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag)\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag)\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* バブルソート（フラグ最適化） */\nvoid BubbleSortWithFlag(int[] nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // 交換する要素を記録\n            }\n        }\n        if (!flag) break;     // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* バブルソート（フラグ最適化） */\nfunc bubbleSortWithFlag(nums []int) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // nums[j] と nums[j + 1] を交換\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // 交換する要素を記録\n            }\n        }\n        if flag == false { // このバブル処理で要素交換が一度もなければそのまま終了\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* バブルソート（フラグ最適化） */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // フラグを初期化する\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swapAt(j, j + 1)\n                flag = true // 交換する要素を記録\n            }\n        }\n        if !flag { // このバブル処理で要素交換が一度もなければそのまま終了\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* バブルソート（フラグ最適化） */\nfunction bubbleSortWithFlag(nums) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* バブルソート（フラグ最適化） */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // 外側のループ：未ソート区間は [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // 外側のループ：未ソート区間は [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // フラグを初期化する\n    // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // nums[j] と nums[j + 1] を交換\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // 交換する要素を記録\n      }\n    }\n    if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* バブルソート（フラグ最適化） */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // 外側のループ：未ソート区間は [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // nums[j] と nums[j + 1] を交換\n                nums.swap(j, j + 1);\n                flag = true; // 交換する要素を記録\n            }\n        }\n        if !flag {\n            break; // このバブル処理で要素交換が一度もなければそのまま終了\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* バブルソート（フラグ最適化） */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* バブルソート（フラグ最適化） */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // 外側のループ：未ソート区間は [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // フラグを初期化する\n        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // nums[j] と nums[j + 1] を交換\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // 交換する要素を記録\n            }\n        }\n        if (!flag) break // このバブル処理で要素交換が一度もなければそのまま終了\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### バブルソート ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n\n# ## バブルソート（フラグ最適化）###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # 外側のループ：未ソート区間は [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # フラグを初期化する\n\n    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # nums[j] と nums[j + 1] を交換\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # 交換する要素を記録\n      end\n    end\n\n    break unless flag # このバブル処理で要素交換が一度もなければそのまま終了\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   アルゴリズムの特徴","text":"<ul> <li>時間計算量は \\(O(n^2)\\)、適応的ソート：各回の「バブル処理」で走査する配列の長さは順に \\(n - 1\\)、\\(n - 2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) であり、その総和は \\((n - 1) n / 2\\) です。<code>flag</code> による最適化を導入すると、最良時間計算量は \\(O(n)\\) に達します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>安定ソート：「バブル処理」では等しい要素に出会っても交換しないためです。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.3 &nbsp; バブルソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   バケットソート","text":"<p>前述のいくつかのソートアルゴリズムは、いずれも「比較ベースのソートアルゴリズム」に属し、要素間の大小を比較することで整列を実現します。この種のソートアルゴリズムの時間計算量は \\(O(n \\log n)\\) を超えられません。続いて、時間計算量が線形オーダーに達しうる「非比較ソートアルゴリズム」をいくつか見ていきます。</p> <p>バケットソート（bucket sort）は分割統治戦略の典型的な応用です。大小関係をもつ複数のバケットを用意し、各バケットがあるデータ範囲に対応するようにして、データを各バケットへ均等に分配します。その後、各バケット内でそれぞれソートを行い、最後にバケットの順序に従ってすべてのデータを結合します。</p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   アルゴリズムの流れ","text":"<p>長さ \\(n\\) の配列を考え、その要素は範囲 \\([0, 1)\\) の浮動小数点数であるとします。バケットソートの流れを以下の図に示します。</p> <ol> <li>\\(k\\) 個のバケットを初期化し、\\(n\\) 個の要素を \\(k\\) 個のバケットに分配します。</li> <li>各バケットに対してそれぞれソートを実行します（ここではプログラミング言語の組み込みソート関数を用います）。</li> <li>バケットを小さい順にたどって結果を結合します。</li> </ol> <p></p> <p> 図 11-13   バケットソートの流れ </p> <p>コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"バケットソート\"\"\"\n    # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. 配列要素を各バケットに振り分ける\n    for num in nums:\n        # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        i = int(num * k)\n        # num をバケット i に追加\n        buckets[i].append(num)\n    # 2. 各バケットをソートする\n    for bucket in buckets:\n        # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort()\n    # 3. バケットを走査して結果を結合\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* バケットソート */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. 配列要素を各バケットに振り分ける\n    for (float num : nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = num * k;\n        // num をバケット bucket_idx に追加\n        buckets[i].push_back(num);\n    }\n    // 2. 各バケットをソートする\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. バケットを走査して結果を結合\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* バケットソート */\nvoid bucketSort(float[] nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (float num : nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = (int) (num * k);\n        // num をバケット i に追加\n        buckets.get(i).add(num);\n    }\n    // 2. 各バケットをソートする\n    for (List&lt;Float&gt; bucket : buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        Collections.sort(bucket);\n    }\n    // 3. バケットを走査して結果を結合\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* バケットソート */\nvoid BucketSort(float[] nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    foreach (float num in nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        int i = (int)(num * k);\n        // num をバケット i に追加\n        buckets[i].Add(num);\n    }\n    // 2. 各バケットをソートする\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.Sort();\n    }\n    // 3. バケットを走査して結果を結合\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* バケットソート */\nfunc bucketSort(nums []float64) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for _, num := range nums {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        i := int(num * float64(k))\n        // num をバケット i に追加\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. 各バケットをソートする\n    for i := 0; i &lt; k; i++ {\n        // 組み込みのスライスソート関数を使う。ほかのソートアルゴリズムに置き換えてもよい\n        sort.Float64s(buckets[i])\n    }\n    // 3. バケットを走査して結果を結合\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* バケットソート */\nfunc bucketSort(nums: inout [Double]) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. 配列要素を各バケットに振り分ける\n    for num in nums {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        let i = Int(num * Double(k))\n        // num をバケット i に追加\n        buckets[i].append(num)\n    }\n    // 2. 各バケットをソートする\n    for i in buckets.indices {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        buckets[i].sort()\n    }\n    // 3. バケットを走査して結果を結合\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* バケットソート */\nfunction bucketSort(nums) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (const num of nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        const i = Math.floor(num * k);\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for (const bucket of buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. バケットを走査して結果を結合\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* バケットソート */\nfunction bucketSort(nums: number[]): void {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (const num of nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        const i = Math.floor(num * k);\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for (const bucket of buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. バケットを走査して結果を結合\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* バケットソート */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. 配列要素を各バケットに振り分ける\n  for (double _num in nums) {\n    // 入力データの範囲は [0, 1) であり、_num * k を用いてインデックス範囲 [0, k-1] に写像する\n    int i = (_num * k).toInt();\n    // _num をバケット bucket_idx に追加\n    buckets[i].add(_num);\n  }\n  // 2. 各バケットをソートする\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. バケットを走査して結果を結合\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* バケットソート */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. 配列要素を各バケットに振り分ける\n    for &amp;num in nums.iter() {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        let i = (num * k as f64) as usize;\n        // num をバケット i に追加\n        buckets[i].push(num);\n    }\n    // 2. 各バケットをソートする\n    for bucket in &amp;mut buckets {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. バケットを走査して結果を結合\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* バケットソート */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // k = n/2 個のバケットを初期化する\n    int *sizes = malloc(k * sizeof(int));          // 各バケットのサイズを記録する\n    float **buckets = malloc(k * sizeof(float *)); // 動的配列の配列（バケット）\n    // 各バケットに十分な容量を事前確保する\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. 各バケットをソートする\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. ソート済みのバケットを結合する\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // メモリを解放する\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* バケットソート */\nfun bucketSort(nums: FloatArray) {\n    // k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. 配列要素を各バケットに振り分ける\n    for (num in nums) {\n        // 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n        val i = (num * k).toInt()\n        // num をバケット i に追加\n        buckets[i].add(num)\n    }\n    // 2. 各バケットをソートする\n    for (bucket in buckets) {\n        // 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n        bucket.sort()\n    }\n    // 3. バケットを走査して結果を結合\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### バケットソート ###\ndef bucket_sort(nums)\n  # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. 配列要素を各バケットに振り分ける\n  nums.each do |num|\n    # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する\n    i = (num * k).to_i\n    # num をバケット i に追加\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. 各バケットをソートする\n  buckets.each do |bucket|\n    # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい\n    bucket.sort!\n  end\n\n  # 3. バケットを走査して結果を結合\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   アルゴリズムの特性","text":"<p>バケットソートは、非常に大規模なデータの処理に適しています。たとえば、入力データに 100 万個の要素が含まれ、空間の制約によりシステムメモリへすべてのデータを一度に読み込めない場合です。このとき、データを 1000 個のバケットに分け、それぞれのバケットを個別にソートしてから、最後に結果を結合できます。</p> <ul> <li>時間計算量は \\(O(n + k)\\) ：要素が各バケット内に平均的に分布していると仮定すると、各バケット内の要素数は \\(\\frac{n}{k}\\) です。1 つのバケットをソートするのに \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) の時間がかかるなら、すべてのバケットのソートには \\(O(n \\log\\frac{n}{k})\\) の時間がかかります。バケット数 \\(k\\) が十分大きいとき、時間計算量は \\(O(n)\\) に近づきます。結果を結合する際には、すべてのバケットと要素を走査する必要があり、\\(O(n + k)\\) の時間を要します。最悪の場合、すべてのデータが 1 つのバケットに割り当てられ、そのバケットのソートに \\(O(n^2)\\) の時間がかかります。</li> <li>空間計算量は \\(O(n + k)\\)、非インプレースソート：\\(k\\) 個のバケットと合計 \\(n\\) 個の要素ぶんの追加領域が必要です。</li> <li>バケットソートが安定かどうかは、バケット内要素のソートに用いるアルゴリズムが安定かどうかに依存します。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   均等な分配を実現するには","text":"<p>バケットソートの時間計算量は理論上 \\(O(n)\\) に達しますが、鍵は要素を各バケットへ均等に分配すること にあります。実際のデータは均一に分布していないことが多いからです。たとえば、Taobao 上のすべての商品を価格帯ごとに 10 個のバケットへ均等に分けたいとしても、商品の価格分布は偏っており、100 元未満は非常に多く、1000 元超は非常に少ないかもしれません。価格区間を単純に 10 等分すると、各バケットの商品数には大きな差が生じます。</p> <p>均等な分配を実現するために、まず大まかな境界線を設定し、データをひとまず 3 個のバケットに粗く振り分けます。分配後は、商品数の多いバケットをさらに 3 個のバケットに分割し、すべてのバケット内の要素数がおおむね等しくなるまでこれを続けます。</p> <p>以下の図に示すように、この方法の本質は再帰木を構築することにあり、目標は葉ノードの値をできるだけ均等にすることです。もちろん、毎回データを 3 個のバケットに分割する必要はなく、具体的な分け方はデータの特徴に応じて柔軟に選べます。</p> <p></p> <p> 図 11-14   再帰的にバケットを分割 </p> <p>商品価格の確率分布をあらかじめ把握しているなら、データの確率分布に基づいて各バケットの価格境界を設定できます。なお、データ分布は必ずしも特別に統計を取る必要はなく、データの特徴に応じて何らかの確率モデルで近似することもできます。</p> <p>以下の図に示すように、商品価格が正規分布に従うと仮定すれば、価格区間を合理的に設定でき、それによって商品を各バケットへ均等に分配できます。</p> <p></p> <p> 図 11-15   確率分布に基づいてバケットを分割 </p>","path":["第 11 章 &nbsp; ソート","11.8 &nbsp; バケットソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   計数ソート","text":"<p>計数ソート（counting sort）は要素数を集計することでソートを実現し、通常は整数配列に適用されます。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   単純な実装","text":"<p>まず簡単な例を見てみましょう。長さ \\(n\\) の配列 <code>nums</code> が与えられ、その要素はすべて「非負整数」であるとします。計数ソートの全体的な流れを以下の図に示します。</p> <ol> <li>配列を走査し、その中の最大値を見つけて \\(m\\) とし、続いて長さ \\(m + 1\\) の補助配列 <code>counter</code> を作成します。</li> <li><code>counter</code> を用いて <code>nums</code> 内の各数値の出現回数を集計します。ここで <code>counter[num]</code> は数値 <code>num</code> の出現回数に対応します。集計方法は非常に簡単で、<code>nums</code> を走査し（現在の数値を <code>num</code> とする）、各回で <code>counter[num]</code> を \\(1\\) 増やせばよいです。</li> <li><code>counter</code> の各インデックスは自然に順序づけられているため、すべての数値はすでに整列された状態とみなせます。続いて <code>counter</code> を走査し、各数値の出現回数に応じて小さい順に <code>nums</code> へ書き戻せば完了です。</li> </ol> <p></p> <p> 図 11-16   計数ソートの流れ </p> <p>コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"計数ソート\"\"\"\n    # 簡易版。オブジェクトのソートには使えない\n    # 1. 配列の最大要素 m を求める\n    m = max(nums)\n    # 2. 各数値の出現回数を数える\n    # counter[num] は num の出現回数を表す\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid CountingSortNaive(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunc countingSortNaive(nums []int) {\n    // 1. 配列の最大要素 m を求める\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. 配列の最大要素 m を求める\n    let m = nums.max()!\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunction countingSortNaive(nums) {\n    // 1. 配列の最大要素 m を求める\n    let m = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfunction countingSortNaive(nums: number[]): void {\n    // 1. 配列の最大要素 m を求める\n    let m: number = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. 配列の最大要素 m を求める\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 各数値の出現回数を数える\n  // counter[_num] は _num の出現回数を表す\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. 配列の最大要素 m を求める\n    let m = *nums.iter().max().unwrap();\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nvoid countingSortNaive(int nums[], int size) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. メモリを解放する\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計数ソート */\n// 簡易実装のため、オブジェクトのソートには使えない\nfun countingSortNaive(nums: IntArray) {\n    // 1. 配列の最大要素 m を求める\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. counter を走査し、各要素を元の配列 nums に書き戻す\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計数ソート ###\ndef counting_sort_naive(nums)\n  # 簡易版。オブジェクトのソートには使えない\n  # 1. 配列の最大要素 m を求める\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. 各数値の出現回数を数える\n  # counter[num] は num の出現回数を表す\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. counter を走査し、各要素を元の配列 nums に書き戻す\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>計数ソートとバケットソートの関係</p> <p>バケットソートの観点から見ると、計数ソートにおける計数配列 <code>counter</code> の各インデックスを 1 つのバケットとみなし、個数を数える過程を各要素を対応するバケットへ振り分ける操作とみなせます。本質的には、計数ソートは整数データにおけるバケットソートの特殊な一例です。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   完全な実装","text":"<p>注意深い読者なら、**入力データがオブジェクトである場合、上記の手順 <code>3.</code> は機能しない**ことに気づくかもしれません。入力データが商品オブジェクトであり、商品価格（クラスのメンバ変数）に基づいて商品をソートしたいとします。しかし上記のアルゴリズムが返せるのは価格のソート結果だけです。</p> <p>では、元のデータのソート結果を得るにはどうすればよいのでしょうか。まず <code>counter</code> の「累積和」を計算します。名前のとおり、インデックス <code>i</code> における累積和 <code>prefix[i]</code> は、配列の先頭から <code>i</code> 番目までの要素の総和に等しくなります：</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>累積和には明確な意味があり、<code>prefix[num] - 1</code> は要素 <code>num</code> が結果配列 <code>res</code> に最後に現れるインデックスを表します。この情報は非常に重要で、各要素が結果配列のどの位置に現れるべきかを示してくれます。続いて元の配列 <code>nums</code> を逆順に走査し、各要素 <code>num</code> に対して各反復で次の 2 つの手順を行います。</p> <ol> <li><code>num</code> を配列 <code>res</code> のインデックス <code>prefix[num] - 1</code> に格納します。</li> <li>累積和 <code>prefix[num]</code> を \\(1\\) 減らし、次に <code>num</code> を配置するインデックスを得ます。</li> </ol> <p>走査が完了すると、配列 <code>res</code> にソート済みの結果が格納されます。最後に <code>res</code> で元の配列 <code>nums</code> を上書きすれば完了です。以下の図は完全な計数ソートの流れを示しています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-17   計数ソートの手順 </p> <p>計数ソートの実装コードは以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"計数ソート\"\"\"\n    # 完全版。オブジェクトをソートでき、かつ安定ソートである\n    # 1. 配列の最大要素 m を求める\n    m = max(nums)\n    # 2. 各数値の出現回数を数える\n    # counter[num] は num の出現回数を表す\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    # つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    # 結果を記録するための配列 res を初期化\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # num を対応するインデックスに配置\n        counter[num] -= 1  # 累積和を 1 減らして、次に num を配置するインデックスを得る\n    # 結果配列 res で元の配列 nums を上書きする\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--;              // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid CountingSort(int[] nums) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunc countingSort(nums []int) {\n    // 1. 配列の最大要素 m を求める\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // num を対応するインデックスに配置\n        res[counter[num]-1] = num\n        // 累積和を 1 減らして、次に num を配置するインデックスを得る\n        counter[num]--\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunc countingSort(nums: inout [Int]) {\n    // 1. 配列の最大要素 m を求める\n    let m = nums.max()!\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // num を対応するインデックスに配置\n        counter[num] -= 1 // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunction countingSort(nums) {\n    // 1. 配列の最大要素 m を求める\n    let m = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfunction countingSort(nums: number[]): void {\n    // 1. 配列の最大要素 m を求める\n    let m: number = Math.max(...nums);\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. 配列の最大要素 m を求める\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 各数値の出現回数を数える\n  // counter[_num] は _num の出現回数を表す\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. counter の累積和を求め、「出現回数」を「末尾インデックス」に変換する\n  // つまり counter[_num]-1 は、res において _num が最後に出現する位置のインデックスである\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n  // 結果を記録するための配列 res を初期化\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // _num を対応する添字に配置\n    counter[_num]--; // 累積和を 1 減らし、次に _num を配置するインデックスを得る\n  }\n  // 結果配列 res で元の配列 nums を上書きする\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. 配列の最大要素 m を求める\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // num を対応するインデックスに配置\n        counter[num as usize] -= 1; // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nvoid countingSort(int nums[], int size) {\n    // 1. 配列の最大要素 m を求める\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // num を対応するインデックスに配置\n        counter[num]--;              // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    memcpy(nums, res, size * sizeof(int));\n    // 5. メモリを解放する\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計数ソート */\n// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである\nfun countingSort(nums: IntArray) {\n    // 1. 配列の最大要素 m を求める\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 各数値の出現回数を数える\n    // counter[num] は num の出現回数を表す\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n    // つまり counter[num]-1 は、num が res に最後に現れるインデックス\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n    // 結果を記録するための配列 res を初期化\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // num を対応するインデックスに配置\n        counter[num]-- // 累積和を 1 減らして、次に num を配置するインデックスを得る\n    }\n    // 結果配列 res で元の配列 nums を上書きする\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計数ソート ###\ndef counting_sort(nums)\n  # 完全版。オブジェクトをソートでき、かつ安定ソートである\n  # 1. 配列の最大要素 m を求める\n  m = nums.max\n  # 2. 各数値の出現回数を数える\n  # counter[num] は num の出現回数を表す\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する\n  # つまり counter[num]-1 は、num が res に最後に現れるインデックス\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. nums を逆順に走査し、各要素を結果配列 res に格納する\n  # 結果を記録するための配列 res を初期化する\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # num を対応するインデックスに配置\n    counter[num] -= 1 # 累積和を 1 減らして、次に num を配置するインデックスを得る\n  end\n  # 結果配列 res で元の配列 nums を上書きする\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n + m)\\)、非適応ソート ：<code>nums</code> の走査と <code>counter</code> の走査が含まれ、いずれも線形時間です。一般には \\(n \\gg m\\) であり、時間計算量は \\(O(n)\\) に近づきます。</li> <li>空間計算量は \\(O(n + m)\\)、非インプレースソート：長さがそれぞれ \\(n\\) と \\(m\\) の配列 <code>res</code> と <code>counter</code> を利用します。</li> <li>安定ソート：<code>res</code> に要素を埋める順序が「右から左」であるため、<code>nums</code> を逆順に走査することで等しい要素どうしの相対位置が変化するのを防ぎ、安定ソートを実現できます。実際には、<code>nums</code> を順方向に走査しても正しいソート結果は得られますが、その結果は安定ではありません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   制約","text":"<p>ここまで読むと、計数ソートは非常に巧妙で、個数を数えるだけで効率的なソートを実現できると感じるかもしれません。しかし、計数ソートを利用するための前提条件は比較的厳格です。</p> <p>計数ソートは非負整数にしか適用できません。ほかの型のデータに適用したい場合は、それらのデータを非負整数に変換でき、かつ変換の過程で要素間の相対的な大小関係が変わらないことを保証する必要があります。たとえば、負数を含む整数配列に対しては、すべての数値に定数を加えて正数へ変換し、ソート後に元へ戻すことができます。</p> <p>計数ソートはデータ量が多く、値域が小さい場合に適しています。たとえば上記の例では \\(m\\) が大きすぎてはならず、そうでないと過剰な空間を消費します。また、\\(n \\ll m\\) のとき、計数ソートは \\(O(m)\\) 時間を要するため、\\(O(n \\log n)\\) のソートアルゴリズムより遅くなる可能性があります。</p>","path":["第 11 章 &nbsp; ソート","11.9 &nbsp; 計数ソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   ヒープソート","text":"<p>Tip</p> <p>本節を読む前に、「ヒープ」の章を学習済みであることを確認してください。</p> <p>ヒープソート（heap sort）は、ヒープデータ構造に基づいて実装される効率的なソートアルゴリズムです。すでに学んだ「ヒープ構築操作」と「要素の取り出し操作」を利用してヒープソートを実現できます。</p> <ol> <li>配列を入力して最小ヒープを構築すると、このとき最小要素はヒープの頂点にあります。</li> <li>取り出し操作を繰り返し実行し、取り出された要素を順に記録すれば、昇順に並んだ列が得られます。</li> </ol> <p>以上の方法でも実行できますが、取り出した要素を保存するために追加の配列が必要となり、空間をやや無駄にします。実際には、通常はより洗練された実装方法を用います。</p>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   アルゴリズムの流れ","text":"<p>配列の長さを \\(n\\) とすると、ヒープソートの流れは次図のとおりです。</p> <ol> <li>配列を入力して最大ヒープを構築します。完了後、最大要素はヒープの頂点にあります。</li> <li>ヒープ頂点の要素（最初の要素）とヒープ末尾の要素（最後の要素）を交換します。交換後、ヒープの長さは \\(1\\) 減少し、整列済み要素数は \\(1\\) 増加します。</li> <li>ヒープ頂点の要素から始めて、上から下へヒープ化操作（sift down）を実行します。ヒープ化が完了すると、ヒープの性質が回復します。</li> <li>第 <code>2.</code> ステップと第 <code>3.</code> ステップを繰り返し実行します。これを \\(n - 1\\) 回繰り返すと、配列の整列が完了します。</li> </ol> <p>Tip</p> <p>実際には、要素の取り出し操作にも第 <code>2.</code> ステップと第 <code>3.</code> ステップが含まれており、要素を取り出す処理が 1 つ加わるだけです。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-12   ヒープソートの手順 </p> <p>コード実装では、「ヒープ」の章と同じ上から下へのヒープ化 <code>sift_down()</code> 関数を使用します。注意すべき点として、ヒープの長さは最大要素を取り出すたびに短くなるため、<code>sift_down()</code> 関数に長さパラメータ \\(n\\) を追加し、ヒープの現在の有効な長さを指定する必要があります。コードは以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"ヒープの長さは n。ノード i から下方向にヒープ化\"\"\"\n    while True:\n        # ノード i, l, r のうち値が最大のノードを ma とする\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i:\n            break\n        # 2 つのノードを交換\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # ループで上から下へヒープ化\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"ヒープソート\"\"\"\n    # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in range(len(nums) - 1, 0, -1):\n        # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums[0], nums[i] = nums[i], nums[0]\n        # 根ノードを起点に、上から下へヒープ化\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        swap(nums[i], nums[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        swap(nums[0], nums[i]);\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(int[] nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i)\n            break;\n        // 2 つのノードを交換\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid HeapSort(int[] nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // 根ノードを起点に、上から下へヒープ化\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfunc heapSort(nums *[]int) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break\n        }\n        // 2 つのノードを交換\n        nums.swapAt(i, ma)\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfunc heapSort(nums: inout [Int]) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in nums.indices.dropFirst().reversed() {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums.swapAt(0, i)\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) {\n            break;\n        }\n        // 2 つのノードを交換\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfunction heapSort(nums) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma === i) {\n            break;\n        }\n        // 2 つのノードを交換\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfunction heapSort(nums: number[]): void {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // ノード i, l, r のうち値が最大のノードを ma とする\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    if (ma == i) break;\n    // 2 つのノードを交換\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // ループで上から下へヒープ化\n    i = ma;\n  }\n}\n\n/* ヒープソート */\nvoid heapSort(List&lt;int&gt; nums) {\n  // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // ヒープから最大要素を取り出し、n-1 回繰り返す\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // 根ノードを起点に、上から下へヒープ化\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if ma == i {\n            break;\n        }\n        // 2 つのノードを交換\n        nums.swap(i, ma);\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for i in (1..nums.len()).rev() {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        nums.swap(0, i);\n        // 根ノードを起点に、上から下へヒープ化\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) {\n            break;\n        }\n        // 2 つのノードを交換\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // ループで上から下へヒープ化\n        i = ma;\n    }\n}\n\n/* ヒープソート */\nvoid heapSort(int nums[], int n) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (int i = n - 1; i &gt; 0; --i) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* ヒープの長さは n。ノード i から下方向にヒープ化 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // ノード i, l, r のうち値が最大のノードを ma とする\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n        if (ma == i) \n            break\n        // 2 つのノードを交換\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // ループで上から下へヒープ化\n        i = ma\n    }\n}\n\n/* ヒープソート */\nfun heapSort(nums: IntArray) {\n    // ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // ヒープから最大要素を取り出し、n-1 回繰り返す\n    for (i in nums.size - 1 downTo 1) {\n        // 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // 根ノードを起点に、上から下へヒープ化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### ヒープ長 n で、ノード i から上から下へヒープ化 ###\ndef sift_down(nums, n, i)\n  while true\n    # ノード i, l, r のうち値が最大のノードを ma とする\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける\n    break if ma == i\n    # 2 つのノードを交換\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # ループで上から下へヒープ化\n    i = ma\n  end\nend\n\n### ヒープソート ###\ndef heap_sort(nums)\n  # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # ヒープから最大要素を取り出し、n-1 回繰り返す\n  (nums.length - 1).downto(1) do |i|\n    # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）\n    nums[0], nums[i] = nums[i], nums[0]\n    # 根ノードを起点に、上から下へヒープ化\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応ソート：ヒープ構築操作には \\(O(n)\\) の時間がかかります。ヒープから最大要素を取り出す時間計算量は \\(O(\\log n)\\) であり、これを合計 \\(n - 1\\) 回繰り返します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：いくつかのポインタ変数が使う空間は \\(O(1)\\) です。要素の交換とヒープ化操作はいずれも元の配列上で行われます。</li> <li>非安定ソート：ヒープ頂点の要素とヒープ末尾の要素を交換する際、等しい要素どうしの相対位置が変化する可能性があります。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.7 &nbsp; ヒープソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   挿入ソート","text":"<p>挿入ソート（insertion sort）は単純なソートアルゴリズムであり、その動作原理は手作業でトランプの山を整える過程と非常によく似ています。</p> <p>具体的には、未ソート区間から基準要素を 1 つ選び、その要素を左側の整列済み区間の要素と 1 つずつ比較し、正しい位置に挿入します。</p> <p>以下の図は、配列に要素を挿入する操作の流れを示しています。基準要素を <code>base</code> とすると、目的のインデックスから <code>base</code> までのすべての要素を 1 つずつ右に移動し、その後 <code>base</code> を目的のインデックスに代入する必要があります。</p> <p></p> <p> 図 11-6   1 回の挿入操作 </p>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   アルゴリズムの流れ","text":"<p>挿入ソート全体の流れを以下の図に示します。</p> <ol> <li>初期状態では、配列の 1 番目の要素はすでに整列済みです。</li> <li>配列の 2 番目の要素を <code>base</code> として選び、正しい位置に挿入すると、**配列の先頭 2 要素が整列済み**になります。</li> <li>3 番目の要素を <code>base</code> として選び、正しい位置に挿入すると、**配列の先頭 3 要素が整列済み**になります。</li> <li>このように繰り返し、最後のラウンドで最後の要素を <code>base</code> として選んで正しい位置に挿入すると、**すべての要素が整列済み**になります。</li> </ol> <p></p> <p> 図 11-7   挿入ソートの流れ </p> <p>コード例は以下のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"挿入ソート\"\"\"\n    # 外側ループ：整列済み区間は [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # nums[j] を 1 つ右へ移動する\n            j -= 1\n        nums[j + 1] = base  # base を正しい位置に配置する\n</code></pre> insertion_sort.cpp<pre><code>/* 挿入ソート */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* 挿入ソート */\nvoid insertionSort(int[] nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base;        // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* 挿入ソート */\nvoid InsertionSort(int[] nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = bas;         // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* 挿入ソート */\nfunc insertionSort(nums []int) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j--\n        }\n        nums[j+1] = base // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* 挿入ソート */\nfunc insertionSort(nums: inout [Int]) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j -= 1\n        }\n        nums[j + 1] = base // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* 挿入ソート */\nfunction insertionSort(nums) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* 挿入ソート */\nfunction insertionSort(nums: number[]): void {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n            j--;\n        }\n        nums[j + 1] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* 挿入ソート */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // 外側ループ：整列済み区間は [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する\n      j--;\n    }\n    nums[j + 1] = base; // base を正しい位置に配置する\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* 挿入ソート */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // nums[j] を 1 つ右へ移動する\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* 挿入ソート */\nvoid insertionSort(int nums[], int size) {\n    // 外側ループ：整列済み区間は [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // nums[j] を 1 つ右へ移動する\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // base を正しい位置に配置する\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* 挿入ソート */\nfun insertionSort(nums: IntArray) {\n    // 外側ループ: ソート済み要素は 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // nums[j] を 1 つ右へ移動する\n            j--\n        }\n        nums[j + 1] = base        // base を正しい位置に配置する\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### 挿入ソート ###\ndef insertion_sort(nums)\n  n = nums.length\n  # 外側ループ：整列済み区間は [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # nums[j] を 1 つ右へ移動する\n      j -= 1\n    end\n    nums[j + 1] = base # base を正しい位置に配置する\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   アルゴリズムの特徴","text":"<ul> <li>計算量は \\(O(n^2)\\)、適応的ソート：最悪の場合、各挿入操作ではそれぞれ \\(n - 1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 回のループが必要であり、合計は \\((n - 1) n / 2\\) となるため、時間計算量は \\(O(n^2)\\) です。データが整列済みであれば、挿入操作は早期に終了します。入力配列が完全に整列済みである場合、挿入ソートは最良の時間計算量 \\(O(n)\\) に達します。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>安定ソート：挿入操作の過程では、要素を等しい要素の右側に挿入するため、それらの順序は変化しません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   挿入ソートの利点","text":"<p>挿入ソートの時間計算量は \\(O(n^2)\\) であり、これから学ぶクイックソートの時間計算量は \\(O(n \\log n)\\) です。挿入ソートの時間計算量のほうが大きいにもかかわらず、**データ量が小さい場合には、挿入ソートのほうが通常は高速**です。</p> <p>この結論は、線形探索と二分探索の適用条件に関する結論と似ています。クイックソートのような \\(O(n \\log n)\\) のアルゴリズムは分割統治法に基づくソートアルゴリズムであり、一般により多くの基本演算を含みます。一方、データ量が小さい場合は、\\(n^2\\) と \\(n \\log n\\) の値は比較的近く、計算量が支配的ではなくなり、各ラウンドにおける基本演算の回数が決定的な役割を果たします。</p> <p>実際、多くのプログラミング言語（たとえば Java）の組み込みソート関数では挿入ソートが採用されており、その大まかな考え方は次のとおりです。長い配列にはクイックソートなどの分割統治法に基づくソートアルゴリズムを使い、短い配列には直接挿入ソートを使います。</p> <p>バブルソート、選択ソート、挿入ソートはいずれも時間計算量が \\(O(n^2)\\) ですが、実際には、挿入ソートはバブルソートや選択ソートよりもはるかに高い頻度で使われます。主な理由は次のとおりです。</p> <ul> <li>バブルソートは要素の交換によって実装され、1 つの一時変数を必要とするため、合計で 3 回の基本演算が関わります。これに対して、挿入ソートは要素の代入に基づいており、必要な基本演算は 1 回だけです。したがって、バブルソートの計算コストは通常、挿入ソートより高くなります。</li> <li>選択ソートの時間計算量はどのような場合でも \\(O(n^2)\\) です。**部分的に整列されたデータが与えられた場合、挿入ソートは通常、選択ソートより効率的**です。</li> <li>選択ソートは安定ではないため、多段ソートには適用できません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.4 &nbsp; 挿入ソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   マージソート","text":"<p>マージソート（merge sort）は分割統治戦略に基づくソートアルゴリズムであり、以下の図に示す「分割」と「マージ」の段階から構成されます。</p> <ol> <li>分割段階：再帰によって配列を中点で繰り返し分割し、長い配列のソート問題を短い配列のソート問題へ変換します。</li> <li>マージ段階：部分配列の長さが 1 になったら分割を終了し、マージを開始して、左右 2 つの短いソート済み配列をより長いソート済み配列へと繰り返しマージしていきます。</li> </ol> <p></p> <p> 図 11-10   マージソートの分割とマージの段階 </p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   アルゴリズムの流れ","text":"<p>以下の図に示すように、「分割段階」では配列を上から下へ再帰的に中点で 2 つの部分配列へ分割します。</p> <ol> <li>配列の中点 <code>mid</code> を計算し、左部分配列（区間 <code>[left, mid]</code> ）と右部分配列（区間 <code>[mid + 1, right]</code> ）を再帰的に分割します。</li> <li>手順 <code>1.</code> を再帰的に実行し、部分配列区間の長さが 1 になった時点で終了します。</li> </ol> <p>「マージ段階」では左部分配列と右部分配列を下から上へとマージし、1 つのソート済み配列にします。長さ 1 の部分配列からマージを始めるため、この段階の各部分配列はすでに整列されています。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-11   マージソートの手順 </p> <p>観察すると、マージソートの再帰順序は二分木の後順走査と一致していることがわかります。</p> <ul> <li>後順走査：まず左部分木を再帰し、次に右部分木を再帰し、最後に根ノードを処理します。</li> <li>マージソート：まず左部分配列を再帰し、次に右部分配列を再帰し、最後にマージを処理します。</li> </ul> <p>マージソートの実装を以下のコードに示します。注意として、<code>nums</code> のマージ対象区間は <code>[left, right]</code> であり、<code>tmp</code> の対応区間は <code>[0, right - left]</code> です。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"左部分配列と右部分配列をマージ\"\"\"\n    # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    # マージ結果を格納する一時配列 tmp を作成\n    tmp = [0] * (right - left + 1)\n    # 左右の部分配列の開始インデックスを初期化する\n    i, j, k = left, mid + 1, 0\n    # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"マージソート\"\"\"\n    # 終了条件\n    if left &gt;= right:\n        return  # 部分配列の長さが 1 になったら再帰を終了\n    # 分割フェーズ\n    mid = (left + right) // 2 # 中点を計算\n    merge_sort(nums, left, mid)  # 左部分配列を再帰処理\n    merge_sort(nums, mid + 1, right)  # 右部分配列を再帰処理\n    # マージフェーズ\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    vector&lt;int&gt; tmp(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    mergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int[] tmp = new int[right - left + 1];\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid mergeSort(int[] nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2; // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int[] tmp = new int[right - left + 1];\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nvoid MergeSort(int[] nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right) return;       // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    MergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    MergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* 左部分配列と右部分配列をマージ */\nfunc merge(nums []int, left, mid, right int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    tmp := make([]int, right-left+1)\n    // 左右の部分配列の開始インデックスを初期化する\n    i, j, k := left, mid+1, 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* マージソート */\nfunc mergeSort(nums []int, left, right int) {\n    // 終了条件\n    if left &gt;= right {\n        return\n    }\n    // 分割フェーズ\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // マージフェーズ\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* 左部分配列と右部分配列をマージ */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // 左右の部分配列の開始インデックスを初期化する\n    var i = left, j = mid + 1, k = 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* マージソート */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // 終了条件\n    if left &gt;= right { // 部分配列の長さが 1 になったら再帰を終了\n        return\n    }\n    // 分割フェーズ\n    let mid = left + (right - left) / 2 // 中点を計算\n    mergeSort(nums: &amp;nums, left: left, right: mid) // 左部分配列を再帰処理\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* 左部分配列と右部分配列をマージ */\nfunction merge(nums, left, mid, right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    const tmp = new Array(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfunction mergeSort(nums, left, right) {\n    // 終了条件\n    if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    let mid = Math.floor(left + (right - left) / 2); // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* 左部分配列と右部分配列をマージ */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    const tmp = new Array(right - left + 1);\n    // 左右の部分配列の開始インデックスを初期化する\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // 終了条件\n    if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    let mid = Math.floor(left + (right - left) / 2); // 中点を計算\n    mergeSort(nums, left, mid); // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n  // マージ結果を格納する一時配列 tmp を作成\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // 左右の部分配列の開始インデックスを初期化する\n  int i = left, j = mid + 1, k = 0;\n  // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // 左右の部分配列の残り要素を一時配列にコピーする\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* マージソート */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // 終了条件\n  if (left &gt;= right) return; // 部分配列の長さが 1 になったら再帰を終了\n  // 分割フェーズ\n  int mid = left + (right - left) ~/ 2; // 中点を計算\n  mergeSort(nums, left, mid); // 左部分配列を再帰処理\n  mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n  // マージフェーズ\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* 左部分配列と右部分配列をマージ */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // 左右の部分配列の開始インデックスを初期化する\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* マージソート */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // 終了条件\n    if left &gt;= right {\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    }\n\n    // 分割フェーズ\n    let mid = left + (right - left) / 2; // 中点を計算\n    merge_sort(nums, left, mid); // 左部分配列を再帰処理\n    merge_sort(nums, mid + 1, right); // 右部分配列を再帰処理\n\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* 左部分配列と右部分配列をマージ */\nvoid merge(int *nums, int left, int mid, int right) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // 左右の部分配列の開始インデックスを初期化する\n    int i = left, j = mid + 1, k = 0;\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // メモリを解放する\n    free(tmp);\n}\n\n/* マージソート */\nvoid mergeSort(int *nums, int left, int right) {\n    // 終了条件\n    if (left &gt;= right)\n        return; // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    int mid = left + (right - left) / 2;    // 中点を計算\n    mergeSort(nums, left, mid);      // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* 左部分配列と右部分配列をマージ */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n    // マージ結果を格納する一時配列 tmp を作成\n    val tmp = IntArray(right - left + 1)\n    // 左右の部分配列の開始インデックスを初期化する\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // 左右の部分配列の残り要素を一時配列にコピーする\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* マージソート */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // 終了条件\n    if (left &gt;= right) return  // 部分配列の長さが 1 になったら再帰を終了\n    // 分割フェーズ\n    val mid = left + (right - left) / 2 // 中点を計算\n    mergeSort(nums, left, mid) // 左部分配列を再帰処理\n    mergeSort(nums, mid + 1, right) // 右部分配列を再帰処理\n    // マージフェーズ\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### 左部分配列と右部分配列をマージ ###\ndef merge(nums, left, mid, right)\n  # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]\n  # マージ結果を格納する一時配列 tmp を作成\n  tmp = Array.new(right - left + 1, 0)\n  # 左右の部分配列の開始インデックスを初期化する\n  i, j, k = left, mid + 1, 0\n  # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # 左右の部分配列の残り要素を一時配列にコピーする\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### マージソート ###\ndef merge_sort(nums, left, right)\n  # 終了条件\n  # 部分配列の長さが 1 になったら再帰を終了する\n  return if left &gt;= right\n  # 分割フェーズ\n  mid = left + (right - left) / 2 # 中点を計算\n  merge_sort(nums, left, mid) # 左部分配列を再帰処理\n  merge_sort(nums, mid + 1, right) # 右部分配列を再帰処理\n  # マージフェーズ\n  merge(nums, left, mid, right)\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応型ソート：分割によって高さ \\(\\log n\\) の再帰木が生成され、各層でのマージ操作の総数は \\(n\\) であるため、全体の時間計算量は \\(O(n \\log n)\\) です。</li> <li>空間計算量は \\(O(n)\\)、インプレースではないソート：再帰の深さは \\(\\log n\\) であり、サイズ \\(O(\\log n)\\) のスタックフレーム領域を使用します。マージ操作は補助配列を用いて実装する必要があり、サイズ \\(O(n)\\) の追加領域を使用します。</li> <li>安定ソート：マージの過程では、等しい要素の順序は変化しません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   連結リストのソート","text":"<p>連結リストに対しては、マージソートは他のソートアルゴリズムと比べて顕著な利点があり、連結リストのソート問題の空間計算量を \\(O(1)\\) まで最適化できます 。</p> <ul> <li>分割段階：連結リストの分割は「再帰」の代わりに「反復」で実装できるため、再帰で使用するスタックフレーム領域を省けます。</li> <li>マージ段階：連結リストでは、ノードの追加や削除は参照（ポインタ）を変更するだけで実現できるため、マージ段階（2 つの短いソート済み連結リストを 1 つの長いソート済み連結リストにマージすること）では追加の連結リストを作成する必要がありません。</li> </ul> <p>具体的な実装の詳細は比較的複雑なので、興味のある読者は関連資料を参照して学習してください。</p>","path":["第 11 章 &nbsp; ソート","11.6 &nbsp; マージソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   クイックソート","text":"<p>クイックソート（quick sort）は分割統治戦略に基づくソートアルゴリズムであり、実行効率が高く、広く利用されています。</p> <p>クイックソートの中核操作は「パーティション」であり、その目的は、配列内のある要素を「基準数」として選び、基準数より小さいすべての要素を左側へ、大きい要素を右側へ移動することです。具体的には、パーティションの流れを下図に示します。</p> <ol> <li>配列の最左端の要素を基準数として選び、2 つのポインタ <code>i</code> と <code>j</code> を初期化して、それぞれ配列の両端を指すようにします。</li> <li>ループを設定し、各ラウンドで <code>i</code>（<code>j</code>）を使ってそれぞれ基準数より大きい（小さい）最初の要素を探し、その後この 2 つの要素を交換します。</li> <li><code>i</code> と <code>j</code> が出会うまでステップ <code>2.</code> を繰り返し、最後に基準数を 2 つの部分配列の境界へ交換します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-8   パーティションの手順 </p> <p>パーティションが完了すると、元の配列は左部分配列、基準数、右部分配列の 3 つに分けられ、「左部分配列の任意の要素 \\(\\leq\\) 基準数 \\(\\leq\\) 右部分配列の任意の要素」を満たします。したがって、次はこの 2 つの部分配列だけをソートすれば済みます。</p> <p>クイックソートの分割統治戦略</p> <p>パーティションの本質は、長い配列のソート問題を 2 つの短い配列のソート問題へ簡略化することです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"番兵分割\"\"\"\n    # nums[left] を基準値とする\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 右から左へ基準値未満の最初の要素を探す\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 左から右へ基準値より大きい最初の要素を探す\n        # 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 基準値のインデックスを返す\n</code></pre> quick_sort.cpp<pre><code>/* 番兵分割 */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums[i], nums[j]); // この 2 つの要素を交換\n    }\n    swap(nums[i], nums[left]);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;                   // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.java<pre><code>/* 要素の交換 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint partition(int[] nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.cs<pre><code>/* 要素の交換 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* 番兵分割 */\nint Partition(int[] nums, int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        Swap(nums, i, j); // この 2 つの要素を交換\n    }\n    Swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.go<pre><code>/* 番兵分割 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // nums[left] を基準値とする\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 右から左へ基準値未満の最初の要素を探す\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.swift<pre><code>/* 番兵分割 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swapAt(i, j) // この 2 つの要素を交換\n    }\n    nums.swapAt(i, left) // 基準値を 2 つの部分配列の境界へ交換する\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.js<pre><code>/* 要素の交換 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\npartition(nums, left, right) {\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.ts<pre><code>/* 要素の交換 */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\npartition(nums: number[], left: number, right: number): number {\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.dart<pre><code>/* 要素の交換 */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // nums[left] を基準値とする\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n    _swap(nums, i, j); // この 2 つの要素を交換\n  }\n  _swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n  return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rs<pre><code>/* 番兵分割 */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // nums[left] を基準値とする\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swap(i, j); // この 2 つの要素を交換\n    }\n    nums.swap(i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.c<pre><code>/* 要素の交換 */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 番兵分割 */\nint partition(int nums[], int left, int right) {\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // この 2 つの要素を交換\n        swap(nums, i, j);\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    swap(nums, i, left);\n    // 基準値のインデックスを返す\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* 要素の交換 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* 番兵分割 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j)  // この 2 つの要素を交換\n    }\n    swap(nums, i, left)   // 基準値を 2 つの部分配列の境界へ交換する\n    return i              // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rb<pre><code>### 番兵分割 ###\ndef partition(nums, left, right)\n  # nums[left] を基準値とする\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   アルゴリズムの流れ","text":"<p>クイックソート全体の流れを下図に示します。</p> <ol> <li>まず、元の配列に対して 1 回「パーティション」を実行し、未ソートの左部分配列と右部分配列を得ます。</li> <li>次に、左部分配列と右部分配列に対してそれぞれ再帰的に「パーティション」を実行します。</li> <li>部分配列の長さが 1 になるまで再帰を続け、配列全体のソートを完了します。</li> </ol> <p></p> <p> 図 11-9   クイックソートの流れ </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"クイックソート\"\"\"\n    # 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right:\n        return\n    # 番兵分割\n    pivot = self.partition(nums, left, right)\n    # 左右の部分配列を再帰処理\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* クイックソート */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* クイックソート */\nvoid quickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* クイックソート */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right)\n        return;\n    // 番兵分割\n    int pivot = Partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* クイックソート */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return\n    }\n    // 番兵分割\n    pivot := q.partition(nums, left, right)\n    // 左右の部分配列を再帰処理\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* クイックソート */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return\n    }\n    // 番兵分割\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // 左右の部分配列を再帰処理\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* クイックソート */\nquickSort(nums, left, right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) return;\n    // 番兵分割\n    const pivot = this.partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* クイックソート */\nquickSort(nums: number[], left: number, right: number): void {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) {\n        return;\n    }\n    // 番兵分割\n    const pivot = this.partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* クイックソート */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 部分配列の長さが 1 なら再帰を終了する\n  if (left &gt;= right) return;\n  // 番兵分割\n  int pivot = _partition(nums, left, right);\n  // 左右の部分配列を再帰処理\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* クイックソート */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if left &gt;= right {\n        return;\n    }\n    // 番兵分割\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // 左右の部分配列を再帰処理\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* クイックソート */\nvoid quickSort(int nums[], int left, int right) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) {\n        return;\n    }\n    // 番兵分割\n    int pivot = partition(nums, left, right);\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* クイックソート */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // 部分配列の長さが 1 なら再帰を終了する\n    if (left &gt;= right) return\n    // 番兵分割\n    val pivot = partition(nums, left, right)\n    // 左右の部分配列を再帰処理\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### クイックソートクラス ###\ndef quick_sort(nums, left, right)\n  # 部分配列の長さが 1 でない場合は再帰する\n  if left &lt; right\n    # 番兵分割\n    pivot = partition(nums, left, right)\n    # 左右の部分配列を再帰処理\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   アルゴリズムの特性","text":"<ul> <li>時間計算量は \\(O(n \\log n)\\)、非適応型ソート：平均的な場合、パーティションの再帰の深さは \\(\\log n\\) で、各層の総ループ回数は \\(n\\) のため、全体で \\(O(n \\log n)\\) 時間を要します。最悪の場合、各回のパーティション操作で長さ \\(n\\) の配列が長さ \\(0\\) と \\(n - 1\\) の 2 つの部分配列に分割され、このとき再帰の深さは \\(n\\) に達し、各層のループ回数は \\(n\\) となるため、全体で \\(O(n^2)\\) 時間を要します。</li> <li>空間計算量は \\(O(n)\\)、インプレースソート：入力配列が完全な逆順の場合、最悪の再帰深さ \\(n\\) に達し、\\(O(n)\\) のスタックフレーム空間を使用します。ソート操作は元の配列上で行われ、追加の配列は用いません。</li> <li>非安定ソート：パーティションの最後のステップで、基準数が等しい要素の右側へ交換される可能性があります。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   クイックソートが速い理由","text":"<p>名前からも分かるように、クイックソートは効率面で一定の優位性を持っています。クイックソートの平均時間計算量は「マージソート」や「ヒープソート」と同じですが、通常はクイックソートのほうが高効率であり、主な理由は次のとおりです。</p> <ul> <li>最悪ケースが起こる確率が低い：クイックソートの最悪時間計算量は \\(O(n^2)\\) で、「マージソート」ほど安定ではありませんが、大半のケースでは \\(O(n \\log n)\\) の時間計算量で動作します。</li> <li>キャッシュ利用効率が高い：パーティション操作の実行時には、システムが部分配列全体をキャッシュに読み込めるため、要素アクセスの効率が高くなります。一方、「ヒープソート」のようなアルゴリズムは要素へ飛び飛びにアクセスする必要があり、この性質を持ちません。</li> <li>計算量の定数係数が小さい：上記 3 つのアルゴリズムの中で、クイックソートは比較、代入、交換などの操作総数が最も少なくなります。これは「挿入ソート」が「バブルソート」より速い理由と似ています。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   基準数の最適化","text":"<p>クイックソートは、入力によっては時間効率が低下する可能性があります。極端な例として、入力配列が完全な逆順であるとします。最左端の要素を基準数として選ぶため、パーティション完了後には基準数が配列の最右端へ交換され、左部分配列の長さが \\(n - 1\\)、右部分配列の長さが \\(0\\) になります。この再帰を続けると、各回のパーティション後に必ず一方の部分配列の長さが \\(0\\) となり、分割統治戦略が機能せず、クイックソートは「バブルソート」に近い形へ退化します。</p> <p>この状況をできるだけ避けるため、パーティションにおける基準数の選び方を最適化できます。たとえば、ランダムに 1 つの要素を選んで基準数にできます。しかし、運が悪く毎回望ましくない基準数を選んでしまうと、効率は依然として十分ではありません。</p> <p>注意すべき点として、プログラミング言語が通常生成するのは「疑似乱数」です。疑似乱数列に合わせて特定のテストケースを構築すると、クイックソートの効率はやはり劣化する可能性があります。</p> <p>さらに改善するために、配列から 3 つの候補要素（通常は先頭、末尾、中間の要素）を選び、**その 3 つの候補要素の中央値を基準数とする**ことができます。こうすると、基準数が「小さすぎず大きすぎもしない」確率が大幅に上がります。もちろん、候補要素をさらに増やして、アルゴリズムの頑健性をいっそう高めることも可能です。この方法を採用すると、時間計算量が \\(O(n^2)\\) まで劣化する確率は大きく下がります。</p> <p>コード例を以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"3つの候補要素の中央値を選ぶ\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m は l と r の間\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l は m と r の間\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"番兵による分割処理（3 点中央値）\"\"\"\n    # nums[left] を基準値とする\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # 中央値を配列の最左端に交換する\n    nums[left], nums[med] = nums[med], nums[left]\n    # nums[left] を基準値とする\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 右から左へ基準値未満の最初の要素を探す\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 左から右へ基準値より大きい最初の要素を探す\n        # 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 基準値のインデックスを返す\n</code></pre> quick_sort.cpp<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums[left], nums[med]);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums[i], nums[j]); // この 2 つの要素を交換\n    }\n    swap(nums[i], nums[left]);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;                   // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.java<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partition(int[] nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.cs<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint Partition(int[] nums, int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    Swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        Swap(nums, i, j); // この 2 つの要素を交換\n    }\n    Swap(nums, i, left);  // 基準値を 2 つの部分配列の境界へ交換する\n    return i;             // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.go<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l は m と r の間\n    }\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // nums[left] を基準値とする\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // 中央値を配列の最左端に交換する\n    nums[left], nums[med] = nums[med], nums[left]\n    // nums[left] を基準値とする\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 右から左へ基準値未満の最初の要素を探す\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 左から右へ基準値より大きい最初の要素を探す\n        }\n        // 要素の交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 基準値を 2 つの部分配列の境界へ交換する\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.swift<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l は m と r の間\n    }\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 3つの候補要素の中央値を選ぶ\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // 中央値を配列の最左端に交換する\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 3つの候補要素の中央値を選ぶ */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m は l と r の間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l は m と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\npartition(nums, left, right) {\n    // 3つの候補要素の中央値を選ぶ\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 中央値を配列の最左端に交換する\n    this.swap(nums, left, med);\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.ts<pre><code>/* 3つの候補要素の中央値を選ぶ */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m は l と r の間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l は m と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\npartition(nums: number[], left: number, right: number): number {\n    // 3つの候補要素の中央値を選ぶ\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 中央値を配列の最左端に交換する\n    this.swap(nums, left, med);\n    // nums[left] を基準値とする\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        this.swap(nums, i, j); // この 2 つの要素を交換\n    }\n    this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.dart<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m は l と r の間\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l は m と r の間\n  return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 3つの候補要素の中央値を選ぶ\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // 中央値を配列の最左端に交換する\n  _swap(nums, left, med);\n  // nums[left] を基準値とする\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す\n    _swap(nums, i, j); // この 2 つの要素を交換\n  }\n  _swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n  return i; // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rs<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m は l と r の間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l は m と r の間\n    }\n    right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 3つの候補要素の中央値を選ぶ\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    nums.swap(left, med);\n    // nums[left] を基準値とする\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 右から左へ基準値未満の最初の要素を探す\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 左から右へ基準値より大きい最初の要素を探す\n        }\n        nums.swap(i, j); // この 2 つの要素を交換\n    }\n    nums.swap(i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    i // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.c<pre><code>/* 3つの候補要素の中央値を選ぶ */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m は l と r の間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l は m と r の間\n    return right;\n}\n\n/* 番兵による分割処理（3 点中央値） */\nint partitionMedian(int nums[], int left, int right) {\n    // 3つの候補要素の中央値を選ぶ\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med);\n    // nums[left] を基準値とする\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j); // この 2 つの要素を交換\n    }\n    swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する\n    return i;            // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.kt<pre><code>/* 3つの候補要素の中央値を選ぶ */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m は l と r の間\n    if ((l in m..r) || (l in r..m))\n        return left // l は m と r の間\n    return right\n}\n\n/* 番兵による分割処理（3 点中央値） */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // 3つの候補要素の中央値を選ぶ\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // 中央値を配列の最左端に交換する\n    swap(nums, left, med)\n    // nums[left] を基準値とする\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // 右から左へ基準値未満の最初の要素を探す\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // 左から右へ基準値より大きい最初の要素を探す\n        swap(nums, i, j)             // この 2 つの要素を交換\n    }\n    swap(nums, i, left)              // 基準値を 2 つの部分配列の境界へ交換する\n    return i                         // 基準値のインデックスを返す\n}\n</code></pre> quick_sort.rb<pre><code>### 3 つの候補要素の中央値を選ぶ ###\ndef median_three(nums, left, mid, right)\n  # 3つの候補要素の中央値を選ぶ\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m は l と r の間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l は m と r の間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### 3 つの候補要素の中央値を選ぶ ###\ndef median_three(nums, left, mid, right)\n  # 3つの候補要素の中央値を選ぶ\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m は l と r の間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l は m と r の間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n# ## 番兵分割（三数中央値）###\ndef partition(nums, left, right)\n  # ## nums[left] を基準値とする\n  med = median_three(nums, left, (left + right) / 2, right)\n  # 中央値を配列の最左端に交換する\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   再帰の深さの最適化","text":"<p>一部の入力では、クイックソートは多くの空間を消費する可能性があります。完全に整列済みの入力配列を例にとり、再帰中の部分配列の長さを \\(m\\) とします。各回のパーティション操作では長さ \\(0\\) の左部分配列と長さ \\(m - 1\\) の右部分配列が生成されます。これは、各再帰呼び出しで減る問題サイズが非常に小さいこと（要素が 1 つ減るだけ）を意味し、再帰木の高さは \\(n - 1\\) に達するため、このとき \\(O(n)\\) のスタックフレーム空間を占有します。</p> <p>スタックフレーム空間の蓄積を防ぐために、各回のパーティション完了後に 2 つの部分配列の長さを比較し、**短いほうの部分配列に対してのみ再帰**を行えます。短い部分配列の長さは \\(n / 2\\) を超えないため、この方法なら再帰の深さを \\(\\log n\\) 以下に抑えられ、最悪時の空間計算量を \\(O(\\log n)\\) まで最適化できます。コードを以下に示します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"クイックソート（再帰深度最適化）\"\"\"\n    # 部分配列の長さが 1 なら終了\n    while left &lt; right:\n        # 番兵による分割処理\n        pivot = self.partition(nums, left, right)\n        # 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # 左部分配列を再帰的にソート\n            left = pivot + 1  # 未ソート区間の残りは [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # 右部分配列を再帰的にソート\n            right = pivot - 1  # 未ソート区間の残りは [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1;                 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1;                 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* クイックソート（再帰深度最適化） */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = Partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // 左部分配列を再帰的にソート\n            left = pivot + 1;  // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* クイックソート（再帰深度最適化） */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // 部分配列の長さが 1 なら終了\n    for left &lt; right {\n        // 番兵による分割処理\n        pivot := q.partition(nums, left, right)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // 左部分配列を再帰的にソート\n            left = pivot + 1                 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // 右部分配列を再帰的にソート\n            right = pivot - 1                 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* クイックソート（再帰深度最適化） */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // 部分配列の長さが 1 なら終了\n    while left &lt; right {\n        // 番兵による分割処理\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // 左部分配列を再帰的にソート\n            left = pivot + 1 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // 右部分配列を再帰的にソート\n            right = pivot - 1 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* クイックソート（再帰深度最適化） */\nquickSort(nums, left, right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        let pivot = this.partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* クイックソート（再帰深度最適化） */\nquickSort(nums: number[], left: number, right: number): void {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        let pivot = this.partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 部分配列の長さが 1 なら終了\n  while (left &lt; right) {\n    // 番兵による分割処理\n    int pivot = _partition(nums, left, right);\n    // 2 つの部分配列のうち短いほうにクイックソートを適用する\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート\n      left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート\n      right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* クイックソート（再帰深度最適化） */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // 部分配列の長さが 1 なら終了\n    while left &lt; right {\n        // 番兵による分割処理\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // 左部分配列を再帰的にソート\n            left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // 右部分配列を再帰的にソート\n            right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* クイックソート（再帰深度最適化） */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // 部分配列の長さが 1 なら終了\n    while (left &lt; right) {\n        // 番兵による分割処理\n        int pivot = partition(nums, left, right);\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - left &lt; right - pivot) {\n            // 左部分配列を再帰的にソート\n            quickSortTailCall(nums, left, pivot - 1);\n            // 未ソート区間の残りは [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // 右部分配列を再帰的にソート\n            quickSortTailCall(nums, pivot + 1, right);\n            // 未ソート区間の残りは [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* クイックソート（再帰深度最適化） */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // 部分配列の長さが 1 なら終了\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // 番兵による分割処理\n        val pivot = partition(nums, l, r)\n        // 2 つの部分配列のうち短いほうにクイックソートを適用する\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // 左部分配列を再帰的にソート\n            l = pivot + 1 // 未ソート区間の残りは [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // 右部分配列を再帰的にソート\n            r = pivot - 1 // 未ソート区間の残りは [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### 番兵分割 ###\ndef partition(nums, left, right)\n  # nums[left] を基準値とする\n  i = left\n  j = right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 右から左へ基準値未満の最初の要素を探す\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 左から右へ基準値より大きい最初の要素を探す\n    end\n    # 要素の交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 基準値を 2 つの部分配列の境界へ交換する\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 基準値のインデックスを返す\nend\n\n# ## クイックソート（再帰深度最適化）###\ndef quick_sort(nums, left, right)\n  # 部分配列の長さが 1 でない場合は再帰する\n  while left &lt; right\n    # 番兵分割\n    pivot = partition(nums, left, right)\n    # 2 つの部分配列のうち短いほうにクイックソートを適用する\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # 未ソート区間の残りは [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # 未ソート区間の残りは [left, pivot - 1]\n    end\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.5 &nbsp; クイックソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   基数ソート","text":"<p>前節では計数ソートを紹介しました。これは、データ量 \\(n\\) が大きく、データ範囲 \\(m\\) が小さい場合に適しています。\\(n = 10^6\\) 個の学籍番号をソートすると仮定すると、学籍番号は \\(8\\) 桁の数字なので、データ範囲 \\(m = 10^8\\) は非常に大きくなります。計数ソートでは大量のメモリ空間を確保する必要がありますが、基数ソートではこの問題を回避できます。</p> <p>基数ソート（radix sort）の基本的な考え方は計数ソートと同じで、個数を数えることによってソートを実現します。そのうえで、基数ソートは各桁の段階的な関係を利用し、各桁を順にソートすることで、最終的なソート結果を得ます。</p>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   アルゴリズムの流れ","text":"<p>学籍番号データを例にすると、数字の最下位桁を第 \\(1\\) 位、最上位桁を第 \\(8\\) 位としたとき、基数ソートの流れは次図のようになります。</p> <ol> <li>桁番号 \\(k = 1\\) を初期化します。</li> <li>学籍番号の第 \\(k\\) 位に対して「計数ソート」を実行します。完了すると、データは第 \\(k\\) 位に従って昇順に並びます。</li> <li>\\(k\\) を \\(1\\) 増やし、手順 <code>2.</code> に戻って反復を続けます。すべての桁のソートが完了したら終了します。</li> </ol> <p></p> <p> 図 11-18   基数ソートのアルゴリズムの流れ </p> <p>以下ではコード実装を分解して見ていきます。\\(d\\) 進数の数値 \\(x\\) について、その第 \\(k\\) 位 \\(x_k\\) を取得するには、次の計算式を用います。</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>ここで、\\(\\lfloor a \\rfloor\\) は浮動小数点数 \\(a\\) の切り捨てを表し、\\(\\bmod \\: d\\) は \\(d\\) による剰余を表します。学籍番号データでは、\\(d = 10\\) かつ \\(k \\in [1, 8]\\) です。</p> <p>さらに、数字の第 \\(k\\) 位に基づいてソートできるように、計数ソートのコードを少し変更する必要があります。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"要素 num の下から k 桁目を取得（exp = 10^(k-1)）\"\"\"\n    # ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"計数ソート（nums の k 桁目でソート）\"\"\"\n    # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    counter = [0] * 10\n    n = len(nums)\n    # 0~9 の各数字の出現回数を集計する\n    for i in range(n):\n        d = digit(nums[i], exp)  # nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1  # 数字 d の出現回数を数える\n    # 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # d の配列内インデックス j を取得する\n        res[j] = nums[i]  # 現在の要素をインデックス j に格納する\n        counter[d] -= 1  # d の個数を 1 減らす\n    # 結果で元の配列 nums を上書きする\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"基数ソート\"\"\"\n    # 最大桁数の判定用に配列の最大要素を取得\n    m = max(nums)\n    # 下位桁から上位桁の順に走査する\n    exp = 1\n    while exp &lt;= m:\n        # 配列要素の k 桁目に対して計数ソートを行う\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # つまり exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = *max_element(nums.begin(), nums.end());\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(int[] nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int[] counter = new int[10];\n    int n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(int[] nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint Digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++;                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nvoid RadixSort(int[] nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunc digit(num, exp int) int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunc countingSortDigit(nums []int, exp int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    counter := make([]int, 10)\n    n := len(nums)\n    // 0~9 の各数字の出現回数を集計する\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d]++             // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i]    // 現在の要素をインデックス j に格納する\n        counter[d]--        // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* 基数ソート */\nfunc radixSort(nums []int) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    var counter = Array(repeating: 0, count: 10)\n    // 0~9 の各数字の出現回数を集計する\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1 // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i] // 現在の要素をインデックス j に格納する\n        counter[d] -= 1 // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* 基数ソート */\nfunc radixSort(nums: inout [Int]) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunction digit(num, exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunction countingSortDigit(nums, exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d]--; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nfunction radixSort(nums) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m = Math.max(... nums);\n    // 下位桁から上位桁の順に走査する\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfunction digit(num: number, exp: number): number {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 0~9 の各数字の出現回数を集計する\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d]++; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d]--; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基数ソート */\nfunction radixSort(nums: number[]): void {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m: number = Math.max(... nums);\n    // 下位桁から上位桁の順に走査する\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* 要素 `_num` の第 k 桁を取得する。ここで `exp = 10^(k-1)` */\nint digit(int _num, int exp) {\n  // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n  return (_num ~/ exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // 0~9 の各数字の出現回数を集計する\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n    counter[d]++; // 数字 d の出現回数を数える\n  }\n  // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // d の配列内インデックス j を取得する\n    res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n    counter[d]--; // d の個数を 1 減らす\n  }\n  // 結果で元の配列 nums を上書きする\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* 基数ソート */\nvoid radixSort(List&lt;int&gt; nums) {\n  // 最大桁数の判定用に配列の最大要素を取得する\n  // dart の `int` の長さは 64 ビット\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // 下位桁から上位桁の順に走査する\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // 配列要素の k 桁目に対して計数ソートを行う\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // つまり exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return ((num / exp) % 10) as usize;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // 0~9 の各数字の出現回数を集計する\n    for i in 0..n {\n        let d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする\n        counter[d] += 1; // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i]; // 現在の要素をインデックス j に格納する\n        counter[d] -= 1; // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    nums.copy_from_slice(&amp;res);\n}\n\n/* 基数ソート */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    let m = *nums.into_iter().max().unwrap();\n    // 下位桁から上位桁の順に走査する\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nint digit(int num, int exp) {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10;\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // 後続のメモリ解放に備えて 0 で初期化する\n    // 0~9 の各数字の出現回数を集計する\n    for (int i = 0; i &lt; size; i++) {\n        // nums[i] の第 k 位を取得し、d とする\n        int d = digit(nums[i], exp);\n        // 数字 d の出現回数を数える\n        counter[d]++;\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // d の配列内インデックス j を取得する\n        res[j] = nums[i];       // 現在の要素をインデックス j に格納する\n        counter[d]--;           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // メモリを解放する\n    free(res);\n    free(counter);\n}\n\n/* 基数ソート */\nvoid radixSort(int nums[], int size) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // 下位桁から上位桁の順に走査する\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */\nfun digit(num: Int, exp: Int): Int {\n    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す\n    return (num / exp) % 10\n}\n\n/* 計数ソート（nums の k 桁目でソート） */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n    val counter = IntArray(10)\n    val n = nums.size\n    // 0~9 の各数字の出現回数を集計する\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // nums[i] の第 k 位を取得し、d とする\n        counter[d]++                // 数字 d の出現回数を数える\n    }\n    // 累積和を求め、「出現回数」を「配列インデックス」に変換する\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // d の配列内インデックス j を取得する\n        res[j] = nums[i]       // 現在の要素をインデックス j に格納する\n        counter[d]--           // d の個数を 1 減らす\n    }\n    // 結果で元の配列 nums を上書きする\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* 基数ソート */\nfun radixSort(nums: IntArray) {\n    // 最大桁数の判定用に配列の最大要素を取得\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // 下位桁から上位桁の順に走査する\n    while (exp &lt;= m) {\n        // 配列要素の k 桁目に対して計数ソートを行う\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // つまり exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### num の第 k 桁を取得する。ここで exp = 10^(k-1) ###\ndef digit(num, exp)\n  # k ではなく exp を渡すことで、ここで高コストな累乗計算を繰り返し実行するのを避けられる\n  (num / exp) % 10\nend\n\n### num の第 k 桁を取得する。ここで exp = 10^(k-1) ###\ndef digit(num, exp)\n  # k ではなく exp を渡すことで、ここで高コストな累乗計算を繰り返し実行するのを避けられる\n  (num / exp) % 10\nend\n\n# ## 計数ソート（nums の k 桁目でソート）###\ndef counting_sort_digit(nums, exp)\n  # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要\n  counter = Array.new(10, 0)\n  n = nums.length\n  # 0~9 の各数字の出現回数を集計する\n  for i in 0...n\n    d = digit(nums[i], exp) # nums[i] の第 k 位を取得し、d とする\n    counter[d] += 1 # 数字 d の出現回数を数える\n  end\n  # 累積和を求め、「出現回数」を「配列インデックス」に変換する\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # d の配列内インデックス j を取得する\n    res[j] = nums[i] # 現在の要素をインデックス j に格納する\n    counter[d] -= 1 # d の個数を 1 減らす\n  end\n  # 結果で元の配列 nums を上書きする\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### 基数ソート ###\ndef radix_sort(nums)\n  # 最大桁数の判定用に配列の最大要素を取得\n  m = nums.max\n  # 下位桁から上位桁の順に走査する\n  exp = 1\n  while exp &lt;= m\n    # 配列要素の k 桁目に対して計数ソートを行う\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # つまり exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>なぜ最下位桁からソートするのですか？</p> <p>連続するソートの各ラウンドでは、後のラウンドの結果が前のラウンドの結果を上書きします。たとえば、第1ラウンドで \\(a &lt; b\\) となっていても、第2ラウンドで \\(a &gt; b\\) となれば、第2ラウンドの結果が優先されます。数字では高位の優先度が低位より高いため、先に低位をソートし、その後で高位をソートする必要があります。</p>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   アルゴリズムの特徴","text":"<p>計数ソートと比べると、基数ソートは値の範囲が大きい場合に適しています。ただし、データが固定桁数の形式で表せること、かつ桁数が大きすぎないことが前提です。たとえば、浮動小数点数は基数ソートに適していません。桁数 \\(k\\) が大きすぎて、時間計算量が \\(O(nk) \\gg O(n^2)\\) になる可能性があるためです。</p> <ul> <li>時間計算量は \\(O(nk)\\)、非適応ソート：データ量を \\(n\\)、データが \\(d\\) 進数、最大桁数を \\(k\\) とすると、ある1桁に対して計数ソートを実行する時間は \\(O(n + d)\\) であり、全 \\(k\\) 桁をソートする時間は \\(O((n + d)k)\\) です。通常、\\(d\\) と \\(k\\) はどちらも比較的小さいため、時間計算量は \\(O(n)\\) に近づきます。</li> <li>空間計算量は \\(O(n + d)\\)、非原地ソート：計数ソートと同様に、基数ソートでは長さ \\(n\\) と \\(d\\) の配列 <code>res</code> と <code>counter</code> を補助的に用います。</li> <li>安定ソート：計数ソートが安定であれば基数ソートも安定です。計数ソートが不安定な場合、基数ソートでは正しいソート結果を保証できません。</li> </ul>","path":["第 11 章 &nbsp; ソート","11.10 &nbsp; 基数ソート"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   選択ソート","text":"<p>選択ソート（selection sort）の仕組みは非常に単純です。ループを開始し、各ラウンドで未ソート区間から最小の要素を選び、整列済み区間の末尾に配置します。</p> <p>配列の長さを \\(n\\) とすると、選択ソートの手順は次の図のようになります。</p> <ol> <li>初期状態では、すべての要素が未ソートであり、未ソートな（インデックス）区間は \\([0, n-1]\\) です。</li> <li>区間 \\([0, n-1]\\) 内の最小要素を選び、インデックス \\(0\\) の要素と交換します。これにより、配列の先頭 1 要素が整列済みになります。</li> <li>区間 \\([1, n-1]\\) 内の最小要素を選び、インデックス \\(1\\) の要素と交換します。これにより、配列の先頭 2 要素が整列済みになります。</li> <li>これを繰り返します。\\(n - 1\\) 回の選択と交換を経ると、配列の先頭 \\(n - 1\\) 要素が整列済みになります。</li> <li>残った 1 つの要素は必ず最大要素なので、ソートは不要です。これで配列のソートは完了します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 11-2   選択ソートの手順 </p> <p>コードでは、\\(k\\) を用いて未ソート区間内の最小要素を記録します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"選択ソート\"\"\"\n    n = len(nums)\n    # 外側ループ：未整列区間は [i, n-1]\n    for i in range(n - 1):\n        # 内側のループ：未ソート区間の最小要素を見つける\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # 最小要素のインデックスを記録\n        # その最小要素を未整列区間の先頭要素と交換する\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* 選択ソート */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* 選択ソート */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* 選択ソート */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* 選択ソート */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // 外側ループ：未整列区間は [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // 最小要素のインデックスを記録\n                k = j\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* 選択ソート */\nfunc selectionSort(nums: inout [Int]) {\n    // 外側ループ：未整列区間は [i, n-1]\n    for i in nums.indices.dropLast() {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* 選択ソート */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* 選択ソート */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // 外側ループ：未整列区間は [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* 選択ソート */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // 外側ループ：未整列区間は [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // 内側のループ：未ソート区間の最小要素を見つける\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // 最小要素のインデックスを記録\n    }\n    // その最小要素を未整列区間の先頭要素と交換する\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* 選択ソート */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // 外側ループ：未整列区間は [i, n-1]\n    for i in 0..n - 1 {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // 最小要素のインデックスを記録\n            }\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* 選択ソート */\nvoid selectionSort(int nums[], int n) {\n    // 外側ループ：未整列区間は [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 内側のループ：未ソート区間の最小要素を見つける\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* 選択ソート */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // 外側ループ：未整列区間は [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // 内側のループ：未ソート区間の最小要素を見つける\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // 最小要素のインデックスを記録\n        }\n        // その最小要素を未整列区間の先頭要素と交換する\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### 選択ソート ###\ndef selection_sort(nums)\n  n = nums.length\n  # 外側ループ：未整列区間は [i, n-1]\n  for i in 0...(n - 1)\n    # 内側のループ：未ソート区間の最小要素を見つける\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # 最小要素のインデックスを記録\n      end\n    end\n    # その最小要素を未整列区間の先頭要素と交換する\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 11 章 &nbsp; ソート","11.2 &nbsp; 選択ソート"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   アルゴリズムの特徴","text":"<ul> <li>時間計算量は \\(O(n^2)\\)、非適応ソート：外側のループは合計 \\(n - 1\\) 回です。最初のラウンドの未ソート区間の長さは \\(n\\)、最後のラウンドでは \\(2\\) であり、各ラウンドの内側のループ回数はそれぞれ \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(3\\)、\\(2\\) となります。総和は \\(\\frac{(n - 1)(n + 2)}{2}\\) です。</li> <li>空間計算量は \\(O(1)\\)、インプレースソート：ポインタ \\(i\\) と \\(j\\) は定数サイズの追加領域しか使用しません。</li> <li>不安定ソート：次の図のように、要素 <code>nums[i]</code> がそれと等しい要素の右側へ交換され、両者の相対的な順序が変わる可能性があります。</li> </ul> <p> 図 11-3   選択ソートの不安定な例 </p>","path":["第 11 章 &nbsp; ソート","11.2 &nbsp; 選択ソート"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   ソートアルゴリズム","text":"<p>ソートアルゴリズム（sorting algorithm）は、データの集合を特定の順序に従って並べ替えるために用いられます。ソートアルゴリズムは幅広く応用されており、整列済みデータは通常、より効率的に検索、分析、処理できるためです。</p> <p>下図に示すように、ソートアルゴリズムにおけるデータ型は整数、浮動小数点数、文字、文字列などです。ソートの判定規則は、数値の大小、文字の ASCII コード順、またはカスタムルールなど、要件に応じて設定できます。</p> <p></p> <p> 図 11-1   データ型と判定規則の例 </p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   評価軸","text":"<p>実行効率：ソートアルゴリズムの時間計算量はできるだけ低く、かつ全体の操作回数も少ないこと（時間計算量における定数項が小さいこと）が望まれます。大量データの場合、実行効率はとりわけ重要です。</p> <p>インプレース性：その名のとおり、インプレースソートは元の配列を直接操作して並べ替えを行うため、追加の補助配列を必要とせず、メモリを節約できます。通常、インプレースソートはデータの移動操作が少なく、実行速度もより高速です。</p> <p>安定性：安定ソートは、並べ替え完了後も、等しい要素の配列内での相対順序が変化しません。</p> <p>安定ソートは多段ソートの場面で必要条件となります。学生情報を保存した表があり、第 1 列と第 2 列がそれぞれ氏名と年齢であると仮定します。この場合、不安定ソートによって入力データの順序性が失われる可能性があります。</p> <pre><code># 入力データは氏名順にソートされている\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# 不安定ソートアルゴリズムで年齢順にリストを並べ替えると仮定すると、\n# 結果では ('D', 19) と ('A', 19) の相対位置が変わり、\n# 入力データが氏名順である性質が失われる\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>適応性：適応的ソートは、入力データに既に存在する順序情報を利用して計算量を減らし、より優れた時間効率を実現できます。適応的ソートアルゴリズムの最良時間計算量は、通常、平均時間計算量より優れています。</p> <p>比較ベースかどうか：比較ベースのソートは、比較演算子（\\(&lt;\\)、\\(=\\)、\\(&gt;\\)）に依存して要素の相対順序を判定し、それによって配列全体をソートします。理論上の最良時間計算量は \\(O(n \\log n)\\) です。一方、非比較ソートは比較演算子を使用せず、時間計算量は \\(O(n)\\) に達しますが、汎用性は相対的に低くなります。</p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   理想的なソートアルゴリズム","text":"<p>高速、インプレース、安定、適応的、高い汎用性。明らかに、これまでのところ、以上のすべての特性を兼ね備えたソートアルゴリズムはまだ見つかっていません。そのため、ソートアルゴリズムを選択する際には、具体的なデータの特徴と問題の要件に応じて判断する必要があります。</p> <p>次に、さまざまなソートアルゴリズムを一緒に学び、上記の評価軸に基づいて各ソートアルゴリズムの長所と短所を分析していきます。</p>","path":["第 11 章 &nbsp; ソート","11.1 &nbsp; ソートアルゴリズム"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   まとめ","text":"","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   重要なポイントの振り返り","text":"<ul> <li>バブルソートは隣接する要素を交換することで整列を行います。フラグを追加して早期リターンを可能にすると、バブルソートの最良時間計算量を \\(O(n)\\) に最適化できます。</li> <li>挿入ソートは各ラウンドで未整列区間の要素を整列済み区間の正しい位置に挿入することで整列を完了します。挿入ソートの時間計算量は \\(O(n^2)\\) ですが、基本操作が比較的少ないため、小規模データのソート処理で非常に人気があります。</li> <li>クイックソートは番兵分割操作に基づいて整列を行います。番兵分割では毎回最悪の基準値を選んでしまう可能性があり、その結果、時間計算量は \\(O(n^2)\\) まで劣化することがあります。中央値の基準値やランダムな基準値を導入すると、この劣化の確率を下げられます。短い部分配列を優先して再帰すれば、再帰の深さを効果的に抑え、空間計算量を \\(O(\\log n)\\) に最適化できます。</li> <li>マージソートは分割とマージという 2 つの段階からなり、分割統治戦略を典型的に体現しています。マージソートでは配列を整列する際に補助配列の作成が必要で、空間計算量は \\(O(n)\\) です。一方、連結リストを整列する場合の空間計算量は \\(O(1)\\) まで最適化できます。</li> <li>バケットソートはデータのバケット分配、バケット内ソート、結果の結合という 3 つの手順を含みます。これも分割統治戦略を体現しており、データ量が非常に大きい場合に適しています。バケットソートの鍵は、データを平均的に分配することにあります。</li> <li>カウントソートはバケットソートの特例であり、データの出現回数を数えることで整列を行います。カウントソートはデータ量が大きく、かつデータ範囲が限られている場合に適しており、データを正の整数に変換できることが前提です。</li> <li>基数ソートは各桁ごとの整列によってデータを整列し、データが固定桁数の数値として表せることを前提とします。</li> <li>総じて言えば、私たちは高効率で、安定で、インプレースで、さらに適応的であるといった利点を備えたソートアルゴリズムを見つけたいと考えます。しかし、ほかのデータ構造やアルゴリズムと同様に、これらすべての条件を同時に満たせるソートアルゴリズムは存在しません。実際の応用では、データの特性に応じて適切なソートアルゴリズムを選ぶ必要があります。</li> <li>下図では、主流のソートアルゴリズムについて、効率、安定性、インプレース性、適応性などを比較しています。</li> </ul> <p> 図 11-19   ソートアルゴリズムの比較 </p>","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ソートアルゴリズムの安定性は、どのような場合に必須ですか？</p> <p>現実には、オブジェクトのある属性に基づいて整列することがあります。たとえば、学生には氏名と身長という 2 つの属性があり、多段階のソートを行いたいとします。まず氏名で整列して <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> を得て、その後に身長で整列します。ソートアルゴリズムが不安定である場合、結果は <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> になる可能性があります。</p> <p>このように、学生 D と C の位置が入れ替わり、氏名に関する順序性が壊れてしまいます。これは望ましくありません。</p> <p>Q：番兵分割において、「右から左へ探索する」順序と「左から右へ探索する」順序は入れ替えられますか？</p> <p>できません。最も左端の要素を基準値とする場合は、必ず先に「右から左へ探索する」を行い、その後に「左から右へ探索する」を行う必要があります。この結論はやや直感に反するので、理由を分析してみましょう。</p> <p>番兵分割 <code>partition()</code> の最後の手順は、<code>nums[left]</code> と <code>nums[i]</code> を交換することです。交換が終わると、基準値の左側にある要素はすべて基準値 <code>&lt;=</code> になります。したがって、最後の交換の前に <code>nums[left] &gt;= nums[i]</code> が必ず成り立っていなければなりません。仮に先に「左から右へ探索する」を行うと、基準値より大きい要素が見つからない場合、<code>i == j</code> の時点でループを抜け、このとき <code>nums[j] == nums[i] &gt; nums[left]</code> となる可能性があります。つまり、この最後の交換によって、基準値より大きい要素が配列の最左端へ移されてしまい、番兵分割は失敗します。</p> <p>たとえば、配列 <code>[0, 0, 0, 0, 1]</code> が与えられたとき、先に「左から右へ探索する」を行うと、番兵分割後の配列は <code>[1, 0, 0, 0, 0]</code> になります。これは誤った結果です。</p> <p>さらに考えると、<code>nums[right]</code> を基準値に選ぶ場合はちょうど逆になり、必ず先に「左から右へ探索する」を行う必要があります。</p> <p>Q：クイックソートの再帰深度最適化について、短い配列を選ぶとなぜ再帰深度が \\(\\log n\\) を超えないと保証できるのですか？</p> <p>再帰深度とは、現在まだ戻っていない再帰呼び出しの数のことです。各ラウンドの番兵分割では、元の配列を 2 つの部分配列に分けます。再帰深度の最適化後は、下方向に再帰する部分配列の長さは最大でも元の配列長の半分です。最悪の場合でも毎回半分の長さになると仮定すれば、最終的な再帰深度は \\(\\log n\\) になります。</p> <p>元のクイックソートを振り返ると、長いほうの配列に対して連続して再帰してしまう可能性があり、最悪の場合は \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) と続き、再帰深度は \\(n\\) になります。再帰深度の最適化により、このような状況を避けられます。</p> <p>Q：配列内のすべての要素が等しい場合、クイックソートの時間計算量は \\(O(n^2)\\) になりますか？このような退化はどう処理すべきですか？</p> <p>はい。この場合は、番兵分割によって配列を「基準値より小さい」「基準値に等しい」「基準値より大きい」の 3 つの部分に分ける方法を検討できます。下方向に再帰するのは、小さい部分と大きい部分だけです。この方法では、入力要素がすべて等しい配列は、1 回の番兵分割だけで整列を完了できます。</p> <p>Q：バケットソートの最悪時間計算量が \\(O(n^2)\\) なのはなぜですか？</p> <p>最悪の場合、すべての要素が同じバケットに振り分けられます。その要素群を整列するのに \\(O(n^2)\\) のアルゴリズムを使えば、時間計算量は \\(O(n^2)\\) になります。</p>","path":["第 11 章 &nbsp; ソート","11.11 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"第 5 章   スタックとキュー","text":"<p>Abstract</p> <p>スタックは猫を積み重ねるようなもので、キューは猫が列に並ぶようなものです。</p> <p>両者はそれぞれ、後入れ先出しと先入れ先出しの論理関係を表します。</p>","path":["第 5 章 &nbsp; スタックとキュー"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"章の内容","text":"<ul> <li>5.1   スタック</li> <li>5.2   キュー</li> <li>5.3   両端キュー</li> <li>5.4   まとめ</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   両端キュー","text":"<p>キューでは、先頭要素を削除するか末尾に要素を追加することしかできません。次の図に示すように、両端キュー（double-ended queue）はより高い柔軟性を備えており、先頭と末尾の両方で要素の追加や削除を行えます。</p> <p></p> <p> 図 5-7   両端キューの操作 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   両端キューの基本操作","text":"<p>両端キューの基本操作を次の表に示します。具体的なメソッド名は、使用するプログラミング言語によって異なります。</p> <p> 表 5-3   両端キューの操作効率 </p> メソッド名 説明 時間計算量 <code>push_first()</code> 先頭に要素を追加 \\(O(1)\\) <code>push_last()</code> 末尾に要素を追加 \\(O(1)\\) <code>pop_first()</code> 先頭要素を削除 \\(O(1)\\) <code>pop_last()</code> 末尾要素を削除 \\(O(1)\\) <code>peek_first()</code> 先頭要素にアクセス \\(O(1)\\) <code>peek_last()</code> 末尾要素にアクセス \\(O(1)\\) <p>同様に、プログラミング言語に組み込み実装されている両端キューのクラスを直接使うこともできます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# 両端キューを初期化\ndeq: deque[int] = deque()\n\n# 要素をエンキュー\ndeq.append(2)      # 末尾に追加\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # 先頭に追加\ndeq.appendleft(1)\n\n# 要素にアクセス\nfront: int = deq[0]  # 先頭要素\nrear: int = deq[-1]  # 末尾要素\n\n# 要素をデキュー\npop_front: int = deq.popleft()  # 先頭要素をデキュー\npop_rear: int = deq.pop()       # 末尾要素をデキュー\n\n# 両端キューの長さを取得\nsize: int = len(deq)\n\n# 両端キューが空かどうかを判定\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* 両端キューを初期化 */\ndeque&lt;int&gt; deque;\n\n/* 要素をエンキュー */\ndeque.push_back(2);   // 末尾に追加\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // 先頭に追加\ndeque.push_front(1);\n\n/* 要素にアクセス */\nint front = deque.front(); // 先頭要素\nint back = deque.back();   // 末尾要素\n\n/* 要素をデキュー */\ndeque.pop_front();  // 先頭要素をデキュー\ndeque.pop_back();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.size();\n\n/* 両端キューが空かどうかを判定 */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* 両端キューを初期化 */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* 要素をエンキュー */\ndeque.offerLast(2);   // 末尾に追加\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // 先頭に追加\ndeque.offerFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.peekFirst();  // 先頭要素\nint peekLast = deque.peekLast();    // 末尾要素\n\n/* 要素をデキュー */\nint popFirst = deque.pollFirst();  // 先頭要素をデキュー\nint popLast = deque.pollLast();    // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.size();\n\n/* 両端キューが空かどうかを判定 */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* 両端キューを初期化 */\n// C# では、連結リスト LinkedList を両端キューとして使用する\nLinkedList&lt;int&gt; deque = new();\n\n/* 要素をエンキュー */\ndeque.AddLast(2);   // 末尾に追加\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // 先頭に追加\ndeque.AddFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.First.Value;  // 先頭要素\nint peekLast = deque.Last.Value;    // 末尾要素\n\n/* 要素をデキュー */\ndeque.RemoveFirst();  // 先頭要素をデキュー\ndeque.RemoveLast();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.Count;\n\n/* 両端キューが空かどうかを判定 */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* 両端キューを初期化 */\n// Go では、list を両端キューとして使用する\ndeque := list.New()\n\n/* 要素をエンキュー */\ndeque.PushBack(2)      // 末尾に追加\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // 先頭に追加\ndeque.PushFront(1)\n\n/* 要素にアクセス */\nfront := deque.Front() // 先頭要素\nrear := deque.Back()   // 末尾要素\n\n/* 要素をデキュー */\ndeque.Remove(front)    // 先頭要素をデキュー\ndeque.Remove(rear)     // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nsize := deque.Len()\n\n/* 両端キューが空かどうかを判定 */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* 両端キューを初期化 */\n// Swift には組み込みの両端キュークラスがないため、Array を両端キューとして使用する\nvar deque: [Int] = []\n\n/* 要素をエンキュー */\ndeque.append(2) // 末尾に追加\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // 先頭に追加\ndeque.insert(1, at: 0)\n\n/* 要素にアクセス */\nlet peekFirst = deque.first! // 先頭要素\nlet peekLast = deque.last! // 末尾要素\n\n/* 要素をデキュー */\n// Array で模擬する場合、popFirst の計算量は O(n)\nlet popFirst = deque.removeFirst() // 先頭要素をデキュー\nlet popLast = deque.removeLast() // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nlet size = deque.count\n\n/* 両端キューが空かどうかを判定 */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* 両端キューを初期化 */\n// JavaScript には組み込みの両端キューがないため、Array を両端キューとして使用するしかない\nconst deque = [];\n\n/* 要素をエンキュー */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 配列であるため、unshift() メソッドの時間計算量は O(n) です\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 要素にアクセス */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* 要素をデキュー */\n// 配列であるため、shift() メソッドの時間計算量は O(n) です\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* 両端キューの長さを取得 */\nconst size = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* 両端キューを初期化 */\n// TypeScript には組み込みの両端キューがないため、Array を両端キューとして使用するしかない\nconst deque: number[] = [];\n\n/* 要素をエンキュー */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 配列であるため、unshift() メソッドの時間計算量は O(n) です\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 要素にアクセス */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* 要素をデキュー */\n// 配列であるため、shift() メソッドの時間計算量は O(n) です\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* 両端キューの長さを取得 */\nconst size: number = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* 両端キューを初期化 */\n// Dart では、Queue は両端キューとして定義されています\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* 要素をエンキュー */\ndeque.addLast(2);  // 末尾に追加\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // 先頭に追加\ndeque.addFirst(1);\n\n/* 要素にアクセス */\nint peekFirst = deque.first; // 先頭要素\nint peekLast = deque.last;   // 末尾要素\n\n/* 要素をデキュー */\nint popFirst = deque.removeFirst(); // 先頭要素をデキュー\nint popLast = deque.removeLast();   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nint size = deque.length;\n\n/* 両端キューが空かどうかを判定 */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* 両端キューを初期化 */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 要素をエンキュー */\ndeque.push_back(2);  // 末尾に追加\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // 先頭に追加\ndeque.push_front(1);\n\n/* 要素にアクセス */\nif let Some(front) = deque.front() { // 先頭要素\n}\nif let Some(rear) = deque.back() {   // 末尾要素\n}\n\n/* 要素をデキュー */\nif let Some(pop_front) = deque.pop_front() { // 先頭要素をデキュー\n}\nif let Some(pop_rear) = deque.pop_back() {   // 末尾要素をデキュー\n}\n\n/* 両端キューの長さを取得 */\nlet size = deque.len();\n\n/* 両端キューが空かどうかを判定 */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C には組み込みの両端キューがありません\n</code></pre> deque.kt<pre><code>/* 両端キューを初期化 */\nval deque = LinkedList&lt;Int&gt;()\n\n/* 要素をエンキュー */\ndeque.offerLast(2)  // 末尾に追加\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // 先頭に追加\ndeque.offerFirst(1)\n\n/* 要素にアクセス */\nval peekFirst = deque.peekFirst() // 先頭要素\nval peekLast = deque.peekLast()   // 末尾要素\n\n/* 要素をデキュー */\nval popFirst = deque.pollFirst() // 先頭要素をデキュー\nval popLast = deque.pollLast()   // 末尾要素をデキュー\n\n/* 両端キューの長さを取得 */\nval size = deque.size\n\n/* 両端キューが空かどうかを判定 */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># 両端キューを初期化\n# Ruby には組み込みの両端キューがないため、Array を両端キューとして使用するしかありません\ndeque = []\n\n# 要素をエンキュー\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# 配列であるため、Array#unshift メソッドの時間計算量は O(n) です\ndeque.unshift(3)\ndeque.unshift(1)\n\n# 要素にアクセス\npeek_first = deque.first\npeek_last = deque.last\n\n# 要素をデキュー\n# 配列であるため、 Array#shift メソッドの時間計算量は O(n) です\npop_front = deque.shift\npop_back = deque.pop\n\n# 両端キューの長さを取得\nsize = deque.length\n\n# 両端キューが空かどうかを判定\nis_empty = size.zero?\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   両端キューの実装 *","text":"<p>両端キューの実装はキューと似ており、連結リストまたは配列を基盤となるデータ構造として選べます。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   双方向連結リストに基づく実装","text":"<p>前節を振り返ると、通常の単方向連結リストを使ってキューを実装しました。これは、先頭ノードの削除（デキューに対応）と末尾ノードの後ろへの新規ノード追加（エンキューに対応）を容易に行えるためです。</p> <p>両端キューでは、先頭と末尾のどちらでもエンキューとデキューを行えます。言い換えると、両端キューではもう一方の対称方向の操作も実装する必要があります。そのため、両端キューの基盤データ構造として「双方向連結リスト」を採用します。</p> <p>次の図に示すように、双方向連結リストの先頭ノードと末尾ノードを両端キューの先頭と末尾と見なし、両端でノードを追加および削除する機能を実現します。</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 5-8   連結リストによる両端キューのエンキューとデキュー </p> <p>実装コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"双方向連結リストノード\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"コンストラクタ\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # 後続ノードへの参照\n        self.prev: ListNode | None = None  # 前駆ノードへの参照\n\nclass LinkedListDeque:\n    \"\"\"双方向連結リストベースの両端キュー\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._front: ListNode | None = None  # 先頭ノード front\n        self._rear: ListNode | None = None  # 末尾ノード rear\n        self._size: int = 0  # 両端キューの長さ\n\n    def size(self) -&gt; int:\n        \"\"\"両端キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"両端キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"エンキュー操作\"\"\"\n        node = ListNode(num)\n        # 連結リストが空なら、front と rear の両方を node に向ける\n        if self.is_empty():\n            self._front = self._rear = node\n        # 先頭へのエンキュー操作\n        elif is_front:\n            # node を連結リストの先頭に追加\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # 先頭ノードを更新する\n        # 末尾へのエンキュー操作\n        else:\n            # node を連結リストの末尾に追加\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # 末尾ノードを更新する\n        self._size += 1  # キューの長さを更新\n\n    def push_first(self, num: int):\n        \"\"\"キュー先頭にエンキュー\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"キュー末尾にエンキュー\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"デキュー操作\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        # キュー先頭からの取り出し\n        if is_front:\n            val: int = self._front.val  # 先頭ノードの値を一時保存\n            # 先頭ノードを削除\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # 先頭ノードを更新する\n        # キュー末尾からの取り出し\n        else:\n            val: int = self._rear.val  # 末尾ノードの値を一時保存\n            # 末尾ノードを削除\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # 末尾ノードを更新する\n        self._size -= 1  # キューの長さを更新\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"キュー先頭からデキュー\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"キュー末尾からデキュー\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"キュー末尾の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"出力用の配列を返す\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* 双方向連結リストノード */\nstruct DoublyListNode {\n    int val;              // ノード値\n    DoublyListNode *next; // 後継ノードへのポインタ\n    DoublyListNode *prev; // 前駆ノードへのポインタ\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize = 0;              // 両端キューの長さ\n\n  public:\n    /* コンストラクタ */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* デストラクタメソッド */\n    ~LinkedListDeque() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* 両端キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー操作 */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty())\n            front = rear = node;\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // 先頭ノードを更新する\n        // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // 末尾ノードを更新する\n        }\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* デキュー操作 */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"キューが空です\");\n        int val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front-&gt;val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // 先頭ノードを更新する\n        // キュー末尾からの取り出し\n        } else {\n            val = rear-&gt;val; // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // 末尾ノードを更新する\n        }\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return front-&gt;val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return rear-&gt;val;\n    }\n\n    /* 出力用の配列を返す */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    int val; // ノード値\n    ListNode next; // 後続ノードへの参照\n    ListNode prev; // 前駆ノードへの参照\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private ListNode front, rear; // 先頭ノード front、末尾ノード rear\n    private int queSize = 0; // 両端キューの長さ\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー操作 */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty())\n            front = rear = node;\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front.prev = node;\n            node.next = front;\n            front = node; // 先頭ノードを更新する\n        // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // 末尾ノードを更新する\n        }\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* デキュー操作 */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front.val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // 先頭ノードを更新する\n        // キュー末尾からの取り出し\n        } else {\n            val = rear.val; // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // 末尾ノードを更新する\n        }\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* 出力用の配列を返す */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* 双方向連結リストノード */\nclass ListNode(int val) {\n    public int val = val;       // ノード値\n    public ListNode? next = null; // 後続ノードへの参照\n    public ListNode? prev = null; // 前駆ノードへの参照\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    ListNode? front, rear; // 先頭ノード front、末尾ノード rear\n    int queSize = 0;      // 両端キューの長さ\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* エンキュー操作 */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // 先頭へのエンキュー操作\n        else if (isFront) {\n            // node を連結リストの先頭に追加\n            front!.prev = node;\n            node.next = front;\n            front = node; // 先頭ノードを更新する\n        }\n        // 末尾へのエンキュー操作\n        else {\n            // node を連結リストの末尾に追加\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // 末尾ノードを更新する\n        }\n\n        queSize++; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* デキュー操作 */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // キュー先頭からの取り出し\n        if (isFront) {\n            val = front?.val; // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // 先頭ノードを更新する\n        }\n        // キュー末尾からの取り出し\n        else {\n            val = rear?.val;  // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // 末尾ノードを更新する\n        }\n\n        queSize--; // キューの長さを更新\n        return val;\n    }\n\n    /* キュー先頭からデキュー */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* 出力用の配列を返す */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* 双方向連結リストベースの両端キュー */\ntype linkedListDeque struct {\n    // 組み込みパッケージ list を使う\n    data *list.List\n}\n\n/* 両端キューを初期化する */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* キュー先頭に要素を追加する */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* キュー末尾に要素を追加する */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* 先頭要素を取り出す */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 末尾要素を取り出す */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* キュー末尾の要素にアクセス */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* キューの長さを取得 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* キューが空かどうかを判定 */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    var val: Int // ノード値\n    var next: ListNode? // 後続ノードへの参照\n    weak var prev: ListNode? // 前駆ノードへの参照\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private var front: ListNode? // 先頭ノード front\n    private var rear: ListNode? // 末尾ノード rear\n    private var _size: Int // 両端キューの長さ\n\n    init() {\n        _size = 0\n    }\n\n    /* 両端キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー操作 */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // 先頭へのエンキュー操作\n        else if isFront {\n            // node を連結リストの先頭に追加\n            front?.prev = node\n            node.next = front\n            front = node // 先頭ノードを更新する\n        }\n        // 末尾へのエンキュー操作\n        else {\n            // node を連結リストの末尾に追加\n            rear?.next = node\n            node.prev = rear\n            rear = node // 末尾ノードを更新する\n        }\n        _size += 1 // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* キュー末尾にエンキュー */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* デキュー操作 */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        let val: Int\n        // キュー先頭からの取り出し\n        if isFront {\n            val = front!.val // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // 先頭ノードを更新する\n        }\n        // キュー末尾からの取り出し\n        else {\n            val = rear!.val // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // 末尾ノードを更新する\n        }\n        _size -= 1 // キューの長さを更新\n        return val\n    }\n\n    /* キュー先頭からデキュー */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* キュー末尾からデキュー */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return front!.val\n    }\n\n    /* キュー末尾の要素にアクセス */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return rear!.val\n    }\n\n    /* 出力用の配列を返す */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    prev; // 前駆ノードへの参照（ポインタ）\n    next; // 後継ノードへの参照（ポインタ）\n    val; // ノード値\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    #front; // 先頭ノード front\n    #rear; // 末尾ノード rear\n    #queSize; // 両端キューの長さ\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* 末尾へのエンキュー操作 */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // node を連結リストの末尾に追加\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // 末尾ノードを更新する\n        }\n        this.#queSize++;\n    }\n\n    /* 先頭へのエンキュー操作 */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // node を連結リストの先頭に追加\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // 先頭ノードを更新する\n        }\n        this.#queSize++;\n    }\n\n    /* キュー末尾からの取り出し */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // 末尾ノードの値を保存する\n        // 末尾ノードを削除\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // 末尾ノードを更新する\n        this.#queSize--;\n        return value;\n    }\n\n    /* キュー先頭からの取り出し */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // 末尾ノードの値を保存する\n        // 先頭ノードを削除\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // 先頭ノードを更新する\n        this.#queSize--;\n        return value;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* 両端キューの長さを取得 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 両端キューを出力する */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n    prev: ListNode; // 前駆ノードへの参照（ポインタ）\n    next: ListNode; // 後継ノードへの参照（ポインタ）\n    val: number; // ノード値\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private front: ListNode; // 先頭ノード front\n    private rear: ListNode; // 末尾ノード rear\n    private queSize: number; // 両端キューの長さ\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* 末尾へのエンキュー操作 */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // node を連結リストの末尾に追加\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // 末尾ノードを更新する\n        }\n        this.queSize++;\n    }\n\n    /* 先頭へのエンキュー操作 */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // node を連結リストの先頭に追加\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // 先頭ノードを更新する\n        }\n        this.queSize++;\n    }\n\n    /* キュー末尾からの取り出し */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // 末尾ノードの値を保存する\n        // 末尾ノードを削除\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // 末尾ノードを更新する\n        this.queSize--;\n        return value;\n    }\n\n    /* キュー先頭からの取り出し */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // 末尾ノードの値を保存する\n        // 先頭ノードを削除\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // 先頭ノードを更新する\n        this.queSize--;\n        return value;\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* 両端キューの長さを取得 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 両端キューを出力する */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* 双方向連結リストノード */\nclass ListNode {\n  int val; // ノード値\n  ListNode? next; // 後続ノードへの参照\n  ListNode? prev; // 前駆ノードへの参照\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* 双方向連結リストに基づく双方向キュー */\nclass LinkedListDeque {\n  late ListNode? _front; // 先頭ノード _front\n  late ListNode? _rear; // 末尾ノード _rear\n  int _queSize = 0; // 両端キューの長さ\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* 両端キューの長さを取得 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* 両端キューが空かどうかを判定 */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* エンキュー操作 */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // 連結リストが空なら、`_front` と `_rear` の両方を `node` に向ける\n      _front = _rear = node;\n    } else if (isFront) {\n      // 先頭へのエンキュー操作\n      // node を連結リストの先頭に追加する\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // 先頭ノードを更新する\n    } else {\n      // 末尾へのエンキュー操作\n      // node を連結リストの末尾に追加する\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // 末尾ノードを更新する\n    }\n    _queSize++; // キューの長さを更新\n  }\n\n  /* キュー先頭にエンキュー */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* キュー末尾にエンキュー */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* デキュー操作 */\n  int? pop(bool isFront) {\n    // キューが空なら、そのまま `null` を返す\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // キュー先頭からの取り出し\n      val = _front!.val; // 先頭ノードの値を一時保存\n      // 先頭ノードを削除\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // 先頭ノードを更新する\n    } else {\n      // キュー末尾からの取り出し\n      val = _rear!.val; // 末尾ノードの値を一時保存\n      // 末尾ノードを削除\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // 末尾ノードを更新する\n    }\n    _queSize--; // キューの長さを更新\n    return val;\n  }\n\n  /* キュー先頭からデキュー */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* キュー末尾からデキュー */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* キュー末尾の要素にアクセス */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* 出力用の配列を返す */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* 双方向連結リストノード */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // ノード値\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 後継ノードへのポインタ\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 前駆ノードへのポインタ\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* 双方向連結リストベースの両端キュー */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノード front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 末尾ノード rear\n    que_size: usize,                         // 両端キューの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 両端キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* エンキュー操作 */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // 先頭へのエンキュー操作\n        if is_front {\n            match self.front.take() {\n                // 連結リストが空なら、front と rear の両方を node に向ける\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // node を連結リストの先頭に追加\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // 先頭ノードを更新する\n                }\n            }\n        }\n        // 末尾へのエンキュー操作\n        else {\n            match self.rear.take() {\n                // 連結リストが空なら、front と rear の両方を node に向ける\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // node を連結リストの末尾に追加\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // 末尾ノードを更新する\n                }\n            }\n        }\n        self.que_size += 1; // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* キュー末尾にエンキュー */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* デキュー操作 */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // キューが空なら、そのまま `None` を返す\n        if self.is_empty() {\n            return None;\n        };\n        // キュー先頭からの取り出し\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // 先頭ノードを更新する\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // キューの長さを更新\n                old_front.borrow().val\n            })\n        }\n        // キュー末尾からの取り出し\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // 末尾ノードを更新する\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // キューの長さを更新\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* キュー先頭からデキュー */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* キュー末尾からデキュー */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* キュー先頭の要素にアクセス */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* キュー末尾の要素にアクセス */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* 出力用の配列を返す */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* 双方向連結リストノード */\ntypedef struct DoublyListNode {\n    int val;                     // ノード値\n    struct DoublyListNode *next; // 後続ノード\n    struct DoublyListNode *prev; // 前駆ノード\n} DoublyListNode;\n\n/* コンストラクタ */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* デストラクタ */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* 双方向連結リストベースの両端キュー */\ntypedef struct {\n    DoublyListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize;                  // 両端キューの長さ\n} LinkedListDeque;\n\n/* コンストラクタ */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* デストラクタ */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // すべてのノードを解放\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // deque 構造体を解放する\n    free(deque);\n}\n\n/* キューの長さを取得 */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* エンキュー */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // 連結リストが空なら、`front` と `rear` の両方を `node` に向ける\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // 先頭へのエンキュー操作\n    else if (isFront) {\n        // node を連結リストの先頭に追加\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // 先頭ノードを更新する\n    }\n    // 末尾へのエンキュー操作\n    else {\n        // node を連結リストの末尾に追加\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // キューの長さを更新\n}\n\n/* キュー先頭にエンキュー */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* キュー末尾にエンキュー */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* キュー先頭の要素にアクセス */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* キュー末尾の要素にアクセス */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* デキュー */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // キュー先頭からの取り出し\n    if (isFront) {\n        val = peekFirst(deque); // 先頭ノードの値を一時保存\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // 先頭ノードを更新する\n    }\n    // キュー末尾からの取り出し\n    else {\n        val = peekLast(deque); // 末尾ノードの値を一時保存\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // 末尾ノードを更新する\n    }\n    deque-&gt;queSize--; // キューの長さを更新\n    return val;\n}\n\n/* キュー先頭からデキュー */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* キュー末尾からデキュー */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* キューを出力する */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // 連結リスト内のデータを配列にコピー\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* 双方向連結リストノード */\nclass ListNode(var _val: Int) {\n    // ノード値\n    var next: ListNode? = null // 後続ノードへの参照\n    var prev: ListNode? = null // 前駆ノードへの参照\n}\n\n/* 双方向連結リストベースの両端キュー */\nclass LinkedListDeque {\n    private var front: ListNode? = null // 先頭ノード front\n    private var rear: ListNode? = null // 末尾ノード rear\n    private var queSize: Int = 0 // 両端キューの長さ\n\n    /* 両端キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* エンキュー操作 */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // 連結リストが空なら、front と rear の両方を node に向ける\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // 先頭へのエンキュー操作\n        } else if (isFront) {\n            // node を連結リストの先頭に追加\n            front?.prev = node\n            node.next = front\n            front = node // 先頭ノードを更新する\n            // 末尾へのエンキュー操作\n        } else {\n            // node を連結リストの末尾に追加\n            rear?.next = node\n            node.prev = rear\n            rear = node // 末尾ノードを更新する\n        }\n        queSize++ // キューの長さを更新\n    }\n\n    /* キュー先頭にエンキュー */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* キュー末尾にエンキュー */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* デキュー操作 */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // キュー先頭からの取り出し\n        if (isFront) {\n            _val = front!!._val // 先頭ノードの値を一時保存\n            // 先頭ノードを削除\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // 先頭ノードを更新する\n            // キュー末尾からの取り出し\n        } else {\n            _val = rear!!._val // 末尾ノードの値を一時保存\n            // 末尾ノードを削除\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // 末尾ノードを更新する\n        }\n        queSize-- // キューの長さを更新\n        return _val\n    }\n\n    /* キュー先頭からデキュー */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* キュー末尾からデキュー */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* 出力用の配列を返す */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n# ## 双方向連結リストノード\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # 後続ノードへの参照\n  attr_accessor :prev # 前ノードへの参照\n\n  ### コンストラクタ ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### 双方向連結リストで実装した両端キュー ###\nclass LinkedListDeque\n  ### 両端キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @front = nil  # 先頭ノード front\n    @rear = nil   # 末尾ノード rear\n    @size = 0     # 両端キューの長さ\n  end\n\n  ### 両端キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### エンキュー操作 ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # 連結リストが空なら、`front` と `rear` の両方を `node` に向ける\n    if is_empty?\n      @front = @rear = node\n    # 先頭へのエンキュー操作\n    elsif is_front\n      # node を連結リストの先頭に追加\n      @front.prev = node\n      node.next = @front\n      @front = node # 先頭ノードを更新する\n    # 末尾へのエンキュー操作\n    else\n      # node を連結リストの末尾に追加\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # 末尾ノードを更新する\n    end\n    @size += 1 # キューの長さを更新\n  end\n\n  ### キュー先頭に追加 ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### キュー末尾に追加 ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### デキュー操作 ###\n  def pop(is_front)\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    # キュー先頭からの取り出し\n    if is_front\n      val = @front.val # 先頭ノードの値を一時保存\n      # 先頭ノードを削除\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # 先頭ノードを更新する\n    # キュー末尾からの取り出し\n    else\n      val = @rear.val # 末尾ノードの値を一時保存\n      # 末尾ノードを削除\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # 末尾ノードを更新する\n    end\n    @size -= 1 # キューの長さを更新\n\n    val\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_first\n    pop(true)\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_last\n    pop(false)\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek_first\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @front.val\n  end\n\n  ### キュー末尾要素を参照 ###\n  def peek_last\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @rear.val\n  end\n\n  ### 表示用の配列を返す ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   配列に基づく実装","text":"<p>次の図に示すように、配列によるキュー実装と同様に、循環配列を使って両端キューを実装することもできます。</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 5-9   配列による両端キューのエンキューとデキュー </p> <p>キュー実装を土台として、「先頭へのエンキュー」と「末尾からのデキュー」のメソッドを追加するだけで済みます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"循環配列ベースの両端キュー\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"コンストラクタ\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"両端キューの容量を取得\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"両端キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"両端キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"循環配列のインデックスを計算\"\"\"\n        # 剰余演算により配列の先頭と末尾をつなげる\n        # i が配列の末尾を越えたら先頭に戻る\n        # i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"キュー先頭にエンキュー\"\"\"\n        if self._size == self.capacity():\n            print(\"両端キューがいっぱいです\")\n            return\n        # 先頭ポインタを左に 1 つ移動する\n        # 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        self._front = self.index(self._front - 1)\n        # num をキュー先頭に追加\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"キュー末尾にエンキュー\"\"\"\n        if self._size == self.capacity():\n            print(\"両端キューがいっぱいです\")\n            return\n        # キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        rear = self.index(self._front + self._size)\n        # num をキュー末尾に追加\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"キュー先頭からデキュー\"\"\"\n        num = self.peek_first()\n        # 先頭ポインタを 1 つ後ろへ進める\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"キュー末尾からデキュー\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"キュー末尾の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"両端キューが空です\")\n        # 末尾要素のインデックスを計算\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"出力用の配列を返す\"\"\"\n        # 有効長の範囲内のリスト要素のみを変換\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // 両端キューの要素を格納する配列\n    int front;        // 先頭ポインタ。先頭要素を指す\n    int queSize;      // 両端キューの長さ\n\n  public:\n    /* コンストラクタ */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* 両端キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    int index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"両端キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"両端キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    int popFirst() {\n        int num = peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"両端キューが空です\");\n        // 末尾要素のインデックスを計算\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private int[] nums; // 両端キューの要素を格納する配列\n    private int front; // 先頭ポインタ。先頭要素を指す\n    private int queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private int index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"双方向キューは満杯です\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"双方向キューは満杯です\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    public int popFirst() {\n        int num = peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // 末尾要素のインデックスを計算\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    public int[] toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    int[] nums;  // 両端キューの要素を格納する配列\n    int front;   // 先頭ポインタ。先頭要素を指す\n    int queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 両端キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    int Index(int i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"両端キューは満杯です\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = Index(front - 1);\n        // num をキュー先頭に追加\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"両端キューは満杯です\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        int rear = Index(front + queSize);\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // 末尾要素のインデックスを計算\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* 循環配列ベースの両端キュー */\ntype arrayDeque struct {\n    nums        []int // 両端キューの要素を格納する配列\n    front       int   // 先頭ポインタ。先頭要素を指す\n    queSize     int   // 両端キューの長さ\n    queCapacity int   // キュー容量（格納できる要素数の上限）\n}\n\n/* キューを初期化 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 両端キューの長さを取得 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* 両端キューが空かどうかを判定 */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 循環配列のインデックスを計算 */\nfunc (q *arrayDeque) index(i int) int {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えて前に出たら末尾に戻る\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* キュー先頭にエンキュー */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"両端キューは満杯です\")\n        return\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n    q.front = q.index(q.front - 1)\n    // num をキュー先頭に追加\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* キュー末尾にエンキュー */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"両端キューは満杯です\")\n        return\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    rear := q.index(q.front + q.queSize)\n    // num をキュー末尾に追加\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* キュー先頭からデキュー */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // 先頭ポインタを 1 つ後ろへ進める\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* キュー末尾からデキュー */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* キュー末尾の要素にアクセス */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // 末尾要素のインデックスを計算\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* 表示用に Slice を取得 */\nfunc (q *arrayDeque) toSlice() []int {\n    // 有効長の範囲内のリスト要素のみを変換\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private var nums: [Int] // 両端キューの要素を格納する配列\n    private var front: Int // 先頭ポインタ。先頭要素を指す\n    private var _size: Int // 両端キューの長さ\n\n    /* コンストラクタ */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 両端キューの容量を取得 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 両端キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private func index(i: Int) -&gt; Int {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        (i + capacity()) % capacity()\n    }\n\n    /* キュー先頭にエンキュー */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"両端キューがいっぱいです\")\n            return\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(i: front - 1)\n        // num をキュー先頭に追加\n        nums[front] = num\n        _size += 1\n    }\n\n    /* キュー末尾にエンキュー */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"両端キューがいっぱいです\")\n            return\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        let rear = index(i: front + size())\n        // num をキュー末尾に追加\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* キュー先頭からデキュー */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* キュー末尾からデキュー */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        return nums[front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"両端キューが空です\")\n        }\n        // 末尾要素のインデックスを計算\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    func toArray() -&gt; [Int] {\n        // 有効長の範囲内のリスト要素のみを変換\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    #nums; // 両端キューの要素を格納する配列\n    #front; // 先頭ポインタ。先頭要素を指す\n    #queSize; // 両端キューの長さ\n\n    /* コンストラクタ */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    index(i) {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('両端キューがいっぱいです');\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        this.#front = this.index(this.#front - 1);\n        // num をキュー先頭に追加\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('両端キューがいっぱいです');\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        const rear = this.index(this.#front + this.#queSize);\n        // num をキュー末尾に追加\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    popFirst() {\n        const num = this.peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 末尾要素のインデックスを計算\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n    private nums: number[]; // 両端キューの要素を格納する配列\n    private front: number; // 先頭ポインタ。先頭要素を指す\n    private queSize: number; // 両端キューの長さ\n\n    /* コンストラクタ */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* 両端キューの容量を取得 */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 両端キューの長さを取得 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 循環配列のインデックスを計算 */\n    index(i: number): number {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* キュー先頭にエンキュー */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('両端キューは満杯です');\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        this.front = this.index(this.front - 1);\n        // num をキュー先頭に追加\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* キュー末尾にエンキュー */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('両端キューは満杯です');\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        const rear: number = this.index(this.front + this.queSize);\n        // num をキュー末尾に追加\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* キュー先頭からデキュー */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // 先頭ポインタを 1 つ後ろへ進める\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー末尾からデキュー */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* キュー末尾の要素にアクセス */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 末尾要素のインデックスを計算\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* 出力用の配列を返す */\n    toArray(): number[] {\n        // 有効長の範囲内のリスト要素のみを変換\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* 循環配列ベースの両端キュー */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // 両端キューの要素を格納する配列\n  late int _front; // 先頭ポインタ。先頭要素を指す\n  late int _queSize; // 両端キューの長さ\n\n  /* コンストラクタ */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* 両端キューの容量を取得 */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* 両端キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 両端キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 循環配列のインデックスを計算 */\n  int index(int i) {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えて前に出たら末尾に戻る\n    return (i + capacity()) % capacity();\n  }\n\n  /* キュー先頭にエンキュー */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"両端キューがいっぱいです\");\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により _front が配列の先頭を越えたあと末尾に戻るようにする\n    _front = index(_front - 1);\n    // _num をキューの先頭に追加\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* キュー末尾にエンキュー */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"両端キューがいっぱいです\");\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    int rear = index(_front + _queSize);\n    // _num をキュー末尾に追加\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* キュー先頭からデキュー */\n  int popFirst() {\n    int _num = peekFirst();\n    // 先頭ポインタを右に 1 つ移動する\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー末尾からデキュー */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"両端キューが空です\");\n    }\n    return _nums[_front];\n  }\n\n  /* キュー末尾の要素にアクセス */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"両端キューが空です\");\n    }\n    // 末尾要素のインデックスを計算\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* 出力用の配列を返す */\n  List&lt;int&gt; toArray() {\n    // 有効長の範囲内のリスト要素のみを変換\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* 循環配列ベースの両端キュー */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // 両端キューの要素を格納する配列\n    front: usize,    // 先頭ポインタ。先頭要素を指す\n    que_size: usize, // 両端キューの長さ\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* コンストラクタ */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* 両端キューの容量を取得 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* 両端キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* キュー先頭にエンキュー */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"両端キューがいっぱいです\");\n            return;\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        self.front = self.index(self.front as i32 - 1);\n        // num をキュー先頭に追加\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* キュー末尾にエンキュー */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"両端キューがいっぱいです\");\n            return;\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // num をキュー末尾に追加\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* キュー先頭からデキュー */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // 先頭ポインタを 1 つ後ろへ進める\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー末尾からデキュー */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"両端キューが空です\")\n        };\n        self.nums[self.front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"両端キューが空です\")\n        };\n        // 末尾要素のインデックスを計算\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // 有効長の範囲内のリスト要素のみを変換\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* 循環配列ベースの両端キュー */\ntypedef struct {\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // 末尾ポインタ。キューの末尾 + 1 を指す\n    int queCapacity; // キューの容量\n} ArrayDeque;\n\n/* コンストラクタ */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // 配列を初期化\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* デストラクタ */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* 両端キューの容量を取得 */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* 両端キューの長さを取得 */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 両端キューが空かどうかを判定 */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* 循環配列のインデックスを計算 */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // 剰余演算により配列の先頭と末尾をつなげる\n    // i が配列の末尾を越えたら先頭に戻る\n    // i が配列の先頭を越えたら末尾に戻る\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* キュー先頭にエンキュー */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"両端キューがいっぱいです\\r\\n\");\n        return;\n    }\n    // 先頭ポインタを左に 1 つ移動する\n    // 剰余演算により front が配列の先頭を越えたあと末尾に戻るようにする\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // num をキューの先頭に追加\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* キュー末尾にエンキュー */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"両端キューがいっぱいです\\r\\n\");\n        return;\n    }\n    // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // num をキュー末尾に追加\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* キュー先頭の要素にアクセス */\nint peekFirst(ArrayDeque *deque) {\n    // アクセス例外：双方向キューが空です\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* キュー末尾の要素にアクセス */\nint peekLast(ArrayDeque *deque) {\n    // アクセス例外：双方向キューが空です\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* キュー先頭からデキュー */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // 先頭ポインタを 1 つ後ろへ進める\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* キュー末尾からデキュー */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 出力用の配列を返す */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* コンストラクタ */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // 両端キューの要素を格納する配列\n    private var front: Int = 0 // 先頭ポインタ。先頭要素を指す\n    private var queSize: Int = 0 // 両端キューの長さ\n\n    /* 両端キューの容量を取得 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 両端キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 両端キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 循環配列のインデックスを計算 */\n    private fun index(i: Int): Int {\n        // 剰余演算により配列の先頭と末尾をつなげる\n        // i が配列の末尾を越えたら先頭に戻る\n        // i が配列の先頭を越えて前に出たら末尾に戻る\n        return (i + capacity()) % capacity()\n    }\n\n    /* キュー先頭にエンキュー */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"双方向キューは満杯です\")\n            return\n        }\n        // 先頭ポインタを左に 1 つ移動する\n        // 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n        front = index(front - 1)\n        // num をキュー先頭に追加\n        nums[front] = num\n        queSize++\n    }\n\n    /* キュー末尾にエンキュー */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"双方向キューは満杯です\")\n            return\n        }\n        // キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n        val rear = index(front + queSize)\n        // num をキュー末尾に追加\n        nums[rear] = num\n        queSize++\n    }\n\n    /* キュー先頭からデキュー */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // 先頭ポインタを 1 つ後ろへ進める\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* キュー末尾からデキュー */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* キュー末尾の要素にアクセス */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 末尾要素のインデックスを計算\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* 出力用の配列を返す */\n    fun toArray(): IntArray {\n        // 有効長の範囲内のリスト要素のみを変換\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### 循環配列で実装した両端キュー ###\nclass ArrayDeque\n  ### 両端キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### 両端キューの容量を取得 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 両端キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### キュー先頭に追加 ###\n  def push_first(num)\n    if size == capacity\n      puts '両端キューがいっぱいです'\n      return\n    end\n\n    # 先頭ポインタを左に 1 つ移動する\n    # 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする\n    @front = index(@front - 1)\n    # num をキュー先頭に追加\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### キュー末尾に追加 ###\n  def push_last(num)\n    if size == capacity\n      puts '両端キューがいっぱいです'\n      return\n    end\n\n    # キュー末尾ポインタを計算し、末尾インデックス + 1 を指す\n    rear = index(@front + size)\n    # num をキュー末尾に追加\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### キュー先頭から取り出す ###\n  def pop_first\n    num = peek_first\n    # 先頭ポインタを 1 つ後ろへ進める\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### キューの末尾から取り出す ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek_first\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### キュー末尾要素を参照 ###\n  def peek_last\n    raise IndexError, '両端キューは空です' if is_empty?\n\n    # 末尾要素のインデックスを計算\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### 表示用の配列を返す ###\n  def to_array\n    # 有効長の範囲内のリスト要素のみを変換\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### 循環配列のインデックスを計算 ###\n  def index(i)\n    # 剰余演算により配列の先頭と末尾をつなげる\n    # i が配列の末尾を越えたら先頭に戻る\n    # i が配列の先頭を越えて前に出たら末尾に戻る\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   両端キューの応用","text":"<p>両端キューはスタックとキューの両方の論理を備えているため、これら 2 つのすべての応用場面を実現でき、さらに高い自由度を提供します。</p> <p>私たちが知っているように、ソフトウェアの「元に戻す」機能は通常スタックを使って実装されます。システムは変更操作を毎回スタックに <code>push</code> し、その後 <code>pop</code> によって取り消しを実現します。しかし、システム資源の制約を考慮すると、通常ソフトウェアは取り消し可能な手数を制限します（たとえば \\(50\\) 手まで保存可能）。スタックの長さが \\(50\\) を超えると、ソフトウェアはスタックの底部（先頭）で削除操作を行う必要があります。しかしスタックではこの機能を実現できないため、この場合はスタックの代わりに両端キューを使用する必要があります。なお、「元に戻す」の中核ロジック自体は依然としてスタックの後入れ先出し原則に従っており、両端キューは追加のロジックをより柔軟に実装できるだけです。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.3 &nbsp; 両端キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   キュー","text":"<p>キュー（queue）は、先入れ先出しの規則に従う線形データ構造です。名前のとおり、キューは順番待ちの現象を模したもので、新しく来た人は絶えずキュー末尾に加わり、キュー先頭にいる人から順に離れていきます。</p> <p>下図のように、キューの先頭を「キュー先頭」、末尾を「キュー末尾」と呼びます。要素をキュー末尾に加える操作を「エンキュー」、キュー先頭の要素を削除する操作を「デキュー」と呼びます。</p> <p></p> <p> 図 5-4   キューの先入れ先出し規則 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   キューの基本操作","text":"<p>キューの基本操作を以下の表に示します。なお、メソッド名はプログラミング言語によって異なる場合があります。ここではスタックと同じ命名を採用します。</p> <p> 表 5-2   キュー操作の効率 </p> メソッド名 説明 時間計算量 <code>push()</code> 要素をエンキューし、キュー末尾に追加する \\(O(1)\\) <code>pop()</code> キュー先頭の要素をデキューする \\(O(1)\\) <code>peek()</code> キュー先頭の要素にアクセスする \\(O(1)\\) <p>プログラミング言語に用意された既存のキュークラスをそのまま利用できます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# キューを初期化\n# Python では、通常は双方向キュークラス deque をキューとして使用する\n# queue.Queue() は純粋なキュークラスだが、やや使いにくいため非推奨\nque: deque[int] = deque()\n\n# 要素をエンキュー\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# キュー先頭の要素にアクセス\nfront: int = que[0]\n\n# 要素をデキュー\npop: int = que.popleft()\n\n# キューの長さを取得\nsize: int = len(que)\n\n# キューが空かどうかを判定\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* キューを初期化 */\nqueue&lt;int&gt; queue;\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nint front = queue.front();\n\n/* 要素をデキュー */\nqueue.pop();\n\n/* キューの長さを取得 */\nint size = queue.size();\n\n/* キューが空かどうかを判定 */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* キューを初期化 */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* 要素をエンキュー */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.peek();\n\n/* 要素をデキュー */\nint pop = queue.poll();\n\n/* キューの長さを取得 */\nint size = queue.size();\n\n/* キューが空かどうかを判定 */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* キューを初期化 */\nQueue&lt;int&gt; queue = new();\n\n/* 要素をエンキュー */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.Peek();\n\n/* 要素をデキュー */\nint pop = queue.Dequeue();\n\n/* キューの長さを取得 */\nint size = queue.Count;\n\n/* キューが空かどうかを判定 */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* キューを初期化 */\n// Go では、list をキューとして使用する\nqueue := list.New()\n\n/* 要素をエンキュー */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* キュー先頭の要素にアクセス */\npeek := queue.Front()\n\n/* 要素をデキュー */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* キューの長さを取得 */\nsize := queue.Len()\n\n/* キューが空かどうかを判定 */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* キューを初期化 */\n// Swift には組み込みのキュークラスがないため、Array をキューとして使える\nvar queue: [Int] = []\n\n/* 要素をエンキュー */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* キュー先頭の要素にアクセス */\nlet peek = queue.first!\n\n/* 要素をデキュー */\n// 配列であるため、removeFirst の計算量は O(n)\nlet pool = queue.removeFirst()\n\n/* キューの長さを取得 */\nlet size = queue.count\n\n/* キューが空かどうかを判定 */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* キューを初期化 */\n// JavaScript には組み込みのキューがないため、Array をキューとして使える\nconst queue = [];\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nconst peek = queue[0];\n\n/* 要素をデキュー */\n// 基盤は配列であるため、shift() メソッドの時間計算量は O(n)\nconst pop = queue.shift();\n\n/* キューの長さを取得 */\nconst size = queue.length;\n\n/* キューが空かどうかを判定 */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* キューを初期化 */\n// TypeScript には組み込みのキューがないため、Array をキューとして使える\nconst queue: number[] = [];\n\n/* 要素をエンキュー */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* キュー先頭の要素にアクセス */\nconst peek = queue[0];\n\n/* 要素をデキュー */\n// 基盤は配列であるため、shift() メソッドの時間計算量は O(n)\nconst pop = queue.shift();\n\n/* キューの長さを取得 */\nconst size = queue.length;\n\n/* キューが空かどうかを判定 */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* キューを初期化 */\n// Dart では、キュークラス Qeque は双方向キューであり、キューとしても使用できる\nQueue&lt;int&gt; queue = Queue();\n\n/* 要素をエンキュー */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* キュー先頭の要素にアクセス */\nint peek = queue.first;\n\n/* 要素をデキュー */\nint pop = queue.removeFirst();\n\n/* キューの長さを取得 */\nint size = queue.length;\n\n/* キューが空かどうかを判定 */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* 双方向キューを初期化 */\n// Rust では双方向キューを通常のキューとして使う\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 要素をエンキュー */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* キュー先頭の要素にアクセス */\nif let Some(front) = deque.front() {\n}\n\n/* 要素をデキュー */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* キューの長さを取得 */\nlet size = deque.len();\n\n/* キューが空かどうかを判定 */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C には組み込みのキューがない\n</code></pre> queue.kt<pre><code>/* キューを初期化 */\nval queue = LinkedList&lt;Int&gt;()\n\n/* 要素をエンキュー */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* キュー先頭の要素にアクセス */\nval peek = queue.peek()\n\n/* 要素をデキュー */\nval pop = queue.poll()\n\n/* キューの長さを取得 */\nval size = queue.size\n\n/* キューが空かどうかを判定 */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># キューを初期化\n# Ruby 組み込みのキュー（Thread::Queue) には peek と走査メソッドがないため、Array をキューとして使える\nqueue = []\n\n# 要素をエンキュー\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# キュー先頭の要素にアクセス\npeek = queue.first\n\n# 要素をデキュー\n# 注意：配列であるため、Array#shift メソッドの時間計算量は O(n)\npop = queue.shift\n\n# キューの長さを取得\nsize = queue.length\n\n# キューが空かどうかを判定\nis_empty = queue.empty?\n</code></pre> 可視化実行 <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%98%9F%E5%88%97%0A%20%20%20%20%23%20%E5%9C%A8%20Python%20%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BB%AC%E4%B8%80%E8%88%AC%E5%B0%86%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%B1%BB%20deque%20%E7%9C%8B%E4%BD%9C%E9%98%9F%E5%88%97%E4%BD%BF%E7%94%A8%0A%20%20%20%20%23%20%E8%99%BD%E7%84%B6%20queue.Queue%28%29%20%E6%98%AF%E7%BA%AF%E6%AD%A3%E7%9A%84%E9%98%9F%E5%88%97%E7%B1%BB%EF%BC%8C%E4%BD%86%E4%B8%8D%E5%A4%AA%E5%A5%BD%E7%94%A8%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%90%8E%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   キューの実装","text":"<p>キューを実装するには、一方の端で要素を追加し、もう一方の端で要素を削除できるデータ構造が必要です。連結リストと配列はいずれもこの条件を満たします。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   連結リストに基づく実装","text":"<p>下図のように、連結リストの「先頭ノード」と「末尾ノード」をそれぞれ「キュー先頭」と「キュー末尾」とみなし、キュー末尾ではノードの追加のみ、キュー先頭ではノードの削除のみを行うようにします。</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> 図 5-5   連結リストでキューを実装したエンキューとデキュー操作 </p> <p>以下は連結リストでキューを実装するコードです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"連結リストベースのキュー\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._front: ListNode | None = None  # 先頭ノード front\n        self._rear: ListNode | None = None  # 末尾ノード rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"エンキュー\"\"\"\n        # 末尾ノードの後ろに num を追加\n        node = ListNode(num)\n        # キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"デキュー\"\"\"\n        num = self.peek()\n        # 先頭ノードを削除\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"キューが空です\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用にリストへ変換\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // 先頭ノード front、末尾ノード rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        freeMemoryLinkedList(front);\n    }\n\n    /* キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    void push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode *node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    int pop() {\n        int num = peek();\n        // 先頭ノードを削除\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // メモリを解放する\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"キューが空です\");\n        return front-&gt;val;\n    }\n\n    /* 連結リストを Vector に変換して返す */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private ListNode front, rear; // 先頭ノード front、末尾ノード rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー */\n    public void push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node;\n            rear = node;\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    public int pop() {\n        int num = peek();\n        // 先頭ノードを削除\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    ListNode? front, rear;  // 先頭ノード front、末尾ノード rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* エンキュー */\n    public void Push(int num) {\n        // 末尾ノードの後ろに num を追加\n        ListNode node = new(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node;\n            rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* デキュー */\n    public int Pop() {\n        int num = Peek();\n        // 先頭ノードを削除\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* 連結リストベースのキュー */\ntype linkedListQueue struct {\n    // 組み込みパッケージ list でキューを実装する\n    data *list.List\n}\n\n/* キューを初期化 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* エンキュー */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* デキュー */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* キューの長さを取得 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* キューが空かどうかを判定 */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private var front: ListNode? // 先頭ノード\n    private var rear: ListNode? // 末尾ノード\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー */\n    func push(num: Int) {\n        // 末尾ノードの後ろに num を追加\n        let node = ListNode(x: num)\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* デキュー */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 先頭ノードを削除\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"キューが空です\")\n        }\n        return front!.val\n    }\n\n    /* 連結リストを Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    #front; // 先頭ノード #front\n    #rear; // 末尾ノード #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* キューの長さを取得 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* エンキュー */\n    push(num) {\n        // 末尾ノードの後ろに num を追加\n        const node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* デキュー */\n    pop() {\n        const num = this.peek();\n        // 先頭ノードを削除\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek() {\n        if (this.size === 0) throw new Error('キューが空');\n        return this.#front.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n    private front: ListNode | null; // 先頭ノード front\n    private rear: ListNode | null; // 末尾ノード rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* キューの長さを取得 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* エンキュー */\n    push(num: number): void {\n        // 末尾ノードの後ろに num を追加\n        const node = new ListNode(num);\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* デキュー */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('キューが空です');\n        // 先頭ノードを削除\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek(): number {\n        if (this.size === 0) throw new Error('キューが空です');\n        return this.front!.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue {\n  ListNode? _front; // 先頭ノード _front\n  ListNode? _rear; // 末尾ノード _rear\n  int _queSize = 0; // キューの長さ\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* エンキュー */\n  void push(int _num) {\n    // 末尾ノードの後ろに _num を追加\n    final node = ListNode(_num);\n    // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* デキュー */\n  int pop() {\n    final int _num = peek();\n    // 先頭ノードを削除\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('キューが空です');\n    }\n    return _front!.val;\n  }\n\n  /* 連結リストを Array に変換して返す */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* 連結リストベースのキュー */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノード front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 末尾ノード rear\n    que_size: usize,                         // キューの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* キューの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* キューが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* エンキュー */\n    pub fn push(&amp;mut self, num: T) {\n        // 末尾ノードの後ろに num を追加\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* デキュー */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* キュー先頭の要素にアクセス */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 連結リストを Array に変換して返す */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* 連結リストベースのキュー */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* コンストラクタ */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* デストラクタ */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // すべてのノードを解放\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // queue 構造体を解放する\n    free(queue);\n}\n\n/* キューの長さを取得 */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* エンキュー */\nvoid push(LinkedListQueue *queue, int num) {\n    // 末尾ノードに node を追加\n    ListNode *node = newListNode(num);\n    // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* キュー先頭の要素にアクセス */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* デキュー */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* キューを出力する */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // 連結リスト内のデータを配列にコピー\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* 連結リストベースのキュー */\nclass LinkedListQueue(\n    // 先頭ノード front、末尾ノード rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* エンキュー */\n    fun push(num: Int) {\n        // 末尾ノードの後ろに num を追加\n        val node = ListNode(num)\n        // キューが空なら、先頭・末尾ノードをともにそのノードに設定\n        if (front == null) {\n            front = node\n            rear = node\n            // キューが空でなければ、そのノードを末尾ノードの後ろに追加\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* デキュー */\n    fun pop(): Int {\n        val num = peek()\n        // 先頭ノードを削除\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 連結リストを Array に変換して返す */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### 連結リストで実装したキュー ###\nclass LinkedListQueue\n  ### キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @front = nil  # 先頭ノード front\n    @rear = nil   # 末尾ノード rear\n    @size = 0\n  end\n\n  ### キューが空か判定 ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### エンキュー ###\n  def push(num)\n    # 末尾ノードの後ろに num を追加\n    node = ListNode.new(num)\n\n    # キューが空なら、先頭ノードと末尾ノードの両方をそのノードに向ける\n    if @front.nil?\n      @front = node\n      @rear = node\n    # キューが空でなければ、そのノードを末尾ノードの後ろに追加する\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### デキュー ###\n  def pop\n    num = peek\n    # 先頭ノードを削除\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek\n    raise IndexError, 'キューは空です' if is_empty?\n\n    @front.val\n  end\n\n  ### 連結リストを Array に変換して返す ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   配列に基づく実装","text":"<p>配列で先頭要素を削除する時間計算量は \\(O(n)\\) であり、そのままではデキュー操作の効率が低くなります。しかし、次の巧妙な方法によってこの問題を回避できます。</p> <p>変数 <code>front</code> を用いてキュー先頭要素のインデックスを指し、さらに変数 <code>size</code> でキューの長さを記録できます。<code>rear = front + size</code> と定義すると、この式で得られる <code>rear</code> はキュー末尾要素の次の位置を指します。</p> <p>この設計に基づくと、配列内で要素を含む有効区間は <code>[front, rear - 1]</code> となります。各種操作の実装方法を下図に示します。</p> <ul> <li>エンキュー操作：入力要素を <code>rear</code> の位置に代入し、<code>size</code> を 1 増やします。</li> <li>デキュー操作：<code>front</code> を 1 増やし、<code>size</code> を 1 減らすだけです。</li> </ul> <p>このように、エンキューとデキューはいずれも 1 回の操作だけで済み、時間計算量はともに \\(O(1)\\) です。</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> 図 5-6   配列でキューを実装したエンキューとデキュー操作 </p> <p>ここで 1 つ問題があります。エンキューとデキューを繰り返すと、<code>front</code> と <code>rear</code> はどちらも右へ移動し続け、配列の末尾に達するとそれ以上進めなくなります。この問題を解決するために、配列を先頭と末尾がつながった「環状配列」とみなします。</p> <p>環状配列では、<code>front</code> または <code>rear</code> が配列末尾を越えたときに、直ちに配列先頭へ戻って走査を続けられるようにする必要があります。この周期的な規則は「剰余演算」によって実現できます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"循環配列ベースのキュー\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"コンストラクタ\"\"\"\n        self._nums: list[int] = [0] * size  # キュー要素を格納する配列\n        self._front: int = 0  # 先頭ポインタ。先頭要素を指す\n        self._size: int = 0  # キューの長さ\n\n    def capacity(self) -&gt; int:\n        \"\"\"キューの容量を取得\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"キューの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"キューが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"エンキュー\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"キューがいっぱいです\")\n        # 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        # 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        rear: int = (self._front + self._size) % self.capacity()\n        # num をキュー末尾に追加\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"デキュー\"\"\"\n        num: int = self.peek()\n        # 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"キュー先頭の要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"キューが空です\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用のリストを返す\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n  private:\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // キューの長さ\n    int queCapacity; // キューの容量\n\n  public:\n    ArrayQueue(int capacity) {\n        // 配列を初期化\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* キューの容量を取得 */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* キューの長さを取得 */\n    int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* エンキュー */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"キューがいっぱいです\" &lt;&lt; endl;\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % queCapacity;\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    int pop() {\n        int num = peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"キューが空です\");\n        return nums[front];\n    }\n\n    /* 配列を Vector に変換して返す */\n    vector&lt;int&gt; toVector() {\n        // 有効長の範囲内のリスト要素のみを変換\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private int[] nums; // キュー要素を格納する配列\n    private int front; // 先頭ポインタ。先頭要素を指す\n    private int queSize; // キューの長さ\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* キューの長さを取得 */\n    public int size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"キューは満杯です\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % capacity();\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    public int pop() {\n        int num = peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 配列を返す */\n    public int[] toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    int[] nums;  // キュー要素を格納する配列\n    int front;   // 先頭ポインタ。先頭要素を指す\n    int queSize; // キューの長さ\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* キューの長さを取得 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* エンキュー */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"キューは満杯です\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        int rear = (front + queSize) % Capacity();\n        // num をキュー末尾に追加\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* デキュー */\n    public int Pop() {\n        int num = Peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* 配列を返す */\n    public int[] ToArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* 循環配列ベースのキュー */\ntype arrayQueue struct {\n    nums        []int // キュー要素を格納する配列\n    front       int   // 先頭ポインタ。先頭要素を指す\n    queSize     int   // キューの長さ\n    queCapacity int   // キュー容量（格納できる要素数の上限）\n}\n\n/* キューを初期化 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* キューの長さを取得 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* キューが空かどうかを判定 */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* エンキュー */\nfunc (q *arrayQueue) push(num int) {\n    // rear == queCapacity のときキューは満杯\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    rear := (q.front + q.queSize) % q.queCapacity\n    // num をキュー末尾に追加\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* デキュー */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* キュー先頭の要素にアクセス */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 表示用に Slice を取得 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private var nums: [Int] // キュー要素を格納する配列\n    private var front: Int // 先頭ポインタ。先頭要素を指す\n    private var _size: Int // キューの長さ\n\n    init(capacity: Int) {\n        // 配列を初期化\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* キューの容量を取得 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* キューの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* キューが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* エンキュー */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"キューがいっぱいです\")\n            return\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        let rear = (front + size()) % capacity()\n        // num をキュー末尾に追加\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* デキュー */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"キューが空です\")\n        }\n        return nums[front]\n    }\n\n    /* 配列を返す */\n    func toArray() -&gt; [Int] {\n        // 有効長の範囲内のリスト要素のみを変換\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    #nums; // キュー要素を格納する配列\n    #front = 0; // 先頭ポインタ。先頭要素を指す\n    #queSize = 0; // キューの長さ\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* キューの容量を取得 */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* キューの長さを取得 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* エンキュー */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('キューがいっぱいです');\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        const rear = (this.#front + this.size) % this.capacity;\n        // num をキュー末尾に追加\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* デキュー */\n    pop() {\n        const num = this.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek() {\n        if (this.isEmpty()) throw new Error('キューが空です');\n        return this.#nums[this.#front];\n    }\n\n    /* Array を返す */\n    toArray() {\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n    private nums: number[]; // キュー要素を格納する配列\n    private front: number; // 先頭ポインタ。先頭要素を指す\n    private queSize: number; // キューの長さ\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* キューの容量を取得 */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* キューの長さを取得 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* キューが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* エンキュー */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('キューは満杯です');\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        const rear = (this.front + this.queSize) % this.capacity;\n        // num をキュー末尾に追加\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* デキュー */\n    pop(): number {\n        const num = this.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* キュー先頭の要素にアクセス */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('キューが空です');\n        return this.nums[this.front];\n    }\n\n    /* Array を返す */\n    toArray(): number[] {\n        // 有効長の範囲内のリスト要素のみを変換\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // キュー要素を格納する配列\n  late int _front; // 先頭ポインタ。先頭要素を指す\n  late int _queSize; // キューの長さ\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* キューの容量を取得 */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* キューの長さを取得 */\n  int size() {\n    return _queSize;\n  }\n\n  /* キューが空かどうかを判定 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* エンキュー */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"キューは満杯です\");\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    int rear = (_front + _queSize) % capaCity();\n    // _num をキュー末尾に追加\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* デキュー */\n  int pop() {\n    int _num = peek();\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* キュー先頭の要素にアクセス */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"キューが空です\");\n    }\n    return _nums[_front];\n  }\n\n  /* Array を返す */\n  List&lt;int&gt; toArray() {\n    // 有効長の範囲内のリスト要素のみを変換\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* 循環配列ベースのキュー */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // キュー要素を格納する配列\n    front: i32,        // 先頭ポインタ。先頭要素を指す\n    que_size: i32,     // キューの長さ\n    que_capacity: i32, // キューの容量\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* コンストラクタ */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* キューの容量を取得 */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* キューの長さを取得 */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* キューが空かどうかを判定 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* エンキュー */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"キューがいっぱいです\");\n            return;\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // num をキュー末尾に追加\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* デキュー */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* 配列を返す */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* 循環配列ベースのキュー */\ntypedef struct {\n    int *nums;       // キュー要素を格納する配列\n    int front;       // 先頭ポインタ。先頭要素を指す\n    int queSize;     // 現在のキュー内の要素数\n    int queCapacity; // キューの容量\n} ArrayQueue;\n\n/* コンストラクタ */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // 配列を初期化\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* デストラクタ */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* キューの容量を取得 */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* キューの長さを取得 */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* キューが空かどうかを判定 */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* キュー先頭の要素にアクセス */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* エンキュー */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"キューは満杯です\\r\\n\");\n        return;\n    }\n    // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // num をキュー末尾に追加\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* デキュー */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 出力用の配列を返す */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* 循環配列ベースのキュー */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // キュー要素を格納する配列\n    private var front: Int = 0 // 先頭ポインタ。先頭要素を指す\n    private var queSize: Int = 0 // キューの長さ\n\n    /* キューの容量を取得 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* キューの長さを取得 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* キューが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* エンキュー */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"キューは満杯です\")\n            return\n        }\n        // 末尾ポインタを計算し、末尾インデックス + 1 を指す\n        // 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n        val rear = (front + queSize) % capacity()\n        // num をキュー末尾に追加\n        nums[rear] = num\n        queSize++\n    }\n\n    /* デキュー */\n    fun pop(): Int {\n        val num = peek()\n        // 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* キュー先頭の要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 配列を返す */\n    fun toArray(): IntArray {\n        // 有効長の範囲内のリスト要素のみを変換\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### 循環配列で実装したキュー ###\nclass ArrayQueue\n  ### キューの長さを取得 ###\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # キュー要素を格納する配列\n    @front = 0 # 先頭ポインタ。先頭要素を指す\n    @size = 0 # キューの長さ\n  end\n\n  ### キューの容量を取得 ###\n  def capacity\n    @nums.length\n  end\n\n  ### キューが空か判定 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### エンキュー ###\n  def push(num)\n    raise IndexError, 'キューがいっぱいです' if size == capacity\n\n    # 末尾ポインタを計算し、末尾インデックス + 1 を指す\n    # 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする\n    rear = (@front + size) % capacity\n    # num をキュー末尾に追加\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### デキュー ###\n  def pop\n    num = peek\n    # 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### 先頭要素にアクセス ###\n  def peek\n    raise IndexError, 'キューは空です' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 表示用のリストを返す ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>上記の実装によるキューにも制約があり、長さを可変にできません。しかし、この問題の解決は難しくなく、配列を動的配列に置き換えれば容量拡張の仕組みを導入できます。興味があれば自分で実装してみてください。</p> <p>2 つの実装の比較に関する結論はスタックの場合と同じなので、ここでは繰り返しません。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   キューの典型的な応用","text":"<ul> <li>淘宝の注文。購入者が注文すると、その注文はキューに追加され、システムは順番に従って注文を処理します。ダブルイレブンの期間には短時間で膨大な注文が発生するため、高並行性がエンジニアにとって重点的に解決すべき課題になります。</li> <li>各種の待機事項。先着順の機能を実現する必要があるあらゆる場面、たとえばプリンターのジョブキューや飲食店の配膳キューなどでは、キューによって処理順序を効果的に維持できます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.2 &nbsp; キュー"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   スタック","text":"<p>スタック（stack）は、後入れ先出しの論理に従う線形データ構造です。</p> <p>スタックは机の上に積まれた皿の山にたとえられます。1回に1枚の皿しか動かせないとすると、いちばん下の皿を取り出すには、上にある皿を順番にどかす必要があります。この皿をさまざまな型の要素（整数、文字、オブジェクトなど）に置き換えたものが、スタックというデータ構造です。</p> <p>下図のように、積み重なった要素の上端を「スタックトップ」、下端を「スタックボトム」と呼びます。要素をスタックトップに追加する操作を「プッシュ」、スタックトップの要素を削除する操作を「ポップ」と呼びます。</p> <p></p> <p> 図 5-1   スタックの後入れ先出しの規則 </p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   スタックの基本操作","text":"<p>スタックの基本操作を以下の表に示します。具体的なメソッド名は使用するプログラミング言語によって異なります。ここでは、一般的な <code>push()</code>、<code>pop()</code>、<code>peek()</code> を例に挙げます。</p> <p> 表 5-1   スタックの操作効率 </p> メソッド 説明 時間計算量 <code>push()</code> 要素をプッシュする（スタックトップに追加） \\(O(1)\\) <code>pop()</code> スタックトップの要素をポップする \\(O(1)\\) <code>peek()</code> スタックトップの要素にアクセスする \\(O(1)\\) <p>通常は、プログラミング言語に組み込まれているスタッククラスをそのまま利用できます。ただし、専用のスタッククラスが用意されていない言語もあります。その場合は、その言語の「配列」や「連結リスト」をスタックとして用い、プログラムのロジック上でスタックに無関係な操作を無視します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># スタックを初期化\n# Python には組み込みのスタッククラスがないため、list をスタックとして使用できる\nstack: list[int] = []\n\n# 要素をプッシュ\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# スタックトップの要素にアクセス\npeek: int = stack[-1]\n\n# 要素をポップ\npop: int = stack.pop()\n\n# スタックの長さを取得\nsize: int = len(stack)\n\n# 空かどうかを判定\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* スタックを初期化 */\nstack&lt;int&gt; stack;\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nint top = stack.top();\n\n/* 要素をポップ */\nstack.pop(); // 戻り値なし\n\n/* スタックの長さを取得 */\nint size = stack.size();\n\n/* 空かどうかを判定 */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* スタックを初期化 */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.peek();\n\n/* 要素をポップ */\nint pop = stack.pop();\n\n/* スタックの長さを取得 */\nint size = stack.size();\n\n/* 空かどうかを判定 */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* スタックを初期化 */\nStack&lt;int&gt; stack = new();\n\n/* 要素をプッシュ */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.Peek();\n\n/* 要素をポップ */\nint pop = stack.Pop();\n\n/* スタックの長さを取得 */\nint size = stack.Count;\n\n/* 空かどうかを判定 */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* スタックを初期化 */\n// Go では、Slice をスタックとして使うのが一般的\nvar stack []int\n\n/* 要素をプッシュ */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* スタックトップの要素にアクセス */\npeek := stack[len(stack)-1]\n\n/* 要素をポップ */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* スタックの長さを取得 */\nsize := len(stack)\n\n/* 空かどうかを判定 */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* スタックを初期化 */\n// Swift には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nvar stack: [Int] = []\n\n/* 要素をプッシュ */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* スタックトップの要素にアクセス */\nlet peek = stack.last!\n\n/* 要素をポップ */\nlet pop = stack.removeLast()\n\n/* スタックの長さを取得 */\nlet size = stack.count\n\n/* 空かどうかを判定 */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* スタックを初期化 */\n// JavaScript には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nconst stack = [];\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nconst peek = stack[stack.length-1];\n\n/* 要素をポップ */\nconst pop = stack.pop();\n\n/* スタックの長さを取得 */\nconst size = stack.length;\n\n/* 空かどうかを判定 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* スタックを初期化 */\n// TypeScript には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nconst stack: number[] = [];\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nconst peek = stack[stack.length - 1];\n\n/* 要素をポップ */\nconst pop = stack.pop();\n\n/* スタックの長さを取得 */\nconst size = stack.length;\n\n/* 空かどうかを判定 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* スタックを初期化 */\n// Dart には組み込みのスタッククラスがないため、List をスタックとして使用できる\nList&lt;int&gt; stack = [];\n\n/* 要素をプッシュ */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* スタックトップの要素にアクセス */\nint peek = stack.last;\n\n/* 要素をポップ */\nint pop = stack.removeLast();\n\n/* スタックの長さを取得 */\nint size = stack.length;\n\n/* 空かどうかを判定 */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* スタックを初期化 */\n// Vec をスタックとして使用する\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* 要素をプッシュ */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* スタックトップの要素にアクセス */\nlet top = stack.last().unwrap();\n\n/* 要素をポップ */\nlet pop = stack.pop().unwrap();\n\n/* スタックの長さを取得 */\nlet size = stack.len();\n\n/* 空かどうかを判定 */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C には組み込みのスタックがない\n</code></pre> stack.kt<pre><code>/* スタックを初期化 */\nval stack = Stack&lt;Int&gt;()\n\n/* 要素をプッシュ */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* スタックトップの要素にアクセス */\nval peek = stack.peek()\n\n/* 要素をポップ */\nval pop = stack.pop()\n\n/* スタックの長さを取得 */\nval size = stack.size\n\n/* 空かどうかを判定 */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># スタックを初期化\n# Ruby には組み込みのスタッククラスがないため、Array をスタックとして使用できる\nstack = []\n\n# 要素をプッシュ\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# スタックトップの要素にアクセス\npeek = stack.last\n\n# 要素をポップ\npop = stack.pop\n\n# スタックの長さを取得\nsize = stack.length\n\n# 空かどうかを判定\nis_empty = stack.empty?\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%A0%88%0A%20%20%20%20%23%20Python%20%E6%B2%A1%E6%9C%89%E5%86%85%E7%BD%AE%E7%9A%84%E6%A0%88%E7%B1%BB%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%8A%8A%20list%20%E5%BD%93%E4%BD%9C%E6%A0%88%E6%9D%A5%E4%BD%BF%E7%94%A8%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E6%A0%88%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%E6%A0%88%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%20peek%20%3D%22,%20peek%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E6%A0%88%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%90%8E%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E6%A0%88%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   スタックの実装","text":"<p>スタックの動作の仕組みをより深く理解するために、自分でスタッククラスを実装してみましょう。</p> <p>スタックは後入れ先出しの原則に従うため、要素の追加や削除はスタックトップでしか行えません。一方、配列や連結リストでは任意の位置で要素を追加・削除できます。つまり、スタックは制限付きの配列または連結リストとみなせます。 言い換えると、配列や連結リストのうち無関係な操作を「隠蔽」することで、外から見た振る舞いをスタックの特性に合わせられます。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   連結リストによる実装","text":"<p>連結リストでスタックを実装する場合、連結リストの先頭ノードをスタックトップ、末尾ノードをスタックボトムとみなせます。</p> <p>下図のように、プッシュ操作では要素を連結リストの先頭に挿入するだけでよく、このノード挿入方法は「頭部挿入法」と呼ばれます。ポップ操作では、先頭ノードを連結リストから削除するだけです。</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> 図 5-2   連結リストによるスタック実装のプッシュ・ポップ操作 </p> <p>以下は、連結リストによってスタックを実装したコード例です：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"連結リストベースのスタック\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"スタックの長さを取得\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"スタックが空かどうかを判定\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"プッシュ\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"ポップ\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"スタックトップの要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用にリストへ変換\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // 先頭ノードをスタックトップとする\n    int stkSize;        // スタックの長さ\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // 連結リストを走査してノードを削除し、メモリを解放する\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* スタックの長さを取得 */\n    int size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // メモリを解放する\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"スタックが空です\");\n        return stackTop-&gt;val;\n    }\n\n    /* List を Array に変換して返す */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private ListNode stackPeek; // 先頭ノードをスタックトップとする\n    private int stkSize = 0; // スタックの長さ\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* List を Array に変換して返す */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    ListNode? stackPeek;  // 先頭ノードをスタックトップとする\n    int stkSize = 0;   // スタックの長さ\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* プッシュ */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* ポップ */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* List を Array に変換して返す */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* 連結リストベースのスタック */\ntype linkedListStack struct {\n    // 組み込みパッケージ list でスタックを実装する\n    data *list.List\n}\n\n/* スタックを初期化 */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* プッシュ */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* ポップ */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* スタックトップの要素にアクセス */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* スタックの長さを取得 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* スタックが空かどうかを判定 */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 表示用に List を取得 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private var _peek: ListNode? // 先頭ノードをスタックトップとする\n    private var _size: Int // スタックの長さ\n\n    init() {\n        _size = 0\n    }\n\n    /* スタックの長さを取得 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* スタックが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* プッシュ */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* ポップ */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* スタックトップの要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return _peek!.val\n    }\n\n    /* List を Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    #stackPeek; // 先頭ノードをスタックトップとする\n    #stkSize = 0; // スタックの長さ\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* プッシュ */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* ポップ */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    peek() {\n        if (!this.#stackPeek) throw new Error('スタックが空');\n        return this.#stackPeek.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // 先頭ノードをスタックトップとする\n    private stkSize: number = 0; // スタックの長さ\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* スタックの長さを取得 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* プッシュ */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* ポップ */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('スタックが空です');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('スタックが空です');\n        return this.stackPeek.val;\n    }\n\n    /* 連結リストを Array に変換して返す */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* 連結リストクラスに基づくスタック */\nclass LinkedListStack {\n  ListNode? _stackPeek; // 先頭ノードをスタックトップとする\n  int _stkSize = 0; // スタックの長さ\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* スタックの長さを取得 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* スタックが空かどうかを判定 */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* プッシュ */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* ポップ */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* スタックトップの要素にアクセス */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* 連結リストを List に変換して返す */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* 連結リストベースのスタック */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 先頭ノードをスタックトップとする\n    stk_size: usize,                              // スタックの長さ\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* スタックの長さを取得 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* スタックが空かどうかを判定 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* プッシュ */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* ポップ */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* スタックトップの要素にアクセス */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* List を Array に変換して返す */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* 連結リストベースのスタック */\ntypedef struct {\n    ListNode *top; // 先頭ノードをスタックトップとする\n    int size;      // スタックの長さ\n} LinkedListStack;\n\n/* コンストラクタ */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* デストラクタ */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* スタックの長さを取得 */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* スタックが空かどうかを判定 */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* プッシュ */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // 新しく追加したノードのポインタフィールドを更新\n    node-&gt;val = num;     // 新しく追加したノードのデータフィールドを更新\n    s-&gt;top = node;       // スタックトップを更新\n    s-&gt;size++;           // スタックサイズを更新\n}\n\n/* スタックトップの要素にアクセス */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"スタックは空です\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* ポップ */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // メモリを解放する\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* 連結リストベースのスタック */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // 先頭ノードをスタックトップとする\n    private var stkSize: Int = 0 // スタックの長さ\n) {\n\n    /* スタックの長さを取得 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* スタックが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* プッシュ */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* ポップ */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* スタックトップの要素にアクセス */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* List を Array に変換して返す */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### 連結リストで実装したスタック ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### コンストラクタ ###\n  def initialize\n    @size = 0\n  end\n\n  ### スタックが空か判定 ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### プッシュ ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### ポップ ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### スタックトップ要素を参照 ###\n  def peek\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @peek.val\n  end\n\n  ### 連結リストを Array に変換して返す ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   配列による実装","text":"<p>配列でスタックを実装する場合、配列の末尾をスタックトップとして扱えます。下図のように、プッシュとポップはそれぞれ配列末尾への要素追加と削除に対応し、どちらの時間計算量も \\(O(1)\\) です。</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> 図 5-3   配列によるスタック実装のプッシュ・ポップ操作 </p> <p>プッシュされる要素は際限なく増える可能性があるため、動的配列を使えば、配列の拡張を自前で処理する必要がありません。以下にコード例を示します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"配列ベースのスタック\"\"\"\n\n    def __init__(self):\n        \"\"\"コンストラクタ\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"スタックの長さを取得\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"スタックが空かどうかを判定\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"プッシュ\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"ポップ\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"スタックトップの要素にアクセス\"\"\"\n        if self.is_empty():\n            raise IndexError(\"スタックが空です\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"表示用のリストを返す\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* スタックの長さを取得 */\n    int size() {\n        return stack.size();\n    }\n\n    /* スタックが空かどうかを判定 */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* プッシュ */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* ポップ */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* スタックトップの要素にアクセス */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"スタックが空です\");\n        return stack.back();\n    }\n\n    /* Vector を返す */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // リスト（動的配列）を初期化する\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* スタックの長さを取得 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* スタックが空かどうかを判定 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* プッシュ */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* ポップ */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* List を Array に変換して返す */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // リスト（動的配列）を初期化する\n        stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* スタックが空かどうかを判定 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* プッシュ */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* ポップ */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* スタックトップの要素にアクセス */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* List を Array に変換して返す */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* 配列ベースのスタック */\ntype arrayStack struct {\n    data []int // データ\n}\n\n/* スタックを初期化 */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // スタックの長さを 0、容量を 16 に設定\n        data: make([]int, 0, 16),\n    }\n}\n\n/* スタックの長さ */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* スタックが空かどうか */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* プッシュ */\nfunc (s *arrayStack) push(v int) {\n    // スライスは自動で拡張される\n    s.data = append(s.data, v)\n}\n\n/* ポップ */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* スタックトップ要素を取得する */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* 表示用に Slice を取得 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // リスト（動的配列）を初期化する\n        stack = []\n    }\n\n    /* スタックの長さを取得 */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* スタックが空かどうかを判定 */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* プッシュ */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* ポップ */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return stack.removeLast()\n    }\n\n    /* スタックトップの要素にアクセス */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"スタックが空です\")\n        }\n        return stack.last!\n    }\n\n    /* List を Array に変換して返す */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* プッシュ */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* ポップ */\n    pop() {\n        if (this.isEmpty()) throw new Error('スタックが空');\n        return this.#stack.pop();\n    }\n\n    /* スタックトップの要素にアクセス */\n    top() {\n        if (this.isEmpty()) throw new Error('スタックが空');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Array を返す */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* スタックの長さを取得 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* スタックが空かどうかを判定 */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* プッシュ */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* ポップ */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('スタックが空です');\n        return this.stack.pop();\n    }\n\n    /* スタックトップの要素にアクセス */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('スタックが空です');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Array を返す */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* スタックの長さを取得 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* スタックが空かどうかを判定 */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* プッシュ */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* ポップ */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* スタックトップの要素にアクセス */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"スタックが空です\");\n    }\n    return _stack.last;\n  }\n\n  /* スタックを Array に変換して返す */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* 配列ベースのスタック */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* スタックを初期化 */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* スタックの長さを取得 */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* スタックが空かどうかを判定 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* プッシュ */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* ポップ */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* スタックトップの要素にアクセス */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"スタックが空です\")\n        };\n        self.stack.last()\n    }\n\n    /* &amp;Vec を返す */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* 配列ベースのスタック */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* コンストラクタ */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // 大きめの容量で初期化し、拡張を避ける\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* デストラクタ */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* スタックの長さを取得 */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* スタックが空かどうかを判定 */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* プッシュ */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"スタックは満杯です\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* スタックトップの要素にアクセス */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"スタックは空です\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* ポップ */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* 配列ベースのスタック */\nclass ArrayStack {\n    // リスト（動的配列）を初期化する\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* スタックの長さを取得 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* スタックが空かどうかを判定 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* プッシュ */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* ポップ */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* スタックトップの要素にアクセス */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* List を Array に変換して返す */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### 配列で実装したスタック ###\nclass ArrayStack\n  ### コンストラクタ ###\n  def initialize\n    @stack = []\n  end\n\n  ### スタックの長さを取得 ###\n  def size\n    @stack.length\n  end\n\n  ### スタックが空か判定 ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### プッシュ ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### ポップ ###\n  def pop\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @stack.pop\n  end\n\n  ### スタックトップ要素を参照 ###\n  def peek\n    raise IndexError, 'スタックは空です' if is_empty?\n\n    @stack.last\n  end\n\n  ### 表示用のリストを返す ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513-2","level":2,"title":"5.1.3   2つの実装の比較","text":"<p>対応する操作</p> <p>どちらの実装も、スタックの定義に含まれる各種操作をサポートします。配列ベースの実装はランダムアクセスも可能ですが、これはスタックの定義範囲を超えているため、通常は利用しません。</p> <p>時間効率</p> <p>配列ベースの実装では、プッシュとポップの両方があらかじめ確保された連続メモリ上で行われるため、キャッシュ局所性が高く、効率に優れます。ただし、プッシュ時に配列容量を超えると拡張処理が発生し、その1回のプッシュの時間計算量は \\(O(n)\\) になります。</p> <p>連結リストベースの実装では、サイズ拡張が非常に柔軟であり、前述のような配列拡張による効率低下はありません。ただし、プッシュ時にはノードオブジェクトの初期化とポインタの更新が必要になるため、効率は相対的に低くなります。もっとも、プッシュする要素自体がノードオブジェクトであれば、初期化の手間を省けるため、効率を高められます。</p> <p>以上を踏まえると、プッシュおよびポップの対象が <code>int</code> や <code>double</code> のような基本データ型である場合、次の結論が得られます。</p> <ul> <li>配列ベースのスタックは拡張時に効率が低下しますが、拡張は低頻度の操作であるため、平均効率はより高くなります。</li> <li>連結リストベースのスタックは、より安定した効率を提供できます。</li> </ul> <p>空間効率</p> <p>リストを初期化するとき、システムは「初期容量」を割り当てますが、この容量は実際の必要量を上回ることがあります。また、拡張は通常、一定の倍率（たとえば2倍）で行われるため、拡張後の容量も実際の必要量を超える可能性があります。したがって、配列ベースのスタックは一定のメモリ浪費を招く可能性があります。</p> <p>一方で、連結リストのノードはポインタを追加で保持する必要があるため、連結リストノードは相対的に大きな領域を占有します。</p> <p>以上より、どちらの実装がより省メモリかを単純に断定することはできず、具体的な状況に応じて分析する必要があります。</p>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   スタックの典型的な応用","text":"<ul> <li>ブラウザにおける戻ると進む、ソフトウェアにおける取り消しとやり直し。新しいWebページを開くたびに、ブラウザは直前のページをスタックにプッシュするため、戻る操作によって前のページに戻れます。戻る操作は実際にはポップに相当します。戻ると進むを同時にサポートするには、2つのスタックを組み合わせて実現する必要があります。</li> <li>プログラムのメモリ管理。関数を呼び出すたびに、システムはスタックトップにスタックフレームを追加し、関数のコンテキスト情報を記録します。再帰関数では、下向きに再帰していく段階でプッシュが繰り返され、上向きにバックトラックする段階でポップが繰り返されます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.1 &nbsp; スタック"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   まとめ","text":"","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>スタックは後入れ先出しの原則に従うデータ構造であり、配列または連結リストで実装できます。</li> <li>時間効率の面では、スタックの配列実装は平均効率が高い一方、拡張時には 1 回のプッシュ操作の時間計算量が \\(O(n)\\) まで悪化します。これに対して、スタックの連結リスト実装はより安定した効率を示します。</li> <li>空間効率の面では、スタックの配列実装はある程度の領域の無駄を生む可能性があります。ただし、連結リストのノードが占有するメモリは配列要素よりも大きい点に注意が必要です。</li> <li>キューは先入れ先出しの原則に従うデータ構造であり、同様に配列または連結リストで実装できます。時間効率と空間効率の比較における結論は、前述のスタックの場合と似ています。</li> <li>両端キューはより高い自由度を持つキューであり、両端で要素の追加と削除を行えます。</li> </ul>","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ブラウザの進む・戻るは双方向連結リストで実装されているのですか？</p> <p>ブラウザの進む・戻る機能の本質は「スタック」の表れです。ユーザーが新しいページにアクセスすると、そのページはスタックの先頭に追加されます。ユーザーが戻るボタンをクリックすると、そのページはスタックの先頭から取り出されます。両端キューを使うといくつかの追加操作を簡単に実装でき、この点は「両端キュー」の章で触れています。</p> <p>Q：ポップした後、そのノードのメモリを解放する必要はありますか？</p> <p>後で取り出したノードを引き続き使うのであれば、メモリを解放する必要はありません。以降そのノードを使わない場合でも、<code>Java</code> や <code>Python</code> などの言語には自動ガベージコレクション機構があるため、手動でメモリを解放する必要はありません。一方、<code>C</code> と <code>C++</code> では手動でメモリを解放する必要があります。</p> <p>Q：両端キューは 2 つのスタックをつなげたように見えますが、用途は何ですか？</p> <p>両端キューは、スタックとキューの組み合わせ、あるいは 2 つのスタックをつなげたもののような構造です。表しているのはスタック + キューのロジックなので、スタックとキューのすべての応用を実現でき、しかもより柔軟です。</p> <p>Q：取り消し（undo）とやり直し（redo）は具体的にどのように実装されますか？</p> <p>2 つのスタックを使い、スタック <code>A</code> を取り消し用、スタック <code>B</code> をやり直し用に使います。</p> <ol> <li>ユーザーが操作を 1 つ実行するたびに、その操作をスタック <code>A</code> にプッシュし、スタック <code>B</code> を空にします。</li> <li>ユーザーが「取り消し」を実行したときは、スタック <code>A</code> から直近の操作をポップし、それをスタック <code>B</code> にプッシュします。</li> <li>ユーザーが「やり直し」を実行したときは、スタック <code>B</code> から直近の操作をポップし、それをスタック <code>A</code> にプッシュします。</li> </ol>","path":["第 5 章 &nbsp; スタックとキュー","5.4 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"第 7 章   木","text":"<p>Abstract</p> <p>大樹は生命力に満ち、根は深く葉は生い茂り、枝は豊かに広がる。</p> <p>それはデータ分割統治の生き生きとした姿を私たちに示してくれる。</p>","path":["第 7 章 &nbsp; 木"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"章の内容","text":"<ul> <li>7.1   二分木</li> <li>7.2   二分木の走査</li> <li>7.3   二分木の配列表現</li> <li>7.4   二分探索木</li> <li>7.5   AVL 木 *</li> <li>7.6   まとめ</li> </ul>","path":["第 7 章 &nbsp; 木"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   二分木の配列表現","text":"<p>連結リスト表現では、二分木の記憶単位はノード <code>TreeNode</code> であり、ノード同士はポインタによって接続されます。前節では、連結リスト表現における二分木の各種基本操作を紹介しました。</p> <p>では、配列で二分木を表現できるでしょうか？答えはもちろん可能です。</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   充足二分木を表現する","text":"<p>まずは簡単な例を考えます。与えられた 1 本の充足二分木について、すべてのノードをレベル順走査の順に配列へ格納すると、各ノードは一意な配列インデックスに対応します。</p> <p>レベル順走査の性質に基づくと、親ノードのインデックスと子ノードのインデックスの間にある「対応式」を導けます。あるノードのインデックスが \\(i\\) なら、その左子ノードのインデックスは \\(2i + 1\\) 、右子ノードのインデックスは \\(2i + 2\\) です。以下の図は、各ノードインデックス間の対応関係を示しています。</p> <p></p> <p> 図 7-12   充足二分木の配列表現 </p> <p>対応式は、連結リストにおけるノード参照（ポインタ）と同じ役割を果たします。与えられた配列内の任意のノードについて、この対応式を使えばその左（右）子ノードにアクセスできます。</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   任意の二分木を表現する","text":"<p>充足二分木は特殊なケースであり、一般の二分木では中間層に多数の <code>None</code> が存在することがよくあります。レベル順走査の列にはこれらの <code>None</code> が含まれないため、その列だけから <code>None</code> の数や分布位置を推定することはできません。つまり、このレベル順走査列に一致する二分木構造は複数存在し得ます。</p> <p>次の図のように、非充足二分木が与えられると、上記の配列表現はすでに成り立ちません。</p> <p></p> <p> 図 7-13   レベル順走査列に対応する複数の二分木の可能性 </p> <p>この問題を解決するために、**レベル順走査列にすべての <code>None</code> を明示的に書き込む**ことを考えられます。次の図のように、このように処理すればレベル順走査列で二分木を一意に表現できます。コード例は以下のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 二分木の配列表現\n# 空き位置を表すために None を使う\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int の最大値 INT_MAX を使って空き位置を示す\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int のラッパークラス Integer を使えば、null で空き位置を示せる\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な int? 型を使えば、null で空き位置を示せる\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// any 型のスライスを使えば、nil で空き位置を示せる\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な Int? 型を使えば、nil で空き位置を示せる\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// nullable な int? 型を使えば、null で空き位置を示せる\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// None を使って空き位置を示す\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// int の最大値で空き位置を示すため、ノード値は INT_MAX であってはならない\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二分木の配列表現 */\n// null を使って空き位置を表す\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### 二分木の配列表現 ###\n# nil を使って空き位置を表す\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> 図 7-14   任意の二分木の配列表現 </p> <p>補足すると、完全二分木は配列による表現に非常に適しています。完全二分木の定義を振り返ると、<code>None</code> は最下層の右側にしか現れないため、すべての <code>None</code> は必ずレベル順走査列の末尾に現れます。</p> <p>つまり、完全二分木を配列で表す場合は、すべての <code>None</code> の格納を省略できるため、非常に便利です。次の図に例を示します。</p> <p></p> <p> 図 7-15   完全二分木の配列表現 </p> <p>以下のコードでは、配列ベースで表現した二分木を実装しており、次の操作を含みます。</p> <ul> <li>あるノードが与えられたとき、その値、左（右）子ノード、親ノードを取得する。</li> <li>前順走査、中順走査、後順走査、レベル順走査の列を取得する。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"配列表現による二分木クラス\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"コンストラクタ\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"リスト容量\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの値を取得\"\"\"\n        # インデックスが範囲外なら、空きを表す None を返す\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの左子ノードのインデックスを取得\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの右子ノードのインデックスを取得\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"インデックス i のノードの親ノードのインデックスを取得\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"レベル順走査\"\"\"\n        self.res = []\n        # 配列を直接走査する\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"深さ優先探索\"\"\"\n        if self.val(i) is None:\n            return\n        # 先行順走査\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # 中順走査\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # 後順走査\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"先行順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"中順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"後順走査\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n  public:\n    /* コンストラクタ */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* リスト容量 */\n    int size() {\n        return tree.size();\n    }\n\n    /* インデックス i のノードの値を取得 */\n    int val(int i) {\n        // インデックスが範囲外なら、空きを表す INT_MAX を返す\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // 配列を直接走査する\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* 先行順走査 */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* 深さ優先探索 */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // 空きスロットなら返す\n        if (val(i) == INT_MAX)\n            return;\n        // 先行順走査\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // 中順走査\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // 後順走査\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* コンストラクタ */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* リスト容量 */\n    public int size() {\n        return tree.size();\n    }\n\n    /* インデックス i のノードの値を取得 */\n    public Integer val(int i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // 配列を直接走査する\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // 空きスロットなら返す\n        if (val(i) == null)\n            return;\n        // 先行順走査\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // 中順走査\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // 後順走査\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* 先行順走査 */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* リスト容量 */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    public int? Val(int i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* レベル順走査 */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // 配列を直接走査する\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // 空きスロットなら返す\n        if (!Val(i).HasValue)\n            return;\n        // 先行順走査\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // 中順走査\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // 後順走査\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* 先行順走査 */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中順走査 */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* 後順走査 */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* 配列表現による二分木クラス */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* コンストラクタ */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* リスト容量 */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* インデックス i のノードの値を取得 */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // インデックスが範囲外なら、空きを表す null を返す\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* インデックス i のノードの左子ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* インデックス i のノードの右子ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* インデックス i のノードの親ノードのインデックスを取得 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* レベル順走査 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // 配列を直接走査する\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* 深さ優先探索 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // 空きスロットなら返す\n    if abt.val(i) == nil {\n        return\n    }\n    // 先行順走査\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // 中順走査\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // 後順走査\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* 先行順走査 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* 中順走査 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* 後順走査 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* コンストラクタ */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* リスト容量 */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* インデックス i のノードの値を取得 */\n    func val(i: Int) -&gt; Int? {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // 配列を直接走査する\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* 深さ優先探索 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // 空きスロットなら返す\n        guard let val = val(i: i) else {\n            return\n        }\n        // 先行順走査\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // 中順走査\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // 後順走査\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* 先行順走査 */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* 中順走査 */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* 後順走査 */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* コンストラクタ */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* リスト容量 */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    val(i) {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // 切り捨て除算\n    }\n\n    /* レベル順走査 */\n    levelOrder() {\n        let res = [];\n        // 配列を直接走査する\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    #dfs(i, order, res) {\n        // 空きスロットなら返す\n        if (this.val(i) === null) return;\n        // 先行順走査\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中順走査\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後順走査\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 先行順走査 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中順走査 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後順走査 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* コンストラクタ */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* リスト容量 */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* インデックス i のノードの値を取得 */\n    val(i: number): number | null {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // 切り捨て除算\n    }\n\n    /* レベル順走査 */\n    levelOrder(): number[] {\n        let res = [];\n        // 配列を直接走査する\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深さ優先探索 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // 空きスロットなら返す\n        if (this.val(i) === null) return;\n        // 先行順走査\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中順走査\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後順走査\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 先行順走査 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中順走査 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後順走査 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* コンストラクタ */\n  ArrayBinaryTree(this._tree);\n\n  /* リスト容量 */\n  int size() {\n    return _tree.length;\n  }\n\n  /* インデックス i のノードの値を取得 */\n  int? val(int i) {\n    // インデックスが範囲外なら、空きを表す null を返す\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* インデックス i のノードの左子ノードのインデックスを取得 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* インデックス i のノードの右子ノードのインデックスを取得 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* インデックス i のノードの親ノードのインデックスを取得 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* レベル順走査 */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* 深さ優先探索 */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // 空きスロットなら返す\n    if (val(i) == null) {\n      return;\n    }\n    // 先行順走査\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // 中順走査\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // 後順走査\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* 先行順走査 */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* 中順走査 */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* 後順走査 */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* 配列表現による二分木クラス */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* コンストラクタ */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* リスト容量 */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* インデックス i のノードの値を取得 */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // インデックスが範囲外なら、空きを表す None を返す\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* 深さ優先探索 */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // 先行順走査\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // 中順走査\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // 後順走査\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* 先行順走査 */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* 中順走査 */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* 後順走査 */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* 配列表現による二分木の構造体 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* コンストラクタ */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* デストラクタ */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* リスト容量 */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* インデックス i のノードの値を取得 */\nint val(ArrayBinaryTree *abt, int i) {\n    // インデックスが範囲外なら、空きを表す INT_MAX を返す\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* レベル順走査 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // 配列を直接走査する\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* 深さ優先探索 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // 空きスロットなら返す\n    if (val(abt, i) == INT_MAX)\n        return;\n    // 先行順走査\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // 中順走査\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // 後順走査\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* 先行順走査 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 中順走査 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 後順走査 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* 配列表現による二分木クラス */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* リスト容量 */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* インデックス i のノードの値を取得 */\n    fun _val(i: Int): Int? {\n        // インデックスが範囲外なら、空きを表す null を返す\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* インデックス i のノードの左子ノードのインデックスを取得 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* インデックス i のノードの右子ノードのインデックスを取得 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* インデックス i のノードの親ノードのインデックスを取得 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* レベル順走査 */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // 配列を直接走査する\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* 深さ優先探索 */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // 空きスロットなら返す\n        if (_val(i) == null)\n            return\n        // 先行順走査\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // 中順走査\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // 後順走査\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* 先行順走査 */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* 中順走査 */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* 後順走査 */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### 配列表現の二分木クラス ###\nclass ArrayBinaryTree\n  ### コンストラクタ ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### リスト容量 ###\n  def size\n    @tree.length\n  end\n\n  ### インデックス i のノードの値を取得 ###\n  def val(i)\n    # インデックスが範囲外なら `nil` を返し、空きスロットを表す\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### インデックス i のノードの左子ノードのインデックスを取得 ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### インデックス i のノードの右子ノードのインデックスを取得 ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### インデックス i のノードの親ノードのインデックスを取得 ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### レベル順走査 ###\n  def level_order\n    @res = []\n\n    # 配列を直接走査する\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### 深さ優先探索 ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # 先行順走査\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # 中順走査\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # 後順走査\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### 前順走査 ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### 中順走査 ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### 後順走査 ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   利点と制約","text":"<p>二分木の配列表現には主に次の利点があります。</p> <ul> <li>配列は連続したメモリ空間に格納されるため、キャッシュ効率が高く、アクセスと走査が速い。</li> <li>ポインタを格納する必要がなく、比較的省スペースである。</li> <li>ノードへのランダムアクセスが可能である。</li> </ul> <p>ただし、配列表現にはいくつかの制約もあります。</p> <ul> <li>配列による格納には連続したメモリ空間が必要なため、データ量が大きすぎる木の格納には向かない。</li> <li>ノードの追加と削除は配列の挿入・削除操作で実現する必要があり、効率は低い。</li> <li>二分木に大量の <code>None</code> が存在すると、配列に占める実ノードデータの比率が低くなり、空間利用率も低下する。</li> </ul>","path":["第 7 章 &nbsp; 木","7.3 &nbsp; 二分木の配列表現"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL 木 *","text":"<p>「二分探索木」章で述べたように、挿入と削除を何度も繰り返すと、二分探索木は連結リストへ退化する可能性があります。この場合、すべての操作の時間計算量は \\(O(\\log n)\\) から \\(O(n)\\) へ劣化します。</p> <p>以下の図に示すように、ノード削除を 2 回行うと、この二分探索木は連結リストへ退化します。</p> <p></p> <p> 図 7-24   AVL 木がノード削除後に退化する </p> <p>別の例として、以下の図に示す完全二分木に 2 つのノードを挿入すると、木は大きく左に傾き、探索操作の時間計算量もそれに伴って劣化します。</p> <p></p> <p> 図 7-25   AVL 木がノード挿入後に退化する </p> <p>1962 年、G. M. Adelson-Velsky と E. M. Landis は論文“An algorithm for the organization of information”の中で AVL 木 を提案しました。論文では一連の操作が詳しく説明されており、ノードの追加と削除を続けても AVL 木が退化しないようにして、各種操作の時間計算量を \\(O(\\log n)\\) の水準に保ちます。言い換えると、追加・削除・探索・更新を頻繁に行う場面でも、AVL 木は常に高いデータ操作性能を維持でき、実用価値の高い構造です。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl","level":2,"title":"7.5.1   AVL 木の基本用語","text":"<p>AVL 木は二分探索木であると同時に平衡二分木でもあり、これら 2 種類の二分木の性質をすべて満たします。したがって、平衡二分探索木（balanced binary search tree）の一種です。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   ノードの高さ","text":"<p>AVL 木の操作ではノードの高さを取得する必要があるため、ノードクラスに <code>height</code> 変数を追加します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL 木ノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # ノード値\n        self.height: int = 0                # ノードの高さ\n        self.left: TreeNode | None = None   # 左の子ノード参照\n        self.right: TreeNode | None = None  # 右の子ノード参照\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nstruct TreeNode {\n    int val{};          // ノード値\n    int height = 0;     // ノードの高さ\n    TreeNode *left{};   // 左の子ノード\n    TreeNode *right{};  // 右の子ノード\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    public int val;        // ノード値\n    public int height;     // ノードの高さ\n    public TreeNode left;  // 左の子ノード\n    public TreeNode right; // 右の子ノード\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode(int? x) {\n    public int? val = x;    // ノード値\n    public int height;      // ノードの高さ\n    public TreeNode? left;  // 左の子ノード参照\n    public TreeNode? right; // 右の子ノード参照\n}\n</code></pre> <pre><code>/* AVL 木ノード構造体 */\ntype TreeNode struct {\n    Val    int       // ノード値\n    Height int       // ノードの高さ\n    Left   *TreeNode // 左の子ノード参照\n    Right  *TreeNode // 右の子ノード参照\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    var val: Int // ノード値\n    var height: Int // ノードの高さ\n    var left: TreeNode? // 左の子ノード\n    var right: TreeNode? // 右の子ノード\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    val; // ノード値\n    height; //ノードの高さ\n    left; // 左の子ノードポインタ\n    right; // 右の子ノードポインタ\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n    val: number;            // ノード値\n    height: number;         // ノードの高さ\n    left: TreeNode | null;  // 左の子ノードポインタ\n    right: TreeNode | null; // 右の子ノードポインタ\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode {\n  int val;         // ノード値\n  int height;      // ノードの高さ\n  TreeNode? left;  // 左の子ノード\n  TreeNode? right; // 右の子ノード\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL 木ノード構造体 */\nstruct TreeNode {\n    val: i32,                               // ノード値\n    height: i32,                            // ノードの高さ\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左の子ノード\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右の子ノード\n}\n\nimpl TreeNode {\n    /* コンストラクタ */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL 木ノード構造体 */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* コンストラクタ */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL 木ノードクラス */\nclass TreeNode(val _val: Int) {  // ノード値\n    val height: Int = 0          // ノードの高さ\n    val left: TreeNode? = null   // 左の子ノード\n    val right: TreeNode? = null  // 右の子ノード\n}\n</code></pre> <pre><code>### AVL 木ノードクラス ###\nclass TreeNode\n  attr_accessor :val    # ノード値\n  attr_accessor :height # ノードの高さ\n  attr_accessor :left   # 左の子ノード参照\n  attr_accessor :right  # 右の子ノード参照\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>「ノードの高さ」とは、そのノードから最も遠い葉ノードまでの距離、すなわち通過する「辺」の本数を指します。特に、葉ノードの高さは \\(0\\)、空ノードの高さは \\(-1\\) です。ここでは、ノードの高さを取得・更新するための 2 つの補助関数を用意します：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"ノードの高さを取得\"\"\"\n    # 空ノードの高さは -1、葉ノードの高さは 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"ノードの高さを更新する\"\"\"\n    # ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* ノードの高さを取得 */\nint height(TreeNode *node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode *node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードの高さを取得 */\nint height(TreeNode node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードの高さを取得 */\nint Height(TreeNode? node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid UpdateHeight(TreeNode node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードの高さを取得 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* ノードの高さを更新する */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードの高さを取得 */\nfunc height(node: TreeNode?) -&gt; Int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    node?.height ?? -1\n}\n\n/* ノードの高さを更新する */\nfunc updateHeight(node: TreeNode?) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* ノードの高さを取得 */\nheight(node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node === null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\n#updateHeight(node) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードの高さを取得 */\nheight(node: TreeNode): number {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node === null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nupdateHeight(node: TreeNode): void {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードの高さを取得 */\nint height(TreeNode? node) {\n  // 空ノードの高さは -1、葉ノードの高さは 0\n  return node == null ? -1 : node.height;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode? node) {\n  // ノードの高さは最も高い部分木の高さ + 1 に等しい\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードの高さを取得 */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* ノードの高さを更新する */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // ノードの高さは最も高い部分木の高さ + 1 に等しい\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードの高さを取得 */\nint height(TreeNode *node) {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* ノードの高さを更新する */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードの高さを取得 */\nfun height(node: TreeNode?): Int {\n    // 空ノードの高さは -1、葉ノードの高さは 0\n    return node?.height ?: -1\n}\n\n/* ノードの高さを更新する */\nfun updateHeight(node: TreeNode?) {\n    // ノードの高さは最も高い部分木の高さ + 1 に等しい\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### ノードの高さを取得 ###\ndef height(node)\n  # 空ノードの高さは -1、葉ノードの高さは 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### ノードの高さを更新 ###\ndef update_height(node)\n  # ノードの高さは最も高い部分木の高さ + 1 に等しい\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   ノードの平衡係数","text":"<p>ノードの平衡係数（balance factor）は、左部分木の高さから右部分木の高さを引いた値と定義し、空ノードの平衡係数は \\(0\\) とします。同様に、ノードの平衡係数を取得する機能も関数にカプセル化して、後続で使いやすくします：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"平衡係数を取得\"\"\"\n    # 空ノードの平衡係数は 0\n    if node is None:\n        return 0\n    # ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode *node) {\n    // 空ノードの平衡係数は 0\n    if (node == nullptr)\n        return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode node) {\n    // 空ノードの平衡係数は 0\n    if (node == null)\n        return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* 平衡係数を取得 */\nint BalanceFactor(TreeNode? node) {\n    // 空ノードの平衡係数は 0\n    if (node == null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* 平衡係数を取得 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // 空ノードの平衡係数は 0\n    if node == nil {\n        return 0\n    }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* 平衡係数を取得 */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // 空ノードの平衡係数は 0\n    guard let node = node else { return 0 }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* 平衡係数を取得 */\nbalanceFactor(node) {\n    // 空ノードの平衡係数は 0\n    if (node === null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* 平衡係数を取得 */\nbalanceFactor(node: TreeNode): number {\n    // 空ノードの平衡係数は 0\n    if (node === null) return 0;\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode? node) {\n  // 空ノードの平衡係数は 0\n  if (node == null) return 0;\n  // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* 平衡係数を取得 */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // 空ノードの平衡係数は 0\n        None =&gt; 0,\n        // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 平衡係数を取得 */\nint balanceFactor(TreeNode *node) {\n    // 空ノードの平衡係数は 0\n    if (node == NULL) {\n        return 0;\n    }\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* 平衡係数を取得 */\nfun balanceFactor(node: TreeNode?): Int {\n    // 空ノードの平衡係数は 0\n    if (node == null) return 0\n    // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### 平衡係数を取得 ###\ndef balance_factor(node)\n  # 空ノードの平衡係数は 0\n  return 0 if node.nil?\n\n  # ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>平衡係数を \\(f\\) とすると、AVL 木の任意のノードの平衡係数は常に \\(-1 \\le f \\le 1\\) を満たします。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl","level":2,"title":"7.5.2   AVL 木の回転","text":"<p>AVL 木の特徴は「回転」操作にあり、二分木の中順走査列を変えずに、不平衡ノードを再び平衡に戻せます。言い換えると、回転操作は「二分探索木」の性質を保ちながら、木を再び「平衡二分木」に戻すことができます。</p> <p>平衡係数の絶対値が \\(&gt; 1\\) のノードを「不平衡ノード」と呼びます。ノードの不平衡の形に応じて、回転操作は 4 種類に分かれます。右回転、左回転、右回転してから左回転、左回転してから右回転です。以下でこれらを順に説明します。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   右回転","text":"<p>以下の図では、ノードの下に平衡係数を示しています。下から上へ見ると、二分木で最初に不平衡になるのは「ノード 3」です。この不平衡ノードを根とする部分木に注目し、そのノードを <code>node</code>、左の子ノードを <code>child</code> として、「右回転」を行います。右回転後、部分木は平衡を回復し、なおかつ二分探索木の性質も保たれます。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-26   右回転の手順 </p> <p>以下の図に示すように、ノード <code>child</code> に右の子ノード（<code>grand_child</code> と記す）がある場合、右回転には 1 ステップ追加する必要があります。すなわち、<code>grand_child</code> を <code>node</code> の左の子ノードにします。</p> <p></p> <p> 図 7-27   grand_child を持つ右回転 </p> <p>「右に回転する」というのはあくまでイメージしやすい表現であり、実際にはノードポインタを変更して実現します。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"右回転\"\"\"\n    child = node.left\n    grand_child = child.right\n    # child を支点として node を右回転させる\n    child.right = node\n    node.left = grand_child\n    # ノードの高さを更新する\n    self.update_height(node)\n    self.update_height(child)\n    # 回転後の部分木の根ノードを返す\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 右回転 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // child を支点として node を右回転させる\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 右回転 */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 右回転 */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 右回転 */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // child を支点として node を右回転させる\n    child.Right = node\n    node.Left = grandChild\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 右回転 */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // child を支点として node を右回転させる\n    child?.right = node\n    node?.left = grandChild\n    // ノードの高さを更新する\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 右回転 */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 右回転 */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // child を支点として node を右回転させる\n    child.right = node;\n    node.left = grandChild;\n    // ノードの高さを更新する\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 右回転 */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // child を支点として node を右回転させる\n  child.right = node;\n  node.left = grandChild;\n  // ノードの高さを更新する\n  updateHeight(node);\n  updateHeight(child);\n  // 回転後の部分木の根ノードを返す\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 右回転 */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // child を支点として node を右回転させる\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // ノードの高さを更新する\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 回転後の部分木の根ノードを返す\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 右回転 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // child を支点として node を右回転させる\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 右回転 */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // child を支点として node を右回転させる\n    child.right = node\n    node.left = grandChild\n    // ノードの高さを更新する\n    updateHeight(node)\n    updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 右回転操作 ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # child を支点として node を右回転させる\n  child.right = node\n  node.left = grand_child\n  # ノードの高さを更新する\n  update_height(node)\n  update_height(child)\n  # 回転後の部分木の根ノードを返す\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   左回転","text":"<p>対応する鏡像として、上記の不平衡二分木を左右反転して考えると、以下の図に示す「左回転」が必要になります。</p> <p></p> <p> 図 7-28   左回転 </p> <p>同様に、以下の図に示すように、ノード <code>child</code> に左の子ノード（<code>grand_child</code> と記す）がある場合、左回転にも 1 ステップ追加する必要があります。すなわち、<code>grand_child</code> を <code>node</code> の右の子ノードにします。</p> <p></p> <p> 図 7-29   grand_child を持つ左回転 </p> <p>分かるように、右回転と左回転は論理的に鏡像対称であり、それぞれが解決する 2 種類の不平衡も対称です。この対称性に基づけば、右回転の実装コードにあるすべての <code>left</code> を <code>right</code> に、すべての <code>right</code> を <code>left</code> に置き換えるだけで、左回転の実装コードが得られます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"左回転\"\"\"\n    child = node.right\n    grand_child = child.left\n    # child を支点として node を左回転させる\n    child.left = node\n    node.right = grand_child\n    # ノードの高さを更新する\n    self.update_height(node)\n    self.update_height(child)\n    # 回転後の部分木の根ノードを返す\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 左回転 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // child を支点として node を左回転させる\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 左回転 */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 左回転 */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 左回転 */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // child を支点として node を左回転させる\n    child.Left = node\n    node.Right = grandChild\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 左回転 */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // child を支点として node を左回転させる\n    child?.left = node\n    node?.right = grandChild\n    // ノードの高さを更新する\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 左回転 */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 左回転 */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // child を支点として node を左回転させる\n    child.left = node;\n    node.right = grandChild;\n    // ノードの高さを更新する\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 左回転 */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // child を支点として node を左回転させる\n  child.left = node;\n  node.right = grandChild;\n  // ノードの高さを更新する\n  updateHeight(node);\n  updateHeight(child);\n  // 回転後の部分木の根ノードを返す\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 左回転 */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // child を支点として node を左回転させる\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // ノードの高さを更新する\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 回転後の部分木の根ノードを返す\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 左回転 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // child を支点として node を左回転させる\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // ノードの高さを更新する\n    updateHeight(node);\n    updateHeight(child);\n    // 回転後の部分木の根ノードを返す\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 左回転 */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // child を支点として node を左回転させる\n    child.left = node\n    node.right = grandChild\n    // ノードの高さを更新する\n    updateHeight(node)\n    updateHeight(child)\n    // 回転後の部分木の根ノードを返す\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 左回転操作 ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # child を支点として node を左回転させる\n  child.left = node\n  node.right = grand_child\n  # ノードの高さを更新する\n  update_height(node)\n  update_height(child)\n  # 回転後の部分木の根ノードを返す\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   左回転してから右回転","text":"<p>以下の図の不平衡ノード 3 では、左回転だけでも右回転だけでも部分木を平衡に戻せません。この場合は、まず <code>child</code> に「左回転」を行い、次に <code>node</code> に「右回転」を行います。</p> <p></p> <p> 図 7-30   左回転してから右回転 </p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   右回転してから左回転","text":"<p>以下の図に示すように、上記の不平衡二分木の鏡像のケースでは、まず <code>child</code> に「右回転」を行い、次に <code>node</code> に「左回転」を行います。</p> <p></p> <p> 図 7-31   右回転してから左回転 </p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   回転の選択","text":"<p>以下の図に示す 4 種類の不平衡は、上の各ケースにそれぞれ対応しており、必要な操作は順に右回転、左回転してから右回転、右回転してから左回転、左回転です。</p> <p></p> <p> 図 7-32   AVL 木の 4 つの回転ケース </p> <p>以下の表に示すように、不平衡ノードの平衡係数と、高い側の子ノードの平衡係数の符号を判定することで、その不平衡ノードが上図のどのケースに属するかを判断できます。</p> <p> 表 7-3   4 種類の回転ケースの選択条件 </p> 不平衡ノードの平衡係数 子ノードの平衡係数 採用すべき回転方法 \\(&gt; 1\\) （左に偏った木） \\(\\geq 0\\) 右回転 \\(&gt; 1\\) （左に偏った木） \\(&lt;0\\) 左回転してから右回転 \\(&lt; -1\\) （右に偏った木） \\(\\leq 0\\) 左回転 \\(&lt; -1\\) （右に偏った木） \\(&gt;0\\) 右回転してから左回転 <p>使いやすくするために、回転操作を 1 つの関数にカプセル化します。この関数があれば、さまざまな不平衡ケースに対して回転を行い、不平衡ノードを再び平衡に戻せます。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"回転操作を行い、この部分木の平衡を回復する\"\"\"\n    # ノード node の平衡係数を取得\n    balance_factor = self.balance_factor(node)\n    # 左に偏った木\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # 右回転\n            return self.right_rotate(node)\n        else:\n            # 左回転してから右回転\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # 右に偏った木\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # 左回転\n            return self.left_rotate(node)\n        else:\n            # 右回転してから左回転\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # 平衡木なので回転不要、そのまま返す\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode *rotate(TreeNode *node) {\n    // ノード node の平衡係数を取得\n    int _balanceFactor = balanceFactor(node);\n    // 左に偏った木\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode rotate(TreeNode node) {\n    // ノード node の平衡係数を取得\n    int balanceFactor = balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode? Rotate(TreeNode? node) {\n    // ノード node の平衡係数を取得\n    int balanceFactorInt = BalanceFactor(node);\n    // 左に偏った木\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // 右回転\n            return RightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // 左回転\n            return LeftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // ノード `node` の平衡係数を取得する\n    // Go では短い変数名が推奨されるため、ここで `bf` は `t.balanceFactor` を表す\n    bf := t.balanceFactor(node)\n    // 左に偏った木\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // 右回転\n            return t.rightRotate(node)\n        } else {\n            // 左回転してから右回転\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // 右に偏った木\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // 左回転\n            return t.leftRotate(node)\n        } else {\n            // 右回転してから左回転\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // ノード node の平衡係数を取得\n    let balanceFactor = balanceFactor(node: node)\n    // 左に偏った木\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // 右回転\n            return rightRotate(node: node)\n        } else {\n            // 左回転してから右回転\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // 右に偏った木\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // 左回転\n            return leftRotate(node: node)\n        } else {\n            // 右回転してから左回転\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\n#rotate(node) {\n    // ノード node の平衡係数を取得\n    const balanceFactor = this.balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return this.#rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return this.#leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nrotate(node: TreeNode): TreeNode {\n    // ノード node の平衡係数を取得\n    const balanceFactor = this.balanceFactor(node);\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return this.rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return this.leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode? rotate(TreeNode? node) {\n  // ノード node の平衡係数を取得\n  int factor = balanceFactor(node);\n  // 左に偏った木\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // 右回転\n      return rightRotate(node);\n    } else {\n      // 左回転してから右回転\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // 右に偏った木\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // 左回転\n      return leftRotate(node);\n    } else {\n      // 右回転してから左回転\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // 平衡木なので回転不要、そのまま返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // ノード node の平衡係数を取得\n    let balance_factor = Self::balance_factor(node.clone());\n    // 左に偏った木\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // 右回転\n            Self::right_rotate(Some(node))\n        } else {\n            // 左回転してから右回転\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // 右に偏った木\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // 左回転\n            Self::left_rotate(Some(node))\n        } else {\n            // 右回転してから左回転\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // 平衡木なので回転不要、そのまま返す\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nTreeNode *rotate(TreeNode *node) {\n    // ノード node の平衡係数を取得\n    int bf = balanceFactor(node);\n    // 左に偏った木\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node);\n        } else {\n            // 左回転してから右回転\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右に偏った木\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node);\n        } else {\n            // 右回転してから左回転\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 回転操作を行い、この部分木の平衡を回復する */\nfun rotate(node: TreeNode): TreeNode {\n    // ノード node の平衡係数を取得\n    val balanceFactor = balanceFactor(node)\n    // 左に偏った木\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右回転\n            return rightRotate(node)\n        } else {\n            // 左回転してから右回転\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // 右に偏った木\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左回転\n            return leftRotate(node)\n        } else {\n            // 右回転してから左回転\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // 平衡木なので回転不要、そのまま返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 回転操作を行い、この部分木の平衡を回復する ###\ndef rotate(node)\n  # ノード node の平衡係数を取得\n  balance_factor = balance_factor(node)\n  # 左部分木をたどる\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # 右回転\n      return right_rotate(node)\n    else\n      # 左回転してから右回転\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # 右に偏った木\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # 左回転\n      return left_rotate(node)\n    else\n      # 右回転してから左回転\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # 平衡木なので回転不要、そのまま返す\n  node\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl","level":2,"title":"7.5.3   AVL 木の基本操作","text":"","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   ノードの挿入","text":"<p>AVL 木のノード挿入は、基本的には二分探索木と同じです。唯一の違いは、AVL 木ではノード挿入後に、そのノードから根ノードまでの経路上に複数の不平衡ノードが現れる可能性があることです。したがって、このノードから開始して、下から上へ回転操作を行い、すべての不平衡ノードを平衡に戻す必要があります。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"ノードを挿入\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"ノードを再帰的に挿入する（補助メソッド）\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. 挿入位置を探索してノードを挿入\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # 重複ノードは挿入せず、そのまま返す\n        return node\n    # ノードの高さを更新する\n    self.update_height(node)\n    # 2. 回転操作を行い、部分木の平衡を回復する\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードを挿入 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // 重複ノードは挿入せず、そのまま返す\n    UpdateHeight(node);  // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = Rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードを挿入 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* ノードを再帰的に挿入する（補助関数） */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // 重複ノードは挿入せず、そのまま返す\n        return node\n    }\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = t.rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードを挿入 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // 重複ノードは挿入せず、そのまま返す\n    }\n    updateHeight(node: node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node: node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* ノードを挿入 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // 重複ノードは挿入せず、そのまま返す\n    this.#updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.#rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードを挿入 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // 重複ノードは挿入せず、そのまま返す\n    }\n    this.updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードを挿入 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. 挿入位置を探索してノードを挿入 */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // 重複ノードは挿入せず、そのまま返す\n  updateHeight(node); // ノードの高さを更新する\n  /* 2. 回転操作を行い、部分木の平衡を回復する */\n  node = rotate(node);\n  // 部分木の根ノードを返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードを挿入 */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 挿入位置を探索してノードを挿入 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // 重複ノードは挿入せず、そのまま返す\n                }\n            }\n            Self::update_height(Some(node.clone())); // ノードの高さを更新する\n\n            /* 2. 回転操作を行い、部分木の平衡を回復する */\n            node = Self::rotate(Some(node)).unwrap();\n            // 部分木の根ノードを返す\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードを挿入 */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* ノードを再帰的に挿入する（補助関数） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // 重複ノードは挿入せず、そのまま返す\n        return node;\n    }\n    // ノードの高さを更新する\n    updateHeight(node);\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードを挿入 */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* ノードを再帰的に挿入する（補助メソッド） */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. 挿入位置を探索してノードを挿入 */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // 重複ノードは挿入せず、そのまま返す\n    updateHeight(node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### ノードを挿入 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### ノードを挿入 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n# ## ノードを再帰的に挿入（補助メソッド）###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. 挿入位置を探索してノードを挿入\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # 重複ノードは挿入せず、そのまま返す\n    return node\n  end\n  # ノードの高さを更新する\n  update_height(node)\n  # 2. 回転操作を行い、部分木の平衡を回復する\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_2","level":3,"title":"2.   ノードの削除","text":"<p>同様に、二分探索木のノード削除メソッドを土台として、下から上へ回転操作を行い、すべての不平衡ノードを平衡に戻す必要があります。コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"ノードを削除\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"ノードを再帰的に削除する（補助メソッド）\"\"\"\n    if node is None:\n        return None\n    # 1. ノードを探索して削除\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if child is None:\n                return None\n            # 子ノード数 = 1 の場合、node をそのまま削除する\n            else:\n                node = child\n        else:\n            # 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # ノードの高さを更新する\n    self.update_height(node)\n    # 2. 回転操作を行い、部分木の平衡を回復する\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* ノードを削除 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = Rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* ノードを削除 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* ノードを再帰的に削除する（補助関数） */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. ノードを探索して削除 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // 子ノード数 = 0 の場合、node をそのまま削除して返す\n                return nil\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // ノードの高さを更新する\n    t.updateHeight(node)\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = t.rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* ノードを削除 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. ノードを探索して削除 */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if child == nil {\n                return nil\n            }\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else {\n                node = child\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node: node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* ノードを削除 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child === null) return null;\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else node = child;\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.#rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* ノードを削除 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child === null) {\n                return null;\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = this.rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* ノードを削除 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. ノードを探索して削除 */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // 子ノード数 = 0 の場合、node をそのまま削除して返す\n      if (child == null)\n        return null;\n      // 子ノード数 = 1 の場合、node をそのまま削除する\n      else\n        node = child;\n    } else {\n      // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // ノードの高さを更新する\n  /* 2. 回転操作を行い、部分木の平衡を回復する */\n  node = rotate(node);\n  // 部分木の根ノードを返す\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* ノードを削除 */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. ノードを探索して削除 */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // 子ノード数 = 0 の場合、node をそのまま削除して返す\n                    None =&gt; {\n                        return None;\n                    }\n                    // 子ノード数 = 1 の場合、node をそのまま削除する\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // ノードの高さを更新する\n\n            /* 2. 回転操作を行い、部分木の平衡を回復する */\n            node = Self::rotate(Some(node)).unwrap();\n            // 部分木の根ノードを返す\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* ノードを削除 */\n// stdio.h を導入しているため、ここでは remove 識別子を使えない\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* ノードを再帰的に削除する（補助関数） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. ノードを探索して削除 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // 子ノード数 = 1 の場合、node をそのまま削除する\n                node = child;\n            }\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // ノードの高さを更新する\n    updateHeight(node);\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node);\n    // 部分木の根ノードを返す\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* ノードを削除 */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* ノードを再帰的に削除する（補助メソッド） */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. ノードを探索して削除 */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // 子ノード数 = 0 の場合、node をそのまま削除して返す\n            if (child == null)\n                return null\n            // 子ノード数 = 1 の場合、node をそのまま削除する\n            else\n                node = child\n        } else {\n            // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // ノードの高さを更新する\n    /* 2. 回転操作を行い、部分木の平衡を回復する */\n    node = rotate(node)\n    // 部分木の根ノードを返す\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### ノードを削除 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### ノードを削除 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n# ## ノードを再帰的に削除（補助メソッド）###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. ノードを探索して削除\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # 子ノード数 = 0 の場合、node をそのまま削除して返す\n      return if child.nil?\n      # 子ノード数 = 1 の場合、node をそのまま削除する\n      node = child\n    else\n      # 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # ノードの高さを更新する\n  update_height(node)\n  # 2. 回転操作を行い、部分木の平衡を回復する\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   ノードの探索","text":"<p>AVL 木のノード探索操作は二分探索木と同じなので、ここでは繰り返しません。</p>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl","level":2,"title":"7.5.4   AVL 木の代表的な応用","text":"<ul> <li>大規模データの整理・格納に用いられ、高頻度の探索と低頻度の追加・削除に適しています。</li> <li>データベースのインデックスシステムの構築に使われます。</li> <li>赤黒木も代表的な平衡二分探索木の一つです。AVL 木と比べると、赤黒木は平衡条件がより緩く、ノードの挿入・削除に必要な回転操作が少ないため、平均的な更新効率はより高くなります。</li> </ul>","path":["第 7 章 &nbsp; 木","7.5 &nbsp; AVL 木 *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   二分探索木","text":"<p>以下の図に示すように、二分探索木（binary search tree）は次の条件を満たします。</p> <ol> <li>根ノードについて、左部分木のすべてのノードの値 \\(&lt;\\) 根ノードの値 \\(&lt;\\) 右部分木のすべてのノードの値。</li> <li>任意のノードの左部分木と右部分木も二分探索木であり、すなわち条件 <code>1.</code> も満たします。</li> </ol> <p></p> <p> 図 7-16   二分探索木 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   二分探索木の操作","text":"<p>二分探索木をクラス <code>BinarySearchTree</code> としてカプセル化し、木の根ノードを指すメンバ変数 <code>root</code> を宣言します。</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   ノードの探索","text":"<p>目標ノードの値 <code>num</code> が与えられたら、二分探索木の性質に基づいて探索できます。以下の図に示すように、ノード <code>cur</code> を宣言し、二分木の根ノード <code>root</code> から出発して、ノード値 <code>cur.val</code> と <code>num</code> の大小関係を繰り返し比較します。</p> <ul> <li><code>cur.val &lt; num</code> の場合、目標ノードは <code>cur</code> の右部分木にあるため、<code>cur = cur.right</code> を実行します。</li> <li><code>cur.val &gt; num</code> の場合、目標ノードは <code>cur</code> の左部分木にあるため、<code>cur = cur.left</code> を実行します。</li> <li><code>cur.val = num</code> の場合、目標ノードが見つかったことを表し、ループを抜けてそのノードを返します。</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-17   二分探索木のノード探索例 </p> <p>二分探索木の探索操作は二分探索アルゴリズムと同じ原理で動作し、各ラウンドで半分の候補を除外します。ループ回数の上限は二分木の高さであり、二分木が平衡であれば \\(O(\\log n)\\) 時間です。コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"ノードを探索\"\"\"\n    cur = self._root\n    # ループで探索し、葉ノードを越えたら抜ける\n    while cur is not None:\n        # 目標ノードは cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 目標ノードは cur の左部分木にある\n        elif cur.val &gt; num:\n            cur = cur.left\n        # 目標ノードが見つかったらループを抜ける\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを探索 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 目標ノードは cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを探索 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを探索 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを探索 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // ループで探索し、葉ノードを越えたら抜ける\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // 目標ノードは cur の右部分木にある\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // 目標ノードは cur の左部分木にある\n            node = node.Left\n        } else {\n            // 目標ノードが見つかったらループを抜ける\n            break\n        }\n    }\n    // 目標ノードを返す\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを探索 */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 目標ノードは cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 目標ノードは cur の左部分木にある\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // 目標ノードが見つかったらループを抜ける\n        else {\n            break\n        }\n    }\n    // 目標ノードを返す\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを探索 */\nsearch(num) {\n    let cur = this.root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num) cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを探索 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 目標ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標ノードは cur の左部分木にある\n        else if (cur.val &gt; num) cur = cur.left;\n        // 目標ノードが見つかったらループを抜ける\n        else break;\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを探索 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 目標ノードは cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 目標ノードは cur の左部分木にある\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // 目標ノードが見つかったらループを抜ける\n    else\n      break;\n  }\n  // 目標ノードを返す\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを探索 */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 目標ノードは cur の右部分木にある\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // 目標ノードは cur の左部分木にある\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // 目標ノードが見つかったらループを抜ける\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // 目標ノードを返す\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを探索 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // 目標ノードは cur の右部分木にある\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // 目標ノードは cur の左部分木にある\n            cur = cur-&gt;left;\n        } else {\n            // 目標ノードが見つかったらループを抜ける\n            break;\n        }\n    }\n    // 目標ノードを返す\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを探索 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 目標ノードは cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 目標ノードは cur の左部分木にある\n        else if (cur._val &gt; num)\n            cur.left\n        // 目標ノードが見つかったらループを抜ける\n        else\n            break\n    }\n    // 目標ノードを返す\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを検索 ###\ndef search(num)\n  cur = @root\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  while !cur.nil?\n    # 目標ノードは cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 目標ノードは cur の左部分木にある\n    elsif cur.val &gt; num\n      cur = cur.left\n    # 目標ノードが見つかったらループを抜ける\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   ノードの挿入","text":"<p>挿入する要素 <code>num</code> が与えられたとき、二分探索木の「左部分木 &lt; 根ノード &lt; 右部分木」という性質を保つため、挿入操作の流れは以下の図のようになります。</p> <ol> <li>挿入位置を探索する：探索操作と同様に、根ノードから出発し、現在のノード値と <code>num</code> の大小関係に基づいて下方向へ探索を繰り返し、葉ノードを越えて（<code>None</code> まで到達して）ループを抜けます。</li> <li>その位置にノードを挿入する：ノード <code>num</code> を初期化し、そのノードを <code>None</code> の位置に置きます。</li> </ol> <p></p> <p> 図 7-18   二分探索木にノードを挿入する </p> <p>コード実装では、次の 2 点に注意が必要です。</p> <ul> <li>二分探索木では重複ノードを許可しません。そうでないと定義に反するためです。したがって、挿入対象のノードが木内にすでに存在する場合は、挿入を行わずそのまま返します。</li> <li>ノード挿入を実現するために、ノード <code>pre</code> を用いて前回のループのノードを保持する必要があります。これにより、<code>None</code> までたどり着いたときにその親ノードを取得でき、ノード挿入を完了できます。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"ノードを挿入\"\"\"\n    # 木が空なら、根ノードを初期化する\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # ループで探索し、葉ノードを越えたら抜ける\n    cur, pre = self._root, None\n    while cur is not None:\n        # 重複ノードが見つかったら、直ちに返す\n        if cur.val == num:\n            return\n        pre = cur\n        # 挿入位置は cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 挿入位置は cur の左部分木にある\n        else:\n            cur = cur.left\n    # ノードを挿入\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを挿入 */\nvoid insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur-&gt;left;\n    }\n    // ノードを挿入\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを挿入 */\nvoid insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // ノードを挿入\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを挿入 */\nvoid Insert(int num) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n\n    // ノードを挿入\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを挿入 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // 木が空なら、根ノードを初期化する\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // 挿入対象ノードの直前のノード位置\n    var pre *TreeNode = nil\n    // ループで探索し、葉ノードを越えたら抜ける\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // ノードを挿入\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを挿入 */\nfunc insert(num: Int) {\n    // 木が空なら、根ノードを初期化する\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 重複ノードが見つかったら、直ちに返す\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // 挿入位置は cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 挿入位置は cur の左部分木にある\n        else {\n            cur = cur?.left\n        }\n    }\n    // ノードを挿入\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを挿入 */\ninsert(num) {\n    // 木が空なら、根ノードを初期化する\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val === num) return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else cur = cur.left;\n    }\n    // ノードを挿入\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを挿入 */\ninsert(num: number): void {\n    // 木が空なら、根ノードを初期化する\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur.val === num) return;\n        pre = cur;\n        // 挿入位置は cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 挿入位置は cur の左部分木にある\n        else cur = cur.left;\n    }\n    // ノードを挿入\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを挿入 */\nvoid insert(int _num) {\n  // 木が空なら、根ノードを初期化する\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 重複ノードが見つかったら、直ちに返す\n    if (cur.val == _num) return;\n    pre = cur;\n    // 挿入位置は cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 挿入位置は cur の左部分木にある\n    else\n      cur = cur.left;\n  }\n  // ノードを挿入\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを挿入 */\npub fn insert(&amp;mut self, num: i32) {\n    // 木が空なら、根ノードを初期化する\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 重複ノードが見つかったら、直ちに返す\n            Ordering::Equal =&gt; return,\n            // 挿入位置は cur の右部分木にある\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 挿入位置は cur の左部分木にある\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // ノードを挿入\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを挿入 */\nvoid insert(BinarySearchTree *bst, int num) {\n    // 木が空なら、根ノードを初期化する\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 挿入位置は cur の右部分木にある\n            cur = cur-&gt;right;\n        } else {\n            // 挿入位置は cur の左部分木にある\n            cur = cur-&gt;left;\n        }\n    }\n    // ノードを挿入\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを挿入 */\nfun insert(num: Int) {\n    // 木が空なら、根ノードを初期化する\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 重複ノードが見つかったら、直ちに返す\n        if (cur._val == num)\n            return\n        pre = cur\n        // 挿入位置は cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 挿入位置は cur の左部分木にある\n        else\n            cur.left\n    }\n    // ノードを挿入\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを挿入 ###\ndef insert(num)\n  # 木が空なら、根ノードを初期化する\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 重複ノードが見つかったら、直ちに返す\n    return if cur.val == num\n\n    pre = cur\n    # 挿入位置は cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 挿入位置は cur の左部分木にある\n    else\n      cur = cur.left\n    end\n  end\n\n  # ノードを挿入\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>ノード探索と同様に、ノード挿入には \\(O(\\log n)\\) 時間を要します。</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   ノードの削除","text":"<p>まず二分木内で目標ノードを見つけ、その後で削除します。ノード挿入と同様に、削除操作の完了後も二分探索木の「左部分木 &lt; 根ノード &lt; 右部分木」という性質が保たれる必要があります。そのため、目標ノードの子ノード数に応じて、0、1、2 の 3 つのケースに分けて対応する削除操作を行います。</p> <p>以下の図に示すように、削除対象ノードの次数が \\(0\\) のとき、そのノードは葉ノードであり、直接削除できます。</p> <p></p> <p> 図 7-19   二分探索木でノードを削除する（次数 0 ） </p> <p>以下の図に示すように、削除対象ノードの次数が \\(1\\) のとき、削除対象ノードをその子ノードで置き換えれば十分です。</p> <p></p> <p> 図 7-20   二分探索木でノードを削除する（次数 1 ） </p> <p>削除対象ノードの次数が \\(2\\) のときは、直接削除できず、別のノードでそのノードを置き換える必要があります。二分探索木の「左部分木 \\(&lt;\\) 根ノード \\(&lt;\\) 右部分木」という性質を保つ必要があるため、このノードには右部分木の最小ノードまたは左部分木の最大ノードを使えます。</p> <p>右部分木の最小ノード（中順走査で次のノード）を選ぶと仮定すると、削除操作の流れは以下の図のようになります。</p> <ol> <li>削除対象ノードの「中順走査列」における次のノードを見つけ、<code>tmp</code> と記します。</li> <li><code>tmp</code> の値で削除対象ノードの値を上書きし、木の中でノード <code>tmp</code> を再帰的に削除します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 図 7-21   二分探索木でノードを削除する（次数 2 ） </p> <p>ノード削除操作も同様に \\(O(\\log n)\\) 時間を要します。削除対象ノードの探索に \\(O(\\log n)\\) 時間、中順走査の後続ノードの取得に \\(O(\\log n)\\) 時間が必要です。コード例は次のとおりです。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"ノードを削除\"\"\"\n    # 木が空なら、そのまま早期リターンする\n    if self._root is None:\n        return\n    # ループで探索し、葉ノードを越えたら抜ける\n    cur, pre = self._root, None\n    while cur is not None:\n        # 削除対象のノードが見つかったら、ループを抜ける\n        if cur.val == num:\n            break\n        pre = cur\n        # 削除対象ノードは cur の右部分木にある\n        if cur.val &lt; num:\n            cur = cur.right\n        # 削除対象ノードは cur の左部分木にある\n        else:\n            cur = cur.left\n    # 削除対象ノードがなければそのまま返す\n    if cur is None:\n        return\n\n    # 子ノード数 = 0 or 1\n    if cur.left is None or cur.right is None:\n        # 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        child = cur.left or cur.right\n        # ノード cur を削除する\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # 削除ノードが根ノードなら、根ノードを再設定\n            self._root = child\n    # 子ノード数 = 2\n    else:\n        # 中順走査における cur の次ノードを取得\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # ノード tmp を再帰的に削除\n        self.remove(tmp.val)\n        # tmp で cur を上書きする\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* ノードを削除 */\nvoid remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != nullptr) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur-&gt;left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == nullptr)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n        // メモリを解放する\n        delete cur;\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // ノード tmp を再帰的に削除\n        remove(tmp-&gt;val);\n        // tmp で cur を上書きする\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* ノードを削除 */\nvoid remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        remove(tmp.val);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* ノードを削除 */\nvoid Remove(int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return;\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        TreeNode? child = cur.left ?? cur.right;\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        Remove(tmp.val!.Value);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* ノードを削除 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // 木が空なら、そのまま早期リターンする\n    if cur == nil {\n        return\n    }\n    // 削除対象ノードの直前のノード位置\n    var pre *TreeNode = nil\n    // ループで探索し、葉ノードを越えたら抜ける\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // 削除対象ノードは右部分木にある\n            cur = cur.Right\n        } else {\n            // 削除対象ノードは左部分木にある\n            cur = cur.Left\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur == nil {\n        return\n    }\n    // 子ノード数は 0 または 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // 削除対象ノードの子ノードを取り出す\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // ノード cur を削除する\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            bst.root = child\n        }\n        // 子ノード数は 2\n    } else {\n        // 中順走査で削除対象ノード `cur` の次のノードを取得する\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // ノード tmp を再帰的に削除\n        bst.remove(tmp.Val.(int))\n        // tmp で cur を上書きする\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* ノードを削除 */\nfunc remove(num: Int) {\n    // 木が空なら、そのまま早期リターンする\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // ループで探索し、葉ノードを越えたら抜ける\n    while cur != nil {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // 削除対象ノードは cur の右部分木にある\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 削除対象ノードは cur の左部分木にある\n        else {\n            cur = cur?.left\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur == nil {\n        return\n    }\n    // 子ノード数 = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        let child = cur?.left ?? cur?.right\n        // ノード cur を削除する\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // ノード tmp を再帰的に削除\n        remove(num: tmp!.val)\n        // tmp で cur を上書きする\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* ノードを削除 */\nremove(num) {\n    // 木が空なら、そのまま早期リターンする\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val === num) break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur === null) return;\n    // 子ノード数 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        const child = cur.left !== null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            this.root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // ノード tmp を再帰的に削除\n        this.remove(tmp.val);\n        // tmp で cur を上書きする\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* ノードを削除 */\nremove(num: number): void {\n    // 木が空なら、そのまま早期リターンする\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur !== null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur.val === num) break;\n        pre = cur;\n        // 削除対象ノードは cur の右部分木にある\n        if (cur.val &lt; num) cur = cur.right;\n        // 削除対象ノードは cur の左部分木にある\n        else cur = cur.left;\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur === null) return;\n    // 子ノード数 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // ノード cur を削除する\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            this.root = child;\n        }\n    }\n    // 子ノード数 = 2\n    else {\n        // 中順走査における cur の次ノードを取得\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // ノード tmp を再帰的に削除\n        this.remove(tmp!.val);\n        // tmp で cur を上書きする\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* ノードを削除 */\nvoid remove(int _num) {\n  // 木が空なら、そのまま早期リターンする\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // ループで探索し、葉ノードを越えたら抜ける\n  while (cur != null) {\n    // 削除対象のノードが見つかったら、ループを抜ける\n    if (cur.val == _num) break;\n    pre = cur;\n    // 削除対象ノードは cur の右部分木にある\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 削除対象ノードは cur の左部分木にある\n    else\n      cur = cur.left;\n  }\n  // 削除対象ノードがない場合は、そのまま返す\n  if (cur == null) return;\n  // 子ノード数 = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n    TreeNode? child = cur.left ?? cur.right;\n    // ノード cur を削除する\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // 削除ノードが根ノードなら、根ノードを再設定\n      _root = child;\n    }\n  } else {\n    // 子ノード数 = 2\n    // 中順走査における cur の次のノードを取得\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // ノード tmp を再帰的に削除\n    remove(tmp.val);\n    // tmp で cur を上書きする\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* ノードを削除 */\npub fn remove(&amp;mut self, num: i32) {\n    // 木が空なら、そのまま早期リターンする\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 削除対象のノードが見つかったら、ループを抜ける\n            Ordering::Equal =&gt; break,\n            // 削除対象ノードは cur の右部分木にある\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 削除対象ノードは cur の左部分木にある\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // 子ノード数 = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // ノード cur を削除する\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // 削除ノードが根ノードなら、根ノードを再設定\n                self.root = child;\n            }\n        }\n        // 子ノード数 = 2\n        (Some(_), Some(_)) =&gt; {\n            // 中順走査における cur の次ノードを取得\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // ノード tmp を再帰的に削除\n            self.remove(tmp_val);\n            // tmp で cur を上書きする\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* ノードを削除 */\n// stdio.h を導入しているため、ここでは remove 識別子を使えない\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // 木が空なら、そのまま早期リターンする\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != NULL) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 削除対象ノードは root の右部分木にある\n            cur = cur-&gt;right;\n        } else {\n            // 削除対象ノードは root の左部分木にある\n            cur = cur-&gt;left;\n        }\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == NULL)\n        return;\n    // 削除対象ノードに子ノードがあるかを判定する\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* 子ノード数 = 0 or 1 */\n        // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // ノード cur を削除する\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // メモリを解放する\n        free(cur);\n    } else {\n        /* 子ノード数 = 2 */\n        // 中順走査における cur の次ノードを取得\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // ノード tmp を再帰的に削除\n        removeItem(bst, tmp-&gt;val);\n        // tmp で cur を上書きする\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* ノードを削除 */\nfun remove(num: Int) {\n    // 木が空なら、そのまま早期リターンする\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // ループで探索し、葉ノードを越えたら抜ける\n    while (cur != null) {\n        // 削除対象のノードが見つかったら、ループを抜ける\n        if (cur._val == num)\n            break\n        pre = cur\n        // 削除対象ノードは cur の右部分木にある\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 削除対象ノードは cur の左部分木にある\n        else\n            cur.left\n    }\n    // 削除対象ノードがなければそのまま返す\n    if (cur == null)\n        return\n    // 子ノード数 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 子ノード数が 0 / 1 のとき、child = null / その子ノード\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // ノード cur を削除する\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // 削除ノードが根ノードなら、根ノードを再設定\n            root = child\n        }\n        // 子ノード数 = 2\n    } else {\n        // 中順走査における cur の次ノードを取得\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // ノード tmp を再帰的に削除\n        remove(tmp._val)\n        // tmp で cur を上書きする\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### ノードを削除 ###\ndef remove(num)\n  # 木が空なら、そのまま早期リターンする\n  return if @root.nil?\n\n  # ループで探索し、葉ノードを越えたら抜ける\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 削除対象のノードが見つかったら、ループを抜ける\n    break if cur.val == num\n\n    pre = cur\n    # 削除対象ノードは cur の右部分木にある\n    if cur.val &lt; num\n      cur = cur.right\n    # 削除対象ノードは cur の左部分木にある\n    else\n      cur = cur.left\n    end\n  end\n  # 削除対象ノードがなければそのまま返す\n  return if cur.nil?\n\n  # 子ノード数 = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # 子ノード数が 0 / 1 のとき、child = null / その子ノード\n    child = cur.left || cur.right\n    # ノード cur を削除する\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # 削除ノードが根ノードなら、根ノードを再設定\n      @root = child\n    end\n  # 子ノード数 = 2\n  else\n    # 中順走査における cur の次ノードを取得\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # ノード tmp を再帰的に削除\n    remove(tmp.val)\n    # tmp で cur を上書きする\n    cur.val = tmp.val\n  end\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   中順走査は昇順","text":"<p>以下の図に示すように、二分木の中順走査は「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」という順序に従い、二分探索木は「左子ノード \\(&lt;\\) 根ノード \\(&lt;\\) 右子ノード」という大小関係を満たします。</p> <p>これは、二分探索木で中順走査を行うと常に次の最小ノードが優先して走査されることを意味し、そこから重要な性質が導かれます。二分探索木の中順走査列は昇順です。</p> <p>中順走査が昇順になる性質を利用すれば、二分探索木から整列済みデータを取得するのに必要な時間は \\(O(n)\\) のみで、追加のソート操作は不要です。非常に効率的です。</p> <p></p> <p> 図 7-22   二分探索木の中順走査列 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   二分探索木の効率","text":"<p>あるデータ集合が与えられたとき、配列または二分探索木で格納する場合を考えます。次の表を見ると、二分探索木の各操作の時間計算量はいずれも対数オーダーであり、安定して高効率です。高頻度の追加と低頻度の探索・削除という場面でのみ、配列のほうが二分探索木より効率的です。</p> <p> 表 7-2   配列と探索木の効率比較 </p> 無秩序配列 二分探索木 要素の探索 \\(O(n)\\) \\(O(\\log n)\\) 要素の挿入 \\(O(1)\\) \\(O(\\log n)\\) 要素の削除 \\(O(n)\\) \\(O(\\log n)\\) <p>理想的な状況では、二分探索木は「平衡」しており、その場合は \\(\\log n\\) 回のループ内で任意のノードを探索できます。</p> <p>しかし、二分探索木でノードの挿入と削除を繰り返すと、二分木が以下の図のような連結リストへ退化する可能性があり、このとき各操作の時間計算量も \\(O(n)\\) に退化します。</p> <p></p> <p> 図 7-23   二分探索木の退化 </p>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   二分探索木の代表的な応用","text":"<ul> <li>システム内の多段インデックスとして用いられ、効率的な探索、挿入、削除操作を実現します。</li> <li>一部の探索アルゴリズムの基盤データ構造として使われます。</li> <li>データストリームを格納し、その順序状態を保つために使われます。</li> </ul>","path":["第 7 章 &nbsp; 木","7.4 &nbsp; 二分探索木"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   二分木","text":"<p>二分木（binary tree）は非線形データ構造の一種であり、「祖先」と「子孫」の派生関係を表し、「一つを二つに分ける」分割統治の考え方を体現しています。連結リストと同様に、二分木の基本単位はノードであり、各ノードは値、左子ノードへの参照、右子ノードへの参照を含みます。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"二分木ノードクラス\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # ノード値\n        self.left: TreeNode | None = None  # 左子ノード参照\n        self.right: TreeNode | None = None # 右子ノード参照\n</code></pre> <pre><code>/* 二分木ノード構造体 */\nstruct TreeNode {\n    int val;          // ノード値\n    TreeNode *left;   // 左子ノードポインタ\n    TreeNode *right;  // 右子ノードポインタ\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    int val;         // ノード値\n    TreeNode left;   // 左子ノード参照\n    TreeNode right;  // 右子ノード参照\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode(int? x) {\n    public int? val = x;    // ノード値\n    public TreeNode? left;  // 左子ノード参照\n    public TreeNode? right; // 右子ノード参照\n}\n</code></pre> <pre><code>/* 二分木ノード構造体 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* コンストラクタ */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // 左子ノードポインタ\n        Right: nil, // 右子ノードポインタ\n        Val:   v,   // ノード値\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    var val: Int // ノード値\n    var left: TreeNode? // 左子ノード参照\n    var right: TreeNode? // 右子ノード参照\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    val; // ノード値\n    left; // 左子ノードポインタ\n    right; // 右子ノードポインタ\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // ノード値\n        this.left = left === undefined ? null : left; // 左子ノード参照\n        this.right = right === undefined ? null : right; // 右子ノード参照\n    }\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode {\n  int val;         // ノード値\n  TreeNode? left;  // 左子ノード参照\n  TreeNode? right; // 右子ノード参照\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 二分木ノード構造体 */\nstruct TreeNode {\n    val: i32,                               // ノード値\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子ノード参照\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子ノード参照\n}\n\nimpl TreeNode {\n    /* コンストラクタ */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* 二分木ノード構造体 */\ntypedef struct TreeNode {\n    int val;                // ノード値\n    int height;             // ノードの高さ\n    struct TreeNode *left;  // 左子ノードポインタ\n    struct TreeNode *right; // 右子ノードポインタ\n} TreeNode;\n\n/* コンストラクタ */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 二分木ノードクラス */\nclass TreeNode(val _val: Int) {  // ノード値\n    val left: TreeNode? = null   // 左子ノード参照\n    val right: TreeNode? = null  // 右子ノード参照\n}\n</code></pre> <pre><code>### 二分木ノードクラス ###\nclass TreeNode\n  attr_accessor :val    # ノード値\n  attr_accessor :left   # 左子ノード参照\n  attr_accessor :right  # 右子ノード参照\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>各ノードは 2 つの参照（ポインタ）を持ち、それぞれ左子ノード（left-child node）と右子ノード（right-child node）を指します。このノードはこれら 2 つの子ノードの親ノード（parent node）と呼ばれます。二分木のあるノードが与えられたとき、そのノードの左子ノードとその配下のノードからなる木をそのノードの左部分木（left subtree）と呼び、同様に右部分木（right subtree）が定義されます。</p> <p>二分木では、葉ノードを除くすべてのノードが子ノードと空でない部分木を持ちます。以下の図に示すように、「ノード 2」を親ノードとみなすと、その左子ノードと右子ノードはそれぞれ「ノード 4」と「ノード 5」であり、左部分木は「ノード 4 とその配下のノードからなる木」、右部分木は「ノード 5 とその配下のノードからなる木」です。</p> <p></p> <p> 図 7-1   親ノード、子ノード、部分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   二分木のよく使われる用語","text":"<p>二分木でよく使われる用語を以下の図に示します。</p> <ul> <li>根ノード（root node）：二分木の最上位にあるノードで、親ノードを持ちません。</li> <li>葉ノード（leaf node）：子ノードを持たないノードで、2 本のポインタはいずれも <code>None</code> を指します。</li> <li>辺（edge）：2 つのノードを結ぶ線分、すなわちノード参照（ポインタ）です。</li> <li>ノードが属するレベル（level）：上から下へ向かって増加し、根ノードのレベルは 1 です。</li> <li>ノードの次数（degree）：ノードの子ノードの数。二分木では次数の取り得る値は 0、1、2 です。</li> <li>二分木の高さ（height）：根ノードから最も遠い葉ノードまでに通る辺の数。</li> <li>ノードの深さ（depth）：根ノードからそのノードまでに通る辺の数。</li> <li>ノードの高さ（height）：そのノードから最も遠い葉ノードまでに通る辺の数。</li> </ul> <p></p> <p> 図 7-2   二分木のよく使われる用語 </p> <p>Tip</p> <p>なお、通常「高さ」と「深さ」は「通過した辺の数」と定義しますが、問題や教材によっては「通過したノードの数」と定義する場合もあります。その場合、高さと深さはいずれも 1 を加える必要があります。</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   二分木の基本操作","text":"","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   二分木を初期化する","text":"<p>連結リストと同様に、まずノードを初期化し、その後で参照（ポインタ）を構築します。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 二分木を初期化する\n# ノードを初期化する\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// ノードを初期化する\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// ノード間の参照（ポインタ）を構築する\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// ノードを初期化する\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// ノードを初期化する\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// ノード間の参照（ポインタ）を構築する\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* 二分木を初期化する */\n// ノードを初期化する\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// ノード間の参照（ポインタ）を構築する\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// ノードを初期化する\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># 二分木を初期化する\n# ノードを初期化する\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# ノード間の参照（ポインタ）を構築する\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   ノードの挿入と削除","text":"<p>連結リストと同様に、二分木でのノードの挿入と削除はポインタを変更することで実現できます。以下の図に 1 つの例を示します。</p> <p></p> <p> 図 7-3   二分木でノードを挿入・削除する </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># ノードの挿入と削除\np = TreeNode(0)\n# n1 -&gt; n2 の間にノード P を挿入する\nn1.left = p\np.left = n2\n# ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* ノードの挿入と削除 */\nTreeNode* P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1-&gt;left = P;\nP-&gt;left = n2;\n// ノード P を削除する\nn1-&gt;left = n2;\n// メモリを解放する\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* ノードの挿入と削除 */\nTreeNode P = new(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* ノードの挿入と削除 */\n// n1 -&gt; n2 の間にノード P を挿入する\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// ノード P を削除する\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P\nP.left = n2\n// ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* ノードの挿入と削除 */\nlet P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* ノードの挿入と削除 */\nconst P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* ノードの挿入と削除 */\nTreeNode P = new TreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P;\nP.left = n2;\n// ノード P を削除する\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// ノード p を削除する\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* ノードの挿入と削除 */\nTreeNode *P = newTreeNode(0);\n// n1 -&gt; n2 の間にノード P を挿入する\nn1-&gt;left = P;\nP-&gt;left = n2;\n// ノード P を削除する\nn1-&gt;left = n2;\n// メモリを解放する\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// n1 -&gt; n2 の間にノード P を挿入する\nn1.left = P\nP.left = n2\n// ノード P を削除する\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># ノードの挿入と削除\n_p = TreeNode.new(0)\n# n1 -&gt; n2 の間にノード _p を挿入する\nn1.left = _p\n_p.left = n2\n# ノードを削除する\nn1.left = n2\n</code></pre> 実行の可視化 <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%E6%8F%92%E5%85%A5%E4%B8%8E%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%E5%9C%A8%20n1%20-%3E%20n2%20%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20n2&amp;cumulative=false&amp;curInstr=37&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Tip</p> <p>注意すべき点として、ノードの挿入は二分木の元の論理構造を変える可能性があり、ノードの削除は通常、そのノードと配下のすべての部分木の削除を意味します。そのため、二分木における挿入と削除は、実際に意味のある操作を実現するために、通常は一連の操作を組み合わせて行います。</p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   一般的な二分木の種類","text":"","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   充足二分木","text":"<p>以下の図に示すように、充足二分木（perfect binary tree）ではすべてのレベルのノードが完全に埋まっています。充足二分木では、葉ノードの次数は \\(0\\) で、それ以外のすべてのノードの次数は \\(2\\) です。木の高さを \\(h\\) とすると、ノード総数は \\(2^{h+1} - 1\\) となり、標準的な指数関係を示して、自然界でよく見られる細胞分裂の現象を反映しています。</p> <p>Tip</p> <p>なお、中国語圏では充足二分木は満二分木と呼ばれることもあります。</p> <p></p> <p> 図 7-4   充足二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   完全二分木","text":"<p>以下の図に示すように、完全二分木（complete binary tree）では最下層のノードだけが完全に埋まっていなくてもよく、しかも最下層のノードは左から右へ連続して詰められていなければなりません。なお、充足二分木も完全二分木の一種です。</p> <p></p> <p> 図 7-5   完全二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   充満二分木","text":"<p>以下の図に示すように、充満二分木（full binary tree）では、葉ノードを除くすべてのノードが 2 つの子ノードを持ちます。</p> <p></p> <p> 図 7-6   充満二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   平衡二分木","text":"<p>以下の図に示すように、平衡二分木（balanced binary tree）では、任意のノードについて左部分木と右部分木の高さの差の絶対値が 1 を超えません。</p> <p></p> <p> 図 7-7   平衡二分木 </p>","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   二分木の退化","text":"<p>以下の図は、二分木の理想的な構造と退化した構造を示しています。二分木の各レベルのノードがすべて埋まっていると「充足二分木」となり、すべてのノードが片側に偏ると二分木は「連結リスト」へ退化します。</p> <ul> <li>充足二分木は理想的なケースであり、二分木の「分割統治」の利点を十分に発揮できます。</li> <li>連結リストはその対極にあり、各種操作はすべて線形操作となり、時間計算量は \\(O(n)\\) まで退化します。</li> </ul> <p></p> <p> 図 7-8   二分木の最良構造と最悪構造 </p> <p>以下の表に示すように、最良構造と最悪構造では、二分木の葉ノード数、ノード総数、高さなどが極大または極小になります。</p> <p> 表 7-1   二分木の最良構造と最悪構造 </p> 充足二分木 連結リスト 第 \\(i\\) レベルのノード数 \\(2^{i-1}\\) \\(1\\) 高さ \\(h\\) の木の葉ノード数 \\(2^h\\) \\(1\\) 高さ \\(h\\) の木のノード総数 \\(2^{h+1} - 1\\) \\(h + 1\\) ノード総数 \\(n\\) の木の高さ \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["第 7 章 &nbsp; 木","7.1 &nbsp; 二分木"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   二分木の走査","text":"<p>物理構造の観点から見ると、木は連結リストを基盤としたデータ構造であり、その走査はポインタを通じてノードへ順にアクセスすることで行われます。しかし、木は非線形データ構造であるため、木の走査は連結リストの走査よりも複雑であり、検索アルゴリズムを用いて実現する必要があります。</p> <p>二分木の一般的な走査方法には、レベル順走査、先行順走査、中間順走査、後行順走査などがあります。</p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   レベル順走査","text":"<p>次の図に示すように、レベル順走査（level-order traversal）では、二分木を上から下へ層ごとに走査し、各層では左から右の順にノードへアクセスします。</p> <p>レベル順走査は本質的に幅優先走査（breadth-first traversal）に属し、幅優先探索（breadth-first search, BFS）とも呼ばれます。これは「同心円状に外側へ広がる」ような、層ごとの走査方法を表しています。</p> <p></p> <p> 図 7-9   二分木のレベル順走査 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   コードの実装","text":"<p>幅優先走査は通常「キュー」を用いて実装します。キューは「先入れ先出し」の規則に従い、幅優先走査は「層ごとに進む」という規則に従います。両者の背後にある考え方は一致しています。実装コードは次のとおりです：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"レベル順走査\"\"\"\n    # キューを初期化し、ルートノードを追加する\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # 走査順序を保存するためのリストを初期化する\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # デキュー\n        res.append(node.val)  # ノードの値を保存する\n        if node.left is not None:\n            queue.append(node.left)  # 左子ノードをキューに追加\n        if node.right is not None:\n            queue.append(node.right)  # 右子ノードをキューに追加\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* レベル順走査 */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // キューを初期化し、ルートノードを追加する\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // 走査順序を保存するためのリストを初期化する\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // デキュー\n        vec.push_back(node-&gt;val); // ノードの値を保存する\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // 左子ノードをキューに追加\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // 右子ノードをキューに追加\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* レベル順走査 */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // キューを初期化し、ルートノードを追加する\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // 走査順序を保存するためのリストを初期化する\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // デキュー\n        list.add(node.val);           // ノードの値を保存する\n        if (node.left != null)\n            queue.offer(node.left);   // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.offer(node.right);  // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* レベル順走査 */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // キューを初期化し、ルートノードを追加する\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // 走査順序を保存するためのリストを初期化する\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // デキュー\n        list.Add(node.val!.Value);       // ノードの値を保存する\n        if (node.left != null)\n            queue.Enqueue(node.left);    // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.Enqueue(node.right);   // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* レベル順走査 */\nfunc levelOrder(root *TreeNode) []any {\n    // キューを初期化し、ルートノードを追加する\n    queue := list.New()\n    queue.PushBack(root)\n    // 走査順を保存するためのスライスを初期化する\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // デキュー\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // ノードの値を保存する\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // 左子ノードをキューに追加\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // 右子ノードをキューに追加\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* レベル順走査 */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // キューを初期化し、ルートノードを追加する\n    var queue: [TreeNode] = [root]\n    // 走査順序を保存するためのリストを初期化する\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // デキュー\n        list.append(node.val) // ノードの値を保存する\n        if let left = node.left {\n            queue.append(left) // 左子ノードをキューに追加\n        }\n        if let right = node.right {\n            queue.append(right) // 右子ノードをキューに追加\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* レベル順走査 */\nfunction levelOrder(root) {\n    // キューを初期化し、ルートノードを追加する\n    const queue = [root];\n    // 走査順序を保存するためのリストを初期化する\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // デキュー\n        list.push(node.val); // ノードの値を保存する\n        if (node.left) queue.push(node.left); // 左子ノードをキューに追加\n        if (node.right) queue.push(node.right); // 右子ノードをキューに追加\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* レベル順走査 */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // キューを初期化し、ルートノードを追加する\n    const queue = [root];\n    // 走査順序を保存するためのリストを初期化する\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // デキュー\n        list.push(node.val); // ノードの値を保存する\n        if (node.left) {\n            queue.push(node.left); // 左子ノードをキューに追加\n        }\n        if (node.right) {\n            queue.push(node.right); // 右子ノードをキューに追加\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* レベル順走査 */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // キューを初期化し、ルートノードを追加する\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // 走査順序を保存するためのリストを初期化する\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // デキュー\n    res.add(node!.val); // ノードの値を保存する\n    if (node.left != null) queue.add(node.left); // 左子ノードをキューに追加\n    if (node.right != null) queue.add(node.right); // 右子ノードをキューに追加\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* レベル順走査 */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // キューを初期化し、ルートノードを追加する\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // 走査順序を保存するためのリストを初期化する\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // デキュー\n        vec.push(node.borrow().val); // ノードの値を保存する\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // 左子ノードをキューに追加\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // 右子ノードをキューに追加\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* レベル順走査 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* 補助キュー */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* 補助キュー */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // キューへのポインタ\n    front = 0, rear = 0;\n    // 根ノードを追加する\n    queue[rear++] = root;\n    // 走査順序を保存するためのリストを初期化する\n    /* 補助配列 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // 配列ポインタ\n    index = 0;\n    while (front &lt; rear) {\n        // デキュー\n        node = queue[front++];\n        // ノードの値を保存する\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // 左子ノードをキューに追加\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // 右子ノードをキューに追加\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // 配列長の値を更新\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // 補助配列の領域を解放する\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* レベル順走査 */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // キューを初期化し、ルートノードを追加する\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // 走査順序を保存するためのリストを初期化する\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // デキュー\n        list.add(node?._val!!)       // ノードの値を保存する\n        if (node.left != null)\n            queue.offer(node.left)   // 左子ノードをキューに追加\n        if (node.right != null)\n            queue.offer(node.right)  // 右子ノードをキューに追加\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### レベル順走査 ###\ndef level_order(root)\n  # キューを初期化し、ルートノードを追加する\n  queue = [root]\n  # 走査順序を保存するためのリストを初期化する\n  res = []\n  while !queue.empty?\n    node = queue.shift # デキュー\n    res &lt;&lt; node.val # ノードの値を保存する\n    queue &lt;&lt; node.left unless node.left.nil? # 左子ノードをキューに追加\n    queue &lt;&lt; node.right unless node.right.nil? # 右子ノードをキューに追加\n  end\n  res\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   計算量","text":"<ul> <li>時間計算量は \\(O(n)\\) ：すべてのノードを1回ずつ訪問するため、計算量は \\(O(n)\\) です。ここで、\\(n\\) はノード数です。</li> <li>空間計算量は \\(O(n)\\) ：最悪の場合、すなわち完全二分木では、最下層に到達する前に、キュー内には最大で同時に \\((n + 1) / 2\\) 個のノードが存在し、\\(O(n)\\) の空間を使用します。</li> </ul>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   先行順・中間順・後行順走査","text":"<p>同様に、先行順・中間順・後行順走査はいずれも深度優先走査（depth-first traversal）に属し、深度優先探索（depth-first search, DFS）とも呼ばれます。これは「まず行き止まりまで進み、その後で戻って続ける」という走査方法を表しています。</p> <p>次の図は、二分木に対して深度優先走査を行う仕組みを示しています。深度優先走査は、二分木全体の外周をぐるりと「一周する」ようなものです。各ノードでは3つの位置に出会い、それぞれが先行順走査・中間順走査・後行順走査に対応します。</p> <p></p> <p> 図 7-10   二分探索木の先行順・中間順・後行順走査 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   コードの実装","text":"<p>深度優先探索は通常、再帰に基づいて実装されます：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"先行順走査\"\"\"\n    if root is None:\n        return\n    # 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"中順走査\"\"\"\n    if root is None:\n        return\n    # 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"後順走査\"\"\"\n    if root is None:\n        return\n    # 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* 先行順走査 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* 中順走査 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* 後順走査 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* 先行順走査 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* 中順走査 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* 後順走査 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* 先行順走査 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* 中順走査 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* 後順走査 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* 先行順走査 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* 先行順走査 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中順走査 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後順走査 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* 先行順走査 */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 中順走査 */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 後順走査 */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* 先行順走査 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* 中順走査 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* 後順走査 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* 先行順走査 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* 中順走査 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* 後順走査 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### 前順走査 ###\ndef pre_order(root)\n  return if root.nil?\n\n  # 訪問順序：根ノード -&gt; 左部分木 -&gt; 右部分木\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### 中順走査 ###\ndef in_order(root)\n  return if root.nil?\n\n  # 訪問優先順: 左部分木 -&gt; 根ノード -&gt; 右部分木\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### 後順走査 ###\ndef post_order(root)\n  return if root.nil?\n\n  # 訪問優先順: 左部分木 -&gt; 右部分木 -&gt; 根ノード\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> コードの可視化 <p> 全画面で見る &gt;</p> <p>Tip</p> <p>深度優先探索は反復によって実装することもできます。興味のある読者は自身で調べてみてください。</p> <p>次の図は、二分木の先行順走査における再帰の過程を示しており、「行き」と「帰り」という2つの逆向きの部分に分けられます。</p> <ol> <li>「行き」は新しいメソッドの開始を表し、この過程でプログラムは次のノードにアクセスします。</li> <li>「帰り」は関数の復帰を表し、現在のノードへのアクセスが完了したことを意味します。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 図 7-11   先行順走査の再帰過程 </p>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   計算量","text":"<ul> <li>時間計算量は \\(O(n)\\) ：すべてのノードを1回ずつ訪問するため、計算量は \\(O(n)\\) です。</li> <li>空間計算量は \\(O(n)\\) ：最悪の場合、すなわち木が連結リストに退化したとき、再帰の深さは \\(n\\) に達し、システムは \\(O(n)\\) のスタックフレーム空間を使用します。</li> </ul>","path":["第 7 章 &nbsp; 木","7.2 &nbsp; 二分木の走査"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   まとめ","text":"","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   要点の振り返り","text":"<ul> <li>二分木は非線形データ構造の一種であり、「二分する」分割統治の考え方を体現している。各二分木ノードは 1 つの値と 2 本のポインタを持ち、それぞれ左子ノードと右子ノードを指す。</li> <li>二分木のあるノードについて、その左（右）子ノードおよびその配下から構成される木を、そのノードの左（右）部分木と呼ぶ。</li> <li>二分木に関する用語には、根ノード、葉ノード、レベル、次数、辺、高さ、深さなどがある。</li> <li>二分木の初期化、ノードの挿入、ノードの削除は、連結リストの操作方法と似ている。</li> <li>一般的な二分木の種類には、perfect 二分木、complete 二分木、full 二分木、平衡二分木がある。perfect 二分木が最も理想的な状態であり、連結リストは退化後の最悪の状態である。</li> <li>二分木は配列で表現できる。方法としては、ノード値と空き位置をレベル順走査の順に並べ、親ノードと子ノードのインデックス対応関係に基づいてポインタを実現する。</li> <li>二分木のレベル順走査は幅優先探索の一種であり、「同心円状に外へ広がる」ような逐次的な走査方式を表しており、通常はキューによって実装される。</li> <li>前順、中順、後順走査はいずれも深さ優先探索に属し、「まず末端まで進み、その後バックトラックして続ける」という走査方式を体現しており、通常は再帰で実装される。</li> <li>二分探索木は効率的な要素探索データ構造であり、探索、挿入、削除の時間計算量はいずれも \\(O(\\log n)\\) である。二分探索木が連結リストへ退化すると、各操作の時間計算量は \\(O(n)\\) まで悪化する。</li> <li>AVL 木は平衡二分探索木とも呼ばれ、回転操作によって、ノードの挿入と削除を繰り返した後も木が平衡を保つようにしている。</li> <li>AVL 木の回転操作には、右回転、左回転、右回転してから左回転、左回転してから右回転がある。ノードの挿入または削除の後、AVL 木は下から上へ回転操作を行い、木を再び平衡状態に戻す。</li> </ul>","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：ノードが 1 つしかない二分木では、木の高さと根ノードの深さはどちらも \\(0\\) ですか？</p> <p>はい。高さと深さは通常「通過した辺の本数」として定義されるからです。</p> <p>Q：二分木における挿入と削除は通常一連の操作を組み合わせて完了しますが、ここでいう「一連の操作」とは何を指すのでしょうか？リソースの子ノードに対するリソース解放と理解できますか？</p> <p>二分探索木を例にすると、ノード削除は 3 つのケースに分けて処理する必要があり、各ケースで複数段階のノード操作が必要になります。</p> <p>Q：なぜ DFS による二分木走査には前順・中順・後順の 3 種類があり、それぞれどのような用途があるのですか？</p> <p>配列の順方向走査と逆方向走査に似て、前順・中順・後順走査は二分木の 3 つの走査方法であり、特定の順序で走査結果を得るために使えます。たとえば二分探索木では、ノードの大小関係が <code>左子ノードの値 &lt; 根ノードの値 &lt; 右子ノードの値</code> を満たすため、「左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右」の優先順で木を走査すれば、整列済みのノード列を得られます。</p> <p>Q：右回転操作は不平衡ノード <code>node</code>、<code>child</code>、<code>grand_child</code> の関係を処理するものですが、<code>node</code> の親ノードと <code>node</code> の元の接続は維持しなくてよいのですか？右回転後に切れてしまいませんか？</p> <p>この問題は再帰の視点から考える必要があります。右回転操作 <code>right_rotate(root)</code> に渡されるのは部分木の根ノードであり、最終的に <code>return child</code> によって回転後の部分木の根ノードを返します。部分木の根ノードとその親ノードの接続は、この関数の返却後に行われるため、右回転操作自身が管理する範囲には含まれません。</p> <p>Q：C++ では関数を <code>private</code> と <code>public</code> に分けますが、この設計にはどのような考えがありますか？なぜ <code>height()</code> 関数と <code>updateHeight()</code> 関数をそれぞれ <code>public</code> と <code>private</code> に置くのですか？</p> <p>主に、そのメソッドの利用範囲を見て決めます。メソッドがクラス内部でしか使われないなら、<code>private</code> に設計します。たとえば、利用者が <code>updateHeight()</code> を単独で呼び出しても意味はなく、これは挿入や削除の途中の 1 ステップにすぎません。一方で <code>height()</code> はノードの高さにアクセスするためのもので、<code>vector.size()</code> に似た役割を持つため、使いやすいように <code>public</code> に設定します。</p> <p>Q：入力データの集合から二分探索木をどのように構築しますか？根ノードの選び方は重要ですか？</p> <p>はい。木の構築方法は、二分探索木のコード中の <code>build_tree()</code> メソッドですでに示されています。根ノードの選択については、通常は入力データをソートし、その中央の要素を根ノードにしてから、左右の部分木を再帰的に構築します。こうすることで、木の平衡性を最大限に保てます。</p> <p>Q：Java では、文字列比較には必ず <code>equals()</code> メソッドを使うべきですか？</p> <p>Java では、基本データ型については <code>==</code> を使って 2 つの変数の値が等しいかどうかを比較します。参照型については、この 2 つの記法の働き方は異なります。</p> <ul> <li><code>==</code> ：2 つの変数が同じオブジェクトを指しているか、つまりメモリ上の位置が同じかどうかを比較するために使います。</li> <li><code>equals()</code>：2 つのオブジェクトの値が等しいかどうかを比較するために使います。</li> </ul> <p>したがって、値を比較したい場合は <code>equals()</code> を使うべきです。ただし、<code>String a = \"hi\"; String b = \"hi\";</code> によって初期化された文字列は文字列定数プールに格納され、同じオブジェクトを指すため、<code>a == b</code> でも 2 つの文字列の内容を比較できます。</p> <p>Q：幅優先走査で最下層に到達する前、キュー内のノード数は \\(2^h\\) ですか？</p> <p>はい。たとえば高さ \\(h = 2\\) の充足二分木では、ノード総数は \\(n = 7\\) であり、最下層のノード数は \\(4 = 2^h = (n + 1) / 2\\) です。</p>","path":["第 7 章 &nbsp; 木","7.6 &nbsp; まとめ"],"tags":[]}]}
\ No newline at end of file
diff --git a/ja/stylesheets/extra.css b/ja/stylesheets/extra.css
index ad77de182..68bd0fb96 100644
--- a/ja/stylesheets/extra.css
+++ b/ja/stylesheets/extra.css
@@ -1,4 +1,4 @@
-/* Color Settings */
+/* Theme tokens */
 /* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
 /* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
 :root>* {
@@ -14,21 +14,23 @@
   --md-code-fg-color: #1d1d20;
   --md-code-bg-color: #f5f5f5;
 
-  --md-accent-fg-color: #999;
-
   --md-typeset-color: #1d1d20;
   --md-typeset-a-color: #349890;
 
+  --md-accent-fg-color: var(--md-typeset-a-color);
+
   --md-typeset-btn-color: #55aea6;
   --md-typeset-btn-hover-color: #52bbb1;
 
   --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
-  --md-admonition-pythontutor-color: #eee;
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+
+  --hello-algo-sidebar-width: 13rem;
 }
 
 [data-md-color-scheme="slate"] {
-  --theme-dark-base: #1E1E1E;
-  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-base: #1e1e1e;
+  --theme-dark-mantle: #1a1a1a;
   --theme-dark-crust: #171717;
   --hero-starfield-bg-color: var(--theme-dark-base);
 
@@ -37,25 +39,25 @@
 
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: var(--theme-dark-base);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
 
-  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-body-bg-color: var(--md-default-bg-color);
   --md-header-bg-color: rgba(26, 26, 26, 0.8);
 
   --md-code-fg-color: #adbac7;
   --md-code-bg-color: var(--theme-dark-crust);
 
-  --md-accent-fg-color: #aaa;
-
-  --md-footer-fg-color: #adbac7;
-  --md-footer-bg-color: var(--theme-dark-mantle);
-
   --md-typeset-color: #adbac7;
   --md-typeset-a-color: #52bbb1;
+  --md-accent-fg-color: var(--md-typeset-a-color);
 
   --md-typeset-btn-color: #52bbb1;
   --md-typeset-btn-hover-color: #55aea6;
 
-  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
 }
 
 [data-md-color-scheme="slate"][data-md-color-primary="black"],
@@ -63,24 +65,82 @@
   --md-typeset-a-color: #52bbb1;
 }
 
+/* Base layout */
+body {
+  background-color: var(--md-default-bg-color);
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Banner and footer */
+.md-banner {
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
 [data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner {
-  background-color: var(--theme-dark-mantle);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer-meta {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer__link {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
 [data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--theme-dark-base);
+  color: var(--md-footer-fg-color);
 }
 
 [data-md-color-scheme="slate"] .md-footer__title,
@@ -93,40 +153,31 @@
   color: var(--md-footer-fg-color);
 }
 
-/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
-.md-nav__link[for] {
-  color: var(--md-default-fg-color) !important;
-}
-
-/* Figure class */
+/* Shared content elements */
 .animation-figure {
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Cover image class */
 .cover-image {
   width: 28rem;
   height: auto;
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Center Markdown Tables (requires md_in_html extension) */
 .center-table {
   text-align: center;
 }
 
-/* Reset alignment for table cells */
 .md-typeset .center-table :is(td, th):not([align]) {
   text-align: initial;
 }
 
-/* Font size */
 .md-typeset {
   font-size: 0.75rem;
   line-height: 1.5;
@@ -136,7 +187,6 @@
   font-size: 0.95em;
 }
 
-/* Markdown Header */
 /* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
 .md-typeset h1 {
   font-weight: 400;
@@ -155,11 +205,6 @@
   text-transform: none;
 }
 
-.md-typeset a:hover {
-  color: var(--md-typeset-a-color);
-  text-decoration: underline;
-}
-
 .md-typeset code {
   border-radius: 0.2rem;
 }
@@ -168,21 +213,11 @@
   font-weight: normal;
 }
 
-/* font-family setting for Win10 */
-body {
-  --md-text-font-family: -apple-system, BlinkMacSystemFont,
-    var(--md-text-font, _), Helvetica, Arial, sans-serif;
-  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
-    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
-}
-
-/* max height of code block */
 /* https://github.com/squidfunk/mkdocs-material/issues/3444 */
 .md-typeset pre>code {
   max-height: 25rem;
 }
 
-/* Keep code block scrollbar hover neutral instead of accent-colored */
 .md-typeset pre>code:hover {
   scrollbar-color: var(--md-default-fg-color--lighter) transparent;
 }
@@ -191,29 +226,48 @@ body {
   background-color: var(--md-default-fg-color--lighter);
 }
 
-/* Make the picture not glare in dark theme */
 [data-md-color-scheme="slate"] .md-typeset img,
 [data-md-color-scheme="slate"] .md-typeset svg,
 [data-md-color-scheme="slate"] .md-typeset video {
   filter: brightness(0.85) invert(0.05);
 }
 
-/* landing page */
-.header-img-div {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0 auto;
-  width: 100%;
-  /* Default to full width */
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+/* Admonitions and tabs */
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
 }
 
-/* Admonition for python tutor */
 .md-typeset .admonition.pythontutor,
 .md-typeset details.pythontutor {
   border-color: var(--md-default-fg-color--lightest);
   margin-top: 0;
   margin-bottom: 1.5625em;
+  background-color: var(--md-code-bg-color);
 }
 
 .md-typeset .pythontutor>.admonition-title,
@@ -228,26 +282,18 @@ body {
   mask-image: var(--md-admonition-icon--pythontutor);
 }
 
-/* code block tabs */
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
 .md-typeset .tabbed-labels>label {
   font-size: 0.61rem;
 }
 
 .md-typeset .tabbed-labels--linked>label>a {
-  padding: .78125em 1.0em .625em;
-}
-
-/* header banner */
-.md-banner {
-  background-color: var(--md-code-bg-color);
-  color: var(--md-default-fg-color);
-  font-size: 0.75rem;
-}
-
-.md-banner .banner-svg svg {
-  margin-right: 0.3rem;
-  height: 0.63rem;
-  fill: var(--md-default-fg-color);
+  padding: 0.78125em 1em 0.625em;
 }
 
 .pythontutor-iframe {
@@ -260,115 +306,55 @@ body {
   border: none;
 }
 
-/* landing page container */
+/* Landing page layout */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+}
+
 .home-div {
   width: 100%;
   height: auto;
   display: flex;
   justify-content: center;
   align-items: center;
+  padding: 3em 2em;
   background-color: var(--md-default-bg-color);
   color: var(--md-default-fg-color);
   font-size: 0.9rem;
-  padding: 3em 2em;
   text-align: center;
 }
 
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6,
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
 .section-content {
   width: 100%;
   height: auto;
   max-width: 70vw;
 }
 
-/* rounded button */
-.rounded-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 10em;
-  margin: 0 0.1em;
-  padding: 0.6em 1.3em;
-  border: none;
-  background-color: var(--md-typeset-btn-color);
-  color: var(--md-primary-fg-color) !important;
-  text-align: center;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.rounded-button:hover {
-  background-color: var(--md-typeset-btn-hover-color);
-}
-
-.rounded-button span {
-  margin: 0;
-  margin-bottom: 0.07em;
-  white-space: nowrap;
-}
-
-.rounded-button svg {
-  fill: var(--md-primary-fg-color);
-  width: auto;
-  height: 1.2em;
-  margin-right: 0.5em;
-}
-
-/* device image */
-.device-on-hover {
-  width: auto;
-  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
-}
-
-a:hover .device-on-hover {
-  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
-  transform: scale(1.01);
-}
-
-/* text button */
-.reading-media {
-  display: flex;
-  justify-content: center;
-  align-items: flex-end;
-  height: 32vw;
-}
-
-.media-block {
-  height: 100%;
-  margin: 0 0.2em;
-}
-
-.text-button {
-  width: auto;
-  color: var(--md-typeset-btn-color);
-  text-decoration: none;
-  text-align: center;
-  margin: 2.7em auto;
-}
-
-.text-button span {
-  white-space: nowrap;
-}
-
-.text-button svg {
-  display: inline-block;
-  fill: var(--md-typeset-btn-color);
-  width: auto;
-  height: 0.9em;
-  background-size: cover;
-  padding-top: 0.17em;
-  margin-left: 0.15em;
-}
-
-a:hover .text-button span {
-  text-decoration: underline;
-}
-
-/* hero image */
 .hero-div {
   height: min(84vh, 75vw);
   width: min(112vh, 100vw);
-  margin: 0 auto;
-  margin-top: -2.4rem;
+  margin: -2.4rem auto 0;
   padding: 0;
   position: relative;
   font-size: min(1.8vh, 2.5vw);
@@ -384,13 +370,12 @@ a:hover .text-button span {
 }
 
 .hero-bg {
-  height: 100%;
   width: 100%;
+  height: 100%;
   object-fit: cover;
   position: absolute;
 }
 
-/* hover on the planets */
 .hero-div>a>img {
   width: auto;
   position: absolute;
@@ -402,7 +387,6 @@ a:hover .text-button span {
   position: absolute;
   transform: translateX(-50%) translateY(-50%);
   white-space: nowrap;
-  /* prevent line breaks */
   color: white;
 }
 
@@ -412,21 +396,105 @@ a:hover .text-button span {
 }
 
 .hero-div>a:hover>span {
-  text-decoration: underline;
   color: var(--md-typeset-btn-color);
+  text-decoration: underline;
 }
 
 .heading-div {
   width: 100%;
   position: absolute;
-  transform: translateX(-50%);
   left: 50%;
   bottom: min(2vh, 3vw);
+  transform: translateX(-50%);
   pointer-events: none;
   color: #fff;
 }
 
-/* code badge */
+/* Landing page CTAs */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  border-radius: 10em;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0 0 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+  fill: var(--md-primary-fg-color);
+}
+
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  margin: 2.7em auto;
+  color: var(--md-typeset-btn-color);
+  text-align: center;
+  text-decoration: none;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  width: auto;
+  height: 0.9em;
+  margin-left: 0.15em;
+  padding-top: 0.17em;
+  fill: var(--md-typeset-btn-color);
+  background-size: cover;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* Landing page content blocks */
 .code-badge {
   width: 100%;
   height: auto;
@@ -434,11 +502,10 @@ a:hover .text-button span {
 }
 
 .code-badge img {
-  height: 1.07em;
   width: auto;
+  height: 1.07em;
 }
 
-/* brief intro */
 .intro-container {
   display: flex;
   align-items: center;
@@ -455,14 +522,13 @@ a:hover .text-button span {
 
 .intro-text {
   flex-grow: 1;
-  /* fill the space */
   display: flex;
   flex-direction: column;
   justify-content: center;
-  text-align: left;
   align-items: flex-start;
   width: fit-content;
   margin: 2em;
+  text-align: left;
 }
 
 .intro-text>div {
@@ -471,6 +537,10 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
+.intro-text svg path {
+  fill: #3b3b3b;
+}
+
 .endor-text {
   width: 50%;
 }
@@ -480,7 +550,10 @@ a:hover .text-button span {
   font-weight: bold;
 }
 
-/* contributors table */
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
 .profile-div {
   display: flex;
   flex-wrap: wrap;
@@ -495,6 +568,11 @@ a:hover .text-button span {
   text-align: center;
 }
 
+.profile-cell a:hover b,
+.profile-cell a:focus-visible b {
+  text-decoration: underline;
+}
+
 .profile-img {
   width: 5em;
   border-radius: 50%;
@@ -517,7 +595,37 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
-/* Hide navigation */
+/* Embedded media */
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Responsive adjustments */
 @media screen and (max-width: 76.25em) {
   .section-content {
     max-width: 95vw;
@@ -532,7 +640,6 @@ a:hover .text-button span {
   }
 }
 
-/* mobile devices */
 @media screen and (max-width: 60em) {
   .home-div {
     font-size: 0.75rem;
@@ -571,209 +678,4 @@ a:hover .text-button span {
     flex: 1 1 30%;
   }
 }
-
-.video-container {
-  position: relative;
-  padding-bottom: 56.25%;
-  /* 16:9 */
-  height: 0;
-}
-
-.video-container iframe {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-/* starfield */
-.starfield {
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  z-index: 0;
-  background-color: var(--hero-starfield-bg-color, transparent);
-}
-
-.starfield-origin {
-  position: absolute;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-}
-
-/* Zensical-specific adjustments merged into the main stylesheet. */
-:root>* {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --hello-algo-sidebar-width: 13rem;
-}
-
-[data-md-color-scheme="slate"] {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --md-body-bg-color: var(--md-default-bg-color);
-  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
-}
-
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
-  background-color: #f5f5f5;
-  color: #1d1d20;
-}
-
-body {
-  background-color: var(--md-default-bg-color);
-}
-
-html:has(body[data-md-color-scheme="slate"]) {
-  background-color: #1e1e1e;
-}
-
-html:has(body[data-md-color-scheme="default"]) {
-  background-color: #ffffff;
-}
-
-.home-div[data-md-color-scheme="default"],
-.home-div[data-md-color-scheme="default"] h1,
-.home-div[data-md-color-scheme="default"] h2,
-.home-div[data-md-color-scheme="default"] h3,
-.home-div[data-md-color-scheme="default"] h4,
-.home-div[data-md-color-scheme="default"] h5,
-.home-div[data-md-color-scheme="default"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div[data-md-color-scheme="slate"],
-.home-div[data-md-color-scheme="slate"] h1,
-.home-div[data-md-color-scheme="slate"] h2,
-.home-div[data-md-color-scheme="slate"] h3,
-.home-div[data-md-color-scheme="slate"] h4,
-.home-div[data-md-color-scheme="slate"] h5,
-.home-div[data-md-color-scheme="slate"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div .intro-quote {
-  color: var(--md-default-fg-color--light) !important;
-}
-
-.reading-media+p {
-  margin-top: 1em !important;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before,
-.md-typeset summary:after {
-  top: 50%;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before {
-  transform: translateY(-50%);
-}
-
-.md-typeset summary:after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open]>summary:after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-nav__link[for] {
-  color: inherit !important;
-}
-
-.md-nav__link[for].md-nav__link--active {
-  color: var(--md-accent-fg-color) !important;
-}
-
-@media screen and (min-width: 76.25em) {
-  .md-grid {
-    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
-  }
-
-  .md-sidebar--primary,
-  .md-sidebar--secondary {
-    width: var(--hello-algo-sidebar-width);
-  }
-
-  [dir="ltr"] .md-sidebar__inner {
-    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-
-  [dir="rtl"] .md-sidebar__inner {
-    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap {
-  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
-  background-color: var(--md-default-fg-color--lighter);
-}
-
-.md-footer,
-.md-footer__inner,
-.md-footer-meta,
-.md-footer__link,
-.md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-footer {
-  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
-}
-
-[data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner,
-[data-md-color-scheme="slate"] .md-footer-meta,
-[data-md-color-scheme="slate"] .md-footer__link,
-[data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-banner {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .admonition.pythontutor,
-.md-typeset details.pythontutor,
-.md-typeset .pythontutor>.admonition-title,
-.md-typeset .pythontutor>summary {
-  background-color: var(--md-code-bg-color);
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before,
-.md-typeset .pythontutor>summary::after {
-  top: 50%;
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before {
-  transform: translateY(-50%);
-}
-
-.md-typeset .pythontutor>summary::after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open].pythontutor>summary::after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-typeset a:not(.md-button) {
-  text-decoration: none;
-}
-
-.md-typeset a:not(.md-button):hover,
-.md-typeset a:not(.md-button):focus-visible {
-  text-decoration: underline;
-}
-/*! update cache: 20260331044524 */
+/*! update cache: 20260331053217 */
diff --git a/javascripts/katex.js b/javascripts/katex.js
index 2e4c4d0af..a112d1080 100644
--- a/javascripts/katex.js
+++ b/javascripts/katex.js
@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260331044451 */
+/*! update cache: 20260331053143 */
diff --git a/javascripts/mathjax.js b/javascripts/mathjax.js
index c5f295fb0..f36d0163c 100644
--- a/javascripts/mathjax.js
+++ b/javascripts/mathjax.js
@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260331044451 */
+/*! update cache: 20260331053143 */
diff --git a/javascripts/starfield.js b/javascripts/starfield.js
index 4108751da..5fc0cc80a 100644
--- a/javascripts/starfield.js
+++ b/javascripts/starfield.js
@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260331044451 */
+/*! update cache: 20260331053143 */
diff --git a/ru/404.html b/ru/404.html
index 2bde90cae..39734f6fe 100644
--- a/ru/404.html
+++ b/ru/404.html
@@ -567,7 +567,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -589,7 +589,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -639,7 +639,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1174,7 +1174,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1196,7 +1196,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1302,7 +1302,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1584,7 +1584,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1606,7 +1606,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1684,7 +1684,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1779,7 +1779,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1801,7 +1801,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1879,7 +1879,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1963,7 +1963,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2126,7 +2126,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2217,7 +2217,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2239,7 +2239,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2289,7 +2289,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2345,7 +2345,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2484,7 +2484,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2512,7 +2512,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2540,7 +2540,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2568,7 +2568,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2773,7 +2773,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2801,7 +2801,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3106,7 +3106,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3134,7 +3134,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3411,7 +3411,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3552,7 +3552,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3664,7 +3664,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/assets/covers/chapter_appendix.jpg b/ru/assets/covers/chapter_appendix.jpg
index c35b7db9e..19c262cb1 100644
Binary files a/ru/assets/covers/chapter_appendix.jpg and b/ru/assets/covers/chapter_appendix.jpg differ
diff --git a/ru/assets/covers/chapter_array_and_linkedlist.jpg b/ru/assets/covers/chapter_array_and_linkedlist.jpg
index 8d03142ff..1c00293c1 100644
Binary files a/ru/assets/covers/chapter_array_and_linkedlist.jpg and b/ru/assets/covers/chapter_array_and_linkedlist.jpg differ
diff --git a/ru/assets/covers/chapter_backtracking.jpg b/ru/assets/covers/chapter_backtracking.jpg
index ea4aa1d11..50afbefc1 100644
Binary files a/ru/assets/covers/chapter_backtracking.jpg and b/ru/assets/covers/chapter_backtracking.jpg differ
diff --git a/ru/assets/covers/chapter_complexity_analysis.jpg b/ru/assets/covers/chapter_complexity_analysis.jpg
index 691523b9f..ed689d46e 100644
Binary files a/ru/assets/covers/chapter_complexity_analysis.jpg and b/ru/assets/covers/chapter_complexity_analysis.jpg differ
diff --git a/ru/assets/covers/chapter_data_structure.jpg b/ru/assets/covers/chapter_data_structure.jpg
index a6ee84428..d77329fc2 100644
Binary files a/ru/assets/covers/chapter_data_structure.jpg and b/ru/assets/covers/chapter_data_structure.jpg differ
diff --git a/ru/assets/covers/chapter_dynamic_programming.jpg b/ru/assets/covers/chapter_dynamic_programming.jpg
index 274e99157..c2b2d5ce5 100644
Binary files a/ru/assets/covers/chapter_dynamic_programming.jpg and b/ru/assets/covers/chapter_dynamic_programming.jpg differ
diff --git a/ru/assets/covers/chapter_graph.jpg b/ru/assets/covers/chapter_graph.jpg
index 0e39cccd0..eeefccce5 100644
Binary files a/ru/assets/covers/chapter_graph.jpg and b/ru/assets/covers/chapter_graph.jpg differ
diff --git a/ru/assets/covers/chapter_hashing.jpg b/ru/assets/covers/chapter_hashing.jpg
index 7a4c95a9c..12ad99151 100644
Binary files a/ru/assets/covers/chapter_hashing.jpg and b/ru/assets/covers/chapter_hashing.jpg differ
diff --git a/ru/assets/covers/chapter_hello_algo.jpg b/ru/assets/covers/chapter_hello_algo.jpg
index 2444c9551..86077958a 100644
Binary files a/ru/assets/covers/chapter_hello_algo.jpg and b/ru/assets/covers/chapter_hello_algo.jpg differ
diff --git a/ru/assets/covers/chapter_introduction.jpg b/ru/assets/covers/chapter_introduction.jpg
index b0933c489..5803e13c1 100644
Binary files a/ru/assets/covers/chapter_introduction.jpg and b/ru/assets/covers/chapter_introduction.jpg differ
diff --git a/ru/assets/covers/chapter_preface.jpg b/ru/assets/covers/chapter_preface.jpg
index b37f0c1b2..2fa1b63ec 100644
Binary files a/ru/assets/covers/chapter_preface.jpg and b/ru/assets/covers/chapter_preface.jpg differ
diff --git a/ru/assets/covers/chapter_sorting.jpg b/ru/assets/covers/chapter_sorting.jpg
index f89612ad7..46519e7e8 100644
Binary files a/ru/assets/covers/chapter_sorting.jpg and b/ru/assets/covers/chapter_sorting.jpg differ
diff --git a/ru/assets/covers/chapter_stack_and_queue.jpg b/ru/assets/covers/chapter_stack_and_queue.jpg
index e41820d18..ab4de4ca1 100644
Binary files a/ru/assets/covers/chapter_stack_and_queue.jpg and b/ru/assets/covers/chapter_stack_and_queue.jpg differ
diff --git a/ru/assets/covers/chapter_tree.jpg b/ru/assets/covers/chapter_tree.jpg
index b780bfe1d..4dff6c918 100644
Binary files a/ru/assets/covers/chapter_tree.jpg and b/ru/assets/covers/chapter_tree.jpg differ
diff --git a/ru/assets/javascripts/bundle.c2b142ea.min.js b/ru/assets/javascripts/bundle.c2b142ea.min.js
index d80d70325..8ed8f65f3 100644
--- a/ru/assets/javascripts/bundle.c2b142ea.min.js
+++ b/ru/assets/javascripts/bundle.c2b142ea.min.js
@@ -1,4 +1,4 @@
 "use strict";(()=>{var xc=Object.create;var kn=Object.defineProperty,wc=Object.defineProperties,Ec=Object.getOwnPropertyDescriptor,Tc=Object.getOwnPropertyDescriptors,Sc=Object.getOwnPropertyNames,Dr=Object.getOwnPropertySymbols,Oc=Object.getPrototypeOf,An=Object.prototype.hasOwnProperty,Fo=Object.prototype.propertyIsEnumerable;var jo=(e,t,r)=>t in e?kn(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,H=(e,t)=>{for(var r in t||(t={}))An.call(t,r)&&jo(e,r,t[r]);if(Dr)for(var r of Dr(t))Fo.call(t,r)&&jo(e,r,t[r]);return e},He=(e,t)=>wc(e,Tc(t));var gr=(e,t)=>{var r={};for(var n in e)An.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&Dr)for(var n of Dr(e))t.indexOf(n)<0&&Fo.call(e,n)&&(r[n]=e[n]);return r};var Cn=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Lc=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Sc(t))!An.call(e,o)&&o!==r&&kn(e,o,{get:()=>t[o],enumerable:!(n=Ec(t,o))||n.enumerable});return e};var _r=(e,t,r)=>(r=e!=null?xc(Oc(e)):{},Lc(t||!e||!e.__esModule?kn(r,"default",{value:e,enumerable:!0}):r,e));var Uo=(e,t,r)=>new Promise((n,o)=>{var i=c=>{try{s(r.next(c))}catch(l){o(l)}},a=c=>{try{s(r.throw(c))}catch(l){o(l)}},s=c=>c.done?n(c.value):Promise.resolve(c.value).then(i,a);s((r=r.apply(e,t)).next())});var Do=Cn((Hn,No)=>{(function(e,t){typeof Hn=="object"&&typeof No!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(Hn,(function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(_){return!!(_&&_!==document&&_.nodeName!=="HTML"&&_.nodeName!=="BODY"&&"classList"in _&&"contains"in _.classList)}function c(_){var de=_.type,be=_.tagName;return!!(be==="INPUT"&&a[de]&&!_.readOnly||be==="TEXTAREA"&&!_.readOnly||_.isContentEditable)}function l(_){_.classList.contains("focus-visible")||(_.classList.add("focus-visible"),_.setAttribute("data-focus-visible-added",""))}function u(_){_.hasAttribute("data-focus-visible-added")&&(_.classList.remove("focus-visible"),_.removeAttribute("data-focus-visible-added"))}function p(_){_.metaKey||_.altKey||_.ctrlKey||(s(r.activeElement)&&l(r.activeElement),n=!0)}function d(_){n=!1}function m(_){s(_.target)&&(n||c(_.target))&&l(_.target)}function h(_){s(_.target)&&(_.target.classList.contains("focus-visible")||_.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(_.target))}function v(_){document.visibilityState==="hidden"&&(o&&(n=!0),x())}function x(){document.addEventListener("mousemove",E),document.addEventListener("mousedown",E),document.addEventListener("mouseup",E),document.addEventListener("pointermove",E),document.addEventListener("pointerdown",E),document.addEventListener("pointerup",E),document.addEventListener("touchmove",E),document.addEventListener("touchstart",E),document.addEventListener("touchend",E)}function w(){document.removeEventListener("mousemove",E),document.removeEventListener("mousedown",E),document.removeEventListener("mouseup",E),document.removeEventListener("pointermove",E),document.removeEventListener("pointerdown",E),document.removeEventListener("pointerup",E),document.removeEventListener("touchmove",E),document.removeEventListener("touchstart",E),document.removeEventListener("touchend",E)}function E(_){_.target.nodeName&&_.target.nodeName.toLowerCase()==="html"||(n=!1,w())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",d,!0),document.addEventListener("pointerdown",d,!0),document.addEventListener("touchstart",d,!0),document.addEventListener("visibilitychange",v,!0),x(),r.addEventListener("focus",m,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)}))});var So=Cn((M0,vs)=>{"use strict";var Gu=/["'&<>]/;vs.exports=Ju;function Ju(e){var t=""+e,r=Gu.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i<t.length;i++){switch(t.charCodeAt(i)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}a!==i&&(o+=t.substring(a,i)),a=i+1,o+=n}return a!==i?o+t.substring(a,i):o}});var Mo=Cn((jr,Lo)=>{(function(t,r){typeof jr=="object"&&typeof Lo=="object"?Lo.exports=r():typeof define=="function"&&define.amd?define([],r):typeof jr=="object"?jr.ClipboardJS=r():t.ClipboardJS=r()})(jr,function(){return(function(){var e={686:(function(n,o,i){"use strict";i.d(o,{default:function(){return vr}});var a=i(279),s=i.n(a),c=i(370),l=i.n(c),u=i(817),p=i.n(u);function d(B){try{return document.execCommand(B)}catch(C){return!1}}var m=function(C){var k=p()(C);return d("cut"),k},h=m;function v(B){var C=document.documentElement.getAttribute("dir")==="rtl",k=document.createElement("textarea");k.style.fontSize="12pt",k.style.border="0",k.style.padding="0",k.style.margin="0",k.style.position="absolute",k.style[C?"right":"left"]="-9999px";var D=window.pageYOffset||document.documentElement.scrollTop;return k.style.top="".concat(D,"px"),k.setAttribute("readonly",""),k.value=B,k}var x=function(C,k){var D=v(C);k.container.appendChild(D);var W=p()(D);return d("copy"),D.remove(),W},w=function(C){var k=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},D="";return typeof C=="string"?D=x(C,k):C instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(C==null?void 0:C.type)?D=x(C.value,k):(D=p()(C),d("copy")),D},E=w;function _(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?_=function(k){return typeof k}:_=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},_(B)}var de=function(){var C=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},k=C.action,D=k===void 0?"copy":k,W=C.container,Z=C.target,We=C.text;if(D!=="copy"&&D!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(Z!==void 0)if(Z&&_(Z)==="object"&&Z.nodeType===1){if(D==="copy"&&Z.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(D==="cut"&&(Z.hasAttribute("readonly")||Z.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(We)return E(We,{container:W});if(Z)return D==="cut"?h(Z):E(Z,{container:W})},be=de;function M(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?M=function(k){return typeof k}:M=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},M(B)}function O(B,C){if(!(B instanceof C))throw new TypeError("Cannot call a class as a function")}function N(B,C){for(var k=0;k<C.length;k++){var D=C[k];D.enumerable=D.enumerable||!1,D.configurable=!0,"value"in D&&(D.writable=!0),Object.defineProperty(B,D.key,D)}}function ee(B,C,k){return C&&N(B.prototype,C),k&&N(B,k),B}function le(B,C){if(typeof C!="function"&&C!==null)throw new TypeError("Super expression must either be null or a function");B.prototype=Object.create(C&&C.prototype,{constructor:{value:B,writable:!0,configurable:!0}}),C&&ce(B,C)}function ce(B,C){return ce=Object.setPrototypeOf||function(D,W){return D.__proto__=W,D},ce(B,C)}function Ne(B){var C=st();return function(){var D=tt(B),W;if(C){var Z=tt(this).constructor;W=Reflect.construct(D,arguments,Z)}else W=D.apply(this,arguments);return bt(this,W)}}function bt(B,C){return C&&(M(C)==="object"||typeof C=="function")?C:De(B)}function De(B){if(B===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return B}function st(){if(typeof Reflect=="undefined"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(B){return!1}}function tt(B){return tt=Object.setPrototypeOf?Object.getPrototypeOf:function(k){return k.__proto__||Object.getPrototypeOf(k)},tt(B)}function Yt(B,C){var k="data-clipboard-".concat(B);if(C.hasAttribute(k))return C.getAttribute(k)}var Mt=(function(B){le(k,B);var C=Ne(k);function k(D,W){var Z;return O(this,k),Z=C.call(this),Z.resolveOptions(W),Z.listenClick(D),Z}return ee(k,[{key:"resolveOptions",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof W.action=="function"?W.action:this.defaultAction,this.target=typeof W.target=="function"?W.target:this.defaultTarget,this.text=typeof W.text=="function"?W.text:this.defaultText,this.container=M(W.container)==="object"?W.container:document.body}},{key:"listenClick",value:function(W){var Z=this;this.listener=l()(W,"click",function(We){return Z.onClick(We)})}},{key:"onClick",value:function(W){var Z=W.delegateTarget||W.currentTarget,We=this.action(Z)||"copy",Gt=be({action:We,container:this.container,target:this.target(Z),text:this.text(Z)});this.emit(Gt?"success":"error",{action:We,text:Gt,trigger:Z,clearSelection:function(){Z&&Z.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(W){return Yt("action",W)}},{key:"defaultTarget",value:function(W){var Z=Yt("target",W);if(Z)return document.querySelector(Z)}},{key:"defaultText",value:function(W){return Yt("text",W)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(W){var Z=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return E(W,Z)}},{key:"cut",value:function(W){return h(W)}},{key:"isSupported",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],Z=typeof W=="string"?[W]:W,We=!!document.queryCommandSupported;return Z.forEach(function(Gt){We=We&&!!document.queryCommandSupported(Gt)}),We}}]),k})(s()),vr=Mt}),828:(function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,c){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(c))return s;s=s.parentNode}}n.exports=a}),438:(function(n,o,i){var a=i(828);function s(u,p,d,m,h){var v=l.apply(this,arguments);return u.addEventListener(d,v,h),{destroy:function(){u.removeEventListener(d,v,h)}}}function c(u,p,d,m,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof d=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,d,m,h)}))}function l(u,p,d,m){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&m.call(u,h)}}n.exports=c}),879:(function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}}),370:(function(n,o,i){var a=i(879),s=i(438);function c(d,m,h){if(!d&&!m&&!h)throw new Error("Missing required arguments");if(!a.string(m))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(d))return l(d,m,h);if(a.nodeList(d))return u(d,m,h);if(a.string(d))return p(d,m,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function l(d,m,h){return d.addEventListener(m,h),{destroy:function(){d.removeEventListener(m,h)}}}function u(d,m,h){return Array.prototype.forEach.call(d,function(v){v.addEventListener(m,h)}),{destroy:function(){Array.prototype.forEach.call(d,function(v){v.removeEventListener(m,h)})}}}function p(d,m,h){return s(document.body,d,m,h)}n.exports=c}),817:(function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var c=window.getSelection(),l=document.createRange();l.selectNodeContents(i),c.removeAllRanges(),c.addRange(l),a=c.toString()}return a}n.exports=o}),279:(function(n){function o(){}o.prototype={on:function(i,a,s){var c=this.e||(this.e={});return(c[i]||(c[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var c=this;function l(){c.off(i,l),a.apply(s,arguments)}return l._=a,this.on(i,l,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),c=0,l=s.length;for(c;c<l;c++)s[c].fn.apply(s[c].ctx,a);return this},off:function(i,a){var s=this.e||(this.e={}),c=s[i],l=[];if(c&&a)for(var u=0,p=c.length;u<p;u++)c[u].fn!==a&&c[u].fn._!==a&&l.push(c[u]);return l.length?s[i]=l:delete s[i],this}},n.exports=o,n.exports.TinyEmitter=o})},t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}return(function(){r.n=function(n){var o=n&&n.__esModule?function(){return n.default}:function(){return n};return r.d(o,{a:o}),o}})(),(function(){r.d=function(n,o){for(var i in o)r.o(o,i)&&!r.o(n,i)&&Object.defineProperty(n,i,{enumerable:!0,get:o[i]})}})(),(function(){r.o=function(n,o){return Object.prototype.hasOwnProperty.call(n,o)}})(),r(686)})().default})});var LM=_r(Do());var $n=function(e,t){return $n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,n){r.__proto__=n}||function(r,n){for(var o in n)Object.prototype.hasOwnProperty.call(n,o)&&(r[o]=n[o])},$n(e,t)};function ue(e,t){if(typeof t!="function"&&t!==null)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");$n(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function Wo(e,t,r,n){function o(i){return i instanceof r?i:new r(function(a){a(i)})}return new(r||(r=Promise))(function(i,a){function s(u){try{l(n.next(u))}catch(p){a(p)}}function c(u){try{l(n.throw(u))}catch(p){a(p)}}function l(u){u.done?i(u.value):o(u.value).then(s,c)}l((n=n.apply(e,t||[])).next())})}function Wr(e,t){var r={label:0,sent:function(){if(i[0]&1)throw i[1];return i[1]},trys:[],ops:[]},n,o,i,a=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return a.next=s(0),a.throw=s(1),a.return=s(2),typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(l){return function(u){return c([l,u])}}function c(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(r=0)),r;)try{if(n=1,o&&(i=l[0]&2?o.return:l[0]?o.throw||((i=o.return)&&i.call(o),0):o.next)&&!(i=i.call(o,l[1])).done)return i;switch(o=0,i&&(l=[l[0]&2,i.value]),l[0]){case 0:case 1:i=l;break;case 4:return r.label++,{value:l[1],done:!1};case 5:r.label++,o=l[1],l=[0];continue;case 7:l=r.ops.pop(),r.trys.pop();continue;default:if(i=r.trys,!(i=i.length>0&&i[i.length-1])&&(l[0]===6||l[0]===2)){r=0;continue}if(l[0]===3&&(!i||l[1]>i[0]&&l[1]<i[3])){r.label=l[1];break}if(l[0]===6&&r.label<i[1]){r.label=i[1],i=l;break}if(i&&r.label<i[2]){r.label=i[2],r.ops.push(l);break}i[2]&&r.ops.pop(),r.trys.pop();continue}l=t.call(e,r)}catch(u){l=[6,u],o=0}finally{n=i=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}function $e(e){var t=typeof Symbol=="function"&&Symbol.iterator,r=t&&e[t],n=0;if(r)return r.call(e);if(e&&typeof e.length=="number")return{next:function(){return e&&n>=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function te(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function ne(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n<o;n++)(i||!(n in t))&&(i||(i=Array.prototype.slice.call(t,0,n)),i[n]=t[n]);return e.concat(i||Array.prototype.slice.call(t))}function kt(e){return this instanceof kt?(this.v=e,this):new kt(e)}function Vo(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),o,i=[];return o=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",a),o[Symbol.asyncIterator]=function(){return this},o;function a(m){return function(h){return Promise.resolve(h).then(m,p)}}function s(m,h){n[m]&&(o[m]=function(v){return new Promise(function(x,w){i.push([m,v,x,w])>1||c(m,v)})},h&&(o[m]=h(o[m])))}function c(m,h){try{l(n[m](h))}catch(v){d(i[0][3],v)}}function l(m){m.value instanceof kt?Promise.resolve(m.value.v).then(u,p):d(i[0][2],m)}function u(m){c("next",m)}function p(m){c("throw",m)}function d(m,h){m(h),i.shift(),i.length&&c(i[0][0],i[0][1])}}function zo(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof $e=="function"?$e(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,c){a=e[i](a),o(s,c,a.done,a.value)})}}function o(i,a,s,c){Promise.resolve(c).then(function(l){i({value:l,done:s})},a)}}function F(e){return typeof e=="function"}function Jt(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var Vr=Jt(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription:
 `+r.map(function(n,o){return o+1+") "+n.toString()}).join(`
   `):"",this.name="UnsubscriptionError",this.errors=r}});function ct(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var rt=(function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=$e(a),c=s.next();!c.done;c=s.next()){var l=c.value;l.remove(this)}}catch(v){t={error:v}}finally{try{c&&!c.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(F(u))try{u()}catch(v){i=v instanceof Vr?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var d=$e(p),m=d.next();!m.done;m=d.next()){var h=m.value;try{qo(h)}catch(v){i=i!=null?i:[],v instanceof Vr?i=ne(ne([],te(i)),te(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{m&&!m.done&&(o=d.return)&&o.call(d)}finally{if(n)throw n.error}}}if(i)throw new Vr(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)qo(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&ct(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&ct(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=(function(){var t=new e;return t.closed=!0,t})(),e})();var Pn=rt.EMPTY;function zr(e){return e instanceof rt||e&&"closed"in e&&F(e.remove)&&F(e.add)&&F(e.unsubscribe)}function qo(e){F(e)?e():e.unsubscribe()}var Je={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var Xt={setTimeout:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Xt.delegate;return o!=null&&o.setTimeout?o.setTimeout.apply(o,ne([e,t],te(r))):setTimeout.apply(void 0,ne([e,t],te(r)))},clearTimeout:function(e){var t=Xt.delegate;return((t==null?void 0:t.clearTimeout)||clearTimeout)(e)},delegate:void 0};function qr(e){Xt.setTimeout(function(){var t=Je.onUnhandledError;if(t)t(e);else throw e})}function Pe(){}var Ko=(function(){return In("C",void 0,void 0)})();function Bo(e){return In("E",void 0,e)}function Yo(e){return In("N",e,void 0)}function In(e,t,r){return{kind:e,value:t,error:r}}var At=null;function Zt(e){if(Je.useDeprecatedSynchronousErrorHandling){var t=!At;if(t&&(At={errorThrown:!1,error:null}),e(),t){var r=At,n=r.errorThrown,o=r.error;if(At=null,n)throw o}}else e()}function Go(e){Je.useDeprecatedSynchronousErrorHandling&&At&&(At.errorThrown=!0,At.error=e)}var yr=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n.isStopped=!1,r?(n.destination=r,zr(r)&&r.add(n)):n.destination=Cc,n}return t.create=function(r,n,o){return new Ct(r,n,o)},t.prototype.next=function(r){this.isStopped?jn(Yo(r),this):this._next(r)},t.prototype.error=function(r){this.isStopped?jn(Bo(r),this):(this.isStopped=!0,this._error(r))},t.prototype.complete=function(){this.isStopped?jn(Ko,this):(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.closed||(this.isStopped=!0,e.prototype.unsubscribe.call(this),this.destination=null)},t.prototype._next=function(r){this.destination.next(r)},t.prototype._error=function(r){try{this.destination.error(r)}finally{this.unsubscribe()}},t.prototype._complete=function(){try{this.destination.complete()}finally{this.unsubscribe()}},t})(rt);var Mc=Function.prototype.bind;function Rn(e,t){return Mc.call(e,t)}var kc=(function(){function e(t){this.partialObserver=t}return e.prototype.next=function(t){var r=this.partialObserver;if(r.next)try{r.next(t)}catch(n){Kr(n)}},e.prototype.error=function(t){var r=this.partialObserver;if(r.error)try{r.error(t)}catch(n){Kr(n)}else Kr(t)},e.prototype.complete=function(){var t=this.partialObserver;if(t.complete)try{t.complete()}catch(r){Kr(r)}},e})(),Ct=(function(e){ue(t,e);function t(r,n,o){var i=e.call(this)||this,a;if(F(r)||!r)a={next:r!=null?r:void 0,error:n!=null?n:void 0,complete:o!=null?o:void 0};else{var s;i&&Je.useDeprecatedNextContext?(s=Object.create(r),s.unsubscribe=function(){return i.unsubscribe()},a={next:r.next&&Rn(r.next,s),error:r.error&&Rn(r.error,s),complete:r.complete&&Rn(r.complete,s)}):a=r}return i.destination=new kc(a),i}return t})(yr);function Kr(e){Je.useDeprecatedSynchronousErrorHandling?Go(e):qr(e)}function Ac(e){throw e}function jn(e,t){var r=Je.onStoppedNotification;r&&Xt.setTimeout(function(){return r(e,t)})}var Cc={closed:!0,next:Pe,error:Ac,complete:Pe};var Qt=(function(){return typeof Symbol=="function"&&Symbol.observable||"@@observable"})();function Oe(e){return e}function Jo(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Fn(e)}function Fn(e){return e.length===0?Oe:e.length===1?e[0]:function(r){return e.reduce(function(n,o){return o(n)},r)}}var U=(function(){function e(t){t&&(this._subscribe=t)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(t,r,n){var o=this,i=$c(t)?t:new Ct(t,r,n);return Zt(function(){var a=o,s=a.operator,c=a.source;i.add(s?s.call(i,c):c?o._subscribe(i):o._trySubscribe(i))}),i},e.prototype._trySubscribe=function(t){try{return this._subscribe(t)}catch(r){t.error(r)}},e.prototype.forEach=function(t,r){var n=this;return r=Xo(r),new r(function(o,i){var a=new Ct({next:function(s){try{t(s)}catch(c){i(c),a.unsubscribe()}},error:i,complete:o});n.subscribe(a)})},e.prototype._subscribe=function(t){var r;return(r=this.source)===null||r===void 0?void 0:r.subscribe(t)},e.prototype[Qt]=function(){return this},e.prototype.pipe=function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return Fn(t)(this)},e.prototype.toPromise=function(t){var r=this;return t=Xo(t),new t(function(n,o){var i;r.subscribe(function(a){return i=a},function(a){return o(a)},function(){return n(i)})})},e.create=function(t){return new e(t)},e})();function Xo(e){var t;return(t=e!=null?e:Je.Promise)!==null&&t!==void 0?t:Promise}function Hc(e){return e&&F(e.next)&&F(e.error)&&F(e.complete)}function $c(e){return e&&e instanceof yr||Hc(e)&&zr(e)}function Pc(e){return F(e==null?void 0:e.lift)}function S(e){return function(t){if(Pc(t))return t.lift(function(r){try{return e(r,this)}catch(n){this.error(n)}});throw new TypeError("Unable to lift unknown Observable type")}}function T(e,t,r,n,o){return new Ic(e,t,r,n,o)}var Ic=(function(e){ue(t,e);function t(r,n,o,i,a,s){var c=e.call(this,r)||this;return c.onFinalize=a,c.shouldUnsubscribe=s,c._next=n?function(l){try{n(l)}catch(u){r.error(u)}}:e.prototype._next,c._error=i?function(l){try{i(l)}catch(u){r.error(u)}finally{this.unsubscribe()}}:e.prototype._error,c._complete=o?function(){try{o()}catch(l){r.error(l)}finally{this.unsubscribe()}}:e.prototype._complete,c}return t.prototype.unsubscribe=function(){var r;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){var n=this.closed;e.prototype.unsubscribe.call(this),!n&&((r=this.onFinalize)===null||r===void 0||r.call(this))}},t})(yr);var er={schedule:function(e){var t=requestAnimationFrame,r=cancelAnimationFrame,n=er.delegate;n&&(t=n.requestAnimationFrame,r=n.cancelAnimationFrame);var o=t(function(i){r=void 0,e(i)});return new rt(function(){return r==null?void 0:r(o)})},requestAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.requestAnimationFrame)||requestAnimationFrame).apply(void 0,ne([],te(e)))},cancelAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.cancelAnimationFrame)||cancelAnimationFrame).apply(void 0,ne([],te(e)))},delegate:void 0};var Zo=Jt(function(e){return function(){e(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}});var I=(function(e){ue(t,e);function t(){var r=e.call(this)||this;return r.closed=!1,r.currentObservers=null,r.observers=[],r.isStopped=!1,r.hasError=!1,r.thrownError=null,r}return t.prototype.lift=function(r){var n=new Qo(this,this);return n.operator=r,n},t.prototype._throwIfClosed=function(){if(this.closed)throw new Zo},t.prototype.next=function(r){var n=this;Zt(function(){var o,i;if(n._throwIfClosed(),!n.isStopped){n.currentObservers||(n.currentObservers=Array.from(n.observers));try{for(var a=$e(n.currentObservers),s=a.next();!s.done;s=a.next()){var c=s.value;c.next(r)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}}})},t.prototype.error=function(r){var n=this;Zt(function(){if(n._throwIfClosed(),!n.isStopped){n.hasError=n.isStopped=!0,n.thrownError=r;for(var o=n.observers;o.length;)o.shift().error(r)}})},t.prototype.complete=function(){var r=this;Zt(function(){if(r._throwIfClosed(),!r.isStopped){r.isStopped=!0;for(var n=r.observers;n.length;)n.shift().complete()}})},t.prototype.unsubscribe=function(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null},Object.defineProperty(t.prototype,"observed",{get:function(){var r;return((r=this.observers)===null||r===void 0?void 0:r.length)>0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Pn:(this.currentObservers=null,s.push(r),new rt(function(){n.currentObservers=null,ct(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new Qo(r,n)},t})(U);var Qo=(function(e){ue(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Pn},t})(I);var Un=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n._value=r,n}return Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!1,configurable:!0}),t.prototype._subscribe=function(r){var n=e.prototype._subscribe.call(this,r);return!n.closed&&r.next(this._value),n},t.prototype.getValue=function(){var r=this,n=r.hasError,o=r.thrownError,i=r._value;if(n)throw o;return this._throwIfClosed(),i},t.prototype.next=function(r){e.prototype.next.call(this,this._value=r)},t})(I);var xr={now:function(){return(xr.delegate||Date).now()},delegate:void 0};var wr=(function(e){ue(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=xr);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,c=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+c)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),c=0;c<s.length&&!r.closed;c+=i?1:2)r.next(s[c]);return this._checkFinalizedStatuses(r),n},t.prototype._trimBuffer=function(){var r=this,n=r._bufferSize,o=r._timestampProvider,i=r._buffer,a=r._infiniteTimeWindow,s=(a?1:2)*n;if(n<1/0&&s<i.length&&i.splice(0,i.length-s),!a){for(var c=o.now(),l=0,u=1;u<i.length&&i[u]<=c;u+=2)l=u;l&&i.splice(0,l+1)}},t})(I);var ei=(function(e){ue(t,e);function t(r,n){return e.call(this)||this}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),this},t})(rt);var Er={setInterval:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Er.delegate;return o!=null&&o.setInterval?o.setInterval.apply(o,ne([e,t],te(r))):setInterval.apply(void 0,ne([e,t],te(r)))},clearInterval:function(e){var t=Er.delegate;return((t==null?void 0:t.clearInterval)||clearInterval)(e)},delegate:void 0};var tr=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o.pending=!1,o}return t.prototype.schedule=function(r,n){var o;if(n===void 0&&(n=0),this.closed)return this;this.state=r;var i=this.id,a=this.scheduler;return i!=null&&(this.id=this.recycleAsyncId(a,i,n)),this.pending=!0,this.delay=n,this.id=(o=this.id)!==null&&o!==void 0?o:this.requestAsyncId(a,this.id,n),this},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),Er.setInterval(r.flush.bind(r,this),o)},t.prototype.recycleAsyncId=function(r,n,o){if(o===void 0&&(o=0),o!=null&&this.delay===o&&this.pending===!1)return n;n!=null&&Er.clearInterval(n)},t.prototype.execute=function(r,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;var o=this._execute(r,n);if(o)return o;this.pending===!1&&this.id!=null&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))},t.prototype._execute=function(r,n){var o=!1,i;try{this.work(r)}catch(a){o=!0,i=a||new Error("Scheduled action threw falsy error")}if(o)return this.unsubscribe(),i},t.prototype.unsubscribe=function(){if(!this.closed){var r=this,n=r.id,o=r.scheduler,i=o.actions;this.work=this.state=this.scheduler=null,this.pending=!1,ct(i,this),n!=null&&(this.id=this.recycleAsyncId(o,n,null)),this.delay=null,e.prototype.unsubscribe.call(this)}},t})(ei);var Nn=(function(){function e(t,r){r===void 0&&(r=e.now),this.schedulerActionCtor=t,this.now=r}return e.prototype.schedule=function(t,r,n){return r===void 0&&(r=0),new this.schedulerActionCtor(this,t).schedule(n,r)},e.now=xr.now,e})();var rr=(function(e){ue(t,e);function t(r,n){n===void 0&&(n=Nn.now);var o=e.call(this,r,n)||this;return o.actions=[],o._active=!1,o}return t.prototype.flush=function(r){var n=this.actions;if(this._active){n.push(r);return}var o;this._active=!0;do if(o=r.execute(r.state,r.delay))break;while(r=n.shift());if(this._active=!1,o){for(;r=n.shift();)r.unsubscribe();throw o}},t})(Nn);var ge=new rr(tr),Dn=ge;var ti=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),n>0?e.prototype.schedule.call(this,r,n):(this.delay=n,this.state=r,this.scheduler.flush(this),this)},t.prototype.execute=function(r,n){return n>0||this.closed?e.prototype.execute.call(this,r,n):this._execute(r,n)},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!=null&&o>0||o==null&&this.delay>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.flush(this),0)},t})(tr);var ri=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t})(rr);var Wn=new ri(ti);var ni=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!==null&&o>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=er.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&n===r._scheduled&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(er.cancelAnimationFrame(n),r._scheduled=void 0)},t})(tr);var oi=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n;r?n=r.id:(n=this._scheduled,this._scheduled=void 0);var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t})(rr);var je=new oi(ni);var y=new U(function(e){return e.complete()});function Br(e){return e&&F(e.schedule)}function Vn(e){return e[e.length-1]}function _t(e){return F(Vn(e))?e.pop():void 0}function qe(e){return Br(Vn(e))?e.pop():void 0}function Yr(e,t){return typeof Vn(e)=="number"?e.pop():t}var nr=(function(e){return e&&typeof e.length=="number"&&typeof e!="function"});function Gr(e){return F(e==null?void 0:e.then)}function Jr(e){return F(e[Qt])}function Xr(e){return Symbol.asyncIterator&&F(e==null?void 0:e[Symbol.asyncIterator])}function Zr(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Rc(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qr=Rc();function en(e){return F(e==null?void 0:e[Qr])}function tn(e){return Vo(this,arguments,function(){var r,n,o,i;return Wr(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,kt(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,kt(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,kt(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function rn(e){return F(e==null?void 0:e.getReader)}function q(e){if(e instanceof U)return e;if(e!=null){if(Jr(e))return jc(e);if(nr(e))return Fc(e);if(Gr(e))return Uc(e);if(Xr(e))return ii(e);if(en(e))return Nc(e);if(rn(e))return Dc(e)}throw Zr(e)}function jc(e){return new U(function(t){var r=e[Qt]();if(F(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Fc(e){return new U(function(t){for(var r=0;r<e.length&&!t.closed;r++)t.next(e[r]);t.complete()})}function Uc(e){return new U(function(t){e.then(function(r){t.closed||(t.next(r),t.complete())},function(r){return t.error(r)}).then(null,qr)})}function Nc(e){return new U(function(t){var r,n;try{for(var o=$e(e),i=o.next();!i.done;i=o.next()){var a=i.value;if(t.next(a),t.closed)return}}catch(s){r={error:s}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}t.complete()})}function ii(e){return new U(function(t){Wc(e,t).catch(function(r){return t.error(r)})})}function Dc(e){return ii(tn(e))}function Wc(e,t){var r,n,o,i;return Wo(this,void 0,void 0,function(){var a,s;return Wr(this,function(c){switch(c.label){case 0:c.trys.push([0,5,6,11]),r=zo(e),c.label=1;case 1:return[4,r.next()];case 2:if(n=c.sent(),!!n.done)return[3,4];if(a=n.value,t.next(a),t.closed)return[2];c.label=3;case 3:return[3,1];case 4:return[3,11];case 5:return s=c.sent(),o={error:s},[3,11];case 6:return c.trys.push([6,,9,10]),n&&!n.done&&(i=r.return)?[4,i.call(r)]:[3,8];case 7:c.sent(),c.label=8;case 8:return[3,10];case 9:if(o)throw o.error;return[7];case 10:return[7];case 11:return t.complete(),[2]}})})}function Fe(e,t,r,n,o){n===void 0&&(n=0),o===void 0&&(o=!1);var i=t.schedule(function(){r(),o?e.add(this.schedule(null,n)):this.unsubscribe()},n);if(e.add(i),!o)return i}function Ie(e,t){return t===void 0&&(t=0),S(function(r,n){r.subscribe(T(n,function(o){return Fe(n,e,function(){return n.next(o)},t)},function(){return Fe(n,e,function(){return n.complete()},t)},function(o){return Fe(n,e,function(){return n.error(o)},t)}))})}function Ht(e,t){return t===void 0&&(t=0),S(function(r,n){n.add(e.schedule(function(){return r.subscribe(n)},t))})}function ai(e,t){return q(e).pipe(Ht(t),Ie(t))}function si(e,t){return q(e).pipe(Ht(t),Ie(t))}function ci(e,t){return new U(function(r){var n=0;return t.schedule(function(){n===e.length?r.complete():(r.next(e[n++]),r.closed||this.schedule())})})}function li(e,t){return new U(function(r){var n;return Fe(r,t,function(){n=e[Qr](),Fe(r,t,function(){var o,i,a;try{o=n.next(),i=o.value,a=o.done}catch(s){r.error(s);return}a?r.complete():r.next(i)},0,!0)}),function(){return F(n==null?void 0:n.return)&&n.return()}})}function nn(e,t){if(!e)throw new Error("Iterable cannot be null");return new U(function(r){Fe(r,t,function(){var n=e[Symbol.asyncIterator]();Fe(r,t,function(){n.next().then(function(o){o.done?r.complete():r.next(o.value)})},0,!0)})})}function ui(e,t){return nn(tn(e),t)}function pi(e,t){if(e!=null){if(Jr(e))return ai(e,t);if(nr(e))return ci(e,t);if(Gr(e))return si(e,t);if(Xr(e))return nn(e,t);if(en(e))return li(e,t);if(rn(e))return ui(e,t)}throw Zr(e)}function me(e,t){return t?pi(e,t):q(e)}function Y(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return me(e,r)}function zn(e,t){var r=F(e)?e:function(){return e},n=function(o){return o.error(r())};return new U(t?function(o){return t.schedule(n,0,o)}:n)}var on=Jt(function(e){return function(){e(this),this.name="EmptyError",this.message="no elements in sequence"}});function fi(e){return e instanceof Date&&!isNaN(e)}function f(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){n.next(e.call(t,i,o++))}))})}var Vc=Array.isArray;function zc(e,t){return Vc(t)?e.apply(void 0,ne([],te(t))):e(t)}function yt(e){return f(function(t){return zc(e,t)})}var qc=Array.isArray,Kc=Object.getPrototypeOf,Bc=Object.prototype,Yc=Object.keys;function mi(e){if(e.length===1){var t=e[0];if(qc(t))return{args:t,keys:null};if(Gc(t)){var r=Yc(t);return{args:r.map(function(n){return t[n]}),keys:r}}}return{args:e,keys:null}}function Gc(e){return e&&typeof e=="object"&&Kc(e)===Bc}function di(e,t){return e.reduce(function(r,n,o){return r[n]=t[o],r},{})}function re(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=_t(e),o=mi(e),i=o.args,a=o.keys;if(i.length===0)return me([],r);var s=new U(qn(i,r,a?function(c){return di(a,c)}:Oe));return n?s.pipe(yt(n)):s}function qn(e,t,r){return r===void 0&&(r=Oe),function(n){hi(t,function(){for(var o=e.length,i=new Array(o),a=o,s=o,c=function(u){hi(t,function(){var p=me(e[u],t),d=!1;p.subscribe(T(n,function(m){i[u]=m,d||(d=!0,s--),s||n.next(r(i.slice()))},function(){--a||n.complete()}))},n)},l=0;l<o;l++)c(l)},n)}}function hi(e,t,r){e?Fe(r,e,t):t()}function vi(e,t,r,n,o,i,a,s){var c=[],l=0,u=0,p=!1,d=function(){p&&!c.length&&!l&&t.complete()},m=function(v){return l<n?h(v):c.push(v)},h=function(v){i&&t.next(v),l++;var x=!1;q(r(v,u++)).subscribe(T(t,function(w){o==null||o(w),i?m(w):t.next(w)},function(){x=!0},void 0,function(){if(x)try{l--;for(var w=function(){var E=c.shift();a?Fe(t,a,function(){return h(E)}):h(E)};c.length&&l<n;)w();d()}catch(E){t.error(E)}}))};return e.subscribe(T(t,m,function(){p=!0,d()})),function(){s==null||s()}}function oe(e,t,r){return r===void 0&&(r=1/0),F(t)?oe(function(n,o){return f(function(i,a){return t(n,i,o,a)})(q(e(n,o)))},r):(typeof t=="number"&&(r=t),S(function(n,o){return vi(n,o,e,r)}))}function or(e){return e===void 0&&(e=1/0),oe(Oe,e)}function bi(){return or(1)}function nt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return bi()(me(e,qe(e)))}function j(e){return new U(function(t){q(e()).subscribe(t)})}var Jc=["addListener","removeListener"],Xc=["addEventListener","removeEventListener"],Zc=["on","off"];function b(e,t,r,n){if(F(r)&&(n=r,r=void 0),n)return b(e,t,r).pipe(yt(n));var o=te(tl(e)?Xc.map(function(s){return function(c){return e[s](t,c,r)}}):Qc(e)?Jc.map(gi(e,t)):el(e)?Zc.map(gi(e,t)):[],2),i=o[0],a=o[1];if(!i&&nr(e))return oe(function(s){return b(s,t,r)})(q(e));if(!i)throw new TypeError("Invalid event target");return new U(function(s){var c=function(){for(var l=[],u=0;u<arguments.length;u++)l[u]=arguments[u];return s.next(1<l.length?l:l[0])};return i(c),function(){return a(c)}})}function gi(e,t){return function(r){return function(n){return e[r](t,n)}}}function Qc(e){return F(e.addListener)&&F(e.removeListener)}function el(e){return F(e.on)&&F(e.off)}function tl(e){return F(e.addEventListener)&&F(e.removeEventListener)}function an(e,t,r){return r?an(e,t).pipe(yt(r)):new U(function(n){var o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];return n.next(a.length===1?a[0]:a)},i=e(o);return F(t)?function(){return t(o,i)}:void 0})}function Ve(e,t,r){e===void 0&&(e=0),r===void 0&&(r=Dn);var n=-1;return t!=null&&(Br(t)?r=t:n=t),new U(function(o){var i=fi(e)?+e-r.now():e;i<0&&(i=0);var a=0;return r.schedule(function(){o.closed||(o.next(a++),0<=n?this.schedule(void 0,n):o.complete())},i)})}function R(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0),o=e;return o.length?o.length===1?q(o[0]):or(n)(me(o,r)):y}var Ke=new U(Pe);var rl=Array.isArray;function sn(e){return e.length===1&&rl(e[0])?e[0]:e}function L(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){return e.call(t,i,o++)&&n.next(i)}))})}function $t(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e),n=sn(e);return n.length?new U(function(o){var i=n.map(function(){return[]}),a=n.map(function(){return!1});o.add(function(){i=a=null});for(var s=function(l){q(n[l]).subscribe(T(o,function(u){if(i[l].push(u),i.every(function(d){return d.length})){var p=i.map(function(d){return d.shift()});o.next(r?r.apply(void 0,ne([],te(p))):p),i.some(function(d,m){return!d.length&&a[m]})&&o.complete()}},function(){a[l]=!0,!i[l].length&&o.complete()}))},c=0;!o.closed&&c<n.length;c++)s(c);return function(){i=a=null}}):y}function _i(e){return S(function(t,r){var n=!1,o=null,i=null,a=!1,s=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var l=o;o=null,r.next(l)}a&&r.complete()},c=function(){i=null,a&&r.complete()};t.subscribe(T(r,function(l){n=!0,o=l,i||q(e(l)).subscribe(i=T(r,s,c))},function(){a=!0,(!n||!i||i.closed)&&r.complete()}))})}function Xe(e,t){return t===void 0&&(t=ge),_i(function(){return Ve(e,t)})}function Pt(e,t){return t===void 0&&(t=null),t=t!=null?t:e,S(function(r,n){var o=[],i=0;r.subscribe(T(n,function(a){var s,c,l,u,p=null;i++%t===0&&o.push([]);try{for(var d=$e(o),m=d.next();!m.done;m=d.next()){var h=m.value;h.push(a),e<=h.length&&(p=p!=null?p:[],p.push(h))}}catch(w){s={error:w}}finally{try{m&&!m.done&&(c=d.return)&&c.call(d)}finally{if(s)throw s.error}}if(p)try{for(var v=$e(p),x=v.next();!x.done;x=v.next()){var h=x.value;ct(o,h),n.next(h)}}catch(w){l={error:w}}finally{try{x&&!x.done&&(u=v.return)&&u.call(v)}finally{if(l)throw l.error}}},function(){var a,s;try{for(var c=$e(o),l=c.next();!l.done;l=c.next()){var u=l.value;n.next(u)}}catch(p){a={error:p}}finally{try{l&&!l.done&&(s=c.return)&&s.call(c)}finally{if(a)throw a.error}}n.complete()},void 0,function(){o=null}))})}function _e(e){return S(function(t,r){var n=null,o=!1,i;n=t.subscribe(T(r,void 0,void 0,function(a){i=q(e(a,_e(e)(t))),n?(n.unsubscribe(),n=null,i.subscribe(r)):o=!0})),o&&(n.unsubscribe(),n=null,i.subscribe(r))})}function yi(e,t,r,n,o){return function(i,a){var s=r,c=t,l=0;i.subscribe(T(a,function(u){var p=l++;c=s?e(c,u,p):(s=!0,u),n&&a.next(c)},o&&(function(){s&&a.next(c),a.complete()})))}}function Kn(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return r?Jo(Kn.apply(void 0,ne([],te(e))),yt(r)):S(function(n,o){qn(ne([n],te(sn(e))))(o)})}function Ze(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Kn.apply(void 0,ne([],te(e)))}function Tr(e){return S(function(t,r){var n=!1,o=null,i=null,a=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var s=o;o=null,r.next(s)}};t.subscribe(T(r,function(s){i==null||i.unsubscribe(),n=!0,o=s,i=T(r,a,Pe),q(e(s)).subscribe(i)},function(){a(),r.complete()},void 0,function(){o=i=null}))})}function Be(e,t){return t===void 0&&(t=ge),S(function(r,n){var o=null,i=null,a=null,s=function(){if(o){o.unsubscribe(),o=null;var l=i;i=null,n.next(l)}};function c(){var l=a+e,u=t.now();if(u<l){o=this.schedule(void 0,l-u),n.add(o);return}s()}r.subscribe(T(n,function(l){i=l,a=t.now(),o||(o=t.schedule(c,e),n.add(o))},function(){s(),n.complete()},void 0,function(){i=o=null}))})}function ot(e){return S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){n||r.next(e),r.complete()}))})}function Me(e){return e<=0?function(){return y}:S(function(t,r){var n=0;t.subscribe(T(r,function(o){++n<=e&&(r.next(o),e<=n&&r.complete())}))})}function he(){return S(function(e,t){e.subscribe(T(t,Pe))})}function xi(e){return f(function(){return e})}function Bn(e,t){return t?function(r){return nt(t.pipe(Me(1),he()),r.pipe(Bn(e)))}:oe(function(r,n){return q(e(r,n)).pipe(Me(1),xi(r))})}function It(e,t){t===void 0&&(t=ge);var r=Ve(e,t);return Bn(function(){return r})}function Yn(e,t){return S(function(r,n){var o=new Set;r.subscribe(T(n,function(i){var a=e?e(i):i;o.has(a)||(o.add(a),n.next(i))})),t&&q(t).subscribe(T(n,function(){return o.clear()},Pe))})}function ie(e,t){return t===void 0&&(t=Oe),e=e!=null?e:nl,S(function(r,n){var o,i=!0;r.subscribe(T(n,function(a){var s=t(a);(i||!e(o,s))&&(i=!1,o=s,n.next(a))}))})}function nl(e,t){return e===t}function fe(e,t){return ie(function(r,n){return t?t(r[e],n[e]):r[e]===n[e]})}function wi(e){return e===void 0&&(e=ol),S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){return n?r.complete():r.error(e())}))})}function ol(){return new on}function ye(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return function(r){return nt(r,Y.apply(void 0,ne([],te(e))))}}function cn(e,t){return t?function(r){return r.pipe(cn(function(n,o){return q(e(n,o)).pipe(f(function(i,a){return t(n,i,o,a)}))}))}:S(function(r,n){var o=0,i=null,a=!1;r.subscribe(T(n,function(s){i||(i=T(n,void 0,function(){i=null,a&&n.complete()}),q(e(s,o++)).subscribe(i))},function(){a=!0,!i&&n.complete()}))})}function V(e){return S(function(t,r){try{t.subscribe(r)}finally{r.add(e)}})}function Sr(e,t){var r=arguments.length>=2;return function(n){return n.pipe(e?L(function(o,i){return e(o,i,n)}):Oe,Me(1),r?ot(t):wi(function(){return new on}))}}function Gn(e){return e<=0?function(){return y}:S(function(t,r){var n=[];t.subscribe(T(r,function(o){n.push(o),e<n.length&&n.shift()},function(){var o,i;try{for(var a=$e(n),s=a.next();!s.done;s=a.next()){var c=s.value;r.next(c)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}r.complete()},void 0,function(){n=null}))})}function Ei(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0);return S(function(o,i){or(n)(me(ne([o],te(e)),r)).subscribe(i)})}function Rt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Ei.apply(void 0,ne([],te(e)))}function jt(e){var t,r=1/0,n;return e!=null&&(typeof e=="object"?(t=e.count,r=t===void 0?1/0:t,n=e.delay):r=e),r<=0?function(){return y}:S(function(o,i){var a=0,s,c=function(){if(s==null||s.unsubscribe(),s=null,n!=null){var u=typeof n=="number"?Ve(n):q(n(a)),p=T(i,function(){p.unsubscribe(),l()});u.subscribe(p)}else l()},l=function(){var u=!1;s=o.subscribe(T(i,void 0,function(){++a<r?s?c():u=!0:i.complete()})),u&&c()};l()})}function Or(e,t){return S(yi(e,t,arguments.length>=2,!0))}function xe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new I}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,c=s===void 0?!0:s;return function(l){var u,p,d,m=0,h=!1,v=!1,x=function(){p==null||p.unsubscribe(),p=void 0},w=function(){x(),u=d=void 0,h=v=!1},E=function(){var _=u;w(),_==null||_.unsubscribe()};return S(function(_,de){m++,!v&&!h&&x();var be=d=d!=null?d:r();de.add(function(){m--,m===0&&!v&&!h&&(p=Jn(E,c))}),be.subscribe(de),!u&&m>0&&(u=new Ct({next:function(M){return be.next(M)},error:function(M){v=!0,x(),p=Jn(w,o,M),be.error(M)},complete:function(){h=!0,x(),p=Jn(w,a),be.complete()}}),q(_).subscribe(u))})(l)}}function Jn(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];if(t===!0){e();return}if(t!==!1){var o=new Ct({next:function(){o.unsubscribe(),e()}});return q(t.apply(void 0,ne([],te(r)))).subscribe(o)}}function se(e,t,r){var n,o,i,a,s=!1;return e&&typeof e=="object"?(n=e.bufferSize,a=n===void 0?1/0:n,o=e.windowTime,t=o===void 0?1/0:o,i=e.refCount,s=i===void 0?!1:i,r=e.scheduler):a=e!=null?e:1/0,xe({connector:function(){return new wr(a,t,r)},resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:s})}function ke(e){return L(function(t,r){return e<=r})}function J(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return S(function(n,o){(r?nt(e,n,r):nt(e,n)).subscribe(o)})}function g(e,t){return S(function(r,n){var o=null,i=0,a=!1,s=function(){return a&&!o&&n.complete()};r.subscribe(T(n,function(c){o==null||o.unsubscribe();var l=0,u=i++;q(e(c,u)).subscribe(o=T(n,function(p){return n.next(t?t(c,p,u,l++):p)},function(){o=null,s()}))},function(){a=!0,s()}))})}function Q(e){return S(function(t,r){q(e).subscribe(T(r,function(){return r.complete()},Pe)),!r.closed&&t.subscribe(r)})}function Xn(e,t){return t===void 0&&(t=!1),S(function(r,n){var o=0;r.subscribe(T(n,function(i){var a=e(i,o++);(a||t)&&n.next(i),!a&&n.complete()}))})}function $(e,t,r){var n=F(e)||t||r?{next:e,error:t,complete:r}:e;return n?S(function(o,i){var a;(a=n.subscribe)===null||a===void 0||a.call(n);var s=!0;o.subscribe(T(i,function(c){var l;(l=n.next)===null||l===void 0||l.call(n,c),i.next(c)},function(){var c;s=!1,(c=n.complete)===null||c===void 0||c.call(n),i.complete()},function(c){var l;s=!1,(l=n.error)===null||l===void 0||l.call(n,c),i.error(c)},function(){var c,l;s&&((c=n.unsubscribe)===null||c===void 0||c.call(n)),(l=n.finalize)===null||l===void 0||l.call(n)}))}):Oe}function Ti(e,t){return S(function(r,n){var o=t!=null?t:{},i=o.leading,a=i===void 0?!0:i,s=o.trailing,c=s===void 0?!1:s,l=!1,u=null,p=null,d=!1,m=function(){p==null||p.unsubscribe(),p=null,c&&(x(),d&&n.complete())},h=function(){p=null,d&&n.complete()},v=function(w){return p=q(e(w)).subscribe(T(n,m,h))},x=function(){if(l){l=!1;var w=u;u=null,n.next(w),!d&&v(w)}};r.subscribe(T(n,function(w){l=!0,u=w,!(p&&!p.closed)&&(a?x():v(w))},function(){d=!0,!(c&&l&&p&&!p.closed)&&n.complete()}))})}function Lr(e,t,r){t===void 0&&(t=ge);var n=Ve(e,t);return Ti(function(){return n},r)}function pe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return S(function(n,o){for(var i=e.length,a=new Array(i),s=e.map(function(){return!1}),c=!1,l=function(p){q(e[p]).subscribe(T(o,function(d){a[p]=d,!c&&!s[p]&&(s[p]=!0,(c=s.every(Oe))&&(s=null))},Pe))},u=0;u<i;u++)l(u);n.subscribe(T(o,function(p){if(c){var d=ne([p],te(a));o.next(r?r.apply(void 0,ne([],te(d))):d)}}))})}function Si(){let e=new wr(1);return b(document,"DOMContentLoaded",{once:!0}).subscribe(()=>e.next(document)),e}function P(e,t=document){return Array.from(t.querySelectorAll(e))}function G(e,t=document){let r=Le(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function Le(e,t=document){return t.querySelector(e)||void 0}function xt(){var e,t,r,n;return(n=(r=(t=(e=document.activeElement)==null?void 0:e.shadowRoot)==null?void 0:t.activeElement)!=null?r:document.activeElement)!=null?n:void 0}var il=R(b(document.body,"focusin"),b(document.body,"focusout")).pipe(Be(1),J(void 0),f(()=>xt()||document.body),se(1));function ir(e){return il.pipe(f(t=>e.contains(t)),ie())}function Ft(e,t){let{matches:r}=matchMedia("(hover)");return j(()=>(r?R(b(e,"mouseenter").pipe(f(()=>!0)),b(e,"mouseleave").pipe(f(()=>!1))):R(b(e,"touchstart").pipe(f(()=>!0)),b(e,"touchend").pipe(f(()=>!1)),b(e,"touchcancel").pipe(f(()=>!1)))).pipe(t?Tr(o=>Ve(+!o*t)):Oe,J(!0,e.matches(":hover"))))}function Oi(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)Oi(e,r)}function A(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)Oi(n,o);return n}function Li(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function ar(e){let t=A("script",{src:e});return j(()=>(document.head.appendChild(t),R(b(t,"load"),b(t,"error").pipe(g(()=>zn(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(f(()=>{}),V(()=>document.head.removeChild(t)),Me(1))))}var Mi=new I,al=j(()=>typeof ResizeObserver=="undefined"?ar("https://unpkg.com/resize-observer-polyfill"):Y(void 0)).pipe(f(()=>new ResizeObserver(e=>e.forEach(t=>Mi.next(t)))),g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Ae(e){return{width:e.offsetWidth,height:e.offsetHeight}}function Re(e){let t=e;for(;t.clientWidth===0&&t.parentElement;)t=t.parentElement;return al.pipe($(r=>r.observe(t)),g(r=>Mi.pipe(L(n=>n.target===t),V(()=>r.unobserve(t)))),f(()=>Ae(e)),J(Ae(e)))}function Mr(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ki(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}function Ai(e){let t=[],r=e.parentElement;for(;r;)(e.clientWidth>r.clientWidth||e.clientHeight>r.clientHeight)&&t.push(r),r=(e=r).parentElement;return t.length===0&&t.push(document.documentElement),t}function wt(e){return{x:e.offsetLeft,y:e.offsetTop}}function Ci(e){let t=e.getBoundingClientRect();return{x:t.x+window.scrollX,y:t.y+window.scrollY}}function Hi(e){return R(b(window,"load"),b(window,"resize")).pipe(Xe(0,je),f(()=>wt(e)),J(wt(e)))}function ln(e){return{x:e.scrollLeft,y:e.scrollTop}}function Ut(e){return R(b(e,"scroll"),b(window,"scroll"),b(window,"resize")).pipe(Xe(0,je),f(()=>ln(e)),J(ln(e)))}var $i=new I,sl=j(()=>Y(new IntersectionObserver(e=>{for(let t of e)$i.next(t)},{threshold:0}))).pipe(g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Et(e){return sl.pipe($(t=>t.observe(e)),g(t=>$i.pipe(L(({target:r})=>r===e),V(()=>t.unobserve(e)),f(({isIntersecting:r})=>r))))}var cl=Object.create,la=Object.defineProperty,ll=Object.getOwnPropertyDescriptor,ul=Object.getOwnPropertyNames,pl=Object.getPrototypeOf,fl=Object.prototype.hasOwnProperty,ml=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),dl=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of ul(t))!fl.call(e,o)&&o!==r&&la(e,o,{get:()=>t[o],enumerable:!(n=ll(t,o))||n.enumerable});return e},hl=(e,t,r)=>(r=e!=null?cl(pl(e)):{},dl(t||!e||!e.__esModule?la(r,"default",{value:e,enumerable:!0}):r,e)),vl=ml((e,t)=>{var r="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,c=/^0o[0-7]+$/i,l=parseInt,u=typeof global=="object"&&global&&global.Object===Object&&global,p=typeof self=="object"&&self&&self.Object===Object&&self,d=u||p||Function("return this")(),m=Object.prototype,h=m.toString,v=Math.max,x=Math.min,w=function(){return d.Date.now()};function E(O,N,ee){var le,ce,Ne,bt,De,st,tt=0,Yt=!1,Mt=!1,vr=!0;if(typeof O!="function")throw new TypeError(r);N=M(N)||0,_(ee)&&(Yt=!!ee.leading,Mt="maxWait"in ee,Ne=Mt?v(M(ee.maxWait)||0,N):Ne,vr="trailing"in ee?!!ee.trailing:vr);function B(Te){var gt=le,br=ce;return le=ce=void 0,tt=Te,bt=O.apply(br,gt),bt}function C(Te){return tt=Te,De=setTimeout(W,N),Yt?B(Te):bt}function k(Te){var gt=Te-st,br=Te-tt,Ro=N-gt;return Mt?x(Ro,Ne-br):Ro}function D(Te){var gt=Te-st,br=Te-tt;return st===void 0||gt>=N||gt<0||Mt&&br>=Ne}function W(){var Te=w();if(D(Te))return Z(Te);De=setTimeout(W,k(Te))}function Z(Te){return De=void 0,vr&&le?B(Te):(le=ce=void 0,bt)}function We(){De!==void 0&&clearTimeout(De),tt=0,le=st=ce=De=void 0}function Gt(){return De===void 0?bt:Z(w())}function Nr(){var Te=w(),gt=D(Te);if(le=arguments,ce=this,st=Te,gt){if(De===void 0)return C(st);if(Mt)return De=setTimeout(W,N),B(st)}return De===void 0&&(De=setTimeout(W,N)),bt}return Nr.cancel=We,Nr.flush=Gt,Nr}function _(O){var N=typeof O;return!!O&&(N=="object"||N=="function")}function de(O){return!!O&&typeof O=="object"}function be(O){return typeof O=="symbol"||de(O)&&h.call(O)==o}function M(O){if(typeof O=="number")return O;if(be(O))return n;if(_(O)){var N=typeof O.valueOf=="function"?O.valueOf():O;O=_(N)?N+"":N}if(typeof O!="string")return O===0?O:+O;O=O.replace(i,"");var ee=s.test(O);return ee||c.test(O)?l(O.slice(2),ee?2:8):a.test(O)?n:+O}t.exports=E}),yn,K,ua,pa,Nt,Pi,fa,ma,da,lo,to,ro,bl,Ar={},ha=[],gl=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Pr=Array.isArray;function pt(e,t){for(var r in t)e[r]=t[r];return e}function uo(e){e&&e.parentNode&&e.parentNode.removeChild(e)}function Wt(e,t,r){var n,o,i,a={};for(i in t)i=="key"?n=t[i]:i=="ref"?o=t[i]:a[i]=t[i];if(arguments.length>2&&(a.children=arguments.length>3?yn.call(arguments,2):r),typeof e=="function"&&e.defaultProps!=null)for(i in e.defaultProps)a[i]===void 0&&(a[i]=e.defaultProps[i]);return fn(e,a,n,o,null)}function fn(e,t,r,n,o){var i={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:o!=null?o:++ua,__i:-1,__u:0};return o==null&&K.vnode!=null&&K.vnode(i),i}function ft(e){return e.children}function at(e,t){this.props=e,this.context=t}function cr(e,t){if(t==null)return e.__?cr(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null)return r.__e;return typeof e.type=="function"?cr(e):null}function va(e){var t,r;if((e=e.__)!=null&&e.__c!=null){for(e.__e=e.__c.base=null,t=0;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null){e.__e=e.__c.base=r.__e;break}return va(e)}}function Ii(e){(!e.__d&&(e.__d=!0)&&Nt.push(e)&&!vn.__r++||Pi!=K.debounceRendering)&&((Pi=K.debounceRendering)||fa)(vn)}function vn(){for(var e,t,r,n,o,i,a,s=1;Nt.length;)Nt.length>s&&Nt.sort(ma),e=Nt.shift(),s=Nt.length,e.__d&&(r=void 0,n=void 0,o=(n=(t=e).__v).__e,i=[],a=[],t.__P&&((r=pt({},n)).__v=n.__v+1,K.vnode&&K.vnode(r),po(t.__P,r,n,t.__n,t.__P.namespaceURI,32&n.__u?[o]:null,i,o!=null?o:cr(n),!!(32&n.__u),a),r.__v=n.__v,r.__.__k[r.__i]=r,_a(i,r,a),n.__e=n.__=null,r.__e!=o&&va(r)));vn.__r=0}function ba(e,t,r,n,o,i,a,s,c,l,u){var p,d,m,h,v,x,w,E=n&&n.__k||ha,_=t.length;for(c=_l(r,t,E,c,_),p=0;p<_;p++)(m=r.__k[p])!=null&&(d=m.__i==-1?Ar:E[m.__i]||Ar,m.__i=p,x=po(e,m,d,o,i,a,s,c,l,u),h=m.__e,m.ref&&d.ref!=m.ref&&(d.ref&&fo(d.ref,null,m),u.push(m.ref,m.__c||h,m)),v==null&&h!=null&&(v=h),(w=!!(4&m.__u))||d.__k===m.__k?c=ga(m,c,e,w):typeof m.type=="function"&&x!==void 0?c=x:h&&(c=h.nextSibling),m.__u&=-7);return r.__e=v,c}function _l(e,t,r,n,o){var i,a,s,c,l,u=r.length,p=u,d=0;for(e.__k=new Array(o),i=0;i<o;i++)(a=t[i])!=null&&typeof a!="boolean"&&typeof a!="function"?(c=i+d,(a=e.__k[i]=typeof a=="string"||typeof a=="number"||typeof a=="bigint"||a.constructor==String?fn(null,a,null,null,null):Pr(a)?fn(ft,{children:a},null,null,null):a.constructor==null&&a.__b>0?fn(a.type,a.props,a.key,a.ref?a.ref:null,a.__v):a).__=e,a.__b=e.__b+1,s=null,(l=a.__i=yl(a,r,c,p))!=-1&&(p--,(s=r[l])&&(s.__u|=2)),s==null||s.__v==null?(l==-1&&(o>u?d--:o<u&&d++),typeof a.type!="function"&&(a.__u|=4)):l!=c&&(l==c-1?d--:l==c+1?d++:(l>c?d--:d++,a.__u|=4))):e.__k[i]=null;if(p)for(i=0;i<u;i++)(s=r[i])!=null&&!(2&s.__u)&&(s.__e==n&&(n=cr(s)),xa(s,s));return n}function ga(e,t,r,n){var o,i;if(typeof e.type=="function"){for(o=e.__k,i=0;o&&i<o.length;i++)o[i]&&(o[i].__=e,t=ga(o[i],t,r,n));return t}e.__e!=t&&(n&&(t&&e.type&&!t.parentNode&&(t=cr(e)),r.insertBefore(e.__e,t||null)),t=e.__e);do t=t&&t.nextSibling;while(t!=null&&t.nodeType==8);return t}function Cr(e,t){return t=t||[],e==null||typeof e=="boolean"||(Pr(e)?e.some(function(r){Cr(r,t)}):t.push(e)),t}function yl(e,t,r,n){var o,i,a,s=e.key,c=e.type,l=t[r],u=l!=null&&(2&l.__u)==0;if(l===null&&e.key==null||u&&s==l.key&&c==l.type)return r;if(n>(u?1:0)){for(o=r-1,i=r+1;o>=0||i<t.length;)if((l=t[a=o>=0?o--:i++])!=null&&!(2&l.__u)&&s==l.key&&c==l.type)return a}return-1}function Ri(e,t,r){t[0]=="-"?e.setProperty(t,r!=null?r:""):e[t]=r==null?"":typeof r!="number"||gl.test(t)?r:r+"px"}function un(e,t,r,n,o){var i,a;e:if(t=="style")if(typeof r=="string")e.style.cssText=r;else{if(typeof n=="string"&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||Ri(e.style,t,"");if(r)for(t in r)n&&r[t]==n[t]||Ri(e.style,t,r[t])}else if(t[0]=="o"&&t[1]=="n")i=t!=(t=t.replace(da,"$1")),a=t.toLowerCase(),t=a in e||t=="onFocusOut"||t=="onFocusIn"?a.slice(2):t.slice(2),e.l||(e.l={}),e.l[t+i]=r,r?n?r.u=n.u:(r.u=lo,e.addEventListener(t,i?ro:to,i)):e.removeEventListener(t,i?ro:to,i);else{if(o=="http://www.w3.org/2000/svg")t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(t!="width"&&t!="height"&&t!="href"&&t!="list"&&t!="form"&&t!="tabIndex"&&t!="download"&&t!="rowSpan"&&t!="colSpan"&&t!="role"&&t!="popover"&&t in e)try{e[t]=r!=null?r:"";break e}catch(s){}typeof r=="function"||(r==null||r===!1&&t[4]!="-"?e.removeAttribute(t):e.setAttribute(t,t=="popover"&&r==1?"":r))}}function ji(e){return function(t){if(this.l){var r=this.l[t.type+e];if(t.t==null)t.t=lo++;else if(t.t<r.u)return;return r(K.event?K.event(t):t)}}}function po(e,t,r,n,o,i,a,s,c,l){var u,p,d,m,h,v,x,w,E,_,de,be,M,O,N,ee,le,ce=t.type;if(t.constructor!=null)return null;128&r.__u&&(c=!!(32&r.__u),i=[s=t.__e=r.__e]),(u=K.__b)&&u(t);e:if(typeof ce=="function")try{if(w=t.props,E="prototype"in ce&&ce.prototype.render,_=(u=ce.contextType)&&n[u.__c],de=u?_?_.props.value:u.__:n,r.__c?x=(p=t.__c=r.__c).__=p.__E:(E?t.__c=p=new ce(w,de):(t.__c=p=new at(w,de),p.constructor=ce,p.render=wl),_&&_.sub(p),p.props=w,p.state||(p.state={}),p.context=de,p.__n=n,d=p.__d=!0,p.__h=[],p._sb=[]),E&&p.__s==null&&(p.__s=p.state),E&&ce.getDerivedStateFromProps!=null&&(p.__s==p.state&&(p.__s=pt({},p.__s)),pt(p.__s,ce.getDerivedStateFromProps(w,p.__s))),m=p.props,h=p.state,p.__v=t,d)E&&ce.getDerivedStateFromProps==null&&p.componentWillMount!=null&&p.componentWillMount(),E&&p.componentDidMount!=null&&p.__h.push(p.componentDidMount);else{if(E&&ce.getDerivedStateFromProps==null&&w!==m&&p.componentWillReceiveProps!=null&&p.componentWillReceiveProps(w,de),!p.__e&&p.shouldComponentUpdate!=null&&p.shouldComponentUpdate(w,p.__s,de)===!1||t.__v==r.__v){for(t.__v!=r.__v&&(p.props=w,p.state=p.__s,p.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.some(function(Ne){Ne&&(Ne.__=t)}),be=0;be<p._sb.length;be++)p.__h.push(p._sb[be]);p._sb=[],p.__h.length&&a.push(p);break e}p.componentWillUpdate!=null&&p.componentWillUpdate(w,p.__s,de),E&&p.componentDidUpdate!=null&&p.__h.push(function(){p.componentDidUpdate(m,h,v)})}if(p.context=de,p.props=w,p.__P=e,p.__e=!1,M=K.__r,O=0,E){for(p.state=p.__s,p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),N=0;N<p._sb.length;N++)p.__h.push(p._sb[N]);p._sb=[]}else do p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),p.state=p.__s;while(p.__d&&++O<25);p.state=p.__s,p.getChildContext!=null&&(n=pt(pt({},n),p.getChildContext())),E&&!d&&p.getSnapshotBeforeUpdate!=null&&(v=p.getSnapshotBeforeUpdate(m,h)),ee=u,u!=null&&u.type===ft&&u.key==null&&(ee=ya(u.props.children)),s=ba(e,Pr(ee)?ee:[ee],t,r,n,o,i,a,s,c,l),p.base=t.__e,t.__u&=-161,p.__h.length&&a.push(p),x&&(p.__E=p.__=null)}catch(Ne){if(t.__v=null,c||i!=null)if(Ne.then){for(t.__u|=c?160:128;s&&s.nodeType==8&&s.nextSibling;)s=s.nextSibling;i[i.indexOf(s)]=null,t.__e=s}else{for(le=i.length;le--;)uo(i[le]);no(t)}else t.__e=r.__e,t.__k=r.__k,Ne.then||no(t);K.__e(Ne,t,r)}else i==null&&t.__v==r.__v?(t.__k=r.__k,t.__e=r.__e):s=t.__e=xl(r.__e,t,r,n,o,i,a,c,l);return(u=K.diffed)&&u(t),128&t.__u?void 0:s}function no(e){e&&e.__c&&(e.__c.__e=!0),e&&e.__k&&e.__k.forEach(no)}function _a(e,t,r){for(var n=0;n<r.length;n++)fo(r[n],r[++n],r[++n]);K.__c&&K.__c(t,e),e.some(function(o){try{e=o.__h,o.__h=[],e.some(function(i){i.call(o)})}catch(i){K.__e(i,o.__v)}})}function ya(e){return typeof e!="object"||e==null||e.__b&&e.__b>0?e:Pr(e)?e.map(ya):pt({},e)}function xl(e,t,r,n,o,i,a,s,c){var l,u,p,d,m,h,v,x=r.props,w=t.props,E=t.type;if(E=="svg"?o="http://www.w3.org/2000/svg":E=="math"?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),i!=null){for(l=0;l<i.length;l++)if((m=i[l])&&"setAttribute"in m==!!E&&(E?m.localName==E:m.nodeType==3)){e=m,i[l]=null;break}}if(e==null){if(E==null)return document.createTextNode(w);e=document.createElementNS(o,E,w.is&&w),s&&(K.__m&&K.__m(t,i),s=!1),i=null}if(E==null)x===w||s&&e.data==w||(e.data=w);else{if(i=i&&yn.call(e.childNodes),x=r.props||Ar,!s&&i!=null)for(x={},l=0;l<e.attributes.length;l++)x[(m=e.attributes[l]).name]=m.value;for(l in x)if(m=x[l],l!="children"){if(l=="dangerouslySetInnerHTML")p=m;else if(!(l in w)){if(l=="value"&&"defaultValue"in w||l=="checked"&&"defaultChecked"in w)continue;un(e,l,null,m,o)}}for(l in w)m=w[l],l=="children"?d=m:l=="dangerouslySetInnerHTML"?u=m:l=="value"?h=m:l=="checked"?v=m:s&&typeof m!="function"||x[l]===m||un(e,l,m,x[l],o);if(u)s||p&&(u.__html==p.__html||u.__html==e.innerHTML)||(e.innerHTML=u.__html),t.__k=[];else if(p&&(e.innerHTML=""),ba(t.type=="template"?e.content:e,Pr(d)?d:[d],t,r,n,E=="foreignObject"?"http://www.w3.org/1999/xhtml":o,i,a,i?i[0]:r.__k&&cr(r,0),s,c),i!=null)for(l=i.length;l--;)uo(i[l]);s||(l="value",E=="progress"&&h==null?e.removeAttribute("value"):h!=null&&(h!==e[l]||E=="progress"&&!h||E=="option"&&h!=x[l])&&un(e,l,h,x[l],o),l="checked",v!=null&&v!=e[l]&&un(e,l,v,x[l],o))}return e}function fo(e,t,r){try{if(typeof e=="function"){var n=typeof e.__u=="function";n&&e.__u(),n&&t==null||(e.__u=e(t))}else e.current=t}catch(o){K.__e(o,r)}}function xa(e,t,r){var n,o;if(K.unmount&&K.unmount(e),(n=e.ref)&&(n.current&&n.current!=e.__e||fo(n,null,t)),(n=e.__c)!=null){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(i){K.__e(i,t)}n.base=n.__P=null}if(n=e.__k)for(o=0;o<n.length;o++)n[o]&&xa(n[o],t,r||typeof e.type!="function");r||uo(e.__e),e.__c=e.__=e.__e=void 0}function wl(e,t,r){return this.constructor(e,r)}function El(e,t,r){var n,o,i,a;t==document&&(t=document.documentElement),K.__&&K.__(e,t),o=(n=typeof r=="function")?null:r&&r.__k||t.__k,i=[],a=[],po(t,e=(!n&&r||t).__k=Wt(ft,null,[e]),o||Ar,Ar,t.namespaceURI,!n&&r?[r]:o?null:t.firstChild?yn.call(t.childNodes):null,i,!n&&r?r:o?o.__e:t.firstChild,n,a),_a(i,e,a)}yn=ha.slice,K={__e:function(e,t,r,n){for(var o,i,a;t=t.__;)if((o=t.__c)&&!o.__)try{if((i=o.constructor)&&i.getDerivedStateFromError!=null&&(o.setState(i.getDerivedStateFromError(e)),a=o.__d),o.componentDidCatch!=null&&(o.componentDidCatch(e,n||{}),a=o.__d),a)return o.__E=o}catch(s){e=s}throw e}},ua=0,pa=function(e){return e!=null&&e.constructor==null},at.prototype.setState=function(e,t){var r;r=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=pt({},this.state),typeof e=="function"&&(e=e(pt({},r),this.props)),e&&pt(r,e),e!=null&&this.__v&&(t&&this._sb.push(t),Ii(this))},at.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),Ii(this))},at.prototype.render=ft,Nt=[],fa=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,ma=function(e,t){return e.__v.__b-t.__v.__b},vn.__r=0,da=/(PointerCapture)$|Capture$/i,lo=0,to=ji(!1),ro=ji(!0),bl=0;var Hr,ve,Zn,Fi,$r=0,wa=[],we=K,Ui=we.__b,Ni=we.__r,Di=we.diffed,Wi=we.__c,Vi=we.unmount,zi=we.__;function mo(e,t){we.__h&&we.__h(ve,e,$r||t),$r=0;var r=ve.__H||(ve.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({}),r.__[e]}function bn(e){return $r=1,Tl(Ta,e)}function Tl(e,t,r){var n=mo(Hr++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):Ta(void 0,t),function(s){var c=n.__N?n.__N[0]:n.__[0],l=n.t(c,s);c!==l&&(n.__N=[l,n.__[1]],n.__c.setState({}))}],n.__c=ve,!ve.__f)){var o=function(s,c,l){if(!n.__c.__H)return!0;var u=n.__c.__H.__.filter(function(d){return!!d.__c});if(u.every(function(d){return!d.__N}))return!i||i.call(this,s,c,l);var p=n.__c.props!==s;return u.forEach(function(d){if(d.__N){var m=d.__[0];d.__=d.__N,d.__N=void 0,m!==d.__[0]&&(p=!0)}}),i&&i.call(this,s,c,l)||p};ve.__f=!0;var i=ve.shouldComponentUpdate,a=ve.componentWillUpdate;ve.componentWillUpdate=function(s,c,l){if(this.__e){var u=i;i=void 0,o(s,c,l),i=u}a&&a.call(this,s,c,l)},ve.shouldComponentUpdate=o}return n.__N||n.__}function mt(e,t){var r=mo(Hr++,3);!we.__s&&Ea(r.__H,t)&&(r.__=e,r.u=t,ve.__H.__h.push(r))}function Vt(e){return $r=5,ur(function(){return{current:e}},[])}function ur(e,t){var r=mo(Hr++,7);return Ea(r.__H,t)&&(r.__=e(),r.__H=t,r.__h=e),r.__}function Sl(e,t){return $r=8,ur(function(){return e},t)}function Ol(){for(var e;e=wa.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(mn),e.__H.__h.forEach(oo),e.__H.__h=[]}catch(t){e.__H.__h=[],we.__e(t,e.__v)}}we.__b=function(e){ve=null,Ui&&Ui(e)},we.__=function(e,t){e&&t.__k&&t.__k.__m&&(e.__m=t.__k.__m),zi&&zi(e,t)},we.__r=function(e){Ni&&Ni(e),Hr=0;var t=(ve=e.__c).__H;t&&(Zn===ve?(t.__h=[],ve.__h=[],t.__.forEach(function(r){r.__N&&(r.__=r.__N),r.u=r.__N=void 0})):(t.__h.forEach(mn),t.__h.forEach(oo),t.__h=[],Hr=0)),Zn=ve},we.diffed=function(e){Di&&Di(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(wa.push(t)!==1&&Fi===we.requestAnimationFrame||((Fi=we.requestAnimationFrame)||Ll)(Ol)),t.__H.__.forEach(function(r){r.u&&(r.__H=r.u),r.u=void 0})),Zn=ve=null},we.__c=function(e,t){t.some(function(r){try{r.__h.forEach(mn),r.__h=r.__h.filter(function(n){return!n.__||oo(n)})}catch(n){t.some(function(o){o.__h&&(o.__h=[])}),t=[],we.__e(n,r.__v)}}),Wi&&Wi(e,t)},we.unmount=function(e){Vi&&Vi(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{mn(n)}catch(o){t=o}}),r.__H=void 0,t&&we.__e(t,r.__v))};var qi=typeof requestAnimationFrame=="function";function Ll(e){var t,r=function(){clearTimeout(n),qi&&cancelAnimationFrame(t),setTimeout(e)},n=setTimeout(r,35);qi&&(t=requestAnimationFrame(r))}function mn(e){var t=ve,r=e.__c;typeof r=="function"&&(e.__c=void 0,r()),ve=t}function oo(e){var t=ve;e.__c=e.__(),ve=t}function Ea(e,t){return!e||e.length!==t.length||t.some(function(r,n){return r!==e[n]})}function Ta(e,t){return typeof t=="function"?t(e):t}function Ml(e,t){for(var r in t)e[r]=t[r];return e}function Ki(e,t){for(var r in e)if(r!=="__source"&&!(r in t))return!0;for(var n in t)if(n!=="__source"&&e[n]!==t[n])return!0;return!1}function Bi(e,t){this.props=e,this.context=t}(Bi.prototype=new at).isPureReactComponent=!0,Bi.prototype.shouldComponentUpdate=function(e,t){return Ki(this.props,e)||Ki(this.state,t)};var Yi=K.__b;K.__b=function(e){e.type&&e.type.__f&&e.ref&&(e.props.ref=e.ref,e.ref=null),Yi&&Yi(e)};var Yx=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911,kl=K.__e;K.__e=function(e,t,r,n){if(e.then){for(var o,i=t;i=i.__;)if((o=i.__c)&&o.__c)return t.__e==null&&(t.__e=r.__e,t.__k=r.__k),o.__c(e,t)}kl(e,t,r,n)};var Gi=K.unmount;function Sa(e,t,r){return e&&(e.__c&&e.__c.__H&&(e.__c.__H.__.forEach(function(n){typeof n.__c=="function"&&n.__c()}),e.__c.__H=null),(e=Ml({},e)).__c!=null&&(e.__c.__P===r&&(e.__c.__P=t),e.__c.__e=!0,e.__c=null),e.__k=e.__k&&e.__k.map(function(n){return Sa(n,t,r)})),e}function Oa(e,t,r){return e&&r&&(e.__v=null,e.__k=e.__k&&e.__k.map(function(n){return Oa(n,t,r)}),e.__c&&e.__c.__P===t&&(e.__e&&r.appendChild(e.__e),e.__c.__e=!0,e.__c.__P=r)),e}function Qn(){this.__u=0,this.o=null,this.__b=null}function La(e){var t=e.__.__c;return t&&t.__a&&t.__a(e)}function pn(){this.i=null,this.l=null}K.unmount=function(e){var t=e.__c;t&&t.__R&&t.__R(),t&&32&e.__u&&(e.type=null),Gi&&Gi(e)},(Qn.prototype=new at).__c=function(e,t){var r=t.__c,n=this;n.o==null&&(n.o=[]),n.o.push(r);var o=La(n.__v),i=!1,a=function(){i||(i=!0,r.__R=null,o?o(s):s())};r.__R=a;var s=function(){if(!--n.__u){if(n.state.__a){var c=n.state.__a;n.__v.__k[0]=Oa(c,c.__c.__P,c.__c.__O)}var l;for(n.setState({__a:n.__b=null});l=n.o.pop();)l.forceUpdate()}};n.__u++||32&t.__u||n.setState({__a:n.__b=n.__v.__k[0]}),e.then(a,a)},Qn.prototype.componentWillUnmount=function(){this.o=[]},Qn.prototype.render=function(e,t){if(this.__b){if(this.__v.__k){var r=document.createElement("div"),n=this.__v.__k[0].__c;this.__v.__k[0]=Sa(this.__b,r,n.__O=n.__P)}this.__b=null}var o=t.__a&&Wt(ft,null,e.fallback);return o&&(o.__u&=-33),[Wt(ft,null,t.__a?null:e.children),o]};var Ji=function(e,t,r){if(++r[1]===r[0]&&e.l.delete(t),e.props.revealOrder&&(e.props.revealOrder[0]!=="t"||!e.l.size))for(r=e.i;r;){for(;r.length>3;)r.pop()();if(r[1]<r[0])break;e.i=r=r[2]}};(pn.prototype=new at).__a=function(e){var t=this,r=La(t.__v),n=t.l.get(e);return n[0]++,function(o){var i=function(){t.props.revealOrder?(n.push(o),Ji(t,e,n)):o()};r?r(i):i()}},pn.prototype.render=function(e){this.i=null,this.l=new Map;var t=Cr(e.children);e.revealOrder&&e.revealOrder[0]==="b"&&t.reverse();for(var r=t.length;r--;)this.l.set(t[r],this.i=[1,0,this.i]);return e.children},pn.prototype.componentDidUpdate=pn.prototype.componentDidMount=function(){var e=this;this.l.forEach(function(t,r){Ji(e,r,t)})};var Al=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,Cl=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,Hl=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,$l=/[A-Z0-9]/g,Pl=typeof document<"u",Il=function(e){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(e)};at.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(e){Object.defineProperty(at.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})});var Xi=K.event;function Rl(){}function jl(){return this.cancelBubble}function Fl(){return this.defaultPrevented}K.event=function(e){return Xi&&(e=Xi(e)),e.persist=Rl,e.isPropagationStopped=jl,e.isDefaultPrevented=Fl,e.nativeEvent=e};var Ma,Ul={enumerable:!1,configurable:!0,get:function(){return this.class}},Zi=K.vnode;K.vnode=function(e){typeof e.type=="string"&&(function(t){var r=t.props,n=t.type,o={},i=n.indexOf("-")===-1;for(var a in r){var s=r[a];if(!(a==="value"&&"defaultValue"in r&&s==null||Pl&&a==="children"&&n==="noscript"||a==="class"||a==="className")){var c=a.toLowerCase();a==="defaultValue"&&"value"in r&&r.value==null?a="value":a==="download"&&s===!0?s="":c==="translate"&&s==="no"?s=!1:c[0]==="o"&&c[1]==="n"?c==="ondoubleclick"?a="ondblclick":c!=="onchange"||n!=="input"&&n!=="textarea"||Il(r.type)?c==="onfocus"?a="onfocusin":c==="onblur"?a="onfocusout":Hl.test(a)&&(a=c):c=a="oninput":i&&Cl.test(a)?a=a.replace($l,"-$&").toLowerCase():s===null&&(s=void 0),c==="oninput"&&o[a=c]&&(a="oninputCapture"),o[a]=s}}n=="select"&&o.multiple&&Array.isArray(o.value)&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.value.indexOf(l.props.value)!=-1})),n=="select"&&o.defaultValue!=null&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.multiple?o.defaultValue.indexOf(l.props.value)!=-1:o.defaultValue==l.props.value})),r.class&&!r.className?(o.class=r.class,Object.defineProperty(o,"className",Ul)):(r.className&&!r.class||r.class&&r.className)&&(o.class=o.className=r.className),t.props=o})(e),e.$$typeof=Al,Zi&&Zi(e)};var Qi=K.__r;K.__r=function(e){Qi&&Qi(e),Ma=e.__c};var ea=K.diffed;K.diffed=function(e){ea&&ea(e);var t=e.props,r=e.__e;r!=null&&e.type==="textarea"&&"value"in t&&t.value!==r.value&&(r.value=t.value==null?"":t.value),Ma=null};function ka(e){let t=Vt(e);return t.current=e,ur(()=>Object.freeze({get current(){return t.current}}),[])}var Nl=typeof globalThis<"u"&&typeof navigator<"u"&&typeof document<"u";function Dl(e,...t){var r;(r=e==null?void 0:e.addEventListener)==null||r.call(e,...t)}function Wl(e,...t){var r;(r=e==null?void 0:e.removeEventListener)==null||r.call(e,...t)}var Vl=(e,t)=>Object.hasOwn(e,t),zl=()=>!0,ql=()=>!1;function Kl(e=!1){let t=Vt(e),r=Sl(()=>t.current,[]);return mt(()=>(t.current=!0,()=>{t.current=!1}),[]),r}function Bl(e,...t){let r=Kl(),n=ka(t[1]),o=ur(()=>function(...i){r()&&(typeof n.current=="function"?n.current.apply(this,i):typeof n.current.handleEvent=="function"&&n.current.handleEvent.apply(this,i))},[]);mt(()=>{let i=Yl(e)?e.current:e;if(!i)return;let a=t.slice(2);return Dl(i,t[0],o,...a),()=>{Wl(i,t[0],o,...a)}},[e,t[0]])}function Yl(e){return e!==null&&typeof e=="object"&&Vl(e,"current")}var Gl=e=>typeof e=="function"?e:typeof e=="string"?t=>t.key===e:e?zl:ql,Jl=Nl?globalThis:null;function Aa(e,t,r=[],n={}){let{event:o="keydown",target:i=Jl,eventOptions:a}=n,s=ka(t),c=ur(()=>{let l=Gl(e);return function(u){l(u)&&s.current.call(this,u)}},r);Bl(i,o,c,a)}function Ca(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(r=Ca(e[t]))&&(n&&(n+=" "),n+=r)}else for(r in e)e[r]&&(n&&(n+=" "),n+=r);return n}function Xl(){for(var e,t,r=0,n="",o=arguments.length;r<o;r++)(e=arguments[r])&&(t=Ca(e))&&(n&&(n+=" "),n+=t);return n}var zt=Xl,Zl=Symbol.for("preact-signals");function xn(){if(St>1)St--;else{for(var e,t=!1;kr!==void 0;){var r=kr;for(kr=void 0,io++;r!==void 0;){var n=r.o;if(r.o=void 0,r.f&=-3,!(8&r.f)&&Pa(r))try{r.c()}catch(o){t||(e=o,t=!0)}r=n}}if(io=0,St--,t)throw e}}function Ql(e){if(St>0)return e();St++;try{return e()}finally{xn()}}var ae=void 0;function Ha(e){var t=ae;ae=void 0;try{return e()}finally{ae=t}}var kr=void 0,St=0,io=0,gn=0;function $a(e){if(ae!==void 0){var t=e.n;if(t===void 0||t.t!==ae)return t={i:0,S:e,p:ae.s,n:void 0,t:ae,e:void 0,x:void 0,r:t},ae.s!==void 0&&(ae.s.n=t),ae.s=t,e.n=t,32&ae.f&&e.S(t),t;if(t.i===-1)return t.i=0,t.n!==void 0&&(t.n.p=t.p,t.p!==void 0&&(t.p.n=t.n),t.p=ae.s,t.n=void 0,ae.s.n=t,ae.s=t),t}}function Ce(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Ce.prototype.brand=Zl;Ce.prototype.h=function(){return!0};Ce.prototype.S=function(e){var t=this,r=this.t;r!==e&&e.e===void 0&&(e.x=r,this.t=e,r!==void 0?r.e=e:Ha(function(){var n;(n=t.W)==null||n.call(t)}))};Ce.prototype.U=function(e){var t=this;if(this.t!==void 0){var r=e.e,n=e.x;r!==void 0&&(r.x=n,e.e=void 0),n!==void 0&&(n.e=r,e.x=void 0),e===this.t&&(this.t=n,n===void 0&&Ha(function(){var o;(o=t.Z)==null||o.call(t)}))}};Ce.prototype.subscribe=function(e){var t=this;return qt(function(){var r=t.value,n=ae;ae=void 0;try{e(r)}finally{ae=n}},{name:"sub"})};Ce.prototype.valueOf=function(){return this.value};Ce.prototype.toString=function(){return this.value+""};Ce.prototype.toJSON=function(){return this.value};Ce.prototype.peek=function(){var e=ae;ae=void 0;try{return this.value}finally{ae=e}};Object.defineProperty(Ce.prototype,"value",{get:function(){var e=$a(this);return e!==void 0&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(io>100)throw new Error("Cycle detected");this.v=e,this.i++,gn++,St++;try{for(var t=this.t;t!==void 0;t=t.x)t.t.N()}finally{xn()}}}});function Ot(e,t){return new Ce(e,t)}function Pa(e){for(var t=e.s;t!==void 0;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function Ia(e){for(var t=e.s;t!==void 0;t=t.n){var r=t.S.n;if(r!==void 0&&(t.r=r),t.S.n=t,t.i=-1,t.n===void 0){e.s=t;break}}}function Ra(e){for(var t=e.s,r=void 0;t!==void 0;){var n=t.p;t.i===-1?(t.S.U(t),n!==void 0&&(n.n=t.n),t.n!==void 0&&(t.n.p=n)):r=t,t.S.n=t.r,t.r!==void 0&&(t.r=void 0),t=n}e.s=r}function Kt(e,t){Ce.call(this,void 0),this.x=e,this.s=void 0,this.g=gn-1,this.f=4,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Kt.prototype=new Ce;Kt.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if((36&this.f)==32||(this.f&=-5,this.g===gn))return!0;if(this.g=gn,this.f|=1,this.i>0&&!Pa(this))return this.f&=-2,!0;var e=ae;try{Ia(this),ae=this;var t=this.x();(16&this.f||this.v!==t||this.i===0)&&(this.v=t,this.f&=-17,this.i++)}catch(r){this.v=r,this.f|=16,this.i++}return ae=e,Ra(this),this.f&=-2,!0};Kt.prototype.S=function(e){if(this.t===void 0){this.f|=36;for(var t=this.s;t!==void 0;t=t.n)t.S.S(t)}Ce.prototype.S.call(this,e)};Kt.prototype.U=function(e){if(this.t!==void 0&&(Ce.prototype.U.call(this,e),this.t===void 0)){this.f&=-33;for(var t=this.s;t!==void 0;t=t.n)t.S.U(t)}};Kt.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;e!==void 0;e=e.x)e.t.N()}};Object.defineProperty(Kt.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var e=$a(this);if(this.h(),e!==void 0&&(e.i=this.i),16&this.f)throw this.v;return this.v}});function ta(e,t){return new Kt(e,t)}function ja(e){var t=e.u;if(e.u=void 0,typeof t=="function"){St++;var r=ae;ae=void 0;try{t()}catch(n){throw e.f&=-2,e.f|=8,ho(e),n}finally{ae=r,xn()}}}function ho(e){for(var t=e.s;t!==void 0;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,ja(e)}function eu(e){if(ae!==this)throw new Error("Out-of-order effect");Ra(this),ae=e,this.f&=-2,8&this.f&&ho(this),xn()}function pr(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=t==null?void 0:t.name}pr.prototype.c=function(){var e=this.S();try{if(8&this.f||this.x===void 0)return;var t=this.x();typeof t=="function"&&(this.u=t)}finally{e()}};pr.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1,this.f&=-9,ja(this),Ia(this),St++;var e=ae;return ae=this,eu.bind(this,e)};pr.prototype.N=function(){2&this.f||(this.f|=2,this.o=kr,kr=this)};pr.prototype.d=function(){this.f|=8,1&this.f||ho(this)};pr.prototype.dispose=function(){this.d()};function qt(e,t){var r=new pr(e,t);try{r.c()}catch(o){throw r.d(),o}var n=r.d.bind(r);return n[Symbol.dispose]=n,n}var Fa,vo,eo,Ua=[];qt(function(){Fa=this.N})();function fr(e,t){K[e]=t.bind(null,K[e]||function(){})}function _n(e){eo&&eo(),eo=e&&e.S()}function Na(e){var t=this,r=e.data,n=ru(r);n.value=r;var o=ur(function(){for(var s=t,c=t.__v;c=c.__;)if(c.__c){c.__c.__$f|=4;break}var l=ta(function(){var m=n.value.value;return m===0?0:m===!0?"":m||""}),u=ta(function(){return!Array.isArray(l.value)&&!pa(l.value)}),p=qt(function(){if(this.N=Da,u.value){var m=l.value;s.__v&&s.__v.__e&&s.__v.__e.nodeType===3&&(s.__v.__e.data=m)}}),d=t.__$u.d;return t.__$u.d=function(){p(),d.call(this)},[u,l]},[]),i=o[0],a=o[1];return i.value?a.peek():a.value}Na.displayName="ReactiveTextNode";Object.defineProperties(Ce.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:Na},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});fr("__b",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),typeof t.type=="string"){var r,n=t.props;for(var o in n)if(o!=="children"){var i=n[o];i instanceof Ce&&(r||(t.__np=r={}),r[o]=i,n[o]=i.peek())}}e(t)});fr("__r",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.enterComponent(t),t.type!==ft){_n();var r,n=t.__c;n&&(n.__$f&=-2,(r=n.__$u)===void 0&&(n.__$u=r=(function(o){var i;return qt(function(){i=this}),i.c=function(){n.__$f|=1,n.setState({})},i})())),vo=n,_n(r)}e(t)});fr("__e",function(e,t,r,n){typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0,e(t,r,n)});fr("diffed",function(e,t){typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0;var r;if(typeof t.type=="string"&&(r=t.__e)){var n=t.__np,o=t.props;if(n){var i=r.U;if(i)for(var a in i){var s=i[a];s!==void 0&&!(a in n)&&(s.d(),i[a]=void 0)}else i={},r.U=i;for(var c in n){var l=i[c],u=n[c];l===void 0?(l=tu(r,c,u,o),i[c]=l):l.o(u,o)}}}e(t)});function tu(e,t,r,n){var o=t in e&&e.ownerSVGElement===void 0,i=Ot(r);return{o:function(a,s){i.value=a,n=s},d:qt(function(){this.N=Da;var a=i.value.value;n[t]!==a&&(n[t]=a,o?e[t]=a:a?e.setAttribute(t,a):e.removeAttribute(t))})}}fr("unmount",function(e,t){if(typeof t.type=="string"){var r=t.__e;if(r){var n=r.U;if(n){r.U=void 0;for(var o in n){var i=n[o];i&&i.d()}}}}else{var a=t.__c;if(a){var s=a.__$u;s&&(a.__$u=void 0,s.d())}}e(t)});fr("__h",function(e,t,r,n){(n<3||n===9)&&(t.__$f|=2),e(t,r,n)});at.prototype.shouldComponentUpdate=function(e,t){var r=this.__$u,n=r&&r.s!==void 0;for(var o in t)return!0;if(this.__f||typeof this.u=="boolean"&&this.u===!0){var i=2&this.__$f;if(!(n||i||4&this.__$f)||1&this.__$f)return!0}else if(!(n||4&this.__$f)||3&this.__$f)return!0;for(var a in e)if(a!=="__source"&&e[a]!==this.props[a])return!0;for(var s in this.props)if(!(s in e))return!0;return!1};function ru(e,t){return bn(function(){return Ot(e,t)})[0]}var nu=function(e){queueMicrotask(function(){queueMicrotask(e)})};function ou(){Ql(function(){for(var e;e=Ua.shift();)Fa.call(e)})}function Da(){Ua.push(this)===1&&(K.requestAnimationFrame||nu)(ou)}var ao=[0];for(let e=0;e<32;e++)ao.push(ao[e]|1<<e);function iu(e){return new Uint32Array(e)}var ra=class{constructor(e,t=iu(Math.ceil(e/32))){this.size=e,this.data=t}get(e){return this.data[e>>>5]>>>e&1}set(e){this.data[e>>>5]|=1<<(e&31)}forEach(e){let t=this.size&31;for(let r=0;r<this.data.length;r++){if(this.data[r]===0)continue;let n=this.data[r];t&&r===this.data.length-1&&(n=n&ao[t]);for(let o=0,i=32-Math.clz32(n);o<i;o++)n&1<<o&&e((r<<5)+o)}}};function au(e){lr.value=e,e.items.find(t=>{var r;return(r=t.tags)==null?void 0:r.length})&&(matchMedia("(max-width: 768px)").matches||Wa())}function Dt(){Qe.value=He(H({},Qe.value),{hideSearch:!Qe.value.hideSearch})}function Wa(){Qe.value=He(H({},Qe.value),{hideFilters:!Qe.value.hideFilters})}function dn(){return Qe.value.selectedItem}function so(e){Qe.value=He(H({},Qe.value),{selectedItem:e})}function su(){var e,t;return(t=(e=lr.value)==null?void 0:e.items)!=null?t:[]}function wn(){return typeof Se.value.input=="string"?Se.value.input:""}function Va(e){let t=za();e.length&&!t.length?Se.value=He(H({},Se.value),{page:void 0,input:e}):!e.length&&t.length?Se.value=He(H({},Se.value),{page:void 0,input:{type:"operator",data:{operator:"not",operands:[]}}}):Se.value=He(H({},Se.value),{page:void 0,input:e})}function cu(){typeof it.value.pagination.next<"u"&&(Se.value=He(H({},Se.value),{page:it.value.pagination.next}))}function lu(e){let t=Se.value.filter.input;if("type"in t&&t.type==="operator"){for(let r of t.data.operands)if("type"in r&&r.type==="value"&&typeof r.data.value=="string"&&r.data.value===e)return!0}return!1}function za(){let e=Se.value.filter.input,t=[];if("type"in e&&e.type==="operator")for(let r of e.data.operands)"type"in r&&r.type==="value"&&typeof r.data.value=="string"&&t.push(r.data.value);return t}function uu(e){let t=Se.value.filter.input,r=[];if("type"in t&&t.type==="operator")for(let n of t.data.operands)"type"in n&&n.type==="value"&&typeof n.data.value=="string"&&r.push(n.data.value);if(r.includes(e)){let n=r.indexOf(e);n>-1&&r.splice(n,1)}else r.push(e);Se.value=He(H({},Se.value),{page:void 0,filter:He(H({},Se.value.filter),{input:{type:"operator",data:{operator:"and",operands:r.map(n=>({type:"value",data:{field:"tags",value:n}}))}}})}),Va(wn())}function pu(){return it.value.items}function fu(){return it.value.total}function mu(){var e;for(let t of(e=it.value.aggregations)!=null?e:[])if(t.type==="term")return t.data.value;return[]}function sr(){return Qe.value.hideSearch}function du(){return Qe.value.hideFilters}function qa(){var e;return(e=Ka.value.highlight)!=null?e:!1}var Qe=Ot({hideSearch:!0,hideFilters:!0,selectedItem:0}),Ka=Ot({}),lr=Ot(),na=Ot(),Se=Ot({input:"",filter:{input:{type:"operator",data:{operator:"and",operands:[]}},aggregation:{input:[{type:"term",data:{field:"tags"}}]}}}),it=Ot({items:[],query:{select:{documents:new ra(0),terms:new ra(0)},values:[]},pagination:{total:0}});function hu(e,t,r){for(let n=0;t<r;){switch(n=n<<8^32|e.charCodeAt(++t),n){case 97:case 98:case 99:case 101:case 104:case 105:case 108:case 109:case 112:case 115:case 116:case 119:case 24946:case 25185:case 25455:case 25965:case 26989:case 26990:case 27753:case 28005:case 28769:case 29551:case 29810:case 30562:case 6386277:case 6447475:case 6647138:case 6909552:case 7104878:case 7169396:case 7364978:case 7565173:case 7631457:case 1701667429:case 1768845429:case 1869967971:case 1885434465:case 1936684402:case 1953653091:continue;case 25202:case 26738:case 6516588:case 6909287:case 7823986:case 1634885997:case 1634887009:case 1650553701:case 1818848875:case 1835165028:case 1835365473:case 1852863860:case 1918985067:case 1970430821:switch(e.charCodeAt(++t)){case 9:case 10:case 32:case 47:case 62:return!0}}break}return!1}function vu(e,t,r=0,n=e.length){let o=0,i=r;for(let a=0;i<n;i++)switch(a=e.charCodeAt(i),a){case 60:i>r&&t(0,o,r,r=i);continue;case 62:e.charCodeAt(r+1)===47?t(2,--o,r,r=i+1):hu(e,r,n)?t(3,o,r,r=i+1):t(1,o++,r,r=i+1)}i>r&&t(0,o,r,i)}function bu(e,t=0,r=e.length){let n=++t;e:for(let l=0;n<r;n++)switch(l=e.charCodeAt(n),l){case 9:case 10:case 32:case 62:break e}let o=e.slice(t,t=n),i=[],a=0,s=0,c=0;for(let l=0;n<r;n++){let u=e.charCodeAt(n);switch(a){case 0:switch(u){case 9:case 10:case 32:t===n?t++:(s=1,a=1);break;case 61:s=1,a=2;break;case 47:t++;case 62:t<n&&(s=1);break}break;case 1:switch(u){case 9:case 10:case 32:continue;case 61:a=2,t=n+1;continue;default:a=0,t=n,l++}continue;case 2:switch(u){case 9:case 10:case 32:t===n?t++:c===0&&(s=2,a=0);break;case 34:case 39:switch(c){case 0:c=u,t=n+1;continue;case u:s=2,a=0,c=0}break;case 62:t<n&&(s=2);break}}switch(s){case 1:i[l]=[e.slice(t,n),""],s=0,t=n+1;break;case 2:i[l++][1]=e.slice(t,n),s=0,t=n+1;break}}return{tag:o,attrs:i.length?Object.fromEntries(i):null}}function gu(e,t,r){return e.slice(t,r)}function _u(e){return(t,r,n,o)=>{let i=[],a=[],{onElement:s,onText:c=gu}=typeof r=="function"?{onElement:r}:r,l=0,u=0;return e(t,(p,d,m,h)=>{if(p===0)i[l++]=c(t,m,h),a[u++]={value:null,depth:d};else if(p&1&&(a[u++]={value:bu(t,m,h),depth:d}),p&2)for(let v=0;u>=0;v++){let{value:x,depth:w}=a[--u];if(w>d)continue;let E=i.slice(l-=v,l+v);i[l++]=s(x,E),u++;break}},n,o),i.slice(0,l)}}function yu(e){return e.replace(/[&<>]/g,t=>{switch(t.charCodeAt(0)){case 38:return"&amp;";case 60:return"&lt;";case 62:return"&gt;"}})}function hn(e){return e.replace(/&(amp|[lg]t);/g,t=>{switch(t.charCodeAt(1)){case 97:return"&";case 108:return"<";case 103:return">"}})}function xu(e,t){return{start:e.start+t,end:e.end+t,value:e.value}}function wu(e,t,r){return e.slice(t,r)}function Eu(e){let{onHighlight:t,onText:r=wu}=typeof e=="function"?{onHighlight:e}:e;return(n,o,i=0,a=n.length)=>{var l;let s=[],c=(l=o==null?void 0:o.ranges)!=null?l:[];for(let u=0,p=i;u<c.length;u++){let d=c[u].start;if(d>a)break;let m=c[u].end;if(m<p)continue;d=Math.max(d,i),m=Math.min(m,a),d>i&&s.push(r(n,i,d));let{value:h}=c[u];s.push(t(n,{start:d,end:i=m,value:h}))}return i<a&&s.push(r(n,i,a)),s}}var Tu={fuzzy:"v"},Su=0;function z(e,t,r,n,o,i){t||(t={});var a,s,c=t;if("ref"in c)for(s in c={},t)s=="ref"?a=t[s]:c[s]=t[s];var l={type:e,props:c,key:r,ref:a,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--Su,__i:-1,__u:0,__source:o,__self:i};if(typeof e=="function"&&(a=e.defaultProps))for(s in a)c[s]===void 0&&(c[s]=a[s]);return K.vnode&&K.vnode(l),l}var Ou=_u(vu),Lu=Eu({onText(e,t,r){return hn(e.slice(t,r))},onHighlight(e,{start:t,end:r,value:n}){let o=Math.min(r,t+n);return t===r?null:(n===-1&&(o=r),z("mark",{className:zt({[Tu.fuzzy]:n===-1}),children:[z("u",{children:hn(e.slice(t,o))}),hn(e.slice(o,r))]}))}});function Ba(e,t){let r=Ou(e,{onElement(n,o){return Wt(n.tag,n.attrs,...o)},onText(n,o,i){return Lu(n,t==null?void 0:t.value.highlight,o,i)}});return z(ft,{children:r})}function Mu(e,t){var n;let r=[];for(let o=0,i=0;o<e.length;o++){let a=[];if((n=t==null?void 0:t.value.highlight)!=null&&n.ranges)for(let s of t.value.highlight.ranges)a.push(xu(s,-i));r.push(Ba(e[o],He(H({},t),{value:He(H({},t==null?void 0:t.value),{highlight:{ranges:a}})}))),i+=e[o].length}return r}function Ya(e,t={highlight:!0}){Ka.value=t;let r=new Worker(e);r.onmessage=n=>{let o=n.data;switch(o.type){case 1:na.value=!0;break;case 3:typeof o.data.pagination.prev<"u"?it.value=He(H({},it.value),{pagination:o.data.pagination,items:[...it.value.items,...o.data.items]}):(it.value=o.data,so(0));break}},qt(()=>{lr.value&&r.postMessage({type:0,data:lr.value})}),qt(()=>{na.value&&r.postMessage({type:2,data:Se.value})})}var oa={container:"p",hidden:"m"};function ku(e){return z("div",{class:zt(oa.container,{[oa.hidden]:e.hidden}),onClick:()=>Dt()})}var ia={container:"r",disabled:"c"};function co(e){return z("button",{class:zt(ia.container,{[ia.disabled]:!e.onClick}),onClick:e.onClick,children:e.children})}var aa=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),Au=e=>e.replace(/^([A-Z])|[\s-_]+(\w)/g,(t,r,n)=>n?n.toUpperCase():r.toLowerCase()),sa=e=>{let t=Au(e);return t.charAt(0).toUpperCase()+t.slice(1)},Cu=(...e)=>e.filter((t,r,n)=>!!t&&t.trim()!==""&&n.indexOf(t)===r).join(" ").trim(),Hu={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},$u=c=>{var l=c,{color:e="currentColor",size:t=24,strokeWidth:r=2,absoluteStrokeWidth:n,children:o,iconNode:i,class:a=""}=l,s=gr(l,["color","size","strokeWidth","absoluteStrokeWidth","children","iconNode","class"]);return Wt("svg",H(He(H({},Hu),{width:String(t),height:t,stroke:e,"stroke-width":n?Number(r)*24/Number(t):r,class:["lucide",a].join(" ")}),s),[...i.map(([u,p])=>Wt(u,p)),...Cr(o)])},bo=(e,t)=>{let r=a=>{var s=a,{class:n="",children:o}=s,i=gr(s,["class","children"]);return Wt($u,He(H({},i),{iconNode:t,class:Cu(`lucide-${aa(sa(e))}`,`lucide-${aa(e)}`,n)}),o)};return r.displayName=sa(e),r},Pu=bo("corner-down-left",[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4",key:"6o5b7l"}],["path",{d:"m9 10-5 5 5 5",key:"1kshq7"}]]),Iu=bo("list-filter",[["path",{d:"M2 5h20",key:"1fs1ex"}],["path",{d:"M6 12h12",key:"8npq4p"}],["path",{d:"M9 19h6",key:"456am0"}]]),Ru=bo("search",[["path",{d:"m21 21-4.34-4.34",key:"14j7rj"}],["circle",{cx:"11",cy:"11",r:"8",key:"4ej97u"}]]),Gx=hl(vl(),1);function ju({threshold:e=0,root:t=null,rootMargin:r="0%",freezeOnceVisible:n=!1,initialIsIntersecting:o=!1,onChange:i}={}){var a;let[s,c]=bn(null),[l,u]=bn(()=>({isIntersecting:o,entry:void 0})),p=Vt();p.current=i;let d=((a=l.entry)==null?void 0:a.isIntersecting)&&n;mt(()=>{if(!s||!("IntersectionObserver"in window)||d)return;let v,x=new IntersectionObserver(w=>{let E=Array.isArray(x.thresholds)?x.thresholds:[x.thresholds];w.forEach(_=>{let de=_.isIntersecting&&E.some(be=>_.intersectionRatio>=be);u({isIntersecting:de,entry:_}),p.current&&p.current(de,_),de&&n&&v&&(v(),v=void 0)})},{threshold:e,root:t,rootMargin:r});return x.observe(s),()=>{x.disconnect()}},[s,JSON.stringify(e),t,r,d,n]);let m=Vt(null);mt(()=>{var v;!s&&(v=l.entry)!=null&&v.target&&!n&&!d&&m.current!==l.entry.target&&(m.current=l.entry.target,u({isIntersecting:o,entry:void 0}))},[s,l.entry,n,d,o]);let h=[c,!!l.isIntersecting,l.entry];return h.ref=h[0],h.isIntersecting=h[1],h.entry=h[2],h}var lt={container:"n",hidden:"l",content:"u",pop:"d",badge:"y",sidebar:"i",controls:"w",results:"k",loadmore:"z"};function Fu(e){let{isIntersecting:t,ref:r}=ju({threshold:0});mt(()=>{t&&cu()},[t]);let n=Vt(null);mt(()=>{n.current&&typeof Se.value.page>"u"&&n.current.scrollTo({top:0,behavior:"smooth"})},[Se.value]);let o=za();return z("div",{class:zt(lt.container,{[lt.hidden]:e.hidden}),children:[z("div",{class:lt.content,children:[z("div",{class:lt.controls,children:[z(co,{onClick:Dt,children:z(Ru,{})}),z(Nu,{focus:!e.hidden}),z(co,{onClick:Wa,children:[z(Iu,{}),o.length>0&&z("span",{class:lt.badge,children:o.length})]})]}),z("div",{class:lt.results,ref:n,children:[z(Du,{keyboard:!e.hidden}),z("div",{class:lt.loadmore,ref:r})]})]}),z("div",{class:zt(lt.sidebar,{[lt.hidden]:du()}),children:z(Uu,{})})]})}var Tt={container:"X",list:"j",heading:"F",title:"I",item:"o",active:"g",value:"R",count:"q"};function Uu(e){let t=mu();return t.sort((r,n)=>n.node.count-r.node.count),z("div",{class:Tt.container,children:[z("h3",{class:Tt.heading,children:"Filters"}),z("h4",{class:Tt.title,children:"Tags"}),z("ol",{class:Tt.list,children:t.map(r=>z("li",{class:zt(Tt.item,{[Tt.active]:lu(r.node.value)}),onClick:()=>uu(r.node.value),children:[z("span",{class:Tt.value,children:r.node.value}),z("span",{class:Tt.count,children:r.node.count})]}))})]})}var ca={container:"f"};function Nu(e){let t=Vt(null);return mt(()=>{var r,n;e.focus?(r=t.current)==null||r.focus():(n=t.current)==null||n.blur()},[e.focus]),z("div",{class:ca.container,children:z("input",{ref:t,type:"text",class:ca.content,value:hn(wn()),onInput:r=>Va(yu(r.currentTarget.value)),autocapitalize:"off",autocomplete:"off",autocorrect:"off",placeholder:"Search",spellcheck:!1,role:"combobox"})})}var ut={container:"b",heading:"A",item:"a",active:"h",wrapper:"B",actions:"s",title:"x",path:"t"};function Ga(){let[e,t]=bn(!1);return mt(()=>{let r=()=>t(!0),n=()=>t(!1);return document.addEventListener("compositionstart",r),document.addEventListener("compositionend",n),()=>{document.removeEventListener("compositionstart",r),document.removeEventListener("compositionend",n)}},[]),e}function Du(e){var s;let t=su(),r=pu(),n=dn(),o=Vt([]),i=Ga();mt(()=>{let c=o.current[n];c&&c.scrollIntoView({block:"center",behavior:"smooth"})},[n]),Aa(e.keyboard,c=>{if(i)return;let l=dn();c.key==="ArrowDown"?(c.preventDefault(),so(Math.min(l+1,r.length-1))):c.key==="ArrowUp"&&(c.preventDefault(),so(Math.max(l-1,0)))},[e.keyboard,i]);let a=(s=fu())!=null?s:0;return z(ft,{children:[r.length>0&&z("h3",{class:ut.heading,children:[z("span",{class:ut.bubble,children:new Intl.NumberFormat("en-US").format(a)})," ","results"]}),z("ol",{class:ut.container,children:r.map((c,l)=>{var m;let u=Ba(t[c.id].title,c.matches.find(({field:h})=>h==="title")),p=Mu((m=t[c.id].path)!=null?m:[],c.matches.find(({field:h})=>h==="path")),d=t[c.id].location;if(qa()){let h=encodeURIComponent(wn()),[v,x]=d.split("#",2);d=`${v}?h=${h.replace(/%20/g,"+")}`,typeof x<"u"&&(d+=`#${x}`)}return z("li",{children:z("a",{ref:h=>{o.current[l]=h},href:d,onClick:()=>Dt(),class:zt(ut.item,{[ut.active]:l===dn()}),children:[z("div",{class:ut.wrapper,children:[z("h2",{class:ut.title,children:u}),z("menu",{class:ut.path,children:p.map(h=>z("li",{children:h}))})]}),z("nav",{class:ut.actions,children:z(co,{children:z(Pu,{})})})]})})})})]})}var Wu={container:"e"};function Vu(e){let t=Ga();return Aa(!0,r=>{var n,o,i,a,s;if(!t)if((r.metaKey||r.ctrlKey)&&r.key==="k")r.preventDefault(),Dt();else if((r.metaKey||r.ctrlKey)&&r.key==="j")document.body.classList.toggle("dark");else if(r.key==="Enter"&&!sr()){r.preventDefault();let c=dn(),l=(o=(n=it.value)==null?void 0:n.items[c])==null?void 0:o.id;if((a=(i=lr.value)==null?void 0:i.items[l])!=null&&a.location){Dt();let u=(s=lr.value)==null?void 0:s.items[l].location;if(qa()){let p=encodeURIComponent(wn()),[d,m]=u.split("#",2);u=`${d}?h=${p.replace(/%20/g,"+")}`,typeof m<"u"&&(u+=`#${m}`)}window.location.href=u}}else r.key==="Escape"&&!sr()&&(r.preventDefault(),Dt())},[t]),z("div",{class:Wu.container,children:[z(ku,{hidden:sr()}),z(Fu,{hidden:sr()})]})}function Ja(e,t){au(e),El(z(Vu,{}),t)}function go(){Dt()}function zu(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function qu(){return R(b(window,"compositionstart").pipe(f(()=>!0)),b(window,"compositionend").pipe(f(()=>!1))).pipe(J(!1))}function Xa(){let e=b(window,"keydown").pipe(f(t=>({mode:sr()?"global":"search",type:t.key,meta:t.ctrlKey||t.metaKey,claim(){t.preventDefault(),t.stopPropagation()}})),L(({mode:t,type:r})=>{if(t==="global"){let n=xt();if(typeof n!="undefined")return!zu(n,r)}return!0}),xe());return qu().pipe(g(t=>t?y:e))}function Ye(){return new URL(location.href)}function dt(e,t=!1){if(X("navigation.instant")&&!t){let r=A("a",{href:e.href});document.body.appendChild(r),r.click(),r.remove()}else location.href=e.href}function Za(){return new I}function Qa(){return location.hash.slice(1)}function es(e){let t=A("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function _o(e){return R(b(window,"hashchange"),e).pipe(f(Qa),J(Qa()),L(t=>t.length>0),se(1))}function ts(e){return _o(e).pipe(f(t=>Le(`[id="${t}"]`)),L(t=>typeof t!="undefined"))}function Ir(e){let t=matchMedia(e);return an(r=>t.addListener(()=>r(t.matches))).pipe(J(t.matches))}function rs(){let e=matchMedia("print");return R(b(window,"beforeprint").pipe(f(()=>!0)),b(window,"afterprint").pipe(f(()=>!1))).pipe(J(e.matches))}function yo(e,t){return e.pipe(g(r=>r?t():y))}function xo(e,t){return new U(r=>{let n=new XMLHttpRequest;return n.open("GET",`${e}`),n.responseType="blob",n.addEventListener("load",()=>{n.status>=200&&n.status<300?(r.next(n.response),r.complete()):r.error(new Error(n.statusText))}),n.addEventListener("error",()=>{r.error(new Error("Network error"))}),n.addEventListener("abort",()=>{r.complete()}),typeof(t==null?void 0:t.progress$)!="undefined"&&(n.addEventListener("progress",o=>{var i;if(o.lengthComputable)t.progress$.next(o.loaded/o.total*100);else{let a=(i=n.getResponseHeader("Content-Length"))!=null?i:0;t.progress$.next(o.loaded/+a*100)}}),t.progress$.next(5)),n.send(),()=>n.abort()})}function et(e,t){return xo(e,t).pipe(g(r=>r.text()),f(r=>JSON.parse(r)),se(1))}function En(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/html")),se(1))}function ns(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/xml")),se(1))}var wo={drawer:G("[data-md-toggle=drawer]"),search:G("[data-md-toggle=search]")};function Eo(e,t){wo[e].checked!==t&&wo[e].click()}function Tn(e){let t=wo[e];return b(t,"change").pipe(f(()=>t.checked),J(t.checked))}function os(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function is(){return R(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(f(os),J(os()))}function as(){return{width:innerWidth,height:innerHeight}}function ss(){return b(window,"resize",{passive:!0}).pipe(f(as),J(as()))}function cs(){return re([is(),ss()]).pipe(f(([e,t])=>({offset:e,size:t})),se(1))}function Sn(e,{viewport$:t,header$:r}){let n=t.pipe(fe("size")),o=re([n,r]).pipe(f(()=>wt(e)));return re([r,t,o]).pipe(f(([{height:i},{offset:a,size:s},{x:c,y:l}])=>({offset:{x:a.x-c,y:a.y-l+i},size:s})))}var Ku=G("#__config"),mr=JSON.parse(Ku.textContent);mr.base=`${new URL(mr.base,Ye())}`;function Ue(){return mr}function X(e){return mr.features.includes(e)}function Bt(e,t){return typeof t!="undefined"?mr.translations[e].replace("#",t.toString()):mr.translations[e]}function ht(e,t=document){return G(`[data-md-component=${e}]`,t)}function Ee(e,t=document){return P(`[data-md-component=${e}]`,t)}function Bu(e){let t=G(".md-typeset > :first-child",e);return b(t,"click",{once:!0}).pipe(f(()=>G(".md-typeset",e)),f(r=>({hash:__md_hash(r.innerHTML)})))}function ls(e){if(!X("announce.dismiss")||!e.childElementCount)return y;if(!e.hidden){let t=G(".md-typeset",e);__md_hash(t.innerHTML)===__md_get("__announce")&&(e.hidden=!0)}return j(()=>{let t=new I;return t.subscribe(({hash:r})=>{e.hidden=!0,__md_set("__announce",r)}),Bu(e).pipe($(r=>t.next(r)),V(()=>t.complete()),f(r=>H({ref:e},r)))})}function Yu(e,{target$:t}){return t.pipe(f(r=>({hidden:r!==e})))}function us(e,t){let r=new I;return r.subscribe(({hidden:n})=>{e.hidden=n}),Yu(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))}function To(e,t){return t==="inline"?A("div",{class:"md-tooltip md-tooltip--inline",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"})):A("div",{class:"md-tooltip",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"}))}function On(...e){return A("div",{class:"md-tooltip2",role:"dialog"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function ps(...e){return A("div",{class:"md-tooltip2",role:"tooltip"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function fs(e,t){if(t=t?`${t}_annotation_${e}`:void 0,t){let r=t?`#${t}`:void 0;return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("a",{href:r,class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}else return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("span",{class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}function ms(e){return A("button",{class:"md-code__button",title:Bt("clipboard.copy"),"data-clipboard-target":`#${e} > code`,"data-md-type":"copy"})}function ds(){return A("button",{class:"md-code__button",title:"Toggle line selection","data-md-type":"select"})}function hs(){return A("nav",{class:"md-code__nav"})}var Xu=_r(So());function bs(e){return A("ul",{class:"md-source__facts"},Object.entries(e).map(([t,r])=>A("li",{class:`md-source__fact md-source__fact--${t}`},typeof r=="number"?Li(r):r)))}function Oo(e){let t=`tabbed-control tabbed-control--${e}`;return A("div",{class:t,hidden:!0},A("button",{class:"tabbed-button",tabIndex:-1,"aria-hidden":"true"}))}function gs(e){return A("div",{class:"md-typeset__scrollwrap"},A("div",{class:"md-typeset__table"},e))}function Zu(e){var n;let t=Ue(),r=new URL(`../${e.version}/`,t.base);return A("li",{class:"md-version__item"},A("a",{href:`${r}`,class:"md-version__link"},e.title,((n=t.version)==null?void 0:n.alias)&&e.aliases.length>0&&A("span",{class:"md-version__alias"},e.aliases[0])))}function _s(e,t){var n;let r=Ue();return e=e.filter(o=>{var i;return!((i=o.properties)!=null&&i.hidden)}),A("div",{class:"md-version"},A("button",{class:"md-version__current","aria-label":Bt("select.version")},t.title,((n=r.version)==null?void 0:n.alias)&&t.aliases.length>0&&A("span",{class:"md-version__alias"},t.aliases[0])),A("ul",{class:"md-version__list"},e.map(Zu)))}var Qu=0;function ep(e,t=250){let r=re([ir(e),Ft(e,t)]).pipe(f(([o,i])=>o||i),ie()),n=j(()=>Ai(e)).pipe(oe(Ut),Lr(1),Ze(r),f(()=>Ci(e)));return r.pipe(Sr(o=>o),g(()=>re([r,n])),f(([o,i])=>({active:o,offset:i})),xe())}function Rr(e,t,r=250){let{content$:n,viewport$:o}=t,i=`__tooltip2_${Qu++}`;return j(()=>{let a=new I,s=new Un(!1);a.pipe(he(),ye(!1)).subscribe(s);let c=s.pipe(Tr(u=>Ve(+!u*250,Wn)),ie(),g(u=>u?n:y),$(u=>u.id=i),xe());re([a.pipe(f(({active:u})=>u)),c.pipe(g(u=>Ft(u,250)),J(!1))]).pipe(f(u=>u.some(p=>p))).subscribe(s);let l=s.pipe(L(u=>u),pe(c,o),f(([u,p,{size:d}])=>{let m=e.getBoundingClientRect(),h=m.width/2;if(p.role==="tooltip")return{x:h,y:8+m.height};if(m.y>=d.height/2){let{height:v}=Ae(p);return{x:h,y:-16-v}}else return{x:h,y:16+m.height}}));return re([c,a,l]).subscribe(([u,{offset:p},d])=>{u.style.setProperty("--md-tooltip-host-x",`${p.x}px`),u.style.setProperty("--md-tooltip-host-y",`${p.y}px`),u.style.setProperty("--md-tooltip-x",`${d.x}px`),u.style.setProperty("--md-tooltip-y",`${d.y}px`),u.classList.toggle("md-tooltip2--top",d.y<0),u.classList.toggle("md-tooltip2--bottom",d.y>=0)}),s.pipe(L(u=>u),pe(c,(u,p)=>p),L(u=>u.role==="tooltip")).subscribe(u=>{let p=Ae(G(":scope > *",u));u.style.setProperty("--md-tooltip-width",`${p.width}px`),u.style.setProperty("--md-tooltip-tail","0px")}),s.pipe(ie(),Ie(je),pe(c)).subscribe(([u,p])=>{p.classList.toggle("md-tooltip2--active",u)}),re([s.pipe(L(u=>u)),c]).subscribe(([u,p])=>{p.role==="dialog"?(e.setAttribute("aria-controls",i),e.setAttribute("aria-haspopup","dialog")):e.setAttribute("aria-describedby",i)}),s.pipe(L(u=>!u)).subscribe(()=>{e.removeAttribute("aria-controls"),e.removeAttribute("aria-describedby"),e.removeAttribute("aria-haspopup")}),ep(e,r).pipe($(u=>a.next(u)),V(()=>a.complete()),f(u=>H({ref:e},u)))})}function Ge(e,{viewport$:t},r=document.body){return Rr(e,{content$:new U(n=>{let o=e.title,i=ps(o);return n.next(i),e.removeAttribute("title"),r.append(i),()=>{i.remove(),e.setAttribute("title",o)}}),viewport$:t},0)}function tp(e,t){let r=j(()=>re([Hi(e),Ut(t)])).pipe(f(([{x:n,y:o},i])=>{let{width:a,height:s}=Ae(e);return{x:n-i.x+a/2,y:o-i.y+s/2}}));return ir(e).pipe(g(n=>r.pipe(f(o=>({active:n,offset:o})),Me(+!n||1/0))))}function ys(e,t,{target$:r}){let[n,o]=Array.from(e.children);return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({offset:s}){e.style.setProperty("--md-tooltip-x",`${s.x}px`),e.style.setProperty("--md-tooltip-y",`${s.y}px`)},complete(){e.style.removeProperty("--md-tooltip-x"),e.style.removeProperty("--md-tooltip-y")}}),Et(e).pipe(Q(a)).subscribe(s=>{e.toggleAttribute("data-md-visible",s)}),R(i.pipe(L(({active:s})=>s)),i.pipe(Be(250),L(({active:s})=>!s))).subscribe({next({active:s}){s?e.prepend(n):n.remove()},complete(){e.prepend(n)}}),i.pipe(Xe(16,je)).subscribe(({active:s})=>{n.classList.toggle("md-tooltip--active",s)}),i.pipe(Lr(125,je),L(()=>!!e.offsetParent),f(()=>e.offsetParent.getBoundingClientRect()),f(({x:s})=>s)).subscribe({next(s){s?e.style.setProperty("--md-tooltip-0",`${-s}px`):e.style.removeProperty("--md-tooltip-0")},complete(){e.style.removeProperty("--md-tooltip-0")}}),b(o,"click").pipe(Q(a),L(s=>!(s.metaKey||s.ctrlKey))).subscribe(s=>{s.stopPropagation(),s.preventDefault()}),b(o,"mousedown").pipe(Q(a),pe(i)).subscribe(([s,{active:c}])=>{var l;if(s.button!==0||s.metaKey||s.ctrlKey)s.preventDefault();else if(c){s.preventDefault();let u=e.parentElement.closest(".md-annotation");u instanceof HTMLElement?u.focus():(l=xt())==null||l.blur()}}),r.pipe(Q(a),L(s=>s===n),It(125)).subscribe(()=>e.focus()),tp(e,t).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function rp(e){let t=Ue();if(e.tagName!=="CODE")return[e];let r=[".c",".c1",".cm"];if(t.annotate){let n=e.closest("[class|=language]");if(n)for(let o of Array.from(n.classList)){if(!o.startsWith("language-"))continue;let[,i]=o.split("-");i in t.annotate&&r.push(...t.annotate[i])}}return P(r.join(", "),e)}function np(e){let t=[];for(let r of rp(e)){let n=[],o=document.createNodeIterator(r,NodeFilter.SHOW_TEXT);for(let i=o.nextNode();i;i=o.nextNode())n.push(i);for(let i of n){let a;for(;a=/(\(\d+\))(!)?/.exec(i.textContent);){let[,s,c]=a;if(typeof c=="undefined"){let l=i.splitText(a.index);i=l.splitText(s.length),t.push(l)}else{i.textContent=s,t.push(i);break}}}}return t}function xs(e,t){t.append(...Array.from(e.childNodes))}function Ln(e,t,{target$:r,print$:n}){let o=t.closest("[id]"),i=o==null?void 0:o.id,a=new Map;for(let s of np(t)){let[,c]=s.textContent.match(/\((\d+)\)/);Le(`:scope > li:nth-child(${c})`,e)&&(a.set(c,fs(c,i)),s.replaceWith(a.get(c)))}return a.size===0?y:j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=[];for(let[u,p]of a)l.push([G(".md-typeset",p),G(`:scope > li:nth-child(${u})`,e)]);return n.pipe(Q(c)).subscribe(u=>{e.hidden=!u,e.classList.toggle("md-annotation-list",u);for(let[p,d]of l)u?xs(p,d):xs(d,p)}),R(...[...a].map(([,u])=>ys(u,t,{target$:r}))).pipe(V(()=>s.complete()),xe())})}function ws(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return ws(t)}}function Es(e,t){return j(()=>{let r=ws(e);return typeof r!="undefined"?Ln(r,e,t):y})}var Ss=_r(Mo());var op=0,Ts=R(b(window,"keydown").pipe(f(()=>!0)),R(b(window,"keyup"),b(window,"contextmenu")).pipe(f(()=>!1))).pipe(J(!1),se(1));function Os(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return Os(t)}}function ip(e){return Re(e).pipe(f(({width:t})=>({scrollable:Mr(e).width>t})),fe("scrollable"))}function Ls(e,t){let{matches:r}=matchMedia("(hover)"),n=j(()=>{let o=new I,i=o.pipe(Gn(1));o.subscribe(({scrollable:m})=>{m&&r?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")});let a=[],s=e.closest("pre"),c=s.closest("[id]"),l=c?c.id:op++;s.id=`__code_${l}`;let u=[],p=e.closest(".highlight");if(p instanceof HTMLElement){let m=Os(p);if(typeof m!="undefined"&&(p.classList.contains("annotate")||X("content.code.annotate"))){let h=Ln(m,e,t);u.push(Re(p).pipe(Q(i),f(({width:v,height:x})=>v&&x),ie(),g(v=>v?h:y)))}}let d=P(":scope > span[id]",e);if(d.length&&(e.classList.add("md-code__content"),e.closest(".select")||X("content.code.select")&&!e.closest(".no-select"))){let m=+d[0].id.split("-").pop(),h=ds();a.push(h),X("content.tooltips")&&u.push(Ge(h,{viewport$}));let v=b(h,"click").pipe(Or(M=>!M,!1),$(()=>h.blur()),xe());v.subscribe(M=>{h.classList.toggle("md-code__button--active",M)});let x=me(d).pipe(oe(M=>Ft(M).pipe(f(O=>[M,O]))));v.pipe(g(M=>M?x:y)).subscribe(([M,O])=>{let N=Le(".hll.select",M);if(N&&!O)N.replaceWith(...Array.from(N.childNodes));else if(!N&&O){let ee=document.createElement("span");ee.className="hll select",ee.append(...Array.from(M.childNodes).slice(1)),M.append(ee)}});let w=me(d).pipe(oe(M=>b(M,"mousedown").pipe($(O=>O.preventDefault()),f(()=>M)))),E=v.pipe(g(M=>M?w:y),pe(Ts),f(([M,O])=>{var ee;let N=d.indexOf(M)+m;if(O===!1)return[N,N];{let le=P(".hll",e).map(ce=>d.indexOf(ce.parentElement)+m);return(ee=window.getSelection())==null||ee.removeAllRanges(),[Math.min(N,...le),Math.max(N,...le)]}})),_=_o(y).pipe(L(M=>M.startsWith(`__codelineno-${l}-`)));_.subscribe(M=>{let[,,O]=M.split("-"),N=O.split(":").map(le=>+le-m+1);N.length===1&&N.push(N[0]);for(let le of P(".hll:not(.select)",e))le.replaceWith(...Array.from(le.childNodes));let ee=d.slice(N[0]-1,N[1]);for(let le of ee){let ce=document.createElement("span");ce.className="hll",ce.append(...Array.from(le.childNodes).slice(1)),le.append(ce)}}),_.pipe(Me(1),Ie(ge)).subscribe(M=>{if(M.includes(":")){let O=document.getElementById(M.split(":")[0]);O&&setTimeout(()=>{let N=O,ee=-64;for(;N!==document.body;)ee+=N.offsetTop,N=N.offsetParent;window.scrollTo({top:ee})},1)}});let be=me(P('a[href^="#__codelineno"]',p)).pipe(oe(M=>b(M,"click").pipe($(O=>O.preventDefault()),f(()=>M)))).pipe(Q(i),pe(Ts),f(([M,O])=>{let ee=+G(`[id="${M.hash.slice(1)}"]`).parentElement.id.split("-").pop();if(O===!1)return[ee,ee];{let le=P(".hll",e).map(ce=>+ce.parentElement.id.split("-").pop());return[Math.min(ee,...le),Math.max(ee,...le)]}}));R(E,be).subscribe(M=>{let O=`#__codelineno-${l}-`;M[0]===M[1]?O+=M[0]:O+=`${M[0]}:${M[1]}`,history.replaceState({},"",O),window.dispatchEvent(new HashChangeEvent("hashchange",{newURL:window.location.origin+window.location.pathname+O,oldURL:window.location.href}))})}if(Ss.default.isSupported()&&(e.closest(".copy")||X("content.code.copy")&&!e.closest(".no-copy"))){let m=ms(s.id);a.push(m),X("content.tooltips")&&u.push(Ge(m,{viewport$}))}if(a.length){let m=hs();m.append(...a),s.insertBefore(m,e)}return ip(e).pipe($(m=>o.next(m)),V(()=>o.complete()),f(m=>H({ref:e},m)),Rt(R(...u).pipe(Q(i))))});return X("content.lazy")?Et(e).pipe(L(o=>o),Me(1),g(()=>n)):n}function ap(e,{target$:t,print$:r}){let n=!0;return R(t.pipe(f(o=>o.closest("details:not([open])")),L(o=>e===o),f(()=>({action:"open",reveal:!0}))),r.pipe(L(o=>o||!n),$(()=>n=e.open),f(o=>({action:o?"open":"close"}))))}function Ms(e,t){return j(()=>{let r=new I;return r.subscribe(({action:n,reveal:o})=>{e.toggleAttribute("open",n==="open"),o&&e.scrollIntoView()}),ap(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}var ks=0,As=new Map;function sp(e){let t=document.createElement("h3");t.innerHTML=e.innerHTML;let r=[t],n=e.nextElementSibling;for(;n&&!(n instanceof HTMLHeadingElement);)r.push(n.cloneNode(!0)),n=n.nextElementSibling;return r}function cp(e,t){for(let r of P("[href], [src]",e))for(let n of["href","src"]){let o=r.getAttribute(n);if(o&&!/^(?:[a-z]+:)?\/\//i.test(o)){r[n]=new URL(r.getAttribute(n),t).toString();break}}for(let r of P("[name^=__], [for]",e))for(let n of["id","for","name"]){let o=r.getAttribute(n);o&&r.setAttribute(n,`${o}$preview_${ks}`)}return ks++,Y(e)}function lp(e){let t=As.get(e.toString());return t?Y(t):En(e).pipe(g(r=>cp(r,e)),f(r=>(As.set(e.toString(),r),r)))}function Cs(e,t){let{sitemap$:r}=t;if(!(e instanceof HTMLAnchorElement))return y;if(!(X("navigation.instant.preview")||e.hasAttribute("data-preview")))return y;e.removeAttribute("title");let n=re([ir(e),Ft(e).pipe(ke(1))]).pipe(f(([i,a])=>i||a),ie(),L(i=>i));return $t([r,n]).pipe(g(([i])=>{let a=new URL(e.href);return a.search=a.hash="",i.has(`${a}`)?Y(a):y}),g(i=>lp(i)),g(i=>{let a=e.hash?`article [id="${decodeURIComponent(e.hash.slice(1))}"]`:"article h1",s=Le(a,i);return typeof s=="undefined"?y:Y(sp(s))})).pipe(g(i=>{let a=new U(s=>{let c=On(...i);return s.next(c),document.body.append(c),()=>c.remove()});return Rr(e,H({content$:a},t))}))}var Hs=".node circle,.node ellipse,.node path,.node polygon,.node rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}marker{fill:var(--md-mermaid-edge-color)!important}.edgeLabel .label rect{fill:#0000}.flowchartTitleText{fill:var(--md-mermaid-label-fg-color)}.label{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.label foreignObject{line-height:normal;overflow:visible}.label div .edgeLabel{color:var(--md-mermaid-label-fg-color)}.edgeLabel,.edgeLabel p,.label div .edgeLabel{background-color:var(--md-mermaid-label-bg-color)}.edgeLabel,.edgeLabel p{fill:var(--md-mermaid-label-bg-color);color:var(--md-mermaid-edge-color)}.edgePath .path,.flowchart-link{stroke:var(--md-mermaid-edge-color)}.edgePath .arrowheadPath{fill:var(--md-mermaid-edge-color);stroke:none}.cluster rect{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}.cluster span{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}g #flowchart-circleEnd,g #flowchart-circleStart,g #flowchart-crossEnd,g #flowchart-crossStart,g #flowchart-pointEnd,g #flowchart-pointStart{stroke:none}.classDiagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.classGroup line,g.classGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.classGroup text{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.classLabel .box{fill:var(--md-mermaid-label-bg-color);background-color:var(--md-mermaid-label-bg-color);opacity:1}.classLabel .label{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.node .divider{stroke:var(--md-mermaid-node-fg-color)}.relation{stroke:var(--md-mermaid-edge-color)}.cardinality{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.cardinality text{fill:inherit!important}defs marker.marker.composition.class path,defs marker.marker.dependency.class path,defs marker.marker.extension.class path{fill:var(--md-mermaid-edge-color)!important;stroke:var(--md-mermaid-edge-color)!important}defs marker.marker.aggregation.class path{fill:var(--md-mermaid-label-bg-color)!important;stroke:var(--md-mermaid-edge-color)!important}.statediagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.stateGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.stateGroup .state-title{fill:var(--md-mermaid-label-fg-color)!important;font-family:var(--md-mermaid-font-family)}g.stateGroup .composit{fill:var(--md-mermaid-label-bg-color)}.nodeLabel,.nodeLabel p{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}a .nodeLabel{text-decoration:underline}.node circle.state-end,.node circle.state-start,.start-state{fill:var(--md-mermaid-edge-color);stroke:none}.end-state-inner,.end-state-outer{fill:var(--md-mermaid-edge-color)}.end-state-inner,.node circle.state-end{stroke:var(--md-mermaid-label-bg-color)}.transition{stroke:var(--md-mermaid-edge-color)}[id^=state-fork] rect,[id^=state-join] rect{fill:var(--md-mermaid-edge-color)!important;stroke:none!important}.statediagram-cluster.statediagram-cluster .inner{fill:var(--md-default-bg-color)}.statediagram-cluster rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}.statediagram-state rect.divider{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}defs #statediagram-barbEnd{stroke:var(--md-mermaid-edge-color)}[id^=entity] path,[id^=entity] rect{fill:var(--md-default-bg-color)}.relationshipLine{stroke:var(--md-mermaid-edge-color)}defs .marker.oneOrMore.er *,defs .marker.onlyOne.er *,defs .marker.zeroOrMore.er *,defs .marker.zeroOrOne.er *{stroke:var(--md-mermaid-edge-color)!important}text:not([class]):last-child{fill:var(--md-mermaid-label-fg-color)}.actor{fill:var(--md-mermaid-sequence-actor-bg-color);stroke:var(--md-mermaid-sequence-actor-border-color)}text.actor>tspan{fill:var(--md-mermaid-sequence-actor-fg-color);font-family:var(--md-mermaid-font-family)}line{stroke:var(--md-mermaid-sequence-actor-line-color)}.actor-man circle,.actor-man line{fill:var(--md-mermaid-sequence-actorman-bg-color);stroke:var(--md-mermaid-sequence-actorman-line-color)}.messageLine0,.messageLine1{stroke:var(--md-mermaid-sequence-message-line-color)}.note{fill:var(--md-mermaid-sequence-note-bg-color);stroke:var(--md-mermaid-sequence-note-border-color)}.loopText,.loopText>tspan,.messageText,.noteText>tspan{stroke:none;font-family:var(--md-mermaid-font-family)!important}.messageText{fill:var(--md-mermaid-sequence-message-fg-color)}.loopText,.loopText>tspan{fill:var(--md-mermaid-sequence-loop-fg-color)}.noteText>tspan{fill:var(--md-mermaid-sequence-note-fg-color)}#arrowhead path{fill:var(--md-mermaid-sequence-message-line-color);stroke:none}.loopLine{fill:var(--md-mermaid-sequence-loop-bg-color);stroke:var(--md-mermaid-sequence-loop-border-color)}.labelBox{fill:var(--md-mermaid-sequence-label-bg-color);stroke:none}.labelText,.labelText>span{fill:var(--md-mermaid-sequence-label-fg-color);font-family:var(--md-mermaid-font-family)}.sequenceNumber{fill:var(--md-mermaid-sequence-number-fg-color)}rect.rect{fill:var(--md-mermaid-sequence-box-bg-color);stroke:none}rect.rect+text.text{fill:var(--md-mermaid-sequence-box-fg-color)}defs #sequencenumber{fill:var(--md-mermaid-sequence-number-bg-color)!important}";var ko,pp=0;function fp(){return typeof mermaid=="undefined"||mermaid instanceof Element?ar("https://unpkg.com/mermaid@11/dist/mermaid.min.js"):Y(void 0)}function $s(e){return e.classList.remove("mermaid"),ko||(ko=fp().pipe($(()=>mermaid.initialize({startOnLoad:!1,themeCSS:Hs,sequence:{actorFontSize:"16px",messageFontSize:"16px",noteFontSize:"16px"}})),f(()=>{}),se(1))),ko.subscribe(()=>Uo(null,null,function*(){e.classList.add("mermaid");let t=`__mermaid_${pp++}`,r=A("div",{class:"mermaid"}),n=e.textContent,{svg:o,fn:i}=yield mermaid.render(t,n),a=r.attachShadow({mode:"closed"});a.innerHTML=o,e.replaceWith(r),i==null||i(a)})),ko.pipe(f(()=>({ref:e})))}var Ps=A("table");function Is(e){return e.replaceWith(Ps),Ps.replaceWith(gs(e)),Y({ref:e})}function mp(e){let t=e.find(r=>r.checked)||e[0];return R(...e.map(r=>b(r,"change").pipe(f(()=>G(`label[for="${r.id}"]`))))).pipe(J(G(`label[for="${t.id}"]`)),f(r=>({active:r})))}function Rs(e,{viewport$:t,target$:r}){let n=G(".tabbed-labels",e),o=P(":scope > input",e),i=Oo("prev");e.append(i);let a=Oo("next");return e.append(a),j(()=>{let s=new I,c=s.pipe(he(),ye(!0));re([s,Re(e),Et(e)]).pipe(Q(c),Xe(1,je)).subscribe({next([{active:l},u]){let p=wt(l),{width:d}=Ae(l);e.style.setProperty("--md-indicator-x",`${p.x}px`),e.style.setProperty("--md-indicator-width",`${d}px`);let m=ln(n);(p.x<m.x||p.x+d>m.x+u.width)&&n.scrollTo({left:Math.max(0,p.x-16),behavior:"smooth"})},complete(){e.style.removeProperty("--md-indicator-x"),e.style.removeProperty("--md-indicator-width")}}),re([Ut(n),Re(n)]).pipe(Q(c)).subscribe(([l,u])=>{let p=Mr(n);i.hidden=l.x<16,a.hidden=l.x>p.width-u.width-16}),R(b(i,"click").pipe(f(()=>-1)),b(a,"click").pipe(f(()=>1))).pipe(Q(c)).subscribe(l=>{let{width:u}=Ae(n);n.scrollBy({left:u*l,behavior:"smooth"})}),r.pipe(Q(c),L(l=>o.includes(l))).subscribe(l=>l.click()),n.classList.add("tabbed-labels--linked");for(let l of o){let u=G(`label[for="${l.id}"]`);u.replaceChildren(A("a",{href:`#${u.htmlFor}`,tabIndex:-1},...Array.from(u.childNodes))),b(u.firstElementChild,"click").pipe(Q(c),L(p=>!(p.metaKey||p.ctrlKey)),$(p=>{p.preventDefault(),p.stopPropagation()})).subscribe(()=>{history.replaceState({},"",`#${u.htmlFor}`),u.click()})}return X("content.tabs.link")&&s.pipe(ke(1),pe(t)).subscribe(([{active:l},{offset:u}])=>{let p=l.innerText.trim();if(l.hasAttribute("data-md-switching"))l.removeAttribute("data-md-switching");else{let d=e.offsetTop-u.y;for(let h of P("[data-tabs]"))for(let v of P(":scope > input",h)){let x=G(`label[for="${v.id}"]`);if(x!==l&&x.innerText.trim()===p){x.setAttribute("data-md-switching",""),v.click();break}}window.scrollTo({top:e.offsetTop-d});let m=__md_get("__tabs")||[];__md_set("__tabs",[...new Set([p,...m])])}}),s.pipe(Q(c)).subscribe(()=>{for(let l of P("audio, video",e))l.offsetWidth&&l.autoplay?l.play().catch(()=>{}):l.pause()}),mp(o).pipe($(l=>s.next(l)),V(()=>s.complete()),f(l=>H({ref:e},l)))}).pipe(Ht(ge))}function js(e,t){let{viewport$:r,target$:n,print$:o}=t;return R(...P(".annotate:not(.highlight)",e).map(i=>Es(i,{target$:n,print$:o})),...P("pre:not(.mermaid) > code",e).map(i=>Ls(i,{target$:n,print$:o})),...P("a",e).map(i=>Cs(i,t)),...P("pre.mermaid",e).map(i=>$s(i)),...P("table:not([class])",e).map(i=>Is(i)),...P("details",e).map(i=>Ms(i,{target$:n,print$:o})),...P("[data-tabs]",e).map(i=>Rs(i,{viewport$:r,target$:n})),...P("[title]:not([data-preview])",e).filter(()=>X("content.tooltips")).map(i=>Ge(i,{viewport$:r})),...P(".footnote-ref",e).filter(()=>X("content.footnote.tooltips")).map(i=>Rr(i,{content$:new U(a=>{let s=new URL(i.href).hash.slice(1),c=Array.from(document.getElementById(s).cloneNode(!0).children),l=On(...c);return a.next(l),document.body.append(l),()=>l.remove()}),viewport$:r})))}function dp(e,{alert$:t}){return t.pipe(g(r=>R(Y(!0),Y(!1).pipe(It(2e3))).pipe(f(n=>({message:r,active:n})))))}function Fs(e,t){let r=G(".md-typeset",e);return j(()=>{let n=new I;return n.subscribe(({message:o,active:i})=>{e.classList.toggle("md-dialog--active",i),r.textContent=o}),dp(e,t).pipe($(o=>n.next(o)),V(()=>n.complete()),f(o=>H({ref:e},o)))})}function hp({viewport$:e}){if(!X("header.autohide"))return Y(!1);let t=e.pipe(f(({offset:{y:o}})=>o),Pt(2,1),f(([o,i])=>[o<i,i]),fe(0)),r=re([e,t]).pipe(L(([{offset:o},[,i]])=>Math.abs(i-o.y)>100),f(([,[o]])=>o),ie()),n=Tn("search");return re([e,n]).pipe(f(([{offset:o},i])=>o.y>400&&!i),ie(),g(o=>o?r:Y(!1)),J(!1))}function Us(e,t){return j(()=>re([Re(e),hp(t)])).pipe(f(([{height:r},n])=>({height:r,hidden:n})),ie((r,n)=>r.height===n.height&&r.hidden===n.hidden),se(1))}function Ns(e,{viewport$:t,header$:r,main$:n}){return j(()=>{let o=new I,i=o.pipe(he(),ye(!0));o.pipe(fe("active"),Ze(r)).subscribe(([{active:s},{hidden:c}])=>{e.classList.toggle("md-header--shadow",s&&!c),e.hidden=c});let a=me(P("[title]",e)).pipe(L(()=>X("content.tooltips")),oe(s=>Ge(s,{viewport$:t})));return n.subscribe(o),r.pipe(Q(i),f(s=>H({ref:e},s)),Rt(a.pipe(Q(i))))})}function vp(e,{viewport$:t,header$:r}){return Sn(e,{viewport$:t,header$:r}).pipe(f(({offset:{y:n}})=>{let{height:o}=Ae(e);return{active:o>0&&n>=o}}),fe("active"))}function Ds(e,t){return j(()=>{let r=new I;r.subscribe({next({active:o}){e.classList.toggle("md-header__title--active",o)},complete(){e.classList.remove("md-header__title--active")}});let n=Le(".md-content h1");return typeof n=="undefined"?y:vp(n,t).pipe($(o=>r.next(o)),V(()=>r.complete()),f(o=>H({ref:e},o)))})}function Ws(e,{viewport$:t,header$:r}){let n=r.pipe(f(({height:i})=>i),ie()),o=n.pipe(g(()=>Re(e).pipe(f(({height:i})=>({top:e.offsetTop,bottom:e.offsetTop+i})),fe("bottom"))));return re([n,o,t]).pipe(f(([i,{top:a,bottom:s},{offset:{y:c},size:{height:l}}])=>(l=Math.max(0,l-Math.max(0,a-c,i)-Math.max(0,l+c-s)),{offset:a-i,height:l,active:a-i<=c})),ie((i,a)=>i.offset===a.offset&&i.height===a.height&&i.active===a.active))}function bp(e){let t=__md_get("__palette")||{index:e.findIndex(n=>matchMedia(n.getAttribute("data-md-color-media")).matches)},r=Math.max(0,Math.min(t.index,e.length-1));return Y(...e).pipe(oe(n=>b(n,"change").pipe(f(()=>n))),J(e[r]),f(n=>({index:e.indexOf(n),color:{media:n.getAttribute("data-md-color-media"),scheme:n.getAttribute("data-md-color-scheme"),primary:n.getAttribute("data-md-color-primary"),accent:n.getAttribute("data-md-color-accent")}})),se(1))}function Vs(e){let t=P("input",e),r=A("meta",{name:"theme-color"});document.head.appendChild(r);let n=A("meta",{name:"color-scheme"});document.head.appendChild(n);let o=Ir("(prefers-color-scheme: light)");return j(()=>{let i=new I;return i.subscribe(a=>{if(document.body.setAttribute("data-md-color-switching",""),a.color.media==="(prefers-color-scheme)"){let s=matchMedia("(prefers-color-scheme: light)"),c=document.querySelector(s.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");a.color.scheme=c.getAttribute("data-md-color-scheme"),a.color.primary=c.getAttribute("data-md-color-primary"),a.color.accent=c.getAttribute("data-md-color-accent")}for(let[s,c]of Object.entries(a.color))document.body.setAttribute(`data-md-color-${s}`,c);for(let s=0;s<t.length;s++){let c=t[s].nextElementSibling;c instanceof HTMLElement&&(c.hidden=a.index!==s)}__md_set("__palette",a)}),b(e,"keydown").pipe(L(a=>a.key==="Enter"),pe(i,(a,s)=>s)).subscribe(({index:a})=>{a=(a+1)%t.length,t[a].click(),t[a].focus()}),i.pipe(f(()=>{let a=ht("header"),s=window.getComputedStyle(a);return n.content=s.colorScheme,s.backgroundColor.match(/\d+/g).map(c=>(+c).toString(16).padStart(2,"0")).join("")})).subscribe(a=>r.content=`#${a}`),i.pipe(Ie(ge)).subscribe(()=>{document.body.removeAttribute("data-md-color-switching")}),bp(t).pipe(Q(o.pipe(ke(1))),jt(),$(a=>i.next(a)),V(()=>i.complete()),f(a=>H({ref:e},a)))})}function zs(e,{progress$:t}){return j(()=>{let r=new I;return r.subscribe(({value:n})=>{e.style.setProperty("--md-progress-value",`${n}`)}),t.pipe($(n=>r.next({value:n})),V(()=>r.complete()),f(n=>({ref:e,value:n})))})}var qs='.v u{text-decoration:underline!important;text-decoration-style:wavy!important;text-decoration-thickness:1px!important}.p{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-backdrop)/var(--alpha-lighter));cursor:pointer;height:100%;pointer-events:auto;position:absolute;transition:opacity .25s;width:100%}.p.m{opacity:0;pointer-events:none;transition:opacity .35s}.r{align-items:center;background-color:initial;border:none;border-radius:var(--space-2);cursor:pointer;display:flex;flex-shrink:0;font-family:var(--font-family);height:36px;justify-content:center;outline:none;padding:0;position:relative;transition:background-color .25s,color .25s;width:36px;z-index:1}.r svg{stroke:rgb(var(--color-foreground));height:18px;opacity:.5;width:18px}.r:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.r:hover:before{opacity:1;transform:scale(1)}.r.c{cursor:auto}.r.c:before{display:none}.n{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background)/var(--alpha-light));border-radius:var(--space-3);box-shadow:0 0 60px #0000000d;display:flex;height:480px;overflow:hidden;pointer-events:auto;position:absolute;transition:transform .25s cubic-bezier(.16,1,.3,1),opacity .25s;width:640px}.n.l{opacity:0;pointer-events:none;transform:scale(1.1);transition:transform .25s .15s,opacity .15s}@media (max-width:680px){.n{border-radius:0;height:100%;width:100%}}.u{display:flex;flex-basis:min-content;flex-direction:column;flex-grow:1;flex-shrink:0}@keyframes d{0%{transform:scale(0)}50%{transform:scale(1.2)}to{transform:scale(1)}}.y{animation:d .25s ease-in-out;background:var(--color-highlight);border-radius:100%;color:#fff;font-size:8px;font-weight:700;height:12px;padding-top:1px;position:absolute;right:4px;top:4px;width:12px}.i{background-color:rgb(var(--color-background-subtle)/var(--alpha-lighter));flex-shrink:0;overflow:scroll;position:relative;transition:width .35s cubic-bezier(.16,1,.3,1),opacity .25s;width:200px}.i>*{transform:translate(0);transition:transform .25s cubic-bezier(.16,1,.3,1)}.i.l{opacity:0;width:0}.i.l>*{transform:translate(-48px)}@media (max-width:680px){.i{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background-subtle)/var(--alpha-light));box-shadow:0 0 60px #00000026;height:100%;position:absolute;right:0;top:0}}.w{border-bottom:1px solid rgb(var(--color-foreground)/var(--alpha-lightest));display:flex;gap:var(--space-1);padding:var(--space-2)}.k{-webkit-overflow-scrolling:touch;overflow:auto;overscroll-behavior:contain}.z{padding:8px 10px}.X{color:rgb(var(--color-foreground)/var(--alpha-light));padding:var(--space-2);position:absolute;width:200px}.X,.j{display:flex;flex-direction:column}.j{gap:2px;list-style:none;padding:0}.F,.j{margin:0}.F{font-size:16px;font-weight:400}.F,.I{padding:8px}.I{font-size:14px;margin:4px 0 0;opacity:.5}.I,.o{font-size:12px}.o{cursor:pointer;display:flex;padding:4px 8px;position:relative}.o:before{background-color:var(--color-highlight-transparent);border-radius:var(--space-1);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.o.g:before,.o:hover:before{opacity:1;transform:scale(1)}.o.g,.o:hover{color:var(--color-highlight)}.R{flex-grow:1}.R,.q{position:relative}.q{font-weight:700}.f{flex-grow:1}.f input{background:#0000;border:none;color:rgb(var(--color-foreground));font-family:var(--font-family);font-size:16px;height:100%;letter-spacing:-.25px;outline:none;width:100%}.b{color:rgb(var(--color-foreground)/var(--alpha-light));display:flex;flex-direction:column;gap:2px;line-height:1.3;list-style:none;margin:var(--space-2);margin-top:0;padding:0}.A,.b li{margin:0}.A{color:rgb(var(--color-foreground)/var(--alpha-lighter));font-size:12px;margin-top:var(--space-2);padding:0 18px}.a{border-radius:var(--space-2);color:inherit;cursor:pointer;display:flex;flex-direction:row;flex-grow:1;padding:8px 10px;position:relative;text-decoration:none}.a:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";display:block;inset:0;opacity:0;position:absolute;transform:scale(.9);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.a.h:before,.a:hover:before{opacity:1;transform:scale(1)}}.a mark{background:#0000;color:var(--color-highlight)}.a u{background-color:var(--color-highlight-transparent);border-radius:2px;box-shadow:0 0 0 1px var(--color-highlight-transparent);text-decoration:none}.B{flex-grow:1}.s{margin-right:-8px;opacity:0;position:relative;transform:translate(-2px);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.h>.s,:hover>.s{opacity:1;transform:none}}.x{font-size:14px;margin:0;position:relative}.x code{background:rgb(var(--color-background-subtle));border-radius:var(--space-1);font-size:13px;padding:2px 4px}.t{color:rgb(var(--color-foreground)/var(--alpha-lighter));display:inline-flex;flex-wrap:wrap;font-size:12px;gap:var(--space-1);list-style:none;margin:0;padding:0;position:relative}.t li{white-space:nowrap}.t li:after{content:"/";display:inline;margin-left:var(--space-1)}.t li:last-child:after{content:"";display:none}.e{--space-1:4px;--space-2:calc(var(--space-1)*2);--space-3:calc(var(--space-2)*2);--space-4:calc(var(--space-3)*2);--space-5:calc(var(--space-4)*2);--alpha-light:.7;--alpha-lighter:.54;--alpha-lightest:.1;--color-highlight:var(--md-accent-fg-color,#526cfe);--color-highlight-transparent:var(--md-accent-fg-color--transparent,#526cfe1a);--border-radius-1:var(--space-1);--border-radius-2:var(--space-2);--border-radius-3:calc(var(--space-1) + var(--space-2));--font-family:var(--md-text-font-family,Inter,Roboto Flex,system-ui,sans-serif);--font-size:16px;--line-height:1.5;--letter-spacing:-.5px;-webkit-font-smoothing:antialiased;align-items:center;display:flex;font-family:var(--font-family);font-size:var(--font-size);height:100vh;justify-content:center;letter-spacing:var(--letter-spacing);line-height:var(--line-height);pointer-events:none;position:absolute;width:100vw}@media (pointer:coarse){.e{height:-webkit-fill-available}}.e *,.e :after,.e :before{box-sizing:border-box}';function Ks(e,{index$:t}){let r=Ue(),n=document.createElement("div");document.body.appendChild(n),n.style.position="fixed",n.style.height="100%",n.style.top="0",n.style.zIndex="4";let o=n.attachShadow({mode:"open"});o.appendChild(A("style",{},qs.toString()));try{Ya(r.search,{highlight:r.features.includes("search.highlight")}),me(t).subscribe(i=>{for(let a of i.items)a.location=new URL(a.location,r.base).toString();Ja(i,o)}),b(e,"click").subscribe(()=>{go()}),Tn("search").pipe(ke(1)).subscribe(()=>go())}catch(i){e.hidden=!0;let a=G("label[for=__search]");a.hidden=!0}return Ke}var Bs=_r(So());function Ys(e,{index$:t,location$:r}){return re([t,r.pipe(J(Ye()),L(n=>!!n.searchParams.get("h")))]).pipe(f(([n,o])=>_p(n.config)(o.searchParams.get("h"))),f(n=>{var a;let o=new Map,i=document.createNodeIterator(e,NodeFilter.SHOW_TEXT);for(let s=i.nextNode();s;s=i.nextNode())if((a=s.parentElement)!=null&&a.offsetHeight){let c=s.textContent,l=n(c);l.length>c.length&&o.set(s,l)}for(let[s,c]of o){let{childNodes:l}=A("span",null,c);s.replaceWith(...Array.from(l))}return{ref:e,nodes:o}}))}function _p(e){let t=e.separator.split("|").map(o=>o.replace(/(\(\?[!=<][^)]+\))/g,"").length===0?"\uFFFD":o).join("|"),r=new RegExp(t,"img"),n=(o,i,a)=>`${i}<mark data-md-highlight>${a}</mark>`;return o=>{o=o.replace(/\s+/g," ").replace(/&/g,"&amp;").trim();let i=new RegExp(`(^|${e.separator}|)(${o.split(r).map(a=>a.replace(/[|\\{}()[\]^$+*?.-]/g,"\\$&")).filter(a=>a.length>0).join("|")})`,"img");return a=>(0,Bs.default)(a).replace(i,n).replace(/<\/mark>(\s+)<mark[^>]*>/img,"$1")}}function yp(e,{viewport$:t,main$:r}){let n=e.closest(".md-grid"),o=n.offsetTop-n.parentElement.offsetTop;return re([r,t]).pipe(f(([{offset:i,height:a},{offset:{y:s}}])=>(a=a+Math.min(o,Math.max(0,s-i))-o,{height:a,locked:s>=i+o})),ie((i,a)=>i.height===a.height&&i.locked===a.locked))}function Ao(e,n){var o=n,{header$:t}=o,r=gr(o,["header$"]);let i=G(".md-sidebar__scrollwrap",e),{y:a}=wt(i);return j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=s.pipe(Xe(0,je));return l.pipe(pe(t)).subscribe({next([{height:u},{height:p}]){i.style.height=`${u-2*a}px`,e.style.top=`${p}px`},complete(){i.style.height="",e.style.top=""}}),l.pipe(Sr()).subscribe(()=>{for(let u of P(".md-nav__link--active[href]",e)){if(!u.clientHeight)continue;let p=u.closest(".md-sidebar__scrollwrap");if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2})}}}),me(P("label[tabindex]",e)).pipe(oe(u=>b(u,"click").pipe(Ie(ge),f(()=>u),Q(c)))).subscribe(u=>{let p=G(`[id="${u.htmlFor}"]`);G(`[aria-labelledby="${u.id}"]`).setAttribute("aria-expanded",`${p.checked}`)}),X("content.tooltips")&&me(P("abbr[title]",e)).pipe(oe(u=>Ge(u,{viewport$})),Q(c)).subscribe(),yp(e,r).pipe($(u=>s.next(u)),V(()=>s.complete()),f(u=>H({ref:e},u)))})}function Gs(e,t){if(typeof t!="undefined"){let r=`https://api.github.com/repos/${e}/${t}`;return $t(et(`${r}/releases/latest`).pipe(_e(()=>y),f(n=>({version:n.tag_name})),ot({})),et(r).pipe(_e(()=>y),f(n=>({stars:n.stargazers_count,forks:n.forks_count})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}else{let r=`https://api.github.com/users/${e}`;return et(r).pipe(f(n=>({repositories:n.public_repos})),ot({}))}}function Js(e,t){let r=`https://${e}/api/v4/projects/${encodeURIComponent(t)}`;return $t(et(`${r}/releases/permalink/latest`).pipe(_e(()=>y),f(({tag_name:n})=>({version:n})),ot({})),et(r).pipe(_e(()=>y),f(({star_count:n,forks_count:o})=>({stars:n,forks:o})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}function Xs(e){let t=e.match(/^.+github\.com\/([^/]+)\/?([^/]+)?/i);if(t){let[,r,n]=t;return Gs(r,n)}if(t=e.match(/^.+?([^/]*gitlab[^/]+)\/(.+?)\/?$/i),t){let[,r,n]=t;return Js(r,n)}return y}var xp;function wp(e){return xp||(xp=j(()=>{let t=__md_get("__source",sessionStorage);if(t)return Y(t);if(Ee("consent").length){let n=__md_get("__consent");if(!(n&&n.github))return y}return Xs(e.href).pipe($(n=>__md_set("__source",n,sessionStorage)))}).pipe(_e(()=>y),L(t=>Object.keys(t).length>0),f(t=>({facts:t})),se(1)))}function Zs(e){let t=G(":scope > :last-child",e);return j(()=>{let r=new I;return r.subscribe(({facts:n})=>{t.appendChild(bs(n)),t.classList.add("md-source__repository--active")}),wp(e).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Ep(e,{viewport$:t,header$:r}){return Re(document.body).pipe(g(()=>Sn(e,{header$:r,viewport$:t})),f(({offset:{y:n}})=>({hidden:n>=10})),fe("hidden"))}function Qs(e,t){return j(()=>{let r=new I;return r.subscribe({next({hidden:n}){e.hidden=n},complete(){e.hidden=!1}}),(X("navigation.tabs.sticky")?Y({hidden:!1}):Ep(e,t)).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Tp(e,{viewport$:t,header$:r}){let n=new Map,o=P(".md-nav__link",e);for(let s of o){let c=decodeURIComponent(s.hash.substring(1)),l=Le(`[id="${c}"]`);typeof l!="undefined"&&n.set(s,l)}let i=r.pipe(fe("height"),f(({height:s})=>{let c=ht("main"),l=G(":scope > :first-child",c);return s+.9*(l.offsetTop-c.offsetTop)}),xe());return Re(document.body).pipe(fe("height"),g(s=>j(()=>{let c=[];return Y([...n].reduce((l,[u,p])=>{for(;c.length&&n.get(c[c.length-1]).tagName>=p.tagName;)c.pop();let d=p.offsetTop;for(;!d&&p.parentElement;)p=p.parentElement,d=p.offsetTop;let m=p.offsetParent;for(;m;m=m.offsetParent)d+=m.offsetTop;return l.set([...c=[...c,u]].reverse(),d)},new Map))}).pipe(f(c=>new Map([...c].sort(([,l],[,u])=>l-u))),Ze(i),g(([c,l])=>t.pipe(Or(([u,p],{offset:{y:d},size:m})=>{let h=d+m.height>=Math.floor(s.height);for(;p.length;){let[,v]=p[0];if(v-l<d||h)u=[...u,p.shift()];else break}for(;u.length;){let[,v]=u[u.length-1];if(v-l>=d&&!h)p=[u.pop(),...p];else break}return[u,p]},[[],[...c]]),ie((u,p)=>u[0]===p[0]&&u[1]===p[1])))))).pipe(f(([s,c])=>({prev:s.map(([l])=>l),next:c.map(([l])=>l)})),J({prev:[],next:[]}),Pt(2,1),f(([s,c])=>s.prev.length<c.prev.length?{prev:c.prev.slice(Math.max(0,s.prev.length-1),c.prev.length),next:[]}:{prev:c.prev.slice(-1),next:c.next.slice(0,c.next.length-s.next.length)}))}function ec(e,{viewport$:t,header$:r,main$:n,target$:o}){return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));if(i.subscribe(({prev:s,next:c})=>{for(let[l]of c)l.classList.remove("md-nav__link--passed"),l.classList.remove("md-nav__link--active");for(let[l,[u]]of s.entries())u.classList.add("md-nav__link--passed"),u.classList.toggle("md-nav__link--active",l===s.length-1)}),X("toc.follow")){let s=R(t.pipe(Be(1),f(()=>{})),t.pipe(Be(250),f(()=>"smooth")));i.pipe(L(({prev:c})=>c.length>0),Ze(n.pipe(Ie(ge))),pe(s)).subscribe(([[{prev:c}],l])=>{let[u]=c[c.length-1];if(u.offsetHeight){let p=ki(u);if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2,behavior:l})}}})}return X("navigation.tracking")&&t.pipe(Q(a),fe("offset"),Be(250),ke(1),Q(o.pipe(ke(1))),jt({delay:250}),pe(i)).subscribe(([,{prev:s}])=>{let c=Ye(),l=s[s.length-1];if(l&&l.length){let[u]=l,{hash:p}=new URL(u.href);c.hash!==p&&(c.hash=p,history.replaceState({},"",`${c}`))}else c.hash="",history.replaceState({},"",`${c}`)}),Tp(e,{viewport$:t,header$:r}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function Sp(e,{viewport$:t,main$:r,target$:n}){let o=t.pipe(f(({offset:{y:a}})=>a),Pt(2,1),f(([a,s])=>a>s&&s>0),ie()),i=r.pipe(f(({active:a})=>a));return re([i,o]).pipe(f(([a,s])=>!(a&&s)),ie(),Q(n.pipe(ke(1))),ye(!0),jt({delay:250}),f(a=>({hidden:a})))}function tc(e,{viewport$:t,header$:r,main$:n,target$:o}){let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({hidden:s}){e.hidden=s,s?(e.setAttribute("tabindex","-1"),e.blur()):e.removeAttribute("tabindex")},complete(){e.style.top="",e.hidden=!0,e.removeAttribute("tabindex")}}),r.pipe(Q(a),fe("height")).subscribe(({height:s})=>{e.style.top=`${s+16}px`}),b(e,"click").subscribe(s=>{s.preventDefault(),window.scrollTo({top:0})}),Sp(e,{viewport$:t,main$:n,target$:o}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))}function rc(e,t){return e.protocol=t.protocol,e.hostname=t.hostname,t.port&&(e.port=t.port),e}function Op(e,t){let r=new Map;for(let n of P("url",e)){let o=G("loc",n),i=[rc(new URL(o.textContent),t)];r.set(`${i[0]}`,i);for(let a of P("[rel=alternate]",n)){let s=a.getAttribute("href");s!=null&&i.push(rc(new URL(s),t))}}return r}function dr(e){return ns(new URL("sitemap.xml",e)).pipe(f(t=>Op(t,new URL(e))),_e(()=>Y(new Map)),xe())}function nc({document$:e}){let t=new Map;e.pipe(g(()=>P("link[rel=alternate]")),f(r=>new URL(r.href)),L(r=>!t.has(r.toString())),oe(r=>dr(r).pipe(f(n=>[r,n]),_e(()=>y)))).subscribe(([r,n])=>{t.set(r.toString().replace(/\/$/,""),n)}),b(document.body,"click").pipe(L(r=>!r.metaKey&&!r.ctrlKey),g(r=>{if(r.target instanceof Element){let n=r.target.closest("a");if(n&&!n.target){let o=[...t].find(([p])=>n.href.startsWith(`${p}/`));if(typeof o=="undefined")return y;let[i,a]=o,s=Ye();if(s.href.startsWith(i))return y;let c=Ue(),l=s.href.replace(c.base,"");l=`${i}/${l}`;let u=a.has(l.split("#")[0])?new URL(l,c.base):new URL(i);return r.preventDefault(),Y(u)}}return y})).subscribe(r=>dt(r,!0))}var Co=_r(Mo());function Lp(e){e.setAttribute("data-md-copying","");let t=e.closest("[data-copy]"),r=t?t.getAttribute("data-copy"):e.innerText;return e.removeAttribute("data-md-copying"),r.trimEnd()}function oc({alert$:e}){Co.default.isSupported()&&new U(t=>{new Co.default("[data-clipboard-target], [data-clipboard-text]",{text:r=>r.getAttribute("data-clipboard-text")||Lp(G(r.getAttribute("data-clipboard-target")))}).on("success",r=>t.next(r))}).pipe($(t=>{t.trigger.focus()}),f(()=>Bt("clipboard.copied"))).subscribe(e)}function ic(e,t){if(!(e.target instanceof Element))return y;let r=e.target.closest("a");if(r===null)return y;if(r.target||e.metaKey||e.ctrlKey)return y;let n=new URL(r.href);return n.search=n.hash="",t.has(`${n}`)?(e.preventDefault(),Y(r)):y}function ac(e){let t=new Map;for(let r of P(":scope > *",e.head))t.set(r.outerHTML,r);return t}function sc(e){for(let t of P("[href], [src]",e))for(let r of["href","src"]){let n=t.getAttribute(r);if(n&&!/^(?:[a-z]+:)?\/\//i.test(n)){t[r]=t[r];break}}return Y(e)}function Mp(e){for(let n of["[data-md-component=announce]","[data-md-component=container]","[data-md-component=header-topic]","[data-md-component=outdated]","[data-md-component=logo]","[data-md-component=skip]",...X("navigation.tabs.sticky")?["[data-md-component=tabs]"]:[]]){let o=Le(n),i=Le(n,e);typeof o!="undefined"&&typeof i!="undefined"&&o.replaceWith(i)}let t=ac(document);for(let[n,o]of ac(e))t.has(n)?t.delete(n):document.head.appendChild(o);for(let n of t.values()){let o=n.getAttribute("name");o!=="theme-color"&&o!=="color-scheme"&&n.remove()}let r=ht("container");return nt(P("script",r)).pipe(g(n=>{let o=e.createElement("script");if(n.src){for(let i of n.getAttributeNames())o.setAttribute(i,n.getAttribute(i));return n.replaceWith(o),new U(i=>{o.onload=()=>i.complete()})}else return o.textContent=n.textContent,n.replaceWith(o),y}),he(),ye(document))}function cc({sitemap$:e,location$:t,viewport$:r,progress$:n}){if(location.protocol==="file:")return Ke;Y(document).subscribe(sc);let o=b(document.body,"click").pipe(Ze(e),g(([s,c])=>ic(s,c)),f(({href:s})=>new URL(s)),xe()),i=b(window,"popstate").pipe(f(Ye),xe());o.pipe(pe(r)).subscribe(([s,{offset:c}])=>{history.replaceState(c,""),history.pushState(null,"",s)}),R(o,i).subscribe(t);let a=t.pipe(fe("pathname"),g(s=>En(s,{progress$:n}).pipe(_e(()=>(dt(s,!0),y)))),g(sc),g(Mp),xe());return R(a.pipe(pe(t,(s,c)=>c)),a.pipe(g(()=>t),fe("hash")),t.pipe(ie((s,c)=>s.pathname===c.pathname&&s.hash===c.hash),g(()=>o),$(()=>history.back()))).subscribe(s=>{var c,l;history.state!==null||!s.hash?window.scrollTo(0,(l=(c=history.state)==null?void 0:c.y)!=null?l:0):(history.scrollRestoration="auto",es(s.hash),history.scrollRestoration="manual")}),t.subscribe(()=>{history.scrollRestoration="manual"}),b(window,"beforeunload").subscribe(()=>{history.scrollRestoration="auto"}),r.pipe(fe("offset"),Be(100)).subscribe(({offset:s})=>{history.replaceState(s,"")}),X("navigation.instant.prefetch")&&R(b(document.body,"mousemove"),b(document.body,"focusin")).pipe(Ze(e),g(([s,c])=>ic(s,c)),Be(25),Yn(({href:s})=>s),cn(s=>{let c=document.createElement("link");return c.rel="prefetch",c.href=s.toString(),document.head.appendChild(c),b(c,"load").pipe(f(()=>c),Me(1))})).subscribe(s=>s.remove()),a}function lc(e){var u;let{selectedVersionSitemap:t,selectedVersionBaseURL:r,currentLocation:n,currentBaseURL:o}=e,i=(u=Ho(o))==null?void 0:u.pathname;if(i===void 0)return;let a=kp(n.pathname,i);if(a===void 0)return;let s=Cp(t.keys());if(!t.has(s))return;let c=Ho(a,s);if(!c||!t.has(c.href))return;let l=Ho(a,r);if(l)return l.hash=n.hash,l.search=n.search,l}function Ho(e,t){try{return new URL(e,t)}catch(r){return}}function kp(e,t){if(e.startsWith(t))return e.slice(t.length)}function Ap(e,t){let r=Math.min(e.length,t.length),n;for(n=0;n<r&&e[n]===t[n];++n);return n}function Cp(e){let t;for(let r of e)t===void 0?t=r:t=t.slice(0,Ap(t,r));return t!=null?t:""}function uc({document$:e}){let t=Ue(),r=et(new URL("../versions.json",t.base)).pipe(_e(()=>y)),n=r.pipe(f(o=>{let[,i]=t.base.match(/([^/]+)\/?$/);return o.find(({version:a,aliases:s})=>a===i||s.includes(i))||o[0]}));r.pipe(f(o=>new Map(o.map(i=>[`${new URL(`../${i.version}/`,t.base)}`,i]))),g(o=>b(document.body,"click").pipe(L(i=>!i.metaKey&&!i.ctrlKey),pe(n),g(([i,a])=>{if(i.target instanceof Element){let s=i.target.closest("a");if(s&&!s.target&&o.has(s.href)){let c=s.href;return!i.target.closest(".md-version")&&o.get(c)===a?y:(i.preventDefault(),Y(new URL(c)))}}return y}),g(i=>dr(i).pipe(f(a=>{var s;return(s=lc({selectedVersionSitemap:a,selectedVersionBaseURL:i,currentLocation:Ye(),currentBaseURL:t.base}))!=null?s:i})))))).subscribe(o=>dt(o,!0)),re([r,n]).subscribe(([o,i])=>{G(".md-header__topic").appendChild(_s(o,i))}),e.pipe(g(()=>n)).subscribe(o=>{var s;let i=new URL(t.base),a=__md_get("__outdated",sessionStorage,i);if(a===null){a=!0;let c=((s=t.version)==null?void 0:s.default)||"latest";Array.isArray(c)||(c=[c]);e:for(let l of c)for(let u of o.aliases.concat(o.version))if(new RegExp(l,"i").test(u)){a=!1;break e}__md_set("__outdated",a,sessionStorage,i)}if(a)for(let c of Ee("outdated"))c.hidden=!1})}function pc({document$:e,viewport$:t}){e.pipe(g(()=>P(".md-ellipsis")),oe(r=>Et(r).pipe(Q(e.pipe(ke(1))),L(n=>n),f(()=>r),Me(1))),L(r=>r.offsetWidth<r.scrollWidth),oe(r=>{let n=r.innerText,o=r.closest("a")||r;return o.title=n,X("content.tooltips")?Ge(o,{viewport$:t}).pipe(Q(e.pipe(ke(1))),V(()=>o.removeAttribute("title"))):y})).subscribe(),X("content.tooltips")&&e.pipe(g(()=>P(".md-status")),oe(r=>Ge(r,{viewport$:t}))).subscribe()}function fc({document$:e,tablet$:t}){e.pipe(g(()=>P(".md-toggle--indeterminate")),$(r=>{r.indeterminate=!0,r.checked=!1}),oe(r=>b(r,"change").pipe(Xn(()=>r.classList.contains("md-toggle--indeterminate")),f(()=>r))),pe(t)).subscribe(([r,n])=>{r.classList.remove("md-toggle--indeterminate"),n&&(r.checked=!1)})}function Hp(){return/(iPad|iPhone|iPod)/.test(navigator.userAgent)}function mc({document$:e}){e.pipe(g(()=>P("[data-md-scrollfix]")),$(t=>t.removeAttribute("data-md-scrollfix")),L(Hp),oe(t=>b(t,"touchstart").pipe(f(()=>t)))).subscribe(t=>{let r=t.scrollTop;r===0?t.scrollTop=1:r+t.offsetHeight===t.scrollHeight&&(t.scrollTop=r-1)})}Object.entries||(Object.entries=function(e){let t=[];for(let r of Object.keys(e))t.push([r,e[r]]);return t});Object.values||(Object.values=function(e){let t=[];for(let r of Object.keys(e))t.push(e[r]);return t});typeof Element!="undefined"&&(Element.prototype.scrollTo||(Element.prototype.scrollTo=function(e,t){typeof e=="object"?(this.scrollLeft=e.left,this.scrollTop=e.top):(this.scrollLeft=e,this.scrollTop=t)}),Element.prototype.replaceWith||(Element.prototype.replaceWith=function(...e){let t=this.parentNode;if(t){e.length===0&&t.removeChild(this);for(let r=e.length-1;r>=0;r--){let n=e[r];typeof n=="string"?n=document.createTextNode(n):n.parentNode&&n.parentNode.removeChild(n),r?t.insertBefore(this.previousSibling,n):t.replaceChild(n,this)}}}));function $p(){return location.protocol==="file:"?ar(`${new URL("search.js",Mn.base)}`).pipe(f(()=>__index),_e(()=>Ke),se(1)):et(new URL("search.json",Mn.base))}document.documentElement.classList.remove("no-js");document.documentElement.classList.add("js");var vt=Si(),Ur=Za(),hr=ts(Ur),hc=Xa(),ze=cs(),$o=Ir("(min-width: 60em)"),vc=Ir("(min-width: 76.25em)"),bc=rs(),Mn=Ue(),gc=Le(".md-search")?$p():Ke,Po=new I;oc({alert$:Po});nc({document$:vt});var Io=new I,_c=dr(Mn.base);X("navigation.instant")&&cc({sitemap$:_c,location$:Ur,viewport$:ze,progress$:Io}).subscribe(vt);var dc;((dc=Mn.version)==null?void 0:dc.provider)==="mike"&&uc({document$:vt});R(Ur,hr).pipe(It(125)).subscribe(()=>{Eo("drawer",!1),Eo("search",!1)});hc.pipe(L(({mode:e,meta:t})=>e==="global"&&!t)).subscribe(e=>{switch(e.type){case",":case"p":let t=document.querySelector("link[rel=prev]");t instanceof HTMLLinkElement&&dt(t);break;case".":case"n":let r=document.querySelector("link[rel=next]");r instanceof HTMLLinkElement&&dt(r);break;case"/":let n=document.querySelector("[data-md-component=search] button");n instanceof HTMLButtonElement&&n.click();break;case"Enter":let o=xt();o instanceof HTMLLabelElement&&o.click()}});pc({viewport$:ze,document$:vt});fc({document$:vt,tablet$:$o});mc({document$:vt});var Lt=Us(ht("header"),{viewport$:ze}),Fr=vt.pipe(f(()=>ht("main")),g(e=>Ws(e,{viewport$:ze,header$:Lt})),se(1)),Pp=R(...Ee("consent").map(e=>us(e,{target$:hr})),...Ee("dialog").map(e=>Fs(e,{alert$:Po})),...Ee("palette").map(e=>Vs(e)),...Ee("progress").map(e=>zs(e,{progress$:Io})),...Ee("search").map(e=>Ks(e,{index$:gc})),...Ee("source").map(e=>Zs(e))),Ip=j(()=>R(...Ee("announce").map(e=>ls(e)),...Ee("content").map(e=>js(e,{sitemap$:_c,viewport$:ze,target$:hr,print$:bc})),...Ee("content").map(e=>X("search.highlight")?Ys(e,{index$:gc,location$:Ur}):y),...Ee("header").map(e=>Ns(e,{viewport$:ze,header$:Lt,main$:Fr})),...Ee("header-title").map(e=>Ds(e,{viewport$:ze,header$:Lt})),...Ee("sidebar").map(e=>e.getAttribute("data-md-type")==="navigation"?yo(vc,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr})):yo($o,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr}))),...Ee("tabs").map(e=>Qs(e,{viewport$:ze,header$:Lt})),...Ee("toc").map(e=>ec(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})),...Ee("top").map(e=>tc(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})))),yc=vt.pipe(g(()=>Ip),Rt(Pp),se(1));yc.subscribe();window.document$=vt;window.location$=Ur;window.target$=hr;window.keyboard$=hc;window.viewport$=ze;window.tablet$=$o;window.screen$=vc;window.print$=bc;window.alert$=Po;window.progress$=Io;window.component$=yc;})();
-/*! update cache: 20260331044536 */
+/*! update cache: 20260331053229 */
diff --git a/ru/chapter_appendix/contribution/index.html b/ru/chapter_appendix/contribution/index.html
index 148b312fc..0df9cdd21 100644
--- a/ru/chapter_appendix/contribution/index.html
+++ b/ru/chapter_appendix/contribution/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_appendix/index.html b/ru/chapter_appendix/index.html
index 13731e1ed..a4febd6c9 100644
--- a/ru/chapter_appendix/index.html
+++ b/ru/chapter_appendix/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_appendix/installation/index.html b/ru/chapter_appendix/installation/index.html
index 60d54ae34..e8c77d7e7 100644
--- a/ru/chapter_appendix/installation/index.html
+++ b/ru/chapter_appendix/installation/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_appendix/terminology/index.html b/ru/chapter_appendix/terminology/index.html
index 937edd689..c797fba90 100644
--- a/ru/chapter_appendix/terminology/index.html
+++ b/ru/chapter_appendix/terminology/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_array_and_linkedlist/array/index.html b/ru/chapter_array_and_linkedlist/array/index.html
index 42c6e4304..1ff18a5db 100644
--- a/ru/chapter_array_and_linkedlist/array/index.html
+++ b/ru/chapter_array_and_linkedlist/array/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1475,7 +1475,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1757,7 +1757,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1779,7 +1779,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1857,7 +1857,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1952,7 +1952,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1974,7 +1974,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2052,7 +2052,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2136,7 +2136,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2299,7 +2299,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2390,7 +2390,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2412,7 +2412,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2462,7 +2462,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2518,7 +2518,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2657,7 +2657,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2685,7 +2685,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2713,7 +2713,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2741,7 +2741,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2946,7 +2946,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2974,7 +2974,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3279,7 +3279,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3307,7 +3307,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3584,7 +3584,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3725,7 +3725,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3837,7 +3837,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_array_and_linkedlist/index.html b/ru/chapter_array_and_linkedlist/index.html
index 21db44401..875a52cb5 100644
--- a/ru/chapter_array_and_linkedlist/index.html
+++ b/ru/chapter_array_and_linkedlist/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4285,7 +4285,7 @@
 <li><a href="array/">4.1 &nbsp; Массив</a></li>
 <li><a href="linked_list/">4.2 &nbsp; Связный список</a></li>
 <li><a href="list/">4.3 &nbsp; Список</a></li>
-<li><a href="ram_and_cache/">4.4 &nbsp; Память и кеш *</a></li>
+<li><a href="ram_and_cache/">4.4 &nbsp; Оперативная память и кэш *</a></li>
 <li><a href="summary/">4.5 &nbsp; Резюме</a></li>
 </ul>
 
diff --git a/ru/chapter_array_and_linkedlist/linked_list/index.html b/ru/chapter_array_and_linkedlist/linked_list/index.html
index ae926a13f..40f492544 100644
--- a/ru/chapter_array_and_linkedlist/linked_list/index.html
+++ b/ru/chapter_array_and_linkedlist/linked_list/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1464,7 +1464,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1746,7 +1746,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1768,7 +1768,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1846,7 +1846,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1941,7 +1941,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1963,7 +1963,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2041,7 +2041,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2125,7 +2125,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2288,7 +2288,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2401,7 +2401,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2451,7 +2451,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2507,7 +2507,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2646,7 +2646,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2674,7 +2674,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2702,7 +2702,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2730,7 +2730,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2935,7 +2935,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2963,7 +2963,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3268,7 +3268,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3296,7 +3296,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3573,7 +3573,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3714,7 +3714,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3826,7 +3826,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_array_and_linkedlist/list/index.html b/ru/chapter_array_and_linkedlist/list/index.html
index 84bd205c7..d7b1e2ca7 100644
--- a/ru/chapter_array_and_linkedlist/list/index.html
+++ b/ru/chapter_array_and_linkedlist/list/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1453,7 +1453,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1735,7 +1735,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1757,7 +1757,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1835,7 +1835,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1930,7 +1930,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1952,7 +1952,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2030,7 +2030,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2114,7 +2114,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2277,7 +2277,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2390,7 +2390,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2440,7 +2440,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2496,7 +2496,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2635,7 +2635,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2663,7 +2663,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2691,7 +2691,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2719,7 +2719,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2924,7 +2924,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2952,7 +2952,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3257,7 +3257,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3285,7 +3285,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3562,7 +3562,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3703,7 +3703,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3815,7 +3815,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -6663,7 +6663,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../ram_and_cache/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 4.4 Память и кеш *"
+    aria-label="Вперед: 4.4 Оперативная память и кэш *"
     rel="next"
   >
     <div class="md-footer__title">
@@ -6671,7 +6671,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        4.4 Память и кеш *
+        4.4 Оперативная память и кэш *
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_array_and_linkedlist/ram_and_cache/index.html b/ru/chapter_array_and_linkedlist/ram_and_cache/index.html
index 6b898aa84..cdcf3d550 100644
--- a/ru/chapter_array_and_linkedlist/ram_and_cache/index.html
+++ b/ru/chapter_array_and_linkedlist/ram_and_cache/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1320,7 +1320,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1338,7 +1338,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1674,7 +1674,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1696,7 +1696,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1774,7 +1774,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1869,7 +1869,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1891,7 +1891,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1969,7 +1969,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2053,7 +2053,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_array_and_linkedlist/summary/index.html b/ru/chapter_array_and_linkedlist/summary/index.html
index 7e1ef6b78..0b208cc6f 100644
--- a/ru/chapter_array_and_linkedlist/summary/index.html
+++ b/ru/chapter_array_and_linkedlist/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4433,7 +4433,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../ram_and_cache/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 4.4 Память и кеш *"
+    aria-label="Назад: 4.4 Оперативная память и кэш *"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4445,7 +4445,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        4.4 Память и кеш *
+        4.4 Оперативная память и кэш *
       </div>
     </div>
   </a>
diff --git a/ru/chapter_backtracking/backtracking_algorithm/index.html b/ru/chapter_backtracking/backtracking_algorithm/index.html
index f18f992c9..a14f4c07b 100644
--- a/ru/chapter_backtracking/backtracking_algorithm/index.html
+++ b/ru/chapter_backtracking/backtracking_algorithm/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3534,7 +3534,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3675,7 +3675,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3787,7 +3787,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_backtracking/index.html b/ru/chapter_backtracking/index.html
index 68e792858..6cfb22f87 100644
--- a/ru/chapter_backtracking/index.html
+++ b/ru/chapter_backtracking/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4285,7 +4285,7 @@
 <li><a href="backtracking_algorithm/">13.1 &nbsp; Алгоритм поиска с возвратом</a></li>
 <li><a href="permutations_problem/">13.2 &nbsp; Задача о перестановках</a></li>
 <li><a href="subset_sum_problem/">13.3 &nbsp; Задача о сумме подмножеств</a></li>
-<li><a href="n_queens_problem/">13.4 &nbsp; Задача о <span class="arithmatex">\(n\)</span> ферзях</a></li>
+<li><a href="n_queens_problem/">13.4 &nbsp; Задача о n ферзях</a></li>
 <li><a href="summary/">13.5 &nbsp; Резюме</a></li>
 </ul>
 
diff --git a/ru/chapter_backtracking/n_queens_problem/index.html b/ru/chapter_backtracking/n_queens_problem/index.html
index 853675db6..9d747cda2 100644
--- a/ru/chapter_backtracking/n_queens_problem/index.html
+++ b/ru/chapter_backtracking/n_queens_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3429,7 +3429,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3447,7 +3447,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_backtracking/permutations_problem/index.html b/ru/chapter_backtracking/permutations_problem/index.html
index 2aaef3a28..f7272e486 100644
--- a/ru/chapter_backtracking/permutations_problem/index.html
+++ b/ru/chapter_backtracking/permutations_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3557,7 +3557,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3698,7 +3698,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3810,7 +3810,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_backtracking/subset_sum_problem/index.html b/ru/chapter_backtracking/subset_sum_problem/index.html
index 4dbd6e617..eb5ffd5ab 100644
--- a/ru/chapter_backtracking/subset_sum_problem/index.html
+++ b/ru/chapter_backtracking/subset_sum_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3557,7 +3557,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3698,7 +3698,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3810,7 +3810,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -6145,7 +6145,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../n_queens_problem/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 13.4 Задача о $n$ ферзях"
+    aria-label="Вперед: 13.4 Задача о n ферзях"
     rel="next"
   >
     <div class="md-footer__title">
@@ -6153,7 +6153,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        13.4 Задача о $n$ ферзях
+        13.4 Задача о n ферзях
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_backtracking/summary/index.html b/ru/chapter_backtracking/summary/index.html
index 23aa26733..9d11a9a75 100644
--- a/ru/chapter_backtracking/summary/index.html
+++ b/ru/chapter_backtracking/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4397,7 +4397,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../n_queens_problem/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 13.4 Задача о $n$ ферзях"
+    aria-label="Назад: 13.4 Задача о n ферзях"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4409,7 +4409,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        13.4 Задача о $n$ ферзях
+        13.4 Задача о n ферзях
       </div>
     </div>
   </a>
diff --git a/ru/chapter_computational_complexity/index.html b/ru/chapter_computational_complexity/index.html
index 401385768..44018c3e3 100644
--- a/ru/chapter_computational_complexity/index.html
+++ b/ru/chapter_computational_complexity/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_computational_complexity/iteration_and_recursion/index.html b/ru/chapter_computational_complexity/iteration_and_recursion/index.html
index c4fe629b0..85249a492 100644
--- a/ru/chapter_computational_complexity/iteration_and_recursion/index.html
+++ b/ru/chapter_computational_complexity/iteration_and_recursion/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1342,7 +1342,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1364,7 +1364,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1470,7 +1470,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1752,7 +1752,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1774,7 +1774,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1852,7 +1852,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1947,7 +1947,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1969,7 +1969,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2047,7 +2047,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2131,7 +2131,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2294,7 +2294,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2385,7 +2385,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2407,7 +2407,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2457,7 +2457,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2513,7 +2513,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2652,7 +2652,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2680,7 +2680,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2708,7 +2708,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2736,7 +2736,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2941,7 +2941,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2969,7 +2969,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3274,7 +3274,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3302,7 +3302,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3579,7 +3579,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3720,7 +3720,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3832,7 +3832,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_computational_complexity/performance_evaluation/index.html b/ru/chapter_computational_complexity/performance_evaluation/index.html
index 472dfae65..72dc1ebc8 100644
--- a/ru/chapter_computational_complexity/performance_evaluation/index.html
+++ b/ru/chapter_computational_complexity/performance_evaluation/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_computational_complexity/space_complexity/index.html b/ru/chapter_computational_complexity/space_complexity/index.html
index ea69a2403..8cd2392b7 100644
--- a/ru/chapter_computational_complexity/space_complexity/index.html
+++ b/ru/chapter_computational_complexity/space_complexity/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1336,7 +1336,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1358,7 +1358,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1464,7 +1464,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1746,7 +1746,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1768,7 +1768,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1846,7 +1846,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1941,7 +1941,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1963,7 +1963,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2041,7 +2041,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2125,7 +2125,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2288,7 +2288,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2401,7 +2401,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2451,7 +2451,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2507,7 +2507,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2646,7 +2646,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2674,7 +2674,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2702,7 +2702,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2730,7 +2730,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2935,7 +2935,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2963,7 +2963,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3268,7 +3268,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3296,7 +3296,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3573,7 +3573,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3714,7 +3714,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3826,7 +3826,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_computational_complexity/summary/index.html b/ru/chapter_computational_complexity/summary/index.html
index 4aa993b29..3b8d2a5ba 100644
--- a/ru/chapter_computational_complexity/summary/index.html
+++ b/ru/chapter_computational_complexity/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_computational_complexity/time_complexity/index.html b/ru/chapter_computational_complexity/time_complexity/index.html
index d46a47e50..585bbbbe3 100644
--- a/ru/chapter_computational_complexity/time_complexity/index.html
+++ b/ru/chapter_computational_complexity/time_complexity/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1397,7 +1397,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1419,7 +1419,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1525,7 +1525,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1807,7 +1807,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1829,7 +1829,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1907,7 +1907,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -2002,7 +2002,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -2024,7 +2024,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2102,7 +2102,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2186,7 +2186,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2349,7 +2349,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2440,7 +2440,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2462,7 +2462,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2512,7 +2512,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2568,7 +2568,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2707,7 +2707,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2735,7 +2735,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2763,7 +2763,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2791,7 +2791,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2996,7 +2996,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -3024,7 +3024,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3329,7 +3329,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3357,7 +3357,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3634,7 +3634,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3775,7 +3775,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3887,7 +3887,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/basic_data_types/index.html b/ru/chapter_data_structure/basic_data_types/index.html
index f6e45c874..aa21cc5cf 100644
--- a/ru/chapter_data_structure/basic_data_types/index.html
+++ b/ru/chapter_data_structure/basic_data_types/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1193,7 +1193,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1215,7 +1215,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1321,7 +1321,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1603,7 +1603,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1625,7 +1625,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1703,7 +1703,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1798,7 +1798,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1820,7 +1820,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1898,7 +1898,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1982,7 +1982,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2145,7 +2145,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2236,7 +2236,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2258,7 +2258,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2308,7 +2308,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2364,7 +2364,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2503,7 +2503,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2531,7 +2531,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2559,7 +2559,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2587,7 +2587,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2792,7 +2792,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2820,7 +2820,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3125,7 +3125,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3153,7 +3153,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3430,7 +3430,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3571,7 +3571,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3683,7 +3683,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/character_encoding/index.html b/ru/chapter_data_structure/character_encoding/index.html
index 10a308da7..a87927d70 100644
--- a/ru/chapter_data_structure/character_encoding/index.html
+++ b/ru/chapter_data_structure/character_encoding/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1286,7 +1286,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1308,7 +1308,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1414,7 +1414,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1696,7 +1696,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1718,7 +1718,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1796,7 +1796,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1891,7 +1891,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1913,7 +1913,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1991,7 +1991,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2075,7 +2075,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2238,7 +2238,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2329,7 +2329,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2351,7 +2351,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2401,7 +2401,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2457,7 +2457,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2596,7 +2596,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2624,7 +2624,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2652,7 +2652,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2680,7 +2680,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2885,7 +2885,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2913,7 +2913,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3218,7 +3218,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3246,7 +3246,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3523,7 +3523,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3664,7 +3664,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3776,7 +3776,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/classification_of_data_structure/index.html b/ru/chapter_data_structure/classification_of_data_structure/index.html
index 910eee963..2c339c815 100644
--- a/ru/chapter_data_structure/classification_of_data_structure/index.html
+++ b/ru/chapter_data_structure/classification_of_data_structure/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/index.html b/ru/chapter_data_structure/index.html
index 66ec09719..8fefd3e34 100644
--- a/ru/chapter_data_structure/index.html
+++ b/ru/chapter_data_structure/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/number_encoding/index.html b/ru/chapter_data_structure/number_encoding/index.html
index 4f3c647c9..5b33e5e23 100644
--- a/ru/chapter_data_structure/number_encoding/index.html
+++ b/ru/chapter_data_structure/number_encoding/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_data_structure/summary/index.html b/ru/chapter_data_structure/summary/index.html
index 0d4feee39..508d2999e 100644
--- a/ru/chapter_data_structure/summary/index.html
+++ b/ru/chapter_data_structure/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_divide_and_conquer/binary_search_recur/index.html b/ru/chapter_divide_and_conquer/binary_search_recur/index.html
index cb8fee5cc..ac853fae8 100644
--- a/ru/chapter_divide_and_conquer/binary_search_recur/index.html
+++ b/ru/chapter_divide_and_conquer/binary_search_recur/index.html
@@ -39,7 +39,7 @@
     
     
       
-        <title>12.2 Поисковая стратегия "разделяй и властвуй" - Hello Algo</title>
+        <title>12.2 Поисковая стратегия разделяй и властвуй - Hello Algo</title>
       
     
     
@@ -152,7 +152,7 @@
         <div class="md-header__topic" data-md-component="header-topic">
           <span class="md-ellipsis">
             
-              12.2 &nbsp; Поисковая стратегия "разделяй и властвуй"
+              12.2 &nbsp; Поисковая стратегия разделяй и властвуй
             
           </span>
         </div>
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3152,7 +3152,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3170,7 +3170,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3479,7 +3479,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3620,7 +3620,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3732,7 +3732,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4332,7 +4332,7 @@
 
 
 <!-- Page content -->
-<h1 id="122">12.2 &nbsp; Поисковая стратегия "разделяй и властвуй"<a class="headerlink" href="#122" title="Permanent link">&para;</a></h1>
+<h1 id="122">12.2 &nbsp; Поисковая стратегия разделяй и властвуй<a class="headerlink" href="#122" title="Permanent link">&para;</a></h1>
 <p>Мы уже знаем, что алгоритмы поиска делятся на две большие категории.</p>
 <ul>
 <li><strong>Полный перебор</strong>: реализуется через обход структуры данных, временная сложность равна <span class="arithmatex">\(O(n)\)</span> .</li>
@@ -4777,7 +4777,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../divide_and_conquer/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 12.1 Алгоритмы разделяй и властвуй"
+    aria-label="Назад: 12.1 Стратегия разделяй и властвуй"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4789,7 +4789,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        12.1 Алгоритмы разделяй и властвуй
+        12.1 Стратегия разделяй и властвуй
       </div>
     </div>
   </a>
diff --git a/ru/chapter_divide_and_conquer/build_binary_tree_problem/index.html b/ru/chapter_divide_and_conquer/build_binary_tree_problem/index.html
index d01ffe59f..94c9fb8aa 100644
--- a/ru/chapter_divide_and_conquer/build_binary_tree_problem/index.html
+++ b/ru/chapter_divide_and_conquer/build_binary_tree_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3512,7 +3512,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3653,7 +3653,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3765,7 +3765,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4959,7 +4959,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_recur/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 12.2 Стратегия поиска разделяй и властвуй"
+    aria-label="Назад: 12.2 Поисковая стратегия разделяй и властвуй"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4971,7 +4971,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        12.2 Стратегия поиска разделяй и властвуй
+        12.2 Поисковая стратегия разделяй и властвуй
       </div>
     </div>
   </a>
diff --git a/ru/chapter_divide_and_conquer/divide_and_conquer/index.html b/ru/chapter_divide_and_conquer/divide_and_conquer/index.html
index 3d5601263..fe08fdab7 100644
--- a/ru/chapter_divide_and_conquer/divide_and_conquer/index.html
+++ b/ru/chapter_divide_and_conquer/divide_and_conquer/index.html
@@ -39,7 +39,7 @@
     
     
       
-        <title>12.1 Стратегия "разделяй и властвуй" - Hello Algo</title>
+        <title>12.1 Стратегия разделяй и властвуй - Hello Algo</title>
       
     
     
@@ -152,7 +152,7 @@
         <div class="md-header__topic" data-md-component="header-topic">
           <span class="md-ellipsis">
             
-              12.1 &nbsp; Стратегия "разделяй и властвуй"
+              12.1 &nbsp; Стратегия разделяй и властвуй
             
           </span>
         </div>
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3124,7 +3124,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3142,7 +3142,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3252,7 +3252,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3529,7 +3529,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3670,7 +3670,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3782,7 +3782,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4432,7 +4432,7 @@
 
 
 <!-- Page content -->
-<h1 id="121">12.1 &nbsp; Стратегия "разделяй и властвуй"<a class="headerlink" href="#121" title="Permanent link">&para;</a></h1>
+<h1 id="121">12.1 &nbsp; Стратегия разделяй и властвуй<a class="headerlink" href="#121" title="Permanent link">&para;</a></h1>
 <p><u>Разделяй и властвуй (divide and conquer)</u> - это очень важная и широко используемая стратегия построения алгоритмов. Обычно она реализуется через рекурсию и включает два этапа: "разделение" и "объединение".</p>
 <ol>
 <li><strong>Разделение (этап декомпозиции)</strong>: рекурсивно разбить исходную задачу на две или более подзадачи, пока не будет достигнута наименьшая подзадача.</li>
@@ -4554,7 +4554,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_recur/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 12.2 Стратегия поиска разделяй и властвуй"
+    aria-label="Вперед: 12.2 Поисковая стратегия разделяй и властвуй"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4562,7 +4562,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        12.2 Стратегия поиска разделяй и властвуй
+        12.2 Поисковая стратегия разделяй и властвуй
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_divide_and_conquer/hanota_problem/index.html b/ru/chapter_divide_and_conquer/hanota_problem/index.html
index a7b8cde37..51ef77567 100644
--- a/ru/chapter_divide_and_conquer/hanota_problem/index.html
+++ b/ru/chapter_divide_and_conquer/hanota_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_divide_and_conquer/index.html b/ru/chapter_divide_and_conquer/index.html
index e025c3be3..a07d2fac0 100644
--- a/ru/chapter_divide_and_conquer/index.html
+++ b/ru/chapter_divide_and_conquer/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4282,8 +4282,8 @@
 </div>
 <h2 id="_1">Содержание главы<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>
-<li><a href="divide_and_conquer/">12.1 &nbsp; Алгоритмы разделяй и властвуй</a></li>
-<li><a href="binary_search_recur/">12.2 &nbsp; Стратегия поиска разделяй и властвуй</a></li>
+<li><a href="divide_and_conquer/">12.1 &nbsp; Стратегия разделяй и властвуй</a></li>
+<li><a href="binary_search_recur/">12.2 &nbsp; Поисковая стратегия разделяй и властвуй</a></li>
 <li><a href="build_binary_tree_problem/">12.3 &nbsp; Задача построения двоичного дерева</a></li>
 <li><a href="hanota_problem/">12.4 &nbsp; Задача о Ханойской башне</a></li>
 <li><a href="summary/">12.5 &nbsp; Резюме</a></li>
@@ -4334,7 +4334,7 @@ aria-label="Нижний колонтитул"
   <a
     href="./divide_and_conquer/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 12.1 Алгоритмы разделяй и властвуй"
+    aria-label="Вперед: 12.1 Стратегия разделяй и властвуй"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4342,7 +4342,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        12.1 Алгоритмы разделяй и властвуй
+        12.1 Стратегия разделяй и властвуй
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_divide_and_conquer/summary/index.html b/ru/chapter_divide_and_conquer/summary/index.html
index fec342b7e..380751da5 100644
--- a/ru/chapter_divide_and_conquer/summary/index.html
+++ b/ru/chapter_divide_and_conquer/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3479,7 +3479,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3620,7 +3620,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3732,7 +3732,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_dynamic_programming/dp_problem_features/index.html b/ru/chapter_dynamic_programming/dp_problem_features/index.html
index e997f389f..de19bb699 100644
--- a/ru/chapter_dynamic_programming/dp_problem_features/index.html
+++ b/ru/chapter_dynamic_programming/dp_problem_features/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5235,7 +5235,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../intro_to_dynamic_programming/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 14.1 Введение в динамическое программирование"
+    aria-label="Назад: 14.1 Первое знакомство с динамическим программированием"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -5247,7 +5247,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        14.1 Введение в динамическое программирование
+        14.1 Первое знакомство с динамическим программированием
       </div>
     </div>
   </a>
diff --git a/ru/chapter_dynamic_programming/dp_solution_pipeline/index.html b/ru/chapter_dynamic_programming/dp_solution_pipeline/index.html
index 0ebbffd1b..387f09c41 100644
--- a/ru/chapter_dynamic_programming/dp_solution_pipeline/index.html
+++ b/ru/chapter_dynamic_programming/dp_solution_pipeline/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3793,7 +3793,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_dynamic_programming/edit_distance_problem/index.html b/ru/chapter_dynamic_programming/edit_distance_problem/index.html
index 75ce713a4..5a3169cec 100644
--- a/ru/chapter_dynamic_programming/edit_distance_problem/index.html
+++ b/ru/chapter_dynamic_programming/edit_distance_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5298,7 +5298,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../unbounded_knapsack_problem/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 14.5 Задача о неограниченном рюкзаке"
+    aria-label="Назад: 14.5 Задача о полном рюкзаке"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -5310,7 +5310,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        14.5 Задача о неограниченном рюкзаке
+        14.5 Задача о полном рюкзаке
       </div>
     </div>
   </a>
diff --git a/ru/chapter_dynamic_programming/index.html b/ru/chapter_dynamic_programming/index.html
index 3c825b485..cf6951fee 100644
--- a/ru/chapter_dynamic_programming/index.html
+++ b/ru/chapter_dynamic_programming/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4282,11 +4282,11 @@
 </div>
 <h2 id="_1">Содержание главы<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>
-<li><a href="intro_to_dynamic_programming/">14.1 &nbsp; Введение в динамическое программирование</a></li>
+<li><a href="intro_to_dynamic_programming/">14.1 &nbsp; Первое знакомство с динамическим программированием</a></li>
 <li><a href="dp_problem_features/">14.2 &nbsp; Свойства задач динамического программирования</a></li>
 <li><a href="dp_solution_pipeline/">14.3 &nbsp; Подход к решению задач динамического программирования</a></li>
 <li><a href="knapsack_problem/">14.4 &nbsp; Задача о рюкзаке 0-1</a></li>
-<li><a href="unbounded_knapsack_problem/">14.5 &nbsp; Задача о неограниченном рюкзаке</a></li>
+<li><a href="unbounded_knapsack_problem/">14.5 &nbsp; Задача о полном рюкзаке</a></li>
 <li><a href="edit_distance_problem/">14.6 &nbsp; Задача о расстоянии редактирования</a></li>
 <li><a href="summary/">14.7 &nbsp; Резюме</a></li>
 </ul>
@@ -4336,7 +4336,7 @@ aria-label="Нижний колонтитул"
   <a
     href="./intro_to_dynamic_programming/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 14.1 Введение в динамическое программирование"
+    aria-label="Вперед: 14.1 Первое знакомство с динамическим программированием"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4344,7 +4344,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        14.1 Введение в динамическое программирование
+        14.1 Первое знакомство с динамическим программированием
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_dynamic_programming/intro_to_dynamic_programming/index.html b/ru/chapter_dynamic_programming/intro_to_dynamic_programming/index.html
index 58111ac55..e3a0ba3ff 100644
--- a/ru/chapter_dynamic_programming/intro_to_dynamic_programming/index.html
+++ b/ru/chapter_dynamic_programming/intro_to_dynamic_programming/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3570,7 +3570,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3588,7 +3588,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3765,7 +3765,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_dynamic_programming/knapsack_problem/index.html b/ru/chapter_dynamic_programming/knapsack_problem/index.html
index a98a8e527..162edc40a 100644
--- a/ru/chapter_dynamic_programming/knapsack_problem/index.html
+++ b/ru/chapter_dynamic_programming/knapsack_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3765,7 +3765,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5771,7 +5771,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../unbounded_knapsack_problem/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 14.5 Задача о неограниченном рюкзаке"
+    aria-label="Вперед: 14.5 Задача о полном рюкзаке"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5779,7 +5779,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        14.5 Задача о неограниченном рюкзаке
+        14.5 Задача о полном рюкзаке
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_dynamic_programming/summary/index.html b/ru/chapter_dynamic_programming/summary/index.html
index cc9d5480d..69d0d6b59 100644
--- a/ru/chapter_dynamic_programming/summary/index.html
+++ b/ru/chapter_dynamic_programming/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_dynamic_programming/unbounded_knapsack_problem/index.html b/ru/chapter_dynamic_programming/unbounded_knapsack_problem/index.html
index 37969afa1..2b9d80de1 100644
--- a/ru/chapter_dynamic_programming/unbounded_knapsack_problem/index.html
+++ b/ru/chapter_dynamic_programming/unbounded_knapsack_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3682,7 +3682,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -3700,7 +3700,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_graph/graph/index.html b/ru/chapter_graph/graph/index.html
index a4dea1a4e..497668325 100644
--- a/ru/chapter_graph/graph/index.html
+++ b/ru/chapter_graph/graph/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2407,7 +2407,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2463,7 +2463,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2686,7 +2686,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2919,7 +2919,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3252,7 +3252,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3529,7 +3529,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3670,7 +3670,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3782,7 +3782,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4576,7 +4576,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../graph_operations/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 9.2 Базовые операции над графами"
+    aria-label="Вперед: 9.2 Базовые операции графа"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4584,7 +4584,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        9.2 Базовые операции над графами
+        9.2 Базовые операции графа
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_graph/graph_operations/index.html b/ru/chapter_graph/graph_operations/index.html
index 19982bc48..1f863e412 100644
--- a/ru/chapter_graph/graph_operations/index.html
+++ b/ru/chapter_graph/graph_operations/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2325,7 +2325,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_graph/graph_traversal/index.html b/ru/chapter_graph/graph_traversal/index.html
index 559a6c982..34e94085c 100644
--- a/ru/chapter_graph/graph_traversal/index.html
+++ b/ru/chapter_graph/graph_traversal/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2480,7 +2480,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2675,7 +2675,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2703,7 +2703,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2908,7 +2908,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2936,7 +2936,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3241,7 +3241,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3269,7 +3269,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3546,7 +3546,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3687,7 +3687,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3799,7 +3799,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5422,7 +5422,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../graph_operations/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 9.2 Базовые операции над графами"
+    aria-label="Назад: 9.2 Базовые операции графа"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -5434,7 +5434,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        9.2 Базовые операции над графами
+        9.2 Базовые операции графа
       </div>
     </div>
   </a>
@@ -5446,7 +5446,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../summary/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 9.4 Резюме"
+    aria-label="Вперед: 9.4 Краткие итоги"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5454,7 +5454,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        9.4 Резюме
+        9.4 Краткие итоги
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_graph/index.html b/ru/chapter_graph/index.html
index c490ee9a7..d1ced2578 100644
--- a/ru/chapter_graph/index.html
+++ b/ru/chapter_graph/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4283,9 +4283,9 @@
 <h2 id="_1">Содержание главы<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>
 <li><a href="graph/">9.1 &nbsp; Граф</a></li>
-<li><a href="graph_operations/">9.2 &nbsp; Базовые операции над графами</a></li>
+<li><a href="graph_operations/">9.2 &nbsp; Базовые операции графа</a></li>
 <li><a href="graph_traversal/">9.3 &nbsp; Обход графа</a></li>
-<li><a href="summary/">9.4 &nbsp; Резюме</a></li>
+<li><a href="summary/">9.4 &nbsp; Краткие итоги</a></li>
 </ul>
 
 <!-- Source file information -->
diff --git a/ru/chapter_graph/summary/index.html b/ru/chapter_graph/summary/index.html
index ceb156849..1936edddc 100644
--- a/ru/chapter_graph/summary/index.html
+++ b/ru/chapter_graph/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2363,7 +2363,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2381,7 +2381,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/fractional_knapsack_problem/index.html b/ru/chapter_greedy/fractional_knapsack_problem/index.html
index be5dc2ea7..e1c8c9cef 100644
--- a/ru/chapter_greedy/fractional_knapsack_problem/index.html
+++ b/ru/chapter_greedy/fractional_knapsack_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/greedy_algorithm/index.html b/ru/chapter_greedy/greedy_algorithm/index.html
index 14f9d2f21..860250447 100644
--- a/ru/chapter_greedy/greedy_algorithm/index.html
+++ b/ru/chapter_greedy/greedy_algorithm/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/index.html b/ru/chapter_greedy/index.html
index 0b4b5cb4c..56de0faca 100644
--- a/ru/chapter_greedy/index.html
+++ b/ru/chapter_greedy/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/max_capacity_problem/index.html b/ru/chapter_greedy/max_capacity_problem/index.html
index 0dc71537f..33aafcb0d 100644
--- a/ru/chapter_greedy/max_capacity_problem/index.html
+++ b/ru/chapter_greedy/max_capacity_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/max_product_cutting_problem/index.html b/ru/chapter_greedy/max_product_cutting_problem/index.html
index e6d7b3667..900d7d1b3 100644
--- a/ru/chapter_greedy/max_product_cutting_problem/index.html
+++ b/ru/chapter_greedy/max_product_cutting_problem/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_greedy/summary/index.html b/ru/chapter_greedy/summary/index.html
index 8072fc7d6..e7e614b2b 100644
--- a/ru/chapter_greedy/summary/index.html
+++ b/ru/chapter_greedy/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_hashing/hash_algorithm/index.html b/ru/chapter_hashing/hash_algorithm/index.html
index f7dd52a91..34ab64427 100644
--- a/ru/chapter_hashing/hash_algorithm/index.html
+++ b/ru/chapter_hashing/hash_algorithm/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1702,7 +1702,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1720,7 +1720,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1880,7 +1880,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1902,7 +1902,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1980,7 +1980,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2064,7 +2064,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2227,7 +2227,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2318,7 +2318,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2340,7 +2340,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2390,7 +2390,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2446,7 +2446,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2585,7 +2585,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2613,7 +2613,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2641,7 +2641,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2669,7 +2669,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2874,7 +2874,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2902,7 +2902,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3207,7 +3207,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3235,7 +3235,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3512,7 +3512,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3653,7 +3653,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3765,7 +3765,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_hashing/hash_collision/index.html b/ru/chapter_hashing/hash_collision/index.html
index da687ea7b..b1b82438b 100644
--- a/ru/chapter_hashing/hash_collision/index.html
+++ b/ru/chapter_hashing/hash_collision/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1813,7 +1813,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1908,7 +1908,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1930,7 +1930,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2008,7 +2008,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2092,7 +2092,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2255,7 +2255,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2346,7 +2346,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2368,7 +2368,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2418,7 +2418,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2474,7 +2474,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2613,7 +2613,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2641,7 +2641,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2669,7 +2669,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2697,7 +2697,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2902,7 +2902,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2930,7 +2930,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3235,7 +3235,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3263,7 +3263,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3540,7 +3540,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3681,7 +3681,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3793,7 +3793,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -7746,7 +7746,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../hash_algorithm/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 6.3 Хеш-алгоритмы"
+    aria-label="Вперед: 6.3 Алгоритмы хеширования"
     rel="next"
   >
     <div class="md-footer__title">
@@ -7754,7 +7754,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        6.3 Хеш-алгоритмы
+        6.3 Алгоритмы хеширования
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_hashing/hash_map/index.html b/ru/chapter_hashing/hash_map/index.html
index 75df42f1b..4e252c611 100644
--- a/ru/chapter_hashing/hash_map/index.html
+++ b/ru/chapter_hashing/hash_map/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1774,7 +1774,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1869,7 +1869,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1891,7 +1891,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1969,7 +1969,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2053,7 +2053,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_hashing/index.html b/ru/chapter_hashing/index.html
index 7e1ace773..646b60586 100644
--- a/ru/chapter_hashing/index.html
+++ b/ru/chapter_hashing/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4284,7 +4284,7 @@
 <ul>
 <li><a href="hash_map/">6.1 &nbsp; Хеш-таблица</a></li>
 <li><a href="hash_collision/">6.2 &nbsp; Хеш-коллизии</a></li>
-<li><a href="hash_algorithm/">6.3 &nbsp; Хеш-алгоритмы</a></li>
+<li><a href="hash_algorithm/">6.3 &nbsp; Алгоритмы хеширования</a></li>
 <li><a href="summary/">6.4 &nbsp; Резюме</a></li>
 </ul>
 
diff --git a/ru/chapter_hashing/summary/index.html b/ru/chapter_hashing/summary/index.html
index 107353b2a..9372111ba 100644
--- a/ru/chapter_hashing/summary/index.html
+++ b/ru/chapter_hashing/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4410,7 +4410,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../hash_algorithm/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 6.3 Хеш-алгоритмы"
+    aria-label="Назад: 6.3 Алгоритмы хеширования"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4422,7 +4422,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        6.3 Хеш-алгоритмы
+        6.3 Алгоритмы хеширования
       </div>
     </div>
   </a>
diff --git a/ru/chapter_heap/build_heap/index.html b/ru/chapter_heap/build_heap/index.html
index b7d4d0418..560c04f04 100644
--- a/ru/chapter_heap/build_heap/index.html
+++ b/ru/chapter_heap/build_heap/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4750,7 +4750,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../top_k/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 8.3 Задача Top-K"
+    aria-label="Вперед: 8.3 Задача Top-k"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4758,7 +4758,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        8.3 Задача Top-K
+        8.3 Задача Top-k
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_heap/heap/index.html b/ru/chapter_heap/heap/index.html
index 007b43ed2..d48cc5779 100644
--- a/ru/chapter_heap/heap/index.html
+++ b/ru/chapter_heap/heap/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2266,7 +2266,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2357,7 +2357,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2379,7 +2379,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2429,7 +2429,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2485,7 +2485,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2624,7 +2624,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2652,7 +2652,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2680,7 +2680,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2708,7 +2708,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2913,7 +2913,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2941,7 +2941,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3246,7 +3246,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3274,7 +3274,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3551,7 +3551,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3692,7 +3692,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3804,7 +3804,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_heap/index.html b/ru/chapter_heap/index.html
index 6f87fd3f8..4f7733c78 100644
--- a/ru/chapter_heap/index.html
+++ b/ru/chapter_heap/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4284,7 +4284,7 @@
 <ul>
 <li><a href="heap/">8.1 &nbsp; Куча</a></li>
 <li><a href="build_heap/">8.2 &nbsp; Построение кучи</a></li>
-<li><a href="top_k/">8.3 &nbsp; Задача Top-K</a></li>
+<li><a href="top_k/">8.3 &nbsp; Задача Top-k</a></li>
 <li><a href="summary/">8.4 &nbsp; Резюме</a></li>
 </ul>
 
@@ -4309,7 +4309,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../chapter_tree/summary/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 7.6 Резюме"
+    aria-label="Назад: 7.6 Краткие итоги"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4321,7 +4321,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        7.6 Резюме
+        7.6 Краткие итоги
       </div>
     </div>
   </a>
diff --git a/ru/chapter_heap/summary/index.html b/ru/chapter_heap/summary/index.html
index 169e57eb2..51af414ab 100644
--- a/ru/chapter_heap/summary/index.html
+++ b/ru/chapter_heap/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4390,7 +4390,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../top_k/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 8.3 Задача Top-K"
+    aria-label="Назад: 8.3 Задача Top-k"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4402,7 +4402,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        8.3 Задача Top-K
+        8.3 Задача Top-k
       </div>
     </div>
   </a>
diff --git a/ru/chapter_heap/top_k/index.html b/ru/chapter_heap/top_k/index.html
index 121e03b74..4b58b5949 100644
--- a/ru/chapter_heap/top_k/index.html
+++ b/ru/chapter_heap/top_k/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2144,7 +2144,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2162,7 +2162,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_hello_algo/index.html b/ru/chapter_hello_algo/index.html
index b5325c287..105b68dcc 100644
--- a/ru/chapter_hello_algo/index.html
+++ b/ru/chapter_hello_algo/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2780,7 +2780,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2808,7 +2808,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3113,7 +3113,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3141,7 +3141,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3418,7 +3418,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3559,7 +3559,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3671,7 +3671,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_introduction/algorithms_are_everywhere/index.html b/ru/chapter_introduction/algorithms_are_everywhere/index.html
index da8e3d1c3..7177f1591 100644
--- a/ru/chapter_introduction/algorithms_are_everywhere/index.html
+++ b/ru/chapter_introduction/algorithms_are_everywhere/index.html
@@ -576,7 +576,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -598,7 +598,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -658,7 +658,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1193,7 +1193,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1215,7 +1215,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1321,7 +1321,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1603,7 +1603,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1625,7 +1625,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1703,7 +1703,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1798,7 +1798,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1820,7 +1820,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1898,7 +1898,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1982,7 +1982,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2145,7 +2145,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2236,7 +2236,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2258,7 +2258,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2308,7 +2308,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2364,7 +2364,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2503,7 +2503,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2531,7 +2531,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2559,7 +2559,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2587,7 +2587,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2792,7 +2792,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2820,7 +2820,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3125,7 +3125,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3153,7 +3153,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3430,7 +3430,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3571,7 +3571,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3683,7 +3683,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4368,7 +4368,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../what_is_dsa/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 1.2 Что такое структуры данных и алгоритмы"
+    aria-label="Вперед: 1.2 Что такое алгоритм"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4376,7 +4376,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        1.2 Что такое структуры данных и алгоритмы
+        1.2 Что такое алгоритм
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_introduction/index.html b/ru/chapter_introduction/index.html
index 511c88436..4944f39f2 100644
--- a/ru/chapter_introduction/index.html
+++ b/ru/chapter_introduction/index.html
@@ -576,7 +576,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -598,7 +598,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -648,7 +648,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4283,7 +4283,7 @@
 <h2 id="_1">Содержание главы<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>
 <li><a href="algorithms_are_everywhere/">1.1 &nbsp; Алгоритмы повсюду</a></li>
-<li><a href="what_is_dsa/">1.2 &nbsp; Что такое структуры данных и алгоритмы</a></li>
+<li><a href="what_is_dsa/">1.2 &nbsp; Что такое алгоритм</a></li>
 <li><a href="summary/">1.3 &nbsp; Резюме</a></li>
 </ul>
 
diff --git a/ru/chapter_introduction/summary/index.html b/ru/chapter_introduction/summary/index.html
index 8d518931d..5e4556038 100644
--- a/ru/chapter_introduction/summary/index.html
+++ b/ru/chapter_introduction/summary/index.html
@@ -576,7 +576,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -598,7 +598,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -648,7 +648,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1253,7 +1253,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1275,7 +1275,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1381,7 +1381,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4396,7 +4396,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../what_is_dsa/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 1.2 Что такое структуры данных и алгоритмы"
+    aria-label="Назад: 1.2 Что такое алгоритм"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4408,7 +4408,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        1.2 Что такое структуры данных и алгоритмы
+        1.2 Что такое алгоритм
       </div>
     </div>
   </a>
diff --git a/ru/chapter_introduction/what_is_dsa/index.html b/ru/chapter_introduction/what_is_dsa/index.html
index 6ec0373b2..3623fefa9 100644
--- a/ru/chapter_introduction/what_is_dsa/index.html
+++ b/ru/chapter_introduction/what_is_dsa/index.html
@@ -576,7 +576,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -598,7 +598,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -657,7 +657,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -675,7 +675,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1264,7 +1264,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1286,7 +1286,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1392,7 +1392,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1674,7 +1674,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1696,7 +1696,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1774,7 +1774,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1869,7 +1869,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1891,7 +1891,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1969,7 +1969,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2053,7 +2053,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_preface/about_the_book/index.html b/ru/chapter_preface/about_the_book/index.html
index df9757d79..71a05d528 100644
--- a/ru/chapter_preface/about_the_book/index.html
+++ b/ru/chapter_preface/about_the_book/index.html
@@ -657,7 +657,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -679,7 +679,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -729,7 +729,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1264,7 +1264,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1286,7 +1286,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1392,7 +1392,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1674,7 +1674,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1696,7 +1696,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1774,7 +1774,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1869,7 +1869,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1891,7 +1891,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1969,7 +1969,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2053,7 +2053,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_preface/index.html b/ru/chapter_preface/index.html
index 400c9d7bb..242f257c4 100644
--- a/ru/chapter_preface/index.html
+++ b/ru/chapter_preface/index.html
@@ -576,7 +576,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -598,7 +598,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -648,7 +648,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1183,7 +1183,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1205,7 +1205,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1311,7 +1311,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_preface/suggestions/index.html b/ru/chapter_preface/suggestions/index.html
index 83515c9d5..3f22e8103 100644
--- a/ru/chapter_preface/suggestions/index.html
+++ b/ru/chapter_preface/suggestions/index.html
@@ -679,7 +679,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -701,7 +701,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -751,7 +751,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1286,7 +1286,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1308,7 +1308,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1414,7 +1414,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1696,7 +1696,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1718,7 +1718,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1796,7 +1796,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1891,7 +1891,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1913,7 +1913,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1991,7 +1991,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2075,7 +2075,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2238,7 +2238,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2329,7 +2329,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2351,7 +2351,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2401,7 +2401,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2457,7 +2457,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2596,7 +2596,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2624,7 +2624,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2652,7 +2652,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2680,7 +2680,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2885,7 +2885,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2913,7 +2913,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3218,7 +3218,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3246,7 +3246,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3523,7 +3523,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3664,7 +3664,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3776,7 +3776,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_preface/summary/index.html b/ru/chapter_preface/summary/index.html
index 5bfceef5d..821b12f1f 100644
--- a/ru/chapter_preface/summary/index.html
+++ b/ru/chapter_preface/summary/index.html
@@ -635,7 +635,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -657,7 +657,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -707,7 +707,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1242,7 +1242,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1264,7 +1264,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1370,7 +1370,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1652,7 +1652,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1674,7 +1674,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1752,7 +1752,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1847,7 +1847,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1869,7 +1869,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1947,7 +1947,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2031,7 +2031,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2194,7 +2194,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2285,7 +2285,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2307,7 +2307,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2357,7 +2357,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2413,7 +2413,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2552,7 +2552,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2580,7 +2580,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2608,7 +2608,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2636,7 +2636,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2841,7 +2841,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2869,7 +2869,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3174,7 +3174,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3202,7 +3202,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3479,7 +3479,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3620,7 +3620,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3732,7 +3732,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_reference/index.html b/ru/chapter_reference/index.html
index a4187dc89..e468fe52a 100644
--- a/ru/chapter_reference/index.html
+++ b/ru/chapter_reference/index.html
@@ -572,7 +572,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -594,7 +594,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -644,7 +644,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1179,7 +1179,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1201,7 +1201,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1307,7 +1307,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1589,7 +1589,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1611,7 +1611,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1689,7 +1689,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1784,7 +1784,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1806,7 +1806,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1884,7 +1884,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1968,7 +1968,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2131,7 +2131,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2222,7 +2222,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2244,7 +2244,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2294,7 +2294,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2350,7 +2350,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2489,7 +2489,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2517,7 +2517,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2545,7 +2545,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2573,7 +2573,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2778,7 +2778,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2806,7 +2806,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3111,7 +3111,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3139,7 +3139,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3416,7 +3416,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3557,7 +3557,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3669,7 +3669,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_searching/binary_search/index.html b/ru/chapter_searching/binary_search/index.html
index a794f8869..dc49f05d2 100644
--- a/ru/chapter_searching/binary_search/index.html
+++ b/ru/chapter_searching/binary_search/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5056,7 +5056,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_insertion/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 10.2 Точка вставки двоичного поиска"
+    aria-label="Вперед: 10.2 Двоичный поиск точки вставки"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5064,7 +5064,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        10.2 Точка вставки двоичного поиска
+        10.2 Двоичный поиск точки вставки
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_searching/binary_search_edge/index.html b/ru/chapter_searching/binary_search_edge/index.html
index 6ff8b2f43..7393dcab6 100644
--- a/ru/chapter_searching/binary_search_edge/index.html
+++ b/ru/chapter_searching/binary_search_edge/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2530,7 +2530,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2548,7 +2548,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2675,7 +2675,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2908,7 +2908,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3241,7 +3241,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3518,7 +3518,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3659,7 +3659,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3771,7 +3771,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4873,7 +4873,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_insertion/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 10.2 Точка вставки двоичного поиска"
+    aria-label="Назад: 10.2 Двоичный поиск точки вставки"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4885,7 +4885,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        10.2 Точка вставки двоичного поиска
+        10.2 Двоичный поиск точки вставки
       </div>
     </div>
   </a>
@@ -4897,7 +4897,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../replace_linear_by_hashing/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 10.4 Стратегия оптимизации через хеширование"
+    aria-label="Вперед: 10.4 Стратегии оптимизации хеширования"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4905,7 +4905,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        10.4 Стратегия оптимизации через хеширование
+        10.4 Стратегии оптимизации хеширования
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_searching/binary_search_insertion/index.html b/ru/chapter_searching/binary_search_insertion/index.html
index eacb2a51b..b4e364274 100644
--- a/ru/chapter_searching/binary_search_insertion/index.html
+++ b/ru/chapter_searching/binary_search_insertion/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2502,7 +2502,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2520,7 +2520,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5012,7 +5012,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_edge/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 10.3 Граничные случаи двоичного поиска"
+    aria-label="Вперед: 10.3 Двоичный поиск границ"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5020,7 +5020,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        10.3 Граничные случаи двоичного поиска
+        10.3 Двоичный поиск границ
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_searching/index.html b/ru/chapter_searching/index.html
index 0c5e155f6..513e21b6c 100644
--- a/ru/chapter_searching/index.html
+++ b/ru/chapter_searching/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4283,10 +4283,10 @@
 <h2 id="_1">Содержание главы<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>
 <li><a href="binary_search/">10.1 &nbsp; Двоичный поиск</a></li>
-<li><a href="binary_search_insertion/">10.2 &nbsp; Точка вставки двоичного поиска</a></li>
-<li><a href="binary_search_edge/">10.3 &nbsp; Граничные случаи двоичного поиска</a></li>
-<li><a href="replace_linear_by_hashing/">10.4 &nbsp; Стратегия оптимизации через хеширование</a></li>
-<li><a href="searching_algorithm_revisited/">10.5 &nbsp; Алгоритмы поиска: новый взгляд</a></li>
+<li><a href="binary_search_insertion/">10.2 &nbsp; Двоичный поиск точки вставки</a></li>
+<li><a href="binary_search_edge/">10.3 &nbsp; Двоичный поиск границ</a></li>
+<li><a href="replace_linear_by_hashing/">10.4 &nbsp; Стратегии оптимизации хеширования</a></li>
+<li><a href="searching_algorithm_revisited/">10.5 &nbsp; Переосмысление алгоритмов поиска</a></li>
 <li><a href="summary/">10.6 &nbsp; Резюме</a></li>
 </ul>
 
@@ -4311,7 +4311,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../chapter_graph/summary/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 9.4 Резюме"
+    aria-label="Назад: 9.4 Краткие итоги"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4323,7 +4323,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        9.4 Резюме
+        9.4 Краткие итоги
       </div>
     </div>
   </a>
diff --git a/ru/chapter_searching/replace_linear_by_hashing/index.html b/ru/chapter_searching/replace_linear_by_hashing/index.html
index cd5920e9c..d30529c94 100644
--- a/ru/chapter_searching/replace_linear_by_hashing/index.html
+++ b/ru/chapter_searching/replace_linear_by_hashing/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2558,7 +2558,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2576,7 +2576,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4868,7 +4868,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../binary_search_edge/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 10.3 Граничные случаи двоичного поиска"
+    aria-label="Назад: 10.3 Двоичный поиск границ"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4880,7 +4880,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        10.3 Граничные случаи двоичного поиска
+        10.3 Двоичный поиск границ
       </div>
     </div>
   </a>
@@ -4892,7 +4892,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../searching_algorithm_revisited/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 10.5 Алгоритмы поиска: новый взгляд"
+    aria-label="Вперед: 10.5 Переосмысление алгоритмов поиска"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4900,7 +4900,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        10.5 Алгоритмы поиска: новый взгляд
+        10.5 Переосмысление алгоритмов поиска
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_searching/searching_algorithm_revisited/index.html b/ru/chapter_searching/searching_algorithm_revisited/index.html
index e6fd814eb..25d9ad4c1 100644
--- a/ru/chapter_searching/searching_algorithm_revisited/index.html
+++ b/ru/chapter_searching/searching_algorithm_revisited/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2586,7 +2586,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2604,7 +2604,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4519,7 +4519,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../replace_linear_by_hashing/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 10.4 Стратегия оптимизации через хеширование"
+    aria-label="Назад: 10.4 Стратегии оптимизации хеширования"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4531,7 +4531,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        10.4 Стратегия оптимизации через хеширование
+        10.4 Стратегии оптимизации хеширования
       </div>
     </div>
   </a>
diff --git a/ru/chapter_searching/summary/index.html b/ru/chapter_searching/summary/index.html
index 6e54038ec..6bf55a99d 100644
--- a/ru/chapter_searching/summary/index.html
+++ b/ru/chapter_searching/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2841,7 +2841,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2869,7 +2869,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3174,7 +3174,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3202,7 +3202,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3479,7 +3479,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3620,7 +3620,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3732,7 +3732,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4364,7 +4364,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../searching_algorithm_revisited/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 10.5 Алгоритмы поиска: новый взгляд"
+    aria-label="Назад: 10.5 Переосмысление алгоритмов поиска"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4376,7 +4376,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        10.5 Алгоритмы поиска: новый взгляд
+        10.5 Переосмысление алгоритмов поиска
       </div>
     </div>
   </a>
diff --git a/ru/chapter_sorting/bubble_sort/index.html b/ru/chapter_sorting/bubble_sort/index.html
index 8cd9df83b..347bb7cb3 100644
--- a/ru/chapter_sorting/bubble_sort/index.html
+++ b/ru/chapter_sorting/bubble_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2791,7 +2791,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2809,7 +2809,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4992,7 +4992,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../insertion_sort/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 11.4 Сортировка вставкой"
+    aria-label="Вперед: 11.4 Сортировка вставками"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5000,7 +5000,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        11.4 Сортировка вставкой
+        11.4 Сортировка вставками
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_sorting/bucket_sort/index.html b/ru/chapter_sorting/bucket_sort/index.html
index d9d904f58..314bc7886 100644
--- a/ru/chapter_sorting/bucket_sort/index.html
+++ b/ru/chapter_sorting/bucket_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/counting_sort/index.html b/ru/chapter_sorting/counting_sort/index.html
index 8558a1f0f..44fb2e6ae 100644
--- a/ru/chapter_sorting/counting_sort/index.html
+++ b/ru/chapter_sorting/counting_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3207,7 +3207,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3235,7 +3235,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3512,7 +3512,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3653,7 +3653,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3765,7 +3765,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/heap_sort/index.html b/ru/chapter_sorting/heap_sort/index.html
index a468a2f54..958d94b85 100644
--- a/ru/chapter_sorting/heap_sort/index.html
+++ b/ru/chapter_sorting/heap_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/index.html b/ru/chapter_sorting/index.html
index 9d93e5fb9..24436d72f 100644
--- a/ru/chapter_sorting/index.html
+++ b/ru/chapter_sorting/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4284,8 +4284,8 @@
 <ul>
 <li><a href="sorting_algorithm/">11.1 &nbsp; Алгоритмы сортировки</a></li>
 <li><a href="selection_sort/">11.2 &nbsp; Сортировка выбором</a></li>
-<li><a href="bubble_sort/">11.3 &nbsp; Пузырьковая сортировка</a></li>
-<li><a href="insertion_sort/">11.4 &nbsp; Сортировка вставкой</a></li>
+<li><a href="bubble_sort/">11.3 &nbsp; Сортировка пузырьком</a></li>
+<li><a href="insertion_sort/">11.4 &nbsp; Сортировка вставками</a></li>
 <li><a href="quick_sort/">11.5 &nbsp; Быстрая сортировка</a></li>
 <li><a href="merge_sort/">11.6 &nbsp; Сортировка слиянием</a></li>
 <li><a href="heap_sort/">11.7 &nbsp; Пирамидальная сортировка</a></li>
diff --git a/ru/chapter_sorting/insertion_sort/index.html b/ru/chapter_sorting/insertion_sort/index.html
index 8c8cc0c6c..e398301ac 100644
--- a/ru/chapter_sorting/insertion_sort/index.html
+++ b/ru/chapter_sorting/insertion_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2819,7 +2819,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -2837,7 +2837,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4657,7 +4657,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../bubble_sort/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 11.3 Пузырьковая сортировка"
+    aria-label="Назад: 11.3 Сортировка пузырьком"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -4669,7 +4669,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        11.3 Пузырьковая сортировка
+        11.3 Сортировка пузырьком
       </div>
     </div>
   </a>
diff --git a/ru/chapter_sorting/merge_sort/index.html b/ru/chapter_sorting/merge_sort/index.html
index a327b3e3b..f6264e3f3 100644
--- a/ru/chapter_sorting/merge_sort/index.html
+++ b/ru/chapter_sorting/merge_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/quick_sort/index.html b/ru/chapter_sorting/quick_sort/index.html
index a77543cd4..0e2afc8a4 100644
--- a/ru/chapter_sorting/quick_sort/index.html
+++ b/ru/chapter_sorting/quick_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3218,7 +3218,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3246,7 +3246,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3523,7 +3523,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3664,7 +3664,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3776,7 +3776,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5748,7 +5748,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../insertion_sort/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 11.4 Сортировка вставкой"
+    aria-label="Назад: 11.4 Сортировка вставками"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -5760,7 +5760,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        11.4 Сортировка вставкой
+        11.4 Сортировка вставками
       </div>
     </div>
   </a>
diff --git a/ru/chapter_sorting/radix_sort/index.html b/ru/chapter_sorting/radix_sort/index.html
index adfbf0ef5..e0f5728fa 100644
--- a/ru/chapter_sorting/radix_sort/index.html
+++ b/ru/chapter_sorting/radix_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/selection_sort/index.html b/ru/chapter_sorting/selection_sort/index.html
index 8f997f0e6..6d7cfa695 100644
--- a/ru/chapter_sorting/selection_sort/index.html
+++ b/ru/chapter_sorting/selection_sort/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2841,7 +2841,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2869,7 +2869,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3174,7 +3174,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3202,7 +3202,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3479,7 +3479,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3620,7 +3620,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3732,7 +3732,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4692,7 +4692,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../bubble_sort/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 11.3 Пузырьковая сортировка"
+    aria-label="Вперед: 11.3 Сортировка пузырьком"
     rel="next"
   >
     <div class="md-footer__title">
@@ -4700,7 +4700,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        11.3 Пузырьковая сортировка
+        11.3 Сортировка пузырьком
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_sorting/sorting_algorithm/index.html b/ru/chapter_sorting/sorting_algorithm/index.html
index 4eeaeba53..8fc9ab0d1 100644
--- a/ru/chapter_sorting/sorting_algorithm/index.html
+++ b/ru/chapter_sorting/sorting_algorithm/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_sorting/summary/index.html b/ru/chapter_sorting/summary/index.html
index 0e6a36fe5..f802861e5 100644
--- a/ru/chapter_sorting/summary/index.html
+++ b/ru/chapter_sorting/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1786,7 +1786,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1808,7 +1808,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1886,7 +1886,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1970,7 +1970,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2133,7 +2133,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2224,7 +2224,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2246,7 +2246,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2491,7 +2491,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2519,7 +2519,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2547,7 +2547,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2575,7 +2575,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_stack_and_queue/deque/index.html b/ru/chapter_stack_and_queue/deque/index.html
index 6821bfaa7..aa3dec144 100644
--- a/ru/chapter_stack_and_queue/deque/index.html
+++ b/ru/chapter_stack_and_queue/deque/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1702,7 +1702,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1724,7 +1724,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1802,7 +1802,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1897,7 +1897,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1919,7 +1919,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1997,7 +1997,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2081,7 +2081,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2244,7 +2244,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2335,7 +2335,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2357,7 +2357,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2407,7 +2407,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2463,7 +2463,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2686,7 +2686,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2919,7 +2919,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3252,7 +3252,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3529,7 +3529,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3670,7 +3670,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3782,7 +3782,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_stack_and_queue/index.html b/ru/chapter_stack_and_queue/index.html
index e209dcafe..e8374fbd3 100644
--- a/ru/chapter_stack_and_queue/index.html
+++ b/ru/chapter_stack_and_queue/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1593,7 +1593,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1615,7 +1615,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1693,7 +1693,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_stack_and_queue/queue/index.html b/ru/chapter_stack_and_queue/queue/index.html
index f727dc190..4a27c1a18 100644
--- a/ru/chapter_stack_and_queue/queue/index.html
+++ b/ru/chapter_stack_and_queue/queue/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1702,7 +1702,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1724,7 +1724,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1802,7 +1802,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1897,7 +1897,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1919,7 +1919,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1997,7 +1997,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2081,7 +2081,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2244,7 +2244,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2335,7 +2335,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2357,7 +2357,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2407,7 +2407,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2463,7 +2463,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2686,7 +2686,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2919,7 +2919,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3252,7 +3252,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3529,7 +3529,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3670,7 +3670,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3782,7 +3782,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -6445,7 +6445,7 @@
 <a id="__codelineno-36-2" name="__codelineno-36-2" href="#__codelineno-36-2"></a><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-36-3" name="__codelineno-36-3" href="#__codelineno-36-3"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">nums</span><span class="p">;</span><span class="w">       </span><span class="c1">// Массив для хранения элементов очереди</span>
 <a id="__codelineno-36-4" name="__codelineno-36-4" href="#__codelineno-36-4"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">front</span><span class="p">;</span><span class="w">       </span><span class="c1">// Указатель head, указывающий на первый элемент очереди</span>
-<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// Указатель хвоста, указывающий на позицию после хвоста</span>
+<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// Текущее количество элементов в очереди</span>
 <a id="__codelineno-36-6" name="__codelineno-36-6" href="#__codelineno-36-6"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queCapacity</span><span class="p">;</span><span class="w"> </span><span class="c1">// Вместимость очереди</span>
 <a id="__codelineno-36-7" name="__codelineno-36-7" href="#__codelineno-36-7"></a><span class="p">}</span><span class="w"> </span><span class="n">ArrayQueue</span><span class="p">;</span>
 <a id="__codelineno-36-8" name="__codelineno-36-8" href="#__codelineno-36-8"></a>
diff --git a/ru/chapter_stack_and_queue/stack/index.html b/ru/chapter_stack_and_queue/stack/index.html
index f57f7b04c..1ea9b1af7 100644
--- a/ru/chapter_stack_and_queue/stack/index.html
+++ b/ru/chapter_stack_and_queue/stack/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1713,7 +1713,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1735,7 +1735,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1813,7 +1813,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1908,7 +1908,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1930,7 +1930,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2008,7 +2008,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2092,7 +2092,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2255,7 +2255,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2346,7 +2346,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2368,7 +2368,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2418,7 +2418,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2474,7 +2474,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2613,7 +2613,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2641,7 +2641,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2669,7 +2669,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2697,7 +2697,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2902,7 +2902,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2930,7 +2930,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3235,7 +3235,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3263,7 +3263,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3540,7 +3540,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3681,7 +3681,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3793,7 +3793,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_stack_and_queue/summary/index.html b/ru/chapter_stack_and_queue/summary/index.html
index 985cba50c..b6c7dc960 100644
--- a/ru/chapter_stack_and_queue/summary/index.html
+++ b/ru/chapter_stack_and_queue/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1663,7 +1663,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1685,7 +1685,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1763,7 +1763,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1858,7 +1858,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1880,7 +1880,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1958,7 +1958,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2042,7 +2042,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_tree/array_representation_of_tree/index.html b/ru/chapter_tree/array_representation_of_tree/index.html
index fa9ec3161..b26e7fa3c 100644
--- a/ru/chapter_tree/array_representation_of_tree/index.html
+++ b/ru/chapter_tree/array_representation_of_tree/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1897,7 +1897,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1915,7 +1915,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2053,7 +2053,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2216,7 +2216,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2307,7 +2307,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2329,7 +2329,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2379,7 +2379,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2435,7 +2435,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2602,7 +2602,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2630,7 +2630,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2658,7 +2658,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2863,7 +2863,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2891,7 +2891,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3196,7 +3196,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3224,7 +3224,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3501,7 +3501,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3642,7 +3642,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3754,7 +3754,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_tree/avl_tree/index.html b/ru/chapter_tree/avl_tree/index.html
index 703d7480a..715889e52 100644
--- a/ru/chapter_tree/avl_tree/index.html
+++ b/ru/chapter_tree/avl_tree/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2192,7 +2192,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2355,7 +2355,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2446,7 +2446,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2468,7 +2468,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2518,7 +2518,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2574,7 +2574,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2713,7 +2713,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2741,7 +2741,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2769,7 +2769,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2797,7 +2797,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -3002,7 +3002,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -3030,7 +3030,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3335,7 +3335,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3363,7 +3363,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3640,7 +3640,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3781,7 +3781,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3893,7 +3893,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -7160,7 +7160,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../summary/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 7.6 Резюме"
+    aria-label="Вперед: 7.6 Краткие итоги"
     rel="next"
   >
     <div class="md-footer__title">
@@ -7168,7 +7168,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        7.6 Резюме
+        7.6 Краткие итоги
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_tree/binary_search_tree/index.html b/ru/chapter_tree/binary_search_tree/index.html
index 797bf8d53..c557f7b37 100644
--- a/ru/chapter_tree/binary_search_tree/index.html
+++ b/ru/chapter_tree/binary_search_tree/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2103,7 +2103,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2266,7 +2266,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2357,7 +2357,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2379,7 +2379,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2429,7 +2429,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2485,7 +2485,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2624,7 +2624,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2652,7 +2652,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2680,7 +2680,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2708,7 +2708,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2913,7 +2913,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2941,7 +2941,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3246,7 +3246,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3274,7 +3274,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3551,7 +3551,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3692,7 +3692,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3804,7 +3804,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -6064,7 +6064,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../array_representation_of_tree/"
     class="md-footer__link md-footer__link--prev"
-    aria-label="Назад: 7.3 Представление дерева массивом"
+    aria-label="Назад: 7.3 Представление двоичного дерева массивом"
     rel="prev"
   >
     <div class="md-footer__button md-icon">
@@ -6076,7 +6076,7 @@ aria-label="Нижний колонтитул"
         Назад
       </span>
       <div class="md-ellipsis">
-        7.3 Представление дерева массивом
+        7.3 Представление двоичного дерева массивом
       </div>
     </div>
   </a>
diff --git a/ru/chapter_tree/binary_tree/index.html b/ru/chapter_tree/binary_tree/index.html
index b830fb794..57a8d7239 100644
--- a/ru/chapter_tree/binary_tree/index.html
+++ b/ru/chapter_tree/binary_tree/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2058,7 +2058,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2142,7 +2142,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2305,7 +2305,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2396,7 +2396,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2418,7 +2418,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2468,7 +2468,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2524,7 +2524,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2663,7 +2663,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2691,7 +2691,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2719,7 +2719,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2747,7 +2747,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2952,7 +2952,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2980,7 +2980,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3285,7 +3285,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3313,7 +3313,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3590,7 +3590,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3731,7 +3731,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3843,7 +3843,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/chapter_tree/binary_tree_traversal/index.html b/ru/chapter_tree/binary_tree_traversal/index.html
index d9b38e228..ccb6cba68 100644
--- a/ru/chapter_tree/binary_tree_traversal/index.html
+++ b/ru/chapter_tree/binary_tree_traversal/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -2014,7 +2014,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -2098,7 +2098,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2261,7 +2261,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2352,7 +2352,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2374,7 +2374,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2480,7 +2480,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2675,7 +2675,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2703,7 +2703,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2908,7 +2908,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2936,7 +2936,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3241,7 +3241,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3269,7 +3269,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3546,7 +3546,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3687,7 +3687,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3799,7 +3799,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -5328,7 +5328,7 @@ aria-label="Нижний колонтитул"
   <a
     href="../array_representation_of_tree/"
     class="md-footer__link md-footer__link--next"
-    aria-label="Вперед: 7.3 Представление дерева массивом"
+    aria-label="Вперед: 7.3 Представление двоичного дерева массивом"
     rel="next"
   >
     <div class="md-footer__title">
@@ -5336,7 +5336,7 @@ aria-label="Нижний колонтитул"
         Вперед
       </span>
       <div class="md-ellipsis">
-        7.3 Представление дерева массивом
+        7.3 Представление двоичного дерева массивом
       </div>
     </div>
     <div class="md-footer__button md-icon">
diff --git a/ru/chapter_tree/index.html b/ru/chapter_tree/index.html
index 559170d27..3a53d78ae 100644
--- a/ru/chapter_tree/index.html
+++ b/ru/chapter_tree/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1972,7 +1972,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2135,7 +2135,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2226,7 +2226,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2248,7 +2248,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2298,7 +2298,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2354,7 +2354,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2493,7 +2493,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2521,7 +2521,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2549,7 +2549,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2577,7 +2577,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2782,7 +2782,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2810,7 +2810,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3115,7 +3115,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3143,7 +3143,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3420,7 +3420,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3561,7 +3561,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3673,7 +3673,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
@@ -4284,10 +4284,10 @@
 <ul>
 <li><a href="binary_tree/">7.1 &nbsp; Двоичное дерево</a></li>
 <li><a href="binary_tree_traversal/">7.2 &nbsp; Обход двоичного дерева</a></li>
-<li><a href="array_representation_of_tree/">7.3 &nbsp; Представление дерева массивом</a></li>
+<li><a href="array_representation_of_tree/">7.3 &nbsp; Представление двоичного дерева массивом</a></li>
 <li><a href="binary_search_tree/">7.4 &nbsp; Двоичное дерево поиска</a></li>
 <li><a href="avl_tree/">7.5 &nbsp; AVL-дерево *</a></li>
-<li><a href="summary/">7.6 &nbsp; Резюме</a></li>
+<li><a href="summary/">7.6 &nbsp; Краткие итоги</a></li>
 </ul>
 
 <!-- Source file information -->
diff --git a/ru/chapter_tree/summary/index.html b/ru/chapter_tree/summary/index.html
index d9692d71b..56550422a 100644
--- a/ru/chapter_tree/summary/index.html
+++ b/ru/chapter_tree/summary/index.html
@@ -574,7 +574,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
     
@@ -596,7 +596,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 1. Знакомство с алгоритмами
+    Глава 1. Введение в алгоритмы
   
 
           </label>
@@ -646,7 +646,7 @@
   <span class="md-ellipsis">
     
   
-    1.2 Что такое структуры данных и алгоритмы
+    1.2 Что такое алгоритм
   
 
     
@@ -1181,7 +1181,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
     
@@ -1203,7 +1203,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 4. Массив и связный список
+    Глава 4. Массивы и списки
   
 
           </label>
@@ -1309,7 +1309,7 @@
   <span class="md-ellipsis">
     
   
-    4.4 Память и кеш *
+    4.4 Оперативная память и кэш *
   
 
     
@@ -1591,7 +1591,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
     
@@ -1613,7 +1613,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 6. Хеширование
+    Глава 6. Хеш-таблицы
   
 
           </label>
@@ -1691,7 +1691,7 @@
   <span class="md-ellipsis">
     
   
-    6.3 Хеш-алгоритмы
+    6.3 Алгоритмы хеширования
   
 
     
@@ -1788,7 +1788,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
     
@@ -1810,7 +1810,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 7. Дерево
+    Глава 7. Деревья
   
 
           </label>
@@ -1888,7 +1888,7 @@
   <span class="md-ellipsis">
     
   
-    7.3 Представление дерева массивом
+    7.3 Представление двоичного дерева массивом
   
 
     
@@ -1981,7 +1981,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -1999,7 +1999,7 @@
   <span class="md-ellipsis">
     
   
-    7.6 Резюме
+    7.6 Краткие итоги
   
 
     
@@ -2205,7 +2205,7 @@
   <span class="md-ellipsis">
     
   
-    8.3 Задача Top-K
+    8.3 Задача Top-k
   
 
     
@@ -2296,7 +2296,7 @@
   <span class="md-ellipsis">
     
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
     
@@ -2318,7 +2318,7 @@
             <span class="md-nav__icon md-icon"></span>
             
   
-    Глава 9. Граф
+    Глава 9. Графы
   
 
           </label>
@@ -2368,7 +2368,7 @@
   <span class="md-ellipsis">
     
   
-    9.2 Базовые операции над графами
+    9.2 Базовые операции графа
   
 
     
@@ -2424,7 +2424,7 @@
   <span class="md-ellipsis">
     
   
-    9.4 Резюме
+    9.4 Краткие итоги
   
 
     
@@ -2563,7 +2563,7 @@
   <span class="md-ellipsis">
     
   
-    10.2 Точка вставки двоичного поиска
+    10.2 Двоичный поиск точки вставки
   
 
     
@@ -2591,7 +2591,7 @@
   <span class="md-ellipsis">
     
   
-    10.3 Граничные случаи двоичного поиска
+    10.3 Двоичный поиск границ
   
 
     
@@ -2619,7 +2619,7 @@
   <span class="md-ellipsis">
     
   
-    10.4 Стратегия оптимизации через хеширование
+    10.4 Стратегии оптимизации хеширования
   
 
     
@@ -2647,7 +2647,7 @@
   <span class="md-ellipsis">
     
   
-    10.5 Алгоритмы поиска: новый взгляд
+    10.5 Переосмысление алгоритмов поиска
   
 
     
@@ -2852,7 +2852,7 @@
   <span class="md-ellipsis">
     
   
-    11.3 Пузырьковая сортировка
+    11.3 Сортировка пузырьком
   
 
     
@@ -2880,7 +2880,7 @@
   <span class="md-ellipsis">
     
   
-    11.4 Сортировка вставкой
+    11.4 Сортировка вставками
   
 
     
@@ -3185,7 +3185,7 @@
   <span class="md-ellipsis">
     
   
-    12.1 Алгоритмы разделяй и властвуй
+    12.1 Стратегия разделяй и властвуй
   
 
     
@@ -3213,7 +3213,7 @@
   <span class="md-ellipsis">
     
   
-    12.2 Стратегия поиска разделяй и властвуй
+    12.2 Поисковая стратегия разделяй и властвуй
   
 
     
@@ -3490,7 +3490,7 @@
   <span class="md-ellipsis">
     
   
-    13.4 Задача о $n$ ферзях
+    13.4 Задача о n ферзях
   
 
     
@@ -3631,7 +3631,7 @@
   <span class="md-ellipsis">
     
   
-    14.1 Введение в динамическое программирование
+    14.1 Первое знакомство с динамическим программированием
   
 
     
@@ -3743,7 +3743,7 @@
   <span class="md-ellipsis">
     
   
-    14.5 Задача о неограниченном рюкзаке
+    14.5 Задача о полном рюкзаке
   
 
     
diff --git a/ru/index.html b/ru/index.html
index c189457f6..7becd4d04 100644
--- a/ru/index.html
+++ b/ru/index.html
@@ -442,11 +442,13 @@
                 </b>
               </div>
               <div class="profile-cell translator-profile-cell">
-                <img alt="Translator: yuyanhuang" class="profile-img" src="../assets/avatar/avatar_yuyanhuang.jpg"/>
-                <br/>
-                <b>
-                  Yuyan Huang
-                </b>
+                <a href="https://github.com/veronicahuang2977">
+                  <img alt="Translator: yuyanhuang" class="profile-img" src="../assets/avatar/avatar_yuyanhuang.jpg"/>
+                  <br/>
+                  <b>
+                    Yuyan Huang
+                  </b>
+                </a>
               </div>
             </div>
           </div>
@@ -736,7 +738,7 @@
                             </path>
                           </svg>
                           <span class="md-ellipsis">
-                            Глава 1. Знакомство с алгоритмами
+                            Глава 1. Введение в алгоритмы
                           </span>
                         </a>
                         <label class="md-nav__link" for="__nav_3" id="__nav_3_label" tabindex="0">
@@ -748,7 +750,7 @@
                         <label class="md-nav__title" for="__nav_3">
                           <span class="md-nav__icon md-icon">
                           </span>
-                          Глава 1. Знакомство с алгоритмами
+                          Глава 1. Введение в алгоритмы
                         </label>
                         <ul class="md-nav__list" data-md-scrollfix="">
                           <li class="md-nav__item">
@@ -761,7 +763,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_introduction/what_is_dsa/">
                               <span class="md-ellipsis">
-                                1.2 Что такое структуры данных и алгоритмы
+                                1.2 Что такое алгоритм
                               </span>
                             </a>
                           </li>
@@ -908,7 +910,7 @@
                             </path>
                           </svg>
                           <span class="md-ellipsis">
-                            Глава 4. Массив и связный список
+                            Глава 4. Массивы и списки
                           </span>
                         </a>
                         <label class="md-nav__link" for="__nav_6" id="__nav_6_label" tabindex="0">
@@ -920,7 +922,7 @@
                         <label class="md-nav__title" for="__nav_6">
                           <span class="md-nav__icon md-icon">
                           </span>
-                          Глава 4. Массив и связный список
+                          Глава 4. Массивы и списки
                         </label>
                         <ul class="md-nav__list" data-md-scrollfix="">
                           <li class="md-nav__item">
@@ -947,7 +949,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_array_and_linkedlist/ram_and_cache/">
                               <span class="md-ellipsis">
-                                4.4 Память и кеш *
+                                4.4 Оперативная память и кэш *
                               </span>
                             </a>
                           </li>
@@ -1025,7 +1027,7 @@
                             </path>
                           </svg>
                           <span class="md-ellipsis">
-                            Глава 6. Хеширование
+                            Глава 6. Хеш-таблицы
                           </span>
                         </a>
                         <label class="md-nav__link" for="__nav_8" id="__nav_8_label" tabindex="0">
@@ -1037,7 +1039,7 @@
                         <label class="md-nav__title" for="__nav_8">
                           <span class="md-nav__icon md-icon">
                           </span>
-                          Глава 6. Хеширование
+                          Глава 6. Хеш-таблицы
                         </label>
                         <ul class="md-nav__list" data-md-scrollfix="">
                           <li class="md-nav__item">
@@ -1057,7 +1059,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_hashing/hash_algorithm/">
                               <span class="md-ellipsis">
-                                6.3 Хеш-алгоритмы
+                                6.3 Алгоритмы хеширования
                               </span>
                             </a>
                           </li>
@@ -1080,7 +1082,7 @@
                             </path>
                           </svg>
                           <span class="md-ellipsis">
-                            Глава 7. Дерево
+                            Глава 7. Деревья
                           </span>
                         </a>
                         <label class="md-nav__link" for="__nav_9" id="__nav_9_label" tabindex="0">
@@ -1092,7 +1094,7 @@
                         <label class="md-nav__title" for="__nav_9">
                           <span class="md-nav__icon md-icon">
                           </span>
-                          Глава 7. Дерево
+                          Глава 7. Деревья
                         </label>
                         <ul class="md-nav__list" data-md-scrollfix="">
                           <li class="md-nav__item">
@@ -1112,7 +1114,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_tree/array_representation_of_tree/">
                               <span class="md-ellipsis">
-                                7.3 Представление дерева массивом
+                                7.3 Представление двоичного дерева массивом
                               </span>
                             </a>
                           </li>
@@ -1133,7 +1135,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_tree/summary/">
                               <span class="md-ellipsis">
-                                7.6 Резюме
+                                7.6 Краткие итоги
                               </span>
                             </a>
                           </li>
@@ -1181,7 +1183,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_heap/top_k/">
                               <span class="md-ellipsis">
-                                8.3 Задача Top-K
+                                8.3 Задача Top-k
                               </span>
                             </a>
                           </li>
@@ -1204,7 +1206,7 @@
                             </path>
                           </svg>
                           <span class="md-ellipsis">
-                            Глава 9. Граф
+                            Глава 9. Графы
                           </span>
                         </a>
                         <label class="md-nav__link" for="__nav_11" id="__nav_11_label" tabindex="0">
@@ -1216,7 +1218,7 @@
                         <label class="md-nav__title" for="__nav_11">
                           <span class="md-nav__icon md-icon">
                           </span>
-                          Глава 9. Граф
+                          Глава 9. Графы
                         </label>
                         <ul class="md-nav__list" data-md-scrollfix="">
                           <li class="md-nav__item">
@@ -1229,7 +1231,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_graph/graph_operations/">
                               <span class="md-ellipsis">
-                                9.2 Базовые операции над графами
+                                9.2 Базовые операции графа
                               </span>
                             </a>
                           </li>
@@ -1243,7 +1245,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_graph/summary/">
                               <span class="md-ellipsis">
-                                9.4 Резюме
+                                9.4 Краткие итоги
                               </span>
                             </a>
                           </li>
@@ -1284,28 +1286,28 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_searching/binary_search_insertion/">
                               <span class="md-ellipsis">
-                                10.2 Точка вставки двоичного поиска
+                                10.2 Двоичный поиск точки вставки
                               </span>
                             </a>
                           </li>
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_searching/binary_search_edge/">
                               <span class="md-ellipsis">
-                                10.3 Граничные случаи двоичного поиска
+                                10.3 Двоичный поиск границ
                               </span>
                             </a>
                           </li>
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_searching/replace_linear_by_hashing/">
                               <span class="md-ellipsis">
-                                10.4 Стратегия оптимизации через хеширование
+                                10.4 Стратегии оптимизации хеширования
                               </span>
                             </a>
                           </li>
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_searching/searching_algorithm_revisited/">
                               <span class="md-ellipsis">
-                                10.5 Алгоритмы поиска: новый взгляд
+                                10.5 Переосмысление алгоритмов поиска
                               </span>
                             </a>
                           </li>
@@ -1360,14 +1362,14 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_sorting/bubble_sort/">
                               <span class="md-ellipsis">
-                                11.3 Пузырьковая сортировка
+                                11.3 Сортировка пузырьком
                               </span>
                             </a>
                           </li>
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_sorting/insertion_sort/">
                               <span class="md-ellipsis">
-                                11.4 Сортировка вставкой
+                                11.4 Сортировка вставками
                               </span>
                             </a>
                           </li>
@@ -1450,14 +1452,14 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_divide_and_conquer/divide_and_conquer/">
                               <span class="md-ellipsis">
-                                12.1 Алгоритмы разделяй и властвуй
+                                12.1 Стратегия разделяй и властвуй
                               </span>
                             </a>
                           </li>
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_divide_and_conquer/binary_search_recur/">
                               <span class="md-ellipsis">
-                                12.2 Стратегия поиска разделяй и властвуй
+                                12.2 Поисковая стратегия разделяй и властвуй
                               </span>
                             </a>
                           </li>
@@ -1533,7 +1535,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_backtracking/n_queens_problem/">
                               <span class="md-ellipsis">
-                                13.4 Задача о $n$ ферзях
+                                13.4 Задача о n ферзях
                               </span>
                             </a>
                           </li>
@@ -1574,7 +1576,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_dynamic_programming/intro_to_dynamic_programming/">
                               <span class="md-ellipsis">
-                                14.1 Введение в динамическое программирование
+                                14.1 Первое знакомство с динамическим программированием
                               </span>
                             </a>
                           </li>
@@ -1602,7 +1604,7 @@
                           <li class="md-nav__item">
                             <a class="md-nav__link" href="./chapter_dynamic_programming/unbounded_knapsack_problem/">
                               <span class="md-ellipsis">
-                                14.5 Задача о неограниченном рюкзаке
+                                14.5 Задача о полном рюкзаке
                               </span>
                             </a>
                           </li>
diff --git a/ru/javascripts/katex.js b/ru/javascripts/katex.js
index 89e3d73c6..b3d5ad9a6 100644
--- a/ru/javascripts/katex.js
+++ b/ru/javascripts/katex.js
@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260331044536 */
+/*! update cache: 20260331053229 */
diff --git a/ru/javascripts/mathjax.js b/ru/javascripts/mathjax.js
index 5e22de2c5..a8febef1a 100644
--- a/ru/javascripts/mathjax.js
+++ b/ru/javascripts/mathjax.js
@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260331044536 */
+/*! update cache: 20260331053229 */
diff --git a/ru/javascripts/starfield.js b/ru/javascripts/starfield.js
index d1b20a215..a85ddcbb4 100644
--- a/ru/javascripts/starfield.js
+++ b/ru/javascripts/starfield.js
@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260331044536 */
+/*! update cache: 20260331053229 */
diff --git a/ru/search.json b/ru/search.json
index 213ab1ca0..951abb2ea 100644
--- a/ru/search.json
+++ b/ru/search.json
@@ -1 +1 @@
-{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"Глава 16.   Приложение","text":"","path":["Глава 16. Приложение","Глава 16. &nbsp; Приложение"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>16.1   Установка среды программирования</li> <li>16.2   Присоединяйтесь к созданию книги</li> <li>16.3   Глоссарий</li> </ul>","path":["Глава 16. Приложение","Глава 16. &nbsp; Приложение"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   Присоединяйтесь к созданию книги","text":"<p>Возможности автора ограничены, поэтому в книге неизбежно могут встречаться упущения и ошибки. Просим отнестись к этому с пониманием. Если вы заметите опечатки, неработающие ссылки, пропуски в содержании, двусмысленные формулировки, неясные объяснения или неудачную структуру изложения, пожалуйста, помогите нам это исправить, чтобы читатели получили более качественный учебный ресурс.</p> <p>Все GitHub ID авторов будут указаны на главных страницах репозитория книги, веб-версии и PDF-версии в знак благодарности за их бескорыстный вклад в сообщество открытого исходного кода.</p> <p>Сила открытого исходного кода</p> <p>Интервал между двумя тиражами бумажной книги обычно довольно велик, поэтому обновлять содержание очень неудобно.</p> <p>В этой же открытой книге цикл обновления содержания сокращается до нескольких дней, а иногда даже до нескольких часов.</p>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   Небольшие правки содержания","text":"<p>Как показано на рисунке 16-3, в правом верхнем углу каждой страницы есть \"значок редактирования\". Текст или код можно изменить следующим образом.</p> <ol> <li>Нажмите на \"значок редактирования\". Если появится сообщение \"You need to fork this repository\", согласитесь с этим действием.</li> <li>Измените содержимое исходного Markdown-файла, проверьте корректность правок и постарайтесь сохранить единый стиль оформления.</li> <li>Внизу страницы заполните описание изменений, затем нажмите кнопку \"Propose file change\". После перехода на следующую страницу нажмите кнопку \"Create pull request\", чтобы отправить pull request.</li> </ol> <p></p> <p> Рисунок 16-3   Кнопка редактирования страницы </p> <p>Изображения нельзя изменить напрямую, поэтому проблему с ними нужно описывать через новый Issue или комментарий. Мы постараемся как можно быстрее исправить и обновить изображение.</p>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   Создание содержания","text":"<p>Если вам интересно участвовать в этом проекте с открытым исходным кодом, например переводить код на другие языки программирования или расширять содержание статей, то следует придерживаться следующего процесса Pull Request.</p> <ol> <li>Войдите в GitHub и сделайте Fork репозитория книги в свой личный аккаунт.</li> <li>Перейдите на страницу своего Fork-репозитория и с помощью команды <code>git clone</code> клонируйте репозиторий локально.</li> <li>Создавайте и редактируйте содержание локально, затем проведите полное тестирование и проверьте корректность кода.</li> <li>Зафиксируйте локальные изменения, после чего выполните Push в удаленный репозиторий.</li> <li>Обновите страницу репозитория и нажмите кнопку \"Create pull request\", чтобы инициировать pull request.</li> </ol>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Развертывание Docker","text":"<p>В корневом каталоге <code>hello-algo</code> выполните следующий Docker-скрипт, после чего проект станет доступен по адресу <code>http://localhost:8000</code>:</p> <pre><code>docker-compose up -d\n</code></pre> <p>Удалить развертывание можно следующей командой:</p> <pre><code>docker-compose down\n</code></pre>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   Установка среды программирования","text":"","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   Установка IDE","text":"<p>В качестве локальной интегрированной среды разработки (IDE) рекомендуется использовать открытую и быструю VS Code. Перейдите на официальный сайт VS Code, выберите версию для своей операционной системы и установите ее.</p> <p></p> <p> Рисунок 16-1   Загрузка VS Code с официального сайта </p> <p>VS Code обладает мощной экосистемой расширений и поддерживает выполнение и отладку большинства языков программирования. Например, после установки расширения \"Python Extension Pack\" можно отлаживать код на Python. Процесс установки показан на рисунке 16-2.</p> <p></p> <p> Рисунок 16-2   Установка расширений VS Code </p>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   Установка языковой среды","text":"","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Среда Python","text":"<ol> <li>Загрузите и установите Miniconda3, требуется Python 3.10 или более поздняя версия.</li> <li>В магазине расширений VS Code найдите <code>python</code> и установите Python Extension Pack.</li> <li>(Необязательно) Введите в командной строке <code>pip install black</code>, чтобы установить инструмент форматирования кода.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   Среда C/C++","text":"<ol> <li>В Windows требуется установить MinGW (руководство по настройке); в macOS компилятор Clang уже установлен по умолчанию.</li> <li>В магазине расширений VS Code найдите <code>c++</code> и установите C/C++ Extension Pack.</li> <li>(Необязательно) Откройте страницу Settings, найдите параметр форматирования <code>Clang_format_fallback Style</code> и задайте значение <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code>.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Среда Java","text":"<ol> <li>Загрузите и установите OpenJDK (требуемая версия: &gt; JDK 9).</li> <li>В магазине расширений VS Code найдите <code>java</code> и установите Extension Pack for Java.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   Среда C","text":"<ol> <li>Загрузите и установите .Net 8.0.</li> <li>В магазине расширений VS Code найдите <code>C# Dev Kit</code> и установите C# Dev Kit (руководство по настройке).</li> <li>Также можно использовать Visual Studio (руководство по установке).</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Среда Go","text":"<ol> <li>Загрузите и установите go.</li> <li>В магазине расширений VS Code найдите <code>go</code> и установите Go.</li> <li>Нажмите <code>Ctrl + Shift + P</code>, чтобы открыть командную палитру, введите <code>go</code>, выберите <code>Go: Install/Update Tools</code>, отметьте все инструменты и установите их.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Среда Swift","text":"<ol> <li>Загрузите и установите Swift.</li> <li>В магазине расширений VS Code найдите <code>swift</code> и установите Swift for Visual Studio Code.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   Среда JavaScript","text":"<ol> <li>Загрузите и установите Node.js.</li> <li>(Необязательно) В магазине расширений VS Code найдите <code>Prettier</code> и установите инструмент форматирования кода.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   Среда TypeScript","text":"<ol> <li>Выполните те же шаги, что и для среды JavaScript.</li> <li>Установите TypeScript Execute (tsx).</li> <li>В магазине расширений VS Code найдите <code>typescript</code> и установите Pretty TypeScript Errors.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Среда Dart","text":"<ol> <li>Загрузите и установите Dart.</li> <li>В магазине расширений VS Code найдите <code>dart</code> и установите Dart.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Среда Rust","text":"<ol> <li>Загрузите и установите Rust.</li> <li>В магазине расширений VS Code найдите <code>rust</code> и установите rust-analyzer.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   Глоссарий","text":"<p>В таблице 16-1 приведены важные термины, встречающиеся в книге. Обратите внимание на следующие моменты.</p> <ul> <li>Рекомендуем запомнить английские названия терминов, чтобы легче читать англоязычные материалы.</li> <li>В русской версии для каждого термина приводится единый рекомендуемый перевод.</li> </ul> <p> Таблица 16-1   Важные термины по структурам данных и алгоритмам </p> English Русский algorithm алгоритм data structure структура данных code код file файл function функция method метод variable переменная asymptotic complexity analysis асимптотический анализ сложности time complexity временная сложность space complexity пространственная сложность loop цикл iteration итерация recursion рекурсия tail recursion хвостовая рекурсия recursion tree дерево рекурсии big-\\(O\\) notation нотация big-\\(O\\) asymptotic upper bound асимптотическая верхняя граница sign-magnitude прямой код 1’s complement обратный код 2’s complement дополнительный код array массив index индекс linked list связный список linked list node, list node узел связного списка head node головной узел tail node хвостовой узел list список dynamic array динамический массив hard disk жесткий диск random-access memory (RAM) оперативная память cache memory кеш-память cache miss промах кеша cache hit rate коэффициент попадания в кеш stack стек top of the stack вершина стека bottom of the stack основание стека queue очередь double-ended queue двусторонняя очередь front of the queue голова очереди rear of the queue хвост очереди hash table хеш-таблица hash set хеш-набор bucket бакет hash function хеш-функция hash collision хеш-коллизия load factor коэффициент заполнения separate chaining цепная адресация open addressing открытая адресация linear probing линейное зондирование lazy deletion ленивое удаление binary tree двоичное дерево tree node узел дерева left-child node левый дочерний узел right-child node правый дочерний узел parent node родительский узел left subtree левое поддерево right subtree правое поддерево root node корневой узел leaf node листовой узел edge ребро level уровень degree степень height высота depth глубина perfect binary tree идеальное двоичное дерево complete binary tree полное двоичное дерево full binary tree строгое двоичное дерево balanced binary tree сбалансированное двоичное дерево binary search tree двоичное дерево поиска AVL tree АВЛ-дерево red-black tree красно-черное дерево level-order traversal обход по уровням breadth-first traversal обход в ширину depth-first traversal обход в глубину pre-order traversal прямой обход in-order traversal симметричный обход post-order traversal обратный обход balanced binary search tree сбалансированное двоичное дерево поиска balance factor фактор баланса heap куча max heap максимальная куча min heap минимальная куча priority queue приоритетная очередь heapify упорядочивание кучи top-\\(k\\) problem поиск \\(k\\) наибольших элементов graph граф vertex вершина undirected graph неориентированный граф directed graph ориентированный граф connected graph связный граф disconnected graph несвязный граф weighted graph взвешенный граф adjacency смежность path путь in-degree входящая степень out-degree исходящая степень adjacency matrix матрица смежности adjacency list список смежности breadth-first search поиск в ширину depth-first search поиск в глубину binary search двоичный поиск searching algorithm алгоритм поиска sorting algorithm алгоритм сортировки selection sort сортировка выбором bubble sort сортировка пузырьком insertion sort сортировка вставкой quick sort быстрая сортировка merge sort сортировка слиянием heap sort пирамидальная сортировка bucket sort блочная сортировка counting sort сортировка подсчетом radix sort поразрядная сортировка divide and conquer разделяй и властвуй hanota problem задача о Ханойской башне backtracking algorithm алгоритм поиска с возвратом constraint ограничение solution решение state состояние pruning отсечение permutations problem задача о перестановках subset-sum problem задача о сумме подмножеств \\(n\\)-queens problem задача о \\(n\\) ферзях dynamic programming динамическое программирование initial state начальное состояние state-transition equation уравнение перехода состояния knapsack problem задача о рюкзаке edit distance problem задача о расстоянии редактирования greedy algorithm жадный алгоритм","path":["Глава 16. Приложение","16.3 &nbsp; Глоссарий"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"Глава 4.   Массивы и списки","text":"<p>Abstract</p> <p>Мир структур данных напоминает прочную кирпичную стену.</p> <p>Кирпичи массива уложены ровно и плотно прилегают друг к другу. Узлы связного списка, напротив, разбросаны в разных местах, а соединяющие их связи свободно тянутся между промежутками.</p>","path":["Глава 4. Массив и связный список","Глава 4. &nbsp; Массивы и списки"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>4.1   Массив</li> <li>4.2   Связный список</li> <li>4.3   Список</li> <li>4.4   Память и кеш *</li> <li>4.5   Резюме</li> </ul>","path":["Глава 4. Массив и связный список","Глава 4. &nbsp; Массивы и списки"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   Массив","text":"<p>Массив (array) - это линейная структура данных, в которой элементы одного типа хранятся в непрерывной области памяти. Положение элемента в массиве называется его индексом (index). На рисунке 4-1 показаны основные понятия, связанные с массивом, и способ его хранения.</p> <p></p> <p> Рисунок 4-1   Определение массива и способ хранения </p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   Основные операции с массивом","text":"","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   Инициализация массива","text":"<p>Существует два способа инициализации массива: без начальных значений и с заданными начальными значениями. Если начальные значения не указаны, большинство языков программирования инициализируют элементы массива нулями:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># Инициализация массива\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* Инициализация массива */\n// Хранится в стеке\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Хранится в куче (требуется ручное освобождение памяти)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* Инициализация массива */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* Инициализация массива */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* Инициализация массива */\nvar arr [5]int\n// В Go указание длины ([5]int) создает массив, а отсутствие длины ([]int) - срез\n// Поскольку длина массива в Go определяется на этапе компиляции, для задания длины можно использовать только константы\n// Чтобы упростить реализацию метода extend(), ниже будем рассматривать срезы (Slice) как массивы (Array)\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* Инициализация массива */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* Инициализация массива */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* Инициализация массива */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* Инициализация массива */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* Инициализация массива */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// В Rust указание длины ([i32; 5]) создает массив, а отсутствие длины (&amp;[i32]) - срез\n// Поскольку длина массива в Rust определяется на этапе компиляции, для задания длины можно использовать только константы\n// Vector в Rust обычно используется как динамический массив\n// Чтобы упростить реализацию метода extend(), ниже будем рассматривать vector как массив (array)\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* Инициализация массива */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* Инициализация массива */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># Инициализация массива\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%0Aarr%20%3D%20%5B0%5D%20%2A%205%20%20%23%20%5B%200%2C%200%2C%200%2C%200%2C%200%20%5D%0Anums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D&amp;cumulative=false&amp;curInstr=0&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   Доступ к элементам","text":"<p>Элементы массива хранятся в непрерывной области памяти, что упрощает вычисление их адресов. Зная адрес массива в памяти (то есть адрес первого элемента) и индекс некоторого элемента, мы можем по формуле с рисунка ниже вычислить адрес этого элемента и напрямую обратиться к нему.</p> <p></p> <p> Рисунок 4-2   Вычисление адреса элемента массива </p> <p>Если посмотреть на рисунок 4-2, можно заметить, что индекс первого элемента массива равен \\(0\\) , и это кажется не слишком интуитивным, ведь естественнее было бы начинать счет с \\(1\\) . Однако с точки зрения формулы адресации индекс по сути является смещением относительно адреса памяти. Смещение первого элемента равно \\(0\\) , поэтому индекс \\(0\\) полностью логичен.</p> <p>Доступ к элементам массива очень эффективен: любой элемент массива можно получить за \\(O(1)\\) времени.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"Случайный доступ к элементу\"\"\"\n    # Случайным образом выбрать число из интервала [0, len(nums)-1]\n    random_index = random.randint(0, len(nums) - 1)\n    # Получить и вернуть случайный элемент\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int *nums, int size) {\n    // Случайным образом выбрать число из интервала [0, size)\n    int randomIndex = rand() % size;\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int[] nums) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* Случайный доступ к элементу */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // Случайным образом выбрать число из интервала [0, nums.Length)\n    int randomIndex = random.Next(nums.Length);\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* Случайный доступ к элементу */\nfunc randomAccess(nums []int) (randomNum int) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    randomIndex := rand.Intn(len(nums))\n    // Получить и вернуть случайный элемент\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* Случайный доступ к элементу */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // Случайным образом выбрать число из интервала [0, nums.count)\n    let randomIndex = nums.indices.randomElement()!\n    // Получить и вернуть случайный элемент\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* Случайный доступ к элементу */\nfunction randomAccess(nums) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Получить и вернуть случайный элемент\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* Случайный доступ к элементу */\nfunction randomAccess(nums: number[]): number {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Получить и вернуть случайный элемент\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* Случайный доступ к элементу */\nint randomAccess(List&lt;int&gt; nums) {\n  // Случайным образом выбрать число из интервала [0, nums.length)\n  int randomIndex = Random().nextInt(nums.length);\n  // Получить и вернуть случайный элемент\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* Случайный доступ к элементу */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // Случайным образом выбрать число из интервала [0, nums.len())\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // Получить и вернуть случайный элемент\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int *nums, int size) {\n    // Случайным образом выбрать число из интервала [0, size)\n    int randomIndex = rand() % size;\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* Случайный доступ к элементу */\nfun randomAccess(nums: IntArray): Int {\n    // Случайным образом выбрать число из интервала [0, nums.size)\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // Получить и вернуть случайный элемент\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### Случайный доступ к элементу ###\ndef random_access(nums)\n  # Случайным образом выбрать число из интервала [0, nums.length)\n  random_index = Random.rand(0...nums.length)\n\n  # Получить и вернуть случайный элемент\n  nums[random_index]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   Вставка элемента","text":"<p>Элементы массива в памяти расположены вплотную друг к другу, и между ними нет места для размещения новых данных. Как показано на рисунке 4-3, если мы хотим вставить элемент в середину массива, то все элементы после этой позиции нужно сдвинуть на одну позицию вправо, а затем записать новое значение в освободившийся индекс.</p> <p></p> <p> Рисунок 4-3   Пример вставки элемента в массив </p> <p>Стоит отметить, что длина массива фиксирована, поэтому вставка нового элемента неизбежно приведет к потере элемента на конце массива. Решение этой проблемы мы оставим для обсуждения в разделе о \"списках\".</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"Вставить элемент num по индексу index в массив\"\"\"\n    # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # Присвоить num элементу по индексу index\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int *nums, int size, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int[] nums, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid Insert(int[] nums, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* Вставить элемент num по индексу index в массив */\nfunc insert(nums []int, num int, index int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* Вставить элемент num по индексу index в массив */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* Вставить элемент num по индексу index в массив */\nfunction insert(nums, num, index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* Вставить элемент num по индексу index в массив */\nfunction insert(nums: number[], num: number, index: number): void {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* Вставить элемент _num по индексу index в массив */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // Присвоить _num элементу по индексу index\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* Вставить элемент num по индексу index в массив */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int *nums, int size, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* Вставить элемент num по индексу index в массив */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### Вставка элемента num по индексу index в массив ###\ndef insert(nums, num, index)\n  # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # Присвоить num элементу по индексу index\n  nums[index] = num\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   Удаление элемента","text":"<p>Аналогично, как показано на рисунке 4-4, если нужно удалить элемент по индексу \\(i\\) , то все элементы после индекса \\(i\\) необходимо сдвинуть на одну позицию влево.</p> <p></p> <p> Рисунок 4-4   Пример удаления элемента из массива </p> <p>Обрати внимание: после удаления исходный последний элемент становится бессмысленным, поэтому специально изменять его не требуется.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"Удалить элемент по индексу index\"\"\"\n    # Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* Удалить элемент по индексу index */\nvoid remove(int *nums, int size, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* Удалить элемент по индексу index */\nvoid remove(int[] nums, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* Удалить элемент по индексу index */\nvoid Remove(int[] nums, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* Удалить элемент по индексу index */\nfunc remove(nums []int, index int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* Удалить элемент по индексу index */\nfunc remove(nums: inout [Int], index: Int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* Удалить элемент по индексу index */\nfunction remove(nums, index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* Удалить элемент по индексу index */\nfunction remove(nums: number[], index: number): void {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* Удалить элемент по индексу index */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // Сдвинуть все элементы после индекса index на одну позицию вперед\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* Удалить элемент по индексу index */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* Удалить элемент по индексу index */\n// Внимание: stdio.h уже использует ключевое слово remove\nvoid removeItem(int *nums, int size, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* Удалить элемент по индексу index */\nfun remove(nums: IntArray, index: Int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### Удаление элемента по индексу index ###\ndef remove(nums, index)\n  # Сдвинуть все элементы после индекса index на одну позицию вперед\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В целом операции вставки и удаления в массиве имеют следующие недостатки.</p> <ul> <li>Высокая временная сложность: средняя временная сложность и вставки, и удаления равна \\(O(n)\\) , где \\(n\\) - длина массива.</li> <li>Потеря элементов: поскольку длина массива неизменяема, после вставки элементы, выходящие за пределы длины массива, будут потеряны.</li> <li>Потери памяти: можно заранее инициализировать более длинный массив и использовать только его переднюю часть; тогда теряемые при вставке элементы на конце не будут нести смысла, но такой подход приводит к лишнему расходу памяти.</li> </ul>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   Обход массива","text":"<p>В большинстве языков программирования массив можно обходить как по индексу, так и напрямую перебирая каждый элемент:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"Обход массива\"\"\"\n    count = 0\n    # Обход массива по индексам\n    for i in range(len(nums)):\n        count += nums[i]\n    # Непосредственно обходить элементы массива\n    for num in nums:\n        count += num\n    # Одновременно обходить индексы и элементы данных\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* Обход массива */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* Обход массива */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* Обход массива */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* Обход массива */\nfunc traverse(nums []int) {\n    count := 0\n    // Обход массива по индексам\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // Непосредственно обходить элементы массива\n    for _, num := range nums {\n        count += num\n    }\n    // Одновременно обходить индексы и элементы данных\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* Обход массива */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // Обход массива по индексам\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // Непосредственно обходить элементы массива\n    for num in nums {\n        count += num\n    }\n    // Одновременно обходить индексы и элементы данных\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* Обход массива */\nfunction traverse(nums) {\n    let count = 0;\n    // Обход массива по индексам\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* Обход массива */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // Обход массива по индексам\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* Перебрать элементы массива */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // Обход массива по индексам\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // Непосредственно обходить элементы массива\n  for (int _num in nums) {\n    count += _num;\n  }\n  // Перебрать массив методом forEach\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* Обход массива */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // Обход массива по индексам\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* Обход массива */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* Обход массива */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // Обход массива по индексам\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // Непосредственно обходить элементы массива\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### Обход массива ###\ndef traverse(nums)\n  count = 0\n\n  # Обход массива по индексам\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # Непосредственно обходить элементы массива\n  for num in nums\n    count += num\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   Поиск элемента","text":"<p>Чтобы найти заданный элемент в массиве, нужно пройти по массиву и на каждой итерации проверять, совпадает ли значение; если совпадает, вернуть соответствующий индекс.</p> <p>Поскольку массив - это линейная структура данных, такая операция поиска называется линейным поиском.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"Найти заданный элемент в массиве\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* Найти заданный элемент в массиве */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* Найти заданный элемент в массиве */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* Найти заданный элемент в массиве */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* Найти заданный элемент в массиве */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* Найти заданный элемент в массиве */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* Найти заданный элемент в массиве */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* Найти заданный элемент в массиве */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* Найти заданный элемент в массиве */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* Найти заданный элемент в массиве */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* Найти заданный элемент в массиве */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* Найти заданный элемент в массиве */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### Поиск заданного элемента в массиве ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   Расширение массива","text":"<p>В сложной системной среде программа не может гарантировать, что память сразу после массива доступна, поэтому безопасно расширить емкость массива невозможно. Поэтому в большинстве языков программирования длина массива неизменяема.</p> <p>Если мы хотим расширить массив, нужно заново создать больший массив и затем по одному скопировать в него элементы исходного массива. Это операция с временной сложностью \\(O(n)\\) , и при больших массивах она очень затратна. Соответствующий код показан ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"Увеличить длину массива\"\"\"\n    # Инициализировать массив увеличенной длины\n    res = [0] * (len(nums) + enlarge)\n    # Скопировать все элементы исходного массива в новый массив\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # Вернуть новый массив после расширения\n    return res\n</code></pre> array.cpp<pre><code>/* Увеличить длину массива */\nint *extend(int *nums, int size, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int *res = new int[size + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Освободить память\n    delete[] nums;\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.java<pre><code>/* Увеличить длину массива */\nint[] extend(int[] nums, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int[] res = new int[nums.length + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.cs<pre><code>/* Увеличить длину массива */\nint[] Extend(int[] nums, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int[] res = new int[nums.Length + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.go<pre><code>/* Увеличить длину массива */\nfunc extend(nums []int, enlarge int) []int {\n    // Инициализировать массив увеличенной длины\n    res := make([]int, len(nums)+enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for i, num := range nums {\n        res[i] = num\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.swift<pre><code>/* Увеличить длину массива */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // Инициализировать массив увеличенной длины\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.js<pre><code>/* Увеличить длину массива */\n// Обратите внимание: Array в JavaScript — это динамический массив, его можно расширять напрямую\n// Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\nfunction extend(nums, enlarge) {\n    // Инициализировать массив увеличенной длины\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Скопировать все элементы исходного массива в новый массив\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.ts<pre><code>/* Увеличить длину массива */\n// Обратите внимание: Array в TypeScript — это динамический массив, его можно расширять напрямую\n// Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\nfunction extend(nums: number[], enlarge: number): number[] {\n    // Инициализировать массив увеличенной длины\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Скопировать все элементы исходного массива в новый массив\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.dart<pre><code>/* Увеличить длину массива */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // Инициализировать массив увеличенной длины\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // Скопировать все элементы исходного массива в новый массив\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // Вернуть новый массив после расширения\n  return res;\n}\n</code></pre> array.rs<pre><code>/* Увеличить длину массива */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // Инициализировать массив увеличенной длины\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // Скопировать все элементы исходного массива в новый\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // Вернуть новый массив после расширения\n    res\n}\n</code></pre> array.c<pre><code>/* Увеличить длину массива */\nint *extend(int *nums, int size, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Инициализировать расширенное пространство\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.kt<pre><code>/* Увеличить длину массива */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // Инициализировать массив увеличенной длины\n    val res = IntArray(nums.size + enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.rb<pre><code>### Увеличить длину массива ###\n# Обратите внимание: Array в Ruby является динамическим массивом и может расширяться напрямую\n# Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\ndef extend(nums, enlarge)\n  # Инициализировать массив увеличенной длины\n  res = Array.new(nums.length + enlarge, 0)\n\n  # Скопировать все элементы исходного массива в новый массив\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # Вернуть новый массив после расширения\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   Преимущества и ограничения массива","text":"<p>Массив хранится в непрерывной области памяти, и все его элементы имеют один и тот же тип. Такой подход содержит богатую априорную информацию, которую система может использовать для оптимизации эффективности операций с этой структурой данных.</p> <ul> <li>Высокая пространственная эффективность: массив выделяет для данных непрерывный блок памяти без дополнительного структурного накладного расхода.</li> <li>Поддержка произвольного доступа: массив позволяет обращаться к любому элементу за \\(O(1)\\) времени.</li> <li>Локальность кэша: при обращении к элементу массива компьютер загружает не только сам элемент, но и соседние данные, что позволяет использовать кэш для ускорения последующих операций.</li> </ul> <p>Непрерывное хранение данных - это палка о двух концах, и у него есть следующие ограничения.</p> <ul> <li>Низкая эффективность вставки и удаления: когда элементов в массиве много, вставка и удаление требуют сдвига большого количества элементов.</li> <li>Неизменяемая длина: после инициализации длина массива фиксирована; расширение массива требует копирования всех данных в новый массив, что стоит дорого.</li> <li>Потери памяти: если выделенный массив больше, чем реально необходимо, лишнее пространство пропадает впустую.</li> </ul>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   Типичные применения массива","text":"<p>Массив - это базовая и очень распространенная структура данных. Он часто используется как в различных алгоритмах, так и при реализации более сложных структур данных.</p> <ul> <li>Произвольный доступ: если мы хотим случайным образом выбирать некоторые образцы, можно сохранить их в массиве и сгенерировать случайную последовательность индексов для выборки.</li> <li>Сортировка и поиск: массив - самая распространенная структура данных для алгоритмов сортировки и поиска. Быстрая сортировка, сортировка слиянием, двоичный поиск и многие другие алгоритмы в основном работают именно с массивами.</li> <li>Таблица поиска: когда нужно быстро находить элемент или его соответствие, массив можно использовать как таблицу поиска. Например, если мы хотим реализовать отображение символов в коды ASCII, можно использовать значение ASCII как индекс, а соответствующий элемент хранить по этой позиции массива.</li> <li>Машинное обучение: в нейронных сетях широко используются операции линейной алгебры над векторами, матрицами и тензорами, и все эти данные строятся в форме массивов. Массив - самая часто используемая структура данных в программировании нейросетей.</li> <li>Реализация структур данных: массивы можно использовать для реализации стеков, очередей, хеш-таблиц, куч, графов и других структур данных. Например, матрица смежности графа по сути является двумерным массивом.</li> </ul>","path":["Глава 4. Массив и связный список","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   Связный список","text":"<p>Память - общий ресурс для всех программ, и в сложной среде выполнения свободные участки памяти могут быть разбросаны по всему адресному пространству. Мы знаем, что память для хранения массива должна быть непрерывной, а если массив очень велик, в памяти может не оказаться столь большого непрерывного блока. Именно здесь и проявляется преимущество гибкости связного списка.</p> <p>Связный список (linked list) - это линейная структура данных, в которой каждый элемент представляет собой объект-узел, а сами узлы соединены между собой с помощью ссылок. Ссылка хранит адрес памяти следующего узла, благодаря чему из текущего узла можно перейти к следующему.</p> <p>Конструкция связного списка позволяет хранить отдельные узлы в разных местах памяти, и их адреса вовсе не обязаны быть последовательными.</p> <p></p> <p> Рисунок 4-5   Определение связного списка и способ хранения </p> <p>Как видно на рисунке 4-5, базовой единицей связного списка является объект узел (node). Каждый узел содержит две части данных: значение узла и ссылку на следующий узел.</p> <ul> <li>Первый узел связного списка называется головным узлом, а последний - хвостовым узлом.</li> <li>Хвостовой узел указывает на пустое значение, что в Java, C++ и Python обозначается как <code>null</code> , <code>nullptr</code> и <code>None</code> соответственно.</li> <li>В языках, поддерживающих указатели, таких как C, C++, Go и Rust, упомянутую выше ссылку следует заменить на указатель.</li> </ul> <p>Как показано в коде ниже, узел связного списка <code>ListNode</code> хранит не только значение, но и дополнительную ссылку (указатель). Поэтому при одинаковом объеме данных связный список занимает больше памяти, чем массив.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Класс узла связного списка\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Значение узла\n        self.next: ListNode | None = None # Ссылка на следующий узел\n</code></pre> <pre><code>/* Структура узла связного списка */\nstruct ListNode {\n    int val;         // Значение узла\n    ListNode *next;  // Указатель на следующий узел\n    ListNode(int x) : val(x), next(nullptr) {}  // Конструктор\n};\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode(int x) { val = x; }  // Конструктор\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode(int x) {  // Конструктор\n    int val = x;         // Значение узла\n    ListNode? next;      // Ссылка на следующий узел\n}\n</code></pre> <pre><code>/* Структура узла связного списка */\ntype ListNode struct {\n    Val  int       // Значение узла\n    Next *ListNode // Указатель на следующий узел\n}\n\n// NewListNode Конструктор, создает новый узел\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на следующий узел\n\n    init(x: Int) { // Конструктор\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Значение узла\n        this.next = (next === undefined ? null : next); // Ссылка на следующий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Значение узла\n        this.next = next === undefined ? null : next;  // Ссылка на следующий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n  int val; // Значение узла\n  ListNode? next; // Ссылка на следующий узел\n  ListNode(this.val, [this.next]); // Конструктор\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* Класс узла связного списка */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Значение узла\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на следующий узел\n}\n</code></pre> <pre><code>/* Структура узла связного списка */\ntypedef struct ListNode {\n    int val;               // Значение узла\n    struct ListNode *next; // Указатель на следующий узел\n} ListNode;\n\n/* Конструктор */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\n// Конструктор\nclass ListNode(x: Int) {\n    val _val: Int = x          // Значение узла\n    val next: ListNode? = null // Ссылка на следующий узел\n}\n</code></pre> <pre><code># Класс узла связного списка\nclass ListNode\n  attr_accessor :val  # Значение узла\n  attr_accessor :next # Ссылка на следующий узел\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   Основные операции со связным списком","text":"","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   Инициализация связного списка","text":"<p>Построение связного списка состоит из двух шагов: сначала нужно инициализировать объекты всех узлов, затем установить ссылочные связи между ними. После завершения инициализации мы можем, начиная с головы списка, последовательно проходить все узлы по ссылке <code>next</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Инициализация отдельных узлов\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Построение ссылок между узлами\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// Инициализация отдельных узлов\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Построение ссылок между узлами\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Построение ссылок между узлами\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Инициализация отдельных узлов\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%201%20-%3E%203%20-%3E%202%20-%3E%205%20-%3E%204%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n0%20%3D%20ListNode%281%29%0A%20%20%20%20n1%20%3D%20ListNode%283%29%0A%20%20%20%20n2%20%3D%20ListNode%282%29%0A%20%20%20%20n3%20%3D%20ListNode%285%29%0A%20%20%20%20n4%20%3D%20ListNode%284%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%0A%20%20%20%20n0.next%20%3D%20n1%0A%20%20%20%20n1.next%20%3D%20n2%0A%20%20%20%20n2.next%20%3D%20n3%0A%20%20%20%20n3.next%20%3D%20n4&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Массив в целом - это одна переменная: например, массив <code>nums</code> содержит элементы <code>nums[0]</code> , <code>nums[1]</code> и т.д. Связный список же состоит из множества независимых объектов-узлов. Обычно в качестве обозначения всего связного списка используют головной узел; например, в приведенном выше коде связный список можно обозначить как <code>n0</code> .</p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   Вставка узла","text":"<p>Вставить узел в связный список очень легко. Как показано на рисунке 4-6, предположим, что мы хотим вставить новый узел <code>P</code> между двумя соседними узлами <code>n0</code> и <code>n1</code> ; для этого нужно изменить всего две ссылки (указателя), а временная сложность будет равна \\(O(1)\\) .</p> <p>Для сравнения: временная сложность вставки элемента в массив составляет \\(O(n)\\) , и при большом объеме данных это менее эффективно.</p> <p></p> <p> Рисунок 4-6   Пример вставки узла в связный список </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"Вставить узел P после узла n0 в связном списке\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* Вставить узел P после узла n0 в связном списке */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### Вставка узла _p после узла n0 в связном списке ###\n# В Ruby `p` является встроенной функцией, а `P` — константой, поэтому вместо них можно использовать `_p`\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   Удаление узла","text":"<p>Как показано на рисунке 4-7, удалить узел из связного списка тоже очень просто: нужно изменить всего одну ссылку (указатель).</p> <p>Стоит отметить, что хотя после завершения операции удаления узел <code>P</code> все еще указывает на <code>n1</code> , при обходе связного списка до <code>P</code> уже нельзя добраться. Это означает, что <code>P</code> фактически больше не принадлежит данному списку.</p> <p></p> <p> Рисунок 4-7   Удаление узла из связного списка </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"Удалить первый узел после узла n0 в связном списке\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Освободить память\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* Удалить первый узел после узла n0 в связном списке */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* Удалить первый узел после узла n0 в связном списке */\n// Внимание: stdio.h уже использует ключевое слово remove\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Освободить память\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### Удаление первого узла после узла n0 в связном списке ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   Доступ к узлу","text":"<p>Доступ к узлам в связном списке менее эффективен. Как уже обсуждалось в предыдущем разделе, к любому элементу массива можно обратиться за \\(O(1)\\) времени. Со связным списком это не так: программе нужно начать с головного узла и последовательно двигаться дальше, пока не будет найден целевой узел. То есть для доступа к \\(i\\) -му узлу списка нужно выполнить \\(i - 1\\) итераций, а временная сложность составляет \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"Доступ к узлу связного списка по индексу index\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* Доступ к узлу связного списка по индексу index */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* Доступ к узлу связного списка по индексу index */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### Доступ к узлу связного списка по индексу index ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   Поиск узла","text":"<p>Поиск узла заключается в обходе связного списка, нахождении узла со значением <code>target</code> и возврате его индекса в списке. Этот процесс тоже относится к линейному поиску. Код выглядит следующим образом:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"Найти в связном списке первый узел со значением target\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* Найти в связном списке первый узел со значением target */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* Найти в связном списке первый узел со значением target */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* Найти в связном списке первый узел со значением target */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* Найти в связном списке первый узел со значением target */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* Найти в связном списке первый узел со значением target */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* Найти в связном списке первый узел со значением target */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* Найти в связном списке первый узел со значением target */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### Поиск первого узла со значением target в связном списке ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422","level":2,"title":"4.2.2   Сравнение массива и связного списка","text":"<p>В таблице 4-1 обобщаются свойства массива и связного списка, а также сравнивается эффективность соответствующих операций. Поскольку они используют противоположные стратегии хранения, их свойства и эффективность операций тоже во многом противоположны.</p> <p> Таблица 4-1   Сравнение эффективности массива и связного списка </p> Массив Связный список Способ хранения Непрерывная область памяти Разрозненная область памяти Расширение емкости Длина неизменяема Гибкое расширение Эффективность памяти Элементы занимают меньше памяти, но возможны потери пространства Элементы занимают больше памяти Доступ к элементу \\(O(1)\\) \\(O(n)\\) Добавление элемента \\(O(n)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(1)\\)","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   Основные типы связных списков","text":"<p>Как показано на рисунке 4-8, существует три распространенных типа связных списков.</p> <ul> <li>Односвязный список: это обычный связный список, рассмотренный выше. Узел односвязного списка содержит значение и ссылку на следующий узел. Первый узел называется головным, последний - хвостовым, и хвост указывает на <code>None</code> .</li> <li>Циклический список: если заставить хвостовой узел односвязного списка указывать на головной, то есть соединить хвост с головой, получится циклический список. В циклическом списке любой узел можно рассматривать как головной.</li> <li>Двусвязный список: по сравнению с односвязным списком двусвязный хранит ссылки в двух направлениях. Определение узла двусвязного списка включает как ссылку на следующий узел, так и ссылку на предыдущий узел. По сравнению с односвязным списком двусвязный более гибок и позволяет обходить список в обе стороны, но за это приходится платить дополнительной памятью.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Класс узла двусвязного списка\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Значение узла\n        self.next: ListNode | None = None  # Ссылка на следующий узел\n        self.prev: ListNode | None = None  # Ссылка на предыдущий узел\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\nstruct ListNode {\n    int val;         // Значение узла\n    ListNode *next;  // Указатель на следующий узел\n    ListNode *prev;  // Указатель на предыдущий узел\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Конструктор\n};\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode prev;  // Ссылка на предыдущий узел\n    ListNode(int x) { val = x; }  // Конструктор\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode(int x) {  // Конструктор\n    int val = x;    // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode prev;  // Ссылка на предыдущий узел\n}\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\ntype DoublyListNode struct {\n    Val  int             // Значение узла\n    Next *DoublyListNode // Указатель на следующий узел\n    Prev *DoublyListNode // Указатель на предыдущий узел\n}\n\n// NewDoublyListNode Инициализация\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на следующий узел\n    var prev: ListNode? // Ссылка на предыдущий узел\n\n    init(x: Int) { // Конструктор\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Значение узла\n        this.next = next  ===  undefined ? null : next;  // Ссылка на следующий узел\n        this.prev = prev  ===  undefined ? null : prev;  // Ссылка на предыдущий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Значение узла\n        this.next = next  ===  undefined ? null : next;  // Ссылка на следующий узел\n        this.prev = prev  ===  undefined ? null : prev;  // Ссылка на предыдущий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode? next;  // Ссылка на следующий узел\n    ListNode? prev;  // Ссылка на предыдущий узел\n    ListNode(this.val, [this.next, this.prev]);  // Конструктор\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Тип узла двусвязного списка */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Значение узла\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на следующий узел\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на предыдущий узел\n}\n\n/* Конструктор */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\ntypedef struct ListNode {\n    int val;               // Значение узла\n    struct ListNode *next; // Указатель на следующий узел\n    struct ListNode *prev; // Указатель на предыдущий узел\n} ListNode;\n\n/* Конструктор */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\n// Конструктор\nclass ListNode(x: Int) {\n    val _val: Int = x           // Значение узла\n    val next: ListNode? = null  // Ссылка на следующий узел\n    val prev: ListNode? = null  // Ссылка на предыдущий узел\n}\n</code></pre> <pre><code># Класс узла двусвязного списка\nclass ListNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :next   # Ссылка на следующий узел\n  attr_accessor :prev   # Ссылка на предыдущий узел\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> Рисунок 4-8   Распространенные типы связных списков </p>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   Типичные применения связных списков","text":"<p>Односвязные списки обычно используются для реализации стеков, очередей, хеш-таблиц и графов.</p> <ul> <li>Стеки и очереди: если операции вставки и удаления выполняются на одном конце связного списка, он проявляет свойства LIFO, соответствующие стеку; если вставка происходит на одном конце, а удаление на другом, он проявляет свойства FIFO, соответствующие очереди.</li> <li>Хеш-таблицы: метод цепочек - один из основных способов разрешения коллизий в хеш-таблицах. В этом подходе все конфликтующие элементы помещаются в связный список.</li> <li>Графы: список смежности - это распространенный способ представления графа, при котором каждой вершине графа соответствует связный список, а каждый элемент этого списка представляет другую вершину, соединенную с данной.</li> </ul> <p>Двусвязные списки обычно используются там, где нужен быстрый доступ как к предыдущему, так и к следующему элементу.</p> <ul> <li>Продвинутые структуры данных: например, в красно-черных деревьях и B-деревьях нам нужен доступ к родительскому узлу; этого можно добиться, сохранив в узле ссылку на родителя, по аналогии с двусвязным списком.</li> <li>История браузера: когда пользователь в браузере нажимает кнопки \"вперед\" или \"назад\", браузеру нужно знать предыдущую и следующую посещенные страницы. Свойства двусвязного списка делают такую операцию простой.</li> <li>Алгоритм LRU: в алгоритмах вытеснения из кэша (LRU) нужно быстро находить наименее недавно использованные данные, а также быстро добавлять и удалять узлы. Для этого двусвязный список подходит очень хорошо.</li> </ul> <p>Циклические списки часто применяются в сценариях, требующих циклических операций, например при планировании ресурсов в операционной системе.</p> <ul> <li>Алгоритм циклического распределения кванта времени: в операционных системах round-robin scheduling - это распространенный алгоритм планирования CPU, который циклически обходит набор процессов. Каждому процессу выделяется квант времени, и когда он исчерпан, CPU переключается на следующий процесс. Такую циклическую операцию удобно реализовать с помощью кольцевого списка.</li> <li>Буферы данных: в некоторых реализациях буферов данных также могут использоваться циклические списки. Например, в аудио- и видеоплеерах поток данных может делиться на несколько буферных блоков и помещаться в кольцевой список для обеспечения непрерывного воспроизведения.</li> </ul>","path":["Глава 4. Массив и связный список","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   Список","text":"<p>Список (list) - это абстрактное понятие структуры данных, обозначающее упорядоченную коллекцию элементов, которая поддерживает доступ к элементам, их изменение, добавление, удаление и обход, не требуя от пользователя учитывать ограничения по емкости. Список может быть реализован как на основе связного списка, так и на основе массива.</p> <ul> <li>Связный список естественным образом можно рассматривать как список: он поддерживает операции добавления, удаления, поиска и изменения элементов и может гибко расширяться динамически.</li> <li>Массив тоже поддерживает операции добавления, удаления, поиска и изменения элементов, но из-за неизменяемости длины его можно считать лишь списком с ограниченной длиной.</li> </ul> <p>Когда список реализуется с помощью массива, неизменяемость длины снижает его практическую полезность. Причина в том, что мы обычно не можем заранее точно знать, сколько данных нужно хранить, а значит, трудно выбрать подходящую длину списка. Если длина слишком мала, она может не покрыть реальные потребности; если слишком велика, будет зря расходоваться память.</p> <p>Чтобы решить эту проблему, можно использовать динамический массив (dynamic array) для реализации списка. Он сохраняет все преимущества массива и при этом может динамически расширяться во время выполнения программы.</p> <p>На практике списки из стандартных библиотек многих языков программирования реализованы именно на основе динамических массивов, например <code>list</code> в Python, <code>ArrayList</code> в Java, <code>vector</code> в C++ и <code>List</code> в C#. В дальнейшем обсуждении мы будем считать понятия \"список\" и \"динамический массив\" эквивалентными.</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   Основные операции со списком","text":"","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   Инициализация списка","text":"<p>Обычно используются два способа инициализации: без начальных значений и с начальными значениями:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Инициализация списка\n# Без начальных значений\nnums1: list[int] = []\n# С начальными значениями\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* Инициализация списка */\n// Обрати внимание: в C++ vector соответствует описываемому здесь nums\n// Без начальных значений\nvector&lt;int&gt; nums1;\n// С начальными значениями\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// С начальными значениями (обрати внимание: элементы массива должны использовать обертку Integer[] вместо int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;int&gt; nums1 = [];\n// С начальными значениями\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* Инициализация списка */\n// Без начальных значений\nnums1 := []int{}\n// С начальными значениями\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* Инициализация списка */\n// Без начальных значений\nlet nums1: [Int] = []\n// С начальными значениями\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* Инициализация списка */\n// Без начальных значений\nconst nums1 = [];\n// С начальными значениями\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* Инициализация списка */\n// Без начальных значений\nconst nums1: number[] = [];\n// С начальными значениями\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;int&gt; nums1 = [];\n// С начальными значениями\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* Инициализация списка */\n// Без начальных значений\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// С начальными значениями\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Инициализация списка */\n// Без начальных значений\nvar nums1 = listOf&lt;Int&gt;()\n// С начальными значениями\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># Инициализация списка\n# Без начальных значений\nnums1 = []\n# С начальными значениями\nnums = [1, 3, 2, 5, 4]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20%23%20%D0%91%D0%B5%D0%B7%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D1%85%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9%0A%20%20%20%20nums1%20%3D%20%5B%5D%0A%20%20%20%20%23%20%D0%A1%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%BC%D0%B8%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D&amp;cumulative=false&amp;curInstr=4&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   Доступ к элементам","text":"<p>Поскольку в этом разделе список рассматривается как структура на основе динамического массива, доступ к элементам и их обновление можно выполнять за \\(O(1)\\) времени, что очень эффективно.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Доступ к элементу\nnum: int = nums[1]  # Доступ к элементу по индексу 1\n\n# Обновление элемента\nnums[1] = 0    # Обновить элемент по индексу 1 значением 0\n</code></pre> list.cpp<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.java<pre><code>/* Доступ к элементу */\nint num = nums.get(1);  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums.set(1, 0);  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.cs<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list_test.go<pre><code>/* Доступ к элементу */\nnum := nums[1]  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0     // Обновить элемент по индексу 1 значением 0\n</code></pre> list.swift<pre><code>/* Доступ к элементу */\nlet num = nums[1] // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0 // Обновить элемент по индексу 1 значением 0\n</code></pre> list.js<pre><code>/* Доступ к элементу */\nconst num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.ts<pre><code>/* Доступ к элементу */\nconst num: number = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.dart<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.rs<pre><code>/* Доступ к элементу */\nlet num: i32 = nums[1];  // Доступ к элементу по индексу 1\n/* Обновление элемента */\nnums[1] = 0;             // Обновить элемент по индексу 1 значением 0\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Доступ к элементу */\nval num = nums[1]       // Доступ к элементу по индексу 1\n/* Обновление элемента */\nnums[1] = 0             // Обновить элемент по индексу 1 значением 0\n</code></pre> list.rb<pre><code># Доступ к элементу\nnum = nums[1] # Доступ к элементу по индексу 1\n# Обновление элемента\nnums[1] = 0 # Обновить элемент по индексу 1 значением 0\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%20%D0%BA%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%83%0A%20%20%20%20num%20%3D%20nums%5B1%5D%20%20%23%20%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%B8%D1%82%D1%8C%D1%81%D1%8F%20%D0%BA%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%201%20%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%0A%20%20%20%20%23%20%D0%9E%D0%B1%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%20%20%20%20nums%5B1%5D%20%3D%200%20%20%20%20%23%20%D0%9E%D0%B1%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%201%20%D0%B4%D0%BE%200&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   Вставка и удаление элементов","text":"<p>В отличие от массива список позволяет свободно добавлять и удалять элементы. Добавление элемента в конец списка имеет временную сложность \\(O(1)\\) , но операции вставки и удаления по-прежнему имеют ту же эффективность, что и у массива, то есть \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Очистить список\nnums.clear()\n\n# Добавить элементы в конец\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Вставить элемент в середину\nnums.insert(3, 6)  # Вставить число 6 по индексу 3\n\n# Удалить элемент\nnums.pop(3)        # Удалить элемент по индексу 3\n</code></pre> list.cpp<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Вставить элемент в середину */\nnums.insert(nums.begin() + 3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.erase(nums.begin() + 3);      // Удалить элемент по индексу 3\n</code></pre> list.java<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.add(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);  // Удалить элемент по индексу 3\n</code></pre> list.cs<pre><code>/* Очистить список */\nnums.Clear();\n\n/* Добавить элементы в конец */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Вставить элемент в середину */\nnums.Insert(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.RemoveAt(3);  // Удалить элемент по индексу 3\n</code></pre> list_test.go<pre><code>/* Очистить список */\nnums = nil\n\n/* Добавить элементы в конец */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Вставить элемент в середину */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums = append(nums[:3], nums[4:]...) // Удалить элемент по индексу 3\n</code></pre> list.swift<pre><code>/* Очистить список */\nnums.removeAll()\n\n/* Добавить элементы в конец */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Вставить элемент в середину */\nnums.insert(6, at: 3) // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(at: 3) // Удалить элемент по индексу 3\n</code></pre> list.js<pre><code>/* Очистить список */\nnums.length = 0;\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.splice(3, 0, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.splice(3, 1);  // Удалить элемент по индексу 3\n</code></pre> list.ts<pre><code>/* Очистить список */\nnums.length = 0;\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.splice(3, 0, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.splice(3, 1);  // Удалить элемент по индексу 3\n</code></pre> list.dart<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.insert(3, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.removeAt(3); // Удалить элемент по индексу 3\n</code></pre> list.rs<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.insert(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);    // Удалить элемент по индексу 3\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.add(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);  // Удалить элемент по индексу 3\n</code></pre> list.rb<pre><code># Очистить список\nnums.clear\n\n# Добавить элементы в конец\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# Вставить элемент в середину\nnums.insert(3, 6) # Вставить число 6 по индексу 3\n\n# Удалить элемент\nnums.delete_at(3) # Удалить элемент по индексу 3\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%A1%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%BC%D0%B8%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D1%87%D0%B8%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums.clear%28%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20nums.append%281%29%0A%20%20%20%20nums.append%283%29%0A%20%20%20%20nums.append%282%29%0A%20%20%20%20nums.append%285%29%0A%20%20%20%20nums.append%284%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D1%83%0A%20%20%20%20nums.insert%283%2C%206%29%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%87%D0%B8%D1%81%D0%BB%D0%BE%206%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%203%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%20%20%20%20nums.pop%283%29%20%20%20%20%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%203&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   Обход списка","text":"<p>Как и массив, список можно обходить как по индексам, так и напрямую по элементам.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Обход списка по индексам\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Прямой обход элементов списка\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Прямой обход элементов списка */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* Обход списка по индексам */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* Обход списка по индексам */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* Обход списка по индексам */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* Обход списка по индексам */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// Обход списка по индексам\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Прямой обход элементов списка\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Обход списка по индексам */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># Обход списка по индексам\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# Прямой обход элементов списка\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%B1%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%B0%D0%BC%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20nums%5Bi%5D%0A%0A%20%20%20%20%23%20%D0%9D%D0%B5%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%20%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20num&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   Конкатенация списков","text":"<p>Создав новый список <code>nums1</code> , мы можем присоединить его к хвосту исходного списка.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Конкатенация двух списков\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Присоединить список nums1 к концу nums\n</code></pre> list.cpp<pre><code>/* Конкатенация двух списков */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// Присоединить список nums1 к концу nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* Конкатенация двух списков */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.cs<pre><code>/* Конкатенация двух списков */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list_test.go<pre><code>/* Конкатенация двух списков */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Присоединить список nums1 к концу nums\n</code></pre> list.swift<pre><code>/* Конкатенация двух списков */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Присоединить список nums1 к концу nums\n</code></pre> list.js<pre><code>/* Конкатенация двух списков */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.ts<pre><code>/* Конкатенация двух списков */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.dart<pre><code>/* Конкатенация двух списков */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.rs<pre><code>/* Конкатенация двух списков */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Конкатенация двух списков */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // Присоединить список nums1 к концу nums\n</code></pre> list.rb<pre><code># Конкатенация двух списков\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D0%B4%D0%B2%D0%B0%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20nums1%20%3D%20%5B6%2C%208%2C%207%2C%2010%2C%209%5D%0A%20%20%20%20nums%20%2B%3D%20nums1%20%20%23%20%D0%9F%D1%80%D0%B8%D1%81%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%20nums1%20%D0%BA%20nums&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   Сортировка списка","text":"<p>После сортировки списка мы сможем применять алгоритмы \"двоичный поиск\" и \"два указателя\", которые очень часто встречаются в задачах по массивам.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Отсортировать список\nnums.sort()  # После сортировки элементы списка идут по возрастанию\n</code></pre> list.cpp<pre><code>/* Отсортировать список */\nsort(nums.begin(), nums.end());  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.java<pre><code>/* Отсортировать список */\nCollections.sort(nums);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.cs<pre><code>/* Отсортировать список */\nnums.Sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list_test.go<pre><code>/* Отсортировать список */\nsort.Ints(nums)  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.swift<pre><code>/* Отсортировать список */\nnums.sort() // После сортировки элементы списка идут по возрастанию\n</code></pre> list.js<pre><code>/* Отсортировать список */\nnums.sort((a, b) =&gt; a - b);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.ts<pre><code>/* Отсортировать список */\nnums.sort((a, b) =&gt; a - b);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.dart<pre><code>/* Отсортировать список */\nnums.sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list.rs<pre><code>/* Отсортировать список */\nnums.sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Отсортировать список */\nnums.sort() // После сортировки элементы списка идут по возрастанию\n</code></pre> list.rb<pre><code># Отсортировать список\nnums = nums.sort { |a, b| a &lt;=&gt; b } # После сортировки элементы списка идут по возрастанию\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums.sort%28%29%20%20%23%20%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%2C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%80%D0%B0%D1%81%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D1%8B%20%D0%BF%D0%BE%20%D0%B2%D0%BE%D0%B7%D1%80%D0%B0%D1%81%D1%82%D0%B0%D0%BD%D0%B8%D1%8E&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   Реализация списка","text":"<p>Во многих языках программирования списки встроены в стандартную библиотеку, например в Java, C++, Python и других языках. Их реализация довольно сложна, а настройки параметров тщательно продуманы: начальная емкость, коэффициент расширения и так далее. Если это интересно, стоит заглянуть в исходный код.</p> <p>Чтобы лучше понять принцип работы списка, попробуем реализовать его упрощенную версию, в которой есть три ключевых аспекта проектирования.</p> <ul> <li>Начальная емкость: выбрать разумную начальную емкость внутреннего массива. В этом примере мы берем 10.</li> <li>Учет количества элементов: объявить переменную <code>size</code> , которая будет хранить текущее число элементов в списке и обновляться в реальном времени при вставке и удалении элементов. С помощью этой переменной можно определять конец списка и понимать, требуется ли расширение.</li> <li>Механизм расширения: если при вставке элементов емкость списка исчерпана, нужно выполнить расширение. Для этого сначала создается больший массив с учетом коэффициента расширения, а затем все элементы текущего массива по порядку переносятся в новый. В этом примере мы считаем, что каждый раз массив расширяется в 2 раза.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"Класс списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._capacity: int = 10  # Вместимость списка\n        self._arr: list[int] = [0] * self._capacity  # Массив (для хранения элементов списка)\n        self._size: int = 0  # Длина списка (текущее число элементов)\n        self._extend_ratio: int = 2  # Коэффициент увеличения списка при каждом расширении\n\n    def size(self) -&gt; int:\n        \"\"\"Получить длину списка (текущее число элементов)\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость списка\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"Доступ к элементу\"\"\"\n        # Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"Обновление элемента\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"Добавление элемента в конец\"\"\"\n        # При превышении вместимости по числу элементов запускается расширение\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"Вставка элемента в середину\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        # При превышении вместимости по числу элементов запускается расширение\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # Обновить число элементов\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"Удаление элемента\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        num = self._arr[index]\n        # Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # Обновить число элементов\n        self._size -= 1\n        # Вернуть удаленный элемент\n        return num\n\n    def extend_capacity(self):\n        \"\"\"Расширение списка\"\"\"\n        # Создать новый массив длиной в _extend_ratio раз больше исходного массива и скопировать в него исходный массив\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # Обновить вместимость списка\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть список фактической длины\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* Класс списка */\nclass MyList {\n  private:\n    int *arr;             // Массив (для хранения элементов списка)\n    int arrCapacity = 10; // Вместимость списка\n    int arrSize = 0;      // Длина списка (текущее число элементов)\n    int extendRatio = 2;   // Коэффициент увеличения списка при каждом расширении\n\n  public:\n    /* Конструктор */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Метод-деструктор */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    int size() {\n        return arrSize;\n    }\n\n    /* Получить вместимость списка */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* Доступ к элементу */\n    int get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    void add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Вставка элемента в середину */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size() == capacity())\n            extendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Удаление элемента */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        arrSize--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    void extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного массива\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // Скопировать все элементы исходного массива в новый массив\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // Освободить память\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* Преобразовать список в Vector для вывода */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* Класс списка */\nclass MyList {\n    private int[] arr; // Массив (для хранения элементов списка)\n    private int capacity = 10; // Вместимость списка\n    private int size = 0; // Длина списка (текущее число элементов)\n    private int extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public int size() {\n        return size;\n    }\n\n    /* Получить вместимость списка */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* Доступ к элементу */\n    public int get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public void add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // Обновить число элементов\n        size++;\n    }\n\n    /* Вставка элемента в середину */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        size++;\n    }\n\n    /* Удаление элемента */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public void extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // Обновить вместимость списка\n        capacity = arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    public int[] toArray() {\n        int size = size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* Класс списка */\nclass MyList {\n    private int[] arr;           // Массив (для хранения элементов списка)\n    private int arrCapacity = 10;    // Вместимость списка\n    private int arrSize = 0;         // Длина списка (текущее число элементов)\n    private readonly int extendRatio = 2;  // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* Получить вместимость списка */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* Доступ к элементу */\n    public int Get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public void Add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Вставка элемента в середину */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Удаление элемента */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        arrSize--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public void ExtendCapacity() {\n        // Создать новый массив длиной arrCapacity * extendRatio и скопировать в него исходный массив\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // Обновить вместимость списка\n        arrCapacity = arr.Length;\n    }\n\n    /* Преобразовать список в массив */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* Класс списка */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* Конструктор */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // Вместимость списка\n        arr:         make([]int, 10), // Массив (для хранения элементов списка)\n        arrSize:     0,               // Длина списка (текущее число элементов)\n        extendRatio: 2,               // Коэффициент увеличения списка при каждом расширении\n    }\n}\n\n/* Получить длину списка (текущее число элементов) */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* Получить вместимость списка */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* Доступ к элементу */\nfunc (l *myList) get(index int) int {\n    // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    return l.arr[index]\n}\n\n/* Обновление элемента */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    l.arr[index] = num\n}\n\n/* Добавление элемента в конец */\nfunc (l *myList) add(num int) {\n    // При превышении вместимости по числу элементов запускается расширение\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // Обновить число элементов\n    l.arrSize++\n}\n\n/* Вставка элемента в середину */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    // При превышении вместимости по числу элементов запускается расширение\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // Обновить число элементов\n    l.arrSize++\n}\n\n/* Удаление элемента */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    num := l.arr[index]\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // Обновить число элементов\n    l.arrSize--\n    // Вернуть удаленный элемент\n    return num\n}\n\n/* Расширение списка */\nfunc (l *myList) extendCapacity() {\n    // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // Обновить вместимость списка\n    l.arrCapacity = len(l.arr)\n}\n\n/* Вернуть список фактической длины */\nfunc (l *myList) toArray() []int {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* Класс списка */\nclass MyList {\n    private var arr: [Int] // Массив (для хранения элементов списка)\n    private var _capacity: Int // Вместимость списка\n    private var _size: Int // Длина списка (текущее число элементов)\n    private let extendRatio: Int // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Получить вместимость списка */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* Доступ к элементу */\n    func get(index: Int) -&gt; Int {\n        // Если индекс выходит за границы, выбросить ошибку; далее аналогично\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        return arr[index]\n    }\n\n    /* Обновление элемента */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        arr[index] = num\n    }\n\n    /* Добавление элемента в конец */\n    func add(num: Int) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // Обновить число элементов\n        _size += 1\n    }\n\n    /* Вставка элемента в середину */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        // При превышении вместимости по числу элементов запускается расширение\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // Обновить число элементов\n        _size += 1\n    }\n\n    /* Удаление элемента */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        let num = arr[index]\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // Обновить число элементов\n        _size -= 1\n        // Вернуть удаленный элемент\n        return num\n    }\n\n    /* Расширение списка */\n    func extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // Обновить вместимость списка\n        _capacity = arr.count\n    }\n\n    /* Преобразовать список в массив */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* Класс списка */\nclass MyList {\n    #arr = new Array(); // Массив (для хранения элементов списка)\n    #capacity = 10; // Вместимость списка\n    #size = 0; // Длина списка (текущее число элементов)\n    #extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    size() {\n        return this.#size;\n    }\n\n    /* Получить вместимость списка */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* Доступ к элементу */\n    get(index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        return this.#arr[index];\n    }\n\n    /* Обновление элемента */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        this.#arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    add(num) {\n        // Если длина равна вместимости, требуется расширение\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Добавить новый элемент в конец списка\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* Вставка элемента в середину */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        // При превышении вместимости по числу элементов запускается расширение\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // Обновить число элементов\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* Удаление элемента */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        let num = this.#arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // Обновить число элементов\n        this.#size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // Обновить вместимость списка\n        this.#capacity = this.#arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    toArray() {\n        let size = this.size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* Класс списка */\nclass MyList {\n    private arr: Array&lt;number&gt;; // Массив (для хранения элементов списка)\n    private _capacity: number = 10; // Вместимость списка\n    private _size: number = 0; // Длина списка (текущее число элементов)\n    private extendRatio: number = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public size(): number {\n        return this._size;\n    }\n\n    /* Получить вместимость списка */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* Доступ к элементу */\n    public get(index: number): number {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        return this.arr[index];\n    }\n\n    /* Обновление элемента */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        this.arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public add(num: number): void {\n        // Если длина равна вместимости, требуется расширение\n        if (this._size === this._capacity) this.extendCapacity();\n        // Добавить новый элемент в конец списка\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* Вставка элемента в середину */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        // При превышении вместимости по числу элементов запускается расширение\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // Обновить число элементов\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* Удаление элемента */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        let num = this.arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // Обновить число элементов\n        this._size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public extendCapacity(): void {\n        // Создать новый массив длиной size и скопировать в него исходный массив\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // Обновить вместимость списка\n        this._capacity = this.arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    public toArray(): number[] {\n        let size = this.size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* Класс списка */\nclass MyList {\n  late List&lt;int&gt; _arr; // Массив (для хранения элементов списка)\n  int _capacity = 10; // Вместимость списка\n  int _size = 0; // Длина списка (текущее число элементов)\n  int _extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n  /* Конструктор */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* Получить длину списка (текущее число элементов) */\n  int size() =&gt; _size;\n\n  /* Получить вместимость списка */\n  int capacity() =&gt; _capacity;\n\n  /* Доступ к элементу */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    return _arr[index];\n  }\n\n  /* Обновление элемента */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    _arr[index] = _num;\n  }\n\n  /* Добавление элемента в конец */\n  void add(int _num) {\n    // При превышении вместимости по числу элементов запускается расширение\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // Обновить число элементов\n    _size++;\n  }\n\n  /* Вставка элемента в середину */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    // При превышении вместимости по числу элементов запускается расширение\n    if (_size == _capacity) extendCapacity();\n    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // Обновить число элементов\n    _size++;\n  }\n\n  /* Удаление элемента */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    int _num = _arr[index];\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // Обновить число элементов\n    _size--;\n    // Вернуть удаленный элемент\n    return _num;\n  }\n\n  /* Расширение списка */\n  void extendCapacity() {\n    // Создать новый массив длиной в _extendRatio раз больше исходного массива\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // Скопировать исходный массив в новый массив\n    List.copyRange(_newNums, 0, _arr);\n    // Обновить ссылку на _arr\n    _arr = _newNums;\n    // Обновить вместимость списка\n    _capacity = _arr.length;\n  }\n\n  /* Преобразовать список в массив */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* Класс списка */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // Массив (для хранения элементов списка)\n    capacity: usize,     // Вместимость списка\n    size: usize,         // Длина списка (текущее число элементов)\n    extend_ratio: usize, // Коэффициент увеличения списка при каждом расширении\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* Конструктор */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* Получить вместимость списка */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* Доступ к элементу */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if index &gt;= self.size {\n            panic!(\"индекс выходит за границы\")\n        };\n        return self.arr[index];\n    }\n\n    /* Обновление элемента */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"индекс выходит за границы\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    pub fn add(&amp;mut self, num: i32) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // Обновить число элементов\n        self.size += 1;\n    }\n\n    /* Вставка элемента в середину */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"индекс выходит за границы\")\n        };\n        // При превышении вместимости по числу элементов запускается расширение\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // Обновить число элементов\n        self.size += 1;\n    }\n\n    /* Удаление элемента */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"индекс выходит за границы\")\n        };\n        let num = self.arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // Обновить число элементов\n        self.size -= 1;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    pub fn extend_capacity(&amp;mut self) {\n        // Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // Обновить вместимость списка\n        self.capacity = new_capacity;\n    }\n\n    /* Преобразовать список в массив */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* Класс списка */\ntypedef struct {\n    int *arr;        // Массив (для хранения элементов списка)\n    int capacity;    // Вместимость списка\n    int size;        // Размер списка\n    int extendRatio; // Коэффициент расширения списка при каждом увеличении\n} MyList;\n\n/* Конструктор */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* Деструктор */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* Получить длину списка */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* Получить вместимость списка */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* Доступ к элементу */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* Обновление элемента */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* Добавление элемента в конец */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Расширение емкости\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* Вставка элемента в середину */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // При превышении вместимости по числу элементов запускается расширение\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Расширение емкости\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* Удаление элемента */\n// Внимание: stdio.h уже использует ключевое слово remove\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* Расширение списка */\nvoid extendCapacity(MyList *nums) {\n    // Сначала выделить память\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // Скопировать старые данные в новые\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // Освободить старые данные\n    free(temp);\n\n    // Обновить новые данные\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* Преобразовать список в Array для вывода */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* Класс списка */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // Массив (для хранения элементов списка)\n    private var capacity: Int = 10 // Вместимость списка\n    private var size: Int = 0 // Длина списка (текущее число элементов)\n    private var extendRatio: Int = 2 // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    fun size(): Int {\n        return size\n    }\n\n    /* Получить вместимость списка */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* Доступ к элементу */\n    fun get(index: Int): Int {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        return arr[index]\n    }\n\n    /* Обновление элемента */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        arr[index] = num\n    }\n\n    /* Добавление элемента в конец */\n    fun add(num: Int) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // Обновить число элементов\n        size++\n    }\n\n    /* Вставка элемента в середину */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity()\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // Обновить число элементов\n        size++\n    }\n\n    /* Удаление элемента */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        val num = arr[index]\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // Обновить число элементов\n        size--\n        // Вернуть удаленный элемент\n        return num\n    }\n\n    /* Расширение списка */\n    fun extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = arr.copyOf(capacity() * extendRatio)\n        // Обновить вместимость списка\n        capacity = arr.size\n    }\n\n    /* Преобразовать список в массив */\n    fun toArray(): IntArray {\n        val size = size()\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### Класс списка ###\nclass MyList\n  attr_reader :size       # Получить длину списка (текущее число элементов)\n  attr_reader :capacity   # Получить вместимость списка\n\n  ### Конструктор ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### Доступ к элементу ###\n  def get(index)\n    # Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### Доступ к элементу ###\n  def set(index, num)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### Добавление элемента в конец ###\n  def add(num)\n    # При превышении вместимости по числу элементов запускается расширение\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # Обновить число элементов\n    @size += 1\n  end\n\n  ### Вставка элемента в середину ###\n  def insert(index, num)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n\n    # При превышении вместимости по числу элементов запускается расширение\n    extend_capacity if size == capacity\n\n    # Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # Обновить число элементов\n    @size += 1\n  end\n\n  ### Удаление элемента ###\n  def remove(index)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # Сдвинуть все элементы после индекса index на одну позицию вперед\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # Обновить число элементов\n    @size -= 1\n\n    # Вернуть удаленный элемент\n    num\n  end\n\n  ### Расширение списка ###\n  def extend_capacity\n    # Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # Обновить вместимость списка\n    @capacity = arr.length\n  end\n\n  ### Преобразование списка в массив ###\n  def to_array\n    sz = size\n    # Преобразовывать только элементы списка в пределах фактической длины\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массив и связный список","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   Оперативная память и кэш *","text":"<p>В первых двух разделах этой главы мы разобрали массивы и связные списки - две базовые и важные структуры данных, которые представляют соответственно непрерывное хранение и разрозненное хранение.</p> <p>На практике физическая структура во многом определяет, насколько эффективно программа использует память и кэш, а это, в свою очередь, влияет на общую производительность алгоритма.</p>","path":["Глава 4. Массив и связный список","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   Устройства хранения данных в компьютере","text":"<p>В компьютере есть три типа устройств хранения данных: жесткий диск (hard disk) , оперативная память (random-access memory, RAM) и кэш-память (cache memory) . В таблице 4-2 показаны их различные роли и характеристики в компьютерной системе.</p> <p> Таблица 4-2   Устройства хранения данных в компьютере </p> Жесткий диск Оперативная память Кэш Назначение Долговременное хранение данных, включая ОС, программы, файлы и т.д. Временное хранение выполняемых программ и обрабатываемых данных Хранение часто используемых данных и инструкций, уменьшающее число обращений CPU к памяти Энергозависимость Данные не теряются после отключения питания Данные теряются после отключения питания Данные теряются после отключения питания Емкость Большая, уровень TB Меньшая, уровень GB Очень малая, уровень MB Скорость Низкая, от сотен до тысяч MB/s Высокая, десятки GB/s Очень высокая, десятки и сотни GB/s Цена Низкая, единицы валюты за GB Высокая, десятки и сотни валютных единиц за GB Очень высокая, входит в стоимость CPU <p>Компьютерную систему хранения можно представить в виде пирамиды, показанной на рисунке 4-9. Чем ближе устройство хранения к вершине пирамиды, тем оно быстрее, тем меньше его емкость и тем выше его стоимость. Такая многоуровневая конструкция возникла не случайно, а стала результатом тщательных инженерных компромиссов.</p> <ul> <li>Жесткий диск трудно заменить оперативной памятью. Во-первых, данные в оперативной памяти исчезают после отключения питания, поэтому она не подходит для долговременного хранения. Во-вторых, память стоит в разы дороже жесткого диска, что мешает ее широкому применению.</li> <li>Кэш не может одновременно быть и очень большим, и очень быстрым. По мере роста емкости кэшей L1, L2 и L3 их физический размер увеличивается, расстояние до ядра CPU становится больше, время передачи данных растет, а задержка доступа к элементам увеличивается. При текущем уровне технологий многоуровневая структура кэша является лучшим балансом между емкостью, скоростью и стоимостью.</li> </ul> <p></p> <p> Рисунок 4-9   Система хранения данных компьютера </p> <p>Tip</p> <p>Иерархия памяти компьютера отражает тонкий баланс между скоростью, емкостью и стоимостью. Подобные компромиссы встречаются почти во всех областях инженерии: приходится искать оптимальный баланс между преимуществами и ограничениями.</p> <p>В итоге жесткий диск используется для долговременного хранения больших объемов данных, оперативная память - для временного хранения данных, с которыми программа работает прямо сейчас, а кэш - для хранения часто используемых данных и инструкций, чтобы ускорять выполнение программ. Все три уровня работают совместно и обеспечивают эффективную работу компьютерной системы.</p> <p>Как показано на рисунке 4-10, во время выполнения программы данные читаются с жесткого диска в оперативную память, а затем используются CPU в вычислениях. Кэш можно рассматривать как часть CPU: он подгружает данные из оперативной памяти, обеспечивая CPU высокоскоростной доступ и тем самым значительно ускоряя выполнение программы и уменьшая зависимость от более медленной RAM.</p> <p></p> <p> Рисунок 4-10   Поток данных между жестким диском, RAM и кэшем </p>","path":["Глава 4. Массив и связный список","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   Эффективность использования памяти структурами данных","text":"<p>С точки зрения использования пространства памяти массивы и связные списки имеют свои преимущества и ограничения.</p> <p>С одной стороны, память ограничена, и один и тот же участок памяти не может совместно использоваться несколькими программами, поэтому нам хочется, чтобы структуры данных использовали пространство как можно эффективнее. Элементы массива расположены плотно и не требуют дополнительного места для хранения ссылок (указателей) между узлами списка, поэтому массивы эффективнее по памяти. Однако массиву нужно сразу выделить достаточно большой непрерывный участок памяти, что может приводить к потерям пространства, а его расширение требует дополнительных затрат времени и памяти. Напротив, связные списки выделяют и освобождают память на уровне узлов, что дает большую гибкость.</p> <p>С другой стороны, во время выполнения программы при многократном выделении и освобождении памяти фрагментация свободной памяти становится все более серьезной, что снижает эффективность ее использования. Массивы из-за непрерывного хранения относительно менее подвержены фрагментации. Напротив, элементы связного списка распределены по памяти, и частые операции вставки и удаления легче приводят к фрагментации.</p>","path":["Глава 4. Массив и связный список","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   Эффективность использования кэша структурами данных","text":"<p>Хотя по объему кэш намного меньше оперативной памяти, он значительно быстрее и играет критически важную роль в скорости выполнения программ. Поскольку объем кэша ограничен и в нем можно хранить только небольшую долю часто используемых данных, когда CPU пытается обратиться к данным, которых в кэше нет, происходит промах кэша (cache miss) , и CPU вынужден загружать нужные данные из более медленной памяти.</p> <p>Очевидно, что чем меньше промахов кэша, тем выше эффективность чтения и записи данных CPU, а значит, тем лучше производительность программы. Долю обращений, при которых CPU успешно получает данные из кэша, называют коэффициентом попадания в кэш (cache hit rate) ; этот показатель обычно используют для оценки эффективности кэша.</p> <p>Чтобы добиться как можно большей эффективности, кэш использует следующие механизмы загрузки данных.</p> <ul> <li>Строки кэша: кэш хранит и загружает данные не по одному байту, а строками кэша. По сравнению с передачей по байтам это гораздо эффективнее.</li> <li>Механизм предвыборки: процессор старается предсказать шаблон доступа к данным (например последовательный доступ, доступ с фиксированным шагом и т.д.) и на основе этого шаблона заранее загружает данные в кэш, повышая вероятность попадания.</li> <li>Пространственная локальность: если к некоторым данным уже обратились, то велика вероятность, что в ближайшее время понадобятся и соседние данные. Поэтому, загружая некоторые данные, кэш часто подгружает и окружающие их данные.</li> <li>Временная локальность: если к данным уже обратились, то высока вероятность, что к ним снова обратятся в ближайшем будущем. Кэш использует это свойство, сохраняя недавно использованные данные.</li> </ul> <p>На практике массивы и связные списки по-разному используют кэш, и это проявляется в нескольких аспектах.</p> <ul> <li>Занимаемое пространство: элементы связного списка занимают больше места, чем элементы массива, поэтому в кэше помещается меньше полезных данных.</li> <li>Строки кэша: данные списка разбросаны по памяти, а кэш загружает данные строками, поэтому доля бесполезно загружаемых данных оказывается выше.</li> <li>Механизм предвыборки: шаблон доступа к данным у массивов более предсказуем, чем у списков, то есть системе легче угадать, какие данные понадобятся следующими.</li> <li>Пространственная локальность: массив хранится в компактной области памяти, поэтому данные рядом с уже загруженными с большей вероятностью скоро будут использованы.</li> </ul> <p>В целом массивы имеют более высокий коэффициент попадания в кэш, поэтому по эффективности операций они обычно превосходят связные списки. Именно поэтому при решении алгоритмических задач структуры данных на основе массивов часто оказываются предпочтительнее.</p> <p>Важно понимать, что высокая эффективность кэша не означает, что массивы во всех случаях лучше связных списков. В реальных приложениях выбор структуры данных должен определяться конкретными требованиями. Например, и массивы, и списки могут использоваться для реализации \"стека\" (подробнее об этом будет рассказано в следующей главе), но подходят они для разных сценариев.</p> <ul> <li>При решении алгоритмических задач мы обычно предпочитаем стек на основе массива, потому что он дает более высокую эффективность операций и поддерживает произвольный доступ, а цена за это - необходимость заранее выделить некоторый объем памяти под массив.</li> <li>Если объем данных очень велик, структура сильно динамична, а ожидаемый размер стека трудно оценить заранее, то более уместен стек на основе связного списка. Список позволяет распределить большой объем данных по разным участкам памяти и избегает накладных расходов, связанных с расширением массива.</li> </ul>","path":["Глава 4. Массив и связный список","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   Резюме","text":"","path":["Глава 4. Массив и связный список","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Массивы и связные списки - это две базовые структуры данных, представляющие два способа хранения данных в памяти компьютера: хранение в непрерывном пространстве и хранение в разрозненном пространстве. Их свойства во многом взаимно дополняют друг друга.</li> <li>Массив поддерживает произвольный доступ и занимает меньше памяти; однако вставка и удаление элементов в нем неэффективны, а длина после инициализации фиксирована.</li> <li>Связный список позволяет эффективно вставлять и удалять узлы путем изменения ссылок (указателей), а также гибко менять длину; однако доступ к узлам менее эффективен, а памяти он занимает больше. Распространенные типы списков включают односвязные, циклические и двусвязные списки.</li> <li>Список - это упорядоченная коллекция элементов, поддерживающая добавление, удаление, поиск и изменение, и обычно реализуемая на основе динамического массива. Он сохраняет преимущества массива и при этом может гибко менять длину.</li> <li>Появление списка значительно повысило практическую ценность массива, хотя это и может приводить к потере части памяти.</li> <li>Во время работы программы данные в основном хранятся в оперативной памяти. Массив обеспечивает более высокую эффективность использования пространства памяти, а связный список дает большую гибкость в использовании памяти.</li> <li>Кэш, используя строки кэша, механизм предвыборки, а также пространственную и временную локальность, предоставляет CPU быстрый доступ к данным и заметно повышает эффективность выполнения программ.</li> <li>Поскольку массивы обычно имеют более высокий коэффициент попадания в кэш, они в большинстве случаев работают эффективнее списков. При выборе структуры данных нужно исходить из конкретных требований и сценариев.</li> </ul>","path":["Глава 4. Массив и связный список","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Влияет ли хранение массива в стеке или в куче на временную и пространственную эффективность?</p> <p>Массивы, расположенные и в стеке, и в куче, все равно хранятся в непрерывной области памяти, поэтому эффективность операций с данными у них в целом одинакова. Однако у стека и кучи есть собственные особенности, из-за которых возникают следующие различия.</p> <ol> <li>Эффективность выделения и освобождения: стек представляет собой относительно небольшой участок памяти, а выделение в нем обычно выполняется автоматически компилятором; куча же обычно больше, может выделяться динамически из кода и легче фрагментируется. Поэтому выделение и освобождение памяти в куче обычно медленнее, чем в стеке.</li> <li>Ограничение размера: объем стека относительно невелик, а размер кучи обычно ограничивается доступной памятью. Поэтому куча лучше подходит для хранения больших массивов.</li> <li>Гибкость: размер массива в стеке должен быть известен во время компиляции, а размер массива в куче может определяться динамически во время выполнения.</li> </ol> <p>Q: Почему для массива требуется, чтобы все элементы были одного типа, а для связного списка это не подчеркивается?</p> <p>Связный список состоит из узлов, а узлы соединяются между собой через ссылки (указатели), поэтому каждый узел в принципе может хранить данные разного типа, например <code>int</code> , <code>double</code> , <code>string</code> , <code>object</code> и т.д.</p> <p>Напротив, элементы массива должны быть одного типа, иначе нельзя будет вычислять адрес элемента через смещение. Например, если массив одновременно содержит <code>int</code> и <code>long</code> , один элемент занимает 4 байта, а другой - 8 байт ; в этом случае формула ниже уже не позволит вычислить смещение, потому что в массиве будут присутствовать элементы разной длины.</p> <pre><code># Адрес элемента в памяти = адрес массива в памяти (адрес первого элемента) + длина элемента * индекс элемента\n</code></pre> <p>Q: После удаления узла <code>P</code> нужно ли присваивать <code>P.next = None</code> ?</p> <p>Можно и не изменять <code>P.next</code> . С точки зрения данного списка, при обходе от головы к хвосту узел <code>P</code> уже больше не встретится. Это означает, что узел <code>P</code> уже удален из списка, и то, куда он указывает после этого, на сам список больше не влияет.</p> <p>С точки зрения задач по структурам данных и алгоритмам, отсутствие такого разрыва обычно не критично, если логика программы остается корректной. Но с точки зрения стандартной библиотеки разорвать связь безопаснее и логичнее. Если этого не сделать и удаленный узел не будет нормально собран, он может мешать освобождению памяти последующих узлов.</p> <p>Q: Временная сложность вставки и удаления в связном списке равна \\(O(1)\\) . Но до вставки или удаления обычно еще нужно потратить \\(O(n)\\) на поиск элемента. Почему тогда общая сложность не \\(O(n)\\) ?</p> <p>Если сначала искать элемент, а потом удалять его, то временная сложность действительно будет \\(O(n)\\) . Однако преимущество связного списка с \\(O(1)\\) вставкой и удалением проявляется в других сценариях. Например, двустороннюю очередь удобно реализовывать именно на связном списке: мы поддерживаем указатели на голову и хвост, и тогда каждая операция вставки или удаления остается \\(O(1)\\) .</p> <p>Q: На рисунке \"Определение связного списка и способ хранения\" светло-голубой блок с указателем узла - это отдельный адрес памяти? Или он делит память пополам со значением узла?</p> <p>Этот рисунок дает только качественное представление; количественно все зависит от конкретных условий.</p> <ul> <li>Значения узлов разных типов занимают разный объем памяти, например <code>int</code> , <code>long</code> , <code>double</code> и объекты-экземпляры.</li> <li>Размер памяти, занимаемой переменной-указателем, зависит от операционной системы и среды компиляции и обычно составляет 8 байт или 4 байта.</li> </ul> <p>Q: Всегда ли добавление элемента в конец списка имеет сложность \\(O(1)\\) ?</p> <p>Если при добавлении элемента длина списка превышается, то сначала приходится расширять список, а уже затем добавлять новый элемент. Система выделяет новый участок памяти и переносит туда все элементы исходного списка, и в этот момент временная сложность становится \\(O(n)\\) .</p> <p>Q: В утверждении \"появление списка сильно повысило практическую полезность массива, но может приводить к потере части памяти\" под потерями памяти имеется в виду дополнительная память под такие переменные, как емкость, длина и коэффициент расширения?</p> <p>Потери памяти здесь в основном имеют два значения: во-первых, список обычно имеет некоторую начальную емкость, которая может быть нам не нужна целиком; во-вторых, чтобы избежать слишком частых расширений, емкость при расширении обычно умножается на некоторый коэффициент, например \\(\\times 1.5\\) . Из-за этого появляется много пустых слотов, которые обычно нельзя полностью заполнить.</p> <p>Q: В Python после инициализации <code>n = [1, 2, 3]</code> адреса этих трех элементов выглядят непрерывными, но после <code>m = [2, 1, 3]</code> можно заметить, что <code>id</code> элементов не идут подряд, а совпадают с одинаковыми числами из <code>n</code> . Если адреса элементов не непрерывны, остается ли <code>m</code> массивом?</p> <p>Предположим, что элементами списка являются узлы <code>n = [n1, n2, n3, n4, n5]</code> . Обычно эти 5 объектов-узлов тоже будут храниться в разных местах памяти. Однако, имея индекс списка, мы по-прежнему можем за \\(O(1)\\) получить адрес памяти соответствующего узла и обратиться к нему. Это связано с тем, что в массиве хранятся ссылки на узлы, а не сами узлы.</p> <p>В отличие от многих других языков, в Python даже числа обернуты в объекты, и в списке хранятся не сами числа, а ссылки на них. Поэтому мы и наблюдаем, что одинаковые числа в двух массивах имеют один и тот же <code>id</code> , а адреса этих чисел не обязаны быть непрерывными.</p> <p>Q: В C++ STL уже есть двусвязный список <code>std::list</code> , но в некоторых учебниках по алгоритмам им пользуются не так часто. Это связано с какими-то ограничениями?</p> <p>С одной стороны, при разработке алгоритмов мы обычно предпочитаем структуры на основе массива, а к связным спискам прибегаем только при необходимости, по двум главным причинам.</p> <ul> <li>Накладные расходы по памяти: поскольку каждому элементу нужны два дополнительных указателя (на предыдущий и следующий элементы), <code>std::list</code> обычно занимает больше памяти, чем <code>std::vector</code> .</li> <li>Низкая дружелюбность к кэшу: поскольку данные не лежат непрерывно, <code>std::list</code> хуже использует кэш. В большинстве случаев <code>std::vector</code> показывает лучшую производительность.</li> </ul> <p>С другой стороны, случаи, когда связный список действительно необходим, в основном возникают в деревьях и графах. Для стеков и очередей чаще используют предоставляемые языком <code>stack</code> и <code>queue</code> , а не связный список напрямую.</p> <p>Q: Операция <code>res = [[0]] * n</code> создает двумерный список. Каждый <code>[0]</code> в нем независим?</p> <p>Нет, они не независимы. В таком двумерном списке все <code>[0]</code> на самом деле являются ссылками на один и тот же объект. Если изменить один из них, окажется, что меняются и все остальные соответствующие элементы.</p> <p>Если нужно, чтобы каждый <code>[0]</code> был независимым, можно использовать <code>res = [[0] for _ in range(n)]</code> . В этом варианте создаются \\(n\\) независимых объектов-списков <code>[0]</code> .</p> <p>Q: Операция <code>res = [0] * n</code> создает список. Каждый целочисленный <code>0</code> в нем независим?</p> <p>В этом списке все целые числа <code>0</code> являются ссылками на один и тот же объект. Это связано с тем, что Python использует механизм кэш-пула для маленьких целых чисел (обычно от -5 до 256), чтобы максимально переиспользовать объекты и повысить производительность.</p> <p>Хотя все элементы указывают на один и тот же объект, мы все равно можем независимо изменять элементы списка, потому что целые числа в Python - это \"неизменяемые объекты\". Когда мы изменяем некоторый элемент, на самом деле происходит переключение ссылки на другой объект, а не изменение исходного объекта.</p> <p>Однако если элементами списка являются \"изменяемые объекты\" (например списки, словари или экземпляры классов), то изменение одного элемента прямо меняет сам объект, и все элементы, ссылающиеся на него, увидят одно и то же изменение.</p>","path":["Глава 4. Массив и связный список","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"Глава 13.   Поиск с возвратом","text":"<p>Abstract</p> <p>Мы словно исследователи в лабиринте: на пути вперед могут встречаться тупики и трудности.</p> <p>Сила возврата позволяет нам начать заново, пробовать снова и снова и в конце концов найти выход к свету.</p>","path":["Глава 13. Поиск с возвратом","Глава 13. &nbsp; Поиск с возвратом"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>13.1   Алгоритм поиска с возвратом</li> <li>13.2   Задача о перестановках</li> <li>13.3   Задача о сумме подмножеств</li> <li>13.4   Задача о \\(n\\) ферзях</li> <li>13.5   Резюме</li> </ul>","path":["Глава 13. Поиск с возвратом","Глава 13. &nbsp; Поиск с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   Алгоритм поиска с возвратом","text":"<p>Алгоритм поиска с возвратом (backtracking algorithm) - это метод решения задач путем полного перебора. Его основная идея состоит в том, чтобы, начиная с некоторого исходного состояния, грубо перебрать все возможные решения, записывать корректные решения и продолжать поиск до тех пор, пока решение не будет найдено или пока не будут исчерпаны все возможные варианты.</p> <p>Обычно алгоритмы поиска с возвратом используют обход в глубину для обхода пространства решений. В главе \"Бинарные деревья\" мы уже упоминали, что прямой, симметричный и обратный обходы относятся к обходу в глубину. Теперь мы на основе прямого обхода построим задачу поиска с возвратом и постепенно разберем принцип работы этого алгоритма.</p> <p>Пример 1</p> <p>Дано двоичное дерево. Найдите и запишите все узлы со значением \\(7\\) ; верните список этих узлов.</p> <p>Для этой задачи мы выполняем прямой обход дерева и проверяем, равно ли значение текущего узла \\(7\\) ; если да, то добавляем значение этого узла в список результатов <code>res</code> . Соответствующий процесс показан на рисунке 13-1 и в коде:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # Записать решение\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Записать решение\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* Предварительный обход: пример 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* Предварительный обход: пример 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // Записать решение\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* Предварительный обход: пример 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // Записать решение\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* Предварительный обход: пример 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Записать решение\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* Предварительный обход: пример 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Записать решение\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // Записать решение\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* Предварительный обход: пример 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* Предварительный обход: пример 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### Предварительный обход: пример 1 ###\ndef pre_order(root)\n  return unless root\n\n  # Записать решение\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 13-1   Поиск узлов при прямом обходе </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   Попытка и откат","text":"<p>Алгоритм называется поиском с возвратом, потому что при поиске в пространстве решений он использует стратегию \"попытка\" и \"откат\". Когда в процессе поиска алгоритм приходит в состояние, из которого нельзя двигаться дальше или нельзя получить удовлетворяющее условиям решение, он отменяет предыдущий выбор, возвращается к более раннему состоянию и пробует другие возможные варианты.</p> <p>Для примера 1 посещение каждого узла представляет собой \"попытку\", а прохождение листового узла или возврат к родителю через <code>return</code> означает \"откат\".</p> <p>Важно понимать, что откат не сводится только к возврату из функции. Чтобы показать это, слегка расширим пример 1.</p> <p>Пример 2</p> <p>Найдите в двоичном дереве все узлы со значением \\(7\\) и верните пути от корня до этих узлов.</p> <p>Взяв за основу код примера 1, добавим список <code>path</code> для записи пути посещенных узлов. Когда встречается узел со значением \\(7\\) , мы копируем <code>path</code> и добавляем его в список результатов <code>res</code> . После завершения обхода именно <code>res</code> будет содержать все решения. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 2\"\"\"\n    if root is None:\n        return\n    # Попытка\n    path.append(root)\n    if root.val == 7:\n        # Записать решение\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Откат\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // Попытка\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // Попытка\n    path.add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Откат\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* Предварительный обход: пример 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // Попытка\n    path.Add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Откат\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* Предварительный обход: пример 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // Попытка\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Записать решение\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // Откат\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* Предварительный обход: пример 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Попытка\n    path.append(root)\n    if root.val == 7 {\n        // Записать решение\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Откат\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* Предварительный обход: пример 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* Предварительный обход: пример 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // Попытка\n  path.add(root);\n  if (root.val == 7) {\n    // Записать решение\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Откат\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* Предварительный обход: пример 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // Попытка\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Откат\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // Попытка\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Записать решение\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* Предварительный обход: пример 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // Попытка\n    path!!.add(root)\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Откат\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### Предварительный обход: пример 2 ###\ndef pre_order(root)\n  return unless root\n\n  # Попытка\n  $path &lt;&lt; root\n\n  # Записать решение\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Откат\n  $path.pop\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В каждой \"попытке\" мы добавляем текущий узел в <code>path</code> , чтобы записать путь; а перед \"откатом\" нам нужно удалить этот узел из <code>path</code> , чтобы восстановить состояние, существовавшее до текущей попытки.</p> <p>Если посмотреть на процесс, изображенный на рисунке 13-2, то попытку и откат можно понимать как \"движение вперед\" и \"отмену\": это два взаимно противоположных действия.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 13-2   Попытка и откат </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   Обрезка","text":"<p>Сложные задачи поиска с возвратом обычно содержат одно или несколько ограничений, которые часто можно использовать для \"обрезки\".</p> <p>Пример 3</p> <p>Найдите в двоичном дереве все узлы со значением \\(7\\) , верните пути от корня до этих узлов, причем путь не должен содержать узлы со значением \\(3\\).</p> <p>Чтобы выполнить это ограничение, нам нужно добавить операцию обрезки: во время поиска, если встречается узел со значением \\(3\\) , мы сразу возвращаемся и не продолжаем дальнейший поиск. Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 3\"\"\"\n    # Отсечение\n    if root is None or root.val == 3:\n        return\n    # Попытка\n    path.append(root)\n    if root.val == 7:\n        # Записать решение\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Откат\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode *root) {\n    // Отсечение\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // Попытка\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode root) {\n    // Отсечение\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Попытка\n    path.add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Откат\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* Предварительный обход: пример 3 */\nvoid PreOrder(TreeNode? root) {\n    // Отсечение\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Попытка\n    path.Add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Откат\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* Предварительный обход: пример 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // Отсечение\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // Попытка\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Записать решение\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // Откат\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* Предварительный обход: пример 3 */\nfunc preOrder(root: TreeNode?) {\n    // Отсечение\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // Попытка\n    path.append(root)\n    if root.val == 7 {\n        // Записать решение\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Откат\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* Предварительный обход: пример 3 */\nfunction preOrder(root, path, res) {\n    // Отсечение\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* Предварительный обход: пример 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Отсечение\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // Попытка\n  path.add(root);\n  if (root.val == 7) {\n    // Записать решение\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Откат\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* Предварительный обход: пример 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // Отсечение\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // Попытка\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Откат\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode *root) {\n    // Отсечение\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // Попытка\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Записать решение\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* Предварительный обход: пример 3 */\nfun preOrder(root: TreeNode?) {\n    // Отсечение\n    if (root == null || root._val == 3) {\n        return\n    }\n    // Попытка\n    path!!.add(root)\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Откат\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### Предварительный обход: пример 3 ###\ndef pre_order(root)\n  # Отсечение\n  return if !root || root.val == 3\n\n  # Попытка\n  $path.append(root)\n\n  # Записать решение\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Откат\n  $path.pop\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Термин \"обрезка\" очень нагляден. Как показано на рисунке 13-3, во время поиска мы отсекаем ветви, не удовлетворяющие ограничениям , тем самым избегая множества бессмысленных попыток и повышая эффективность поиска.</p> <p></p> <p> Рисунок 13-3   Обрезка по условиям задачи </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   Каркас кода","text":"<p>Теперь попробуем извлечь общий каркас из действий \"попытка\", \"откат\" и \"обрезка\", чтобы сделать код более универсальным.</p> <p>В следующем каркасе кода <code>state</code> обозначает текущее состояние задачи, а <code>choices</code> - список выборов, доступных в текущем состоянии:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"Каркас алгоритма поиска с возвратом\"\"\"\n    # Проверка, является ли текущее состояние решением\n    if is_solution(state):\n        # Запись решения\n        record_solution(state, res)\n        # Дальше не продолжаем поиск\n        return\n    # Перебор всех возможных выборов\n    for choice in choices:\n        # Обрезка: проверка допустимости выбора\n        if is_valid(state, choice):\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (Choice choice : choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (Choice choice : choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Проверка, является ли текущее состояние решением\n    if (IsSolution(state)) {\n        // Запись решения\n        RecordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    foreach (Choice choice in choices) {\n        // Обрезка: проверка допустимости выбора\n        if (IsValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // Проверка, является ли текущее состояние решением\n    if isSolution(state) {\n        // Запись решения\n        recordSolution(state, res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for _, choice := range choices {\n        // Обрезка: проверка допустимости выбора\n        if isValid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // Проверка, является ли текущее состояние решением\n    if isSolution(state: state) {\n        // Запись решения\n        recordSolution(state: state, res: &amp;res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for choice in choices {\n        // Обрезка: проверка допустимости выбора\n        if isValid(state: state, choice: choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunction backtrack(state, choices, res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (let choice of choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (let choice of choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // Проверка, является ли текущее состояние решением\n  if (isSolution(state)) {\n    // Запись решения\n    recordSolution(state, res);\n    // Дальше не продолжаем поиск\n    return;\n  }\n  // Перебор всех возможных выборов\n  for (Choice choice in choices) {\n    // Обрезка: проверка допустимости выбора\n    if (isValid(state, choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // Проверка, является ли текущее состояние решением\n    if is_solution(state) {\n        // Запись решения\n        record_solution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for choice in choices {\n        // Обрезка: проверка допустимости выбора\n        if is_valid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res, numRes);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (int i = 0; i &lt; numChoices; i++) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, &amp;choices[i])) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for (choice in choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### Каркас алгоритма поиска с возвратом ###\ndef backtrack(state, choices, res)\n    # Проверка, является ли текущее состояние решением\n    if is_solution?(state)\n        # Запись решения\n        record_solution(state, res)\n        return\n    end\n\n    # Перебор всех возможных выборов\n    for choice in choices\n        # Обрезка: проверка допустимости выбора\n        if is_valid?(state, choice)\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>Теперь, опираясь на этот каркас, решим пример 3. Состояние <code>state</code> здесь - это путь обхода узлов, выбор <code>choices</code> - левый и правый потомки текущего узла, а результат <code>res</code> - список путей:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"Проверить, является ли текущее состояние решением\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"Записать решение\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"Проверить, допустим ли этот выбор в текущем состоянии\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Обновить состояние\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Восстановить состояние\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"Алгоритм бэктрекинга: пример 3\"\"\"\n    # Проверить, является ли текущее состояние решением\n    if is_solution(state):\n        # Записать решение\n        record_solution(state, res)\n    # Перебор всех вариантов выбора\n    for choice in choices:\n        # Отсечение: проверить допустимость выбора\n        if is_valid(state, choice):\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            # Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (TreeNode *choice : choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* Проверить, является ли текущее состояние решением */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (TreeNode choice : choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* Проверить, является ли текущее состояние решением */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* Записать решение */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* Восстановить состояние */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Проверить, является ли текущее состояние решением\n    if (IsSolution(state)) {\n        // Записать решение\n        RecordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    foreach (TreeNode choice in choices) {\n        // Отсечение: проверить допустимость выбора\n        if (IsValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            MakeChoice(state, choice);\n            // Перейти к следующему выбору\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* Проверить, является ли текущее состояние решением */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* Записать решение */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* Обновить состояние */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* Восстановить состояние */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // Проверить, является ли текущее состояние решением\n    if isSolution(state) {\n        // Записать решение\n        recordSolution(state, res)\n    }\n    // Перебор всех вариантов выбора\n    for _, choice := range *choices {\n        // Отсечение: проверить допустимость выбора\n        if isValid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            // Перейти к следующему выбору\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* Проверить, является ли текущее состояние решением */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* Записать решение */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* Обновить состояние */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* Восстановить состояние */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // Проверить, является ли текущее состояние решением\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // Перебор всех вариантов выбора\n    for choice in choices {\n        // Отсечение: проверить допустимость выбора\n        if isValid(state: state, choice: choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state: &amp;state, choice: choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* Проверить, является ли текущее состояние решением */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Записать решение */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Обновить состояние */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunction backtrack(state, choices, res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* Проверить, является ли текущее состояние решением */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Записать решение */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Обновить состояние */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // Проверить, является ли текущее состояние решением\n  if (isSolution(state)) {\n    // Записать решение\n    recordSolution(state, res);\n  }\n  // Перебор всех вариантов выбора\n  for (TreeNode? choice in choices) {\n    // Отсечение: проверить допустимость выбора\n    if (isValid(state, choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      makeChoice(state, choice);\n      // Перейти к следующему выбору\n      backtrack(state, [choice!.left, choice.right], res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* Проверить, является ли текущее состояние решением */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* Записать решение */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* Обновить состояние */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // Проверить, является ли текущее состояние решением\n    if is_solution(state) {\n        // Записать решение\n        record_solution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for &amp;choice in choices.iter() {\n        // Отсечение: проверить допустимость выбора\n        if is_valid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice.unwrap().clone());\n            // Перейти к следующему выбору\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* Восстановить состояние */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution()) {\n        // Записать решение\n        recordSolution();\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // Отсечение: проверить допустимость выбора\n        if (isValid(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(choice);\n            // Перейти к следующему выбору\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* Проверить, является ли текущее состояние решением */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* Записать решение */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* Обновить состояние */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* Восстановить состояние */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res)\n    }\n    // Перебор всех вариантов выбора\n    for (choice in choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            // Перейти к следующему выбору\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### Проверка, является ли текущее состояние решением ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### Записать решение ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### Проверка допустимости этого выбора в текущем состоянии ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### Обновить состояние ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### Восстановить состояние ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### Алгоритм бэктрекинга: пример 3 ###\ndef backtrack(state, choices, res)\n  # Проверить, является ли текущее состояние решением\n  record_solution(state, res) if is_solution?(state)\n\n  # Перебор всех вариантов выбора\n  for choice in choices\n    # Отсечение: проверить допустимость выбора\n    if is_valid?(state, choice)\n      # Попытка: сделать выбор и обновить состояние\n      make_choice(state, choice)\n      # Перейти к следующему выбору\n      backtrack(state, [choice.left, choice.right], res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Согласно условию задачи, после нахождения узла со значением \\(7\\) мы должны продолжать поиск, поэтому оператор <code>return</code> после записи решения нужно удалить. На рисунке 13-4 сравниваются процессы поиска в случаях, когда <code>return</code> сохраняется и когда он удаляется.</p> <p></p> <p> Рисунок 13-4   Сравнение поиска при сохранении и удалении return </p> <p>По сравнению с реализацией на основе прямого обхода, версия на основе общего каркаса поиска с возвратом выглядит более громоздкой, но при этом обладает лучшей универсальностью. На практике многие задачи поиска с возвратом можно решать в рамках этого каркаса. Для этого нужно лишь определить <code>state</code> и <code>choices</code> под конкретную задачу и реализовать соответствующие методы каркаса.</p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   Часто используемые термины","text":"<p>Чтобы яснее анализировать алгоритмические задачи, подытожим значения часто используемых терминов поиска с возвратом и сопоставим их с примером 3, как показано в таблице 13-1.</p> <p> Таблица 13-1   Часто используемые термины алгоритма поиска с возвратом </p> Термин Определение Пример 3 Решение (solution) Решение - это ответ, удовлетворяющий условиям задачи; решений может быть одно или несколько Все пути от корня до узла \\(7\\) , удовлетворяющие ограничениям Ограничение (constraint) Ограничение определяет допустимость решения и обычно используется для обрезки Путь не содержит узлы со значением \\(3\\) Состояние (state) Состояние описывает ситуацию задачи в некоторый момент времени, включая уже сделанные выборы Текущий путь посещенных узлов, то есть список узлов <code>path</code> Попытка (attempt) Попытка - это исследование пространства решений на основе доступных выборов, включая выбор, обновление состояния и проверку, является ли состояние решением Рекурсивный переход к левому или правому потомку, добавление узла в <code>path</code> и проверка, равно ли значение узла \\(7\\) Откат (backtracking) Откат означает отмену предыдущих выборов и возврат к более раннему состоянию при встрече состояния, не удовлетворяющего ограничениям Завершение поиска при проходе через лист, окончании посещения узла или встрече узла со значением \\(3\\) , то есть возврат из функции Обрезка (pruning) Обрезка - это способ избегать бессмысленных путей поиска на основе свойств задачи и ее ограничений, повышающий эффективность При встрече узла со значением \\(3\\) поиск по этой ветви прекращается <p>Tip</p> <p>Такие понятия, как задача, решение и состояние, являются общими и встречаются не только в поиске с возвратом, но и в \"разделяй и властвуй\", динамическом программировании, жадных алгоритмах и других темах.</p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   Преимущества и ограничения","text":"<p>Алгоритм поиска с возвратом по своей сути представляет собой алгоритм обхода в глубину, который перебирает все возможные решения, пока не найдет удовлетворяющее условиям. Преимущество этого подхода в том, что он позволяет находить все возможные решения и при разумной обрезке может работать весьма эффективно.</p> <p>Однако при работе с большими или сложными задачами эффективность поиска с возвратом может оказаться неприемлемой.</p> <ul> <li>Время: поиск с возвратом обычно требует обхода всех возможных состояний пространства состояний, и его временная сложность может достигать экспоненциального или факториального порядка.</li> <li>Память: при рекурсивных вызовах нужно хранить текущее состояние (например, путь, вспомогательные переменные для обрезки и т.д.), поэтому при большой глубине рекурсии потребность в памяти может стать значительной.</li> </ul> <p>Тем не менее поиск с возвратом по-прежнему остается лучшим решением для некоторых поисковых задач и задач удовлетворения ограничений. В таких задачах заранее невозможно предсказать, какие выборы приведут к эффективному решению, поэтому приходится перебирать все возможные варианты. В этой ситуации ключевым становится вопрос оптимизации эффективности , и для этого обычно используют две стратегии.</p> <ul> <li>Обрезка: избегать поиска по тем путям, которые заведомо не приведут к решению, тем самым экономя время и память.</li> <li>Эвристический поиск: вводить во время поиска дополнительные стратегии или оценки, чтобы в первую очередь исследовать пути, наиболее вероятно ведущие к эффективному решению.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   Типичные задачи поиска с возвратом","text":"<p>Алгоритм поиска с возвратом можно использовать для решения множества поисковых задач, задач удовлетворения ограничений и задач комбинаторной оптимизации.</p> <p>Поисковые задачи: целью таких задач является поиск решений, удовлетворяющих определенным условиям.</p> <ul> <li>Задача о перестановках: дано множество, требуется найти все возможные перестановки его элементов.</li> <li>Задача о сумме подмножеств: даны множество и целевая сумма; нужно найти все подмножества, сумма элементов которых равна целевой.</li> <li>Задача о Ханойской башне: даны три стержня и набор дисков разного размера; требуется перенести все диски с одного стержня на другой, перемещая за раз только один диск и не помещая больший диск на меньший.</li> </ul> <p>Задачи удовлетворения ограничений: целью таких задач является поиск решений, удовлетворяющих всем ограничениям.</p> <ul> <li>Задача о \\(n\\) ферзях: разместить \\(n\\) ферзей на шахматной доске размера \\(n \\times n\\) так, чтобы они не атаковали друг друга.</li> <li>Судоку: заполнить сетку \\(9 \\times 9\\) числами от \\(1\\) до \\(9\\) так, чтобы в каждой строке, каждом столбце и каждом блоке \\(3 \\times 3\\) числа не повторялись.</li> <li>Задача раскраски графа: дан неориентированный граф; требуется раскрасить его вершины минимальным числом цветов так, чтобы соседние вершины имели разные цвета.</li> </ul> <p>Задачи комбинаторной оптимизации: целью таких задач является поиск оптимального решения в некотором комбинаторном пространстве при заданных ограничениях.</p> <ul> <li>Задача о рюкзаке 0-1: даны набор предметов и рюкзак; у каждого предмета есть ценность и вес, и нужно выбрать предметы так, чтобы при ограниченной вместимости рюкзака суммарная ценность была максимальной.</li> <li>Задача коммивояжера: начиная из некоторой вершины графа, требуется посетить все остальные вершины ровно по одному разу и вернуться в исходную вершину, найдя при этом кратчайший путь.</li> <li>Задача о максимальной клике: дан неориентированный граф; требуется найти в нем максимальный полный подграф, то есть подграф, в котором любая пара вершин соединена ребром.</li> </ul> <p>Стоит отметить: для многих задач комбинаторной оптимизации поиск с возвратом не является оптимальным способом решения.</p> <ul> <li>Задача о рюкзаке 0-1 обычно решается с помощью динамического программирования, что дает более высокую временную эффективность.</li> <li>Задача коммивояжера является известной NP-Hard задачей; для ее решения часто используют генетические алгоритмы, муравьиные алгоритмы и другие методы.</li> <li>Задача о максимальной клике является классической задачей теории графов и может решаться жадными и другими эвристическими алгоритмами.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   Задача о n ферзях","text":"<p>Question</p> <p>Согласно правилам шахмат ферзь может атаковать фигуры, находящиеся с ним на одной строке, в одном столбце или на одной диагонали. Даны \\(n\\) ферзей и шахматная доска размера \\(n \\times n\\) ; требуется найти такие расстановки, при которых ни одна пара ферзей не может атаковать друг друга.</p> <p>Как показано на рисунке 13-15, при \\(n = 4\\) существует два решения. С точки зрения поиска с возвратом доска размера \\(n \\times n\\) содержит \\(n^2\\) клеток, которые образуют все возможные выборы <code>choices</code> . По мере поочередного размещения ферзей состояние доски непрерывно меняется, и текущее содержимое доски образует состояние <code>state</code> .</p> <p></p> <p> Рисунок 13-15   Решения задачи о 4 ферзях </p> <p>На рисунке 13-16 показаны три ограничения этой задачи: несколько ферзей не могут находиться на одной строке, в одном столбце или на одной диагонали. При этом нужно помнить, что диагонали бывают двух типов: главная <code>\\</code> и побочная <code>/</code> .</p> <p></p> <p> Рисунок 13-16   Ограничения задачи о n ферзях </p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   Построчная стратегия размещения","text":"<p>Число ферзей и число строк доски одинаково и равно \\(n\\) , поэтому легко получить следующий вывод: в каждой строке доски разрешено и нужно разместить ровно одного ферзя.</p> <p>Иначе говоря, можно использовать построчную стратегию: начиная с первой строки, размещать по одному ферзю в каждой строке, пока не будет достигнута последняя.</p> <p>На рисунке 13-17 показан процесс построчного размещения для задачи о 4 ферзях. Из-за ограничений размера изображения на нем раскрыта только одна ветвь поиска для первой строки, а все варианты, не удовлетворяющие ограничениям по столбцам и диагоналям, были отсечены.</p> <p></p> <p> Рисунок 13-17   Построчная стратегия размещения </p> <p>По своей сути построчная стратегия сама по себе выполняет роль обрезки , потому что заранее исключает все ветви поиска, в которых в одной строке оказалось бы несколько ферзей.</p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   Обрезка по столбцам и диагоналям","text":"<p>Чтобы удовлетворить ограничению по столбцам, можно использовать булев массив <code>cols</code> длины \\(n\\) , который записывает, есть ли ферзь в каждом столбце. Перед каждым размещением мы используем <code>cols</code> для отсечения столбцов, уже занятых ферзями, а затем динамически обновляем состояние <code>cols</code> во время отката.</p> <p>Tip</p> <p>Обратите внимание: начало координат матрицы находится в левом верхнем углу, при этом индексы строк растут сверху вниз, а индексы столбцов - слева направо.</p> <p>Как теперь обработать ограничения по диагоналям? Пусть клетка на доске имеет координаты \\((row, col)\\) . Выбрав некоторую главную диагональ в матрице, можно заметить, что разность индексов строки и столбца одинакова для всех клеток этой диагонали, то есть для всех клеток главной диагонали значение \\(row - col\\) постоянно.</p> <p>Это означает, что если для двух клеток выполняется равенство \\(row_1 - col_1 = row_2 - col_2\\) , то они обязательно лежат на одной и той же главной диагонали. Используя это правило, можно с помощью массива <code>diags1</code> , показанного на рисунке 13-18, отмечать наличие ферзя на каждой главной диагонали.</p> <p>Аналогично для всех клеток побочной диагонали значение \\(row + col\\) является постоянным. Поэтому для обработки ограничений по побочным диагоналям можно использовать еще один массив <code>diags2</code> .</p> <p></p> <p> Рисунок 13-18   Обработка ограничений по столбцам и диагоналям </p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>Заметим, что в квадратной матрице размера \\(n\\) диапазон значений \\(row - col\\) равен \\([-n + 1, n - 1]\\) , а диапазон значений \\(row + col\\) равен \\([0, 2n - 2]\\) . Следовательно, число главных и побочных диагоналей равно \\(2n - 1\\) , а значит, длины массивов <code>diags1</code> и <code>diags2</code> тоже равны \\(2n - 1\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"Алгоритм бэктрекинга: n ферзей\"\"\"\n    # Когда все строки уже обработаны, записать решение\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # Обойти все столбцы\n    for col in range(n):\n        # Вычислить главную и побочную диагонали, соответствующие этой клетке\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"Решить задачу о n ферзях\"\"\"\n    # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # Отмечать, есть ли ферзь в столбце\n    diags1 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на главной диагонали\n    diags2 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на побочной диагонали\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // Отмечать, есть ли ферзь в столбце\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // Отмечать, есть ли ферзь в столбце\n    boolean[] diags1 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    boolean[] diags2 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // Отмечать, есть ли ферзь в столбце\n    bool[] diags1 = new bool[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    bool[] diags2 = new bool[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все столбцы\n    for col := 0; col &lt; n; col++ {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // Перейти к размещению следующей строки\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // Откат: восстановить эту клетку как пустую\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunc nQueens(n int) [][][]string {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // Отмечать, есть ли ферзь в столбце\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        res.append(state)\n        return\n    }\n    // Обойти все столбцы\n    for col in 0 ..&lt; n {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // Перейти к размещению следующей строки\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // Отмечать, есть ли ферзь в столбце\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на главной диагонали\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на побочной диагонали\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Обойти все столбцы\n    for (let col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunction nQueens(n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце\n    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали\n    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // Когда все строки уже обработаны, записать решение\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Обойти все столбцы\n    for (let col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunction nQueens(n: number): string[][][] {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце\n    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали\n    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // Когда все строки уже обработаны, записать решение\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // Обойти все столбцы\n  for (int col = 0; col &lt; n; col++) {\n    // Вычислить главную и побочную диагонали, соответствующие этой клетке\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // Попытка: поставить ферзя в эту клетку\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // Перейти к размещению следующей строки\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // Откат: восстановить эту клетку как пустую\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // Отмечать, есть ли ферзь в столбце\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все столбцы\n    for col in 0..n {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // Отмечать, есть ли ферзь в столбце\n    let mut diags1 = vec![false; 2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    let mut diags2 = vec![false; 2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // Отмечать, есть ли ферзь в столбце\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // Отмечать наличие ферзя на главной диагонали\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // Отмечать наличие ферзя на побочной диагонали\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // Обойти все столбцы\n    for (col in 0..&lt;n) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // Отмечать, есть ли ферзь в столбце\n    val diags1 = BooleanArray(2 * n - 1) // Отмечать наличие ферзя на главной диагонали\n    val diags2 = BooleanArray(2 * n - 1) // Отмечать наличие ферзя на побочной диагонали\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### Алгоритм бэктрекинга: n ферзей ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # Когда все строки уже обработаны, записать решение\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # Обойти все столбцы\n  for col in 0...n\n    # Вычислить главную и побочную диагонали, соответствующие этой клетке\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # Попытка: поставить ферзя в эту клетку\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # Перейти к размещению следующей строки\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # Откат: восстановить эту клетку как пустую\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Решить задачу о n ферзях ###\ndef n_queens(n)\n  # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # Отмечать, есть ли ферзь в столбце\n  diags1 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на главной диагонали\n  diags2 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на побочной диагонали\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если размещать ферзей построчно \\(n\\) раз, учитывая ограничение по столбцам, то начиная с первой строки и заканчивая последней мы получаем соответственно \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\) вариантов выбора, что дает \\(O(n!)\\) времени. При записи решения нужно скопировать матрицу <code>state</code> и добавить ее в <code>res</code> , а копирование требует \\(O(n^2)\\) времени. Следовательно, общая временная сложность равна \\(O(n! \\cdot n^2)\\) . На практике обрезка по диагональным ограничениям дополнительно сильно уменьшает пространство поиска, поэтому фактическая эффективность часто лучше этой оценки.</p> <p>Массив <code>state</code> использует \\(O(n^2)\\) пространства, а массивы <code>cols</code> , <code>diags1</code> и <code>diags2</code> используют по \\(O(n)\\) пространства. Максимальная глубина рекурсии равна \\(n\\) , что требует \\(O(n)\\) памяти стека. Следовательно, пространственная сложность равна \\(O(n^2)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   Задача о перестановках","text":"<p>Задача о перестановках является типичным применением алгоритма поиска с возвратом. Ее определение состоит в том, чтобы для данного множества элементов (например, массива или строки) найти все возможные перестановки этих элементов.</p> <p>В таблице 13-2 приведено несколько примеров входных массивов и соответствующих им перестановок.</p> <p> Таблица 13-2   Примеры перестановок </p> Входной массив Все перестановки \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   Случай без равных элементов","text":"<p>Question</p> <p>Дан массив целых чисел, в котором нет повторяющихся элементов. Верните все возможные перестановки.</p> <p>С точки зрения поиска с возвратом процесс построения перестановок можно представить как результат последовательности выборов. Пусть входной массив равен \\([1, 2, 3]\\) ; если мы сначала выберем \\(1\\) , затем \\(3\\) , а потом \\(2\\) , то получим перестановку \\([1, 3, 2]\\) . Откат здесь означает отмену одного из выборов с последующей попыткой других вариантов.</p> <p>С точки зрения кода поиска с возвратом множество кандидатов <code>choices</code> состоит из всех элементов входного массива, а состояние <code>state</code> - из элементов, уже выбранных к текущему моменту. Поскольку каждый элемент разрешено выбирать только один раз, все элементы в <code>state</code> должны быть уникальны.</p> <p>Как показано на рисунке 13-5, процесс поиска можно развернуть в дерево рекурсии, где каждый узел представляет текущее состояние <code>state</code> . Начиная от корня, после трех раундов выбора мы попадаем в листья, и каждый лист соответствует одной перестановке.</p> <p></p> <p> Рисунок 13-5   Дерево рекурсии для перестановок </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   Обрезка повторного выбора","text":"<p>Чтобы гарантировать, что каждый элемент выбирается только один раз, введем булев массив <code>selected</code> , где <code>selected[i]</code> обозначает, был ли уже выбран <code>choices[i]</code> , и на его основе выполним следующую обрезку.</p> <ul> <li>После того как сделан выбор <code>choice[i]</code> , мы присваиваем <code>selected[i]</code> значение \\(\\text{True}\\) , тем самым отмечая, что этот элемент уже выбран.</li> <li>При обходе списка вариантов <code>choices</code> пропускаем все уже выбранные элементы, то есть выполняем обрезку.</li> </ul> <p>Как показано на рисунке 13-6, если в первом раунде мы выберем 1 , во втором - 3 , а в третьем - 2 , то во втором раунде нужно отсечь ветвь элемента 1 , а в третьем - ветви элементов 1 и 3 .</p> <p></p> <p> Рисунок 13-6   Пример обрезки в задаче о перестановках </p> <p>Из рисунка видно, что такая обрезка уменьшает размер пространства поиска с \\(O(n^n)\\) до \\(O(n!)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   Реализация кода","text":"<p>После прояснения всей логики можно просто \"заполнить пропуски\" в шаблоне поиска с возвратом. Чтобы сократить общий объем кода, мы не будем отдельно реализовывать каждую функцию из каркаса, а раскроем их прямо внутри <code>backtrack()</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: все перестановки I\"\"\"\n    # Когда длина состояния равна числу элементов, записать решение\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    for i, choice in enumerate(choices):\n        # Отсечение: нельзя выбирать один и тот же элемент повторно\n        if not selected[i]:\n            # Попытка: сделать выбор и обновить состояние\n            selected[i] = True\n            state.append(choice)\n            # Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Все перестановки I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push_back(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Все перестановки I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.add(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.Add(choice);\n            // Перейти к следующему выбору\n            Backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Перебор всех вариантов выбора\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !(*selected)[i] {\n            // Попытка: сделать выбор и обновить состояние\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Перейти к следующему выбору\n            backtrackI(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Все перестановки I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i, choice) in choices.enumerated() {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !selected[i] {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true\n            state.append(choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Все перестановки I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunction backtrack(state, choices, selected, res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Когда длина состояния равна числу элементов, записать решение\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Отсечение: нельзя выбирать один и тот же элемент повторно\n    if (!selected[i]) {\n      // Попытка: сделать выбор и обновить состояние\n      selected[i] = true;\n      state.add(choice);\n      // Перейти к следующему выбору\n      backtrack(state, choices, selected, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !selected[i] {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state.clone(), choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Все перестановки I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // Состояние (подмножество)\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Перейти к следующему выбору\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n        }\n    }\n}\n\n/* Все перестановки I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true\n            state.add(choice)\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Все перестановки I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### Алгоритм бэктрекинга: все перестановки I ###\ndef backtrack(state, choices, selected, res)\n  # Когда длина состояния равна числу элементов, записать решение\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  choices.each_with_index do |choice, i|\n    # Отсечение: нельзя выбирать один и тот же элемент повторно\n    unless selected[i]\n      # Попытка: сделать выбор и обновить состояние\n      selected[i] = true\n      state &lt;&lt; choice\n      # Перейти к следующему выбору\n      backtrack(state, choices, selected, res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Все перестановки I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   Учет равных элементов","text":"<p>Question</p> <p>Дан массив целых чисел, который может содержать повторяющиеся элементы. Верните все неповторяющиеся перестановки.</p> <p>Пусть входной массив равен \\([1, 1, 2]\\) . Чтобы различать два одинаковых элемента \\(1\\) , будем обозначать второй из них как \\(\\hat{1}\\) .</p> <p>Как показано на рисунке 13-7, описанный выше метод создаст результат, половина которого окажется дублирующейся.</p> <p></p> <p> Рисунок 13-7   Повторяющиеся перестановки </p> <p>Как же убрать повторяющиеся перестановки? Самый прямолинейный способ - воспользоваться хеш-множеством и удалить дубликаты уже после генерации результата. Но это не слишком изящно, потому что ветви поиска, порождающие дубликаты, вообще не нужно посещать: их следует распознавать заранее и отсекать, что дополнительно повышает эффективность алгоритма.</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   Обрезка равных элементов","text":"<p>Посмотрите на рисунок 13-8: в первом раунде выбрать \\(1\\) или выбрать \\(\\hat{1}\\) - это одно и то же, а значит, все перестановки, полученные из этих двух выборов, будут дублироваться. Поэтому ветвь \\(\\hat{1}\\) нужно отсечь.</p> <p>Точно так же, если в первом раунде выбрать \\(2\\) , то во втором раунде выборы \\(1\\) и \\(\\hat{1}\\) снова создадут дублирующиеся ветви, поэтому и в этом случае ветвь \\(\\hat{1}\\) нужно отсечь.</p> <p>Иначе говоря, наша цель заключается в том, чтобы на каждом раунде выбора каждый из нескольких равных элементов выбирался только один раз.</p> <p></p> <p> Рисунок 13-8   Обрезка повторяющихся перестановок </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"<p>На основе решения из предыдущей задачи можно на каждом раунде выбора заводить хеш-множество <code>duplicated</code> , которое будет записывать элементы, уже встречавшиеся в этом раунде, и отсекать повторы:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: все перестановки II\"\"\"\n    # Когда длина состояния равна числу элементов, записать решение\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if not selected[i] and choice not in duplicated:\n            # Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice)  # Записать значения уже выбранных элементов\n            selected[i] = True\n            state.append(choice)\n            # Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Все перестановки II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.emplace(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push_back(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Все перестановки II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.add(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.Add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.Add(choice);\n            // Перейти к следующему выбору\n            Backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Перебор всех вариантов выбора\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // Попробовать: сделать выбор, обновить состояние\n            // Записать значение уже выбранного элемента\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Перейти к следующему выбору\n            backtrackII(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Все перестановки II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if !selected[i], !duplicated.contains(choice) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.insert(choice) // Записать значения уже выбранных элементов\n            selected[i] = true\n            state.append(choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Все перестановки II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunction backtrack(state, choices, selected, res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Когда длина состояния равна числу элементов, записать решение\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      duplicated.add(choice); // Записать значения уже выбранных элементов\n      selected[i] = true;\n      state.add(choice);\n      // Перейти к следующему выбору\n      backtrack(state, choices, selected, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.insert(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state.clone(), choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Все перестановки II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated[choice] = true; // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Перейти к следующему выбору\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n        }\n    }\n}\n\n/* Все перестановки II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice) // Записать значения уже выбранных элементов\n            selected[i] = true\n            state.add(choice)\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Все перестановки II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### Алгоритм бэктрекинга: все перестановки II ###\ndef backtrack(state, choices, selected, res)\n  # Когда длина состояния равна числу элементов, записать решение\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # Попытка: сделать выбор и обновить состояние\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # Перейти к следующему выбору\n      backtrack(state, choices, selected, res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Все перестановки II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если предположить, что все элементы попарно различны, то из \\(n\\) элементов можно получить \\(n!\\) перестановок; при записи результата требуется копировать список длины \\(n\\) , что занимает \\(O(n)\\) времени. Следовательно, временная сложность равна \\(O(n!n)\\) .</p> <p>Максимальная глубина рекурсии равна \\(n\\) , что требует \\(O(n)\\) стековой памяти. Массив <code>selected</code> занимает \\(O(n)\\) пространства. Одновременно может существовать до \\(n\\) хеш-множеств <code>duplicated</code> , что дает \\(O(n^2)\\) памяти. Следовательно, пространственная сложность равна \\(O(n^2)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3","level":3,"title":"3.   Сравнение двух видов обрезки","text":"<p>Обратите внимание: хотя и <code>selected</code> , и <code>duplicated</code> используются для обрезки, их цели различаются.</p> <ul> <li>Обрезка повторного выбора: во всем процессе поиска существует только один <code>selected</code> . Он записывает, какие элементы уже входят в текущее состояние, и нужен для того, чтобы один и тот же элемент не появлялся в <code>state</code> дважды.</li> <li>Обрезка равных элементов: каждый раунд выбора (каждый вызов <code>backtrack</code>) содержит собственный <code>duplicated</code> . Он записывает, какие элементы уже выбирались в текущем раунде (<code>for</code> цикле), и нужен для того, чтобы равные элементы выбирались только один раз.</li> </ul> <p>На рисунке 13-9 показана область действия двух условий обрезки. Помните, что каждый узел дерева соответствует одному выбору, а путь от корня до листа образует одну перестановку.</p> <p></p> <p> Рисунок 13-9   Область действия двух условий обрезки </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   Задача о сумме подмножеств","text":"","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   Случай без повторяющихся элементов","text":"<p>Question</p> <p>Дан массив положительных целых чисел <code>nums</code> и целое положительное значение <code>target</code> . Найдите все возможные комбинации, сумма элементов которых равна <code>target</code> . Во входном массиве нет повторяющихся элементов, и каждый элемент можно выбирать неограниченное число раз. Верните эти комбинации в виде списка; в результате не должно быть повторяющихся комбинаций.</p> <p>Например, для входного множества \\(\\{3, 4, 5\\}\\) и целевого значения \\(9\\) решениями будут \\(\\{3, 3, 3\\}\\) и \\(\\{4, 5\\}\\) . При этом важно учитывать два обстоятельства.</p> <ul> <li>Элементы входного множества можно выбирать повторно неограниченное число раз.</li> <li>Подмножество не различает порядок элементов, поэтому \\(\\{4, 5\\}\\) и \\(\\{5, 4\\}\\) считаются одним и тем же подмножеством.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   Отталкиваемся от решения задачи о перестановках","text":"<p>Как и в задаче о перестановках, можно представлять построение подмножеств как результат последовательности выборов и во время выбора динамически обновлять \"сумму элементов\"; когда эта сумма становится равной <code>target</code> , соответствующее подмножество записывается в список результатов.</p> <p>Однако в отличие от задачи о перестановках в этой задаче элементы множества можно выбирать неограниченное число раз, поэтому нам не нужен булев список <code>selected</code> для записи того, был ли выбран элемент. Можно слегка изменить код для перестановок и получить первоначальную версию решения:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств I\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if total == target:\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    for i in range(len(choices)):\n        # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target:\n            continue\n        # Попытка: сделать выбор и обновить элемент и total\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств I (с повторяющимися подмножествами)\"\"\"\n    state = []  # Состояние (подмножество)\n    total = 0  # Сумма подмножеств\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // Состояние (подмножество)\n    int total = 0;           // Сумма подмножеств\n    vector&lt;vector&lt;int&gt;&gt; res; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    int total = 0; // Сумма подмножеств\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    int total = 0; // Сумма подмножеств\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for i := 0; i &lt; len(*choices); i++ {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    total := 0              // Сумма подмножеств\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if total == target {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for i in choices.indices {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let total = 0 // Сумма подмножеств\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(state, target, total, choices, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // Состояние (подмножество)\n    const total = 0; // Сумма подмножеств\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    const total = 0; // Сумма подмножеств\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  for (int i = 0; i &lt; choices.length; i++) {\n    // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // Попытка: сделать выбор и обновить элемент и total\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  int total = 0; // Сумма элементов\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for i in 0..choices.len() {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    let total = 0; // Сумма подмножеств\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state[stateSize++] = choices[i];\n        // Перейти к следующему выбору\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // Инициализировать число решений нулем\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i in choices.indices) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    val total = 0 // Сумма подмножеств\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, total, choices, res)\n  # Если сумма подмножества равна target, записать решение\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  for i in 0...choices.length\n    # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    next if total + choices[i] &gt; target\n    # Попытка: сделать выбор и обновить элемент и total\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, total, choices, res)\n  # Если сумма подмножества равна target, записать решение\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  for i in 0...choices.length\n    # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    next if total + choices[i] &gt; target\n    # Попытка: сделать выбор и обновить элемент и total\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n# ## Решить задачу суммы подмножеств I (с повторяющимися подмножествами) ###\ndef subset_sum_i_naive(nums, target)\n  state = [] # Состояние (подмножество)\n  total = 0 # Сумма подмножеств\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если подать на этот код массив \\([3, 4, 5]\\) и целевое значение \\(9\\) , то на выходе мы получим \\([3, 3, 3], [4, 5], [5, 4]\\) . Хотя все подмножества с суммой \\(9\\) успешно найдены, среди них все же присутствуют дубликаты: \\([4, 5]\\) и \\([5, 4]\\) .</p> <p>Причина в том, что процесс поиска различает порядок выбора, тогда как для подмножеств порядок не важен. Как показано на рисунке 13-10, сначала выбрать \\(4\\) , а затем \\(5\\) , и сначала выбрать \\(5\\) , а затем \\(4\\) - это разные ветви поиска, но им соответствует одно и то же подмножество.</p> <p></p> <p> Рисунок 13-10   Поиск подмножеств и обрезка по выходу за границу </p> <p>Чтобы убрать повторяющиеся подмножества, одна из прямых идей - удалить дубликаты уже из итогового списка результатов. Но это решение малоэффективно по двум причинам.</p> <ul> <li>Когда массив содержит много элементов, а особенно когда <code>target</code> велик, процесс поиска порождает огромное число повторяющихся подмножеств.</li> <li>Сравнение подмножеств (то есть массивов) само по себе довольно затратно: сначала приходится сортировать массивы, а затем поэлементно сравнивать их.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   Обрезка повторяющихся подмножеств","text":"<p>Поэтому стоит выполнять устранение дубликатов прямо во время поиска, с помощью обрезки. Посмотрите на рисунок 13-11: повторяющиеся подмножества возникают тогда, когда элементы массива выбираются в разном порядке, например так.</p> <ol> <li>Если в первом и втором раундах выбрать соответственно \\(3\\) и \\(4\\) , то будут сгенерированы все подмножества, содержащие эти два элемента, и их можно обозначить как \\([3, 4, \\dots]\\) .</li> <li>После этого, если в первом раунде выбрать \\(4\\) , то во втором раунде нужно пропустить \\(3\\) , потому что подмножества \\([4, 3, \\dots]\\) полностью дублируют подмножества, уже построенные на шаге <code>1.</code> .</li> </ol> <p>Во время поиска варианты на каждом уровне пробуются по одному слева направо, поэтому чем правее ветвь, тем больше ветвей оказывается отсечено.</p> <ol> <li>В первых двух раундах выбираются \\(3\\) и \\(5\\) , что дает подмножества \\([3, 5, \\dots]\\) .</li> <li>В первых двух раундах выбираются \\(4\\) и \\(5\\) , что дает подмножества \\([4, 5, \\dots]\\) .</li> <li>Если же в первом раунде выбрать \\(5\\) , то во втором раунде нужно пропустить \\(3\\) и \\(4\\) , потому что подмножества \\([5, 3, \\dots]\\) и \\([5, 4, \\dots]\\) полностью дублируют случаи, описанные в шагах <code>1.</code> и <code>2.</code> .</li> </ol> <p></p> <p> Рисунок 13-11   Повторяющиеся подмножества из-за разного порядка выбора </p> <p>В общем виде, если входной массив имеет вид \\([x_1, x_2, \\dots, x_n]\\) , а последовательность выборов в ходе поиска равна \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) , то она должна удовлетворять условию \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ; все последовательности выборов, не удовлетворяющие этому условию, приводят к дубликатам и должны отсекаться.</p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>Чтобы реализовать такую обрезку, инициализируем переменную <code>start</code> , которая будет указывать начальную точку обхода. После выбора элемента \\(x_i\\) следующий раунд начинается с индекса \\(i\\). Благодаря этому последовательность выборов всегда удовлетворяет условию \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) , а значит, каждое подмножество создается только один раз.</p> <p>Помимо этого, мы внесем в код еще два улучшения.</p> <ul> <li>Перед началом поиска отсортируем массив <code>nums</code> . Тогда при обходе всех вариантов можно сразу прервать цикл, как только сумма подмножества превысит <code>target</code> , потому что все последующие элементы будут еще больше и их сумма тоже превысит <code>target</code> .</li> <li>Откажемся от отдельной переменной суммы <code>total</code> и будем учитывать сумму через вычитание из <code>target</code> ; когда <code>target</code> станет равным \\(0\\) , решение фиксируется.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств I\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if target == 0:\n        res.append(list(state))\n        return\n    # Обойти все варианты выбора\n    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in range(start, len(choices)):\n        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0:\n            break\n        # Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств I\"\"\"\n    state = []  # Состояние (подмножество)\n    nums.sort()  # Отсортировать nums\n    start = 0  # Стартовая вершина обхода\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // Состояние (подмножество)\n    sort(nums.begin(), nums.end()); // Отсортировать nums\n    int start = 0;                  // Стартовая вершина обхода\n    vector&lt;vector&lt;int&gt;&gt; res;        // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    Arrays.sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    Array.Sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i := start; i &lt; len(*choices); i++ {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    sort.Ints(nums)         // Отсортировать nums\n    start := 0              // Стартовая вершина обхода\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in choices.indices.dropFirst(start) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let nums = nums.sorted() // Отсортировать nums\n    let start = 0 // Стартовая вершина обхода\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(state, target, choices, start, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunction subsetSumI(nums, target) {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Обойти все варианты выбора\n  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  for (int i = start; i &lt; choices.length; i++) {\n    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Попытка: сделать выбор и обновить target и start\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  nums.sort(); // Отсортировать nums\n  int start = 0; // Стартовая вершина обхода\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in start..choices.len() {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    nums.sort(); // Отсортировать nums\n    let start = 0; // Стартовая вершина обхода\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Перейти к следующему выбору\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // Отсортировать nums\n    int start = 0;                           // Стартовая вершина обхода\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (i in start..&lt;choices.size) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    nums.sort() // Отсортировать nums\n    val start = 0 // Стартовая вершина обхода\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, choices, start, res)\n  # Если сумма подмножества равна target, записать решение\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # Обойти все варианты выбора\n  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  for i in start...choices.length\n    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    break if target - choices[i] &lt; 0\n    # Попытка: сделать выбор и обновить target и start\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Решить задачу суммы подмножеств I ###\ndef subset_sum_i(nums, target)\n  state = [] # Состояние (подмножество)\n  nums.sort! # Отсортировать nums\n  start = 0 # Стартовая вершина обхода\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 13-12 показан полный процесс поиска с возвратом для массива \\([3, 4, 5]\\) и целевого значения \\(9\\) .</p> <p></p> <p> Рисунок 13-12   Процесс поиска с возвратом для задачи о сумме подмножеств I </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   Учет повторяющихся элементов","text":"<p>Question</p> <p>Дан массив положительных целых чисел <code>nums</code> и целое положительное значение <code>target</code> . Найдите все возможные комбинации, сумма элементов которых равна <code>target</code> . Во входном массиве могут присутствовать повторяющиеся элементы, и каждый элемент разрешено выбирать только один раз. Верните эти комбинации в виде списка; в результате не должно быть повторяющихся комбинаций.</p> <p>По сравнению с предыдущей задачей во входном массиве теперь могут присутствовать повторяющиеся элементы, и это создает новую проблему. Например, если дан массив \\([4, \\hat{4}, 5]\\) и целевое значение \\(9\\) , то существующий код вернет результат \\([4, 5], [\\hat{4}, 5]\\) , то есть с повторяющимся подмножеством.</p> <p>Причина появления дублей в том, что равные элементы выбираются несколько раз в одном и том же раунде. На рисунке 13-13 в первом раунде существует три варианта выбора, и два из них равны \\(4\\) ; из-за этого появляются две дублирующиеся ветви поиска и, соответственно, повторяющиеся подмножества. Точно так же два элемента \\(4\\) во втором раунде тоже порождают дубликаты.</p> <p></p> <p> Рисунок 13-13   Повторяющиеся подмножества из-за равных элементов </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   Обрезка равных элементов","text":"<p>Чтобы решить эту проблему, нужно ограничить выбор равных элементов так, чтобы в каждом раунде каждый из них выбирался только один раз. Реализуется это довольно естественно: поскольку массив отсортирован, равные элементы стоят рядом. Значит, если в текущем раунде текущий элемент равен соседнему слева, то этот вариант уже был рассмотрен, и текущий элемент нужно пропустить.</p> <p>Одновременно по условию этой задачи каждый элемент массива можно выбрать только один раз. К счастью, это ограничение тоже можно реализовать через переменную <code>start</code> : после выбора элемента \\(x_i\\) следующий раунд начинается с индекса \\(i + 1\\) . Так мы одновременно убираем повторяющиеся подмножества и исключаем повторный выбор одного и того же элемента.</p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств II\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if target == 0:\n        res.append(list(state))\n        return\n    # Обойти все варианты выбора\n    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in range(start, len(choices)):\n        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0:\n            break\n        # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств II\"\"\"\n    state = []  # Состояние (подмножество)\n    nums.sort()  # Отсортировать nums\n    start = 0  # Стартовая вершина обхода\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // Состояние (подмножество)\n    sort(nums.begin(), nums.end()); // Отсортировать nums\n    int start = 0;                  // Стартовая вершина обхода\n    vector&lt;vector&lt;int&gt;&gt; res;        // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    Arrays.sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    Array.Sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i := start; i &lt; len(*choices); i++ {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    sort.Ints(nums)         // Отсортировать nums\n    start := 0              // Стартовая вершина обхода\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in choices.indices.dropFirst(start) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let nums = nums.sorted() // Отсортировать nums\n    let start = 0 // Стартовая вершина обхода\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunction backtrack(state, target, choices, start, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunction subsetSumII(nums, target) {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Обойти все варианты выбора\n  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n  for (int i = start; i &lt; choices.length; i++) {\n    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // Попытка: сделать выбор и обновить target и start\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  nums.sort(); // Отсортировать nums\n  int start = 0; // Стартовая вершина обхода\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in start..choices.len() {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    nums.sort(); // Отсортировать nums\n    let start = 0; // Стартовая вершина обхода\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, сразу пропустить\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Перейти к следующему выбору\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // Отсортировать nums\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // Начать бэктрекинг\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (i in start..&lt;choices.size) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    nums.sort() // Отсортировать nums\n    val start = 0 // Стартовая вершина обхода\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств II ###\ndef backtrack(state, target, choices, start, res)\n  # Если сумма подмножества равна target, записать решение\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Обойти все варианты выбора\n  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n  for i in start...choices.length\n    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    break if target - choices[i] &lt; 0\n    # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # Попытка: сделать выбор и обновить target и start\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Решить задачу суммы подмножеств II ###\ndef subset_sum_ii(nums, target)\n  state = [] # Состояние (подмножество)\n  nums.sort! # Отсортировать nums\n  start = 0 # Стартовая вершина обхода\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 13-14 показан процесс поиска с возвратом для массива \\([4, 4, 5]\\) и целевого значения \\(9\\) . В нем используются четыре вида обрезки. Попробуйте сопоставить рисунок с комментариями в коде, чтобы понять полный процесс поиска и то, как работает каждый тип обрезки.</p> <p></p> <p> Рисунок 13-14   Процесс поиска с возвратом для задачи о сумме подмножеств II </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   Резюме","text":"","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Алгоритм поиска с возвратом по своей сути является методом полного перебора: он ищет решения путем обхода пространства решений в глубину. Во время поиска он фиксирует решения, удовлетворяющие условиям, пока не найдет все такие решения или пока обход не завершится.</li> <li>Процесс поиска с возвратом состоит из двух частей: попытки и отката. Он с помощью поиска в глубину пробует разные варианты выбора; когда встречается состояние, не удовлетворяющее ограничениям, алгоритм отменяет предыдущий выбор, возвращается к прошлому состоянию и продолжает пробовать другие варианты. Попытка и откат являются двумя противоположными по направлению действиями.</li> <li>Задачи поиска с возвратом обычно содержат несколько ограничений, которые можно использовать для обрезки. Обрезка позволяет заранее завершать ненужные ветви поиска и тем самым значительно повышать эффективность.</li> <li>Алгоритм поиска с возвратом в первую очередь применяется для решения поисковых задач и задач с ограничениями. Задачи комбинаторной оптимизации тоже можно решать с его помощью, но для них часто существуют более эффективные или более подходящие методы.</li> <li>Задача о перестановках нацелена на поиск всех возможных перестановок элементов данного множества. Мы используем массив для записи того, был ли выбран каждый элемент, и отсекаем ветви, где один и тот же элемент выбирается повторно, чтобы гарантировать однократный выбор каждого элемента.</li> <li>В задаче о перестановках, если во множестве присутствуют повторяющиеся элементы, в итоговом результате возникнут повторяющиеся перестановки. Поэтому нужно ограничить выбор равных элементов так, чтобы в каждом раунде каждый из них выбирался только один раз; обычно это реализуется с помощью хеш-множества.</li> <li>Цель задачи о сумме подмножеств - найти все подмножества данного множества, сумма которых равна целевому значению. В множестве порядок элементов не важен, однако процесс поиска порождает результаты во всех возможных порядках, из-за чего появляются повторяющиеся подмножества. Поэтому перед запуском поиска с возвратом мы сортируем данные и вводим переменную, указывающую начальную точку обхода в каждом раунде, чтобы отсечь ветви, создающие дубликаты.</li> <li>В задаче о сумме подмножеств равные элементы массива также порождают повторяющиеся множества. При наличии предварительной сортировки их можно отсекать, проверяя равенство соседних элементов, и тем самым гарантировать, что в каждом раунде равные элементы будут выбираться только один раз.</li> <li>Задача о \\(n\\) ферзях состоит в поиске способов разместить \\(n\\) ферзей на доске размера \\(n \\times n\\) так, чтобы никакие два ферзя не атаковали друг друга. Ограничения этой задачи включают строки, столбцы, главные диагонали и побочные диагонали. Чтобы выполнить ограничение по строкам, используется построчная стратегия размещения, гарантирующая по одному ферзю в каждой строке.</li> <li>Обработка ограничений по столбцам и диагоналям устроена похожим образом. Для ограничения по столбцам используется массив, фиксирующий наличие ферзя в каждом столбце. Для диагоналей используются два массива, записывающие наличие ферзей на главных и побочных диагоналях. Основная сложность здесь состоит в том, чтобы найти закономерность индексов строк и столбцов клеток, лежащих на одной и той же главной или побочной диагонали.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/summary/#2","level":3,"title":"2.   Вопросы и ответы","text":"<p>Q: Как понять связь между поиском с возвратом и рекурсией?</p> <p>В целом поиск с возвратом - это скорее \"алгоритмическая стратегия\", а рекурсия больше похожа на \"инструмент\".</p> <ul> <li>Алгоритмы поиска с возвратом обычно реализуются на основе рекурсии. Однако поиск с возвратом - это лишь один из вариантов применения рекурсии, а именно ее использование в поисковых задачах.</li> <li>Структура рекурсии отражает парадигму разбиения на подзадачи и часто применяется для решения задач \"разделяй и властвуй\", поиска с возвратом, динамического программирования (мемоизированной рекурсии) и других подобных задач.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"Глава 2.   Анализ сложности","text":"<p>Abstract</p> <p>Анализ сложности подобен пространственно-временному проводнику в необъятной вселенной алгоритмов.</p> <p>Он ведет нас в глубину двух измерений - времени и пространства, помогая искать более изящные решения.</p>","path":["Глава 2. Анализ сложности","Глава 2. &nbsp; Анализ сложности"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>2.1   Оценка эффективности алгоритмов</li> <li>2.2   Итерация и рекурсия</li> <li>2.3   Временная сложность</li> <li>2.4   Пространственная сложность</li> <li>2.5   Резюме</li> </ul>","path":["Глава 2. Анализ сложности","Глава 2. &nbsp; Анализ сложности"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   Итерация и рекурсия","text":"<p>В алгоритмах часто требуется повторное выполнение определенной задачи, что тесно связано с анализом сложности. Поэтому, прежде чем перейти к обсуждению временной и пространственной сложности, рассмотрим, как реализовать повторное выполнение задач в программе, а именно две основные структуры управления программой: итерацию и рекурсию.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   Итерация","text":"<p>Итерация (iteration) - это структура управления, которая позволяет повторно выполнять определенную задачу. В итерации программа повторяет выполнение определенного участка кода, пока выполняется определенное условие.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   Цикл for","text":"<p>Цикл <code>for</code> - одна из наиболее распространенных форм итерации, которая подходит для использования, когда количество итераций известно заранее.</p> <p>Следующая функция реализует суммирование \\(1 + 2 + \\dots + n\\) с использованием цикла <code>for</code> , а результат суммирования сохраняется в переменной <code>res</code> . Следует отметить, что в Python диапазон <code>range(a, b)</code> соответствует левому закрытому, правому открытому интервалу, то есть перебираются значения \\(a, a + 1, \\dots, b-1\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"Цикл for\"\"\"\n    res = 0\n    # Циклическое суммирование 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл for */\nint ForLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл for */\nfunc forLoop(n int) int {\n    res := 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл for */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл for */\nfunction forLoop(n) {\n    let res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл for */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл for */\nint forLoop(int n) {\n  int res = 0;\n  // Циклическое суммирование 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл for */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл for */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл for ###\ndef for_loop(n)\n  res = 0\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже представлена блок-схема этой функции суммирования.</p> <p></p> <p> Рисунок 2-1   Блок-схема функции суммирования </p> <p>Количество операций этой функции суммирования пропорционально размеру входных данных \\(n\\) , или, другими словами, линейно зависит от него. На самом деле временная сложность описывает именно эту линейную зависимость. Соответствующий материал будет подробно рассмотрен в следующем разделе.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   Цикл while","text":"<p>Подобно циклу <code>for</code> , цикл <code>while</code> также представляет собой метод реализации итерации. В цикле <code>while</code> программа перед каждой итерацией проверяет условие: если условие истинно, то выполнение продолжается, иначе цикл завершается.</p> <p>Ниже приведен пример реализации суммирования \\(1 + 2 + \\dots + n\\) с использованием цикла <code>while</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"Цикл while\"\"\"\n    res = 0\n    i = 1  # Инициализация условной переменной\n    # Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # Обновить условную переменную\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл while */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл while */\nfunc whileLoop(n int) int {\n    res := 0\n    // Инициализация условной переменной\n    i := 1\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл while */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // Обновить условную переменную\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл while */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл while */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл while */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // Инициализация условной переменной\n  // Циклическое суммирование 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // Обновить условную переменную\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл while */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Инициализация условной переменной\n\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // Обновить условную переменную\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл while */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // Обновить условную переменную\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл while ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Обновить условную переменную\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>**Цикл <code>while</code> обладает большей степенью свободы по сравнению с циклом <code>for</code> **. В цикле <code>while</code> можно свободно управлять инициализацией и обновлением условной переменной.</p> <p>Например, в следующем коде условная переменная \\(i\\) обновляется дважды на каждой итерации, что затруднительно сделать с использованием цикла <code>for</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"Цикл while (двойное обновление)\"\"\"\n    res = 0\n    i = 1  # Инициализация условной переменной\n    # Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # Обновить условную переменную\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл while (двойное обновление) */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл while (двойное обновление) */\nfunc whileLoopII(n int) int {\n    res := 0\n    // Инициализация условной переменной\n    i := 1\n    // Циклическое суммирование 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл while (двойное обновление) */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл while (двойное обновление) */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл while (двойное обновление) */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // Инициализация условной переменной\n  // Циклическое суммирование 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // Обновить условную переменную\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл while (двойное обновление) */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Инициализация условной переменной\n\n    // Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // Обновить условную переменную\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл while (двойное обновление) */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // Обновить условную переменную\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл while ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Обновить условную переменную\n  end\n\n  res\nend\n\n# ## Цикл while (двойное обновление) ###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # Обновить условную переменную\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В целом код с использованием цикла <code>for</code> более компактный, а цикл <code>while</code> более гибкий. Но они оба могут реализовать итерационную структуру. Выбор между ними определяется требованиями конкретной задачи.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   Вложенные циклы","text":"<p>Внутрь одной циклической структуры можно вложить другую, например используя два цикла <code>for</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"Двойной цикл for\"\"\"\n    res = \"\"\n    # Цикл по i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # Цикл по j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* Двойной цикл for */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* Двойной цикл for */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* Двойной цикл for */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* Двойной цикл for */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // Цикл по j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Двойной цикл for */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Двойной цикл for */\nfunction nestedForLoop(n) {\n    let res = '';\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Двойной цикл for */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Двойной цикл for */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // Цикл по i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // Цикл по j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Двойной цикл for */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* Двойной цикл for */\nchar *nestedForLoop(int n) {\n    // n * n — это число соответствующих точек, а максимальная длина строки \"(i, j), \" равна 6+10*2, плюс дополнительное место для завершающего нулевого символа \\0\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Двойной цикл for */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### Двойной цикл for ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # Цикл по i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # Цикл по j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже приведена блок-схема такого вложенного цикла.</p> <p></p> <p> Рисунок 2-2   Блок-схема вложенного цикла </p> <p>В этом случае количество выполненных действий пропорционально \\(n^2\\) , или, другими словами, время выполнения алгоритма и размер входных данных \\(n\\) находятся в квадратичной зависимости.</p> <p>Можно и дальше добавлять вложенные циклы, тогда каждое вложение будет повышать размерность, увеличивая временную сложность до кубической зависимости, зависимости четвертой степени и так далее.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   Рекурсия","text":"<p>Рекурсия (recursion) - это стратегия алгоритма, при которой функция вызывает саму себя для решения задачи. Она включает два основных этапа.</p> <ol> <li>Вызов: программа постоянно вызывает саму себя, обычно передавая меньшие или более упрощенные параметры, пока не будет достигнуто условие завершения.</li> <li>Возврат: после срабатывания условия завершения программа начинает возвращаться из самой глубокой рекурсивной функции, объединяя результаты каждого уровня.</li> </ol> <p>С точки зрения реализации рекурсивный код включает три основных элемента.</p> <ol> <li>Условие завершения: используется для определения момента перехода от вызова к возврату.</li> <li>Рекурсивный вызов: соответствует вызову, функция вызывает саму себя, обычно с меньшими или упрощенными параметрами.</li> <li>Возврат результата: соответствует возврату, возвращает результат текущего уровня рекурсии на предыдущий уровень.</li> </ol> <p>Рассмотрим следующий код: вызов функции <code>recur(n)</code> позволяет вычислить сумму \\(1 + 2 + \\dots + n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"Рекурсия\"\"\"\n    # Условие завершения\n    if n == 1:\n        return 1\n    # Рекурсия: рекурсивный вызов\n    res = recur(n - 1)\n    # Возврат: вернуть результат\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* Рекурсия */\nint Recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = Recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* Рекурсия */\nfunc recur(n int) int {\n    // Условие завершения\n    if n == 1 {\n        return 1\n    }\n    // Рекурсия: рекурсивный вызов\n    res := recur(n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* Рекурсия */\nfunc recur(n: Int) -&gt; Int {\n    // Условие завершения\n    if n == 1 {\n        return 1\n    }\n    // Рекурсия: рекурсивный вызов\n    let res = recur(n: n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* Рекурсия */\nfunction recur(n) {\n    // Условие завершения\n    if (n === 1) return 1;\n    // Рекурсия: рекурсивный вызов\n    const res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* Рекурсия */\nfunction recur(n: number): number {\n    // Условие завершения\n    if (n === 1) return 1;\n    // Рекурсия: рекурсивный вызов\n    const res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* Рекурсия */\nint recur(int n) {\n  // Условие завершения\n  if (n == 1) return 1;\n  // Рекурсия: рекурсивный вызов\n  int res = recur(n - 1);\n  // Возврат: вернуть результат\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* Рекурсия */\nfn recur(n: i32) -&gt; i32 {\n    // Условие завершения\n    if n == 1 {\n        return 1;\n    }\n    // Рекурсия: рекурсивный вызов\n    let res = recur(n - 1);\n    // Возврат: вернуть результат\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* Рекурсия */\nfun recur(n: Int): Int {\n    // Условие завершения\n    if (n == 1)\n        return 1\n    // Рекурсивный шаг: рекурсивный вызов\n    val res = recur(n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### Рекурсия ###\ndef recur(n)\n  # Условие завершения\n  return 1 if n == 1\n  # Рекурсия: рекурсивный вызов\n  res = recur(n - 1)\n  # Возврат: вернуть результат\n  n + res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже представлен рекурсивный процесс этой функции.</p> <p></p> <p> Рисунок 2-3   Рекурсивный процесс функции суммирования </p> <p>Хотя с точки зрения вычислений итерация и рекурсия могут давать одинаковый результат, они представляют собой совершенно разные парадигмы мышления и решения задач.</p> <ul> <li>Итерация: решение задачи снизу вверх. Начинаем с самых базовых шагов, которые затем повторяются или накапливаются до завершения задачи.</li> <li>Рекурсия: решение задачи сверху вниз. Исходная задача разбивается на более мелкие подзадачи, которые имеют ту же форму, что и исходная задача. Далее подзадачи продолжают делиться на еще более мелкие, пока не достигается базовый случай, решение которого известно.</li> </ul> <p>Рассмотрим в качестве примера вышеупомянутую функцию суммирования, где решается задача \\(f(n) = 1 + 2 + \\dots + n\\) .</p> <ul> <li>Итерация: моделирование процесса суммирования в цикле проходит от \\(1\\) до \\(n\\) , выполняя операцию суммирования на каждом шаге, чтобы получить итоговое значение \\(f(n)\\) .</li> <li>Рекурсия: последовательное разбиение задачи на подзадачи вида \\(f(n) = n + f(n - 1)\\) до достижения базового случая \\(f(1) = 1\\) .</li> </ul>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   Стек вызовов","text":"<p>Каждый раз, когда рекурсивная функция вызывает саму себя, система выделяет память для нового вызова функции, чтобы хранить локальные переменные, адрес вызова и другую информацию. Это поведение имеет два последствия.</p> <ul> <li>Контекстные данные функции хранятся в области памяти, называемой пространством стекового кадра, и освобождаются только после возврата функции. Поэтому рекурсия обычно требует больше памяти, чем итерация.</li> <li>Рекурсивный вызов функции создает дополнительные накладные расходы. Поэтому рекурсия обычно менее эффективна по времени, чем цикл.</li> </ul> <p>Как показано на рисунке 2-4, до срабатывания условия завершения одновременно существует \\(n\\) невозвращенных рекурсивных функций, а глубина рекурсии равна \\(n\\) .</p> <p></p> <p> Рисунок 2-4   Глубина рекурсивного вызова </p> <p>На практике глубина рекурсии, разрешенная языком программирования, обычно ограничена, и слишком глубокая рекурсия может привести к ошибке переполнения стека.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   Хвостовая рекурсия","text":"<p>Интересно, что если рекурсивный вызов происходит на последнем шаге перед возвратом функции , то компилятор или интерпретатор может оптимизировать этот вызов, сделав его по эффективности использования памяти сопоставимым с итерацией. Это называется хвостовой рекурсией (tail recursion).</p> <ul> <li>Обычная рекурсия: когда функция возвращается на предыдущий уровень, необходимо продолжить выполнение кода, поэтому системе нужно сохранить контекст предыдущего вызова.</li> <li>Хвостовая рекурсия: рекурсивный вызов является последней операцией перед возвратом функции, что означает, что после возврата на предыдущий уровень не требуется выполнять другие операции, поэтому системе не нужно сохранять контекст предыдущей функции.</li> </ul> <p>В качестве примера вычисления суммы \\(1 + 2 + \\dots + n\\) можно установить переменную результата <code>res</code> в качестве параметра функции, чтобы реализовать хвостовую рекурсию:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"Хвостовая рекурсия\"\"\"\n    # Условие завершения\n    if n == 0:\n        return res\n    # Хвостовой рекурсивный вызов\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* Хвостовая рекурсия */\nint TailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* Хвостовая рекурсия */\nfunc tailRecur(n int, res int) int {\n    // Условие завершения\n    if n == 0 {\n        return res\n    }\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* Хвостовая рекурсия */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // Условие завершения\n    if n == 0 {\n        return res\n    }\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* Хвостовая рекурсия */\nfunction tailRecur(n, res) {\n    // Условие завершения\n    if (n === 0) return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* Хвостовая рекурсия */\nfunction tailRecur(n: number, res: number): number {\n    // Условие завершения\n    if (n === 0) return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n  // Условие завершения\n  if (n == 0) return res;\n  // Хвостовой рекурсивный вызов\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* Хвостовая рекурсия */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // Условие завершения\n    if n == 0 {\n        return res;\n    }\n    // Хвостовой рекурсивный вызов\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* Хвостовая рекурсия */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // Добавить ключевое слово tailrec, чтобы включить оптимизацию хвостовой рекурсии\n    // Условие завершения\n    if (n == 0)\n        return res\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### Хвостовая рекурсия ###\ndef tail_recur(n, res)\n  # Условие завершения\n  return res if n == 0\n  # Хвостовой рекурсивный вызов\n  tail_recur(n - 1, res + n)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Процесс выполнения хвостовой рекурсии показан на рисунке 2-5. Сравнивая обычную и хвостовую рекурсии, можно заметить, что точка выполнения операции суммирования у них различается.</p> <ul> <li>Обычная рекурсия: операция суммирования выполняется в процессе возврата, после каждого возврата необходимо снова выполнить операцию суммирования.</li> <li>Хвостовая рекурсия: операция суммирования выполняется в процессе вызова, а процесс возврата требует только последовательного возврата.</li> </ul> <p></p> <p> Рисунок 2-5   Процесс хвостовой рекурсии </p> <p>Tip</p> <p>Обратите внимание: многие компиляторы и интерпретаторы не поддерживают оптимизацию хвостовой рекурсии. Например, Python по умолчанию такую оптимизацию не выполняет, поэтому даже функция в хвостово-рекурсивной форме все равно может привести к переполнению стека.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   Дерево рекурсии","text":"<p>При решении задач, связанных с алгоритмами типа \"разделяй и властвуй\", рекурсия часто оказывается более интуитивной и читабельной, чем итерация. Рассмотрим в качестве примера последовательность Фибоначчи.</p> <p>Question</p> <p>Дана последовательность Фибоначчи \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) ; найди \\(n\\)-й элемент этой последовательности.</p> <p>Обозначив \\(n\\)-й член последовательности Фибоначчи как \\(f(n)\\) , можно сформулировать два утверждения.</p> <ul> <li>Первые два числа последовательности: \\(f(1) = 0\\) и \\(f(2) = 1\\) .</li> <li>Каждое число последовательности является суммой двух предыдущих чисел, то есть \\(f(n) = f(n - 1) + f(n - 2)\\) .</li> </ul> <p>Используя рекурсивные вызовы в соответствии с рекуррентным соотношением и принимая первые два числа за условия остановки, можно написать рекурсивный код. Вызов <code>fib(n)</code> позволит получить \\(n\\)-й член последовательности Фибоначчи:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"Последовательность Фибоначчи: рекурсия\"\"\"\n    # Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # Вернуть результат f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint Fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunc fib(n int) int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunc fib(n: Int) -&gt; Int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunction fib(n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunction fib(n: number): number {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n  // Условие завершения: f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // Вернуть результат f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfn fib(n: i32) -&gt; i32 {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат\n    res\n}\n</code></pre> recursion.c<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfun fib(n: Int): Int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Последовательность Фибоначчи: рекурсия ###\ndef fib(n)\n  # Условие завершения: f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # Вернуть результат f(n)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Проанализировав приведенный код, можно заметить, что внутри функции осуществляется рекурсивный вызов двух функций, то есть из одного вызова образуются два ветвления. Как показано на рисунке 2-6, при последующем выполнении рекурсивных вызовов в итоге образуется дерево рекурсии (recursion tree) глубиной \\(n\\) .</p> <p></p> <p> Рисунок 2-6   Дерево рекурсии последовательности Фибоначчи </p> <p>По своей сути рекурсия отражает парадигму мышления \"разбиение задачи на более мелкие подзадачи\", что делает стратегию \"разделяй и властвуй\" крайне важной.</p> <ul> <li>С точки зрения алгоритмов многие важные алгоритмические стратегии, такие как поиск, сортировка, возврат, \"разделяй и властвуй\" и динамическое программирование, прямо или косвенно используют этот подход.</li> <li>С точки зрения структур данных рекурсия естественно подходит для решения задач, связанных со списками, деревьями и графами, поскольку они очень хорошо поддаются анализу с использованием идеи \"разделяй и властвуй\".</li> </ul>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   Сравнение","text":"<p>Подводя итог, можно сказать, что итерация и рекурсия различаются по реализации, производительности и применимости, как показано в таблице 2-1.</p> <p> Таблица 2-1   Сравнение итерации и рекурсии </p> Итерация Рекурсия Способ реализации Циклическая структура Функция вызывает саму себя Временная эффективность Обычно высокая эффективность, нет затрат на вызов функции Каждый вызов функции создает затраты Использование памяти Обычно используется фиксированный объем памяти Накопление вызовов функции может использовать значительное количество пространства стека Сфера использования Подходит для простых циклических задач, код интуитивно понятен и хорошо читаем Подходит для разбиения на подзадачи, для структур деревья и графы, алгоритмов \"разделяй и властвуй\", возврата и т. д.; структура кода проста и ясна <p>Tip</p> <p>Если дальнейшее содержание кажется сложным, можно вернуться к нему после чтения главы о \"стеке\".</p> <p>Какова же внутренняя связь между итерацией и рекурсией? В рассмотренном примере рекурсивной функции операция сложения выполняется на этапе возврата рекурсии. Это означает, что функция, вызванная первой, фактически завершает операцию сложения последней, что соответствует принципу стека \"первым пришел - последним вышел\".</p> <p>На самом деле такие термины рекурсии, как \"стек вызовов\" и \"пространство стекового кадра\", уже намекают на тесную связь между рекурсией и стеком.</p> <ol> <li>Вызов: когда вызывается функция, система выделяет для нее новый стековый кадр в \"стеке вызовов\" для хранения локальных переменных функции, параметров, адреса возврата и других данных.</li> <li>Возврат: когда функция завершает выполнение и возвращает результат, соответствующий стековый кадр удаляется из \"стека вызовов\", восстанавливая среду выполнения предыдущей функции.</li> </ol> <p>Таким образом, можно использовать явный стек для моделирования поведения стека вызовов, чтобы преобразовать рекурсию в итеративную форму:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"Имитация рекурсии итерацией\"\"\"\n    # Использовать явный стек для имитации системного стека вызовов\n    stack = []\n    res = 0\n    # Рекурсия: рекурсивный вызов\n    for i in range(n, 0, -1):\n        # Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.append(i)\n    # Возврат: вернуть результат\n    while stack:\n        # Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (!stack.empty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (!stack.isEmpty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Имитация рекурсии итерацией */\nint ForLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.Push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.Count &gt; 0) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Имитация рекурсии итерацией */\nfunc forLoopRecur(n int) int {\n    // Использовать явный стек для имитации системного стека вызовов\n    stack := list.New()\n    res := 0\n    // Рекурсия: рекурсивный вызов\n    for i := n; i &gt; 0; i-- {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.PushBack(i)\n    }\n    // Возврат: вернуть результат\n    for stack.Len() != 0 {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Имитация рекурсии итерацией */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // Использовать явный стек для имитации системного стека вызовов\n    var stack: [Int] = []\n    var res = 0\n    // Рекурсия: рекурсивный вызов\n    for i in (1 ... n).reversed() {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.append(i)\n    }\n    // Возврат: вернуть результат\n    while !stack.isEmpty {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Имитация рекурсии итерацией */\nfunction forLoopRecur(n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    const stack = [];\n    let res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (let i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.length) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Имитация рекурсии итерацией */\nfunction forLoopRecur(n: number): number {\n    // Использовать явный стек для имитации системного стека вызовов\n    const stack: number[] = [];\n    let res: number = 0;\n    // Рекурсия: рекурсивный вызов\n    for (let i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.length) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n  // Использовать явный стек для имитации системного стека вызовов\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // Рекурсия: рекурсивный вызов\n  for (int i = n; i &gt; 0; i--) {\n    // Имитировать «рекурсию» с помощью операции помещения в стек\n    stack.add(i);\n  }\n  // Возврат: вернуть результат\n  while (!stack.isEmpty) {\n    // Имитировать «возврат» с помощью операции извлечения из стека\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Имитация рекурсии итерацией */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // Использовать явный стек для имитации системного стека вызовов\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // Рекурсия: рекурсивный вызов\n    for i in (1..=n).rev() {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while !stack.is_empty() {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    int stack[1000]; // Использовать большой массив для имитации стека\n    int top = -1;    // Индекс вершины стека\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack[1 + top++] = i;\n    }\n    // Возврат: вернуть результат\n    while (top &gt;= 0) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Имитация рекурсии итерацией */\nfun forLoopRecur(n: Int): Int {\n    // Использовать явный стек для имитации системного стека вызовов\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // Рекурсивный шаг: рекурсивный вызов\n    for (i in n downTo 0) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i)\n    }\n    // Возврат: вернуть результат\n    while (stack.isNotEmpty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Имитация рекурсии итерацией ###\ndef for_loop_recur(n)\n  # Использовать явный стек для имитации системного стека вызовов\n  stack = []\n  res = 0\n\n  # Рекурсия: рекурсивный вызов\n  for i in n.downto(0)\n    # Имитировать «рекурсию» с помощью операции помещения в стек\n    stack &lt;&lt; i\n  end\n  # Возврат: вернуть результат\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Наблюдая за приведенным выше кодом, можно заметить, что после преобразования рекурсии в итерацию код становится более сложным. Хотя во многих случаях итерация и рекурсия действительно могут быть преобразованы друг в друга, это не всегда стоит делать по двум причинам.</p> <ul> <li>Преобразованный код может стать труднее для понимания и менее читаемым.</li> <li>Для некоторых сложных задач моделирование поведения системного стека вызовов может оказаться очень трудным.</li> </ul> <p>Итак, выбор между итерацией и рекурсией зависит от природы конкретной задачи. В практическом программировании крайне важно взвешивать преимущества и недостатки обоих подходов и выбирать подходящий метод с учетом контекста.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   Оценка эффективности алгоритмов","text":"<p>В процессе разработки алгоритмов мы стремимся к достижению следующих целей.</p> <ol> <li>Найти решение задачи: алгоритм должен надежно находить правильное решение задачи в заданных пределах входных данных.</li> <li>Найти оптимальное решение: для одной и той же задачи может существовать несколько решений, и мы стремимся найти максимально эффективный алгоритм.</li> </ol> <p>Таким образом, при условии возможности решения задачи эффективность алгоритма становится основным критерием его оценки, который включает два аспекта.</p> <ul> <li>Временная эффективность: продолжительность выполнения алгоритма.</li> <li>Пространственная эффективность: объем памяти, занимаемой алгоритмом.</li> </ul> <p>В двух словах, наша цель - разработка быстрых и экономных структур данных и алгоритмов. Эффективная оценка алгоритмов крайне важна, так как только так можно сравнивать различные алгоритмы и управлять процессом их разработки и оптимизации.</p> <p>Методы оценки эффективности делятся на два типа: практическое тестирование и теоретическую оценку.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   Практическое тестирование","text":"<p>Предположим, у нас есть алгоритмы <code>A</code> и <code>B</code>, которые решают одну и ту же задачу, и необходимо сравнить их эффективность. Самый прямой метод - это запустить оба алгоритма на компьютере и зафиксировать время их выполнения и объем используемой памяти. Этот метод отражает реальную ситуацию, но имеет значительные ограничения.</p> <p>С одной стороны, сложно исключить влияние факторов тестовой среды. Аппаратная конфигурация влияет на производительность алгоритма. Например, если алгоритм обладает высокой степенью параллелизма, он будет лучше работать на многоядерных CPU; если алгоритм интенсивно использует память, его производительность будет выше на высокопроизводительной памяти. Это означает, что результаты тестирования на разных машинах могут значительно отличаться, а для получения средней эффективности пришлось бы тестировать на различных платформах, что крайне затруднительно.</p> <p>С другой стороны, проведение полного тестирования требует значительных ресурсов. С изменением объема входных данных алгоритмы демонстрируют разную эффективность. Например, при небольшом объеме данных алгоритм <code>A</code> может работать быстрее, чем алгоритм <code>B</code>, но при большом объеме данных результат может быть противоположным. Следовательно, для получения убедительных выводов необходимо тестировать различные масштабы входных данных, что требует значительных вычислительных ресурсов.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   Теоретическая оценка","text":"<p>Из-за значительных ограничений практического тестирования можно рассмотреть возможность оценки эффективности алгоритмов только с помощью вычислений. Такой метод называется анализом асимптотической сложности (asymptotic complexity analysis), или сокращенно анализом сложности.</p> <p>Анализ сложности позволяет отразить зависимость между ресурсами времени и пространства, необходимыми для выполнения алгоритма, и размером входных данных. Он описывает тенденцию роста времени и пространства, необходимых для выполнения алгоритма, по мере увеличения размера входных данных. Это определение может показаться сложным, но его можно разбить на три ключевых момента.</p> <ul> <li>\"Ресурсы времени и пространства\" соответствуют временной сложности (time complexity) и пространственной сложности (space complexity).</li> <li>\"По мере увеличения размера входных данных\" означает, что сложность отражает зависимость эффективности алгоритма от объема входных данных.</li> <li>\"Тенденция роста времени и пространства\" указывает, что анализ сложности фокусируется не на конкретных значениях времени выполнения или объема занимаемой памяти, а на скорости их роста.</li> </ul> <p>Анализ сложности преодолевает недостатки метода практического тестирования, что выражается в следующих аспектах.</p> <ul> <li>Он не требует фактического выполнения кода, что делает его более экологичным и энергосберегающим.</li> <li>Он независим от тестовой среды, а результаты анализа применимы ко всем платформам выполнения.</li> <li>Он может продемонстрировать эффективность алгоритма при различных объемах данных, особенно при больших объемах.</li> </ul> <p>Tip</p> <p>Если понятие сложности пока все еще кажется вам запутанным, не переживайте: мы подробно разберем его в следующих разделах.</p> <p>Анализ сложности предоставляет нам мерило оценки эффективности алгоритмов, позволяя измерять время и ресурсы, необходимые для выполнения конкретного алгоритма, а также сравнивать эффективность различных алгоритмов.</p> <p>Сложность - это математическое понятие, которое новичкам может показаться абстрактным и сложным для изучения. С этой точки зрения анализ сложности не то, с чего стоит начинать изучение алгоритмов. Однако, обсуждая особенности той или иной структуры данных или алгоритма, невозможно избежать анализа их скорости выполнения и использования памяти.</p> <p>Таким образом, перед погружением в изучение структур данных и алгоритмов рекомендуется получить базовое представление об анализе сложности, чтобы иметь возможность выполнять хотя бы базовую оценку их эффективности.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   Пространственная сложность","text":"<p>Пространственная сложность (space complexity) служит для оценки того, как меняется объем памяти, требуемой алгоритму, по мере роста объема данных. Это понятие очень похоже на временную сложность, только вместо времени выполнения рассматривается объем используемой памяти.</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   Пространство, связанное с алгоритмом","text":"<p>Память, которую использует алгоритм во время работы, в основном делится на следующие части.</p> <ul> <li>Входное пространство: используется для хранения входных данных алгоритма.</li> <li>Временное пространство: используется для хранения переменных, объектов, контекста функций и других данных, возникающих во время выполнения алгоритма.</li> <li>Выходное пространство: используется для хранения выходных данных алгоритма.</li> </ul> <p>Как правило, при анализе пространственной сложности в расчет включают временное пространство и выходное пространство.</p> <p>Временное пространство можно дополнительно разделить на три части.</p> <ul> <li>Временные данные: используются для хранения различных констант, переменных, объектов и т.д., возникающих во время выполнения алгоритма.</li> <li>Пространство кадров стека: используется для хранения контекстных данных вызываемых функций. При каждом вызове функции система создает на вершине стека новый кадр; после возврата функции пространство этого кадра освобождается.</li> <li>Пространство инструкций: используется для хранения скомпилированных инструкций программы и в реальном подсчете обычно не учитывается.</li> </ul> <p>При анализе пространственной сложности программы обычно учитываются временные данные, пространство стека и выходные данные, как показано на рисунке 2-15.</p> <p></p> <p> Рисунок 2-15   Пространство, используемое алгоритмом </p> <p>Ниже приведен соответствующий код:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"Класс\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # Значение узла\n        self.next: Node | None = None  # Ссылка на следующий узел\n\ndef function() -&gt; int:\n    \"\"\"Функция\"\"\"\n    # Выполнить некоторые операции...\n    return 0\n\ndef algorithm(n) -&gt; int:  # Входные данные\n    A = 0                 # Временные данные (константа, обычно обозначается заглавной буквой)\n    b = 0                 # Временные данные (переменная)\n    node = Node(0)        # Временные данные (объект)\n    c = function()        # Пространство кадра стека (вызов функции)\n    return A + b + c      # Выходные данные\n</code></pre> <pre><code>/* Структура */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Функция */\nint func() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) {        // Входные данные\n    const int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node* node = new Node(0); // Временные данные (объект)\n    int c = func();           // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Функция */\nint function() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) {        // Входные данные\n    final int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node node = new Node(0);  // Временные данные (объект)\n    int c = function();       // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* Функция */\nint Function() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint Algorithm(int n) {        // Входные данные\n    const int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node node = new(0);       // Временные данные (объект)\n    int c = Function();       // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Структура */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Создать структуру node */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* Функция */\nfunc function() int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfunc algorithm(n int) int { // Входные данные\n    const a = 0             // Временные данные (константа)\n    b := 0                  // Временные данные (переменная)\n    newNode(0)              // Временные данные (объект)\n    c := function()         // Пространство кадра стека (вызов функции)\n    return a + b + c        // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Функция */\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // Входные данные\n    let a = 0             // Временные данные (константа)\n    var b = 0             // Временные данные (переменная)\n    let node = Node(x: 0) // Временные данные (объект)\n    let c = function()    // Пространство кадра стека (вызов функции)\n    return a + b + c      // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.next = null;                       // Ссылка на следующий узел\n    }\n}\n\n/* Функция */\nfunction constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\nfunction algorithm(n) {       // Входные данные\n    const a = 0;              // Временные данные (константа)\n    let b = 0;                // Временные данные (переменная)\n    const node = new Node(0); // Временные данные (объект)\n    const c = constFunc();    // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.next = null;                       // Ссылка на следующий узел\n    }\n}\n\n/* Функция */\nfunction constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n\nfunction algorithm(n: number): number { // Входные данные\n    const a = 0;                        // Временные данные (константа)\n    let b = 0;                          // Временные данные (переменная)\n    const node = new Node(0);           // Временные данные (объект)\n    const c = constFunc();              // Пространство кадра стека (вызов функции)\n    return a + b + c;                   // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Функция */\nint function() {\n  // Выполнить некоторые операции...\n  return 0;\n}\n\nint algorithm(int n) {  // Входные данные\n  const int a = 0;      // Временные данные (константа)\n  int b = 0;            // Временные данные (переменная)\n  Node node = Node(0);  // Временные данные (объект)\n  int c = function();   // Пространство кадра стека (вызов функции)\n  return a + b + c;     // Выходные данные\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Создать структуру Node */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Функция */\nfn function() -&gt; i32 {      \n    // Выполнить некоторые операции...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // Входные данные\n    const a: i32 = 0;               // Временные данные (константа)\n    let mut b = 0;                  // Временные данные (переменная)\n    let node = Node::new(0);        // Временные данные (объект)\n    let c = function();             // Пространство кадра стека (вызов функции)\n    return a + b + c;               // Выходные данные\n}\n</code></pre> <pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) { // Входные данные\n    const int a = 0;   // Временные данные (константа)\n    int b = 0;         // Временные данные (переменная)\n    int c = func();    // Пространство кадра стека (вызов функции)\n    return a + b + c;  // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* Функция */\nfun function(): Int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // Входные данные\n    val a = 0                // Временные данные (константа)\n    var b = 0                // Временные данные (переменная)\n    val node = Node(0)       // Временные данные (объект)\n    val c = function()       // Пространство кадра стека (вызов функции)\n    return a + b + c         // Выходные данные\n}\n</code></pre> <pre><code>### Класс ###\nclass Node\n    attr_accessor :val      # Значение узла\n    attr_accessor :next     # Ссылка на следующий узел\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### Функция ###\ndef function\n    # Выполнить некоторые операции...\n    0\nend\n\n### Алгоритм ###\ndef algorithm(n)        # Входные данные\n    a = 0               # Временные данные (константа)\n    b = 0               # Временные данные (переменная)\n    node = Node.new(0)  # Временные данные (объект)\n    c = function        # Пространство кадра стека (вызов функции)\n    a + b + c           # Выходные данные\nend\n</code></pre>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   Метод вывода","text":"<p>Метод вывода пространственной сложности в целом аналогичен выводу временной сложности: меняется только объект подсчета, с количества операций на размер используемого пространства.</p> <p>В отличие от временной сложности, обычно рассматривается только худшая пространственная сложность. Это связано с тем, что память является жестким ограничением: необходимо гарантировать, что для любых входных данных у программы будет достаточно памяти.</p> <p>Рассмотрим следующий код. Понятие худшей пространственной сложности здесь имеет два значения.</p> <ol> <li>Ориентир на худшие входные данные: когда \\(n &lt; 10\\) , пространственная сложность равна \\(O(1)\\) ; но когда \\(n &gt; 10\\) , инициализированный массив <code>nums</code> занимает \\(O(n)\\) пространства, поэтому худшая пространственная сложность равна \\(O(n)\\) .</li> <li>Ориентир на пиковое использование памяти во время выполнения: например, до выполнения последней строки программа занимает \\(O(1)\\) пространства; при инициализации массива <code>nums</code> она занимает \\(O(n)\\) пространства, поэтому худшая пространственная сложность также равна \\(O(n)\\) .</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>В рекурсивных функциях необходимо учитывать пространство кадров стека. Рассмотрим следующий код:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # Выполнить некоторые операции\n    return 0\n\ndef loop(n: int):\n    \"\"\"Пространственная сложность цикла равна O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Пространственная сложность рекурсии равна O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Пространственная сложность цикла равна O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* Пространственная сложность рекурсии равна O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Пространственная сложность цикла равна O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* Пространственная сложность рекурсии равна O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // Выполнить некоторые операции\n  return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // Выполнить некоторые операции\n    return 0\n}\n/* Пространственная сложность цикла равна O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # Выполнить некоторые операции\n    0\nend\n\n### Пространственная сложность цикла равна O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### Пространственная сложность рекурсии равна O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>Функции <code>loop()</code> и <code>recur()</code> имеют временную сложность \\(O(n)\\) , но их пространственная сложность различается.</p> <ul> <li>Функция <code>loop()</code> вызывает <code>function()</code> в цикле \\(n\\) раз; на каждой итерации <code>function()</code> возвращается и освобождает пространство своего кадра стека, поэтому пространственная сложность по-прежнему равна \\(O(1)\\) .</li> <li>Рекурсивная функция <code>recur()</code> во время выполнения одновременно содержит \\(n\\) еще не завершившихся экземпляров <code>recur()</code> , поэтому занимает \\(O(n)\\) пространства кадров стека.</li> </ul>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   Распространенные типы","text":"<p>Пусть размер входных данных равен \\(n\\) . На рисунке 2-16 показаны распространенные типы пространственной сложности в порядке от меньшей к большей.</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{Постоянная} &lt; \\text{Логарифмическая} &lt; \\text{Линейная} &lt; \\text{Квадратичная} &lt; \\text{Экспоненциальная} \\end{aligned} \\] <p></p> <p> Рисунок 2-16   Распространенные типы пространственной сложности </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   Постоянная сложность \\(O(1)\\)","text":"<p>Постоянная сложность обычно встречается у констант, переменных и объектов, количество которых не зависит от размера входных данных \\(n\\) .</p> <p>Следует заметить, что память, занятая инициализацией переменных или вызовом функций внутри цикла, освобождается при переходе к следующей итерации, поэтому она не накапливается, и пространственная сложность по-прежнему остается \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"Функция\"\"\"\n    # Выполнить некоторые операции\n    return 0\n\ndef constant(n: int):\n    \"\"\"Постоянная сложность\"\"\"\n    # Константы, переменные и объекты занимают O(1) памяти\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # Переменные в цикле занимают O(1) памяти\n    for _ in range(n):\n        c = 0\n    # Функции в цикле занимают O(1) памяти\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Функция */\nint function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Функция */\nint Function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid Constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Функция */\nfunc function() int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\n/* Постоянная сложность */\nfunc spaceConstant(n int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // Переменные в цикле занимают O(1) памяти\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* Функция */\n@discardableResult\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Постоянная сложность */\nfunc constant(n: Int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // Переменные в цикле занимают O(1) памяти\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* Функция */\nfunction constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nfunction constant(n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Функция */\nfunction constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nfunction constant(n: number): void {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Функция */\nint function() {\n  // Выполнить некоторые операции\n  return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n  // Константы, переменные и объекты занимают O(1) памяти\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // Переменные в цикле занимают O(1) памяти\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // Функции в цикле занимают O(1) памяти\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Функция */\nfn function() -&gt; i32 {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\n#[allow(unused)]\nfn constant(n: i32) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // Переменные в цикле занимают O(1) памяти\n    for i in 0..n {\n        let c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Функция */\nfun function(): Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Постоянная сложность */\nfun constant(n: Int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // Переменные в цикле занимают O(1) памяти\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Функция ###\ndef function\n  # Выполнить некоторые операции\n  0\nend\n\n### Постоянная сложность ###\ndef constant(n)\n  # Константы, переменные и объекты занимают O(1) памяти\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # Переменные в цикле занимают O(1) памяти\n  (0...n).each { c = 0 }\n  # Функции в цикле занимают O(1) памяти\n  (0...n).each { function }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   Линейная сложность \\(O(n)\\)","text":"<p>Линейная сложность часто встречается у массивов, списков, стеков, очередей и других структур, число элементов в которых пропорционально \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"Линейная сложность\"\"\"\n    # Список длины n занимает O(n) памяти\n    nums = [0] * n\n    # Хеш-таблица длины n занимает O(n) памяти\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    vector&lt;int&gt; nums(n);\n    // Список длины n занимает O(n) памяти\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int[] nums = new int[n];\n    // Список длины n занимает O(n) памяти\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Линейная сложность */\nvoid Linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int[] nums = new int[n];\n    // Список длины n занимает O(n) памяти\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Линейная сложность */\nfunc spaceLinear(n int) {\n    // Массив длины n занимает O(n) памяти\n    _ = make([]int, n)\n    // Список длины n занимает O(n) памяти\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Линейная сложность */\nfunc linear(n: Int) {\n    // Массив длины n занимает O(n) памяти\n    let nums = Array(repeating: 0, count: n)\n    // Список длины n занимает O(n) памяти\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // Хеш-таблица длины n занимает O(n) памяти\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* Линейная сложность */\nfunction linear(n) {\n    // Массив длины n занимает O(n) памяти\n    const nums = new Array(n);\n    // Список длины n занимает O(n) памяти\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Линейная сложность */\nfunction linear(n: number): void {\n    // Массив длины n занимает O(n) памяти\n    const nums = new Array(n);\n    // Список длины n занимает O(n) памяти\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n  // Массив длины n занимает O(n) памяти\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // Список длины n занимает O(n) памяти\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // Хеш-таблица длины n занимает O(n) памяти\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Линейная сложность */\n#[allow(unused)]\nfn linear(n: i32) {\n    // Массив длины n занимает O(n) памяти\n    let mut nums = vec![0; n as usize];\n    // Список длины n занимает O(n) памяти\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Хеш-таблица */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Реализовано на основе uthash.h\n} HashTable;\n\n/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // Список длины n занимает O(n) памяти\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // Освобождение памяти\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // Хеш-таблица длины n занимает O(n) памяти\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // Освобождение памяти\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Линейная сложность */\nfun linear(n: Int) {\n    // Массив длины n занимает O(n) памяти\n    val nums = Array(n) { 0 }\n    // Список длины n занимает O(n) памяти\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  # Список длины n занимает O(n) памяти\n  nums = Array.new(n, 0)\n\n  # Хеш-таблица длины n занимает O(n) памяти\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 2-17, глубина рекурсии этой функции равна \\(n\\) , то есть одновременно существует \\(n\\) еще не завершившихся функций <code>linear_recur()</code> , которые используют \\(O(n)\\) пространства кадров стека:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"Линейная сложность (рекурсивная реализация)\"\"\"\n    print(\"Рекурсия n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"Рекурсия n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    System.out.println(\"Рекурсия n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"Рекурсия n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"Рекурсия n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunc linearRecur(n: Int) {\n    print(\"Рекурсия n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunction linearRecur(n) {\n    console.log(`Рекурсия n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunction linearRecur(n: number): void {\n    console.log(`Рекурсия n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n  print('Рекурсия n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfn linear_recur(n: i32) {\n    println!(\"Рекурсия n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    printf(\"Рекурсия n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfun linearRecur(n: Int) {\n    println(\"Рекурсия n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  # Список длины n занимает O(n) памяти\n  nums = Array.new(n, 0)\n\n  # Хеш-таблица длины n занимает O(n) памяти\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n\n# ## Линейная сложность (рекурсивная реализация) ###\ndef linear_recur(n)\n  puts \"Рекурсия n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-17   Линейная пространственная сложность, порождаемая рекурсивной функцией </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   Квадратичная сложность \\(O(n^2)\\)","text":"<p>Квадратичная сложность часто встречается у матриц и графов, где число элементов связано с \\(n\\) квадратичной зависимостью:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"Квадратичная сложность\"\"\"\n    # Двумерный список занимает O(n^2) памяти\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Двумерный список занимает O(n^2) памяти\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Матрица занимает O(n^2) памяти\n    int[][] numMatrix = new int[n][n];\n    // Двумерный список занимает O(n^2) памяти\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Квадратичная сложность */\nvoid Quadratic(int n) {\n    // Матрица занимает O(n^2) памяти\n    int[,] numMatrix = new int[n, n];\n    // Двумерный список занимает O(n^2) памяти\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Квадратичная сложность */\nfunc spaceQuadratic(n int) {\n    // Матрица занимает O(n^2) памяти\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Квадратичная сложность */\nfunc quadratic(n: Int) {\n    // Двумерный список занимает O(n^2) памяти\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* Квадратичная сложность */\nfunction quadratic(n) {\n    // Матрица занимает O(n^2) памяти\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // Двумерный список занимает O(n^2) памяти\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Квадратичная сложность */\nfunction quadratic(n: number): void {\n    // Матрица занимает O(n^2) памяти\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // Двумерный список занимает O(n^2) памяти\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n  // Матрица занимает O(n^2) памяти\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // Двумерный список занимает O(n^2) памяти\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Квадратичная сложность */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // Матрица занимает O(n^2) памяти\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // Двумерный список занимает O(n^2) памяти\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Двумерный список занимает O(n^2) памяти\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // Освобождение памяти\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* Квадратичная сложность */\nfun quadratic(n: Int) {\n    // Матрица занимает O(n^2) памяти\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // Двумерный список занимает O(n^2) памяти\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 2-18, глубина рекурсии этой функции равна \\(n\\) , и в каждой рекурсивной функции инициализируется массив длины \\(n\\) , \\(n-1\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) ; его средняя длина равна \\(n / 2\\) , поэтому в сумме используется \\(O(n^2)\\) пространства:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"Квадратичная сложность (рекурсивная реализация)\"\"\"\n    if n &lt;= 0:\n        return 0\n    # Длина массива nums равна n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"Рекурсия n = \" &lt;&lt; n &lt;&lt; \" , длина nums = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"В рекурсии n = \" + n + \", длина nums = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"В рекурсии n = \" + n + \", длина nums = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"В рекурсии n = %d, длина nums = %d\\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"В рекурсии n = \\(n), длина nums = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`В рекурсии n = ${n} длина nums = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`В рекурсии n = ${n} длина nums = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('В рекурсии n = $n длина nums = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"В рекурсии n = {} , длина nums = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"Рекурсия n = %d, длина nums = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"В рекурсии n = $n длина nums = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## Квадратичная сложность (рекурсивная реализация) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Длина массива nums равна n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-18   Квадратичная пространственная сложность, порождаемая рекурсивной функцией </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   Экспоненциальная сложность \\(O(2^n)\\)","text":"<p>Экспоненциальная сложность часто встречается у бинарных деревьев. Полное бинарное дерево с \\(n\\) уровнями содержит \\(2^n - 1\\) узлов и занимает \\(O(2^n)\\) пространства:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"Экспоненциальная сложность (построение полного двоичного дерева)\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## Квадратичная сложность (рекурсивная реализация) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Длина массива nums равна n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n\n# ## Экспоненциальная сложность (построение полного двоичного дерева) ###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-19   Экспоненциальная пространственная сложность, порождаемая полным бинарным деревом </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   Логарифмическая сложность \\(O(\\log n)\\)","text":"<p>Логарифмическая сложность часто встречается в алгоритмах \"разделяй и властвуй\". Например, при сортировке слиянием входной массив длины \\(n\\) на каждом шаге рекурсии делится пополам, образуя рекурсивное дерево высоты \\(\\log n\\) и используя \\(O(\\log n)\\) пространства кадров стека.</p> <p>Еще один пример - преобразование числа в строку. Если задано положительное целое число \\(n\\) , то количество его цифр равно \\(\\lfloor \\log_{10} n \\rfloor + 1\\) , то есть длина соответствующей строки тоже равна \\(\\lfloor \\log_{10} n \\rfloor + 1\\) , следовательно, пространственная сложность составляет \\(O(\\log_{10} n + 1) = O(\\log n)\\) .</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   Компромисс между временем и пространством","text":"<p>В идеальных условиях хотелось бы, чтобы и временная, и пространственная сложность алгоритма были оптимальными. Однако на практике одновременно оптимизировать и время, и память обычно очень трудно.</p> <p>Снижение временной сложности обычно достигается ценой увеличения пространственной сложности, и наоборот. Подход, при котором жертвуют памятью ради ускорения работы алгоритма, называется обменом пространства на время; обратный подход называется обменом времени на пространство.</p> <p>Выбор между этими двумя идеями зависит от того, что важнее в конкретной задаче. В большинстве случаев время ценнее памяти, поэтому стратегия обмена пространства на время используется чаще. Но при очень больших объемах данных контроль пространственной сложности тоже становится крайне важным.</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   Резюме","text":"","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<p>Оценка эффективности алгоритмов</p> <ul> <li>Временная и пространственная эффективность являются двумя основными критериями для оценки качества алгоритмов.</li> <li>Эффективность алгоритмов можно оценивать с помощью практических тестов, однако это сложно из-за влияния тестовой среды и значительных затрат вычислительных ресурсов.</li> <li>Анализ сложности позволяет устранить недостатки практических тестов, а результаты анализа применимы ко всем платформам и могут выявить эффективность алгоритма при различных объемах данных.</li> </ul> <p>Временная сложность</p> <ul> <li>Временная сложность используется для оценки тенденции изменения времени выполнения алгоритма с увеличением объема данных, что позволяет оценивать его эффективность. Однако в некоторых случаях она может работать не так хорошо, например когда объем входных данных мал или временная сложность одинакова, что не позволяет точно сравнить эффективность алгоритмов.</li> <li>Худшая временная сложность обозначается символом Big \\(O\\) и соответствует асимптотической верхней границе, отражая уровень роста количества операций \\(T(n)\\) при стремлении \\(n\\) к бесконечности.</li> <li>Определение временной сложности включает два этапа: сначала подсчитывается количество операций, затем определяется асимптотическая верхняя граница.</li> <li>Наиболее распространенные временные сложности в порядке возрастания: \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\) и \\(O(n!)\\).</li> <li>Временная сложность некоторых алгоритмов не является фиксированной и зависит от распределения входных данных. Временная сложность делится на худшую, лучшую и среднюю. Лучшая временная сложность почти не используется, так как для достижения лучшего случая входные данные должны соответствовать строгим критериям.</li> <li>Средняя временная сложность отражает эффективность алгоритма при случайных входных данных и наиболее близка к реальной производительности алгоритма. Для расчета средней временной сложности необходимо учитывать распределение входных данных и математическое ожидание.</li> </ul> <p>Пространственная сложность</p> <ul> <li>Пространственная сложность аналогична временной сложности и используется для оценки тенденции изменения объема памяти, занимаемой алгоритмом, с увеличением объема данных.</li> <li>Память, используемую в процессе выполнения алгоритма, можно разделить на входное пространство, временное пространство и выходное пространство. Обычно при расчете пространственной сложности входное пространство не учитывается. Временное пространство делится на временные данные, пространство стека и пространство инструкций, причем пространство стека обычно влияет на сложность только в рекурсивных функциях.</li> <li>Обычно рассматривается только худшая пространственная сложность, то есть пространственная сложность алгоритма при худших входных данных и в худший момент выполнения.</li> <li>Наиболее распространенные пространственные сложности в порядке возрастания: \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\) и \\(O(2^n)\\).</li> </ul>","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Является ли пространственная сложность хвостовой рекурсии равной \\(O(1)\\)?</p> <p>Теоретически пространственную сложность хвостово-рекурсивных функций можно оптимизировать до \\(O(1)\\) . Однако большинство языков программирования (например Java, Python, C++, Go, C# и другие) не поддерживают автоматическую оптимизацию хвостовой рекурсии, поэтому на практике пространственная сложность обычно считается равной \\(O(n)\\) .</p> <p>Q: В чем разница между терминами function и method?</p> <p>Функция (function) может выполняться независимо, и все ее параметры передаются явно. Метод (method) связан с объектом, неявно получает объект, который его вызывает, и может работать с данными, содержащимися в экземпляре класса.</p> <p>Ниже это проиллюстрировано на примере нескольких распространенных языков программирования.</p> <ul> <li>C - процедурный язык программирования без объектно-ориентированной модели, поэтому в нем есть только функции. Однако мы можем имитировать объектно-ориентированное программирование через структуры (<code>struct</code>), и функции, связанные со структурами, эквивалентны методам в других языках.</li> <li>Java и C# - объектно-ориентированные языки программирования, в которых блоки кода (методы) обычно являются частью класса. Статические методы по поведению похожи на функции, потому что они привязаны к классу и не могут обращаться к конкретным переменным экземпляра.</li> <li>C++ и Python поддерживают как процедурное программирование (функции), так и объектно-ориентированное программирование (методы).</li> </ul> <p>Q: Отражает ли диаграмма \"распространенных типов пространственной сложности\" абсолютный размер занятой памяти?</p> <p>Нет, эта диаграмма показывает пространственную сложность, а значит отражает именно тенденцию роста, а не абсолютный объем занятого пространства.</p> <p>Если взять \\(n = 8\\) , можно заметить, что значения на кривых не совпадают напрямую с соответствующими функциями. Это связано с тем, что каждая кривая содержит константный член, который сжимает диапазон значений до визуально удобного масштаба.</p> <p>На практике, поскольку мы обычно не знаем, какова \"константная\" сложность каждого метода, только по сложности мы, как правило, не можем выбрать оптимальное решение для случая \\(n = 8\\) . Но для \\(n = 8^5\\) выбор уже очевиден: в этой области доминирует именно тенденция роста.</p> <p>Q: Бывают ли случаи, когда в реальных сценариях алгоритм специально проектируют так, чтобы жертвовать временем ради пространства или пространством ради времени?</p> <p>На практике в большинстве случаев выбирают обмен пространства на время. Например, для индексов в базах данных обычно строят B+ деревья или хеш-индексы, расходуя значительный объем памяти ради эффективных запросов уровня \\(O(\\log n)\\) или даже \\(O(1)\\).</p> <p>В сценариях, где память особенно дорога, наоборот, могут жертвовать временем ради пространства. Например, в embedded-разработке память устройства очень ограничена, поэтому инженеры могут отказаться от хеш-таблиц и выбрать последовательный поиск по массиву, экономя память ценой более медленного поиска.</p>","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   Временная сложность","text":"<p>Время выполнения действительно может наглядно и точно отражать эффективность алгоритма. Но если мы захотим точно оценить время работы некоторого фрагмента кода, то столкнемся со следующими шагами.</p> <ol> <li>Определить платформу выполнения, включая конфигурацию оборудования, язык программирования, системную среду и т.д., поскольку все эти факторы влияют на эффективность выполнения кода.</li> <li>Оценить время выполнения различных вычислительных операций, например операция сложения <code>+</code> требует 1 нс , операция умножения <code>*</code> требует 10 нс , операция вывода <code>print()</code> требует 5 нс и т.д.</li> <li>Подсчитать все вычислительные операции в коде и суммировать время выполнения всех операций, чтобы получить общее время работы.</li> </ol> <p>Например, в следующем коде размер входных данных равен \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># На некоторой платформе выполнения\ndef algorithm(n: int):\n    a = 2      # 1 нс\n    a = a + 1  # 1 нс\n    a = a * 2  # 10 нс\n    # Цикл выполняется n раз\n    for _ in range(n):  # 1 нс\n        print(0)        # 5 нс\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        System.out.println(0);     // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid Algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        Console.WriteLine(0);      // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunc algorithm(n int) {\n    a := 2     // 1 нс\n    a = a + 1  // 1 нс\n    a = a * 2  // 10 нс\n    // Цикл выполняется n раз\n    for i := 0; i &lt; n; i++ {  // 1 нс\n        fmt.Println(a)        // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunc algorithm(n: Int) {\n    var a = 2 // 1 нс\n    a = a + 1 // 1 нс\n    a = a * 2 // 10 нс\n    // Цикл выполняется n раз\n    for _ in 0 ..&lt; n { // 1 нс\n        print(0) // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunction algorithm(n) {\n    var a = 2; // 1 нс\n    a = a + 1; // 1 нс\n    a = a * 2; // 10 нс\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++) { // 1 нс\n        console.log(0); // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 нс\n    a = a + 1; // 1 нс\n    a = a * 2; // 10 нс\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++) { // 1 нс\n        console.log(0); // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n  int a = 2; // 1 нс\n  a = a + 1; // 1 нс\n  a = a * 2; // 10 нс\n  // Цикл выполняется n раз\n  for (int i = 0; i &lt; n; i++) { // 1 нс\n    print(0); // 5 нс\n  }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 нс\n    a = a + 1;          // 1 нс\n    a = a * 2;          // 10 нс\n    // Цикл выполняется n раз\n    for _ in 0..n {     // 1 нс\n        println!(\"{}\", 0);  // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // 1 нс\n        printf(\"%d\", 0);            // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfun algorithm(n: Int) {\n    var a = 2 // 1 нс\n    a = a + 1 // 1 нс\n    a = a * 2 // 10 нс\n    // Цикл выполняется n раз\n    for (i in 0..&lt;n) {  // 1 нс\n        println(0)      // 5 нс\n    }\n}\n</code></pre> <pre><code># На некоторой платформе выполнения\ndef algorithm(n)\n    a = 2       # 1 нс\n    a = a + 1   # 1 нс\n    a = a * 2   # 10 нс\n    # Цикл выполняется n раз\n    (0...n).each do # 1 нс\n        puts 0      # 5 нс\n    end\nend\n</code></pre> <p>Согласно приведенному выше методу, время работы алгоритма равно \\((6n + 12)\\) нс :</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>Но на практике подсчитывать реальное время выполнения алгоритма и неразумно, и нереалистично. Во-первых, мы не хотим привязывать оценку времени к конкретной платформе, потому что алгоритм должен запускаться на самых разных платформах. Во-вторых, нам трудно определить время выполнения каждого типа операций, а это делает точную оценку крайне затруднительной.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   Подсчет тенденции роста времени","text":"<p>Анализ временной сложности оценивает не само время выполнения алгоритма, а тенденцию роста этого времени по мере увеличения объема данных.</p> <p>Понятие \"тенденции роста времени\" выглядит довольно абстрактным, поэтому разберем его на примере. Предположим, размер входных данных равен \\(n\\) , и даны три алгоритма <code>A</code> , <code>B</code> и <code>C</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Временная сложность алгоритма A: постоянная\ndef algorithm_A(n: int):\n    print(0)\n# Временная сложность алгоритма B: линейная\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Временная сложность алгоритма C: постоянная\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Временная сложность алгоритма B: линейная\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Временная сложность алгоритма B: линейная\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// Временная сложность алгоритма C: постоянная\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Временная сложность алгоритма B: линейная\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Временная сложность алгоритма B: линейная\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithmA(int n) {\n  print(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Временная сложность алгоритма B: линейная\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// Временная сложность алгоритма B: линейная\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># Временная сложность алгоритма A: постоянная\ndef algorithm_A(n)\n    puts 0\nend\n\n# Временная сложность алгоритма B: линейная\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# Временная сложность алгоритма C: постоянная\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>Ниже показаны временные сложности трех приведенных выше функций.</p> <ul> <li>У алгоритма <code>A</code> есть только одна операция вывода, и время его работы не растет с увеличением \\(n\\) . Такую временную сложность называют постоянной.</li> <li>В алгоритме <code>B</code> операция вывода выполняется в цикле \\(n\\) раз, поэтому время работы растет линейно по мере увеличения \\(n\\) . Такая временная сложность называется линейной.</li> <li>В алгоритме <code>C</code> операция вывода выполняется \\(1000000\\) раз; хотя время работы велико, оно не зависит от размера входных данных \\(n\\) . Поэтому временная сложность <code>C</code> такая же, как у <code>A</code> , и тоже является постоянной.</li> </ul> <p></p> <p> Рисунок 2-7   Тенденции роста времени для алгоритмов A, B и C </p> <p>Какие особенности имеет анализ временной сложности по сравнению с непосредственным измерением времени работы алгоритма?</p> <ul> <li>Временная сложность позволяет эффективно оценивать эффективность алгоритма. Например, время работы алгоритма <code>B</code> растет линейно: при \\(n &gt; 1\\) он медленнее алгоритма <code>A</code> , а при \\(n &gt; 1000000\\) медленнее алгоритма <code>C</code> . Если размер входных данных достаточно велик, алгоритм с постоянной сложностью обязательно лучше алгоритма с линейной сложностью. В этом и состоит смысл тенденции роста времени.</li> <li>Метод вывода временной сложности проще. Платформа выполнения и тип вычислительных операций не влияют на тенденцию роста времени работы алгоритма. Поэтому в анализе временной сложности можно считать время выполнения всех вычислительных операций одинаковым единичным временем и тем самым упростить подсчет времени выполнения до подсчета количества операций.</li> <li>У временной сложности есть и определенные ограничения. Например, хотя временная сложность алгоритмов <code>A</code> и <code>C</code> одинакова, их реальное время выполнения сильно различается. Точно так же, хотя временная сложность <code>B</code> выше, чем у <code>C</code> , при малых \\(n\\) алгоритм <code>B</code> очевидно лучше <code>C</code> . Несмотря на эти ограничения, анализ сложности все равно остается самым эффективным и самым распространенным способом оценки алгоритмов.</li> </ul>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   Асимптотическая верхняя граница функции","text":"<p>Для функции с входным размером \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Цикл выполняется n раз\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // +1 (каждый раз выполняется i ++)\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Цикл выполняется n раз\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Цикл выполняется n раз\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++){ // +1 (каждый раз выполняется i ++)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++){ // +1 (каждый раз выполняется i ++)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Цикл выполняется n раз\n  for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Цикл выполняется n раз\n    for _ in 0..n { // +1 (каждый раз выполняется i ++)\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // +1 (каждый раз выполняется i ++)\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Цикл выполняется n раз\n    for (i in 0..&lt;n) { // +1 (каждый раз выполняется i ++)\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # Цикл выполняется n раз\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>Пусть количество операций алгоритма является функцией от размера входных данных \\(n\\) и обозначается как \\(T(n)\\) ; тогда для приведенной выше функции число операций равно:</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) - линейная функция, а это означает, что тенденция роста времени работы линейна, следовательно, временная сложность здесь тоже линейна.</p> <p>Линейную временную сложность записывают как \\(O(n)\\) ; этот математический символ называется нотацией Big \\(O\\) (big-\\(O\\) notation) и обозначает асимптотическую верхнюю границу (asymptotic upper bound) функции \\(T(n)\\) .</p> <p>Иными словами, анализ временной сложности сводится к определению асимптотической верхней границы числа операций \\(T(n)\\), и у этого понятия есть строгое математическое определение.</p> <p>Асимптотическая верхняя граница функции</p> <p>Если существуют положительное действительное число \\(c\\) и действительное число \\(n_0\\) , такие что для всех \\(n &gt; n_0\\) выполняется \\(T(n) \\leq c \\cdot f(n)\\) , то можно считать, что \\(f(n)\\) задает асимптотическую верхнюю границу для \\(T(n)\\) ; это записывается как \\(T(n) = O(f(n))\\) .</p> <p>Как показано на рисунке 2-8, вычислить асимптотическую верхнюю границу - значит найти такую функцию \\(f(n)\\) , что при стремлении \\(n\\) к бесконечности функции \\(T(n)\\) и \\(f(n)\\) имеют один и тот же порядок роста и отличаются только постоянным коэффициентом \\(c\\).</p> <p></p> <p> Рисунок 2-8   Асимптотическая верхняя граница функции </p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   Метод вывода","text":"<p>Математическое определение асимптотической верхней границы выглядит довольно формально, и если оно пока не до конца понятно, переживать не стоит. Сначала можно освоить сам метод вывода, а в процессе дальнейшей практики постепенно почувствовать его математический смысл.</p> <p>Согласно определению, после того как мы определили \\(f(n)\\) , можно получить временную сложность \\(O(f(n))\\) . Но как определить саму асимптотическую верхнюю границу \\(f(n)\\) ? В целом процесс состоит из двух шагов: сначала подсчитать количество операций, затем определить асимптотическую верхнюю границу.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-1","level":3,"title":"1.   Шаг 1: подсчет количества операций","text":"<p>Для кода это можно делать построчно сверху вниз. Однако, поскольку в выражении \\(c \\cdot f(n)\\) постоянный коэффициент \\(c\\) может быть сколь угодно большим, различные коэффициенты и постоянные члены в числе операций \\(T(n)\\) можно игнорировать. Исходя из этого принципа, можно сформулировать следующие упрощающие приемы подсчета.</p> <ol> <li>Игнорировать константы в \\(T(n)\\). Они не зависят от \\(n\\) , а значит не влияют на временную сложность.</li> <li>Опускать все коэффициенты. Например, циклы на \\(2n\\) раз или \\(5n + 1\\) раз можно упростить до \\(n\\) раз, потому что коэффициент перед \\(n\\) не влияет на временную сложность.</li> <li>При вложенных циклах использовать умножение. Общее число операций равно произведению числа операций внешнего и внутреннего циклов; при этом для каждого уровня цикла по-прежнему можно применять приемы из пунктов <code>1.</code> и <code>2.</code> .</li> </ol> <p>Для заданной функции мы можем использовать перечисленные выше приемы и подсчитать число операций:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0 (прием 1)\n    a = a + n  # +0 (прием 1)\n    # +n (прием 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (прием 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0 (прием 1)\n    a = a + n  // +0 (прием 1)\n    // +n (прием 2)\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (прием 3)\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0 (прием 1)\n    a = a + n // +0 (прием 1)\n    // +n (прием 2)\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (прием 3)\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (прием 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (прием 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0 (прием 1)\n  a = a + n; // +0 (прием 1)\n  // +n (прием 2)\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (прием 3)\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (прием 1)\n    a = a + n;        // +0 (прием 1)\n\n    // +n (прием 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (прием 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0 (прием 1)\n    a = a + n   // +0 (прием 1)\n    // +n (прием 2)\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n (прием 3)\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0 (прием 1)\n    a = a + n   # +0 (прием 1)\n    # +n (прием 2)\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n (прием 3)\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>Следующая формула показывает результаты подсчета до и после использования перечисленных выше приемов; в обоих случаях выводимая временная сложность равна \\(O(n^2)\\) .</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{полный подсчет (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{ленивый подсчет (o.O)} \\end{aligned} \\]","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-2","level":3,"title":"2.   Шаг 2: определение асимптотической верхней границы","text":"<p>**Временная сложность определяется старшим по степени членом в \\(T(n)\\) **. Это связано с тем, что при стремлении \\(n\\) к бесконечности именно старший член начинает доминировать, а влиянием остальных членов можно пренебречь.</p> <p>В таблице 2-2 приведены несколько примеров. Некоторые значения специально сделаны преувеличенными, чтобы подчеркнуть вывод: коэффициент не способен изменить порядок. Когда \\(n\\) стремится к бесконечности, эти константы становятся несущественными.</p> <p> Таблица 2-2   Временная сложность, соответствующая разному количеству операций </p> Число операций \\(T(n)\\) Временная сложность \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   Распространенные типы","text":"<p>Пусть размер входных данных равен \\(n\\) ; распространенные типы временной сложности показаны на рисунке 2-9 в порядке от меньшей к большей.</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{Постоянная} &lt; \\text{Логарифмическая} &lt; \\text{Линейная} &lt; \\text{Линейно-логарифмическая} &lt; \\text{Квадратичная} &lt; \\text{Экспоненциальная} &lt; \\text{Факториальная} \\end{aligned} \\] <p></p> <p> Рисунок 2-9   Распространенные типы временной сложности </p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   Постоянная сложность \\(O(1)\\)","text":"<p>Число операций при постоянной сложности не зависит от размера входных данных \\(n\\) , то есть не изменяется вместе с изменением \\(n\\) .</p> <p>В следующей функции, хотя число операций <code>size</code> может быть большим, оно не зависит от размера входных данных \\(n\\) , поэтому временная сложность по-прежнему равна \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"Постоянная сложность\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Постоянная сложность */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Постоянная сложность */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Постоянная сложность */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Постоянная сложность */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Постоянная сложность */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Постоянная сложность */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Постоянная сложность */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Постоянная сложность */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Постоянная сложность ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   Линейная сложность \\(O(n)\\)","text":"<p>Линейная сложность характеризуется тем, что число операций растет линейно относительно размера входных данных \\(n\\) . Линейная сложность обычно встречается в одноуровневых циклах:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"Линейная сложность\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейная сложность */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейная сложность */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейная сложность */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейная сложность */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейная сложность */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейная сложность */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейная сложность */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейная сложность */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Операции обхода массива и обхода связного списка имеют временную сложность \\(O(n)\\) , где \\(n\\) - длина массива или списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"Линейная сложность (обход массива)\"\"\"\n    count = 0\n    # Число итераций пропорционально длине массива\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейная сложность (обход массива) */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейная сложность (обход массива) */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // Число итераций пропорционально длине массива\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейная сложность (обход массива) */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // Число итераций пропорционально длине массива\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейная сложность (обход массива) */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // Число итераций пропорционально длине массива\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейная сложность (обход массива) */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // Число итераций пропорционально длине массива\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // Число итераций пропорционально длине массива\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейная сложность (обход массива) */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // Число итераций пропорционально длине массива\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейная сложность (обход массива) */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // Число итераций пропорционально длине массива\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n\n# ## Линейная сложность (обход массива) ###\ndef array_traversal(nums)\n  count = 0\n\n  # Число итераций пропорционально длине массива\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Стоит отметить, что размер входных данных \\(n\\) нужно определять конкретно в зависимости от типа входа. Например, в первом примере переменная \\(n\\) сама является размером входных данных; во втором примере размером данных служит длина массива.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   Квадратичная сложность \\(O(n^2)\\)","text":"<p>Квадратичная сложность характеризуется тем, что число операций растет квадратично относительно размера входных данных \\(n\\) . Квадратичная сложность обычно встречается во вложенных циклах: временная сложность внешнего и внутреннего циклов равна \\(O(n)\\) , поэтому общая временная сложность составляет \\(O(n^2)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"Квадратичная сложность\"\"\"\n    count = 0\n    # Число итераций квадратично зависит от размера данных n\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Квадратичная сложность */\nint Quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Квадратичная сложность */\nfunc quadratic(n int) int {\n    count := 0\n    // Число итераций квадратично зависит от размера данных n\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Квадратичная сложность */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // Число итераций квадратично зависит от размера данных n\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Квадратичная сложность */\nfunction quadratic(n) {\n    let count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Квадратичная сложность */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n  int count = 0;\n  // Число итераций квадратично зависит от размера данных n\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Квадратичная сложность */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Квадратичная сложность */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // Число итераций квадратично зависит от размера данных n\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 2-10 сравниваются три временные сложности: постоянная, линейная и квадратичная.</p> <p></p> <p> Рисунок 2-10   Постоянная, линейная и квадратичная временная сложность </p> <p>Возьмем в качестве примера пузырьковую сортировку: внешний цикл выполняется \\(n - 1\\) раз, внутренний цикл выполняется \\(n-1\\) , \\(n-2\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) раз, в среднем это \\(n / 2\\) раз, поэтому временная сложность равна \\(O((n - 1)n / 2) = O(n^2)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"Квадратичная сложность (пузырьковая сортировка)\"\"\"\n    count = 0  # Счетчик\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # Обмен элементов включает 3 элементарные операции\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(int[] nums) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint BubbleSort(int[] nums) {\n    int count = 0;  // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunc bubbleSort(nums []int) int {\n    count := 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunction bubbleSort(nums) {\n    let count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // Счетчик\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // Обмен элементов включает 3 элементарные операции\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // Счетчик\n\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   Экспоненциальная сложность \\(O(2^n)\\)","text":"<p>Типичный пример экспоненциального роста в биологии - деление клеток: в начальном состоянии есть одна клетка, после одного деления их становится 2, после двух делений - 4 и так далее; после \\(n\\) раундов деления клеток становится \\(2^n\\) .</p> <p>На рисунке 2-11 и в следующем коде моделируется процесс деления клеток; временная сложность равна \\(O(2^n)\\) . Здесь входное значение \\(n\\) обозначает число раундов деления, а возвращаемое значение <code>count</code> обозначает общее число делений.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"Экспоненциальная сложность (итеративная реализация)\"\"\"\n    count = 0\n    base = 1\n    # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-11   Экспоненциальная временная сложность </p> <p>В реальных алгоритмах экспоненциальная сложность также часто встречается в рекурсивных функциях. Например, в следующем коде процесс рекурсивно делится надвое и останавливается после \\(n\\) разбиений:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"Экспоненциальная сложность (рекурсивная реализация)\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Экспоненциальный рост происходит очень быстро и часто встречается в переборных методах, грубой силе, поиске с возвратом и тому подобных подходах. Для задач большого масштаба экспоненциальная сложность неприемлема, и обычно приходится применять динамическое программирование, жадные алгоритмы и другие стратегии.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   Логарифмическая сложность \\(O(\\log n)\\)","text":"<p>В противоположность экспоненциальной, логарифмическая сложность описывает ситуацию, когда в каждом раунде размер задачи уменьшается вдвое. Пусть размер входных данных равен \\(n\\) ; так как на каждом шаге размер уменьшается вдвое, число итераций равно \\(\\log_2 n\\) , то есть является обратной функцией к \\(2^n\\) .</p> <p>На рисунке 2-12 и в следующем коде моделируется процесс, в котором в каждом раунде размер задачи уменьшается вдвое; временная сложность равна \\(O(\\log_2 n)\\) и кратко записывается как \\(O(\\log n)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"Логарифмическая сложность (итеративная реализация)\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## Логарифмическая сложность (итеративная реализация) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-12   Логарифмическая временная сложность </p> <p>Подобно экспоненциальной сложности, логарифмическая также часто встречается в рекурсивных функциях. Следующий код формирует рекурсивное дерево высотой \\(\\log_2 n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"Логарифмическая сложность (рекурсивная реализация)\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## Логарифмическая сложность (итеративная реализация) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n\n# ## Логарифмическая сложность (рекурсивная реализация) ###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Логарифмическая сложность часто встречается в алгоритмах, основанных на стратегии \"разделяй и властвуй\", и отражает идеи разбиения на части и упрощения сложной задачи. Она растет медленно и считается одной из самых желательных временных сложностей после константной.</p> <p>Каково основание у \\(O(\\log n)\\) ?</p> <p>Точнее говоря, \"разделение на \\(m\\) частей\" соответствует временной сложности \\(O(\\log_m n)\\) . А по формуле перехода к другому основанию логарифма мы получаем равные по сложности выражения с разными основаниями:</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>Иными словами, основание \\(m\\) можно менять без влияния на сложность. Поэтому мы обычно опускаем основание \\(m\\) и напрямую записываем логарифмическую сложность как \\(O(\\log n)\\) .</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   Линейно-логарифмическая сложность \\(O(n \\log n)\\)","text":"<p>Линейно-логарифмическая сложность часто встречается в рекурсивных разбиениях, где временная сложность одного измерения равна \\(O(\\log n)\\) , а другого - \\(O(n)\\) . Соответствующий код выглядит следующим образом:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"Линейно-логарифмическая сложность\"\"\"\n    if n &lt;= 1:\n        return 1\n    # Разделение надвое: размер подзадачи уменьшается вдвое\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # Текущая подзадача содержит n операций\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейно-логарифмическая сложность */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейно-логарифмическая сложность */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейно-логарифмическая сложность */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейно-логарифмическая сложность */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейно-логарифмическая сложность */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейно-логарифмическая сложность */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейно-логарифмическая сложность */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейно-логарифмическая сложность ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 2-13 показано, как возникает линейно-логарифмическая сложность. Общее число операций на каждом уровне бинарного дерева равно \\(n\\) , а дерево имеет \\(\\log_2 n + 1\\) уровней, поэтому временная сложность равна \\(O(n \\log n)\\) .</p> <p></p> <p> Рисунок 2-13   Линейно-логарифмическая временная сложность </p> <p>Временная сложность основных алгоритмов сортировки обычно равна \\(O(n \\log n)\\) , например у быстрой сортировки, сортировки слиянием, пирамидальной сортировки и т.д.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   Факториальная сложность \\(O(n!)\\)","text":"<p>Факториальная сложность соответствует математической задаче полной перестановки. Если даны \\(n\\) попарно различных элементов, то число всех возможных перестановок равно:</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>Факториал обычно реализуют через рекурсию. Как показано на рисунке 2-14 и в следующем коде, на первом уровне происходит ветвление на \\(n\\) подзадач, на втором - на \\(n - 1\\) и так далее, пока на \\(n\\)-м уровне ветвление не прекращается:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"Факториальная сложность (рекурсивная реализация)\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # Из одного получается n\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // Из одного получается n\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // Из одного получается n\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // Из одного получается n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // Из одного получается n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // Из одного получается n\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // Из одного получается n\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // Из одного получается n\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейно-логарифмическая сложность ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n\n# ## Факториальная сложность (рекурсивная реализация) ###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # Из одного получается n\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-14   Факториальная временная сложность </p> <p>Следует отметить, что поскольку при \\(n \\geq 4\\) всегда выполняется \\(n! &gt; 2^n\\) , факториальная сложность растет еще быстрее, чем экспоненциальная, и при больших \\(n\\) становится неприемлемой.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   Худшая, лучшая и средняя временная сложность","text":"<p>Временная эффективность алгоритма часто не фиксирована, а зависит от распределения входных данных. Предположим, на вход подается массив <code>nums</code> длины \\(n\\) , состоящий из чисел от \\(1\\) до \\(n\\) , каждое из которых встречается ровно один раз; при этом порядок элементов случайно перемешан. Задача состоит в том, чтобы вернуть индекс элемента \\(1\\) . Тогда можно сделать следующие выводы.</p> <ul> <li>Когда <code>nums = [?, ?, ..., 1]</code> , то есть когда последний элемент равен \\(1\\) , нужно полностью пройти по массиву, что дает худшую временную сложность \\(O(n)\\) .</li> <li>Когда <code>nums = [1, ?, ?, ...]</code> , то есть когда первый элемент равен \\(1\\) , независимо от длины массива продолжать обход не нужно, что дает лучшую временную сложность \\(\\Omega(1)\\) .</li> </ul> <p>Худшая временная сложность соответствует асимптотической верхней границе функции и обозначается нотацией Big \\(O\\) . Соответственно, лучшая временная сложность соответствует асимптотической нижней границе функции и обозначается символом \\(\\Omega\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"Сгенерировать массив с элементами 1, 2, ..., n в случайном порядке\"\"\"\n    # Создать массив nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # Случайно перемешать элементы массива\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"Найти индекс числа 1 в массиве nums\"\"\"\n    for i in range(len(nums)):\n        # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        # Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Использовать системное время для генерации случайного seed\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // Случайно перемешать элементы массива\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // Случайно перемешать элементы массива\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // Случайно перемешать элементы массива\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // Случайно перемешать элементы массива\n    nums.shuffle()\n    return nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // Создать массив nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // Случайно перемешать элементы массива\n  nums.shuffle();\n\n  return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n    // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // Случайно перемешать элементы массива\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint *randomNumbers(int n) {\n    // Выделить память в куче (создать одномерный массив переменной длины: число элементов равно n, тип элементов — int)\n    int *nums = (int *)malloc(n * sizeof(int));\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // Случайно перемешать элементы массива\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### Создать массив с элементами: 1, 2, ..., n в случайном порядке ###\ndef random_numbers(n)\n  # Создать массив nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # Случайно перемешать элементы массива\n  nums.shuffle!\nend\n\n### Найти индекс числа 1 в массиве nums ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n    # Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Стоит отметить, что на практике лучшая временная сложность используется редко, поскольку обычно она достигается лишь с очень малой вероятностью и может вводить в заблуждение. Худшая временная сложность гораздо практичнее, потому что задает безопасную оценку эффективности и позволяет уверенно использовать алгоритм.</p> <p>Из приведенного выше примера видно, что худшая и лучшая временные сложности возникают только при особых распределениях данных; вероятность таких случаев может быть низкой, и они не всегда реально отражают эффективность алгоритма. Напротив, средняя временная сложность способна показать эффективность алгоритма на случайных входных данных и обозначается символом \\(\\Theta\\) .</p> <p>Для некоторых алгоритмов можно относительно просто вывести средний случай при случайном распределении данных. Например, в приведенном выше примере входной массив перемешан, а вероятность появления элемента \\(1\\) на любом индексе одинакова; следовательно, среднее число итераций алгоритма равно половине длины массива, то есть \\(n / 2\\) , а средняя временная сложность равна \\(\\Theta(n / 2) = \\Theta(n)\\) .</p> <p>Однако для более сложных алгоритмов вычислить среднюю временную сложность часто непросто, потому что трудно проанализировать полное математическое ожидание на заданном распределении данных. В таких случаях обычно используют худшую временную сложность как критерий оценки эффективности алгоритма.</p> <p>Почему символ \\(\\Theta\\) встречается так редко?</p> <p>Возможно, потому что символ \\(O\\) звучит слишком привычно, и мы часто используем его для обозначения средней временной сложности. Но строго говоря, это некорректно. В этой книге и в других материалах, если встретится выражение вроде \"средняя временная сложность \\(O(n)\\)\", просто понимай его как \\(\\Theta(n)\\) .</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"Глава 3.   Структуры данных","text":"<p>Abstract</p> <p>Структуры данных подобны прочному и многообразному каркасу.</p> <p>Они задают схему упорядоченной организации данных, на основе которой оживают алгоритмы.</p>","path":["Глава 3. Структуры данных","Глава 3. &nbsp; Структуры данных"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>3.1   Классификация структур данных</li> <li>3.2   Базовые типы данных</li> <li>3.3   Кодирование чисел *</li> <li>3.4   Кодирование символов *</li> <li>3.5   Резюме</li> </ul>","path":["Глава 3. Структуры данных","Глава 3. &nbsp; Структуры данных"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   Базовые типы данных","text":"<p>Когда речь заходит о данных в компьютере, мы в первую очередь вспоминаем текст, изображения, видео, звук, 3D-модели и многие другие формы представления информации. Хотя способы организации этих данных различаются, все они строятся из базовых типов данных.</p> <p>Базовые типы данных - это типы, которые процессор может обрабатывать непосредственно. В алгоритмах они используются напрямую и в основном включают следующее.</p> <ul> <li>Целочисленные типы <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> .</li> <li>Типы с плавающей точкой <code>float</code> , <code>double</code> , используемые для представления дробных чисел.</li> <li>Символьный тип <code>char</code> , используемый для представления букв, знаков препинания и даже эмодзи в разных языках.</li> <li>Логический тип <code>bool</code> , используемый для представления суждений \"да\" и \"нет\".</li> </ul> <p>Базовые типы данных хранятся в компьютере в двоичной форме. Один двоичный разряд равен \\(1\\) биту. В большинстве современных операционных систем \\(1\\) байт (byte) состоит из \\(8\\) битов (bit).</p> <p>Диапазон значений базовых типов данных зависит от объема занимаемого ими пространства. Ниже в качестве примера используется Java.</p> <ul> <li>Целочисленный тип <code>byte</code> занимает \\(1\\) байт = \\(8\\) бит и может представлять \\(2^{8}\\) чисел.</li> <li>Целочисленный тип <code>int</code> занимает \\(4\\) байта = \\(32\\) бита и может представлять \\(2^{32}\\) чисел.</li> </ul> <p>В таблице 3-1 перечислены объем памяти, диапазон значений и значения по умолчанию для различных базовых типов данных в Java. Эту таблицу не нужно заучивать наизусть; достаточно иметь общее представление и при необходимости обращаться к ней.</p> <p> Таблица 3-1   Объем памяти и диапазоны значений базовых типов данных </p> Тип Обозначение Объем памяти Минимальное значение Максимальное значение Значение по умолчанию Целые <code>byte</code> 1 байт \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 байта \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 байта \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 байт \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) Вещественные <code>float</code> 4 байта \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 байт \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) Символы <code>char</code> 2 байта \\(0\\) \\(2^{16} - 1\\) \\(0\\) Логические <code>bool</code> 1 байт \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>Обрати внимание: приведенная выше таблица относится именно к базовым типам данных Java. В каждом языке программирования свои определения типов, поэтому объем памяти, диапазон значений и значения по умолчанию могут различаться.</p> <ul> <li>В Python целочисленный тип <code>int</code> может иметь произвольный размер, ограниченный только доступной памятью; тип <code>float</code> является 64-битным числом двойной точности; типа <code>char</code> нет, а отдельный символ на деле является строкой <code>str</code> длины 1.</li> <li>В C и C++ размер базовых типов данных явно не зафиксирован и зависит от реализации и платформы. таблица 3-1 соответствует модели данных LP64 data model, используемой в 64-битных Unix-системах, включая Linux и macOS.</li> <li>Размер символа <code>char</code> в C и C++ составляет 1 байт, а в большинстве других языков программирования зависит от конкретного способа кодирования символов; подробнее это рассматривается в разделе \"Кодирование символов\".</li> <li>Хотя для представления логического значения достаточно 1 бита ( \\(0\\) или \\(1\\) ), в памяти оно обычно хранится как 1 байт. Это связано с тем, что современные CPU обычно используют 1 байт как минимальную адресуемую единицу памяти.</li> </ul> <p>Какова же связь между базовыми типами данных и структурами данных? Мы знаем, что структура данных - это способ организации и хранения данных в компьютере. Подлежащее в этой фразе - \"структура\", а не \"данные\".</p> <p>Если мы хотим представить \"ряд чисел\", то естественно подумаем об использовании массива. Это связано с тем, что линейная структура массива может выразить отношения соседства и порядка между числами, а то, что именно хранится внутри - целые <code>int</code> , вещественные <code>float</code> или символы <code>char</code> , - к \"структуре данных\" отношения не имеет.</p> <p>Иными словами, базовые типы данных задают \"тип содержимого\" данных, а структуры данных задают \"способ организации\" данных. Например, в следующем коде мы используем одну и ту же структуру данных (массив) для хранения и представления различных базовых типов данных, включая <code>int</code> , <code>float</code> , <code>char</code> , <code>bool</code> и т.д.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Инициализируем массивы с использованием различных базовых типов данных\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# В Python символы фактически являются строками длины 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Списки Python могут свободно хранить различные базовые типы данных и ссылки на объекты\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// Массивы JavaScript могут свободно хранить различные базовые типы данных и объекты\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Списки Ruby могут свободно хранить различные базовые типы данных и ссылки на объекты\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%20%D1%81%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC%20%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%B8%D1%85%20%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D1%85%20%D1%82%D0%B8%D0%BF%D0%BE%D0%B2%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20%2A%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20%2A%205%0A%20%20%20%20%23%20%D0%92%20Python%20%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D1%8B%20%D0%BD%D0%B0%20%D1%81%D0%B0%D0%BC%D0%BE%D0%BC%20%D0%B4%D0%B5%D0%BB%D0%B5%20%D1%8F%D0%B2%D0%BB%D1%8F%D1%8E%D1%82%D1%81%D1%8F%20%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B0%D0%BC%D0%B8%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%8B%201%0A%20%20%20%20characters%20%3D%20%5B%270%27%5D%20%2A%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20%2A%205%0A%20%20%20%20%23%20%D0%A1%D0%BF%D0%B8%D1%81%D0%BA%D0%B8%20%D0%B2%20Python%20%D0%BC%D0%BE%D0%B3%D1%83%D1%82%20%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%BE%20%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D1%82%D1%8C%20%D1%80%D0%B0%D0%B7%D0%BB%D0%B8%D1%87%D0%BD%D1%8B%D0%B5%20%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B8%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BD%D0%B0%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B%0A%20%20%20%20data%20%3D%20%5B0%2C%200.0%2C%20%27a%27%2C%20False%2C%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 3. Структуры данных","3.2 &nbsp; Базовые типы данных"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   Кодирование символов *","text":"<p>В компьютере все данные хранятся в виде двоичных чисел, и символьный тип данных <code>char</code> не является исключением. Для представления символов необходимо задать \"таблицу символов\", которая устанавливает взаимно-однозначное соответствие между каждым символом и двоичным числом. С помощью этой таблицы компьютер может преобразовывать двоичные числа в символы.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   Таблица символов ASCII","text":"<p>Код ASCII - это самая ранняя таблица символов; ее полное название - American Standard Code for Information Interchange (американский стандартный код обмена информацией). Для представления символов в ней используются 7 двоичных битов (нижние 7 битов одного байта), что позволяет закодировать до 128 различных символов. Как показано на рисунке 3-6, ASCII включает заглавные и строчные буквы английского алфавита, цифры 0 ~ 9, некоторые знаки препинания, а также некоторые управляющие символы (например перевод строки и табуляцию).</p> <p></p> <p> Рисунок 3-6   Таблица ASCII </p> <p>Однако код ASCII может представлять только английский язык. С развитием компьютерных технологий появилась таблица символов EASCII, способная охватывать больше языков. Она расширяет 7-битную основу ASCII до 8 битов и может представлять 256 различных символов.</p> <p>Во всем мире постепенно появились разные таблицы EASCII, подходящие для разных регионов. Первые 128 символов в этих таблицах одинаковы и соответствуют ASCII, а последние 128 символов определяются по-разному, чтобы удовлетворять потребностям разных языков.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   Таблица символов GBK","text":"<p>Позже люди обнаружили, что кодов EASCII все равно недостаточно для количества символов во многих языках. Например, китайских иероглифов существует почти сто тысяч, а в повседневном употреблении нужны тысячи. В 1980 году Государственное управление стандартов Китая выпустило таблицу символов GB2312, включающую 6763 иероглифа, что в основном удовлетворило потребности компьютерной обработки китайского текста.</p> <p>Однако GB2312 не умеет работать с некоторыми редкими иероглифами и традиционными формами письма. Таблица символов GBK представляет собой расширение GB2312 и в общей сложности содержит 21886 иероглифов. В схеме кодирования GBK символы ASCII представляются одним байтом, а китайские иероглифы - двумя байтами.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Таблица символов Unicode","text":"<p>С бурным развитием компьютерной техники таблицы символов и стандарты кодирования начали стремительно множиться, и это породило множество проблем. С одной стороны, такие таблицы обычно определяли символы только для конкретных языков и не могли нормально работать в многоязычной среде. С другой стороны, для одного и того же языка существовало несколько стандартов кодирования; если две машины использовали разные стандарты, при обмене информацией возникали искажения текста.</p> <p>Исследователи той эпохи задумались: если создать достаточно полную таблицу символов, которая включит все языки и знаки мира, разве это не решит проблемы многоязычной среды и искаженного текста? Под влиянием этой идеи и появилась большая и всеобъемлющая таблица символов Unicode.</p> <p>Unicode по-китайски называется \"единый код\" и теоретически способен вместить более миллиона символов. Его цель - собрать символы со всего мира в единую таблицу символов, предоставить универсальный стандарт для обработки и отображения текстов на разных языках и уменьшить количество проблем с искажением текста, вызванных различиями стандартов кодирования.</p> <p>С момента публикации в 1991 году Unicode непрерывно расширялся, добавляя новые языки и символы. По состоянию на сентябрь 2022 года Unicode уже включал 149186 символов, в том числе буквы разных языков, знаки, а также эмодзи. В огромной таблице символов Unicode часто используемые символы занимают 2 байта, а некоторые редкие символы - 3 байта и даже 4 байта.</p> <p>Unicode - это универсальный набор символов, который по сути просто присваивает каждому символу номер (так называемую \"кодовую точку\"), но не определяет, как именно хранить эти кодовые точки в компьютере. Тут неизбежно возникает вопрос: если в одном тексте одновременно встречаются кодовые точки Unicode разной длины, как система должна разбирать символы? Например, если дан код длиной 2 байта, как понять, является ли это одним 2-байтовым символом или двумя 1-байтовыми?</p> <p>Для этой проблемы прямолинейное решение состоит в том, чтобы хранить все символы в кодировке одинаковой длины. Как показано на рисунке 3-7, каждый символ в \"Hello\" занимает 1 байт, а каждый символ в \"алгоритм\" занимает 2 байта. Мы можем дополнить старшие биты нулями и закодировать все символы в \"Hello алгоритм\" в виде 2-байтовых единиц. Тогда система сможет считывать по одному символу каждые 2 байта и восстановить эту фразу.</p> <p></p> <p> Рисунок 3-7   Пример кодирования Unicode </p> <p>Однако ASCII уже показал нам, что для кодирования английского текста достаточно 1 байта. Если использовать описанную выше схему, английский текст будет занимать вдвое больше памяти, чем при ASCII, а это очень неэффективно. Поэтому нам нужен более эффективный способ кодирования Unicode.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   Кодировка UTF-8","text":"<p>Сегодня UTF-8 стала самым широко используемым способом кодирования Unicode в мире. Это кодировка переменной длины, использующая от 1 до 4 байт на символ в зависимости от его сложности. Символам ASCII нужен только 1 байт, латинским и греческим буквам - 2 байта, часто используемым китайским символам - 3 байта, а некоторым редким символам - 4 байта.</p> <p>Правила кодирования UTF-8 не слишком сложны и делятся на два случая.</p> <ul> <li>Для символов длиной 1 байт старший бит устанавливается в \\(0\\) , а оставшиеся 7 битов содержат кодовую точку Unicode. Стоит отметить, что символы ASCII занимают первые 128 кодовых точек в наборе Unicode. Иными словами, кодировка UTF-8 обратно совместима с ASCII. Это означает, что мы можем использовать UTF-8 для разбора очень старых ASCII-текстов.</li> <li>Для символов длиной \\(n\\) байт (где \\(n &gt; 1\\)) старшие \\(n\\) битов первого байта устанавливаются в \\(1\\) , а \\((n + 1)\\)-й бит устанавливается в \\(0\\) ; начиная со второго байта, старшие 2 бита каждого байта устанавливаются в \\(10\\) ; все остальные биты используются для заполнения кодовой точки Unicode соответствующего символа.</li> </ul> <p>На рисунке 3-8 показана UTF-8-кодировка для строки \"Hello алгоритм\". Можно заметить, что поскольку старшие \\(n\\) битов установлены в \\(1\\) , система может определить длину символа как \\(n\\) , подсчитав число ведущих единиц.</p> <p>Но почему старшие 2 бита всех остальных байтов устанавливаются в \\(10\\) ? На самом деле это \\(10\\) играет роль контрольного маркера. Если система начнет разбирать текст с неверного байта, префикс \\(10\\) поможет быстро обнаружить аномалию.</p> <p>Причина выбора \\(10\\) в качестве контрольного маркера в том, что по правилам UTF-8 символ не может иметь старшие два бита, равные \\(10\\) . Это можно доказать от противного: если предположить, что у некоторого символа старшие два бита равны \\(10\\) , то длина такого символа должна быть 1 байт, то есть это ASCII. Но у ASCII старший бит обязан быть \\(0\\) , что противоречит предположению.</p> <p></p> <p> Рисунок 3-8   Пример кодировки UTF-8 </p> <p>Помимо UTF-8, распространены еще два следующих способа кодирования.</p> <ul> <li>Кодировка UTF-16: использует 2 или 4 байта для представления символа. Все символы ASCII и часто используемые неанглийские символы представляются 2 байтами; небольшая часть символов требует 4 байта. Для 2-байтовых символов кодировка UTF-16 совпадает с кодовой точкой Unicode.</li> <li>Кодировка UTF-32: каждый символ занимает 4 байта. Это означает, что UTF-32 требует больше места, чем UTF-8 и UTF-16, особенно в текстах с большой долей ASCII-символов.</li> </ul> <p>С точки зрения занимаемого места UTF-8 очень эффективна для английских символов, потому что им нужен всего 1 байт; а для некоторых неанглийских символов (например китайских) UTF-16 может быть эффективнее, потому что ей требуется только 2 байта, тогда как UTF-8 может потребовать 3 байта.</p> <p>С точки зрения совместимости у UTF-8 наилучшая универсальность, и многие инструменты и библиотеки в первую очередь поддерживают именно UTF-8.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   Кодирование символов в языках программирования","text":"<p>Для большинства языков программирования прошлого строки во время выполнения программы использовали фиксированные по длине кодировки, такие как UTF-16 или UTF-32. При кодировке фиксированной длины строку можно обрабатывать как массив, и такой подход дает следующие преимущества.</p> <ul> <li>Произвольный доступ: к строкам в UTF-16 легко осуществлять произвольный доступ. UTF-8 же является кодировкой переменной длины, поэтому, чтобы найти \\(i\\) -й символ, нужно пройти от начала строки до этого символа, а это требует \\(O(n)\\) времени.</li> <li>Подсчет длины строки: аналогично произвольному доступу, вычисление длины строки в UTF-16 - это операция \\(O(1)\\) . А вот вычисление длины строки в UTF-8 требует обхода всей строки.</li> <li>Строковые операции: многие операции со строками (разделение, конкатенация, вставка, удаление и т.д.) над строками в UTF-16 реализуются проще. При работе с UTF-8 обычно требуются дополнительные вычисления, чтобы не породить некорректную UTF-8-последовательность.</li> </ul> <p>Вообще говоря, проектирование схем кодирования символов в языках программирования - очень интересная тема, в которой учитывается множество факторов.</p> <ul> <li>Тип <code>String</code> в Java использует кодировку UTF-16, и каждый символ занимает 2 байта. Это связано с тем, что на раннем этапе проектирования Java считалось, что 16 битов достаточно для представления всех возможных символов. Но это оказалось неверным предположением. Позднее Unicode вышел за пределы 16 битов, поэтому символы в Java теперь могут представляться парой 16-битных значений (так называемой \"суррогатной парой\").</li> <li>Строки в JavaScript и TypeScript используют UTF-16 по причинам, похожим на Java. Когда Netscape впервые выпустила JavaScript в 1995 году, Unicode еще находился на ранней стадии развития, и 16-битного кодирования тогда было достаточно для представления всех символов Unicode.</li> <li>C# использует UTF-16 главным образом потому, что платформа .NET была разработана Microsoft, а многие технологии Microsoft (включая Windows) широко используют именно UTF-16.</li> </ul> <p>Из-за недооценки общего числа символов перечисленным выше языкам пришлось использовать \"суррогатные пары\" для представления Unicode-символов длиной больше 16 бит. Это вынужденный компромисс. С одной стороны, в строках с суррогатными парами один символ может занимать 2 байта или 4 байта, из-за чего теряется преимущество кодировки фиксированной длины. С другой стороны, обработка суррогатных пар требует дополнительного кода, что повышает сложность разработки и отладки.</p> <p>По этим причинам некоторые языки программирования предложили иные схемы кодирования.</p> <ul> <li><code>str</code> в Python использует Unicode и гибкое строковое представление, где длина хранимого символа зависит от наибольшей кодовой точки Unicode в строке. Если все символы строки принадлежат ASCII, каждый символ занимает 1 байт; если есть символы за пределами ASCII, но все они лежат в базовой многоязычной плоскости (BMP), каждый символ занимает 2 байта; если встречаются символы за пределами BMP, каждый символ занимает 4 байта.</li> <li>Тип <code>string</code> в Go внутри использует кодировку UTF-8. Язык Go также предоставляет тип <code>rune</code>, предназначенный для представления одной кодовой точки Unicode.</li> <li>Типы <code>str</code> и <code>String</code> в Rust внутри используют UTF-8. В Rust также есть тип <code>char</code>, представляющий одну кодовую точку Unicode.</li> </ul> <p>Следует помнить, что выше обсуждался способ хранения строк внутри языков программирования, а это не то же самое, что хранение строк в файлах или передача их по сети. При файловом хранении и сетевой передаче мы обычно кодируем строки в формате UTF-8, чтобы получить наилучшую совместимость и эффективность по занимаемому месту.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   Классификация структур данных","text":"<p>К распространенным структурам данных относятся массивы, связные списки, стеки, очереди, хеш-таблицы, деревья, кучи и графы. Их можно классифицировать по двум измерениям: логической структуре и физической структуре.</p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   Логическая структура: линейная и нелинейная","text":"<p>Логическая структура раскрывает логические отношения между элементами данных. В массивах и связных списках данные расположены в определенном порядке, что отражает линейные отношения между элементами. В деревьях данные расположены по уровням сверху вниз, что демонстрирует отношения \"предок\" и \"потомок\". Графы состоят из вершин и ребер, отражая сложные сетевые отношения.</p> <p>Как показано на рисунке 3-1, логические структуры делятся на две большие категории: линейные и нелинейные. Линейные структуры более интуитивны, поскольку в них данные расположены линейно и логически связаны. Нелинейные структуры, напротив, представляют собой нелинейное расположение элементов данных.</p> <ul> <li>Линейные структуры данных: массивы, связные списки, стеки, очереди, хеш-таблицы, в которых элементы связаны отношением \"один к одному\".</li> <li>Нелинейные структуры данных: деревья, кучи, графы, хеш-таблицы.</li> </ul> <p>Нелинейные структуры данных можно дополнительно разделить на древовидные и сетевые.</p> <ul> <li>Древовидные структуры: деревья, кучи, хеш-таблицы, в которых элементы связаны отношением \"один ко многим\".</li> <li>Сетевые структуры: графы, в которых элементы связаны отношением \"многие ко многим\".</li> </ul> <p></p> <p> Рисунок 3-1   Линейные и нелинейные структуры данных </p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   Физическая структура: непрерывная и разрозненная","text":"<p>Во время выполнения программы обрабатываемые данные в основном хранятся в памяти. На рисунке 3-2 показан модуль оперативной памяти компьютера, где каждый черный блок содержит определенный участок памяти. Память можно представить как огромную таблицу Excel, в которой каждая ячейка способна хранить данные определенного размера.</p> <p>Система обращается к данным по адресам памяти соответствующих позиций. Как показано на рисунке 3-2, компьютер по определенным правилам присваивает каждой ячейке в этой таблице номер, чтобы каждый участок памяти имел уникальный адрес. Благодаря этим адресам программа получает доступ к данным, находящимся в памяти.</p> <p></p> <p> Рисунок 3-2   Планка памяти, участок памяти и адрес памяти </p> <p>Tip</p> <p>Стоит отметить, что сравнение памяти с таблицей Excel - это упрощенная аналогия; реальный механизм работы памяти гораздо сложнее и включает такие понятия, как адресное пространство, управление памятью, кэш-механизмы, виртуальная и физическая память.</p> <p>Память - общий ресурс для всех программ. Когда некоторый участок памяти занят одной программой, другие программы обычно не могут использовать его одновременно. Поэтому при проектировании структур данных и алгоритмов память занимает важное место. Например, пиковое потребление памяти алгоритмом не должно превышать объем доступной свободной памяти системы; если не хватает непрерывных крупных участков памяти, выбранная структура данных должна уметь размещаться в разрозненных областях памяти.</p> <p>Как показано на рисунке 3-3, физическая структура отражает способ хранения данных в памяти компьютера. Ее можно разделить на хранение в непрерывном пространстве (массивы) и хранение в разрозненном пространстве (связные списки). Физическая структура на низком уровне определяет способы доступа к данным, их обновления, вставки и удаления. Эти два типа физических структур взаимно дополняют друг друга по временной и пространственной эффективности.</p> <p></p> <p> Рисунок 3-3   Хранение в непрерывном и разрозненном пространстве </p> <p>Стоит отметить, что все структуры данных реализуются на основе массивов, связных списков или их комбинации. Например, стек и очередь можно реализовать как с помощью массивов, так и с помощью связных списков; реализация хеш-таблицы также может одновременно включать массивы и связные списки.</p> <ul> <li>Можно реализовать на основе массивов: стеки, очереди, хеш-таблицы, деревья, кучи, графы, матрицы, тензоры (массивы размерности \\(\\geq 3\\) ) и т.д.</li> <li>Можно реализовать на основе связных списков: стеки, очереди, хеш-таблицы, деревья, кучи, графы и т.д.</li> </ul> <p>После инициализации длину связного списка все еще можно изменять во время выполнения программы, поэтому его также называют \"динамической структурой данных\". Длина массива после инициализации неизменна, поэтому его также называют \"статической структурой данных\". Стоит отметить, что массив может изменять длину за счет повторного выделения памяти, тем самым приобретая определенную \"динамичность\".</p> <p>Tip</p> <p>Если тебе пока трудно понять физическую структуру, рекомендуется сначала прочитать следующую главу, а затем вернуться к этому разделу.</p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   Кодирование чисел *","text":"<p>Tip</p> <p>В этой книге разделы, помеченные символом <code>*</code>, относятся к дополнительному чтению. Если у тебя мало времени или материал кажется трудным, можно сначала пропустить их и вернуться после изучения обязательных разделов.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331","level":2,"title":"3.3.1   Прямой, обратный и дополнительный коды","text":"<p>В таблице из предыдущего раздела можно заметить, что все целочисленные типы могут представлять на одно отрицательное число больше, чем положительных. Например, диапазон <code>byte</code> равен \\([-128, 127]\\) . Это выглядит не слишком интуитивно, и внутренняя причина связана с прямым, обратным и дополнительным кодами.</p> <p>Прежде всего нужно отметить, что числа хранятся в компьютере в виде \"дополнительного кода\". Прежде чем разбирать причины такого решения, сначала дадим определения всем трем способам представления.</p> <ul> <li>Прямой код: старший бит двоичного представления числа рассматривается как знаковый, где \\(0\\) означает положительное число, а \\(1\\) - отрицательное; остальные биты представляют значение числа.</li> <li>Обратный код: для положительного числа обратный код совпадает с прямым; для отрицательного числа он получается инверсией всех битов прямого кода, кроме знакового бита.</li> <li>Дополнительный код: для положительного числа дополнительный код совпадает с прямым; для отрицательного числа он получается добавлением \\(1\\) к его обратному коду.</li> </ul> <p>На рисунке 3-4 показаны способы преобразования между прямым, обратным и дополнительным кодами.</p> <p></p> <p> Рисунок 3-4   Преобразования между прямым, обратным и дополнительным кодами </p> <p>Прямой код (sign-magnitude), хотя и является самым наглядным, имеет определенные ограничения. С одной стороны, прямой код отрицательных чисел нельзя напрямую использовать в вычислениях. Например, при вычислении \\(1 + (-2)\\) в прямом коде результатом будет \\(-3\\) , что, очевидно, неверно.</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>Чтобы решить эту проблему, компьютеры ввели обратный код (1's complement). Если сначала преобразовать прямой код в обратный и выполнить вычисление \\(1 + (-2)\\) в обратном коде, а затем перевести результат обратно в прямой код, то получится правильный результат \\(-1\\) .</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(прямой код)} + 1000 \\; 0010 \\; \\text{(прямой код)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(обратный код)} + 1111  \\; 1101 \\; \\text{(обратный код)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(обратный код)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(прямой код)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>С другой стороны, **в прямом коде у нуля есть два представления: \\(+0\\) и \\(-0\\) **. Это означает, что числу ноль соответствуют два разных двоичных кода, что может приводить к неоднозначности. Например, если в условном выражении не различать положительный и отрицательный ноль, можно получить ошибочный результат. А если специально обрабатывать такую неоднозначность, придется вводить дополнительные проверки, что может снизить вычислительную эффективность компьютера.</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>Как и прямой код, обратный код тоже страдает от неоднозначности положительного и отрицательного нуля, поэтому компьютеры ввели дополнительный код (2's complement). Сначала посмотрим на процесс преобразования отрицательного нуля из прямого кода в обратный, а затем в дополнительный:</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(прямой код)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(обратный код)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(дополнительный код)} \\newline \\end{aligned} \\] <p>При добавлении \\(1\\) к обратному коду отрицательного нуля возникает перенос, но длина типа <code>byte</code> составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, дополнительный код отрицательного нуля равен \\(0000 \\; 0000\\) и совпадает с дополнительным кодом положительного нуля. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.</p> <p>Остается последний вопрос: диапазон типа <code>byte</code> равен \\([-128, 127]\\) , откуда берется лишнее отрицательное число \\(-128\\) ? Мы замечаем, что у всех целых чисел из интервала \\([-127, +127]\\) есть соответствующие прямой, обратный и дополнительный коды, а прямой и дополнительный коды можно преобразовывать друг в друга.</p> <p>Однако дополнительный код \\(1000 \\; 0000\\) является исключением: у него нет соответствующего прямого кода. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен \\(0000 \\; 0000\\) . Это очевидное противоречие, потому что такой прямой код обозначает число \\(0\\) , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код \\(1000 \\; 0000\\) представляет число \\(-128\\) . На самом деле результат вычисления \\((-1) + (-127)\\) в дополнительном коде как раз и равен \\(-128\\) .</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(прямой код)} + 1000 \\; 0001 \\; \\text{(прямой код)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(обратный код)} + 1111  \\; 1110 \\; \\text{(обратный код)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(дополнительный код)} + 1111  \\; 1111 \\; \\text{(дополнительный код)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(дополнительный код)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>Ты, вероятно, уже заметил, что все приведенные выше вычисления были операциями сложения. Это указывает на важный факт: аппаратные схемы внутри компьютера в основном проектируются на основе операций сложения. Причина в том, что сложение по сравнению с другими операциями (например умножением, делением и вычитанием) проще реализуется на аппаратном уровне, легче распараллеливается и выполняется быстрее.</p> <p>Обрати внимание: это не означает, что компьютер умеет только складывать. Комбинируя сложение с некоторыми базовыми логическими операциями, компьютер может реализовать и другие математические операции. Например, вычитание \\(a - b\\) можно преобразовать в сложение \\(a + (-b)\\) ; умножение и деление можно свести к многократному сложению или вычитанию.</p> <p>Теперь можно подвести итог, почему компьютеры используют дополнительный код: с представлением в дополнительном коде компьютер может использовать одни и те же схемы и операции для сложения положительных и отрицательных чисел, без необходимости проектировать специальные аппаратные схемы для вычитания и без особой обработки неоднозначности положительного и отрицательного нуля. Это значительно упрощает аппаратную архитектуру и повышает эффективность вычислений.</p> <p>Идея дополнительного кода очень изящна; из-за ограничений по объему мы на этом остановимся. Если тебе интересно, стоит изучить эту тему глубже.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   Кодирование чисел с плавающей точкой","text":"<p>Внимательный читатель может заметить: <code>int</code> и <code>float</code> имеют одинаковую длину, по 4 байта , но почему диапазон значений у <code>float</code> намного больше, чем у <code>int</code> ? Это выглядит парадоксально, ведь <code>float</code> должен еще представлять дробные числа, а значит диапазон вроде бы должен быть меньше.</p> <p>На самом деле это связано с тем, что число с плавающей точкой <code>float</code> использует другой способ представления. Обозначим двоичное число длиной 32 бита как:</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>Согласно стандарту IEEE 754, 32-битный <code>float</code> состоит из следующих трех частей.</p> <ul> <li>Бит знака \\(\\mathrm{S}\\) : занимает 1 бит и соответствует \\(b_{31}\\) .</li> <li>Биты экспоненты \\(\\mathrm{E}\\) : занимают 8 бит и соответствуют \\(b_{30} b_{29} \\ldots b_{23}\\) .</li> <li>Биты мантиссы \\(\\mathrm{N}\\) : занимают 23 бита и соответствуют \\(b_{22} b_{21} \\ldots b_0\\) .</li> </ul> <p>Формула вычисления значения, соответствующего двоичному числу <code>float</code>, имеет вид:</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>Если перейти к десятичной записи, формула вычисления будет такой:</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>Диапазоны значений соответствующих частей таковы:</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> Рисунок 3-5   Пример вычисления float по стандарту IEEE 754 </p> <p>Посмотрим на рисунок 3-5: если взять пример \\(\\mathrm{S} = 0\\) , \\(\\mathrm{E} = 124\\) , \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) , то получим:</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>Теперь мы можем ответить на исходный вопрос: в представлении <code>float</code> присутствуют биты экспоненты, поэтому его диапазон значений намного больше, чем у <code>int</code>. Согласно приведенным выше вычислениям, максимально возможное положительное число для <code>float</code> равно \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) ; если изменить бит знака, получим минимальное отрицательное число.</p> <p>Хотя число с плавающей точкой <code>float</code> расширяет диапазон значений, побочным эффектом становится потеря точности. Целочисленный тип <code>int</code> использует все 32 бита для представления числа, и числа распределены равномерно; а из-за существования битов экспоненты у <code>float</code> чем больше число, тем больше обычно становится разница между двумя соседними представимыми значениями.</p> <p>Как показано в таблице 3-2, значения экспоненты \\(\\mathrm{E} = 0\\) и \\(\\mathrm{E} = 255\\) имеют специальный смысл и используются для представления нуля, бесконечности, \\(\\mathrm{NaN}\\) и т.д.</p> <p> Таблица 3-2   Значение поля экспоненты </p> Поле экспоненты E Поле мантиссы \\(\\mathrm{N} = 0\\) Поле мантиссы \\(\\mathrm{N} \\ne 0\\) Формула вычисления \\(0\\) \\(\\pm 0\\) Денормализованное число \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Нормализованное число Нормализованное число \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>Стоит отметить, что денормализованные числа заметно повышают точность чисел с плавающей точкой. Наименьшее положительное нормализованное число равно \\(2^{-126}\\) , а наименьшее положительное денормализованное число равно \\(2^{-126} \\times 2^{-23}\\) .</p> <p>Двойная точность <code>double</code> использует способ представления, аналогичный <code>float</code> , поэтому здесь мы не будем подробно останавливаться на нем.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   Резюме","text":"","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Структуры данных можно классифицировать с точки зрения логической и физической структуры. Логическая структура описывает логические отношения между элементами данных, а физическая структура описывает способ хранения данных в памяти компьютера.</li> <li>К распространенным логическим структурам относятся линейные, древовидные и сетевые. Обычно структуры данных делятся на линейные (массивы, связные списки, стеки, очереди) и нелинейные (деревья, графы, кучи). Реализация хеш-таблицы может включать как линейные, так и нелинейные структуры данных.</li> <li>При выполнении программы данные хранятся в памяти компьютера. Каждый участок памяти имеет соответствующий адрес, с помощью которого программа получает доступ к данным.</li> <li>Физическая структура делится на хранение в непрерывном пространстве (массивы) и хранение в разрозненном пространстве (связные списки). Все структуры данных реализуются на основе массивов, связных списков или их комбинации.</li> <li>Базовые типы данных в компьютере включают целые <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> , числа с плавающей точкой <code>float</code> , <code>double</code> , символы <code>char</code> и логический тип <code>bool</code> . Их диапазон значений зависит от объема занимаемого пространства и способа представления.</li> <li>Прямой код, обратный код и дополнительный код - это три способа кодирования чисел в компьютере, между которыми можно выполнять взаимные преобразования. В прямом коде старший бит целого числа является знаковым, а остальные биты представляют значение числа.</li> <li>Целые числа в компьютере хранятся в виде дополнительного кода. В таком представлении компьютер может одинаково обрабатывать сложение положительных и отрицательных чисел без специальной аппаратной схемы для вычитания, и при этом исчезает неоднозначность положительного и отрицательного нуля.</li> <li>Кодирование числа с плавающей точкой состоит из 1 бита знака, 8 битов экспоненты и 23 битов мантиссы. Благодаря наличию экспоненты диапазон значений у чисел с плавающей точкой намного больше, чем у целых, но это достигается ценой потери точности.</li> <li>ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 127 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.</li> <li>UTF-8 - самый популярный способ кодирования Unicode, обладающий очень хорошей универсальностью. Это кодировка переменной длины, хорошо расширяемая и эффективно использующая память. UTF-16 и UTF-32 относятся к кодировкам фиксированной длины. При кодировании китайского текста UTF-16 занимает меньше места, чем UTF-8. Такие языки программирования, как Java и C#, по умолчанию используют UTF-16.</li> </ul>","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Почему хеш-таблица одновременно включает линейные и нелинейные структуры данных?</p> <p>В основе хеш-таблицы лежит массив, а для разрешения коллизий мы можем использовать \"цепочки адресации\" (об этом будет рассказано в последующем разделе \"Хеш-коллизии\"): каждый бакет массива указывает на связный список, а если длина списка превышает некоторый порог, он может быть преобразован в дерево (обычно в красно-черное дерево).</p> <p>С точки зрения хранения данных в основе хеш-таблицы находится массив, где каждый слот бакета может содержать либо отдельное значение, либо связный список, либо дерево. Поэтому хеш-таблица действительно может одновременно включать линейные структуры данных (массивы, списки) и нелинейные структуры данных (деревья).</p> <p>Q: Длина типа <code>char</code> равна 1 байту?</p> <p>Длина типа <code>char</code> определяется используемым в языке программирования способом кодирования. Например, Java, JavaScript, TypeScript и C# используют кодировку UTF-16 (для хранения кодовых точек Unicode), поэтому длина <code>char</code> у них равна 2 байтам.</p> <p>Q: Не является ли двусмысленным утверждение, что структуры данных, реализованные на основе массива, также называются \"статическими структурами данных\"? Ведь стек тоже поддерживает операции push и pop, а они явно \"динамические\".</p> <p>Стек действительно может поддерживать динамические операции над данными, но сама структура данных при этом остается \"статической\" (ее длина неизменна). Хотя структуры на основе массива могут динамически добавлять и удалять элементы, их емкость фиксирована. Если количество данных превышает заранее выделенный размер, приходится создавать новый, более крупный массив и копировать в него содержимое старого.</p> <p>Q: При построении стека (очереди) его размер не задается явно, почему же его относят к \"статическим структурам данных\"?</p> <p>В языках высокого уровня нам не нужно вручную задавать начальную емкость стека (очереди): это автоматически делает сама реализация класса. Например, начальная емкость <code>ArrayList</code> в Java обычно равна 10. Кроме того, автоматом реализуется и расширение емкости. Подробнее это рассматривается в последующем разделе о \"списках\".</p> <p>Q: Если метод преобразования из прямого кода в дополнительный - это \"сначала инвертировать, затем прибавить 1\", то обратное преобразование из дополнительного кода в прямой, по идее, должно быть обратной операцией \"сначала вычесть 1, затем инвертировать\". Почему же дополнительный код также можно перевести в прямой тем же способом \"сначала инвертировать, затем прибавить 1\"?</p> <p>Это связано с тем, что взаимное преобразование прямого и дополнительного кодов по сути является вычислением \"дополнения\". Сначала дадим определение дополнения: если \\(a + b = c\\) , то говорят, что \\(a\\) является дополнением числа \\(b\\) до \\(c\\) ; аналогично, \\(b\\) является дополнением числа \\(a\\) до \\(c\\) .</p> <p>Для двоичного числа длины \\(n = 4\\) со значением \\(0010\\) , если рассматривать его как прямой код (не учитывая знаковый бит), то его дополнительный код получается правилом \"сначала инвертировать, затем прибавить 1\":</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>Мы видим, что сумма прямого и дополнительного кодов равна \\(0010 + 1110 = 10000\\) , то есть дополнительный код \\(1110\\) является \"дополнением\" прямого кода \\(0010\\) до \\(10000\\) . **Это означает, что описанная выше операция \"сначала инвертировать, затем прибавить 1\" на самом деле вычисляет дополнение до \\(10000\\) **.</p> <p>Тогда чему равно \"дополнение\" дополнительного кода \\(1110\\) до \\(10000\\) ? Мы снова можем получить его правилом \"сначала инвертировать, затем прибавить 1\":</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>Иначе говоря, прямой и дополнительный коды являются взаимными \"дополнениями\" друг друга до \\(10000\\) , поэтому и \"прямой код -&gt; дополнительный код\", и \"дополнительный код -&gt; прямой код\" можно реализовать одной и той же операцией (сначала инвертировать, затем прибавить 1).</p> <p>Разумеется, можно получить прямой код из дополнительного кода \\(1110\\) и обратной операцией, то есть \"сначала вычесть 1, затем инвертировать\":</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>В итоге и \"сначала инвертировать, затем прибавить 1\", и \"сначала вычесть 1, затем инвертировать\" - это два эквивалентных способа вычисления дополнения до \\(10000\\) .</p> <p>По сути операция \"инвертировать\" сама по себе вычисляет дополнение до \\(1111\\) (потому что всегда выполняется <code>прямой код + обратный код = 1111</code> ); а дополнительный код, получающийся после добавления 1 к обратному коду, и есть дополнение до \\(10000\\) .</p> <p>Приведенный выше пример использовал \\(n = 4\\) , но его можно обобщить на двоичные числа любой длины.</p>","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"Глава 12.   Разделяй и властвуй","text":"<p>Abstract</p> <p>Сложная задача раскладывается слой за слоем, и каждое новое разбиение делает ее проще.</p> <p>Принцип \"разделяй и властвуй\" показывает важный факт: если начать с простого, многое перестает быть сложным.</p>","path":["Глава 12. Разделяй и властвуй","Глава 12. &nbsp; Разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>12.1   Алгоритмы разделяй и властвуй</li> <li>12.2   Стратегия поиска разделяй и властвуй</li> <li>12.3   Задача построения двоичного дерева</li> <li>12.4   Задача о Ханойской башне</li> <li>12.5   Резюме</li> </ul>","path":["Глава 12. Разделяй и властвуй","Глава 12. &nbsp; Разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   Поисковая стратегия \"разделяй и властвуй\"","text":"<p>Мы уже знаем, что алгоритмы поиска делятся на две большие категории.</p> <ul> <li>Полный перебор: реализуется через обход структуры данных, временная сложность равна \\(O(n)\\) .</li> <li>Адаптивный поиск: использует особую организацию данных или априорную информацию, временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) .</li> </ul> <p>На практике алгоритмы поиска с временной сложностью \\(O(\\log n)\\) обычно реализуются на основе стратегии \"разделяй и властвуй\", например двоичный поиск и деревья.</p> <ul> <li>На каждом шаге двоичный поиск раскладывает задачу (поиск целевого элемента в массиве) на более мелкую задачу (поиск целевого элемента в одной половине массива), и этот процесс продолжается, пока массив не станет пустым или пока не будет найден целевой элемент.</li> <li>Деревья являются типичными представителями идей \"разделяй и властвуй\"; в таких структурах данных, как двоичное дерево поиска, AVL-дерево и куча, временная сложность различных операций равна \\(O(\\log n)\\) .</li> </ul> <p>Стратегия \"разделяй и властвуй\" для двоичного поиска выглядит следующим образом.</p> <ul> <li>Задача раскладывается на части: двоичный поиск рекурсивно разбивает исходную задачу (поиск в массиве) на подзадачу (поиск в одной половине массива), и это достигается сравнением среднего элемента с целевым значением.</li> <li>Подзадачи независимы: в двоичном поиске на каждом шаге обрабатывается только одна подзадача, и она не зависит от других подзадач.</li> <li>Решения подзадач не нужно объединять: двоичный поиск нацелен на поиск конкретного элемента, поэтому объединять решения подзадач не требуется. Как только подзадача решена, одновременно считается решенной и исходная задача.</li> </ul> <p>Иными словами, стратегия \"разделяй и властвуй\" повышает эффективность поиска потому, что при полном переборе за один шаг удается исключить только один вариант, тогда как при поиске на основе \"разделяй и властвуй\" за один шаг можно исключить половину вариантов.</p>","path":["Глава 12. Разделяй и властвуй","12.2 &nbsp; Поисковая стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   Реализация двоичного поиска на основе \"разделяй и властвуй\"","text":"<p>В предыдущих главах двоичный поиск реализовывался через итерацию. Теперь реализуем его с помощью стратегии \"разделяй и властвуй\", то есть через рекурсию.</p> <p>Question</p> <p>Дан отсортированный массив <code>nums</code> длины \\(n\\) , в котором все элементы уникальны. Найдите элемент <code>target</code> .</p> <p>С точки зрения стратегии \"разделяй и властвуй\" обозначим подзадачу, соответствующую интервалу поиска \\([i, j]\\) , через \\(f(i, j)\\) .</p> <p>Начиная с исходной задачи \\(f(0, n-1)\\) , выполняем двоичный поиск по следующим шагам.</p> <ol> <li>Вычислить середину \\(m\\) интервала поиска \\([i, j]\\) и с ее помощью исключить половину интервала.</li> <li>Рекурсивно решить подзадачу вдвое меньшего размера; это может быть либо \\(f(i, m-1)\\) , либо \\(f(m+1, j)\\) .</li> <li>Повторять шаг <code>1.</code> и шаг <code>2.</code> , пока не будет найден <code>target</code> или пока интервал не станет пустым.</li> </ol> <p>На рисунке 12-4 показан процесс применения стратегии \"разделяй и властвуй\" для поиска элемента \\(6\\) в массиве.</p> <p></p> <p> Рисунок 12-4   Процесс двоичного поиска в стиле разделяй и властвуй </p> <p>В реализации кода мы объявляем рекурсивную функцию <code>dfs()</code> для решения задачи \\(f(i, j)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"Бинарный поиск: задача f(i, j)\"\"\"\n    # Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j:\n        return -1\n    # Вычислить индекс середины m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # Целевой элемент найден, вернуть его индекс\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск\"\"\"\n    n = len(nums)\n    # Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* Бинарный поиск: задача f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // Решить задачу f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // Если интервал пуст, это означает отсутствие целевого элемента, вернуть -1\n    if i &gt; j {\n        return -1\n    }\n    // Вычислить средний индекс\n    m := i + ((j - i) &gt;&gt; 1)\n    // Сравнить середину и целевой элемент\n    if nums[m] &lt; target {\n        // Если меньше, рекурсивно обрабатывать правую половину массива\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // Если больше, рекурсивно обработать левую половину массива\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m\n    }\n}\n\n/* Бинарный поиск */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j {\n        return -1\n    }\n    // Вычислить индекс середины m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m\n    }\n}\n\n/* Бинарный поиск */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Решить задачу f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // Вычислить индекс середины m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // Рекурсивная подзадача f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // Рекурсивная подзадача f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // Целевой элемент найден, вернуть его индекс\n    return m;\n  }\n}\n\n/* Бинарный поиск */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // Решить задачу f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* Бинарный поиск: задача f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // Решить задачу f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* Бинарный поиск: задача f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1\n    }\n    // Вычислить индекс середины m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        m\n    }\n}\n\n/* Бинарный поиск */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### Бинарный поиск: задача f(i, j) ###\ndef dfs(nums, target, i, j)\n  # Если интервал пуст, целевой элемент отсутствует, вернуть -1\n  return -1 if i &gt; j\n\n  # Вычислить индекс середины m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # Рекурсивная подзадача f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # Рекурсивная подзадача f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # Целевой элемент найден, вернуть его индекс\n    return m\n  end\nend\n\n### Бинарный поиск ###\ndef binary_search(nums, target)\n  n = nums.length\n  # Решить задачу f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 12. Разделяй и властвуй","12.2 &nbsp; Поисковая стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   Задача построения двоичного дерева","text":"<p>Question</p> <p>Даны прямой обход <code>preorder</code> и симметричный обход <code>inorder</code> некоторого двоичного дерева. Постройте по ним двоичное дерево и верните его корневой узел. Предполагается, что в дереве нет узлов с одинаковыми значениями (как показано на рисунке 12-5).</p> <p></p> <p> Рисунок 12-5   Пример данных для построения двоичного дерева </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   Проверка, является ли это задачей \"разделяй и властвуй\"","text":"<p>Исходная задача - построить двоичное дерево по <code>preorder</code> и <code>inorder</code> - является типичной задачей для стратегии \"разделяй и властвуй\".</p> <ul> <li>Задача раскладывается на части: если смотреть с точки зрения стратегии \"разделяй и властвуй\", исходную задачу можно разбить на две подзадачи: построение левого поддерева и построение правого поддерева, плюс одно действие: инициализация корневого узла. Для каждого поддерева (подзадачи) можно использовать тот же способ разбиения, пока не будет достигнута наименьшая подзадача (пустое поддерево).</li> <li>Подзадачи независимы: левое и правое поддеревья независимы друг от друга и не пересекаются. При построении левого поддерева нам нужно смотреть только на ту часть прямого и симметричного обходов, которая соответствует левому поддереву. Для правого поддерева рассуждение аналогично.</li> <li>Решения подзадач можно объединить: когда левое и правое поддеревья (решения подзадач) уже построены, их можно присоединить к корневому узлу и тем самым получить решение исходной задачи.</li> </ul>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   Как разделить поддеревья","text":"<p>Из анализа выше видно, что эта задача действительно решается через \"разделяй и властвуй\", но как именно, имея прямой обход <code>preorder</code> и симметричный обход <code>inorder</code>, отделить левое и правое поддеревья?</p> <p>По определению и <code>preorder</code> , и <code>inorder</code> можно разбить на три части.</p> <ul> <li>Прямой обход: <code>[ корневой узел | левое поддерево | правое поддерево ]</code> , например для дерева на рисунке 12-5 это <code>[ 3 | 9 | 2 1 7 ]</code> .</li> <li>Симметричный обход: <code>[ левое поддерево | корневой узел | правое поддерево ]</code> , например для дерева на рисунке 12-5 это <code>[ 9 | 3 | 1 2 7 ]</code> .</li> </ul> <p>На примере данных с рисунка можно получить результат разбиения по следующим шагам.</p> <ol> <li>Первый элемент прямого обхода, равный 3, является значением корневого узла.</li> <li>Найти индекс корневого узла 3 в <code>inorder</code> ; используя этот индекс, можно разбить <code>inorder</code> на <code>[ 9 | 3 | 1 2 7 ]</code> .</li> <li>По результату разбиения <code>inorder</code> нетрудно определить, что число узлов в левом и правом поддеревьях равно 1 и 3 соответственно, а значит, <code>preorder</code> можно разбить как <code>[ 3 | 9 | 2 1 7 ]</code> .</li> </ol> <p></p> <p> Рисунок 12-6   Разбиение поддеревьев в прямом и симметричном обходах </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   Описание интервалов поддеревьев через переменные","text":"<p>Согласно описанному выше способу разбиения, мы уже получили интервалы индексов корневого узла, левого и правого поддеревьев в <code>preorder</code> и <code>inorder</code>. Чтобы описывать эти интервалы, нам понадобится несколько указателей-переменных.</p> <ul> <li>Обозначим индекс корневого узла текущего дерева в <code>preorder</code> через \\(i\\) .</li> <li>Обозначим индекс корневого узла текущего дерева в <code>inorder</code> через \\(m\\) .</li> <li>Обозначим интервал индексов текущего дерева в <code>inorder</code> через \\([l, r]\\) .</li> </ul> <p>Как показано в таблице 12-1, этих переменных достаточно для описания индекса корневого узла в <code>preorder</code> и интервалов поддеревьев в <code>inorder</code> .</p> <p> Таблица 12-1   Индексы корневого узла и поддеревьев в прямом и симметричном обходах </p> Индекс корневого узла в <code>preorder</code> Интервал индексов поддерева в <code>inorder</code> Текущее дерево \\(i\\) \\([l, r]\\) Левое поддерево \\(i + 1\\) \\([l, m-1]\\) Правое поддерево \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>Стоит отметить, что \\((m-l)\\) в индексе корневого узла правого поддерева означает число узлов в левом поддереве; лучше всего понимать это выражение вместе с рисунком ниже.</p> <p></p> <p> Рисунок 12-7   Представление индексных интервалов корня и поддеревьев </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   Реализация кода","text":"<p>Чтобы ускорить поиск \\(m\\) , мы используем хеш-таблицу <code>hmap</code> для хранения отображения значений массива <code>inorder</code> в индексы:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"Построить двоичное дерево: разделяй и властвуй\"\"\"\n    # Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0:\n        return None\n    # Инициализировать корневой узел\n    root = TreeNode(preorder[i])\n    # Найти m, чтобы разделить левое и правое поддеревья\n    m = inorder_map[preorder[i]]\n    # Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # Вернуть корневой узел\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"Построить двоичное дерево\"\"\"\n    # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return NULL;\n    // Инициализировать корневой узел\n    TreeNode *root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return null;\n    // Инициализировать корневой узел\n    TreeNode root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return null;\n    // Инициализировать корневой узел\n    TreeNode root = new(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // Завершить при пустом диапазоне поддерева\n    if r-l &lt; 0 {\n        return nil\n    }\n    // Инициализировать корневой узел\n    root := NewTreeNode(preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    m := inorderMap[preorder[i]]\n    // Подзадача: построить левое поддерево\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // Подзадача: построить правое поддерево\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0 {\n        return nil\n    }\n    // Инициализировать корневой узел\n    let root = TreeNode(x: preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    let m = inorderMap[preorder[i]]!\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null;\n    // Инициализировать корневой узел\n    const root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    const m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nfunction buildTree(preorder, inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null;\n    // Инициализировать корневой узел\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    const m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // Завершить при пустом диапазоне поддерева\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // Инициализировать корневой узел\n  TreeNode? root = TreeNode(preorder[i]);\n  // Найти m, чтобы разделить левое и правое поддеревья\n  int m = inorderMap[preorder[i]]!;\n  // Подзадача: построить левое поддерево\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // Подзадача: построить правое поддерево\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // Вернуть корневой узел\n  return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0 {\n        return None;\n    }\n    // Инициализировать корневой узел\n    let root = TreeNode::new(preorder[i as usize]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // Подзадача: построить левое поддерево\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    Some(root)\n}\n\n/* Построить двоичное дерево */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return NULL;\n    // Инициализировать корневой узел\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // Подзадача: построить правое поддерево\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null\n    // Инициализировать корневой узел\n    val root = TreeNode(preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    val m = inorderMap[preorder[i]]!!\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### Построить двоичное дерево: разделяй и властвуй ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # Завершить при пустом диапазоне поддерева\n  return if r - l &lt; 0\n\n  # Инициализировать корневой узел\n  root = TreeNode.new(preorder[i])\n  # Найти m, чтобы разделить левое и правое поддеревья\n  m = inorder_map[preorder[i]]\n  # Подзадача: построить левое поддерево\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # Подзадача: построить правое поддерево\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # Вернуть корневой узел\n  root\nend\n\n### Построить двоичное дерево ###\ndef build_tree(preorder, inorder)\n  # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 12-8 показан рекурсивный процесс построения двоичного дерева: каждый узел создается в фазе \"спуска\", а каждое ребро (ссылка) формируется в фазе \"подъема\".</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-8   Рекурсивный процесс построения двоичного дерева </p> <p>Результаты разбиения <code>preorder</code> и <code>inorder</code> внутри каждого рекурсивного вызова показаны на рисунке 12-9.</p> <p></p> <p> Рисунок 12-9   Результаты разбиения в каждом рекурсивном вызове </p> <p>Пусть число узлов дерева равно \\(n\\) ; инициализация каждого узла (то есть выполнение одного рекурсивного вызова <code>dfs()</code> ) занимает \\(O(1)\\) времени. Следовательно, общая временная сложность равна \\(O(n)\\) .</p> <p>Хеш-таблица хранит отображение значений <code>inorder</code> в индексы, поэтому ее пространственная сложность равна \\(O(n)\\) . В худшем случае, когда двоичное дерево вырождается в связный список, глубина рекурсии достигает \\(n\\) и требует \\(O(n)\\) памяти стека. Следовательно, общая пространственная сложность также равна \\(O(n)\\) .</p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   Стратегия \"разделяй и властвуй\"","text":"<p>Разделяй и властвуй (divide and conquer) - это очень важная и широко используемая стратегия построения алгоритмов. Обычно она реализуется через рекурсию и включает два этапа: \"разделение\" и \"объединение\".</p> <ol> <li>Разделение (этап декомпозиции): рекурсивно разбить исходную задачу на две или более подзадачи, пока не будет достигнута наименьшая подзадача.</li> <li>Объединение (этап синтеза): начиная с уже известных решений наименьших подзадач, снизу вверх объединять решения подзадач и тем самым получать решение исходной задачи.</li> </ol> <p>Как показано на рисунке 12-1, \"сортировка слиянием\" является одним из типичных примеров применения стратегии \"разделяй и властвуй\".</p> <ol> <li>Разделение: рекурсивно разделить исходный массив (исходную задачу) на два подмассива (подзадачи), пока в подмассиве не останется только один элемент (наименьшая подзадача).</li> <li>Объединение: снизу вверх объединять упорядоченные подмассивы (решения подзадач), чтобы получить упорядоченный исходный массив (решение исходной задачи).</li> </ol> <p></p> <p> Рисунок 12-1   Стратегия разделяй и властвуй в сортировке слиянием </p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   Как определить задачу \"разделяй и властвуй\"","text":"<p>Чтобы понять, подходит ли задача для решения методом \"разделяй и властвуй\", обычно можно ориентироваться на следующие критерии.</p> <ol> <li>Задача раскладывается на части: исходную задачу можно разбить на более мелкие и похожие подзадачи, причем такое разбиение можно применять рекурсивно.</li> <li>Подзадачи независимы: подзадачи не пересекаются, не зависят друг от друга и могут решаться независимо.</li> <li>Решения подзадач можно объединить: решение исходной задачи получается объединением решений подзадач.</li> </ol> <p>Очевидно, что сортировка слиянием удовлетворяет всем трем критериям.</p> <ol> <li>Задача раскладывается на части: массив (исходная задача) рекурсивно делится на два подмассива (подзадачи).</li> <li>Подзадачи независимы: каждый подмассив можно сортировать отдельно (то есть каждую подзадачу можно решать независимо).</li> <li>Решения подзадач можно объединить: два упорядоченных подмассива (решения подзадач) можно объединить в один упорядоченный массив (решение исходной задачи).</li> </ol>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   Повышение эффективности с помощью \"разделяй и властвуй\"","text":"<p>Стратегия \"разделяй и властвуй\" не только позволяет эффективно решать алгоритмические задачи, но и часто повышает эффективность самих алгоритмов. Именно поэтому быстрая сортировка, сортировка слиянием и пирамидальная сортировка обычно работают быстрее, чем сортировка выбором, пузырьком и вставками.</p> <p>Тогда возникает естественный вопрос: почему стратегия \"разделяй и властвуй\" повышает эффективность алгоритма и какова внутренняя логика этого подхода? Иными словами, почему разбиение большой задачи на несколько подзадач, решение этих подзадач и последующее объединение их решений оказывается эффективнее, чем прямое решение исходной задачи? Этот вопрос можно рассмотреть с двух сторон: через число операций и через параллельные вычисления.</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   Оптимизация числа операций","text":"<p>Рассмотрим \"сортировку пузырьком\": для массива длины \\(n\\) ей требуется \\(O(n^2)\\) времени. Предположим, что мы разделим массив на два подмассива в середине, как показано на рисунке 12-2. Тогда само разбиение потребует \\(O(n)\\) времени, сортировка каждого подмассива займет \\(O((n / 2)^2)\\) времени, а объединение двух подмассивов потребует еще \\(O(n)\\) времени. Общая временная сложность будет равна:</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> Рисунок 12-2   Сортировка пузырьком до и после разбиения массива </p> <p>Теперь рассмотрим следующее неравенство, в котором левая и правая части обозначают общее число операций до разбиения и после него:</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>Это означает, что при \\(n &gt; 4\\) число операций после разбиения становится меньше, а значит, сортировка должна работать быстрее. При этом важно заметить, что временная сложность после разбиения все еще остается квадратичной, то есть \\(O(n^2)\\) ; уменьшается лишь константный множитель.</p> <p>Если пойти дальше и продолжать делить каждый подмассив пополам, пока в нем не останется только один элемент, то мы фактически получим \"сортировку слиянием\", чья временная сложность равна \\(O(n \\log n)\\) .</p> <p>Можно пойти еще дальше и спросить: что если задать несколько точек разделения и равномерно разбить исходный массив на \\(k\\) подмассивов? Такая ситуация очень похожа на блочную сортировку, которая особенно хорошо подходит для сортировки очень больших объемов данных и теоретически может достигать временной сложности \\(O(n + k)\\) .</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   Оптимизация параллельных вычислений","text":"<p>Мы знаем, что подзадачи, порождаемые стратегией \"разделяй и властвуй\", являются независимыми, а значит, их обычно можно решать параллельно. Иначе говоря, \"разделяй и властвуй\" не только может уменьшить временную сложность алгоритма, но и хорошо сочетается с параллельной оптимизацией на уровне системы.</p> <p>Параллельная оптимизация особенно эффективна в среде с несколькими ядрами или несколькими процессорами, потому что система может одновременно обрабатывать разные подзадачи, лучше загружая вычислительные ресурсы и тем самым заметно сокращая общее время работы.</p> <p>Например, в показанной ниже \"блочной сортировке\" большой объем данных равномерно распределяется по блокам. Тогда сортировку каждого блока можно поручить отдельным вычислительным единицам, а после завершения просто объединить результаты.</p> <p></p> <p> Рисунок 12-3   Параллельные вычисления в блочной сортировке </p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   Типичные применения стратегии \"разделяй и властвуй\"","text":"<p>С одной стороны, стратегию \"разделяй и властвуй\" можно использовать для решения многих классических алгоритмических задач.</p> <ul> <li>Поиск ближайшей пары точек: сначала множество точек делится на две части, затем ищется ближайшая пара в каждой части, а затем ближайшая пара, пересекающая границу между двумя частями.</li> <li>Умножение больших чисел: например, алгоритм Карацубы, который раскладывает умножение больших чисел на несколько умножений и сложений меньших чисел.</li> <li>Умножение матриц: например, алгоритм Штрассена, который раскладывает умножение больших матриц на несколько умножений и сложений матриц меньшего размера.</li> <li>Задача о Ханойской башне: задача о Ханойской башне решается рекурсивно и является типичным примером применения стратегии \"разделяй и властвуй\".</li> <li>Подсчет инверсий: если в последовательности предыдущее число больше следующего, то такая пара образует инверсию. Эту задачу можно решить с помощью идей \"разделяй и властвуй\", опираясь на сортировку слиянием.</li> </ul> <p>С другой стороны, стратегия \"разделяй и властвуй\" очень широко применяется при проектировании алгоритмов и структур данных.</p> <ul> <li>Двоичный поиск: двоичный поиск делит отсортированный массив на две части по индексу середины, а затем, в зависимости от результата сравнения целевого значения со средним элементом, исключает одну из половин и повторяет ту же операцию на оставшемся интервале.</li> <li>Сортировка слиянием: она уже была рассмотрена в начале этого раздела, поэтому не будем повторяться.</li> <li>Быстрая сортировка: в ней выбирается опорное значение, после чего массив делится на два подмассива: один содержит элементы меньше опорного, а другой - больше. Затем такая же операция повторяется для обеих частей, пока в подмассиве не останется один элемент.</li> <li>Блочная сортировка: ее основная идея заключается в распределении данных по нескольким блокам, сортировке элементов внутри каждого блока и последующем последовательном извлечении элементов из блоков для построения отсортированного массива.</li> <li>Деревья: например, двоичные деревья поиска, AVL-деревья, красно-черные деревья, B-деревья, B+ деревья и т.д. Их операции поиска, вставки и удаления можно рассматривать как применение стратегии \"разделяй и властвуй\".</li> <li>Кучи: куча является особым видом полного двоичного дерева, а такие операции, как вставка, удаление и упорядочивание, по сути содержат идеи \"разделяй и властвуй\".</li> <li>Хеш-таблицы: хотя хеш-таблицы напрямую не используют стратегию \"разделяй и властвуй\", некоторые способы разрешения коллизий косвенно опираются на эту идею. Например, длинные цепочки в методе цепочек могут преобразовываться в красно-черные деревья для повышения эффективности поиска.</li> </ul> <p>Нетрудно заметить, что \"разделяй и властвуй\" - это \"тихая\" алгоритмическая идея, скрыто присутствующая внутри самых разных алгоритмов и структур данных.</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия \"разделяй и властвуй\""],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   Задача о Ханойской башне","text":"<p>В задачах сортировки слиянием и построения двоичного дерева мы делили исходную задачу на две подзадачи, каждая из которых имела размер, равный примерно половине исходной задачи. Однако для задачи о Ханойской башне используется другая стратегия разбиения.</p> <p>Question</p> <p>Даны три стержня, обозначенные как <code>A</code> , <code>B</code> и <code>C</code> . В начальном состоянии на стержне <code>A</code> находятся \\(n\\) дисков, расположенных сверху вниз в порядке от меньшего к большему. Нужно переместить эти \\(n\\) дисков на стержень <code>C</code> , сохранив их исходный порядок (как показано на рисунке 12-10). Во время перемещения дисков необходимо соблюдать следующие правила.</p> <ol> <li>Диск можно снять только с вершины одного стержня и положить только на вершину другого стержня.</li> <li>За один раз можно перемещать только один диск.</li> <li>Меньший диск всегда должен лежать на большем.</li> </ol> <p></p> <p> Рисунок 12-10   Пример задачи о Ханойской башне </p> <p>Обозначим задачу о Ханойской башне размера \\(i\\) как \\(f(i)\\) . Например, \\(f(3)\\) означает задачу перемещения 3 дисков со стержня <code>A</code> на стержень <code>C</code> .</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   Рассмотрим базовые случаи","text":"<p>Как показано на рисунке 12-11, для задачи \\(f(1)\\) , то есть когда имеется только один диск, достаточно просто переместить его напрямую со стержня <code>A</code> на стержень <code>C</code> .</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> Рисунок 12-11   Решение задачи размера 1 </p> <p>Как показано на рисунке 12-12, для задачи \\(f(2)\\) , то есть когда есть два диска, поскольку меньший диск все время должен лежать на большем, приходится использовать <code>B</code> как вспомогательный стержень.</p> <ol> <li>Сначала переместить верхний маленький диск с <code>A</code> на <code>B</code> .</li> <li>Затем переместить большой диск с <code>A</code> на <code>C</code> .</li> <li>Наконец, переместить маленький диск с <code>B</code> на <code>C</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-12   Решение задачи размера 2 </p> <p>Процесс решения задачи \\(f(2)\\) можно кратко описать так: переместить два диска с <code>A</code> на <code>C</code> с помощью <code>B</code> . Здесь <code>C</code> называется целевым стержнем, а <code>B</code> - буферным стержнем.</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   Разбиение на подзадачи","text":"<p>Для задачи \\(f(3)\\) , то есть когда имеется три диска, ситуация становится сложнее.</p> <p>Поскольку решения \\(f(1)\\) и \\(f(2)\\) уже известны, можно подойти к задаче с точки зрения стратегии \"разделяй и властвуй\" и рассматривать два верхних диска на <code>A</code> как единое целое, выполняя шаги, показанные на рисунке 12-13. Так три диска успешно перемещаются с <code>A</code> на <code>C</code> .</p> <ol> <li>Сделать <code>B</code> целевым стержнем, а <code>C</code> буферным, и переместить два диска с <code>A</code> на <code>B</code> .</li> <li>Переместить оставшийся один диск с <code>A</code> напрямую на <code>C</code> .</li> <li>Сделать <code>C</code> целевым стержнем, а <code>A</code> буферным, и переместить два диска с <code>B</code> на <code>C</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-13   Решение задачи размера 3 </p> <p>Иначе говоря, мы разбиваем задачу \\(f(3)\\) на две подзадачи \\(f(2)\\) и одну подзадачу \\(f(1)\\) . Если последовательно решить эти три подзадачи, исходная задача тоже будет решена. Это показывает, что подзадачи независимы и что их решения можно объединить.</p> <p>Таким образом, можно сформулировать показанную на рисунке 12-14 стратегию \"разделяй и властвуй\" для задачи о Ханойской башне: исходная задача \\(f(n)\\) разбивается на две подзадачи \\(f(n-1)\\) и одну подзадачу \\(f(1)\\) , которые затем решаются в следующем порядке.</p> <ol> <li>Переместить \\(n-1\\) дисков с <code>A</code> на <code>B</code> с помощью <code>C</code> .</li> <li>Переместить оставшийся \\(1\\) диск напрямую с <code>A</code> на <code>C</code> .</li> <li>Переместить \\(n-1\\) дисков с <code>B</code> на <code>C</code> с помощью <code>A</code> .</li> </ol> <p>Для двух подзадач \\(f(n-1)\\) можно применять тот же способ рекурсивного разбиения, пока не будет достигнута наименьшая подзадача \\(f(1)\\) . А решение для \\(f(1)\\) уже известно и требует всего одного перемещения.</p> <p></p> <p> Рисунок 12-14   Стратегия разделяй и властвуй для решения задачи о Ханойской башне </p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>В коде мы объявляем рекурсивную функцию <code>dfs(i, src, buf, tar)</code> , которая перемещает \\(i\\) верхних дисков со стержня <code>src</code> на целевой стержень <code>tar</code> с помощью буферного стержня <code>buf</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"Переместить один диск\"\"\"\n    # Снять диск с вершины src\n    pan = src.pop()\n    # Положить диск на вершину tar\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"Решить задачу Ханойской башни f(i)\"\"\"\n    # Если в src остался только один диск, сразу переместить его в tar\n    if i == 1:\n        move(src, tar)\n        return\n    # Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf)\n    # Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    # Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"Решить задачу Ханойской башни\"\"\"\n    n = len(A)\n    # Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* Переместить один диск */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // Снять диск с вершины src\n    int pan = src.back();\n    src.pop_back();\n    // Положить диск на вершину tar\n    tar.push_back(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* Переместить один диск */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // Снять диск с вершины src\n    Integer pan = src.remove(src.size() - 1);\n    // Положить диск на вершину tar\n    tar.add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* Переместить один диск */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // Снять диск с вершины src\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // Положить диск на вершину tar\n    tar.Add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    DFS(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    Move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    DFS(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // Переместить верхние n дисков из A в C с помощью B\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* Переместить один диск */\nfunc move(src, tar *list.List) {\n    // Снять диск с вершины src\n    pan := src.Back()\n    // Положить диск на вершину tar\n    tar.PushBack(pan.Value)\n    // Убрать верхний диск из src\n    src.Remove(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfsHanota(i-1, src, tar, buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* Решить задачу Ханойской башни */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // Переместить верхние n дисков из A в C с помощью B\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* Переместить один диск */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // Снять диск с вершины src\n    let pan = src.popLast()!\n    // Положить диск на вершину tar\n    tar.append(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src: &amp;src, tar: &amp;tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* Решить задачу Ханойской башни */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // Хвост списка соответствует вершине столбца\n    // Переместить верхние n дисков из src в C с помощью B\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* Переместить один диск */\nfunction move(src, tar) {\n    // Снять диск с вершины src\n    const pan = src.pop();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunction dfs(i, src, buf, tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* Переместить один диск */\nfunction move(src: number[], tar: number[]): void {\n    // Снять диск с вершины src\n    const pan = src.pop();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* Переместить один диск */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // Снять диск с вершины src\n  int pan = src.removeLast();\n  // Положить диск на вершину tar\n  tar.add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // Если в src остался только один диск, сразу переместить его в tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n  dfs(i - 1, src, tar, buf);\n  // Подзадача f(1): переместить оставшийся один диск из src в tar\n  move(src, tar);\n  // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n  dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // Переместить верхние n дисков из A в C с помощью B\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* Переместить один диск */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Снять диск с вершины src\n    let pan = src.pop().unwrap();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move_pan(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* Переместить один диск */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // Снять диск с вершины src\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // Положить диск на вершину tar\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, srcSize, tar, tarSize);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* Переместить один диск */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Снять диск с вершины src\n    val pan = src.removeAt(src.size - 1)\n    // Положить диск на вершину tar\n    tar.add(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar)\n}\n\n/* Решить задачу Ханойской башни */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### Переместить один диск ###\ndef move(src, tar)\n  # Снять диск с вершины src\n  pan = src.pop\n  # Положить диск на вершину tar\n  tar &lt;&lt; pan\nend\n\n### Решить задачу Ханойской башни f(i) ###\ndef dfs(i, src, buf, tar)\n  # Если в src остался только один диск, сразу переместить его в tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n  dfs(i - 1, src, tar, buf)\n  # Подзадача f(1): переместить оставшийся один диск из src в tar\n  move(src, tar)\n  # Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n  dfs(i - 1, buf, src, tar)\nend\n\n### Решить задачу Ханойской башни ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # Переместить верхние n дисков из A в C с помощью B\n  dfs(n, _A, _B, _C)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 12-15, задача о Ханойской башне формирует дерево рекурсии высоты \\(n\\) , в котором каждый узел представляет подзадачу и соответствует одному открытому вызову <code>dfs()</code> ; поэтому временная сложность равна \\(O(2^n)\\) , а пространственная сложность равна \\(O(n)\\) .</p> <p></p> <p> Рисунок 12-15   Дерево рекурсии задачи о Ханойской башне </p> <p>Quote</p> <p>Задача о Ханойской башне происходит из древней легенды. В одном из храмов древней Индии монахи имели три высоких алмазных стержня и \\(64\\) золотых диска разного размера. Монахи непрерывно перекладывали диски и верили, что в тот момент, когда последний диск будет правильно перенесен, мир подойдет к концу.</p> <p>Однако даже если бы монахи перемещали по одному диску в секунду, им понадобилось бы примерно \\(2^{64} \\approx 1.84×10^{19}\\) секунд, то есть около \\(585\\) миллиардов лет, что намного превышает текущую оценку возраста Вселенной. Поэтому, если легенда и верна, нам, вероятно, пока не о чем беспокоиться.</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   Резюме","text":"","path":["Глава 12. Разделяй и властвуй","12.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>\"Разделяй и властвуй\" - это распространенная стратегия проектирования алгоритмов, которая включает два этапа: разделение (декомпозицию) и объединение (синтез), и обычно реализуется с помощью рекурсии.</li> <li>Критерии применимости этой стратегии к задаче включают: возможность разложения задачи, независимость подзадач и возможность объединения их решений.</li> <li>Сортировка слиянием является типичным применением стратегии \"разделяй и властвуй\": она рекурсивно делит массив на два равных по длине подмассива, пока не останется массив из одного элемента, после чего начинает поэтапное объединение.</li> <li>Использование стратегии \"разделяй и властвуй\" часто позволяет повысить эффективность алгоритма. С одной стороны, она уменьшает число операций; с другой - после разбиения способствует параллельной оптимизации на уровне системы.</li> <li>\"Разделяй и властвуй\" не только помогает решать многие алгоритмические задачи, но и широко используется при проектировании структур данных и алгоритмов, поэтому его можно встретить буквально повсюду.</li> <li>По сравнению с полным перебором адаптивный поиск работает эффективнее. Алгоритмы поиска со сложностью \\(O(\\log n)\\) обычно реализуются на основе стратегии \"разделяй и властвуй\".</li> <li>Двоичный поиск - еще одно типичное применение стратегии \"разделяй и властвуй\", в котором отсутствует шаг объединения решений подзадач. Его можно реализовать рекурсивно, опираясь на эту стратегию.</li> <li>В задаче построения двоичного дерева исходная задача построения дерева может быть разбита на две подзадачи: построение левого и правого поддеревьев, а реализуется это через разбиение индексных интервалов прямого и симметричного обходов.</li> <li>В задаче о Ханойской башне задача размера \\(n\\) разбивается на две подзадачи размера \\(n-1\\) и одну подзадачу размера \\(1\\) . После последовательного решения этих трех подзадач исходная задача также оказывается решенной.</li> </ul>","path":["Глава 12. Разделяй и властвуй","12.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"Глава 14.   Динамическое программирование","text":"<p>Abstract</p> <p>Ручьи впадают в реки, а реки вливаются в море.</p> <p>Динамическое программирование собирает решения малых задач в ответ на большую задачу и шаг за шагом ведет нас к ее решению.</p>","path":["Глава 14. Динамическое программирование","Глава 14. &nbsp; Динамическое программирование"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>14.1   Введение в динамическое программирование</li> <li>14.2   Свойства задач динамического программирования</li> <li>14.3   Подход к решению задач динамического программирования</li> <li>14.4   Задача о рюкзаке 0-1</li> <li>14.5   Задача о неограниченном рюкзаке</li> <li>14.6   Задача о расстоянии редактирования</li> <li>14.7   Резюме</li> </ul>","path":["Глава 14. Динамическое программирование","Глава 14. &nbsp; Динамическое программирование"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   Свойства задач динамического программирования","text":"<p>В предыдущем разделе мы увидели, как динамическое программирование решает исходную задачу через разложение на подзадачи. На самом деле разложение на подзадачи - это общий алгоритмический подход, но в методе \"разделяй и властвуй\", динамическом программировании и поиске с возвратом акценты расставлены по-разному.</p> <ul> <li>Алгоритмы \"разделяй и властвуй\" рекурсивно раскладывают исходную задачу на несколько независимых подзадач, пока не будет достигнута наименьшая подзадача, а затем в процессе возврата объединяют решения подзадач в решение исходной задачи.</li> <li>Динамическое программирование тоже раскладывает задачу рекурсивно, но его главное отличие от метода \"разделяй и властвуй\" в том, что подзадачи здесь зависят друг от друга и в процессе разложения возникает много перекрывающихся подзадач.</li> <li>Алгоритм поиска с возвратом перебирает все возможные решения через попытки и откат и с помощью обрезки избегает ненужных ветвей поиска. Решение исходной задачи состоит из последовательности решений, и подзадачей можно считать префикс этой последовательности решений.</li> </ul> <p>На практике динамическое программирование часто применяется для задач оптимизации. Такие задачи не только содержат перекрывающиеся подзадачи, но и обладают еще двумя важными свойствами: оптимальной подструктурой и отсутствием последствий.</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   Оптимальная подструктура","text":"<p>Немного изменим задачу о подъеме по лестнице, чтобы нагляднее показать понятие оптимальной подструктуры.</p> <p>Минимальная стоимость подъема по лестнице</p> <p>Дана лестница, по которой можно подниматься на \\(1\\) или на \\(2\\) ступени за раз. На каждой ступени указано неотрицательное целое число, обозначающее цену попадания на эту ступень. Дан массив неотрицательных целых чисел \\(cost\\) , где \\(cost[i]\\) - это цена для ступени \\(i\\) , а \\(cost[0]\\) соответствует земле (начальной позиции). Найдите минимальную суммарную стоимость, необходимую для достижения вершины.</p> <p>Как показано на рисунке 14-6, если цены для ступеней \\(1\\) , \\(2\\) и \\(3\\) равны соответственно \\(1\\) , \\(10\\) и \\(1\\) , то минимальная стоимость подъема с земли на третью ступень равна \\(2\\) .</p> <p></p> <p> Рисунок 14-6   Минимальная стоимость подъема на 3-ю ступень </p> <p>Пусть \\(dp[i]\\) обозначает накопленную стоимость подъема на ступень \\(i\\) . Поскольку на ступень \\(i\\) можно прийти только со ступени \\(i - 1\\) или со ступени \\(i - 2\\) , значение \\(dp[i]\\) может быть либо \\(dp[i - 1] + cost[i]\\) , либо \\(dp[i - 2] + cost[i]\\) . Чтобы минимизировать стоимость, нужно выбрать меньший из этих двух вариантов:</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>Отсюда и возникает смысл оптимальной подструктуры: оптимальное решение исходной задачи строится из оптимальных решений подзадач.</p> <p>Очевидно, что эта задача обладает оптимальной подструктурой: мы берем лучшее из двух оптимальных решений подзадач \\(dp[i-1]\\) и \\(dp[i-2]\\) и на его основе строим оптимальное решение исходной задачи \\(dp[i]\\) .</p> <p>А обладает ли оптимальной подструктурой исходная задача о числе способов подъема по лестнице из прошлого раздела? Формально она не про оптимум, а про подсчет количества. Но если переформулировать ее как \"найдите максимальное количество способов\", мы неожиданно увидим, что хотя исходная задача осталась по сути той же, оптимальная подструктура стала явной: максимальное число способов добраться до ступени \\(n\\) равно сумме максимальных чисел способов добраться до ступеней \\(n-1\\) и \\(n-2\\) . То есть объяснение оптимальной подструктуры в разных задачах может быть довольно гибким.</p> <p>Зная уравнение перехода состояния, а также начальные состояния \\(dp[1] = cost[1]\\) и \\(dp[2] = cost[2]\\) , мы можем сразу написать код динамического программирования:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"Минимальная стоимость подъема по лестнице: динамическое программирование\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [0] * (n + 1)\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1], dp[2] = cost[1], cost[2]\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;int&gt; dp(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: 0, count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![-1; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int *dp = calloc(n + 1, sizeof(int));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = IntArray(n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Минимальная стоимость подъема по лестнице: динамическое программирование ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = cost[1], cost[2]\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-7 показан процесс динамического программирования для этой задачи.</p> <p></p> <p> Рисунок 14-7   Процесс динамического программирования для минимальной стоимости подъема </p> <p>В этой задаче тоже можно оптимизировать пространство, сжав одномерное состояние в нулевое измерение и тем самым уменьшив пространственную сложность с \\(O(n)\\) до \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    a, b := cost[1], cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Минимальная стоимость подъема по лестнице: динамическое программирование ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = cost[1], cost[2]\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   Отсутствие последствий","text":"<p>Отсутствие последствий - одно из ключевых свойств, благодаря которому динамическое программирование вообще может эффективно работать. Его определение таково: если текущее состояние задано однозначно, то его дальнейшее развитие зависит только от него самого и не зависит от всей истории предыдущих состояний.</p> <p>Для примера снова рассмотрим задачу о лестнице. Если дано состояние \\(i\\) , то из него можно перейти в состояния \\(i+1\\) и \\(i+2\\) , соответствующие прыжкам на \\(1\\) и на \\(2\\) ступени. Чтобы сделать один из этих выборов, не нужно знать, какими были состояния до \\(i\\) ; на будущее влияет только текущее состояние \\(i\\) .</p> <p>Однако если добавить в задачу дополнительное ограничение, ситуация изменится.</p> <p>Подъем по лестнице с ограничением</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени, но нельзя два раунда подряд прыгать на \\(1\\) ступень. Сколькими способами можно добраться до вершины?</p> <p>Как показано на рисунке 14-8, на третью ступень теперь существует только \\(2\\) допустимых способа добраться: вариант с тремя последовательными прыжками на \\(1\\) не удовлетворяет ограничению и потому отбрасывается.</p> <p></p> <p> Рисунок 14-8   Число способов подняться на 3-ю ступень при наличии ограничения </p> <p>В этой задаче, если в предыдущем раунде был сделан прыжок на \\(1\\) ступень, то в следующем раунде уже обязательно нужно прыгнуть на \\(2\\) ступени. Иными словами, следующий выбор уже нельзя определить только по текущему состоянию (текущему номеру ступени) - он зависит еще и от предыдущего состояния (с какой ступени мы пришли в прошлый раз).</p> <p>Нетрудно заметить, что в таком виде задача больше не удовлетворяет свойству отсутствия последствий, а уравнение перехода состояния \\(dp[i] = dp[i-1] + dp[i-2]\\) перестает работать, потому что \\(dp[i-1]\\) соответствует прыжку на \\(1\\) ступень, но при этом включает множество вариантов, где предыдущий раунд тоже был прыжком на \\(1\\) ступень. Такие варианты уже нельзя напрямую учитывать в \\(dp[i]\\) , если мы хотим соблюдать ограничение.</p> <p>Поэтому нам нужно расширить определение состояния: состояние \\([i, j]\\) означает, что мы находимся на ступени \\(i\\) и в предыдущем раунде прыгнули на \\(j\\) ступеней, где \\(j \\in \\{1, 2\\}\\) . Такое определение состояния эффективно различает, был ли в прошлом раунде прыжок на \\(1\\) или на \\(2\\) ступени, и позволяет корректно определить, откуда произошло текущее состояние.</p> <ul> <li>Если в предыдущем раунде был прыжок на \\(1\\) ступень, то в раунде перед ним мог быть только прыжок на \\(2\\) ступени, то есть \\(dp[i, 1]\\) может перейти только из \\(dp[i-1, 2]\\) .</li> <li>Если в предыдущем раунде был прыжок на \\(2\\) ступени, то еще шагом раньше можно было прыгнуть либо на \\(1\\) , либо на \\(2\\) ступени, то есть \\(dp[i, 2]\\) может переходить из \\(dp[i-2, 1]\\) или из \\(dp[i-2, 2]\\) .</li> </ul> <p>Как показано на рисунке 14-9, при таком определении \\(dp[i, j]\\) обозначает число способов для состояния \\([i, j]\\) . Тогда уравнение перехода состояния имеет вид:</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> Рисунок 14-9   Рекуррентная связь с учетом ограничения </p> <p>В конце достаточно вернуть \\(dp[n, 1] + dp[n, 2]\\) ; эта сумма и представляет общее число способов добраться до ступени \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице с ограничениями: динамическое программирование\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[][] dp = new int[n + 1][3];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[,] dp = new int[n + 1, 3];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([][3]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = Array(n + 1) { IntArray(3) }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### Подъем по лестнице с ограничениями: динамическое программирование ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В этом примере достаточно дополнительно учитывать только одно предыдущее состояние, поэтому после расширения определения состояния задача снова начинает удовлетворять свойству отсутствия последствий. Однако в некоторых задачах \"зависимость от прошлого\" бывает гораздо серьезнее.</p> <p>Подъем по лестнице с порождением препятствий</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени. При этом, если вы попали на ступень \\(i\\) , система автоматически создает препятствие на ступени \\(2i\\) , и на всех последующих шагах становиться на ступень \\(2i\\) уже нельзя. Например, если в первых двух раундах вы попали на ступени \\(2\\) и \\(3\\) , то после этого нельзя будет попадать на ступени \\(4\\) и \\(6\\) . Сколько существует способов добраться до вершины?</p> <p>В этой задаче следующий прыжок зависит от всех предыдущих состояний, потому что каждый прыжок порождает новое препятствие на более высокой ступени и тем самым влияет на все будущие прыжки. Для задач такого типа динамическое программирование обычно оказывается непригодным.</p> <p>Вообще, многие сложные задачи комбинаторной оптимизации (например, задача коммивояжера) не обладают свойством отсутствия последствий. Для таких задач обычно выбирают другие методы - например, эвристический поиск, генетические алгоритмы, обучение с подкреплением и т.д., - чтобы за ограниченное время получить пригодное локально оптимальное решение.</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   Подход к решению задач динамического программирования","text":"<p>В двух предыдущих разделах были рассмотрены основные свойства задач динамического программирования. Теперь исследуем два более практических вопроса.</p> <ol> <li>Как определить, является ли некоторая задача задачей динамического программирования?</li> <li>С чего начинать решение такой задачи и как выглядит полный процесс решения?</li> </ol>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   Определение задачи","text":"<p>В целом, если задача содержит перекрывающиеся подзадачи, оптимальную подструктуру и удовлетворяет свойству отсутствия последствий, то она обычно подходит для решения с помощью динамического программирования. Однако извлечь все эти свойства напрямую из формулировки задачи бывает трудно. Поэтому на практике мы обычно ослабляем требования и сначала смотрим, подходит ли задача для решения методом поиска с возвратом (полного перебора).</p> <p>Задачи, подходящие для поиска с возвратом, обычно удовлетворяют \"модели дерева решений\". Такие задачи можно описать деревом, где каждый узел представляет одно решение, а каждый путь представляет последовательность решений.</p> <p>Иначе говоря, если в задаче есть четко выраженные решения и ответ порождается последовательностью таких решений, то она удовлетворяет модели дерева решений и обычно допускает решение через поиск с возвратом.</p> <p>Поверх этого у задач динамического программирования есть и некоторые дополнительные \"плюсы\".</p> <ul> <li>В условии задачи фигурируют слова \"максимальный\", \"минимальный\", \"наибольший\", \"наименьший\" и другие формулировки оптимизации.</li> <li>Состояния задачи можно описать списком, многомерной матрицей или деревом, и между состоянием и соседними состояниями существует рекуррентная зависимость.</li> </ul> <p>Соответственно, существуют и некоторые \"минусы\".</p> <ul> <li>Цель задачи состоит в поиске всех возможных решений, а не одного оптимального решения.</li> <li>В формулировке явно присутствуют признаки комбинаторного перечисления, и требуется вернуть сразу много конкретных вариантов.</li> </ul> <p>Если задача удовлетворяет модели дерева решений и имеет достаточно явные \"плюсы\", мы можем предположить, что это задача динамического программирования, а затем проверить это предположение уже в процессе решения.</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   Этапы решения задачи","text":"<p>Конкретный процесс решения задач динамического программирования зависит от природы и сложности задачи, но обычно включает следующие шаги: описание решений, определение состояний, построение таблицы \\(dp\\) , вывод уравнения перехода состояния, определение граничных условий и порядка переходов.</p> <p>Чтобы нагляднее показать этот процесс, рассмотрим классическую задачу \"минимальная сумма пути\".</p> <p>Question</p> <p>Дана двумерная сетка <code>grid</code> размера \\(n \\times m\\) , в каждой клетке которой записано неотрицательное целое число, означающее стоимость прохождения через эту клетку. Робот стартует из левой верхней клетки и за один шаг может двигаться только вправо или вниз, пока не достигнет правой нижней клетки. Верните минимальную сумму пути от левой верхней клетки до правой нижней.</p> <p>На рисунке 14-10 показан пример, в котором минимальная сумма пути равна \\(13\\) .</p> <p></p> <p> Рисунок 14-10   Пример данных для задачи о минимальной сумме пути </p> <p>Шаг 1: понять решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>В этой задаче на каждом раунде решение состоит в том, чтобы из текущей клетки сделать один шаг вниз или вправо. Пусть индексы строки и столбца текущей клетки равны \\([i, j]\\) ; тогда после шага вниз или вправо индексы становятся равными \\([i+1, j]\\) или \\([i, j+1]\\) . Значит, состояние должно включать два переменных индекса: строки и столбца, то есть состояние обозначается как \\([i, j]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, j]\\) , такова: минимальная сумма пути от стартовой клетки \\([0, 0]\\) до клетки \\([i, j]\\) . Ее решение обозначается через \\(dp[i, j]\\) .</p> <p>На этом этапе мы получаем двумерную матрицу \\(dp\\) , показанную на рисунке 14-11, размер которой совпадает с размером входной сетки <code>grid</code> .</p> <p></p> <p> Рисунок 14-11   Определение состояния и таблицы dp </p> <p>Note</p> <p>Как в динамическом программировании, так и в поиске с возвратом, решение задачи можно описать как последовательность решений, а состояние образуется всеми переменными решений. Оно должно содержать всю информацию, достаточную для вывода следующего состояния.</p> <p>Каждому состоянию соответствует некоторая подзадача, и для хранения решений всех подзадач мы определяем таблицу \\(dp\\) ; каждая независимая переменная состояния становится одним измерением таблицы \\(dp\\) . По сути таблица \\(dp\\) - это отображение от состояния к решению соответствующей подзадачи.</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>Для состояния \\([i, j]\\) возможны только два источника: клетка сверху \\([i-1, j]\\) и клетка слева \\([i, j-1]\\) . Следовательно, оптимальная подструктура выглядит так: минимальная сумма пути до \\([i, j]\\) определяется меньшим из двух значений - минимальной суммы пути до \\([i-1, j]\\) и минимальной суммы пути до \\([i, j-1]\\) .</p> <p>По этому рассуждению получается уравнение перехода состояния, показанное на рисунке 14-12:</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> Рисунок 14-12   Оптимальная подструктура и уравнение перехода состояния </p> <p>Note</p> <p>Опираясь на уже определенную таблицу \\(dp\\) , нужно продумать отношение между исходной задачей и подзадачами и найти способ построить оптимальное решение исходной задачи из оптимальных решений подзадач, то есть найти оптимальную подструктуру.</p> <p>Как только оптимальная подструктура найдена, на ее основе можно построить уравнение перехода состояния.</p> <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>В этой задаче состояния в первой строке могут переходить только из клетки слева, а состояния в первом столбце - только из клетки сверху, поэтому первая строка \\(i = 0\\) и первый столбец \\(j = 0\\) образуют граничные условия.</p> <p>Как показано на рисунке 14-13, поскольку каждая клетка получается из клетки слева и клетки сверху, мы можем проходить матрицу циклами: внешний цикл по строкам, внутренний - по столбцам.</p> <p></p> <p> Рисунок 14-13   Граничные условия и порядок перехода состояний </p> <p>Note</p> <p>В динамическом программировании граничные условия используются для инициализации таблицы \\(dp\\) , а в поиске - для обрезки.</p> <p>Смысл порядка перехода состояния в том, чтобы к моменту вычисления текущей подзадачи все более мелкие подзадачи, от которых она зависит, уже были вычислены корректно.</p> <p>После этого анализа мы уже можем напрямую написать код динамического программирования. Однако разложение на подзадачи - это мышление \"сверху вниз\", поэтому с точки зрения мышления более естественно реализовывать задачу в порядке \"полный перебор \\(\\rightarrow\\) поиск с мемоизацией \\(\\rightarrow\\) динамическое программирование\".</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-1","level":3,"title":"1.   Метод 1: полный перебор","text":"<p>Начав со состояния \\([i, j]\\) , мы непрерывно раскладываем его на меньшие состояния \\([i-1, j]\\) и \\([i, j-1]\\) . Рекурсивная функция при этом имеет следующие элементы.</p> <ul> <li>Параметры рекурсии: состояние \\([i, j]\\) .</li> <li>Возвращаемое значение: минимальная сумма пути до \\([i, j]\\) , то есть \\(dp[i, j]\\) .</li> <li>Условие завершения: когда \\(i = 0\\) и \\(j = 0\\) , возвращается стоимость \\(grid[0, 0]\\) .</li> <li>Обрезка: если \\(i &lt; 0\\) или \\(j &lt; 0\\) , индекс выходит за границы, и в этом случае возвращается стоимость \\(+\\infty\\) , обозначающая невозможность.</li> </ul> <p>Код реализации:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"Минимальная сумма пути: полный перебор\"\"\"\n    # Если это верхняя левая ячейка, завершить поиск\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: полный перебор */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: полный перебор */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: полный перебор */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: полный перебор */\nfunction minPathSumDFS(grid, i, j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: полный перебор */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // Если это верхняя левая ячейка, завершить поиск\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  if (i &lt; 0 || j &lt; 0) {\n    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: полный перебор */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: полный перебор */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: полный перебор ###\ndef min_path_sum_dfs(grid, i, j)\n  # Если это верхняя левая ячейка, завершить поиск\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  [left, up].min + grid[i][j]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-14 показано дерево рекурсии с корнем в \\(dp[2, 1]\\) ; в нем содержатся перекрывающиеся подзадачи, и их число будет резко расти вместе с размером сетки <code>grid</code> .</p> <p>По своей сути причина появления перекрывающихся подзадач такова: существует много разных путей от левого верхнего угла до одной и той же клетки.</p> <p></p> <p> Рисунок 14-14   Дерево рекурсии полного перебора </p> <p>У каждого состояния есть два выбора - вниз и вправо, а от левого верхнего угла до правого нижнего нужно сделать всего \\(m + n - 2\\) шагов, поэтому худшая временная сложность равна \\(O(2^{m + n})\\) , где \\(n\\) и \\(m\\) - число строк и столбцов сетки соответственно. Заметим, что в этой оценке не учитывается близость к границам сетки: у граничных клеток остается только один выбор, так что фактическое число путей будет несколько меньше.</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-2","level":3,"title":"2.   Метод 2: поиск с мемоизацией","text":"<p>Введем список памяти <code>mem</code> того же размера, что и сетка <code>grid</code> , для хранения решений всех подзадач и отсечения перекрывающихся подзадач:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"Минимальная сумма пути: поиск с мемоизацией\"\"\"\n    # Если это верхняя левая ячейка, завершить поиск\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # Минимальная стоимость пути для левой и верхней ячеек\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // Если это верхняя левая ячейка, завершить поиск\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  if (i &lt; 0 || j &lt; 0) {\n    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Если запись уже есть, вернуть сразу\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // Минимальная стоимость пути для левой и верхней ячеек\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: поиск с мемоизацией ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # Если это верхняя левая ячейка, завершить поиск\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Если запись уже есть, вернуть сразу\n  return mem[i][j] if mem[i][j] != -1\n  # Минимальная стоимость пути для левой и верхней ячеек\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-15, после добавления мемоизации решение каждой подзадачи вычисляется только один раз, поэтому временная сложность определяется общим числом состояний, то есть равна \\(O(nm)\\) .</p> <p></p> <p> Рисунок 14-15   Дерево рекурсии для поиска с мемоизацией </p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-3","level":3,"title":"3.   Метод 3: динамическое программирование","text":"<p>Итеративная реализация динамического программирования выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Минимальная сумма пути: динамическое программирование\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Инициализация таблицы dp\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # Переход состояний: первая строка\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # Переход состояний: первый столбец\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Инициализация таблицы dp\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // Переход состояний: первая строка\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // Переход состояний: первый столбец\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Инициализация таблицы dp\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // Освободить память\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Инициализация таблицы dp\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: динамическое программирование ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # Инициализация таблицы dp\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # Переход состояний: первая строка\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # Переход состояний: первый столбец\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-16 показан процесс переходов состояний в задаче о минимальной сумме пути. Он проходит по всей сетке, поэтому временная сложность равна \\(O(nm)\\) .</p> <p>Размер массива <code>dp</code> равен \\(n \\times m\\) , поэтому пространственная сложность равна \\(O(nm)\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-16   Процесс динамического программирования для минимальной суммы пути </p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   Оптимизация пространства","text":"<p>Поскольку каждая клетка зависит только от клетки слева и клетки сверху, таблицу \\(dp\\) можно реализовать с помощью одномерного массива, соответствующего одной строке.</p> <p>Обратите внимание: поскольку массив <code>dp</code> теперь может представлять только одну строку состояний, мы не можем заранее инициализировать состояния первого столбца, а должны обновлять их по мере обхода каждой строки:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Минимальная сумма пути: динамическое программирование с оптимизацией памяти\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Инициализация таблицы dp\n    dp = [0] * m\n    # Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # Переход состояний: остальные строки\n    for i in range(1, n):\n        # Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        # Переход состояний: остальные столбцы\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Инициализация таблицы dp\n    int[] dp = new int[m];\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Инициализация таблицы dp\n    dp := make([]int, m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt; n; i++ {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки\n    for i in 1 ..&lt; n {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = new Array(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = new Array(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // Переход состояний: остальные строки\n  for (int i = 1; i &lt; n; i++) {\n    // Переход состояний: первый столбец\n    dp[0] = dp[0] + grid[i][0];\n    // Переход состояний: остальные столбцы\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Инициализация таблицы dp\n    let mut dp = vec![0; m];\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for i in 1..n {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Инициализация таблицы dp\n    int *dp = calloc(m, sizeof(int));\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Инициализация таблицы dp\n    val dp = IntArray(m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки\n    for (i in 1..&lt;n) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # Инициализация таблицы dp\n  dp = Array.new(m, 0)\n  # Переход состояний: первая строка\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # Переход состояний: остальные строки\n  for i in 1...n\n    # Переход состояний: первый столбец\n    dp[0] = dp[0] + grid[i][0]\n    # Переход состояний: остальные столбцы\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   Задача о расстоянии редактирования","text":"<p>Расстояние редактирования, также называемое расстоянием Левенштейна, - это минимальное количество изменений, необходимых для преобразования одной строки в другую. Обычно оно используется для измерения сходства двух последовательностей в информационном поиске и обработке естественного языка.</p> <p>Question</p> <p>Даны две строки \\(s\\) и \\(t\\) . Верните минимальное число шагов редактирования, необходимое для преобразования \\(s\\) в \\(t\\) .</p> <p>Для строки допускаются три операции редактирования: вставка одного символа, удаление одного символа и замена одного символа на произвольный другой символ.</p> <p>Как показано на рисунке 14-27, для преобразования <code>kitten</code> в <code>sitting</code> требуется 3 шага редактирования: 2 операции замены и 1 операция вставки; для преобразования <code>hello</code> в <code>algo</code> также требуется 3 шага: 2 замены и 1 удаление.</p> <p></p> <p> Рисунок 14-27   Пример данных для задачи о расстоянии редактирования </p> <p>Задачу о расстоянии редактирования можно естественным образом объяснить с помощью модели дерева решений. Строки соответствуют узлам дерева, а один шаг решения, то есть одна операция редактирования, соответствует одному ребру дерева.</p> <p>Как показано на рисунке 14-28, если не ограничивать число операций, то каждый узел может порождать множество ребер, и каждое из них соответствует одному из вариантов преобразования. Это означает, что преобразовать <code>hello</code> в <code>algo</code> можно множеством разных путей.</p> <p>С точки зрения дерева решений цель этой задачи - найти кратчайший путь между узлом <code>hello</code> и узлом <code>algo</code> .</p> <p></p> <p> Рисунок 14-28   Представление задачи о расстоянии редактирования через дерево решений </p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>На каждом раунде решение состоит в выполнении одной операции редактирования над строкой \\(s\\) .</p> <p>Нам нужно, чтобы в ходе выполнения операций размер задачи постепенно уменьшался; только тогда можно строить подзадачи. Пусть длины строк \\(s\\) и \\(t\\) равны соответственно \\(n\\) и \\(m\\) ; сначала рассмотрим последние символы этих строк, то есть \\(s[n-1]\\) и \\(t[m-1]\\) .</p> <ul> <li>Если \\(s[n-1]\\) и \\(t[m-1]\\) совпадают, их можно просто пропустить и сразу перейти к сравнению \\(s[n-2]\\) и \\(t[m-2]\\) .</li> <li>Если \\(s[n-1]\\) и \\(t[m-1]\\) различны, нужно выполнить над \\(s\\) одну операцию редактирования (вставку, удаление или замену), чтобы последние символы стали одинаковыми, после чего можно перейти к задаче меньшего размера.</li> </ul> <p>Иначе говоря, каждый шаг решения, то есть операция редактирования над строкой \\(s\\) , меняет те символы, которые еще необходимо сопоставить в строках \\(s\\) и \\(t\\) . Поэтому состояние определяется текущими позициями рассматриваемых символов в \\(s\\) и \\(t\\) , то есть состоянием \\([i, j]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, j]\\) , такова: минимальное число операций редактирования, необходимое для преобразования первых \\(i\\) символов строки \\(s\\) в первые \\(j\\) символов строки \\(t\\).</p> <p>Отсюда получается двумерная таблица \\(dp\\) размера \\((i+1) \\times (j+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>Рассмотрим подзадачу \\(dp[i, j]\\) . Ее последние символы - это \\(s[i-1]\\) и \\(t[j-1]\\) . В зависимости от операции редактирования возможны три случая, показанные на рисунке 14-29.</p> <ol> <li>Вставить после \\(s[i-1]\\) символ \\(t[j-1]\\) ; тогда остается подзадача \\(dp[i, j-1]\\) .</li> <li>Удалить \\(s[i-1]\\) ; тогда остается подзадача \\(dp[i-1, j]\\) .</li> <li>Заменить \\(s[i-1]\\) на \\(t[j-1]\\) ; тогда остается подзадача \\(dp[i-1, j-1]\\) .</li> </ol> <p></p> <p> Рисунок 14-29   Переходы состояния в задаче о расстоянии редактирования </p> <p>Согласно этому анализу оптимальная подструктура такова: минимальное число шагов редактирования для \\(dp[i, j]\\) равно минимуму из трех значений - \\(dp[i, j-1]\\) , \\(dp[i-1, j]\\) и \\(dp[i-1, j-1]\\) - плюс \\(1\\) шаг за текущее редактирование. Значит, уравнение перехода состояния имеет вид:</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>Заметим, что если символы \\(s[i-1]\\) и \\(t[j-1]\\) совпадают, то редактировать текущий символ не нужно. В этом случае уравнение перехода состояния имеет вид:</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда обе строки пусты, число операций редактирования равно \\(0\\) , то есть \\(dp[0, 0] = 0\\) . Когда строка \\(s\\) пуста, а строка \\(t\\) непуста, минимальное число операций равно длине строки \\(t\\) , то есть вся первая строка инициализируется как \\(dp[0, j] = j\\) . Когда строка \\(s\\) непуста, а строка \\(t\\) пуста, минимальное число операций равно длине строки \\(s\\) , то есть весь первый столбец инициализируется как \\(dp[i, 0] = i\\) .</p> <p>Из уравнения перехода видно, что решение \\(dp[i, j]\\) зависит от значений слева, сверху и слева сверху, поэтому всю таблицу \\(dp\\) можно обходить двумя вложенными циклами в прямом порядке.</p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"Редакционное расстояние: динамическое программирование\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # Переход состояний: первая строка и первый столбец\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Редакционное расстояние: динамическое программирование */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // Переход состояний: первая строка и первый столбец\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // Переход состояний: первая строка и первый столбец\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // Переход состояний: первая строка и первый столбец\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // Переход состояний: первая строка и первый столбец\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // Если два символа равны, сразу пропустить их\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Редакционное расстояние: динамическое программирование */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // Переход состояний: первая строка и первый столбец\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Редакционное расстояние: динамическое программирование */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // Переход состояний: первая строка и первый столбец\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### Редакционное расстояние: динамическое программирование ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # Переход состояний: первая строка и первый столбец\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # Если два символа равны, сразу пропустить их\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-30, процесс переходов состояния в задаче о расстоянии редактирования очень похож на задачи о рюкзаке: и там и здесь его можно рассматривать как заполнение двумерной сетки.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-30   Процесс динамического программирования для расстояния редактирования </p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   Оптимизация пространства","text":"<p>Поскольку \\(dp[i,j]\\) зависит от значения сверху \\(dp[i-1, j]\\) , слева \\(dp[i, j-1]\\) и слева сверху \\(dp[i-1, j-1]\\) , прямой обход после оптимизации памяти теряет значение слева сверху, а обратный обход не позволяет заранее построить значение слева \\(dp[i, j-1]\\) . Значит, оба наивных варианта обхода здесь непригодны.</p> <p>Чтобы решить эту проблему, можно использовать переменную <code>leftup</code> для временного сохранения значения слева сверху \\(dp[i-1, j-1]\\) ; после этого остается учитывать только верхнее и левое значения. Тогда ситуация становится аналогичной задаче о полном рюкзаке, и можно выполнять прямой обход. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"Редакционное расстояние: динамическое программирование с оптимизацией памяти\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # Переход состояний: первая строка\n    for j in range(1, m + 1):\n        dp[j] = j\n    # Переход состояний: остальные строки\n    for i in range(1, n + 1):\n        # Переход состояний: первый столбец\n        leftup = dp[0]  # Временно сохранить dp[i-1, j-1]\n        dp[0] += 1\n        # Переход состояний: остальные столбцы\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            else:\n                # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # Обновить до значения dp[i-1, j-1] для следующей итерации\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // Переход состояний: первая строка\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for i := 1; i &lt;= n; i++ {\n        // Переход состояний: первый столбец\n        leftUp := dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftUp\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // Переход состояний: первая строка\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for i in 1 ... n {\n        // Переход состояний: первый столбец\n        var leftup = dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        let leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        let leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // Переход состояний: первая строка\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // Переход состояний: остальные строки\n  for (int i = 1; i &lt;= n; i++) {\n    // Переход состояний: первый столбец\n    int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n    dp[0] = i;\n    // Переход состояний: остальные столбцы\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // Если два символа равны, сразу пропустить их\n        dp[j] = leftup;\n      } else {\n        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // Переход состояний: первая строка\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // Переход состояний: остальные строки\n    for i in 1..=n {\n        // Переход состояний: первый столбец\n        let mut leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i as i32;\n        // Переход состояний: остальные столбцы\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    int res = dp[m];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // Переход состояний: первая строка\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for (i in 1..n) {\n        // Переход состояний: первый столбец\n        var leftup = dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### Редакционное расстояние: динамическое программирование с оптимизацией памяти ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # Переход состояний: первая строка\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # Переход состояний: остальные строки\n  for i in 1...(n + 1)\n    # Переход состояний: первый столбец\n    leftup = dp.first # Временно сохранить dp[i-1, j-1]\n    dp[0] += 1\n    # Переход состояний: остальные столбцы\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # Если два символа равны, сразу пропустить их\n        dp[j] = leftup\n      else\n        # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # Обновить до значения dp[i-1, j-1] для следующей итерации\n    end\n  end\n  dp[m]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   Первое знакомство с динамическим программированием","text":"<p>Динамическое программирование (dynamic programming) - это важная алгоритмическая парадигма, которая разбивает задачу на последовательность более мелких подзадач и за счет хранения их решений избегает повторных вычислений, тем самым резко повышая эффективность по времени.</p> <p>В этом разделе мы начнем с классического примера: сначала представим его грубое решение методом поиска с возвратом, увидим в нем перекрывающиеся подзадачи, а затем постепенно выведем более эффективное решение на основе динамического программирования.</p> <p>Подъем по лестнице</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени. Сколькими способами можно добраться до вершины?</p> <p>Как показано на рисунке 14-1, для лестницы из \\(3\\) ступеней существует \\(3\\) способа добраться до вершины.</p> <p></p> <p> Рисунок 14-1   Число способов подняться на 3-ю ступень </p> <p>Цель этой задачи - вычислить количество способов. Поэтому можно попробовать использовать для ее решения метод поиска с возвратом. Если представить подъем по лестнице как последовательность решений, то мы начинаем от земли и на каждом раунде выбираем прыжок на \\(1\\) или на \\(2\\) ступени; всякий раз, когда достигаем вершины, увеличиваем число способов на \\(1\\) , а если перескакиваем вершину, обрезаем эту ветвь. Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"Бэктрекинг\"\"\"\n    # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n:\n        res[0] += 1\n    # Перебор всех вариантов выбора\n    for choice in choices:\n        # Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n:\n            continue\n        # Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res)\n        # Откат\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: бэктрекинг\"\"\"\n    choices = [1, 2]  # Можно подняться на 1 или 2 ступени\n    state = 0  # Начать подъем с 0-й ступени\n    res = [0]  # Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* Бэктрекинг */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    for (auto &amp;choice : choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // Можно подняться на 1 или 2 ступени\n    int state = 0;                // Начать подъем с 0-й ступени\n    vector&lt;int&gt; res = {0};        // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* Бэктрекинг */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (Integer choice : choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // Можно подняться на 1 или 2 ступени\n    int state = 0; // Начать подъем с 0-й ступени\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* Бэктрекинг */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    foreach (int choice in choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        Backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    int state = 0; // Начать подъем с 0-й ступени\n    List&lt;int&gt; res = [0]; // Использовать res[0] для хранения числа решений\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* Бэктрекинг */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // Перебор всех вариантов выбора\n    for _, choice := range choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state+choice &gt; n {\n            continue\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state+choice, n, res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunc climbingStairsBacktrack(n int) int {\n    // Можно подняться на 1 или 2 ступени\n    choices := []int{1, 2}\n    // Начать подъем с 0-й ступени\n    state := 0\n    res := make([]int, 1)\n    // Использовать res[0] для хранения числа решений\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* Бэктрекинг */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] += 1\n    }\n    // Перебор всех вариантов выбора\n    for choice in choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n {\n            continue\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // Можно подняться на 1 или 2 ступени\n    let state = 0 // Начать подъем с 0-й ступени\n    var res: [Int] = []\n    res.append(0) // Использовать res[0] для хранения числа решений\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* Бэктрекинг */\nfunction backtrack(choices, state, n, res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    const state = 0; // Начать подъем с 0-й ступени\n    const res = new Map();\n    res.set(0, 0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* Бэктрекинг */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    const state = 0; // Начать подъем с 0-й ступени\n    const res = new Map();\n    res.set(0, 0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* Бэктрекинг */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n  if (state == n) {\n    res[0]++;\n  }\n  // Перебор всех вариантов выбора\n  for (int choice in choices) {\n    // Отсечение: нельзя выходить за n-ю ступень\n    if (state + choice &gt; n) continue;\n    // Попытка: сделать выбор и обновить состояние\n    backtrack(choices, state + choice, n, res);\n    // Откат\n  }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n  int state = 0; // Начать подъем с 0-й ступени\n  List&lt;int&gt; res = [];\n  res.add(0); // Использовать res[0] для хранения числа решений\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* Бэктрекинг */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // Перебор всех вариантов выбора\n    for &amp;choice in choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // Можно подняться на 1 или 2 ступени\n    let state = 0; // Начать подъем с 0-й ступени\n    let mut res = Vec::new();\n    res.push(0); // Использовать res[0] для хранения числа решений\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* Бэктрекинг */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res, len);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // Можно подняться на 1 или 2 ступени\n    int state = 0;           // Начать подъем с 0-й ступени\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // Использовать res[0] для хранения числа решений\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* Бэктрекинг */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0] = res[0] + 1\n    // Перебор всех вариантов выбора\n    for (choice in choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // Можно подняться на 1 или 2 ступени\n    val state = 0 // Начать подъем с 0-й ступени\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### Бэктрекинг ###\ndef backtrack(choices, state, n, res)\n  # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n  res[0] += 1 if state == n\n  # Перебор всех вариантов выбора\n  for choice in choices\n    # Отсечение: нельзя выходить за n-ю ступень\n    next if state + choice &gt; n\n\n    # Попытка: сделать выбор и обновить состояние\n    backtrack(choices, state + choice, n, res)\n  end\n  # Откат\nend\n\n### Подъем по лестнице: бэктрекинг ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # Можно подняться на 1 или 2 ступени\n  state = 0 # Начать подъем с 0-й ступени\n  res = [0] # Использовать res[0] для хранения числа решений\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-1","level":2,"title":"14.1.1   Метод 1: полный перебор","text":"<p>Алгоритм поиска с возвратом обычно не раскладывает задачу явно на подзадачи; вместо этого он рассматривает решение как последовательность решений, используя попытки и обрезку для поиска всех возможных ответов.</p> <p>Попробуем посмотреть на задачу именно как на разложение подзадач. Пусть число способов добраться до ступени \\(i\\) равно \\(dp[i]\\) ; тогда \\(dp[i]\\) - это исходная задача, а ее подзадачи включают:</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>Поскольку за один раунд можно подняться только на \\(1\\) или на \\(2\\) ступени, стоя на ступени \\(i\\) , в предыдущий раунд мы могли находиться только на ступени \\(i - 1\\) или на ступени \\(i - 2\\) . Иначе говоря, на ступень \\(i\\) можно попасть только со ступени \\(i -1\\) или со ступени \\(i - 2\\) .</p> <p>Отсюда получается важный вывод: число способов добраться до ступени \\(i - 1\\) плюс число способов добраться до ступени \\(i - 2\\) равно числу способов добраться до ступени \\(i\\). Формула имеет вид:</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>Это означает, что в задаче о подъеме по лестнице между подзадачами существует рекуррентная зависимость, и решение исходной задачи может быть построено на основе решений подзадач. Эта связь показана на рисунке 14-2.</p> <p></p> <p> Рисунок 14-2   Рекуррентная связь числа способов </p> <p>По рекуррентной формуле можно получить решение полного перебора. Начиная с \\(dp[n]\\) , мы рекурсивно разлагаем большую задачу в сумму двух меньших задач , пока не дойдем до наименьших подзадач \\(dp[1]\\) и \\(dp[2]\\) . Их решения уже известны: \\(dp[1] = 1\\) и \\(dp[2] = 2\\) , что означает \\(1\\) и \\(2\\) способа подняться соответственно на \\(1\\)-ю и \\(2\\)-ю ступени.</p> <p>Посмотрите на следующий код: как и стандартный поиск с возвратом, он относится к поиску в глубину, но выглядит более компактно:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"Поиск\"\"\"\n    # dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: поиск\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* Поиск */\nint DFS(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* Поиск */\nfunc dfs(i int) int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* Поиск */\nfunc dfs(i: Int) -&gt; Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* Поиск */\nfunction dfs(i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* Поиск */\nfunction dfs(i: number): number {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* Поиск */\nint dfs(int i) {\n  // dp[1] и dp[2] уже известны, вернуть их\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* Поиск */\nfn dfs(i: usize) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* Подъем по лестнице: поиск */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* Поиск */\nfun dfs(i: Int): Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### Поиск ###\ndef dfs(i)\n  # dp[1] и dp[2] уже известны, вернуть их\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### Подъем по лестнице: поиск ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-3 показано дерево рекурсии, возникающее при полном переборе. Для задачи \\(dp[n]\\) глубина дерева рекурсии равна \\(n\\) , а временная сложность равна \\(O(2^n)\\) . Экспоненциальный рост взрывообразен: если подать на вход достаточно большое значение \\(n\\) , ожидание станет очень долгим.</p> <p></p> <p> Рисунок 14-3   Дерево рекурсии для подъема по лестнице </p> <p>Если посмотреть на рисунок 14-3, то видно, что экспоненциальная временная сложность порождается \"перекрывающимися подзадачами\". Например, \\(dp[9]\\) раскладывается в \\(dp[8]\\) и \\(dp[7]\\) , а \\(dp[8]\\) - в \\(dp[7]\\) и \\(dp[6]\\) ; обе ветви содержат подзадачу \\(dp[7]\\) .</p> <p>Продолжая это рассуждение, мы видим, что подзадачи порождают все более мелкие перекрывающиеся подзадачи без конца. Подавляющая часть вычислительных ресурсов уходит именно на них.</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-2","level":2,"title":"14.1.2   Метод 2: поиск с мемоизацией","text":"<p>Чтобы ускорить алгоритм, мы хотим, чтобы каждая перекрывающаяся подзадача вычислялась только один раз. Для этого объявим массив <code>mem</code> для хранения решения каждой подзадачи и будем обрезать повторные вычисления в процессе поиска.</p> <ol> <li>Когда \\(dp[i]\\) вычисляется впервые, мы сохраняем его в <code>mem[i]</code> для последующего использования.</li> <li>Когда значение \\(dp[i]\\) требуется снова, мы просто берем его напрямую из <code>mem[i]</code> и тем самым избегаем повторного вычисления подзадачи.</li> </ol> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"Поиск с мемоизацией\"\"\"\n    # dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 or i == 2:\n        return i\n    # Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # Сохранить dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: поиск с мемоизацией\"\"\"\n    # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, int[] mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* Поиск с мемоизацией */\nint DFS(int i, int[] mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* Поиск с мемоизацией */\nfunc dfsMem(i int, mem []int) int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* Поиск с мемоизацией */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* Поиск с мемоизацией */\nfunction dfs(i, mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* Поиск с мемоизацией */\nfunction dfs(i: number, mem: number[]): number {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, List&lt;int&gt; mem) {\n  // dp[1] и dp[2] уже известны, вернуть их\n  if (i == 1 || i == 2) return i;\n  // Если запись dp[i] существует, сразу вернуть ее\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // Сохранить dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n  // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* Поиск с мемоизацией */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, int *mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* Поиск с мемоизацией */\nfun dfs(i: Int, mem: IntArray): Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2) return i\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### Поиск с мемоизацией ###\ndef dfs(i, mem)\n  # dp[1] и dp[2] уже известны, вернуть их\n  return i if i == 1 || i == 2\n  # Если запись dp[i] существует, сразу вернуть ее\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # Сохранить dp[i]\n  mem[i] = count\nend\n\n### Подъем по лестнице: поиск с мемоизацией ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-4, после введения мемоизации каждая перекрывающаяся подзадача вычисляется только один раз, и временная сложность оптимизируется до \\(O(n)\\) . Это огромный скачок в эффективности.</p> <p></p> <p> Рисунок 14-4   Дерево рекурсии для поиска с мемоизацией </p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-3","level":2,"title":"14.1.3   Метод 3: динамическое программирование","text":"<p>Поиск с мемоизацией - это метод \"сверху вниз\" : мы начинаем с исходной задачи (корня), рекурсивно раскладываем более крупные подзадачи на меньшие, пока не достигнем наименьших подзадач с уже известным ответом (листьев). Затем в процессе возврата постепенно собираем решения подзадач и тем самым получаем решение исходной задачи.</p> <p>Напротив, динамическое программирование - это метод \"снизу вверх\" : начиная с решений наименьших подзадач, мы итеративно строим решения для более крупных подзадач, пока не получим ответ на исходную задачу.</p> <p>Поскольку в динамическом программировании нет этапа возврата, для его реализации достаточно обычных циклов, без рекурсии. В приведенном ниже коде мы инициализируем массив <code>dp</code> для хранения решений подзадач; он выполняет ту же роль, что и массив <code>mem</code> в мемоизированном поиске:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: динамическое программирование\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [0] * (n + 1)\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1], dp[2] = 1, 2\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;int&gt; dp(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Подъем по лестнице: динамическое программирование */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: 0, count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1).fill(-1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1).fill(-1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1] = 1;\n  dp[2] = 2;\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Подъем по лестнице: динамическое программирование */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![-1; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Подъем по лестнице: динамическое программирование */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = IntArray(n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Подъем по лестнице: динамическое программирование ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = 1, 2\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-5 смоделирован процесс выполнения этого кода.</p> <p></p> <p> Рисунок 14-5   Процесс динамического программирования для подъема по лестнице </p> <p>Как и в поиске с возвратом, в динамическом программировании используется понятие \"состояние\" для обозначения некоторого этапа решения задачи; каждое состояние соответствует одной подзадаче и ее локально оптимальному решению. Например, в задаче о лестнице состояние определяется текущим номером ступени \\(i\\) .</p> <p>На основе сказанного можно подвести несколько часто используемых терминов динамического программирования.</p> <ul> <li>Массив <code>dp</code> называют таблицей dp, а \\(dp[i]\\) обозначает решение подзадачи, соответствующей состоянию \\(i\\) .</li> <li>Состояния, соответствующие наименьшим подзадачам (первая и вторая ступени), называют начальными состояниями.</li> <li>Рекуррентную формулу \\(dp[i] = dp[i-1] + dp[i-2]\\) называют уравнением перехода состояния.</li> </ul>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   Оптимизация пространства","text":"<p>Внимательный читатель мог заметить, что поскольку \\(dp[i]\\) зависит только от \\(dp[i-1]\\) и \\(dp[i-2]\\) , нам не нужен весь массив <code>dp</code> для хранения ответов всех подзадач ; достаточно двух переменных, которые будут \"перекатываться\" вперед. Код имеет вид:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: динамическое программирование с оптимизацией памяти\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Подъем по лестнице: динамическое программирование с оптимизацией памяти ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Из кода видно, что после отказа от массива <code>dp</code> пространственная сложность уменьшается с \\(O(n)\\) до \\(O(1)\\) .</p> <p>Во многих задачах динамического программирования текущее состояние зависит лишь от ограниченного числа предыдущих состояний. Тогда можно сохранять только действительно нужные состояния и за счет \"уменьшения размерности\" экономить память. Этот прием оптимизации памяти называют \"скользящими переменными\" или \"скользящим массивом\".</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   Задача о рюкзаке 0-1","text":"<p>Задача о рюкзаке является отличным примером для начала изучения динамического программирования и представляет собой одну из наиболее распространенных форм этой задачи. У нее существует множество вариантов, например задача о рюкзаке 0-1, задача о полном рюкзаке, задача о многократном рюкзаке и т.д.</p> <p>В этом разделе сначала разберем самый распространенный вариант - задачу о рюкзаке 0-1.</p> <p>Question</p> <p>Даны \\(n\\) предметов. Вес \\(i\\)-го предмета равен \\(wgt[i-1]\\) , стоимость равна \\(val[i-1]\\) . Также дан рюкзак вместимости \\(cap\\) . Каждый предмет можно выбрать только один раз. Найдите максимальную суммарную стоимость, которую можно поместить в рюкзак при заданной вместимости.</p> <p>Как видно на рисунке 14-17, поскольку номер предмета \\(i\\) начинается с \\(1\\) , а индексы массива начинаются с \\(0\\) , предмету \\(i\\) соответствуют вес \\(wgt[i-1]\\) и стоимость \\(val[i-1]\\) .</p> <p></p> <p> Рисунок 14-17   Пример данных для задачи о рюкзаке 0-1 </p> <p>Задачу о рюкзаке 0-1 можно рассматривать как процесс из \\(n\\) раундов принятия решений: для каждого предмета есть два решения - не класть его в рюкзак или положить в рюкзак. Поэтому задача удовлетворяет модели дерева решений.</p> <p>Цель задачи - найти \"максимальную суммарную стоимость при ограниченной вместимости рюкзака\", а это с большой вероятностью указывает на задачу динамического программирования.</p> <p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>Для каждого предмета возможны два случая: не класть его в рюкзак, тогда вместимость не меняется; или положить его в рюкзак, тогда оставшаяся вместимость уменьшается. Отсюда получается определение состояния: текущий номер предмета \\(i\\) и текущая вместимость рюкзака \\(c\\) , то есть состояние обозначается как \\([i, c]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, c]\\) , такова: максимальная стоимость, которую можно получить, используя первые \\(i\\) предметов и рюкзак вместимости \\(c\\). Ее решение обозначается через \\(dp[i, c]\\) .</p> <p>Искомым значением является \\(dp[n, cap]\\) , значит, нам нужна двумерная таблица \\(dp\\) размера \\((n+1) \\times (cap+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>После того как мы принимаем решение по предмету \\(i\\) , остается подзадача, связанная с первыми \\(i-1\\) предметами. Здесь возможны два случая.</p> <ul> <li>Не класть предмет \\(i\\) : вместимость рюкзака не меняется, и состояние переходит в \\([i-1, c]\\) .</li> <li>Положить предмет \\(i\\) : вместимость рюкзака уменьшается на \\(wgt[i-1]\\) , а стоимость увеличивается на \\(val[i-1]\\) , и состояние переходит в \\([i-1, c-wgt[i-1]]\\) .</li> </ul> <p>Этот анализ и раскрывает оптимальную подструктуру задачи: максимальная стоимость \\(dp[i, c]\\) равна лучшему из двух вариантов - не брать предмет \\(i\\) или взять предмет \\(i\\). Отсюда получается уравнение перехода состояния:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>Нужно учитывать, что если вес текущего предмета \\(wgt[i - 1]\\) превышает оставшуюся вместимость \\(c\\) , то предмет можно только не брать.</p> <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда предметов нет или вместимость рюкзака равна \\(0\\) , максимальная стоимость равна \\(0\\) ; то есть весь первый столбец \\(dp[i, 0]\\) и вся первая строка \\(dp[0, c]\\) заполняются нулями.</p> <p>Текущее состояние \\([i, c]\\) зависит от состояния сверху \\([i-1, c]\\) и состояния слева сверху \\([i-1, c-wgt[i-1]]\\) , поэтому достаточно двумя вложенными циклами пройти по всей таблице \\(dp\\) в прямом порядке.</p> <p>После этого анализа реализуем по порядку: полный перебор, поиск с мемоизацией и динамическое программирование.</p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-1","level":3,"title":"1.   Метод 1: полный перебор","text":"<p>Код поиска содержит следующие элементы.</p> <ul> <li>Параметры рекурсии: состояние \\([i, c]\\) .</li> <li>Возвращаемое значение: решение подзадачи \\(dp[i, c]\\) .</li> <li>Условие завершения: когда номер предмета выходит за границу, то есть \\(i = 0\\) , или оставшаяся вместимость равна \\(0\\) , рекурсия завершается и возвращается стоимость \\(0\\) .</li> <li>Обрезка: если вес текущего предмета превышает оставшуюся вместимость рюкзака, то можно только не класть этот предмет.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: полный перебор\"\"\"\n    # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 or c == 0:\n        return 0\n    # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: полный перебор */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: полный перебор */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: полный перебор */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: полный перебор */\nfunction knapsackDFS(wgt, val, i, c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: полный перебор */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Вернуть вариант с большей стоимостью из двух возможных\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: полный перебор */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: полный перебор */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: полный перебор ###\ndef knapsack_dfs(wgt, val, i, c)\n  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  return 0 if i == 0 || c == 0\n  # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Вернуть вариант с большей стоимостью из двух возможных\n  [no, yes].max\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-18, поскольку каждый предмет создает две ветви поиска - \"не брать\" и \"брать\", временная сложность равна \\(O(2^n)\\) .</p> <p>Посмотрев на дерево рекурсии, легко заметить наличие перекрывающихся подзадач, например \\(dp[1, 10]\\) и подобных. Когда число предметов растет, вместимость рюкзака велика, а особенно когда много предметов с одинаковым весом, количество перекрывающихся подзадач быстро увеличивается.</p> <p></p> <p> Рисунок 14-18   Дерево полного перебора для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-2","level":3,"title":"2.   Метод 2: мемоизация","text":"<p>Чтобы каждая перекрывающаяся подзадача вычислялась только один раз, используем таблицу памяти <code>mem</code> для хранения решений подзадач, где <code>mem[i][c]</code> соответствует \\(dp[i, c]\\) .</p> <p>После введения мемоизации временная сложность определяется числом подзадач , то есть равна \\(O(n \\times cap)\\) . Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"Рюкзак 0-1: поиск с мемоизацией\"\"\"\n    # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 or c == 0:\n        return 0\n    # Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // Если запись уже есть, вернуть сразу\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Сохранить и вернуть вариант с большей стоимостью из двух решений\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: поиск с мемоизацией ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  return 0 if i == 0 || c == 0\n  # Если запись уже есть, вернуть сразу\n  return mem[i][c] if mem[i][c] != -1\n  # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Сохранить и вернуть вариант с большей стоимостью из двух решений\n  mem[i][c] = [no, yes].max\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-19 показаны ветви поиска, которые были отсечены благодаря мемоизации.</p> <p></p> <p> Рисунок 14-19   Дерево поиска с мемоизацией для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-3","level":3,"title":"3.   Метод 3: динамическое программирование","text":"<p>По своей сути динамическое программирование здесь - это процесс последовательного заполнения таблицы \\(dp\\) в соответствии с переходами состояний. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: динамическое программирование\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # Переход состояний\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: динамическое программирование ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-20, и временная сложность, и пространственная сложность определяются размером массива <code>dp</code> , то есть равны \\(O(n \\times cap)\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-20   Процесс динамического программирования для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   Оптимизация пространства","text":"<p>Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с \\(O(n^2)\\) до \\(O(n)\\) .</p> <p>Если пойти дальше, можно спросить: можно ли оптимизировать память так, чтобы использовать только один массив? Наблюдение показывает, что каждое состояние зависит от клетки прямо сверху и клетки слева сверху. Предположим, что у нас есть только один массив, и в момент начала обхода строки \\(i\\) он еще хранит состояния строки \\(i-1\\) .</p> <ul> <li>Если обходить массив слева направо, то к моменту вычисления \\(dp[i, j]\\) значения слева сверху \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) могут уже быть перезаписаны, и правильный результат перехода состояния получить не удастся.</li> <li>Если же обходить массив справа налево, проблема перезаписи не возникает, и переход состояния вычисляется корректно.</li> </ul> <p>На рисунке 14-21 показан процесс перехода от строки \\(i = 1\\) к строке \\(i = 2\\) при использовании одного массива. С его помощью удобно понять различие между прямым и обратным обходом.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-21   Процесс динамического программирования после оптимизации памяти для рюкзака 0-1 </p> <p>В коде для этого достаточно удалить первое измерение массива <code>dp</code> , а внутренний цикл заменить на обратный обход:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [0] * (cap + 1)\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Обход в обратном порядке\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([]int, cap+1)\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Обход в обратном порядке\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: cap + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        // Обход в обратном порядке\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(cap + 1).fill(0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(cap + 1).fill(0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    // Обход в обратном порядке\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; cap + 1];\n    // Переход состояний\n    for i in 1..=n {\n        // Обход в обратном порядке\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(cap + 1, sizeof(int));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = IntArray(cap + 1)\n    // Переход состояний\n    for (i in 1..n) {\n        // Обход в обратном порядке\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(cap + 1, 0)\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Обход в обратном порядке\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   Резюме","text":"","path":["Глава 14. Динамическое программирование","14.7 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Динамическое программирование раскладывает задачу на подзадачи и повышает вычислительную эффективность за счет хранения решений этих подзадач и устранения повторных вычислений.</li> <li>Если не учитывать затраты времени, то любую задачу динамического программирования можно решить с помощью поиска с возвратом (полного перебора), однако в дереве рекурсии возникает множество перекрывающихся подзадач, из-за чего эффективность крайне низка. После введения таблицы памяти можно хранить решения всех уже вычисленных подзадач и гарантировать, что каждая перекрывающаяся подзадача будет вычисляться только один раз.</li> <li>Поиск с мемоизацией - это рекурсивный метод \"сверху вниз\", а соответствующее ему динамическое программирование - это итеративный метод \"снизу вверх\", похожий на заполнение таблицы. Поскольку текущее состояние обычно зависит только от части локальных состояний, можно убрать одно измерение таблицы \\(dp\\) и тем самым снизить пространственную сложность.</li> <li>Разложение на подзадачи - это общий алгоритмический подход, но в методе \"разделяй и властвуй\", динамическом программировании и поиске с возвратом он имеет разные свойства.</li> <li>Для задач динамического программирования характерны три главных свойства: перекрывающиеся подзадачи, оптимальная подструктура и отсутствие последствий.</li> <li>Если оптимальное решение исходной задачи можно построить из оптимальных решений подзадач, то задача обладает оптимальной подструктурой.</li> <li>Отсутствие последствий означает, что для данного состояния его дальнейшее развитие определяется только этим состоянием и не зависит от всех прошлых состояний. Многие задачи комбинаторной оптимизации этим свойством не обладают и потому не могут эффективно решаться с помощью динамического программирования.</li> </ul> <p>Задачи о рюкзаке</p> <ul> <li>Задача о рюкзаке - один из самых типичных классов задач динамического программирования; она включает варианты 0-1 рюкзака, полного рюкзака, многократного рюкзака и другие.</li> <li>В задаче о рюкзаке 0-1 состояние определяется как максимальная стоимость первых \\(i\\) предметов в рюкзаке вместимости \\(c\\) . Рассматривая два решения - не брать предмет и брать предмет, - можно получить оптимальную подструктуру и вывести уравнение перехода состояния. При оптимизации памяти, поскольку каждое состояние зависит от значения сверху и слева сверху, внутренний цикл нужно выполнять в обратном порядке, чтобы не перезаписать нужное значение.</li> <li>В задаче о полном рюкзаке число экземпляров каждого предмета не ограничено, поэтому при выборе предмета переход состояния отличается от варианта 0-1. Поскольку состояние зависит от значения сверху и слева, после оптимизации памяти внутренний цикл следует выполнять в прямом порядке.</li> <li>Задача о размене монет - это вариант задачи о полном рюкзаке. Здесь вместо \"максимальной стоимости\" ищется \"минимальное число монет\", поэтому в уравнении перехода \\(\\max()\\) заменяется на \\(\\min()\\) . Кроме того, вместо условия \"не превышать вместимость рюкзака\" нужно ровно набрать целевую сумму, поэтому значение \\(amt + 1\\) используется как обозначение недопустимого решения \"сумму набрать нельзя\".</li> <li>В задаче о размене монет II вместо \"минимального числа монет\" требуется найти \"число комбинаций монет\", поэтому в уравнении перехода оператор \\(\\min()\\) заменяется на суммирование.</li> </ul> <p>Задача о расстоянии редактирования</p> <ul> <li>Расстояние редактирования (расстояние Левенштейна) используется для измерения сходства двух строк и определяется как минимальное число операций редактирования, необходимых для преобразования одной строки в другую; допустимые операции - вставка, удаление и замена.</li> <li>В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых \\(i\\) символов строки \\(s\\) в первые \\(j\\) символов строки \\(t\\) . Если \\(s[i] \\ne t[j]\\) , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же \\(s[i] = t[j]\\) , то редактировать текущий символ не нужно.</li> <li>В задаче о расстоянии редактирования состояние зависит от значений сверху, слева и слева сверху. Поэтому после оптимизации памяти ни прямой, ни обратный обход сам по себе не дает корректного перехода состояния. Для решения этой проблемы значение слева сверху временно сохраняется в отдельной переменной, что делает ситуацию эквивалентной задаче о полном рюкзаке и позволяет использовать прямой обход.</li> </ul>","path":["Глава 14. Динамическое программирование","14.7 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   Задача о полном рюкзаке","text":"<p>В этом разделе сначала решим еще одну распространенную задачу о рюкзаке - задачу о полном рюкзаке, а затем рассмотрим один из ее типичных частных случаев: задачу о размене монет.</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   Задача о полном рюкзаке","text":"<p>Question</p> <p>Даны \\(n\\) предметов. Вес \\(i\\)-го предмета равен \\(wgt[i-1]\\) , стоимость равна \\(val[i-1]\\) . Также дан рюкзак вместимости \\(cap\\) . Каждый предмет можно выбирать многократно. Найдите максимальную суммарную стоимость, которую можно поместить в рюкзак при заданной вместимости. Пример показан на рисунке 14-22.</p> <p></p> <p> Рисунок 14-22   Пример данных для задачи о полном рюкзаке </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Задача о полном рюкзаке очень похожа на задачу о рюкзаке 0-1; разница состоит только в том, что количество выборов каждого предмета не ограничено.</p> <ul> <li>В задаче о рюкзаке 0-1 каждого предмета существует только один экземпляр, поэтому после того как предмет \\(i\\) помещен в рюкзак, выбирать можно только из первых \\(i-1\\) предметов.</li> <li>В задаче о полном рюкзаке количество предметов не ограничено, поэтому после того как предмет \\(i\\) помещен в рюкзак, можно продолжать выбирать из первых \\(i\\) предметов.</li> </ul> <p>При этом состояние \\([i, c]\\) в задаче о полном рюкзаке может изменяться двумя способами.</p> <ul> <li>Не брать предмет \\(i\\) : как и в задаче о рюкзаке 0-1, переход осуществляется в \\([i-1, c]\\) .</li> <li>Взять предмет \\(i\\) : в отличие от рюкзака 0-1 переход происходит в \\([i, c-wgt[i-1]]\\) .</li> </ul> <p>Следовательно, уравнение перехода состояния принимает вид:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   Реализация кода","text":"<p>Если сравнить код этой задачи с кодом задачи о рюкзаке 0-1, то окажется, что в переходе состояний меняется только одна деталь: вместо \\(i-1\\) появляется \\(i\\) ; все остальное остается таким же:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Полный рюкзак: динамическое программирование\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # Переход состояний\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Полный рюкзак: динамическое программирование */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Полный рюкзак: динамическое программирование */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Полный рюкзак: динамическое программирование */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Полный рюкзак: динамическое программирование */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Полный рюкзак: динамическое программирование */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Полный рюкзак: динамическое программирование */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Полный рюкзак: динамическое программирование */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Полный рюкзак: динамическое программирование ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   Оптимизация пространства","text":"<p>Поскольку текущее состояние переходит из состояния слева и состояния сверху, после оптимизации памяти каждую строку таблицы \\(dp\\) нужно обходить слева направо.</p> <p>Этот порядок обхода как раз противоположен задаче о рюкзаке 0-1. Разницу удобно понять по рисунку ниже.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-23   Процесс динамического программирования после оптимизации памяти для полного рюкзака </p> <p>Код реализации здесь довольно прост: достаточно просто убрать первое измерение массива <code>dp</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Полный рюкзак: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [0] * (cap + 1)\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([]int, cap+1)\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: cap + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; cap + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(cap + 1, sizeof(int));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = IntArray(cap + 1)\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Полный рюкзак: динамическое программирование ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n# ## Полный рюкзак: динамическое программирование с оптимизацией памяти ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(cap + 1, 0)\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   Задача о размене монет","text":"<p>Задача о рюкзаке представляет собой целый класс задач динамического программирования, у которого есть множество вариантов, и одной из таких вариаций является задача о размене монет.</p> <p>Question</p> <p>Даны \\(n\\) видов монет, номинал монеты \\(i\\) равен \\(coins[i - 1]\\) , а целевая сумма равна \\(amt\\) . Монеты каждого вида можно брать многократно. Требуется найти минимальное число монет, которыми можно набрать целевую сумму. Если набрать сумму невозможно, верните \\(-1\\) . Пример показан на рисунке 14-24.</p> <p></p> <p> Рисунок 14-24   Пример данных для задачи о размене монет </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Задачу о размене монет можно рассматривать как частный случай задачи о полном рюкзаке ; между ними существуют следующие соответствия и различия.</p> <ul> <li>Эти две задачи можно взаимно преобразовать: \"предмет\" соответствует \"монете\", \"вес предмета\" соответствует \"номиналу монеты\", а \"вместимость рюкзака\" соответствует \"целевой сумме\".</li> <li>Цель оптимизации противоположна: в задаче о полном рюкзаке нужно максимизировать стоимость предметов, а в задаче о размене монет - минимизировать число монет.</li> <li>В задаче о полном рюкзаке ищется решение, не превышающее вместимость, а в задаче о размене монет требуется ровно набрать целевую сумму.</li> </ul> <p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>Подзадача, соответствующая состоянию \\([i, a]\\) , выглядит так: минимальное число монет из первых \\(i\\) видов, которыми можно набрать сумму \\(a\\). Решение этой подзадачи обозначается как \\(dp[i, a]\\) .</p> <p>Размер двумерной таблицы \\(dp\\) равен \\((n+1) \\times (amt+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>По сравнению с задачей о полном рюкзаке здесь есть два отличия в уравнении перехода состояния.</p> <ul> <li>Нужно искать минимум, а не максимум, поэтому оператор \\(\\max()\\) заменяется на \\(\\min()\\) .</li> <li>Оптимизируемое значение - это число монет, а не суммарная стоимость, поэтому при выборе монеты нужно просто прибавить \\(1\\) .</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда целевая сумма равна \\(0\\) , минимальное число монет для ее набора равно \\(0\\) , то есть весь первый столбец \\(dp[i, 0]\\) заполняется нулями.</p> <p>Когда монет нет, невозможно набрать никакую целевую сумму \\(&gt; 0\\) ; это и есть недопустимое решение. Чтобы функция \\(\\min()\\) в уравнении перехода состояния могла распознавать и отбрасывать такие недопустимые решения, удобно использовать значение \\(+ \\infty\\) ; то есть всю первую строку \\(dp[0, a]\\) нужно инициализировать значением \\(+ \\infty\\) .</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"<p>Большинство языков программирования не предоставляет представление для \\(+ \\infty\\) в целочисленном виде, поэтому обычно приходится заменять его на максимальное значение типа <code>int</code> . Но тогда возникает риск переполнения: операция \\(+ 1\\) в уравнении перехода может переполнить большое число.</p> <p>Поэтому здесь мы используем число \\(amt + 1\\) как обозначение недопустимого решения, потому что для набора суммы \\(amt\\) максимум нужно не больше чем \\(amt\\) монет. Перед возвратом результата проверяем, равно ли \\(dp[n, amt]\\) значению \\(amt + 1\\) ; если да, то возвращаем \\(-1\\) , что означает невозможность набрать целевую сумму. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: динамическое программирование\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Инициализация таблицы dp\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Переход состояний: первая строка и первый столбец\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][amt + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Размен монет: динамическое программирование */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, amt + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Переход состояний: первая строка и первый столбец\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Переход состояний: первая строка и первый столбец\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Размен монет: динамическое программирование */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Размен монет: динамическое программирование */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Переход состояний: первая строка и первый столбец\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Меньшее из двух решений: не брать или взять монету i\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Размен монет: динамическое программирование */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Переход состояний: первая строка и первый столбец\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Размен монет: динамическое программирование */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Переход состояний: первая строка и первый столбец\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Размен монет: динамическое программирование ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Переход состояний: первая строка и первый столбец\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Меньшее из двух решений: не брать или взять монету i\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-25, процесс динамического программирования для задачи о размене монет очень похож на задачу о полном рюкзаке.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-25   Процесс динамического программирования для задачи о размене монет </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   Оптимизация пространства","text":"<p>Оптимизация пространства для задачи о размене монет выполняется так же, как и для полного рюкзака:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Инициализация таблицы dp\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            else:\n                # Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Инициализация таблицы dp\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Прямой обход\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Инициализация таблицы dp\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a];\n      } else {\n        // Меньшее из двух решений: не брать или взять монету i\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Инициализация таблицы dp\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Инициализация таблицы dp\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Размен монет: динамическое программирование с оптимизацией памяти ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Инициализация таблицы dp\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a]\n      else\n        # Меньшее из двух решений: не брать или взять монету i\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   Задача о размене монет II","text":"<p>Question</p> <p>Даны \\(n\\) видов монет, номинал монеты \\(i\\) равен \\(coins[i - 1]\\) , а целевая сумма равна \\(amt\\) . Монеты каждого вида можно брать многократно. Найдите число различных комбинаций монет, которыми можно набрать целевую сумму. Пример показан на рисунке 14-26.</p> <p></p> <p> Рисунок 14-26   Пример данных для задачи о размене монет II </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   Идея динамического программирования","text":"<p>По сравнению с предыдущей задачей здесь целью является число комбинаций. Поэтому подзадача меняется на следующую: число комбинаций из первых \\(i\\) видов монет, которыми можно набрать сумму \\(a\\). При этом таблица \\(dp\\) по-прежнему остается двумерной матрицей размера \\((n+1) \\times (amt + 1)\\) .</p> <p>Число комбинаций для текущего состояния равно сумме числа комбинаций для двух решений: не брать текущую монету и брать текущую монету. Поэтому уравнение перехода состояния принимает вид:</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>Когда целевая сумма равна \\(0\\) , ее можно набрать, не выбирая ни одной монеты, поэтому весь первый столбец \\(dp[i, 0]\\) нужно инициализировать единицами. Когда монет нет, невозможно набрать никакую сумму \\(&gt;0\\) , поэтому вся первая строка \\(dp[0, a]\\) должна быть заполнена нулями.</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет II: динамическое программирование\"\"\"\n    n = len(coins)\n    # Инициализация таблицы dp\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Инициализация первого столбца\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # Переход состояний\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][amt + 1];\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Размен монет II: динамическое программирование */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, amt + 1];\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Размен монет II: динамическое программирование */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Инициализация первого столбца\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Размен монет II: динамическое программирование */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Инициализация первого столбца\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Размен монет II: динамическое программирование */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Инициализация первого столбца\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Размен монет II: динамическое программирование */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Инициализация первого столбца\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Инициализация первого столбца\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Сумма двух решений: не брать или взять монету i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Размен монет II: динамическое программирование */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Инициализация первого столбца\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Размен монет II: динамическое программирование */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Инициализация первого столбца\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Размен монет II: динамическое программирование ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Инициализация первого столбца\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Сумма двух решений: не брать или взять монету i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   Оптимизация пространства","text":"<p>При оптимизации памяти способ остается тем же самым: достаточно убрать измерение, отвечающее за виды монет:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет II: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(coins)\n    # Инициализация таблицы dp\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            else:\n                # Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // Инициализация таблицы dp\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Прямой обход\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a];\n      } else {\n        // Сумма двух решений: не брать или взять монету i\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Инициализация таблицы dp\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Размен монет II: динамическое программирование с оптимизацией памяти ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # Инициализация таблицы dp\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a]\n      else\n        # Сумма двух решений: не брать или взять монету i\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"Глава 9.   Графы","text":"<p>Abstract</p> <p>В жизни мы похожи на вершины, соединенные множеством невидимых ребер.</p> <p>Каждая встреча и каждое расставание оставляют в этой огромной сети свой след.</p>","path":["Глава 9. Граф","Глава 9. &nbsp; Графы"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>9.1   Граф</li> <li>9.2   Базовые операции над графами</li> <li>9.3   Обход графа</li> <li>9.4   Резюме</li> </ul>","path":["Глава 9. Граф","Глава 9. &nbsp; Графы"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   Граф","text":"<p>Граф (graph) - это нелинейная структура данных, состоящая из вершин (vertex) и ребер (edge). Граф \\(G\\) можно абстрактно представить как множество вершин \\(V\\) и множество ребер \\(E\\) . Ниже приведен пример графа, содержащего 5 вершин и 7 ребер.</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>Если рассматривать вершины как узлы, а ребра как ссылки, соединяющие узлы, граф можно считать структурой данных, расширяющей связный список. Как показано на рисунке 9-1, по сравнению с линейными отношениями (связный список) и отношениями разделения (дерево), сетевые отношения (граф) обладают большей свободой и потому являются более сложными.</p> <p></p> <p> Рисунок 9-1   Связь между связным списком, деревом и графом </p>","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   Распространенные типы и термины графов","text":"<p>В зависимости от наличия направления у ребер графы делятся на неориентированные графы (undirected graph) и ориентированные графы (directed graph) , как показано на рисунке 9-2.</p> <ul> <li>В неориентированном графе ребро представляет двустороннюю связь между двумя вершинами, например дружеские отношения в социальных сетях.</li> <li>В ориентированном графе ребро имеет направление, то есть ребра \\(A \\rightarrow B\\) и \\(A \\leftarrow B\\) независимы друг от друга, например отношения подписки и подписчиков.</li> </ul> <p></p> <p> Рисунок 9-2   Ориентированный и неориентированный графы </p> <p>В зависимости от того, связаны ли все вершины между собой, граф делится на связный граф (connected graph) и несвязный граф (disconnected graph) , как показано на рисунке 9-3.</p> <ul> <li>В связном графе из любой вершины можно достичь любой другой вершины.</li> <li>В несвязном графе существует по крайней мере одна вершина, недостижимая из текущей.</li> </ul> <p></p> <p> Рисунок 9-3   Связный и несвязный графы </p> <p>Мы также можем добавить к ребрам переменную \"вес\" и получить показанный ниже взвешенный граф (weighted graph). Например, в мобильных играх вроде Honor of Kings система рассчитывает \"близость\" между игроками по времени совместной игры, и такую сеть близости можно представить взвешенным графом.</p> <p></p> <p> Рисунок 9-4   Взвешенный и невзвешенный графы </p> <p>Со структурой данных \"граф\" связаны следующие основные термины.</p> <ul> <li>Смежность (adjacency): если между двумя вершинами существует ребро, то такие вершины называются смежными. На рисунке 9-4 с вершиной 1 смежны вершины 2, 3 и 5.</li> <li>Путь (path): последовательность ребер от вершины A до вершины B называется путем из A в B. На рисунке 9-4 последовательность ребер 1-5-2-4 является одним из путей от вершины 1 к вершине 4.</li> <li>Степень (degree): количество ребер, принадлежащих вершине. Для ориентированного графа входящая степень (in-degree) показывает, сколько ребер входит в вершину, а исходящая степень (out-degree) показывает, сколько ребер из нее выходит.</li> </ul>","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   Представление графа","text":"<p>Распространенные способы представления графа включают \"матрицу смежности\" и \"список смежности\". Ниже для примера рассматривается неориентированный граф.</p>","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   Матрица смежности","text":"<p>Пусть число вершин графа равно \\(n\\) ; тогда матрица смежности (adjacency matrix) использует матрицу размера \\(n \\times n\\) для представления графа, где каждая строка и каждый столбец соответствуют вершине, а элементы матрицы показывают наличие или отсутствие ребра.</p> <p>Как показано на рисунке 9-5, обозначим матрицу смежности через \\(M\\) , а список вершин через \\(V\\) ; тогда элемент матрицы \\(M[i, j] = 1\\) означает наличие ребра между вершинами \\(V[i]\\) и \\(V[j]\\) , а элемент \\(M[i, j] = 0\\) означает отсутствие ребра.</p> <p></p> <p> Рисунок 9-5   Представление графа матрицей смежности </p> <p>Матрица смежности обладает следующими особенностями.</p> <ul> <li>В простом графе вершина не может соединяться сама с собой, поэтому элементы на главной диагонали матрицы смежности не имеют значения.</li> <li>Для неориентированного графа ребра в обоих направлениях эквивалентны, поэтому матрица смежности симметрична относительно главной диагонали.</li> <li>Если заменить в матрице смежности значения \\(1\\) и \\(0\\) на веса, то можно представить взвешенный граф.</li> </ul> <p>При представлении графа матрицей смежности можно напрямую обращаться к элементам матрицы и получать сведения о ребрах, поэтому операции добавления, удаления, поиска и изменения обладают высокой эффективностью и выполняются за \\(O(1)\\) . Однако пространственная сложность матрицы составляет \\(O(n^2)\\) , поэтому она требует значительных затрат памяти.</p>","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   Список смежности","text":"<p>Список смежности (adjacency list) использует \\(n\\) списков для представления графа, где узлы списка обозначают вершины. \\(i\\)-й список соответствует вершине \\(i\\) и хранит все смежные с ней вершины, то есть все вершины, соединенные с данной вершиной. На рисунке 9-6 показан пример графа, представленного списком смежности.</p> <p></p> <p> Рисунок 9-6   Представление графа списком смежности </p> <p>Список смежности хранит только реально существующие ребра, а общее число ребер обычно значительно меньше \\(n^2\\) , поэтому он лучше экономит память. Однако для поиска ребра в списке смежности требуется обходить список, поэтому по времени он уступает матрице смежности.</p> <p>Если посмотреть на рисунок 9-6, можно заметить, что структура списка смежности очень похожа на цепную адресацию в хеш-таблицах, поэтому здесь можно использовать похожие методы оптимизации эффективности. Например, если список слишком длинный, его можно преобразовать в AVL-дерево или красно-черное дерево, чтобы снизить временную сложность с \\(O(n)\\) до \\(O(\\log n)\\) ; также список можно преобразовать в хеш-таблицу, чтобы довести временную сложность до \\(O(1)\\) .</p>","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   Типичные применения графов","text":"<p>Как показано в таблице 9-1, многие реальные системы можно моделировать с помощью графов, а соответствующие задачи затем сводить к задачам вычислений на графах.</p> <p> Таблица 9-1   Распространенные графы в реальной жизни </p> Вершина Ребро Задача вычислений на графе Социальные сети Пользователь Дружеская связь Рекомендация потенциальных друзей Линии метро Станция Связь между станциями Рекомендация кратчайшего маршрута Солнечная система Небесное тело Гравитационное взаимодействие между телами Вычисление орбит планет","path":["Глава 9. Граф","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   Базовые операции графа","text":"<p>Базовые операции графа можно разделить на операции над \"ребрами\" и операции над \"вершинами\". При двух способах представления, \"матрице смежности\" и \"списке смежности\", реализация этих операций различается.</p>","path":["Глава 9. Граф","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   Реализация на основе матрицы смежности","text":"<p>Пусть дан неориентированный граф с числом вершин \\(n\\) . Тогда способы реализации различных операций показаны на рисунках ниже.</p> <ul> <li>Добавление или удаление ребра: достаточно изменить соответствующее ребро в матрице смежности, что требует \\(O(1)\\) времени. Поскольку граф неориентированный, необходимо одновременно обновить ребра в обоих направлениях.</li> <li>Добавление вершины: в конец матрицы смежности добавляется строка и столбец, полностью заполненные нулями; это требует \\(O(n)\\) времени.</li> <li>Удаление вершины: из матрицы смежности удаляется строка и столбец. При удалении первой строки и первого столбца достигается худший случай, когда требуется \"сдвинуть влево вверх\" \\((n-1)^2\\) элементов, поэтому используется \\(O(n^2)\\) времени.</li> <li>Инициализация: передаются \\(n\\) вершин, затем инициализируется список вершин <code>vertices</code> длины \\(n\\) , что требует \\(O(n)\\) времени; после этого инициализируется матрица смежности <code>adjMat</code> размера \\(n \\times n\\) , что требует \\(O(n^2)\\) времени.</li> </ul> Инициализация матрицы смежностиДобавление ребраУдаление ребраДобавление вершиныУдаление вершины <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-7   Инициализация матрицы смежности, добавление и удаление ребер и вершин </p> <p>Ниже приведен код реализации графа на основе матрицы смежности:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"Класс неориентированного графа на основе матрицы смежности\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"Конструктор\"\"\"\n        # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n        self.vertices: list[int] = []\n        # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n        self.adj_mat: list[list[int]] = []\n        # Добавление вершины\n        for val in vertices:\n            self.add_vertex(val)\n        # Добавить ребра\n        # Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Получить число вершин\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"Добавление вершины\"\"\"\n        n = self.size()\n        # Добавить значение новой вершины в список вершин\n        self.vertices.append(val)\n        # Добавить строку в матрицу смежности\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # Добавить столбец в матрицу смежности\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"Удаление вершины\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # Удалить вершину с индексом index из списка вершин\n        self.vertices.pop(index)\n        # Удалить строку с индексом index из матрицы смежности\n        self.adj_mat.pop(index)\n        # Удалить столбец с индексом index из матрицы смежности\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"Добавление ребра\"\"\"\n        # Параметры i и j соответствуют индексам элементов vertices\n        # Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"Удаление ребра\"\"\"\n        # Параметры i и j соответствуют индексам элементов vertices\n        # Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"Вывести матрицу смежности\"\"\"\n        print(\"Список вершин =\", self.vertices)\n        print(\"Матрица смежности =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n  public:\n    /* Конструктор */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // Добавление вершины\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* Добавление вершины */\n    void addVertex(int val) {\n        int n = size();\n        // Добавить значение новой вершины в список вершин\n        vertices.push_back(val);\n        // Добавить строку в матрицу смежности\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // Добавить столбец в матрицу смежности\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* Удаление вершины */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        // Удалить вершину с индексом index из списка вершин\n        vertices.erase(vertices.begin() + index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.erase(adjMat.begin() + index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    void addEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    void removeEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    void print() {\n        cout &lt;&lt; \"Список вершин = \";\n        printVector(vertices);\n        cout &lt;&lt; \"Матрица смежности =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // Добавление вершины\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* Добавление вершины */\n    public void addVertex(int val) {\n        int n = size();\n        // Добавить значение новой вершины в список вершин\n        vertices.add(val);\n        // Добавить строку в матрицу смежности\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // Добавить столбец в матрицу смежности\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* Удаление вершины */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // Удалить вершину с индексом index из списка вершин\n        vertices.remove(index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.remove(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void addEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void removeEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* Вывести матрицу смежности */\n    public void print() {\n        System.out.print(\"Список вершин = \");\n        System.out.println(vertices);\n        System.out.println(\"Матрица смежности =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    List&lt;List&lt;int&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* Добавление вершины */\n    public void AddVertex(int val) {\n        int n = Size();\n        // Добавить значение новой вершины в список вершин\n        vertices.Add(val);\n        // Добавить строку в матрицу смежности\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // Добавить столбец в матрицу смежности\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* Удаление вершины */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // Удалить вершину с индексом index из списка вершин\n        vertices.RemoveAt(index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.RemoveAt(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void AddEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void RemoveEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    public void Print() {\n        Console.Write(\"Список вершин = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"Матрица смежности =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\ntype graphAdjMat struct {\n    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    vertices []int\n    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    adjMat [][]int\n}\n\n/* Конструктор */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // Добавление вершины\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // Инициализировать граф\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // Добавить ребра\n    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* Получить число вершин */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* Добавление вершины */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // Добавить значение новой вершины в список вершин\n    g.vertices = append(g.vertices, val)\n    // Добавить строку в матрицу смежности\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // Добавить столбец в матрицу смежности\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* Удаление вершины */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // Удалить вершину с индексом index из списка вершин\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // Удалить строку с индексом index из матрицы смежности\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // Удалить столбец с индексом index из матрицы смежности\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* Добавление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* Удаление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* Вывести матрицу смежности */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\tСписок вершин = %v\\n\", g.vertices)\n    fmt.Printf(\"\\tМатрица смежности = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    private var vertices: [Int] // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    private var adjMat: [[Int]] // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // Добавление вершины\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* Получить число вершин */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* Добавление вершины */\n    func addVertex(val: Int) {\n        let n = size()\n        // Добавить значение новой вершины в список вершин\n        vertices.append(val)\n        // Добавить строку в матрицу смежности\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // Добавить столбец в матрицу смежности\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* Удаление вершины */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        // Удалить вершину с индексом index из списка вершин\n        vertices.remove(at: index)\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.remove(at: index)\n        // Удалить столбец с индексом index из матрицы смежности\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    func addEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    func removeEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Вывести матрицу смежности */\n    func print() {\n        Swift.print(\"Список вершин = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"Матрица смежности =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* Добавление вершины */\n    addVertex(val) {\n        const n = this.size();\n        // Добавить значение новой вершины в список вершин\n        this.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Добавить столбец в матрицу смежности\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Удалить вершину с индексом index из списка вершин\n        this.vertices.splice(index, 1);\n\n        // Удалить строку с индексом index из матрицы смежности\n        this.adjMat.splice(index, 1);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    addEdge(i, j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    removeEdge(i, j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    print() {\n        console.log('Список вершин = ', this.vertices);\n        console.log('Матрица смежности =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vertices: number[]; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    adjMat: number[][]; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* Добавление вершины */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // Добавить значение новой вершины в список вершин\n        this.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Добавить столбец в матрицу смежности\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Удалить вершину с индексом index из списка вершин\n        this.vertices.splice(index, 1);\n\n        // Удалить строку с индексом index из матрицы смежности\n        this.adjMat.splice(index, 1);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    addEdge(i: number, j: number): void {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    removeEdge(i: number, j: number): void {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    print(): void {\n        console.log('Список вершин = ', this.vertices);\n        console.log('Матрица смежности =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // Элемент вершины: элемент представляет «значение вершины», индекс представляет «индекс вершины»\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n  /* Конструктор */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // Добавление вершины\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // Добавить ребра\n    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* Получить число вершин */\n  int size() {\n    return vertices.length;\n  }\n\n  /* Добавление вершины */\n  void addVertex(int val) {\n    int n = size();\n    // Добавить значение новой вершины в список вершин\n    vertices.add(val);\n    // Добавить строку в матрицу смежности\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // Добавить столбец в матрицу смежности\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* Удаление вершины */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // Удалить вершину с индексом index из списка вершин\n    vertices.removeAt(index);\n    // Удалить строку с индексом index из матрицы смежности\n    adjMat.removeAt(index);\n    // Удалить столбец с индексом index из матрицы смежности\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* Добавление ребра */\n  // Параметры i и j соответствуют индексам элементов vertices\n  void addEdge(int i, int j) {\n    // Обработка выхода индекса за границы и случая равенства\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* Удаление ребра */\n  // Параметры i и j соответствуют индексам элементов vertices\n  void removeEdge(int i, int j) {\n    // Обработка выхода индекса за границы и случая равенства\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* Вывести матрицу смежности */\n  void printAdjMat() {\n    print(\"Список вершин = $vertices\");\n    print(\"Матрица смежности = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* Тип неориентированного графа на основе матрицы смежности */\npub struct GraphAdjMat {\n    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    pub vertices: Vec&lt;i32&gt;,\n    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* Конструктор */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // Добавление вершины\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* Получить число вершин */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* Добавление вершины */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // Добавить значение новой вершины в список вершин\n        self.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        self.adj_mat.push(vec![0; n]);\n        // Добавить столбец в матрицу смежности\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // Удалить вершину с индексом index из списка вершин\n        self.vertices.remove(index);\n        // Удалить строку с индексом index из матрицы смежности\n        self.adj_mat.remove(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* Добавление ребра */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // Параметры i и j соответствуют индексам элементов vertices\n        // Обработка выхода индекса за границы и случая равенства\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // Параметры i и j соответствуют индексам элементов vertices\n        // Обработка выхода индекса за границы и случая равенства\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    pub fn print(&amp;self) {\n        println!(\"Список вершин = {:?}\", self.vertices);\n        println!(\"Матрица смежности =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* Структура неориентированного графа на основе матрицы смежности */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* Конструктор */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* Деструктор */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* Добавление вершины */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"Количество вершин графа уже достигло максимума\\n\");\n        return;\n    }\n    // Добавить n-ю вершину и обнулить n-ю строку и столбец\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* Удаление вершины */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"индекс вершины выходит за границы\\n\");\n        return;\n    }\n    // Удалить вершину с индексом index из списка вершин\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // Удалить строку с индексом index из матрицы смежности\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // Удалить столбец с индексом index из матрицы смежности\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* Добавление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"индексы ребра выходят за границы или совпадают\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* Удаление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"индексы ребра выходят за границы или совпадают\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* Вывести матрицу смежности */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"Список вершин = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"Матрица смежности =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    init {\n        // Добавление вершины\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* Получить число вершин */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* Добавление вершины */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // Добавить значение новой вершины в список вершин\n        vertices.add(_val)\n        // Добавить строку в матрицу смежности\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // Добавить столбец в матрицу смежности\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* Удаление вершины */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // Удалить вершину с индексом index из списка вершин\n        vertices.removeAt(index)\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.removeAt(index)\n        // Удалить столбец с индексом index из матрицы смежности\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    fun addEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    fun removeEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Вывести матрицу смежности */\n    fun print() {\n        print(\"Список вершин = \")\n        println(vertices)\n        println(\"Матрица смежности =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### Класс неориентированного графа на основе матрицы смежности ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### Конструктор ###\n    # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    @vertices = []\n    # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    @adj_mat = []\n    # Добавление вершины\n    vertices.each { |val| add_vertex(val) }\n    # Добавить ребра\n    # Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### Получение числа вершин ###\n  def size\n    @vertices.length\n  end\n\n  ### Добавление вершины ###\n  def add_vertex(val)\n    n = size\n    # Добавить значение новой вершины в список вершин\n    @vertices &lt;&lt; val\n    # Добавить строку в матрицу смежности\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # Добавить столбец в матрицу смежности\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### Удаление вершины ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # Удалить вершину с индексом index из списка вершин\n    @vertices.delete_at(index)\n    # Удалить строку с индексом index из матрицы смежности\n    @adj_mat.delete_at(index)\n    # Удалить столбец с индексом index из матрицы смежности\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### Добавление ребра ###\n  def add_edge(i, j)\n    # Параметры i и j соответствуют индексам элементов vertices\n    # Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### Удаление ребра ###\n  def remove_edge(i, j)\n    # Параметры i и j соответствуют индексам элементов vertices\n    # Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### Вывести матрицу смежности ###\n  def __print__\n    puts \"Список вершин = #{@vertices}\"\n    puts 'Матрица смежности ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 9. Граф","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   Реализация на основе списка смежности","text":"<p>Пусть неориентированный граф содержит в сумме \\(n\\) вершин и \\(m\\) ребер. Тогда различные операции можно реализовать способом, показанным на рисунках ниже.</p> <ul> <li>Добавление ребра: достаточно добавить ребро в конец списка, соответствующего вершине; это требует \\(O(1)\\) времени. Поскольку граф неориентированный, необходимо одновременно добавить ребра в обоих направлениях.</li> <li>Удаление ребра: нужно найти и удалить указанное ребро в списке, соответствующем вершине; это требует \\(O(m)\\) времени. В неориентированном графе необходимо удалить ребра в обоих направлениях.</li> <li>Добавление вершины: в список смежности добавляется еще один список, а новая вершина становится его головным узлом; это требует \\(O(1)\\) времени.</li> <li>Удаление вершины: требуется пройти по всему списку смежности и удалить все ребра, содержащие указанную вершину; это требует \\(O(n + m)\\) времени.</li> <li>Инициализация: в списке смежности создаются \\(n\\) вершин и \\(2m\\) ребер; это требует \\(O(n + m)\\) времени.</li> </ul> Инициализация списка смежностиДобавление ребраУдаление ребраДобавление вершиныУдаление вершины <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-8   Инициализация списка смежности, добавление и удаление ребер и вершин </p> <p>Ниже приведен код списка смежности. По сравнению с рисунками выше, реальная реализация имеет следующие отличия.</p> <ul> <li>Чтобы упростить добавление и удаление вершин, а также сделать код проще, мы используем список, то есть динамический массив, вместо связного списка.</li> <li>Для хранения списка смежности используется хеш-таблица, где <code>key</code> - это экземпляр вершины, а <code>value</code> - список смежных вершин данной вершины.</li> </ul> <p>Кроме того, в списке смежности используется класс <code>Vertex</code> для представления вершины. Причина в том, что если, как и в матрице смежности, различать вершины по индексам списка, то при удалении вершины с индексом \\(i\\) пришлось бы обходить весь список смежности и уменьшать на \\(1\\) все индексы, большие \\(i\\) , что крайне неэффективно. Если же каждая вершина является уникальным экземпляром <code>Vertex</code> , то после удаления одной вершины остальные вершины менять уже не требуется.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"Класс неориентированного графа на основе списка смежности\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"Конструктор\"\"\"\n        # Список смежности, где key — вершина, а value — все смежные ей вершины\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # Добавить все вершины и ребра\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Получить число вершин\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Добавление ребра\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Добавить ребро vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Удаление ребра\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Удалить ребро vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"Добавление вершины\"\"\"\n        if vet in self.adj_list:\n            return\n        # Добавить новый список в список смежности\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"Удаление вершины\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # Удалить из списка смежности список, соответствующий вершине vet\n        self.adj_list.pop(vet)\n        # Обойти списки других вершин и удалить все ребра, содержащие vet\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"Вывести список смежности\"\"\"\n        print(\"Список смежности =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n  public:\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* Удалить указанный узел из vector */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* Конструктор */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // Добавить все вершины и ребра\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int size() {\n        return adjList.size();\n    }\n\n    /* Добавление ребра */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"вершина не существует\");\n        // Добавить ребро vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* Удаление ребра */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"вершина не существует\");\n        // Удалить ребро vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* Добавление вершины */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* Удаление вершины */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"вершина не существует\");\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.erase(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    void print() {\n        cout &lt;&lt; \"Список смежности =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Конструктор */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // Добавить все вершины и ребра\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* Добавление ребра */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Добавить ребро vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* Удаление ребра */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Удалить ребро vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* Добавление вершины */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* Удаление вершины */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.remove(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    public void print() {\n        System.out.println(\"Список смежности =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Конструктор */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // Добавить все вершины и ребра\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* Добавление ребра */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Добавить ребро vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* Удаление ребра */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Удалить ребро vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* Добавление вершины */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList.Add(vet, []);\n    }\n\n    /* Удаление вершины */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.Remove(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    public void Print() {\n        Console.WriteLine(\"Список смежности =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* Класс неориентированного графа на основе списка смежности */\ntype graphAdjList struct {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList map[Vertex][]Vertex\n}\n\n/* Конструктор */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // Добавить все вершины и ребра\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* Получить число вершин */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* Добавление ребра */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Добавить ребро vet1 - vet2, добавив анонимную struct{}\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* Удаление ребра */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Удалить ребро vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* Добавление вершины */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // Добавить новый список в список смежности\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* Удаление вершины */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // Удалить из списка смежности список, соответствующий вершине vet\n    delete(g.adjList, vet)\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* Вывести список смежности */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"Список смежности = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* Конструктор */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // Добавить все вершины и ребра\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* Получить число вершин */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* Добавление ребра */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Добавить ребро vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* Удаление ребра */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Удалить ребро vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* Добавление вершины */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // Добавить новый список в список смежности\n        adjList[vet] = []\n    }\n\n    /* Удаление вершины */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.removeValue(forKey: vet)\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* Вывести список смежности */\n    public func print() {\n        Swift.print(\"Список смежности =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList;\n\n    /* Конструктор */\n    constructor(edges) {\n        this.adjList = new Map();\n        // Добавить все вершины и ребра\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* Добавление ребра */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Добавить ребро vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Удаление ребра */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить ребро vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Добавление вершины */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // Добавить новый список в список смежности\n        this.adjList.set(vet, []);\n    }\n\n    /* Удаление вершины */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        this.adjList.delete(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Вывести список смежности */\n    print() {\n        console.log('Список смежности =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* Конструктор */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // Добавить все вершины и ребра\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* Добавление ребра */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Добавить ребро vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Удаление ребра */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить ребро vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Добавление вершины */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // Добавить новый список в список смежности\n        this.adjList.set(vet, []);\n    }\n\n    /* Удаление вершины */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        this.adjList.delete(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Вывести список смежности */\n    print(): void {\n        console.log('Список смежности =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n  // Список смежности, где key — вершина, а value — все смежные ей вершины\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* Конструктор */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* Получить число вершин */\n  int size() {\n    return adjList.length;\n  }\n\n  /* Добавление ребра */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Добавить ребро vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* Удаление ребра */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Удалить ребро vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* Добавление вершины */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // Добавить новый список в список смежности\n    adjList[vet] = [];\n  }\n\n  /* Удаление вершины */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // Удалить из списка смежности список, соответствующий вершине vet\n    adjList.remove(vet);\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* Вывести список смежности */\n  void printAdjList() {\n    print(\"Список смежности =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* Тип неориентированного графа на основе списка смежности */\npub struct GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* Конструктор */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // Добавить все вершины и ребра\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* Получить число вершин */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* Добавление ребра */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Добавить ребро vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* Удаление ребра */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Удалить ребро vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* Добавление вершины */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // Добавить новый список в список смежности\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* Удаление вершины */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // Удалить из списка смежности список, соответствующий вершине vet\n        self.adj_list.remove(&amp;vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    pub fn print(&amp;self) {\n        println!(\"Список смежности =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* Структура узла */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // Вершина\n    struct AdjListNode *next; // Узел-преемник\n} AdjListNode;\n\n/* Найти узел, соответствующий вершине */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Вспомогательная функция добавления ребра */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // Вставка в голову\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* Вспомогательная функция удаления ребра */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // Искать в связном списке узел, соответствующий vet\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // Удалить из связного списка узел, соответствующий vet\n    pre-&gt;next = cur-&gt;next;\n    // Освободить память\n    free(cur);\n}\n\n/* Класс неориентированного графа на основе списка смежности */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // Массив узлов\n    int size;                     // Количество узлов\n} GraphAdjList;\n\n/* Конструктор */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* Деструктор */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* Найти узел, соответствующий вершине */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Добавление ребра */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // Добавить ребро vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* Удаление ребра */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // Удалить ребро vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* Добавление вершины */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // Добавить новый список в список смежности\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* Удаление вершины */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // Удалить из списка смежности список, соответствующий вершине vet\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // Сдвинуть вершины после данной вперед, чтобы заполнить образовавшийся пробел\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* Конструктор */\n    init {\n        // Добавить все вершины и ребра\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* Получить число вершин */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* Добавление ребра */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Добавить ребро vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* Удаление ребра */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Удалить ребро vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* Добавление вершины */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // Добавить новый список в список смежности\n        adjList[vet] = mutableListOf()\n    }\n\n    /* Удаление вершины */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.remove(vet)\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* Вывести список смежности */\n    fun print() {\n        println(\"Список смежности =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### Класс неориентированного графа на основе списка смежности ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### Конструктор ###\n  def initialize(edges)\n    # Список смежности, где key — вершина, а value — все смежные ей вершины\n    @adj_list = {}\n    # Добавить все вершины и ребра\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### Получение числа вершин ###\n  def size\n    @adj_list.length\n  end\n\n  ### Добавление ребра ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### Удаление ребра ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # Удалить ребро vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### Добавление вершины ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # Добавить новый список в список смежности\n    @adj_list[vet] = []\n  end\n\n  ### Удаление вершины ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # Удалить из списка смежности список, соответствующий вершине vet\n    @adj_list.delete(vet)\n    # Обойти списки других вершин и удалить все ребра, содержащие vet\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### Вывести список смежности ###\n  def __print__\n    puts 'Список смежности ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 9. Граф","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   Сравнение эффективности","text":"<p>Пусть в графе имеется \\(n\\) вершин и \\(m\\) ребер. В таблице 9-2 сравниваются временная и пространственная эффективность матрицы смежности и списка смежности. Обратите внимание: список смежности (связный список) соответствует реализации из этой статьи, а список смежности (хеш-таблица) означает вариант, в котором все списки заменены хеш-таблицами.</p> <p> Таблица 9-2   Сравнение матрицы смежности и списка смежности </p> Матрица смежности Список смежности (связный список) Список смежности (хеш-таблица) Проверка смежности \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Добавление ребра \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Удаление ребра \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Добавление вершины \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) Удаление вершины \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) Занимаемая память \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>Если смотреть только на таблицу, может показаться, что список смежности на основе хеш-таблицы является лучшим и по времени, и по памяти. Но на практике операции над ребрами в матрице смежности обычно выполняются быстрее, потому что там нужен лишь один доступ к массиву или одно присваивание. В целом матрица смежности воплощает принцип \"обмена пространства на время\", а список смежности - принцип \"обмена времени на пространство\".</p>","path":["Глава 9. Граф","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   Обход графа","text":"<p>Дерево представляет отношение \"один ко многим\", тогда как граф обладает большей свободой и может выражать произвольные отношения \"многие ко многим\". Поэтому дерево можно рассматривать как частный случай графа. Очевидно, что операции обхода дерева также являются частным случаем операций обхода графа.</p> <p>И графы, и деревья требуют применения алгоритмов обхода. Способы обхода графа также делятся на два типа: обход в ширину и обход в глубину.</p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   Обход в ширину","text":"<p>Обход в ширину - это способ обхода от ближнего к дальнему, при котором начиная с некоторого узла сначала посещают ближайшие вершины, а затем слой за слоем расширяются наружу. Как показано на рисунке 9-9, начиная с вершины в левом верхнем углу, мы сначала обходим все смежные вершины этой вершины, затем все смежные вершины следующей вершины и так далее, пока не будут посещены все вершины.</p> <p></p> <p> Рисунок 9-9   Обход графа в ширину </p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   Реализация алгоритма","text":"<p>BFS обычно реализуется с помощью очереди, код приведен ниже. Очередь обладает свойством \"первым пришел - первым вышел\", что хорошо соответствует идее BFS \"от ближнего к дальнему\".</p> <ol> <li>Поместить стартовую вершину обхода <code>startVet</code> в очередь и запустить цикл.</li> <li>На каждой итерации цикла извлекать вершину из головы очереди и записывать ее посещение, после чего добавлять все смежные вершины этой вершины в хвост очереди.</li> <li>Повторять шаг <code>2.</code> до тех пор, пока не будут посещены все вершины.</li> </ol> <p>Чтобы предотвратить повторный обход вершин, нам нужно хеш-множество <code>visited</code> , в котором записывается, какие вершины уже посещены.</p> <p>Tip</p> <p>Хеш-множество можно рассматривать как хеш-таблицу, которая хранит только <code>key</code> и не хранит <code>value</code> . Оно позволяет выполнять добавление, удаление и проверку наличия <code>key</code> за \\(O(1)\\) времени. Благодаря уникальности <code>key</code> хеш-множество обычно используется, например, для устранения повторов.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Обход в ширину\"\"\"\n    # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n    # Последовательность обхода вершин\n    res = []\n    # Хеш-множество для хранения уже посещенных вершин\n    visited = set[Vertex]([start_vet])\n    # Очередь используется для реализации BFS\n    que = deque[Vertex]([start_vet])\n    # Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while len(que) &gt; 0:\n        vet = que.popleft()  # Извлечь головную вершину из очереди\n        res.append(vet)  # Отметить посещенную вершину\n        # Обойти все смежные вершины данной вершины\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # Пропустить уже посещенную вершину\n            que.append(adj_vet)  # Помещать в очередь только непосещенные вершины\n            visited.add(adj_vet)  # Отметить эту вершину как посещенную\n    # Вернуть последовательность обхода вершин\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Последовательность обхода вершин\n    vector&lt;Vertex *&gt; res;\n    // Хеш-множество для хранения уже посещенных вершин\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // Очередь используется для реализации BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // Извлечь головную вершину из очереди\n        res.push_back(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // Пропустить уже посещенную вершину\n            que.push(adjVet);        // Помещать в очередь только непосещенные вершины\n            visited.emplace(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Хеш-множество для хранения уже посещенных вершин\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // Извлечь головную вершину из очереди\n        res.add(vet);            // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // Пропустить уже посещенную вершину\n            que.offer(adjVet);   // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // Очередь используется для реализации BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // Извлечь головную вершину из очереди\n        res.Add(vet);               // Отметить посещенную вершину\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // Пропустить уже посещенную вершину\n            }\n            que.Enqueue(adjVet);   // Помещать в очередь только непосещенные вершины\n            visited.Add(adjVet);   // Отметить эту вершину как посещенную\n        }\n    }\n\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Последовательность обхода вершин\n    res := make([]Vertex, 0)\n    // Хеш-множество для хранения уже посещенных вершин\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // Очередь используется для реализации BFS, срез используется для имитации очереди\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    for len(queue) &gt; 0 {\n        // Извлечь головную вершину из очереди\n        vet := queue[0]\n        queue = queue[1:]\n        // Отметить посещенную вершину\n        res = append(res, vet)\n        // Обойти все смежные вершины данной вершины\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // Помещать в очередь только непосещенные вершины\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Последовательность обхода вершин\n    var res: [Vertex] = []\n    // Хеш-множество для хранения уже посещенных вершин\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // Очередь используется для реализации BFS\n    var que: [Vertex] = [startVet]\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while !que.isEmpty {\n        let vet = que.removeFirst() // Извлечь головную вершину из очереди\n        res.append(vet) // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // Пропустить уже посещенную вершину\n            }\n            que.append(adjVet) // Помещать в очередь только непосещенные вершины\n            visited.insert(adjVet) // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphBFS(graph, startVet) {\n    // Последовательность обхода вершин\n    const res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited = new Set();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    const que = [startVet];\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.length) {\n        const vet = que.shift(); // Извлечь головную вершину из очереди\n        res.push(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            que.push(adjVet); // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Последовательность обхода вершин\n    const res: Vertex[] = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    const que = [startVet];\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.length) {\n        const vet = que.shift(); // Извлечь головную вершину из очереди\n        res.push(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            que.push(adjVet); // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* Обход в ширину */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  // Последовательность обхода вершин\n  List&lt;Vertex&gt; res = [];\n  // Хеш-множество для хранения уже посещенных вершин\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // Очередь используется для реализации BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // Извлечь головную вершину из очереди\n    res.add(vet); // Отметить посещенную вершину\n    // Обойти все смежные вершины данной вершины\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // Пропустить уже посещенную вершину\n      }\n      que.add(adjVet); // Помещать в очередь только непосещенные вершины\n      visited.add(adjVet); // Отметить эту вершину как посещенную\n    }\n  }\n  // Вернуть последовательность обхода вершин\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Последовательность обхода вершин\n    let mut res = vec![];\n    // Хеш-множество для хранения уже посещенных вершин\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // Очередь используется для реализации BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // Отметить посещенную вершину\n\n        // Обойти все смежные вершины данной вершины\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // Пропустить уже посещенную вершину\n                }\n                que.push_back(adj_vet); // Помещать в очередь только непосещенные вершины\n                visited.insert(adj_vet); // Отметить эту вершину как посещенную\n            }\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* Структура очереди узлов */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* Конструктор */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* Проверка, пуста ли очередь */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* Операция добавления в очередь */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* Операция извлечения из очереди */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* Проверить, была ли вершина уже посещена */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // Искать узел обходом за O(n) времени\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // Очередь используется для реализации BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // Извлечь головную вершину из очереди\n        res[(*resSize)++] = vet;      // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // Пропустить уже посещенную вершину\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // Помещать в очередь только непосещенные вершины\n                visited[(*visitedSize)++] = node-&gt;vertex; // Отметить эту вершину как посещенную\n            }\n            node = node-&gt;next;\n        }\n    }\n    // Освободить память\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // Последовательность обхода вершин\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Хеш-множество для хранения уже посещенных вершин\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // Очередь используется для реализации BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.isEmpty()) {\n        val vet = que.poll() // Извлечь головную вершину из очереди\n        res.add(vet)         // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // Пропустить уже посещенную вершину\n            que.offer(adjVet)   // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet) // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### Обход в ширину ###\ndef graph_bfs(graph, start_vet)\n  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  # Последовательность обхода вершин\n  res = []\n  # Хеш-множество для хранения уже посещенных вершин\n  visited = Set.new([start_vet])\n  # Очередь используется для реализации BFS\n  que = [start_vet]\n  # Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n  while que.length &gt; 0\n    vet = que.shift # Извлечь головную вершину из очереди\n    res &lt;&lt; vet # Отметить посещенную вершину\n    # Обойти все смежные вершины данной вершины\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # Пропустить уже посещенную вершину\n      que &lt;&lt; adj_vet # Помещать в очередь только непосещенные вершины\n      visited.add(adj_vet) # Отметить эту вершину как посещенную\n    end\n  end\n  # Вернуть последовательность обхода вершин\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Код сравнительно абстрактен, поэтому рекомендуется сверяться с рисунками ниже для лучшего понимания.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-10   Шаги обхода графа в ширину </p> <p>Является ли последовательность обхода в ширину единственной?</p> <p>Нет. Обход в ширину требует только соблюдения порядка \"от ближнего к дальнему\", а порядок обхода нескольких вершин на одинаковом расстоянии может произвольно меняться. Например, на рисунке 9-10 можно поменять местами порядок посещения вершин \\(1\\) и \\(3\\) , а вершины \\(2\\), \\(4\\), \\(6\\) также можно переставлять произвольно.</p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   Анализ сложности","text":"<p>Временная сложность: все вершины по одному разу помещаются в очередь и извлекаются из нее, что требует \\(O(|V|)\\) времени; при обходе смежных вершин, поскольку граф неориентированный, все ребра будут посещены по \\(2\\) раза, что требует \\(O(2|E|)\\) времени; в сумме получается \\(O(|V| + |E|)\\) .</p> <p>Пространственная сложность: список <code>res</code> , хеш-множество <code>visited</code> и очередь <code>que</code> в худшем случае могут содержать до \\(|V|\\) вершин, поэтому требуется \\(O(|V|)\\) памяти.</p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   Обход в глубину","text":"<p>Обход в глубину - это способ обхода, при котором сначала идут до самого конца, а когда дальше идти нельзя, возвращаются назад. Как показано на рисунке 9-11, начиная с вершины в левом верхнем углу, мы выбираем некоторую смежную вершину текущей вершины, идем до упора, затем возвращаемся назад, снова идем до упора и так далее, пока не будут посещены все вершины.</p> <p></p> <p> Рисунок 9-11   Обход графа в глубину </p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   Реализация алгоритма","text":"<p>Такой алгоритмический шаблон \"дойти до конца и вернуться\" обычно реализуется через рекурсию. Подобно обходу в ширину, в обходе в глубину мы также используем хеш-множество <code>visited</code> для записи уже посещенных вершин и тем самым избегаем повторного посещения.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"Вспомогательная функция обхода в глубину\"\"\"\n    res.append(vet)  # Отметить посещенную вершину\n    visited.add(vet)  # Отметить эту вершину как посещенную\n    # Обойти все смежные вершины данной вершины\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # Пропустить уже посещенную вершину\n        # Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Обход в глубину\"\"\"\n    # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n    # Последовательность обхода вершин\n    res = []\n    # Хеш-множество для хранения уже посещенных вершин\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // Отметить посещенную вершину\n    visited.emplace(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Последовательность обхода вершин\n    vector&lt;Vertex *&gt; res;\n    // Хеш-множество для хранения уже посещенных вершин\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Хеш-множество для хранения уже посещенных вершин\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // Отметить посещенную вершину\n    visited.Add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* Вспомогательная функция обхода в глубину */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // Операция append возвращает новую ссылку, поэтому исходную ссылку нужно заново присвоить новому срезу\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // Обойти все смежные вершины данной вершины\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // Рекурсивно обходить смежные вершины\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Последовательность обхода вершин\n    res := make([]Vertex, 0)\n    // Хеш-множество для хранения уже посещенных вершин\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* Вспомогательная функция обхода в глубину */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // Отметить посещенную вершину\n    visited.insert(vet) // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Последовательность обхода вершин\n    var res: [Vertex] = []\n    // Хеш-множество для хранения уже посещенных вершин\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphDFS(graph, startVet) {\n    // Последовательность обхода вершин\n    const res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* Вспомогательная функция обхода в глубину */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Последовательность обхода вершин\n    const res: Vertex[] = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // Отметить посещенную вершину\n  visited.add(vet); // Отметить эту вершину как посещенную\n  // Обойти все смежные вершины данной вершины\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // Пропустить уже посещенную вершину\n    }\n    // Рекурсивно обходить смежные вершины\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* Обход в глубину */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // Последовательность обхода вершин\n  List&lt;Vertex&gt; res = [];\n  // Хеш-множество для хранения уже посещенных вершин\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* Вспомогательная функция обхода в глубину */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // Отметить посещенную вершину\n    visited.insert(vet); // Отметить эту вершину как посещенную\n                         // Обойти все смежные вершины данной вершины\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            // Рекурсивно обходить смежные вершины\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Последовательность обхода вершин\n    let mut res = vec![];\n    // Хеш-множество для хранения уже посещенных вершин\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* Проверить, была ли вершина уже посещена */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // Искать узел обходом за O(n) времени\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // Отметить посещенную вершину\n    res[(*resSize)++] = vet;\n    // Обойти все смежные вершины данной вершины\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // Пропустить уже посещенную вершину\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // Рекурсивно обходить смежные вершины\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* Вспомогательная функция обхода в глубину */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // Отметить посещенную вершину\n    visited.add(vet) // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // Последовательность обхода вершин\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Хеш-множество для хранения уже посещенных вершин\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### Вспомогательная функция обхода в глубину ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # Отметить посещенную вершину\n  visited.add(vet) # Отметить эту вершину как посещенную\n  # Обойти все смежные вершины данной вершины\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # Пропустить уже посещенную вершину\n    # Рекурсивно обходить смежные вершины\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### Обход в глубину ###\ndef graph_dfs(graph, start_vet)\n  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  # Последовательность обхода вершин\n  res = []\n  # Хеш-множество для хранения уже посещенных вершин\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Алгоритмический процесс обхода в глубину показан на рисунках ниже.</p> <ul> <li>Прямая пунктирная линия обозначает нисходящую рекурсию , то есть запуск нового рекурсивного метода для посещения новой вершины.</li> <li>Изогнутая пунктирная линия обозначает восходящую рекурсию , то есть данный рекурсивный метод завершился и управление вернулось туда, откуда он был вызван.</li> </ul> <p>Чтобы лучше понять алгоритм, рекомендуется совместить рисунки ниже с кодом и мысленно проследить весь процесс DFS, включая моменты запуска и возврата каждого рекурсивного вызова.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-12   Шаги обхода графа в глубину </p> <p>Является ли последовательность обхода в глубину единственной?</p> <p>Как и в случае обхода в ширину, последовательность DFS тоже не является единственной. Для заданной вершины допустимо сначала углубиться в любое направление, то есть порядок смежных вершин может быть произвольным, и все такие варианты будут корректными обходами в глубину.</p> <p>Если взять в качестве примера обход дерева, то варианты \"корень \\(\\rightarrow\\) лево \\(\\rightarrow\\) право\", \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\" и \"лево \\(\\rightarrow\\) право \\(\\rightarrow\\) корень\" соответствуют прямому, симметричному и обратному обходам соответственно. Они показывают три разных приоритета обхода, но все они относятся к обходу в глубину.</p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   Анализ сложности","text":"<p>Временная сложность: все вершины будут посещены по \\(1\\) разу, что требует \\(O(|V|)\\) времени; все ребра будут посещены по \\(2\\) раза, что требует \\(O(2|E|)\\) времени; суммарно получается \\(O(|V| + |E|)\\) .</p> <p>Пространственная сложность: число вершин в списке <code>res</code> и хеш-множестве <code>visited</code> в худшем случае достигает \\(|V|\\) , максимальная глубина рекурсии тоже равна \\(|V|\\) , поэтому требуется \\(O(|V|)\\) памяти.</p>","path":["Глава 9. Граф","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   Краткие итоги","text":"","path":["Глава 9. Граф","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   Основные моменты","text":"<ul> <li>Граф состоит из вершин и ребер и может быть задан как множество вершин и множество ребер.</li> <li>По сравнению с линейными отношениями (связный список) и отношениями разделения (дерево), сетевые отношения (граф) обладают большей свободой и потому более сложны.</li> <li>Ребра ориентированного графа имеют направление, в связном графе любые вершины достижимы, а во взвешенном графе каждое ребро содержит переменную веса.</li> <li>Матрица смежности использует матрицу для представления графа: каждая строка и каждый столбец соответствуют вершине, а элементы матрицы показывают, есть между двумя вершинами ребро или нет. Матрица смежности эффективна в операциях добавления, удаления, поиска и изменения, но расходует больше памяти.</li> <li>Список смежности использует несколько списков для представления графа; \\(i\\)-й список соответствует вершине \\(i\\) и хранит все ее смежные вершины. По сравнению с матрицей смежности список смежности экономит пространство, но для поиска ребра в нем приходится обходить список, поэтому по времени он уступает.</li> <li>Когда списки в списке смежности становятся слишком длинными, их можно преобразовать в красно-черное дерево или хеш-таблицу, чтобы повысить эффективность поиска.</li> <li>С точки зрения алгоритмической идеи матрица смежности отражает принцип \"обмена пространства на время\", а список смежности - принцип \"обмена времени на пространство\".</li> <li>Графы можно использовать для моделирования различных реальных систем, таких как социальные сети, линии метро и так далее.</li> <li>Дерево является частным случаем графа, а обход дерева - частным случаем обхода графа.</li> <li>Обход графа в ширину представляет собой способ поиска, который расширяется от ближнего к дальнему и обычно реализуется с помощью очереди.</li> <li>Обход графа в глубину представляет собой способ поиска, который сначала идет до самого конца, а затем возвращается назад, когда путь исчерпан; обычно он реализуется на основе рекурсии.</li> </ul>","path":["Глава 9. Граф","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Что считается путем: последовательность вершин или последовательность ребер?</p> <p>Определение в разных языковых версиях Википедии различается: в английской версии путь определяется как \"последовательность ребер\", а в русской версии - как \"последовательность вершин\". В английской версии исходная формулировка выглядит так: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>В этой книге путь рассматривается как последовательность ребер, а не как последовательность вершин. Причина в том, что между двумя вершинами может существовать несколько ребер, и в таком случае каждому ребру соответствует свой путь.</p> <p>Q: Есть ли в несвязном графе вершины, до которых нельзя дойти?</p> <p>В несвязном графе, начиная из некоторой вершины, по крайней мере одна вершина оказывается недостижимой. Чтобы обойти весь несвязный граф, нужно задать несколько стартовых точек и обойти все связные компоненты графа.</p> <p>Q: Есть ли требования к порядку вершин в списке \"всех вершин, соединенных с данной вершиной\" в списке смежности?</p> <p>Порядок может быть произвольным. Но на практике может понадобиться сортировка по определенному правилу, например по порядку добавления вершин или по возрастанию значений вершин; это помогает быстро находить вершины с некоторым экстремальным свойством.</p>","path":["Глава 9. Граф","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"Глава 15.   Жадность","text":"<p>Abstract</p> <p>Подсолнух поворачивается к солнцу, постоянно стремясь к наилучшим условиям для роста.</p> <p>Жадная стратегия через цепочку простых выборов постепенно приводит к наилучшему ответу.</p>","path":["Глава 15. Жадность","Глава 15. &nbsp; Жадность"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>15.1   Жадный алгоритм</li> <li>15.2   Задача о дробном рюкзаке</li> <li>15.3   Задача о максимальной вместимости</li> <li>15.4   Задача о максимальном произведении разбиения</li> <li>15.5   Резюме</li> </ul>","path":["Глава 15. Жадность","Глава 15. &nbsp; Жадность"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   Задача о дробном рюкзаке","text":"<p>Question</p> <p>Дано \\(n\\) предметов. Вес предмета \\(i\\) равен \\(wgt[i-1]\\), ценность равна \\(val[i-1]\\), также дан рюкзак вместимостью \\(cap\\). Каждый предмет можно выбрать только один раз, но разрешается взять лишь часть предмета, а ценность вычисляется пропорционально взятому весу. Требуется найти максимальную ценность предметов в рюкзаке при ограниченной вместимости. Пример показан на рисунке 15-3.</p> <p></p> <p> Рисунок 15-3   Пример данных для задачи о дробном рюкзаке </p> <p>Задача о дробном рюкзаке в целом очень похожа на задачу о рюкзаке 0-1: состояние включает текущий предмет \\(i\\) и вместимость \\(c\\), а цель состоит в нахождении максимальной ценности при заданной вместимости рюкзака.</p> <p>Отличие в том, что здесь разрешено брать только часть предмета. Как показано на рисунке 15-4, мы можем произвольно делить предмет и вычислять соответствующую ценность пропорционально весу.</p> <ol> <li>Для предмета \\(i\\) его ценность на единицу веса равна \\(val[i-1] / wgt[i-1]\\), сокращенно - удельная ценность.</li> <li>Если взять часть предмета \\(i\\) весом \\(w\\), то ценность рюкзака увеличится на \\(w \\times val[i-1] / wgt[i-1]\\).</li> </ol> <p></p> <p> Рисунок 15-4   Ценность предмета на единицу веса </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>Максимизация общей ценности предметов в рюкзаке по сути равносильна максимизации ценности на единицу веса. Отсюда естественно выводится следующая жадная стратегия.</p> <ol> <li>Отсортировать предметы по убыванию удельной ценности.</li> <li>Перебирать все предметы и на каждом шаге жадно выбирать предмет с наибольшей удельной ценностью.</li> <li>Если оставшейся вместимости рюкзака недостаточно, взять часть текущего предмета, чтобы заполнить рюкзак.</li> </ol> <p></p> <p> Рисунок 15-5   Жадная стратегия для задачи о дробном рюкзаке </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Мы вводим класс <code>Item</code>, чтобы можно было сортировать предметы по удельной ценности. Далее циклически выполняем жадный выбор и, когда рюкзак заполнен, выходим и возвращаем ответ:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"Предмет\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # Вес предмета\n        self.v = v  # Стоимость предмета\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Дробный рюкзак: жадный алгоритм\"\"\"\n    # Создать список предметов с двумя свойствами: вес и стоимость\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # Циклический жадный выбор\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v\n            cap -= item.w\n        else:\n            # Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap\n            # Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* Предмет */\nclass Item {\n  public:\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // Циклический жадный выбор\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double)item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* Предмет */\nclass Item {\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // Циклический жадный выбор\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double) item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* Предмет */\nclass Item(int w, int v) {\n    public int w = w; // Вес предмета\n    public int v = v; // Стоимость предмета\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // Циклический жадный выбор\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double)item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* Предмет */\ntype Item struct {\n    w int // Вес предмета\n    v int // Стоимость предмета\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // Циклический жадный выбор\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* Предмет */\nclass Item {\n    var w: Int // Вес предмета\n    var v: Int // Стоимость предмета\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // Циклический жадный выбор\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* Предмет */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // Вес предмета\n        this.v = v; // Стоимость предмета\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Циклический жадный выбор\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* Предмет */\nclass Item {\n    w: number; // Вес предмета\n    v: number; // Стоимость предмета\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Циклический жадный выбор\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* Предмет */\nclass Item {\n  int w; // Вес предмета\n  int v; // Стоимость предмета\n\n  Item(this.w, this.v);\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // Создать список предметов с двумя свойствами: вес и стоимость\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // Циклический жадный выбор\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n      res += item.v / item.w * cap;\n      // Свободной вместимости больше не осталось, поэтому выйти из цикла\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* Предмет */\nstruct Item {\n    w: i32, // Вес предмета\n    v: i32, // Стоимость предмета\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // Циклический жадный выбор\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* Предмет */\ntypedef struct {\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n} Item;\n\n/* Дробный рюкзак: жадный алгоритм */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // Циклический жадный выбор\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* Предмет */\nclass Item(\n    val w: Int, // Предмет\n    val v: Int  // Стоимость предмета\n)\n\n/* Дробный рюкзак: жадный алгоритм */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // Циклический жадный выбор\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += item.v.toDouble() / item.w * cap\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### Предмет ###\nclass Item\n  attr_accessor :w # Вес предмета\n  attr_accessor :v # Стоимость предмета\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### Дробный рюкзак: жадный алгоритм ###\ndef fractional_knapsack(wgt, val, cap)\n  # Создать список предметов с двумя свойствами: вес и стоимость\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # Циклический жадный выбор\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n      res += item.v\n      cap -= item.w\n    else\n      # Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n      res += (item.v.to_f / item.w) * cap\n      # Свободной вместимости больше не осталось, поэтому выйти из цикла\n      break\n    end\n  end\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Встроенный алгоритм сортировки обычно имеет временную сложность \\(O(n \\log n)\\), а пространственная сложность обычно равна \\(O(\\log n)\\) или \\(O(n)\\), в зависимости от конкретной реализации в языке программирования.</p> <p>Помимо сортировки, в худшем случае потребуется пройти весь список предметов, но это не меняет асимптотику, поэтому итоговая временная сложность равна \\(O(n \\log n)\\), где \\(n\\) - число предметов.</p> <p>Поскольку инициализируется список объектов <code>Item</code>, пространственная сложность равна \\(O(n)\\).</p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Используем доказательство от противного. Предположим, что предмет \\(x\\) имеет наибольшую удельную ценность, некоторый алгоритм получил максимальную ценность <code>res</code>, но в найденном решении предмет \\(x\\) отсутствует.</p> <p>Теперь вынем из рюкзака произвольный предмет единичного веса и заменим его на предмет \\(x\\) того же веса. Поскольку предмет \\(x\\) имеет наибольшую удельную ценность, общая ценность после замены обязательно станет больше <code>res</code>. Это противоречит тому, что <code>res</code> является оптимальным решением, а значит оптимальное решение обязательно содержит предмет \\(x\\).</p> <p>Для других предметов в этом решении можно построить аналогичное противоречие. Иными словами, предметы с большей удельной ценностью всегда являются более выгодным выбором, а значит жадная стратегия корректна.</p> <p>Как показано на рисунке 15-6, если рассматривать вес предметов и их удельную ценность как горизонтальную и вертикальную оси двумерной диаграммы, то задачу о дробном рюкзаке можно интерпретировать как «поиск максимальной площади, ограниченной конечным отрезком по горизонтали». Эта аналогия помогает понять корректность жадной стратегии с геометрической точки зрения.</p> <p></p> <p> Рисунок 15-6   Геометрическая интерпретация задачи о дробном рюкзаке </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   Жадный алгоритм","text":"<p>Жадный алгоритм (greedy algorithm) - это распространенный метод решения задач оптимизации. Его основная идея состоит в том, чтобы на каждом этапе принятия решения выбирать вариант, который выглядит наилучшим прямо сейчас, то есть жадно принимать локально оптимальные решения в надежде получить глобально оптимальный результат. Жадные алгоритмы просты и эффективны, поэтому широко применяются во многих практических задачах.</p> <p>Жадные алгоритмы и динамическое программирование часто используются для решения задач оптимизации. У них есть некоторое сходство, например оба метода опираются на свойство оптимальной подструктуры, но принципы работы различаются.</p> <ul> <li>Динамическое программирование при получении текущего решения учитывает все предыдущие решения и использует ответы для прошлых подзадач, чтобы построить ответ для текущей подзадачи.</li> <li>Жадный алгоритм не учитывает предыдущие решения, а просто движется вперед, каждый раз делая жадный выбор и постепенно сужая область задачи, пока она не будет решена.</li> </ul> <p>Чтобы лучше понять принцип работы жадного алгоритма, разберем его на примере задачи «размен монет». Эта задача уже встречалась в разделе «задача о полном рюкзаке», поэтому она наверняка вам знакома.</p> <p>Question</p> <p>Дано \\(n\\) видов монет. Номинал монеты \\(i\\) равен \\(coins[i - 1]\\), целевая сумма равна \\(amt\\), причем каждую монету можно брать неограниченное число раз. Требуется найти минимальное число монет, которыми можно набрать целевую сумму. Если набрать сумму невозможно, верните \\(-1\\).</p> <p>Жадная стратегия для этой задачи показана на рисунке 15-1. Для заданной целевой суммы мы жадно выбираем монету, которая не превышает ее и находится к ней ближе всего, и повторяем этот шаг, пока не получим нужную сумму.</p> <p></p> <p> Рисунок 15-1   Жадная стратегия для задачи о размене монет </p> <p>Ниже приведен код реализации.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: жадный алгоритм\"\"\"\n    # Предположить, что список coins упорядочен\n    i = len(coins) - 1\n    count = 0\n    # Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0:\n        # Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # Выбрать coins[i]\n        amt -= coins[i]\n        count += 1\n    # Если допустимое решение не найдено, вернуть -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.size() - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(int[] coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.length - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* Размен монет: жадный алгоритм */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.Length - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* Размен монет: жадный алгоритм */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // Предположить, что список coins упорядочен\n    i := len(coins) - 1\n    count := 0\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    for amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // Выбрать coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* Размен монет: жадный алгоритм */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // Предположить, что список coins упорядочен\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // Выбрать coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* Размен монет: жадный алгоритм */\nfunction coinChangeGreedy(coins, amt) {\n    // Предположить, что массив coins упорядочен\n    let i = coins.length - 1;\n    let count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* Размен монет: жадный алгоритм */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // Предположить, что массив coins упорядочен\n    let i = coins.length - 1;\n    let count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // Предположить, что список coins упорядочен\n  int i = coins.length - 1;\n  int count = 0;\n  // Циклически выполнять жадный выбор, пока не останется суммы\n  while (amt &gt; 0) {\n    // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // Выбрать coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // Если допустимое решение не найдено, вернуть -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* Размен монет: жадный алгоритм */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // Предположить, что список coins упорядочен\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = size - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* Размен монет: жадный алгоритм */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // Предположить, что список coins упорядочен\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (am &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // Выбрать coins[i]\n        am -= coins[i]\n        count++\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### Размен монет: жадный алгоритм ###\ndef coin_change_greedy(coins, amt)\n  # Предположить, что список coins упорядочен\n  i = coins.length - 1\n  count = 0\n  # Циклически выполнять жадный выбор, пока не останется суммы\n  while amt &gt; 0\n    # Найти монету, которая меньше остатка суммы и наиболее к нему близка\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # Выбрать coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # Если допустимое решение не найдено, вернуть -1\n  amt == 0 ? count : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>У вас может невольно вырваться: «Эврика!» Жадный алгоритм решает задачу размена монет всего примерно десятью строками кода.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   Преимущества и ограничения жадного алгоритма","text":"<p>Жадный алгоритм не только прост в реализации, но и обычно очень эффективен. В приведенном выше коде обозначим минимальный номинал монеты через \\(\\min(coins)\\), тогда жадный выбор выполняется не более чем \\(amt / \\min(coins)\\) раз, а временная сложность равна \\(O(amt / \\min(coins))\\). Это на порядок меньше, чем временная сложность решения через динамическое программирование \\(O(n \\times amt)\\).</p> <p>Однако для некоторых наборов номиналов монет жадный алгоритм не может найти оптимальный ответ. Ниже показаны два примера.</p> <ul> <li>Положительный пример \\(coins = [1, 5, 10, 20, 50, 100]\\): для такого набора монет при любом \\(amt\\) жадный алгоритм находит оптимальное решение.</li> <li>Отрицательный пример \\(coins = [1, 20, 50]\\): пусть \\(amt = 60\\). Жадный алгоритм найдет только комбинацию \\(50 + 1 \\times 10\\), то есть всего \\(11\\) монет, тогда как динамическое программирование находит оптимум \\(20 + 20 + 20\\), где требуется лишь \\(3\\) монеты.</li> <li>Отрицательный пример \\(coins = [1, 49, 50]\\): пусть \\(amt = 98\\). Жадный алгоритм найдет только комбинацию \\(50 + 1 \\times 48\\), то есть всего \\(49\\) монет, тогда как динамическое программирование находит оптимум \\(49 + 49\\), где требуется лишь \\(2\\) монеты.</li> </ul> <p></p> <p> Рисунок 15-2   Примеры, где жадный алгоритм не находит оптимального решения </p> <p>Иными словами, в задаче о размене монет жадный алгоритм не гарантирует нахождение глобально оптимального решения и иногда может приводить к очень плохому ответу. Для этой задачи больше подходит динамическое программирование.</p> <p>В общем случае жадный алгоритм применим в двух следующих ситуациях.</p> <ol> <li>Можно гарантировать нахождение оптимального решения: в таком случае жадный алгоритм часто является лучшим выбором, поскольку обычно он эффективнее, чем поиск с возвратом и динамическое программирование.</li> <li>Можно найти приближенно оптимальное решение: в таком случае жадный алгоритм тоже полезен. Для многих сложных задач поиск глобального оптимума очень труден, и возможность быстро найти субоптимальный ответ уже весьма ценна.</li> </ol>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   Свойства жадного алгоритма","text":"<p>Тогда возникает вопрос: какие задачи подходят для решения жадным алгоритмом? Или, другими словами, в каких случаях жадный алгоритм может гарантировать оптимальный ответ?</p> <p>По сравнению с динамическим программированием условия применения жадного алгоритма более строгие. В основном нас интересуют два свойства задачи.</p> <ul> <li>Свойство жадного выбора: только когда локально оптимальный выбор всегда может привести к глобально оптимальному решению, жадный алгоритм способен гарантировать оптимум.</li> <li>Оптимальная подструктура: оптимальное решение исходной задачи содержит оптимальные решения подзадач.</li> </ul> <p>Оптимальная подструктура уже обсуждалась в главе «Динамическое программирование», поэтому здесь не будем повторяться. Стоит отметить, что у некоторых задач оптимальная подструктура не столь очевидна, но их все равно можно решать жадным алгоритмом.</p> <p>Основное внимание мы уделяем тому, как определить свойство жадного выбора. Хотя формулировка выглядит довольно простой, на практике для многих задач доказать свойство жадного выбора совсем не легко.</p> <p>Например, в задаче о размене монет легко привести контрпример и опровергнуть свойство жадного выбора, но вот доказать его истинность намного сложнее. Если спросить: для каких наборов монет можно использовать жадный алгоритм? - обычно удается дать лишь интуитивный или примерный ответ, а не строгое математическое доказательство.</p> <p>Quote</p> <p>Существует статья, в которой приводится алгоритм со временной сложностью \\(O(n^3)\\) для определения того, можно ли с помощью жадного алгоритма находить оптимальный размен для любой суммы в заданной системе монет.</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   Этапы решения задач жадным алгоритмом","text":"<p>Процесс решения жадной задачи в общем виде можно разбить на три шага.</p> <ol> <li>Анализ задачи: разобраться в свойствах задачи, включая определение состояний, целевой функции и ограничений. Этот этап присутствует и в поиске с возвратом, и в динамическом программировании.</li> <li>Определение жадной стратегии: определить, какой жадный выбор следует делать на каждом шаге. Эта стратегия должна уменьшать размер задачи на каждом этапе и в итоге привести к решению всей задачи.</li> <li>Доказательство корректности: обычно требуется доказать, что задача обладает свойством жадного выбора и оптимальной подструктурой. На этом этапе может понадобиться математическое доказательство, например индукция или доказательство от противного.</li> </ol> <p>Определение жадной стратегии - это ключевой этап решения, но на практике он часто оказывается непростым по следующим причинам.</p> <ul> <li>Жадные стратегии для разных задач сильно различаются. Для многих задач стратегия довольно очевидна, и до нее можно дойти за счет общих рассуждений и нескольких проб. Но в более сложных задачах жадная стратегия может быть очень скрытой, и тут уже многое зависит от опыта решения задач и алгоритмической подготовки.</li> <li>Некоторые жадные стратегии выглядят убедительно, но оказываются обманчивыми. Бывает, что мы с уверенностью придумали жадную стратегию, написали код и отправили его на проверку, а часть тестов не проходит. Причина в том, что спроектированная стратегия лишь «частично верна», и описанная выше задача о размене монет - типичный пример.</li> </ul> <p>Чтобы гарантировать корректность, нужно дать строгое математическое доказательство жадной стратегии, обычно с использованием доказательства от противного или математической индукции.</p> <p>Однако и доказательство корректности может оказаться непростой задачей. Если идей нет, мы обычно начинаем отлаживать код на тестовых примерах, постепенно меняя и проверяя жадную стратегию.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   Типичные задачи для жадного алгоритма","text":"<p>Жадные алгоритмы часто применяются в задачах оптимизации, обладающих свойством жадного выбора и оптимальной подструктурой. Ниже приведены некоторые типичные задачи, решаемые жадным подходом.</p> <ul> <li>Задача о размене монет: при некоторых системах монет жадный алгоритм всегда дает оптимальный ответ.</li> <li>Задача о расписании интервалов: пусть есть несколько задач, каждая выполняется в некотором временном интервале, и требуется завершить как можно больше задач. Если каждый раз выбирать задачу с самым ранним временем окончания, то жадный алгоритм дает оптимальный ответ.</li> <li>Задача о дробном рюкзаке: дана группа предметов и грузоподъемность. Требуется выбрать предметы так, чтобы их общий вес не превышал ограничение, а общая ценность была максимальной. Если каждый раз выбирать предмет с наилучшим отношением стоимости к весу, то в некоторых случаях жадный алгоритм дает оптимальный ответ.</li> <li>Задача о покупке и продаже акций: дана история цен акции. Можно совершать несколько сделок, но если акция уже куплена, то до продажи покупать снова нельзя. Цель - получить максимальную прибыль.</li> <li>Код Хаффмана: это жадный алгоритм для сжатия данных без потерь. Построив дерево Хаффмана и каждый раз объединяя два узла с наименьшей частотой, мы получаем дерево с минимальной взвешенной длиной пути, то есть минимальной длиной кодирования.</li> <li>Алгоритм Дейкстры: это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.</li> </ul>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   Задача о максимальной вместимости","text":"<p>Question</p> <p>Дан массив \\(ht\\), где каждый элемент обозначает высоту вертикальной перегородки. Любые две перегородки в массиве вместе с пространством между ними образуют контейнер.</p> <p>Вместимость контейнера равна произведению высоты и ширины (площади), где высота определяется более короткой перегородкой, а ширина - разностью индексов двух перегородок в массиве.</p> <p>Требуется выбрать две перегородки так, чтобы образованный ими контейнер имел максимальную вместимость. Пример показан на рисунке 15-7.</p> <p></p> <p> Рисунок 15-7   Пример данных для задачи о максимальной вместимости </p> <p>Контейнер образуется произвольными двумя перегородками, поэтому состоянием задачи служит пара индексов этих перегородок, обозначим ее как \\([i, j]\\).</p> <p>Согласно условию, вместимость равна произведению высоты на ширину, где высота определяется короткой перегородкой, а ширина - разностью индексов двух перегородок. Обозначим вместимость через \\(cap[i, j]\\), тогда формула принимает вид:</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>Пусть длина массива равна \\(n\\). Тогда число пар перегородок, то есть общее число состояний, равно \\(C_n^2 = \\frac{n(n - 1)}{2}\\). Самый прямолинейный подход - перебрать все состояния, после чего найти максимальную вместимость. Его временная сложность равна \\(O(n^2)\\).</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>У этой задачи есть и более эффективное решение. Как показано на рисунке 15-8, рассмотрим состояние \\([i, j]\\), где индексы удовлетворяют \\(i &lt; j\\), а высоты - условию \\(ht[i] &lt; ht[j]\\), то есть \\(i\\) - короткая перегородка, а \\(j\\) - длинная.</p> <p></p> <p> Рисунок 15-8   Начальное состояние </p> <p>Как показано на рисунке 15-9, если в этот момент сдвинуть длинную перегородку \\(j\\) ближе к короткой перегородке \\(i\\), то вместимость обязательно уменьшится.</p> <p>Причина в том, что после смещения длинной перегородки \\(j\\) ширина \\(j-i\\) обязательно станет меньше, а высота определяется короткой перегородкой, поэтому высота либо останется прежней (если \\(i\\) останется короткой перегородкой), либо уменьшится (если сдвинутая \\(j\\) станет короткой перегородкой).</p> <p></p> <p> Рисунок 15-9   Состояние после перемещения длинной перегородки внутрь </p> <p>Рассуждая в обратную сторону, только сдвигая короткую перегородку \\(i\\) внутрь, мы можем получить шанс увеличить вместимость. Хотя ширина при этом обязательно уменьшится, высота может возрасти (если после перемещения короткая перегородка \\(i\\) станет выше). Например, на рисунке 15-10 после перемещения короткой перегородки площадь увеличивается.</p> <p></p> <p> Рисунок 15-10   Состояние после перемещения короткой перегородки внутрь </p> <p>Отсюда и выводится жадная стратегия для этой задачи: инициализировать два указателя по краям контейнера и на каждом шаге сдвигать внутрь указатель, соответствующий короткой перегородке, пока указатели не встретятся.</p> <p>На рисунках ниже показан процесс выполнения этой жадной стратегии.</p> <ol> <li>В начальном состоянии указатели \\(i\\) и \\(j\\) стоят на двух концах массива.</li> <li>Вычислить вместимость текущего состояния \\(cap[i, j]\\) и обновить максимальную вместимость.</li> <li>Сравнить высоты перегородок \\(i\\) и \\(j\\), после чего сдвинуть короткую перегородку на одну позицию внутрь.</li> <li>Повторять шаги <code>2.</code> и <code>3.</code> до тех пор, пока \\(i\\) и \\(j\\) не встретятся.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 15-11   Жадный процесс решения задачи о максимальной вместимости </p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Цикл в коде выполняется не более \\(n\\) раз, поэтому временная сложность равна \\(O(n)\\).</p> <p>Переменные \\(i\\), \\(j\\), \\(res\\) используют дополнительную память постоянного размера, поэтому пространственная сложность равна \\(O(1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"Максимальная вместимость: жадный алгоритм\"\"\"\n    # Инициализировать i и j так, чтобы они располагались по двум концам массива\n    i, j = 0, len(ht) - 1\n    # Начальная максимальная вместимость равна 0\n    res = 0\n    # Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j:\n        # Обновить максимальную вместимость\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.size() - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(int[] ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint MaxCapacity(int[] ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.Length - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunc maxCapacity(ht []int) int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    i, j := 0, len(ht)-1\n    // Начальная максимальная вместимость равна 0\n    res := 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    for i &lt; j {\n        // Обновить максимальную вместимость\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // Начальная максимальная вместимость равна 0\n    var res = 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j {\n        // Обновить максимальную вместимость\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunction maxCapacity(ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let i = 0,\n        j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    let res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunction maxCapacity(ht: number[]): number {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let i = 0,\n        j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    let res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(List&lt;int&gt; ht) {\n  // Инициализировать i и j так, чтобы они располагались по двум концам массива\n  int i = 0, j = ht.length - 1;\n  // Начальная максимальная вместимость равна 0\n  int res = 0;\n  // Выполнять жадный выбор в цикле, пока две доски не встретятся\n  while (i &lt; j) {\n    // Обновить максимальную вместимость\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // Сдвигать внутрь более короткую сторону\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // Начальная максимальная вместимость равна 0\n    let mut res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j {\n        // Обновить максимальную вместимость\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(int ht[], int htLength) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0;\n    int j = htLength - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfun maxCapacity(ht: IntArray): Int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    var i = 0\n    var j = ht.size - 1\n    // Начальная максимальная вместимость равна 0\n    var res = 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### Максимальная вместимость: жадный алгоритм ###\ndef max_capacity(ht)\n  # Инициализировать i и j так, чтобы они располагались по двум концам массива\n  i, j = 0, ht.length - 1\n  # Начальная максимальная вместимость равна 0\n  res = 0\n\n  # Выполнять жадный выбор в цикле, пока две доски не встретятся\n  while i &lt; j\n    # Обновить максимальную вместимость\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # Сдвигать внутрь более короткую сторону\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Жадный алгоритм быстрее полного перебора именно потому, что каждый жадный шаг «пропускает» часть состояний.</p> <p>Например, в состоянии \\(cap[i, j]\\) перегородка \\(i\\) является короткой, а \\(j\\) - длинной. Если жадно сдвинуть короткую перегородку \\(i\\) на одну позицию внутрь, то состояния, показанные на рисунке 15-12, будут «пропущены». Это означает, что позже мы уже не сможем проверить вместимость этих состояний.</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> Рисунок 15-12   Состояния, пропущенные из-за смещения короткой перегородки </p> <p>Нетрудно заметить, что эти пропущенные состояния на самом деле и есть все состояния, в которых длинная перегородка \\(j\\) сдвигается внутрь. Ранее мы уже доказали, что перемещение длинной перегородки внутрь обязательно уменьшает вместимость. Иными словами, пропущенные состояния не могут быть оптимальным решением, поэтому их пропуск не приводит к потере оптимума.</p> <p>Приведенный анализ показывает, что операция перемещения короткой перегородки является «безопасной», а жадная стратегия действительно корректна.</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   Задача о максимальном произведении разбиения","text":"<p>Question</p> <p>Дан положительный целый \\(n\\). Требуется разложить его в сумму как минимум двух положительных целых чисел и найти максимально возможное произведение всех полученных чисел, как показано на рисунке 15-13.</p> <p></p> <p> Рисунок 15-13   Определение задачи о максимальном произведении разбиения </p> <p>Предположим, что мы разбили \\(n\\) на \\(m\\) целочисленных множителей, где \\(i\\)-й множитель обозначим через \\(n_i\\), то есть</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>Цель задачи - найти максимальное произведение всех целочисленных множителей, то есть</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>Нужно понять: каким должно быть число частей \\(m\\) и какими должны быть значения каждого \\(n_i\\)?</p>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>Из опыта известно, что произведение двух целых чисел часто больше их суммы. Предположим, что мы выделяем из \\(n\\) множитель \\(2\\), тогда произведение равно \\(2(n-2)\\). Сравним это выражение с \\(n\\):</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>Как показано на рисунке 15-14, когда \\(n \\geq 4\\), выделение множителя \\(2\\) увеличивает произведение. Это означает, что все целые числа, большие либо равные \\(4\\), следует продолжать разбивать.</p> <p>Жадная стратегия 1: если в схеме разбиения присутствует множитель \\(\\geq 4\\), то его нужно дальше разбивать. В конечной схеме разбиения должны остаться только множители \\(1\\), \\(2\\), \\(3\\).</p> <p></p> <p> Рисунок 15-14   Разбиение увеличивает произведение </p> <p>Теперь подумаем, какой множитель является наилучшим. Среди \\(1\\), \\(2\\), \\(3\\) очевидно худшим является \\(1\\), потому что всегда выполняется \\(1 \\times (n-1) &lt; n\\), то есть выделение \\(1\\) уменьшает произведение.</p> <p>Как показано на рисунке 15-15, при \\(n = 6\\) имеем \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\). Это означает, что выделять \\(3\\) выгоднее, чем выделять \\(2\\).</p> <p>Жадная стратегия 2: в схеме разбиения должно быть не более двух множителей \\(2\\). Потому что три двойки всегда можно заменить двумя тройками и получить большее произведение.</p> <p></p> <p> Рисунок 15-15   Оптимальные множители разбиения </p> <p>Итак, получаем следующую жадную стратегию.</p> <ol> <li>Для заданного целого \\(n\\) непрерывно выделять из него множитель \\(3\\), пока остаток не станет равным \\(0\\), \\(1\\) или \\(2\\).</li> <li>Если остаток равен \\(0\\), это означает, что \\(n\\) кратно \\(3\\), и больше ничего делать не нужно.</li> <li>Если остаток равен \\(2\\), дальнейшее разбиение не требуется, его нужно сохранить.</li> <li>Если остаток равен \\(1\\), то поскольку \\(2 \\times 2 &gt; 1 \\times 3\\), последний множитель \\(3\\) следует заменить на \\(2\\).</li> </ol>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Как показано на рисунке 15-16, нам не нужен цикл, чтобы выполнять разбиение числа. Можно использовать целочисленное деление, чтобы получить число троек \\(a\\), и операцию взятия остатка, чтобы получить остаток \\(b\\). Тогда имеем:</p> \\[ n = 3 a + b \\] <p>Обратите внимание, что для граничного случая \\(n \\leq 3\\) необходимо выделить множитель \\(1\\), и тогда произведение равно \\(1 \\times (n - 1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"Максимальное произведение разрезания: жадный алгоритм\"\"\"\n    # Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # Жадно выделить множители 3, где a — число троек, а b — остаток\n    a, b = n // 3, n % 3\n    if b == 1:\n        # Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # Если остаток равен 2, ничего не делать\n        return int(math.pow(3, a)) * 2\n    # Если остаток равен 0, ничего не делать\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int)pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int) Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint MaxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunc maxProductCutting(n int) int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        return pow(3, a) * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunction maxProductCutting(n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // Если остаток равен 2, ничего не делать\n        return Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunction maxProductCutting(n: number): number {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // Если остаток равен 2, ничего не делать\n        return Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n  // Когда n &lt;= 3, обязательно нужно выделить одну 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // Жадно выделить множители 3, где a — число троек, а b — остаток\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // Если остаток равен 2, ничего не делать\n    return (pow(3, a) * 2).toInt();\n  }\n  // Если остаток равен 0, ничего не делать\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        3_i32.pow(a as u32) * 2\n    } else {\n        // Если остаток равен 0, ничего не делать\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfun maxProductCutting(n: Int): Int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### Максимальное произведение разрезания: жадный алгоритм ###\ndef max_product_cutting(n)\n  # Когда n &lt;= 3, обязательно нужно выделить одну 1\n  return 1 * (n - 1) if n &lt;= 3\n  # Жадно выделить множители 3, где a — число троек, а b — остаток\n  a, b = n / 3, n % 3\n  # Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # Если остаток равен 2, ничего не делать\n  return (3.pow(a) * 2).to_i if b == 2\n  # Если остаток равен 0, ничего не делать\n  3.pow(a).to_i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 15-16   Метод вычисления максимального произведения разбиения </p> <p>Временная сложность зависит от того, как в языке программирования реализовано возведение в степень. Если взять Python, то обычно используются три распространенные функции для вычисления степени.</p> <ul> <li>Оператор <code>**</code> и функция <code>pow()</code> имеют временную сложность \\(O(\\log⁡ a)\\).</li> <li>Функция <code>math.pow()</code> внутри вызывает функцию <code>pow()</code> из библиотеки C, выполняющую возведение в степень с плавающей точкой, и ее временная сложность равна \\(O(1)\\).</li> </ul> <p>Переменные \\(a\\) и \\(b\\) занимают дополнительную память постоянного размера, поэтому пространственная сложность равна \\(O(1)\\).</p>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Используем доказательство от противного и рассмотрим только случай \\(n \\geq 4\\).</p> <ol> <li>Все множители \\(\\leq 3\\): предположим, что в оптимальной схеме разбиения существует множитель \\(x \\geq 4\\). Тогда его можно дальше разложить в \\(2(x-2)\\) и получить большее или равное произведение. Это противоречит предположению.</li> <li>Схема разбиения не содержит \\(1\\): предположим, что в оптимальной схеме присутствует множитель \\(1\\). Тогда его можно объединить с другим множителем и получить большее произведение. Это противоречит предположению.</li> <li>Схема разбиения содержит не более двух \\(2\\): предположим, что в оптимальной схеме присутствуют три двойки. Тогда их можно заменить двумя тройками и получить большее произведение. Это противоречит предположению.</li> </ol>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   Резюме","text":"","path":["Глава 15. Жадность","15.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   Ключевые моменты","text":"<ul> <li>Жадный алгоритм обычно используется для решения задач оптимизации. Его принцип состоит в том, чтобы на каждом этапе принятия решения делать локально оптимальный выбор в надежде получить глобально оптимальный ответ.</li> <li>Жадный алгоритм итеративно делает один жадный выбор за другим, на каждом шаге превращая задачу в подзадачу меньшего размера, пока задача не будет полностью решена.</li> <li>Жадный алгоритм не только прост в реализации, но и часто обладает высокой эффективностью. По сравнению с динамическим программированием его временная сложность обычно ниже.</li> <li>В задаче о размене монет для некоторых наборов монет жадный алгоритм способен гарантировать оптимальный ответ, а для других наборов - нет: он может дать очень плохое решение.</li> <li>Задачи, подходящие для жадного алгоритма, обладают двумя ключевыми свойствами: свойством жадного выбора и оптимальной подструктурой. Свойство жадного выбора отражает корректность жадной стратегии.</li> <li>Для некоторых сложных задач доказать свойство жадного выбора непросто. Относительно легче найти контрпример и опровергнуть его, как это видно на примере задачи о размене монет.</li> <li>Решение жадной задачи обычно состоит из трех шагов: анализ задачи, определение жадной стратегии и доказательство корректности. Из них ключевым является выбор жадной стратегии, а доказательство корректности часто оказывается самым трудным.</li> <li>В задаче о дробном рюкзаке, в отличие от задачи о рюкзаке 0-1, разрешено брать часть предмета, поэтому ее можно решать жадным алгоритмом. Корректность жадной стратегии доказывается методом от противного.</li> <li>Задачу о максимальной вместимости можно решать полным перебором со временной сложностью \\(O(n^2)\\). Разработав жадную стратегию со сдвигом короткой перегородки внутрь на каждом шаге, временную сложность можно оптимизировать до \\(O(n)\\).</li> <li>В задаче о максимальном произведении разбиения мы последовательно выводим две жадные стратегии: все целые числа \\(\\geq 4\\) следует дальше разбивать, а оптимальным множителем разбиения является \\(3\\). В коде присутствуют операции возведения в степень, поэтому временная сложность зависит от способа их реализации и обычно равна \\(O(1)\\) или \\(O(\\log n)\\).</li> </ul>","path":["Глава 15. Жадность","15.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"Глава 6.   Хеш-таблицы","text":"<p>Abstract</p> <p>Хеш-таблица устанавливает соответствие между ключом и значением.</p> <p>Благодаря этому она позволяет получать нужное значение по ключу за очень короткое время.</p>","path":["Глава 6. Хеширование","Глава 6. &nbsp; Хеш-таблицы"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>6.1   Хеш-таблица</li> <li>6.2   Хеш-коллизии</li> <li>6.3   Хеш-алгоритмы</li> <li>6.4   Резюме</li> </ul>","path":["Глава 6. Хеширование","Глава 6. &nbsp; Хеш-таблицы"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   Алгоритмы хеширования","text":"<p>В двух предыдущих разделах мы рассмотрели принципы работы хеш-таблицы и способы обработки хеш-коллизий. Однако и открытая адресация, и метод цепочек лишь позволяют хеш-таблице корректно работать при возникновении коллизий, но не уменьшают вероятность появления самих коллизий.</p> <p>Если хеш-коллизии происходят слишком часто, производительность хеш-таблицы резко деградирует. Как показано на рисунке 6-8, для хеш-таблицы с методом цепочек в идеальном случае пары ключ-значение равномерно распределены по всем бакетам, и это дает наилучшую эффективность поиска; в худшем же случае все пары ключ-значение оказываются в одном бакете, и временная сложность вырождается до \\(O(n)\\) .</p> <p></p> <p> Рисунок 6-8   Лучший и худший случаи хеш-коллизий </p> <p>Распределение пар ключ-значение определяется хеш-функцией. Вспомним этапы вычисления хеш-функции: сначала вычисляется хеш-значение, затем оно берется по модулю длины массива:</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Из этой формулы видно: при фиксированной емкости хеш-таблицы <code>capacity</code> **выходное значение определяет именно хеш-алгоритм <code>hash()</code> **, а значит, именно он определяет распределение пар ключ-значение в хеш-таблице.</p> <p>Это означает, что для уменьшения вероятности хеш-коллизий нам следует сосредоточиться на проектировании хеш-алгоритма <code>hash()</code> .</p>","path":["Глава 6. Хеширование","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631-","level":2,"title":"6.3.1   Цели хеш-алгоритма","text":"<p>Чтобы получить структуру данных хеш-таблицы, которая будет одновременно быстрой и надежной, хеш-алгоритм должен обладать следующими свойствами.</p> <ul> <li>Детерминированность: для одинакового входа хеш-алгоритм всегда должен выдавать одинаковый результат. Только так хеш-таблица остается надежной.</li> <li>Высокая эффективность: вычисление хеш-значения должно быть достаточно быстрым. Чем меньше вычислительные затраты, тем выше практическая ценность хеш-таблицы.</li> <li>Равномерное распределение: хеш-алгоритм должен стараться распределять пары ключ-значение в хеш-таблице равномерно. Чем равномернее распределение, тем ниже вероятность хеш-коллизий.</li> </ul> <p>На практике хеш-алгоритмы используются не только для реализации хеш-таблиц, но и во многих других областях.</p> <ul> <li>Хранение паролей: чтобы защищать пароли пользователей, система обычно хранит не сами пароли в открытом виде, а их хеш-значения. Когда пользователь вводит пароль, система вычисляет хеш-значение введенного пароля и сравнивает его с сохраненным значением. Если они совпадают, пароль считается правильным.</li> <li>Проверка целостности данных: отправитель может вычислить хеш-значение данных и отправить его вместе с самими данными; получатель затем вычисляет хеш-значение повторно и сравнивает его с полученным. Если они совпадают, данные считаются целостными.</li> </ul> <p>Для приложений, связанных с криптографией, чтобы не допустить восстановления исходного пароля по хеш-значению и иных форм обратного анализа, хеш-алгоритм должен обладать более строгими свойствами безопасности.</p> <ul> <li>Односторонность: по хеш-значению нельзя восстановить какую-либо информацию о входных данных.</li> <li>Устойчивость к коллизиям: должно быть крайне трудно найти два разных входа, имеющих одинаковое хеш-значение.</li> <li>Эффект лавины: даже небольшое изменение во входных данных должно приводить к заметному и непредсказуемому изменению результата.</li> </ul> <p>Обрати внимание: \"равномерное распределение\" и \"устойчивость к коллизиям\" - это два независимых понятия , и выполнение первого не означает автоматического выполнения второго. Например, при случайном распределении входных <code>key</code> хеш-функция <code>key % 100</code> может выдавать достаточно равномерное распределение. Однако этот хеш-алгоритм слишком прост: все <code>key</code> с одинаковыми двумя последними цифрами будут иметь одинаковый результат, а значит, по хеш-значению можно легко подобрать подходящие <code>key</code> и, например, взломать пароль.</p>","path":["Глава 6. Хеширование","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632-","level":2,"title":"6.3.2   Проектирование хеш-алгоритма","text":"<p>Разработка хеш-алгоритма - это сложная задача, в которой нужно учитывать множество факторов. Однако для некоторых нетребовательных сценариев мы можем спроектировать и несколько простых хеш-алгоритмов.</p> <ul> <li>Аддитивный хеш: складываем ASCII-коды всех символов входной строки и используем полученную сумму как хеш-значение.</li> <li>Мультипликативный хеш: используем \"некоррелированность\" умножения; на каждом шаге умножаем текущее значение на константу и добавляем ASCII-код очередного символа.</li> <li>XOR-хеш: последовательно накапливаем элементы входных данных в одном хеш-значении через операцию XOR.</li> <li>Ротационный хеш: последовательно накапливаем ASCII-коды символов, причем перед каждым накоплением выполняем циклический сдвиг хеш-значения.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"Аддитивное хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"Мультипликативное хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR-хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"Хеширование с циклическим сдвигом\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* Аддитивное хеширование */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* Аддитивное хеширование */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR-хеширование */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* Аддитивное хеширование */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* Аддитивное хеширование */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* Мультипликативное хеширование */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR-хеширование */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* Хеширование с циклическим сдвигом */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* Аддитивное хеширование */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* Мультипликативное хеширование */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR-хеширование */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* Хеширование с циклическим сдвигом */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* Аддитивное хеширование */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Мультипликативное хеширование */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR-хеширование */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* Аддитивное хеширование */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Мультипликативное хеширование */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR-хеширование */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* Аддитивное хеширование */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR-хеширование */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* Аддитивное хеширование */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* Мультипликативное хеширование */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR-хеширование */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* Хеширование с циклическим сдвигом */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* Аддитивное хеширование */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* Аддитивное хеширование */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* Мультипликативное хеширование */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR-хеширование */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* Хеширование с циклическим сдвигом */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### Аддитивное хеширование ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### Мультипликативное хеширование ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR-хеширование ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### Хеширование с циклическим сдвигом ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Нетрудно заметить, что последний шаг каждого из этих хеш-алгоритмов - взятие по модулю большого простого числа \\(1000000007\\) , чтобы гарантировать, что хеш-значение остается в разумных границах. Стоит задуматься: почему подчеркивается именно взятие по модулю простого числа, и какие недостатки возникают при использовании составного модуля? Это интересный вопрос.</p> <p>Сначала дадим вывод: использование большого простого числа в качестве модуля позволяет в максимальной степени обеспечивать равномерное распределение хеш-значений. Поскольку простое число не имеет общих делителей с другими числами, это помогает уменьшить периодические закономерности, возникающие из-за операции взятия остатка, и тем самым снизить число хеш-коллизий.</p> <p>Рассмотрим пример. Предположим, мы выбрали составное число \\(9\\) в качестве модуля. Оно делится на \\(3\\) , поэтому все <code>key</code> , которые делятся на \\(3\\) , будут отображаться только в три хеш-значения: \\(0\\) , \\(3\\) , \\(6\\) .</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>Если входные <code>key</code> как раз удовлетворяют такому распределению в виде арифметической прогрессии, то хеш-значения начнут скучиваться, а это усугубит хеш-коллизии. Теперь предположим, что мы заменили <code>modulus</code> на простое число \\(13\\) ; поскольку между <code>key</code> и <code>modulus</code> нет общих делителей, равномерность распределения хеш-значений заметно улучшится.</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>Следует отметить: если можно гарантировать, что <code>key</code> распределены случайно и равномерно, то выбор простого или составного числа в качестве модуля не так важен - оба варианта способны дать равномерное распределение хеш-значений. Но если в распределении <code>key</code> присутствует периодичность, то взятие по модулю составного числа гораздо легче приводит к кластеризации.</p> <p>Итак, на практике мы обычно выбираем простое число в качестве модуля, причем это простое число желательно брать достаточно большим, чтобы по возможности убрать периодические закономерности и повысить устойчивость хеш-алгоритма.</p>","path":["Глава 6. Хеширование","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633-","level":2,"title":"6.3.3   Распространенные хеш-алгоритмы","text":"<p>Нетрудно заметить, что описанные выше простые хеш-алгоритмы довольно хрупкие и далеки от поставленных целей. Например, сложение и XOR подчиняются коммутативному закону, поэтому аддитивный хеш и XOR-хеш не различают строки, состоящие из одних и тех же символов, но в разном порядке. Это может усиливать хеш-коллизии и даже создавать некоторые проблемы безопасности.</p> <p>На практике мы обычно используем стандартные хеш-алгоритмы, такие как MD5, SHA-1, SHA-2 и SHA-3. Они могут отображать входные данные произвольной длины в хеш-значения фиксированной длины.</p> <p>На протяжении почти ста лет хеш-алгоритмы непрерывно развивались и оптимизировались. Одни исследователи старались повысить их производительность, а другие исследователи и хакеры сосредоточивались на поиске уязвимостей в их безопасности. В таблице 6-2 приведены распространенные хеш-алгоритмы, которые часто встречаются в реальных приложениях.</p> <ul> <li>MD5 и SHA-1 уже многократно были успешно атакованы, поэтому они выведены из большинства сценариев, где требуется безопасность.</li> <li>SHA-256 из семейства SHA-2 является одним из самых надежных хеш-алгоритмов; на сегодняшний день не известно успешных практических атак, поэтому он широко используется в самых разных протоколах и системах безопасности.</li> <li>SHA-3 по сравнению с SHA-2 требует меньших затрат на реализацию и обеспечивает более высокую вычислительную эффективность, но на данный момент распространен слабее, чем семейство SHA-2.</li> </ul> <p> Таблица 6-2   Распространенные хеш-алгоритмы </p> MD5 SHA-1 SHA-2 SHA-3 Год появления 1992 1995 2002 2008 Длина вывода 128 bit 160 bit 256/512 bit 224/256/384/512 bit Хеш-коллизии Частые Частые Редкие Редкие Уровень безопасности Низкий, успешно атакован Низкий, успешно атакован Высокий Высокий Применение Устарел, но еще используется для проверки целостности данных Устарел Проверка криптовалютных транзакций, цифровые подписи и т. д. Может использоваться как замена SHA-2","path":["Глава 6. Хеширование","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634-","level":2,"title":"6.3.4   Хеш-значения структур данных","text":"<p>Мы знаем, что <code>key</code> в хеш-таблице могут быть целыми числами, вещественными числами, строками и другими типами данных. Языки программирования обычно предоставляют встроенные хеш-алгоритмы для этих типов, чтобы вычислять индексы бакетов в хеш-таблице. Возьмем Python: в нем можно вызвать функцию <code>hash()</code> , чтобы вычислить хеш-значения для различных типов данных.</p> <ul> <li>Хеш-значение целого числа и булева значения совпадает с самим значением.</li> <li>Вычисление хеш-значений для вещественных чисел и строк устроено сложнее; интересующиеся читатели могут изучить это самостоятельно.</li> <li>Хеш-значение кортежа получается путем хеширования каждого элемента, а затем объединения этих хеш-значений в одно итоговое значение.</li> <li>Хеш-значение объекта обычно строится на основе его адреса в памяти. Если переопределить метод хеширования объекта, можно реализовать вычисление хеша по содержимому.</li> </ul> <p>Tip</p> <p>Обрати внимание: определения и способы вычисления встроенных хеш-значений в разных языках программирования отличаются.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# Хеш-значение целого числа 3 равно 3\n\nbol = True\nhash_bol = hash(bol)\n# Хеш-значение булевого значения True равно 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Хеш-значение числа 3.14159 равно 326484311674566659\n\nstr = \"Hello Algo\"\nhash_str = hash(str)\n# Хеш-значение строки \"Hello Algo\" равно 4617003410720528961\n\ntup = (12836, \"Сяо Ха\")\nhash_tup = hash(tup)\n# Хеш-значение кортежа (12836, \"Сяо Ха\") равно 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Хеш-значение объекта узла &lt;ListNode object at 0x1058fd810&gt; равно 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// Хеш-значение целого числа 3 равно 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// Хеш-значение булевого значения 1 равно 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// Хеш-значение числа 3.14159 равно 4614256650576692846\n\nstring str = \"Hello Algo\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// Хеш-значение строки \"Hello Algo\" равно 15466937326284535026\n\n// В C++ встроенный std::hash() предоставляет вычисление хеша только для базовых типов данных\n// Для массивов и объектов хеш-значение обычно приходится реализовывать самостоятельно\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// Хеш-значение целого числа 3 равно 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Хеш-значение булевого значения true равно 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Хеш-значение числа 3.14159 равно -1340954729\n\nString str = \"Hello Algo\";\nint hashStr = str.hashCode();\n// Хеш-значение строки \"Hello Algo\" равно -727081396\n\nObject[] arr = { 12836, \"Сяо Ха\" };\nint hashTup = Arrays.hashCode(arr);\n// Хеш-значение массива [12836, Сяо Ха] равно 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Хеш-значение объекта узла utils.ListNode@7dc5e7b4 равно 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// Хеш-значение целого числа 3 равно 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Хеш-значение булевого значения true равно 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Хеш-значение числа 3.14159 равно -1340954729;\n\nstring str = \"Hello Algo\";\nint hashStr = str.GetHashCode();\n// Хеш-значение строки \"Hello Algo\" равно -586107568;\n\nobject[] arr = [12836, \"Сяо Ха\"];\nint hashTup = arr.GetHashCode();\n// Хеш-значение массива [12836, Сяо Ха] равно 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Хеш-значение объекта узла 0 равно 39053774;\n</code></pre> built_in_hash.go<pre><code>// В Go нет встроенной функции hash code\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// Хеш-значение целого числа 3 равно 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Хеш-значение булевого значения true равно -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Хеш-значение числа 3.14159 равно -2465384235396674631\n\nlet str = \"Hello Algo\"\nlet hashStr = str.hashValue\n// Хеш-значение строки \"Hello Algo\" равно -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"Сяо Ха\")]\nlet hashTup = arr.hashValue\n// Хеш-значение массива [AnyHashable(12836), AnyHashable(\"Сяо Ха\")] равно -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Хеш-значение объекта узла utils.ListNode равно -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// В JavaScript нет встроенной функции hash code\n</code></pre> built_in_hash.ts<pre><code>// В TypeScript нет встроенной функции hash code\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// Хеш-значение целого числа 3 равно 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Хеш-значение булевого значения true равно 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Хеш-значение числа 3.14159 равно 2570631074981783\n\nString str = \"Hello Algo\";\nint hashStr = str.hashCode;\n// Хеш-значение строки \"Hello Algo\" равно 468167534\n\nList arr = [12836, \"Сяо Ха\"];\nint hashArr = arr.hashCode;\n// Хеш-значение массива [12836, Сяо Ха] равно 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Хеш-значение объекта Instance of 'ListNode' равно 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Хеш-значение целого числа 3 равно 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Хеш-значение булевого значения true равно 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Хеш-значение числа 3.14159 равно 2566941990314602357\n\nlet str = \"Hello Algo\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Хеш-значение строки \"Hello Algo\" равно 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"Сяо Ха\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Хеш-значение кортежа (12836, \"Сяо Ха\") равно 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// Хеш-значение объекта RefCell { value: ListNode { val: 42, next: None } } равно 15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// В C нет встроенной функции hash code\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// Хеш-значение целого числа 3 равно 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// Хеш-значение булевого значения true равно 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// Хеш-значение числа 3.14159 равно -1340954729\n\nval str = \"Hello Algo\"\nval hashStr = str.hashCode()\n// Хеш-значение строки \"Hello Algo\" равно -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"Сяо Ха\")\nval hashTup = arr.hashCode()\n// Хеш-значение массива [12836, Сяо Ха] равно 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// Хеш-значение объекта узла utils.ListNode@1d81eb93 равно 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# Хеш-значение целого числа 3 равно -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# Хеш-значение булевого значения true равно -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# Хеш-значение числа 3.14159 равно -1479186995943067893\n\nstr = \"Hello Algo\"\nhash_str = str.hash\n# Хеш-значение строки \"Hello Algo\" равно -4075943250025831763\n\ntup = [12836, 'Сяо Ха']\nhash_tup = tup.hash\n# Хеш-значение кортежа (12836, 'Сяо Ха') равно 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# Хеш-значение объекта #&lt;ListNode:0x000078133140ab70&gt; равно 4302940560806366381\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%86%D0%B5%D0%BB%D0%BE%D0%B3%D0%BE%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%203%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B1%D1%83%D0%BB%D0%B5%D0%B2%D0%B0%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20True%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%203.14159%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20Algo%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8%20%22Hello%20Algo%22%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836%2C%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D0%BE%D1%80%D1%82%D0%B5%D0%B6%D0%B0%20%2812836%2C%20%27%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%27%29%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%B0%20%D1%83%D0%B7%D0%BB%D0%B0%20%3CListNode%20object%20at%200x1058fd810%3E%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Во многих языках программирования в качестве <code>key</code> хеш-таблицы можно использовать только неизменяемые объекты . Если, например, использовать список (динамический массив) как <code>key</code> , то после изменения содержимого списка изменится и его хеш-значение, из-за чего мы уже не сможем найти прежнее <code>value</code> в хеш-таблице.</p> <p>Хотя у пользовательских объектов (например, у узла связного списка) поля являются изменяемыми, сам объект все же может быть хешируемым. Причина в том, что хеш-значение объекта обычно строится на основе адреса в памяти : даже если содержимое объекта меняется, его адрес памяти остается прежним, а значит, и хеш-значение не меняется.</p> <p>Внимательный читатель мог заметить, что при запуске программы в разных консолях выводимые хеш-значения отличаются. Это связано с тем, что интерпретатор Python при каждом запуске добавляет в хеш-функцию строк случайную соль (salt). Такой подход эффективно защищает от атак типа HashDoS и повышает безопасность хеш-алгоритма.</p>","path":["Глава 6. Хеширование","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   Хеш-коллизии","text":"<p>Как уже говорилось в предыдущем разделе, в обычных условиях входное пространство хеш-функции намного больше выходного пространства , поэтому теоретически хеш-коллизии неизбежны. Например, если входное пространство состоит из всех целых чисел, а выходное пространство ограничено размером массива, то неизбежно несколько целых чисел будут отображаться в один и тот же индекс бакета.</p> <p>Хеш-коллизии могут приводить к ошибочным результатам поиска и серьезно влиять на работоспособность хеш-таблицы. Чтобы решить эту проблему, можно при каждом конфликте выполнять расширение хеш-таблицы, пока конфликт не исчезнет. Этот метод понятен и прост, но слишком неэффективен, потому что расширение хеш-таблицы требует большого объема переноса данных и вычислений хеш-значений. Чтобы повысить эффективность, можно использовать следующие стратегии.</p> <ol> <li>Улучшить структуру данных хеш-таблицы, чтобы она могла корректно работать даже при возникновении хеш-коллизий.</li> <li>Выполнять расширение только тогда, когда это действительно необходимо, то есть когда хеш-коллизии становятся достаточно серьезными.</li> </ol> <p>Основные способы улучшения структуры хеш-таблицы включают метод цепочек и открытую адресацию.</p>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   Метод цепочек","text":"<p>В исходной хеш-таблице каждый бакет может хранить только одну пару ключ-значение. Метод цепочек (separate chaining) превращает отдельный элемент в связный список: пары ключ-значение становятся узлами списка, и все конфликтующие пары ключ-значение хранятся в одном и том же списке. На рисунке 6-5 показан пример хеш-таблицы, реализованной методом цепочек.</p> <p></p> <p> Рисунок 6-5   Хеш-таблица с методом цепочек </p> <p>Методы работы с хеш-таблицей, построенной на основе метода цепочек, меняются следующим образом.</p> <ul> <li>Поиск элемента: передаем <code>key</code> , по хеш-функции получаем индекс бакета, после чего обращаемся к голове списка и обходим список, сравнивая <code>key</code> , пока не найдем целевую пару ключ-значение.</li> <li>Добавление элемента: сначала через хеш-функцию получаем голову списка, затем добавляем узел (пару ключ-значение) в этот список.</li> <li>Удаление элемента: по результату хеш-функции обращаемся к голове списка, затем обходим список, находим целевой узел и удаляем его.</li> </ul> <p>Метод цепочек имеет следующие ограничения.</p> <ul> <li>Рост потребления памяти: связный список содержит указатели на узлы, поэтому по сравнению с массивом он требует больше памяти.</li> <li>Снижение эффективности поиска: для нахождения нужного элемента нужно линейно обходить связный список.</li> </ul> <p>Ниже приведена простая реализация хеш-таблицы методом цепочек. Следует обратить внимание на два момента.</p> <ul> <li>Для упрощения кода вместо связного списка используется список (динамический массив). В этой реализации хеш-таблица (массив) содержит несколько бакетов, и каждый бакет представляет собой список.</li> <li>Ниже включен метод расширения хеш-таблицы. Когда коэффициент загрузки превышает \\(\\frac{2}{3}\\) , мы расширяем хеш-таблицу до \\(2\\) раз от прежней емкости.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"Хеш-таблица с цепочками\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self.size = 0  # Число пар ключ-значение\n        self.capacity = 4  # Вместимость хеш-таблицы\n        self.load_thres = 2.0 / 3.0  # Порог коэффициента загрузки для запуска расширения\n        self.extend_ratio = 2  # Коэффициент расширения\n        self.buckets = [[] for _ in range(self.capacity)]  # Массив корзин\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Коэффициент загрузки\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Операция поиска\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # Если key не найден, вернуть None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Операция добавления\"\"\"\n        # Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # Если такого key нет, добавить пару ключ-значение в конец\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину и удалить из нее пару ключ-значение\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"Расширить хеш-таблицу\"\"\"\n        # Временно сохранить исходную хеш-таблицу\n        buckets = self.buckets\n        # Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n  private:\n    int size;                       // Число пар ключ-значение\n    int capacity;                   // Вместимость хеш-таблицы\n    double loadThres;               // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;                // Коэффициент расширения\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // Массив корзин\n\n  public:\n    /* Конструктор */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* Метод-деструктор */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // Освободить память\n                delete pair;\n            }\n        }\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        int index = hashFunc(key);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // Если key не найден, вернуть пустую строку\n        return \"\";\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // Удалить из него пару ключ-значение\n                delete tmp;                       // Освободить память\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // Освободить память\n                delete pair;\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    int size; // Число пар ключ-значение\n    int capacity; // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio; // Коэффициент расширения\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n    /* Конструктор */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Операция поиска */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    void put(int key, String val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    int size; // Число пар ключ-значение\n    int capacity; // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio; // Коэффициент расширения\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n    /* Конструктор */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Обойти корзину и удалить из нее пару ключ-значение\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void Extend() {\n        // Временно сохранить исходную хеш-таблицу\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* Хеш-таблица с цепочками */\ntype hashMapChaining struct {\n    size        int      // Число пар ключ-значение\n    capacity    int      // Вместимость хеш-таблицы\n    loadThres   float64  // Порог коэффициента загрузки для запуска расширения\n    extendRatio int      // Коэффициент расширения\n    buckets     [][]pair // Массив корзин\n}\n\n/* Конструктор */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* Хеш-функция */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* Коэффициент загрузки */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* Операция поиска */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // Если key не найден, вернуть пустую строку\n    return \"\"\n}\n\n/* Операция добавления */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // Если такого key нет, добавить пару ключ-значение в конец\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* Операция удаления */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // Обойти корзину и удалить из нее пару ключ-значение\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // Удаление из среза\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* Расширить хеш-таблицу */\nfunc (m *hashMapChaining) extend() {\n    // Временно сохранить исходную хеш-таблицу\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // Инициализация новой хеш-таблицы после расширения\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* Вывести хеш-таблицу */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    var loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    var extendRatio: Int // Коэффициент расширения\n    var buckets: [[Pair]] // Массив корзин\n\n    /* Конструктор */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* Хеш-функция */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // Если key не найден, вернуть nil\n        return nil\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    func extend() {\n        // Временно сохранить исходную хеш-таблицу\n        let bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    #size; // Число пар ключ-значение\n    #capacity; // Вместимость хеш-таблицы\n    #loadThres; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio; // Коэффициент расширения\n    #buckets; // Массив корзин\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key, val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend() {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    #size: number; // Число пар ключ-значение\n    #capacity: number; // Вместимость хеш-таблицы\n    #loadThres: number; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio: number; // Коэффициент расширения\n    #buckets: Pair[][]; // Массив корзин\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* Операция поиска */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key: number, val: string): void {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend(): void {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n  late int size; // Число пар ключ-значение\n  late int capacity; // Вместимость хеш-таблицы\n  late double loadThres; // Порог коэффициента загрузки для запуска расширения\n  late int extendRatio; // Коэффициент расширения\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n  /* Конструктор */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* Хеш-функция */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* Коэффициент загрузки */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // Если key не найден, вернуть null\n    return null;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // Если такого key нет, добавить пару ключ-значение в конец\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину и удалить из нее пару ключ-значение\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* Расширить хеш-таблицу */\n  void extend() {\n    // Временно сохранить исходную хеш-таблицу\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* Хеш-таблица с цепочками */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* Конструктор */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* Коэффициент загрузки */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* Операция удаления */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // Если key не найден, вернуть None\n        None\n    }\n\n    /* Расширить хеш-таблицу */\n    fn extend(&amp;mut self) {\n        // Временно сохранить исходную хеш-таблицу\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* Операция добавления */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // Если такого key нет, добавить пару ключ-значение в конец\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* Операция поиска */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // Если key не найден, вернуть None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* Узел связного списка */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* Хеш-таблица с цепочками */\ntypedef struct {\n    int size;         // Число пар ключ-значение\n    int capacity;     // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;  // Коэффициент расширения\n    Node **buckets;   // Массив корзин\n} HashMapChaining;\n\n/* Конструктор */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* Деструктор */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* Хеш-функция */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Коэффициент загрузки */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Операция поиска */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // Если key не найден, вернуть пустую строку\n}\n\n/* Операция добавления */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // Если встретился указанный key, обновить соответствующий val и вернуть\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // Если такого key нет, добавить пару ключ-значение в голову связного списка\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* Расширить хеш-таблицу */\nvoid extend(HashMapChaining *hashMap) {\n    // Временно сохранить исходную хеш-таблицу\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // Освободить память\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* Операция удаления */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // Удалить из него пару ключ-значение\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // Освободить память\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* Вывести хеш-таблицу */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    val loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    val extendRatio: Int // Коэффициент расширения\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // Массив корзин\n\n    /* Конструктор */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // Если key не найден, вернуть null\n        return null\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fun extend() {\n        // Временно сохранить исходную хеш-таблицу\n        val bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        // mutablelist не имеет фиксированного размера\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### Хеш-таблица с цепочками ###\nclass HashMapChaining\n  ### Конструктор ###\n  def initialize\n    @size = 0 # Число пар ключ-значение\n    @capacity = 4 # Вместимость хеш-таблицы\n    @load_thres = 2.0 / 3.0 # Порог коэффициента загрузки для запуска расширения\n    @extend_ratio = 2 # Коэффициент расширения\n    @buckets = Array.new(@capacity) { [] } # Массив корзин\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Коэффициент загрузки ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину; если найден key, вернуть соответствующее val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # Если key не найден, вернуть nil\n    nil\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    # Когда коэффициент загрузки превышает порог, выполнить расширение\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # Если такого key нет, добавить пару ключ-значение в конец\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину и удалить из нее пару ключ-значение\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### Расширение хеш-таблицы ###\n  def extend\n    # Временно сохранить исходную хеш-таблицу\n    buckets = @buckets\n    # Инициализация новой хеш-таблицы после расширения\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Следует отметить, что когда связный список становится очень длинным, эффективность поиска \\(O(n)\\) оказывается низкой. В этом случае список можно преобразовать в AVL-дерево или красно-черное дерево , чтобы оптимизировать временную сложность поиска до \\(O(\\log n)\\) .</p>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   Открытая адресация","text":"<p>Открытая адресация (open addressing) не вводит дополнительных структур данных, а обрабатывает хеш-коллизии с помощью многократного пробирования; основные варианты пробирования включают линейное пробирование, квадратичное пробирование и повторное хеширование.</p> <p>Ниже на примере линейного пробирования рассмотрим механизм работы хеш-таблицы с открытой адресацией.</p>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   Линейное пробирование","text":"<p>Линейное пробирование использует линейный поиск с фиксированным шагом. Его методы работы отличаются от обычной хеш-таблицы.</p> <ul> <li>Вставка элемента: по хеш-функции вычисляется индекс бакета; если бакет уже занят, то от места конфликта выполняется линейный обход вперед (шаг обычно равен \\(1\\) ), пока не будет найден пустой бакет, после чего элемент вставляется туда.</li> <li>Поиск элемента: если возник конфликт, то с тем же шагом продолжается линейный обход вперед, пока не будет найден целевой элемент и возвращено <code>value</code> ; если встречается пустой бакет, это означает, что искомого элемента в хеш-таблице нет, и возвращается <code>None</code> .</li> </ul> <p>На рисунке 6-6 показано распределение пар ключ-значение в хеш-таблице с открытой адресацией (линейное пробирование). Для этой хеш-функции все <code>key</code> с одинаковыми двумя последними цифрами отображаются в один и тот же бакет. Благодаря линейному пробированию они по очереди сохраняются в этом бакете и в следующих за ним бакетах.</p> <p></p> <p> Рисунок 6-6   Распределение пар ключ-значение в хеш-таблице с открытой адресацией (линейное пробирование) </p> <p>Однако линейное пробирование легко приводит к кластеризации. Иначе говоря, чем длиннее непрерывная занятая область в массиве, тем выше вероятность новых коллизий в этой области, что еще сильнее способствует росту этой группы и в итоге ухудшает эффективность операций добавления, удаления, поиска и обновления.</p> <p>Стоит заметить, что мы не можем напрямую удалять элементы из хеш-таблицы с открытой адресацией. Причина в том, что удаление создаст внутри массива пустой бакет <code>None</code> , а при поиске элемента линейное пробирование остановится на этом пустом бакете и вернет результат, из-за чего элементы ниже этого бакета уже не смогут быть найдены, и программа может ошибочно посчитать, что их не существует, как показано на рисунке 6-7.</p> <p></p> <p> Рисунок 6-7   Проблема поиска после удаления элемента в открытой адресации </p> <p>Чтобы решить эту проблему, можно использовать механизм ленивого удаления (lazy deletion): он не удаляет элемент из хеш-таблицы напрямую, **а помечает этот бакет специальной константой <code>TOMBSTONE</code> **. В этом механизме и <code>None</code> , и <code>TOMBSTONE</code> означают пустой бакет, и оба могут быть использованы для размещения пары ключ-значение. Но есть важное различие: при линейном пробировании, встретив <code>TOMBSTONE</code> , нужно продолжать обход, потому что ниже него все еще могут существовать пары ключ-значение.</p> <p>Однако ленивое удаление может ускорять деградацию производительности хеш-таблицы. Это связано с тем, что каждая операция удаления создает новую метку удаления; по мере роста числа <code>TOMBSTONE</code> время поиска тоже увеличивается, потому что линейное пробирование может быть вынуждено перескакивать через множество <code>TOMBSTONE</code> , прежде чем найдет целевой элемент.</p> <p>Поэтому имеет смысл при линейном пробировании запоминать индекс первого встреченного <code>TOMBSTONE</code> и затем менять найденный целевой элемент местами с этим <code>TOMBSTONE</code> . Преимущество такого подхода в том, что при каждом поиске или добавлении элемент будет перемещаться в бакет, расположенный ближе к его идеальной позиции (начальной точке пробирования), а значит, эффективность поиска улучшится.</p> <p>Ниже приведена реализация хеш-таблицы с открытой адресацией, то есть с линейным пробированием, включающая ленивое удаление. Чтобы пространство хеш-таблицы использовалось более полно, мы рассматриваем ее как кольцевой массив: когда обход выходит за конец массива, он возвращается к началу и продолжается.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"Хеш-таблица с открытой адресацией\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self.size = 0  # Число пар ключ-значение\n        self.capacity = 4  # Вместимость хеш-таблицы\n        self.load_thres = 2.0 / 3.0  # Порог коэффициента загрузки для запуска расширения\n        self.extend_ratio = 2  # Коэффициент расширения\n        self.buckets: list[Pair | None] = [None] * self.capacity  # Массив корзин\n        self.TOMBSTONE = Pair(-1, \"-1\")  # Удалить метку\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Коэффициент загрузки\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"Найти индекс корзины, соответствующий key\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while self.buckets[index] is not None:\n            # Если встретился key, вернуть соответствующий индекс корзины\n            if self.buckets[index].key == key:\n                # Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # Вернуть индекс корзины после перемещения\n                return index  # Вернуть индекс корзины\n            # Записать первую встретившуюся метку удаления\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % self.capacity\n        # Если key не существует, вернуть индекс точки добавления\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"Операция поиска\"\"\"\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, вернуть соответствующее val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # Если пара ключ-значение не существует, вернуть None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Операция добавления\"\"\"\n        # Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, перезаписать val и вернуть\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # Если пары ключ-значение нет, добавить ее\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, заменить ее меткой удаления\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"Расширить хеш-таблицу\"\"\"\n        # Временно сохранить исходную хеш-таблицу\n        buckets_tmp = self.buckets\n        # Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // Число пар ключ-значение\n    int capacity = 4;                     // Вместимость хеш-таблицы\n    const double loadThres = 2.0 / 3.0;     // Порог коэффициента загрузки для запуска расширения\n    const int extendRatio = 2;            // Коэффициент расширения\n    vector&lt;Pair *&gt; buckets;               // Массив корзин\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // Удалить метку\n\n  public:\n    /* Конструктор */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* Метод-деструктор */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != nullptr) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index]-&gt;key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // Если пары ключ-значение не существует, вернуть пустую строку\n        return \"\";\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private int size; // Число пар ключ-значение\n    private int capacity = 4; // Вместимость хеш-таблицы\n    private final double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n    private final int extendRatio = 2; // Коэффициент расширения\n    private Pair[] buckets; // Массив корзин\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // Удалить метку\n\n    /* Конструктор */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Хеш-функция */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index].key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    public String get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void put(int key, String val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    public void remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    private void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        Pair[] bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    int size; // Число пар ключ-значение\n    int capacity = 4; // Вместимость хеш-таблицы\n    double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio = 2; // Коэффициент расширения\n    Pair[] buckets; // Массив корзин\n    Pair TOMBSTONE = new(-1, \"-1\"); // Удалить метку\n\n    /* Конструктор */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index].key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void Extend() {\n        // Временно сохранить исходную хеш-таблицу\n        Pair[] bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* Хеш-таблица с открытой адресацией */\ntype hashMapOpenAddressing struct {\n    size        int     // Число пар ключ-значение\n    capacity    int     // Вместимость хеш-таблицы\n    loadThres   float64 // Порог коэффициента загрузки для запуска расширения\n    extendRatio int     // Коэффициент расширения\n    buckets     []*pair // Массив корзин\n    TOMBSTONE   *pair   // Удалить метку\n}\n\n/* Конструктор */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* Хеш-функция */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // Вычислить хеш-значение по ключу\n}\n\n/* Коэффициент загрузки */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // Вычислить текущий коэффициент загрузки\n}\n\n/* Найти индекс корзины, соответствующий key */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // Получить начальный индекс\n    firstTombstone := -1     // Запомнить положение первого TOMBSTONE\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // Вернуть индекс корзины после перемещения\n            }\n            return index // Вернуть найденный индекс\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // Запомнить положение первой метки удаления\n        }\n        index = (index + 1) % h.capacity // Линейное пробирование: при выходе за хвост вернуться к началу\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* Операция поиска */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // Если пара ключ-значение найдена, вернуть соответствующее val\n    }\n    return \"\" // Если пара ключ-значение не существует, вернуть \"\"\n}\n\n/* Операция добавления */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // Когда коэффициент загрузки превышает порог, выполнить расширение\n    }\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // Если пары ключ-значение нет, добавить ее\n        h.size++\n    } else {\n        h.buckets[index].val = val // Если пара ключ-значение найдена, перезаписать val\n    }\n}\n\n/* Операция удаления */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // Если пара ключ-значение найдена, заменить ее меткой удаления\n        h.size--\n    }\n}\n\n/* Расширить хеш-таблицу */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // Временно сохранить исходную хеш-таблицу\n    h.capacity *= h.extendRatio           // Обновить емкость\n    h.buckets = make([]*pair, h.capacity) // Инициализация новой хеш-таблицы после расширения\n    h.size = 0                            // Сбросить размер\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* Вывести хеш-таблицу */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    var loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    var extendRatio: Int // Коэффициент расширения\n    var buckets: [Pair?] // Массив корзин\n    var TOMBSTONE: Pair // Удалить метку\n\n    /* Конструктор */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* Хеш-функция */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while buckets[index] != nil {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if buckets[index]!.key == key {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Вернуть индекс корзины после перемещения\n                }\n                return index // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return nil\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    func extend() {\n        // Временно сохранить исходную хеш-таблицу\n        let bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    #size; // Число пар ключ-значение\n    #capacity; // Вместимость хеш-таблицы\n    #loadThres; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio; // Коэффициент расширения\n    #buckets; // Массив корзин\n    #TOMBSTONE; // Удалить метку\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0; // Число пар ключ-значение\n        this.#capacity = 4; // Вместимость хеш-таблицы\n        this.#loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n        this.#extendRatio = 2; // Коэффициент расширения\n        this.#buckets = Array(this.#capacity).fill(null); // Массив корзин\n        this.#TOMBSTONE = new Pair(-1, '-1'); // Удалить метку\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (this.#buckets[index] !== null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (this.#buckets[index].key === key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % this.#capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key, val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key) {\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend() {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private size: number; // Число пар ключ-значение\n    private capacity: number; // Вместимость хеш-таблицы\n    private loadThres: number; // Порог коэффициента загрузки для запуска расширения\n    private extendRatio: number; // Коэффициент расширения\n    private buckets: Array&lt;Pair | null&gt;; // Массив корзин\n    private TOMBSTONE: Pair; // Удалить метку\n\n    /* Конструктор */\n    constructor() {\n        this.size = 0; // Число пар ключ-значение\n        this.capacity = 4; // Вместимость хеш-таблицы\n        this.loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n        this.extendRatio = 2; // Коэффициент расширения\n        this.buckets = Array(this.capacity).fill(null); // Массив корзин\n        this.TOMBSTONE = new Pair(-1, '-1'); // Удалить метку\n    }\n\n    /* Хеш-функция */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* Коэффициент загрузки */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (this.buckets[index] !== null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (this.buckets[index]!.key === key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % this.capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    get(key: number): string | null {\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key: number, val: string): void {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* Операция удаления */\n    remove(key: number): void {\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    private extend(): void {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n  late int _size; // Число пар ключ-значение\n  int _capacity = 4; // Вместимость хеш-таблицы\n  double _loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n  int _extendRatio = 2; // Коэффициент расширения\n  late List&lt;Pair?&gt; _buckets; // Массив корзин\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // Удалить метку\n\n  /* Конструктор */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* Хеш-функция */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* Коэффициент загрузки */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* Найти индекс корзины, соответствующий key */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while (_buckets[index] != null) {\n      // Если встретился key, вернуть соответствующий индекс корзины\n      if (_buckets[index]!.key == key) {\n        // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // Вернуть индекс корзины после перемещения\n        }\n        return index; // Вернуть индекс корзины\n      }\n      // Записать первую встретившуюся метку удаления\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // Вычислить индекс корзины; при выходе за конец вернуться к началу\n      index = (index + 1) % _capacity;\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, вернуть соответствующее val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // Если пары ключ-значение не существует, вернуть null\n    return null;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, перезаписать val и вернуть\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // Если пары ключ-значение нет, добавить ее\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, заменить ее меткой удаления\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* Расширить хеш-таблицу */\n  void extend() {\n    // Временно сохранить исходную хеш-таблицу\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* Хеш-таблица с открытой адресацией */\nstruct HashMapOpenAddressing {\n    size: usize,                // Число пар ключ-значение\n    capacity: usize,            // Вместимость хеш-таблицы\n    load_thres: f64,            // Порог коэффициента загрузки для запуска расширения\n    extend_ratio: usize,        // Коэффициент расширения\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // Массив корзин\n    TOMBSTONE: Option&lt;Pair&gt;,    // Удалить метку\n}\n\nimpl HashMapOpenAddressing {\n    /* Конструктор */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* Коэффициент загрузки */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while self.buckets[index].is_some() {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение в этот индекс\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % self.capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* Операция поиска */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        None\n    }\n\n    /* Операция добавления */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* Операция удаления */\n    fn remove(&amp;mut self, key: i32) {\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fn extend(&amp;mut self) {\n        // Временно сохранить исходную хеш-таблицу\n        let buckets_tmp = self.buckets.clone();\n        // Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* Вывести хеш-таблицу */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* Хеш-таблица с открытой адресацией */\ntypedef struct {\n    int size;         // Число пар ключ-значение\n    int capacity;     // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;  // Коэффициент расширения\n    Pair **buckets;   // Массив корзин\n    Pair *TOMBSTONE;  // Удалить метку\n} HashMapOpenAddressing;\n\n/* Конструктор */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* Деструктор */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* Хеш-функция */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Коэффициент загрузки */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Найти индекс корзины, соответствующий key */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // Если встретился key, вернуть соответствующий индекс корзины\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // Вернуть индекс корзины после перемещения\n            }\n            return index; // Вернуть индекс корзины\n        }\n        // Записать первую встретившуюся метку удаления\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // Вычислить индекс корзины; при выходе за конец вернуться к началу\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* Операция поиска */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, вернуть соответствующее val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // Если пары ключ-значение не существует, вернуть пустую строку\n    return \"\";\n}\n\n/* Операция добавления */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, перезаписать val и вернуть\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // Если пары ключ-значение нет, добавить ее\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* Операция удаления */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, заменить ее меткой удаления\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* Расширить хеш-таблицу */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // Временно сохранить исходную хеш-таблицу\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // Инициализация новой хеш-таблицы после расширения\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* Вывести хеш-таблицу */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private var size: Int               // Число пар ключ-значение\n    private var capacity: Int           // Вместимость хеш-таблицы\n    private val loadThres: Double       // Порог коэффициента загрузки для запуска расширения\n    private val extendRatio: Int        // Коэффициент расширения\n    private var buckets: Array&lt;Pair?&gt;   // Массив корзин\n    private val TOMBSTONE: Pair         // Удалить метку\n\n    /* Конструктор */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index]?.key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Вернуть индекс корзины после перемещения\n                }\n                return index // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fun extend() {\n        // Временно сохранить исходную хеш-таблицу\n        val bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### Хеш-таблица с открытой адресацией ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # Удалить метку\n\n  ### Конструктор ###\n  def initialize\n    @size = 0 # Число пар ключ-значение\n    @capacity = 4 # Вместимость хеш-таблицы\n    @load_thres = 2.0 / 3.0 # Порог коэффициента загрузки для запуска расширения\n    @extend_ratio = 2 # Коэффициент расширения\n    @buckets = Array.new(@capacity) # Массив корзин\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Коэффициент загрузки ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Найти индекс корзины, соответствующий key ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while !@buckets[index].nil?\n      # Если встретился key, вернуть соответствующий индекс корзины\n      if @buckets[index].key == key\n        # Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # Вернуть индекс корзины после перемещения\n        end\n        return index # Вернуть индекс корзины\n      end\n      # Записать первую встретившуюся метку удаления\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # Вычислить индекс корзины; при выходе за конец вернуться к началу\n      index = (index + 1) % @capacity\n    end\n    # Если key не существует, вернуть индекс точки добавления\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, вернуть соответствующее val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # Если пара ключ-значение не существует, вернуть nil\n    nil\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    # Когда коэффициент загрузки превышает порог, выполнить расширение\n    extend if load_factor &gt; @load_thres\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, перезаписать val и вернуть\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # Если пары ключ-значение нет, добавить ее\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, заменить ее меткой удаления\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### Расширение хеш-таблицы ###\n  def extend\n    # Временно сохранить исходную хеш-таблицу\n    buckets_tmp = @buckets\n    # Инициализация новой хеш-таблицы после расширения\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   Квадратичное пробирование","text":"<p>Квадратичное пробирование похоже на линейное пробирование и тоже является одной из распространенных стратегий открытой адресации. При возникновении конфликта оно не пропускает фиксированное число шагов, а переходит на расстояние, равное \"квадрату числа попыток\", то есть на \\(1, 4, 9, \\dots\\) шагов.</p> <p>Квадратичное пробирование имеет следующие основные преимущества.</p> <ul> <li>Квадратичное пробирование пытается смягчить эффект кластеризации линейного пробирования, так как пропускает расстояния, равные квадрату номера попытки.</li> <li>Квадратичное пробирование перепрыгивает на более дальние позиции в поисках свободного места, что помогает распределять данные более равномерно.</li> </ul> <p>Однако квадратичное пробирование не является идеальным.</p> <ul> <li>Кластеризация все равно существует: некоторые позиции по-прежнему занимают чаще других.</li> <li>Из-за быстрого роста квадрата квадратичное пробирование может не охватить всю хеш-таблицу, а это означает, что даже при наличии пустых бакетов оно может так до них и не добраться.</li> </ul>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   Повторное хеширование","text":"<p>Как видно из названия, метод повторного хеширования использует для пробирования несколько хеш-функций \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) .</p> <ul> <li>Вставка элемента: если хеш-функция \\(f_1(x)\\) вызывает конфликт, то пробуем \\(f_2(x)\\) , и так далее, пока не будет найдено пустое место для вставки элемента.</li> <li>Поиск элемента: поиск идет в том же порядке хеш-функций, пока не будет найден целевой элемент; если встречается пустая позиция или уже были опробованы все хеш-функции, это означает, что элемента в хеш-таблице нет, и возвращается <code>None</code> .</li> </ul> <p>По сравнению с линейным пробированием метод повторного хеширования меньше подвержен кластеризации, но несколько хеш-функций приносят дополнительные вычислительные затраты.</p> <p>Tip</p> <p>Обрати внимание: у хеш-таблиц с открытой адресацией (линейное пробирование, квадратичное пробирование и повторное хеширование) есть общая проблема: в них нельзя напрямую удалять элементы.</p>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   Выбор в языках программирования","text":"<p>Разные языки программирования используют разные стратегии реализации хеш-таблиц. Ниже приведено несколько примеров.</p> <ul> <li>Python использует открытую адресацию. В словаре <code>dict</code> для пробирования применяются псевдослучайные числа.</li> <li>Java использует метод цепочек. Начиная с JDK 1.8, когда длина массива внутри <code>HashMap</code> достигает 64, а длина списка достигает 8, этот список преобразуется в красно-черное дерево для повышения производительности поиска.</li> <li>Go использует метод цепочек. В Go установлено, что каждый бакет может хранить не более 8 пар ключ-значение; при переполнении подключается overflow-бакет, а когда таких бакетов становится слишком много, выполняется специальное расширение того же масштаба, чтобы сохранить производительность.</li> </ul>","path":["Глава 6. Хеширование","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   Хеш-таблица","text":"<p>Хеш-таблица (hash table), также называемая таблицей рассеяния, реализует эффективный поиск элементов за счет установления соответствия между ключом <code>key</code> и значением <code>value</code> . Иначе говоря, если передать в хеш-таблицу ключ <code>key</code> , то можно за \\(O(1)\\) времени получить соответствующее значение <code>value</code> .</p> <p>Как показано на рисунке 6-1, пусть есть \\(n\\) студентов, и у каждого из них есть два поля данных: имя и номер студенческого билета. Если мы хотим реализовать запрос вида \"ввести номер студенческого билета и вернуть соответствующее имя\", то для этого можно использовать показанную ниже хеш-таблицу.</p> <p></p> <p> Рисунок 6-1   Абстрактное представление хеш-таблицы </p> <p>Помимо хеш-таблицы, функцией поиска также обладают массив и связный список. Сравнение их эффективности приведено в таблице 6-1.</p> <ul> <li>Добавление элемента: нужно лишь добавить элемент в конец массива (или списка), что занимает \\(O(1)\\) времени.</li> <li>Поиск элемента: так как массив (или список) неупорядочен, приходится обходить все элементы, что занимает \\(O(n)\\) времени.</li> <li>Удаление элемента: сначала нужно найти элемент, затем удалить его из массива (или списка), что занимает \\(O(n)\\) времени.</li> </ul> <p> Таблица 6-1   Сравнение эффективности поиска элементов </p> Массив Связный список Хеш-таблица Поиск элемента \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Добавление элемента \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>Нетрудно заметить, что операции поиска, добавления и удаления в хеш-таблице имеют временную сложность \\(O(1)\\) , то есть выполняются очень эффективно.</p>","path":["Глава 6. Хеширование","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#611-","level":2,"title":"6.1.1   Основные операции с хеш-таблицей","text":"<p>К базовым операциям хеш-таблицы относятся инициализация, поиск, добавление пар ключ-значение и удаление пар ключ-значение. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Инициализация хеш-таблицы\nhmap: dict = {}\n\n# Операция добавления\n# Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n# Операция поиска\n# Передать в хеш-таблицу ключ key и получить значение value\nname: str = hmap[15937]\n\n# Операция удаления\n# Удалить пару ключ-значение (key, value) из хеш-таблицы\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* Инициализация хеш-таблицы */\nunordered_map&lt;int, string&gt; map;\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\";\nmap[15937] = \"Сяо Ло\";\nmap[16750] = \"Сяо Суань\";\nmap[13276] = \"Сяо Фа\";\nmap[10583] = \"Сяо Я\";\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nstring name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* Инициализация хеш-таблицы */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.put(12836, \"Сяо Ха\");\nmap.put(15937, \"Сяо Ло\");\nmap.put(16750, \"Сяо Суань\");\nmap.put(13276, \"Сяо Фа\");\nmap.put(10583, \"Сяо Я\");\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nString name = map.get(15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* Инициализация хеш-таблицы */\nDictionary&lt;int, string&gt; map = new() {\n    /* Операция добавления */\n    // Добавить пару ключ-значение (key, value) в хеш-таблицу\n    { 12836, \"Сяо Ха\" },\n    { 15937, \"Сяо Ло\" },\n    { 16750, \"Сяо Суань\" },\n    { 13276, \"Сяо Фа\" },\n    { 10583, \"Сяо Я\" }\n};\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nstring name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* Инициализация хеш-таблицы */\nhmap := make(map[int]string)\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nname := hmap[15937]\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* Инициализация хеш-таблицы */\nvar map: [Int: String] = [:]\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\"\nmap[15937] = \"Сяо Ло\"\nmap[16750] = \"Сяо Суань\"\nmap[13276] = \"Сяо Фа\"\nmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map[15937]!\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* Инициализация хеш-таблицы */\nconst map = new Map();\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.set(12836, 'Сяо Ха');\nmap.set(15937, 'Сяо Ло');\nmap.set(16750, 'Сяо Суань');\nmap.set(13276, 'Сяо Фа');\nmap.set(10583, 'Сяо Я');\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map.get(15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* Инициализация хеш-таблицы */\nconst map = new Map&lt;number, string&gt;();\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.set(12836, 'Сяо Ха');\nmap.set(15937, 'Сяо Ло');\nmap.set(16750, 'Сяо Суань');\nmap.set(13276, 'Сяо Фа');\nmap.set(10583, 'Сяо Я');\nconsole.info('\\nПосле добавления хеш-таблица имеет вид\\nKey -&gt; Value');\nconsole.info(map);\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map.get(15937);\nconsole.info('\\nПо номеру 15937 найдено имя ' + name);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.delete(10583);\nconsole.info('\\nПосле удаления 10583 хеш-таблица имеет вид\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* Инициализация хеш-таблицы */\nMap&lt;int, String&gt; map = {};\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\";\nmap[15937] = \"Сяо Ло\";\nmap[16750] = \"Сяо Суань\";\nmap[13276] = \"Сяо Фа\";\nmap[10583] = \"Сяо Я\";\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nString name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* Инициализация хеш-таблицы */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.insert(12836, \"Сяо Ха\".to_string());\nmap.insert(15937, \"Сяо Ло\".to_string());\nmap.insert(16750, \"Сяо Суань\".to_string());\nmap.insert(13279, \"Сяо Фа\".to_string());\nmap.insert(10583, \"Сяо Я\".to_string());\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// В C нет встроенной хеш-таблицы\n</code></pre> hash_map.kt<pre><code>/* Инициализация хеш-таблицы */\nval map = HashMap&lt;Int,String&gt;()\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\"\nmap[15937] = \"Сяо Ло\"\nmap[16750] = \"Сяо Суань\"\nmap[13276] = \"Сяо Фа\"\nmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nval name = map[15937]\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># Инициализация хеш-таблицы\nhmap = {}\n\n# Операция добавления\n# Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n# Операция поиска\n# Передать в хеш-таблицу ключ key и получить значение value\nname = hmap[15937]\n\n# Операция удаления\n# Удалить пару ключ-значение (key, value) из хеш-таблицы\nhmap.delete(10583)\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%9B%D0%BE%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A1%D1%83%D0%B0%D0%BD%D1%8C%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A4%D0%B0%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%D0%A3%D1%82%D0%B5%D0%BD%D0%BE%D0%BA%22%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%82%D1%8C%20%D0%BA%D0%BB%D1%8E%D1%87%20key%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%B8%20%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D0%B8%D0%B7%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Существует три распространенных способа обхода хеш-таблицы: обход пар ключ-значение, обход ключей и обход значений. Примеры кода приведены ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Обход хеш-таблицы\n# Обход пар ключ-значение key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# Обход только ключей key\nfor key in hmap.keys():\n    print(key)\n# Обход только значений value\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// Обход key-&gt;value с помощью итератора\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// Обход только ключей key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Обход только значений value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// Обход только ключей key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Обход только значений value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// Обход только ключей key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Обход только значений value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// Обход только ключей Key\nfor key in map.keys {\n    print(key)\n}\n// Обход только значений Value\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* Обход хеш-таблицы */\nconsole.info('\\nОбход пар ключ-значение Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nОбход только ключей Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nОбход только значений Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* Обход хеш-таблицы */\nconsole.info('\\nОбход пар ключ-значение Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nОбход только ключей Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nОбход только значений Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// Обход только ключей Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// Обход только значений Value\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// Обход только ключей Key\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// Обход только значений Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// В C нет встроенной хеш-таблицы\n</code></pre> hash_map.kt<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// Обход только ключей key\nfor (key in map.keys) {\n    println(key)\n}\n// Обход только значений value\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># Обход хеш-таблицы\n# Обход пар ключ-значение key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# Обход только ключей key\nhmap.keys.each { |key| puts key }\n\n# Обход только значений value\nhmap.values.each { |val| puts val }\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%9B%D0%BE%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A1%D1%83%D0%B0%D0%BD%D1%8C%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A4%D0%B0%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%D0%A3%D1%82%D0%B5%D0%BD%D0%BE%D0%BA%22%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%B1%D1%80%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20%23%20%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%BF%D0%B0%D1%80%D0%B0%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20key-%3Evalue%0A%20%20%20%20for%20key%2C%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%2C%20%22-%3E%22%2C%20value%29%0A%20%20%20%20%23%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%BA%D0%BB%D1%8E%D1%87%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 6. Хеширование","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#612-","level":2,"title":"6.1.2   Простая реализация хеш-таблицы","text":"<p>Сначала рассмотрим самый простой случай: реализуем хеш-таблицу только с помощью одного массива. В хеш-таблице каждую пустую ячейку массива мы называем бакетом (bucket), и каждый бакет может хранить одну пару ключ-значение. Следовательно, операция поиска сводится к тому, чтобы найти бакет, соответствующий <code>key</code> , и получить из него <code>value</code> .</p> <p>Но как определить бакет, соответствующий заданному <code>key</code> ? Это делается с помощью хеш-функции (hash function). Назначение хеш-функции - отображать большое входное пространство в меньшее выходное пространство. В хеш-таблице входным пространством являются все <code>key</code> , а выходным - все бакеты, то есть индексы массива. Иначе говоря, передав <code>key</code> на вход, мы можем с помощью хеш-функции получить позицию хранения соответствующей пары ключ-значение в массиве.</p> <p>Процесс вычисления хеш-функции для одного <code>key</code> включает два шага.</p> <ol> <li>Сначала с помощью некоторого хеш-алгоритма <code>hash()</code> вычисляется хеш-значение.</li> <li>Затем хеш-значение берется по модулю числа бакетов (длины массива) <code>capacity</code> , чтобы получить бакет (индекс массива) <code>index</code> , соответствующий этому <code>key</code> .</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>После этого можно использовать <code>index</code> для доступа к соответствующему бакету в хеш-таблице и получения <code>value</code> .</p> <p>Пусть длина массива <code>capacity = 100</code> , а хеш-алгоритм <code>hash(key) = key</code> . Тогда легко получить хеш-функцию <code>key % 100</code> . На рисунке 6-2 на примере <code>key</code> \"номер студенческого билета\" и <code>value</code> \"имя\" показан принцип работы хеш-функции.</p> <p></p> <p> Рисунок 6-2   Принцип работы хеш-функции </p> <p>Ниже приведен код простой реализации хеш-таблицы. В нем мы инкапсулируем <code>key</code> и <code>value</code> в класс <code>Pair</code> , чтобы представить пару ключ-значение.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"Пара ключ-значение\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"Хеш-таблица на основе массива\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        # Инициализировать массив, содержащий 100 корзин\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Операция поиска\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"Операции добавления и обновления\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        index: int = self.hash_func(key)\n        # Присвоить None, что означает удаление\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"Получить все пары ключ-значение\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"Получить все ключи\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"Получить все значения\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* Пара ключ-значение */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // Освободить память\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // Освободить память и присвоить nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* Получить все пары ключ-значение */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* Пара ключ-значение */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* Хеш-функция */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* Операция удаления */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // Присвоить null, что означает удаление\n        buckets.set(index, null);\n    }\n\n    /* Получить все пары ключ-значение */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* Пара ключ-значение int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Присвоить null, что означает удаление\n        buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* Пара ключ-значение */\ntype pair struct {\n    key int\n    val string\n}\n\n/* Хеш-таблица на основе массива */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* Инициализация хеш-таблицы */\nfunc newArrayHashMap() *arrayHashMap {\n    // Инициализировать массив, содержащий 100 корзин\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* Хеш-функция */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* Операция поиска */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* Операция добавления */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* Операция удаления */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // Присвоить nil, что означает удаление\n    a.buckets[index] = nil\n}\n\n/* Получить все ключи */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* Получить все ключи */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* Получить все значения */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* Вывести хеш-таблицу */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* Пара ключ-значение */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* Хеш-функция */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // Присвоить nil, что означает удаление\n        buckets[index] = nil\n    }\n\n    /* Получить все пары ключ-значение */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* Получить все ключи */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* Получить все значения */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* Пара ключ-значение Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // Инициализировать массив, содержащий 100 корзин\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* Операция удаления */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // Присвоить null, что означает удаление\n        this.#buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все ключи */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все значения */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* Пара ключ-значение Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // Инициализировать массив, содержащий 100 корзин\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* Хеш-функция */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* Операция поиска */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* Операция удаления */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // Присвоить null, что означает удаление\n        this.buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все ключи */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все значения */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Вывести хеш-таблицу */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* Пара ключ-значение */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // Инициализировать массив, содержащий 100 корзин\n    _buckets = List.filled(100, null);\n  }\n\n  /* Хеш-функция */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* Получить все пары ключ-значение */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* Получить все ключи */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* Получить все значения */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* Пара ключ-значение */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* Хеш-таблица на основе массива */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // Инициализировать массив, содержащий 100 корзин\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* Операция поиска */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* Операция добавления */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* Операция удаления */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // Присвоить None, что означает удаление\n        self.buckets[index] = None;\n    }\n\n    /* Получить все пары ключ-значение */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* Получить все ключи */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* Получить все значения */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* Вывести хеш-таблицу */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* Пара ключ-значение int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* Хеш-таблица на основе массива */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* Конструктор */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* Деструктор */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* Операция добавления */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* Операция удаления */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* Получить все пары ключ-значение */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* Получить все ключи */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* Получить все значения */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* Вывести хеш-таблицу */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* Пара ключ-значение */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    // Инициализировать массив, содержащий 100 корзин\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // Присвоить null, что означает удаление\n        buckets[index] = null\n    }\n\n    /* Получить все пары ключ-значение */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* Получить все ключи */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* Получить все значения */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### Пара ключ-значение ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### Хеш-таблица на основе массива ###\nclass ArrayHashMap\n  ### Конструктор ###\n  def initialize\n    # Инициализировать массив, содержащий 100 корзин\n    @buckets = Array.new(100)\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    index = hash_func(key)\n    # Присвоить nil, что означает удаление\n    @buckets[index] = nil\n  end\n\n  ### Получить все пары ключ-значение ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### Получить все ключи ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### Получить все значения ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 6. Хеширование","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#613-","level":2,"title":"6.1.3   Хеш-коллизии и расширение","text":"<p>По сути, хеш-функция отображает входное пространство, состоящее из всех <code>key</code> , в выходное пространство, состоящее из всех индексов массива, а входное пространство обычно значительно больше выходного. Поэтому теоретически неизбежно существование ситуации \"несколько входов соответствуют одному выходу\".</p> <p>Для хеш-функции из приведенного выше примера, если последние две цифры <code>key</code> совпадают, то совпадает и результат хеш-функции. Например, если искать студентов с номерами 12836 и 20336, то получим:</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>Как показано на рисунке 6-3, два номера указывают на одно и то же имя, что, очевидно, неверно. Такую ситуацию, когда нескольким входам соответствует один и тот же выход, называют хеш-коллизией (hash collision).</p> <p></p> <p> Рисунок 6-3   Пример хеш-коллизии </p> <p>Легко понять, что чем больше емкость хеш-таблицы \\(n\\) , тем ниже вероятность того, что несколько <code>key</code> попадут в один и тот же бакет, а значит, тем меньше коллизий. Поэтому мы можем уменьшать число хеш-коллизий путем расширения хеш-таблицы.</p> <p>Как показано на рисунке 6-4, до расширения пары ключ-значение <code>(136, A)</code> и <code>(236, D)</code> конфликтовали, а после расширения коллизия исчезла.</p> <p></p> <p> Рисунок 6-4   Расширение хеш-таблицы </p> <p>Подобно расширению массива, расширение хеш-таблицы требует перенести все пары ключ-значение из старой таблицы в новую, а это очень затратно по времени; кроме того, поскольку емкость хеш-таблицы <code>capacity</code> изменилась, нам приходится с помощью хеш-функции заново вычислять позиции хранения всех пар ключ-значение, что дополнительно увеличивает вычислительные расходы процесса расширения. Поэтому языки программирования обычно заранее резервируют достаточно большую емкость хеш-таблицы, чтобы избежать частых расширений.</p> <p>Коэффициент загрузки (load factor) - важное понятие хеш-таблицы. Он определяется как отношение числа элементов в хеш-таблице к числу бакетов и используется для оценки степени серьезности хеш-коллизий, а также часто служит условием срабатывания расширения хеш-таблицы. Например, в Java, когда коэффициент загрузки превышает \\(0.75\\) , система расширяет хеш-таблицу до \\(2\\) раз от исходной емкости.</p>","path":["Глава 6. Хеширование","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   Резюме","text":"","path":["Глава 6. Хеширование","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Передав <code>key</code> , мы можем получить <code>value</code> из хеш-таблицы за \\(O(1)\\) времени, поэтому она очень эффективна.</li> <li>К типичным операциям хеш-таблицы относятся поиск, добавление пары ключ-значение, удаление пары ключ-значение и обход хеш-таблицы.</li> <li>Хеш-функция отображает <code>key</code> в индекс массива, после чего можно обратиться к соответствующему бакету и получить <code>value</code> .</li> <li>Два разных <code>key</code> после хеш-функции могут дать один и тот же индекс массива, что приводит к ошибочному результату поиска; это явление называется хеш-коллизией.</li> <li>Чем больше емкость хеш-таблицы, тем ниже вероятность хеш-коллизий. Поэтому хеш-коллизии можно смягчать путем расширения хеш-таблицы. Как и у массива, операция расширения у хеш-таблицы очень затратна.</li> <li>Коэффициент загрузки определяется как отношение числа элементов в хеш-таблице к числу бакетов, отражает степень серьезности хеш-коллизий и часто используется как условие запуска расширения хеш-таблицы.</li> <li>Метод цепочек превращает одиночный элемент в связный список и хранит все конфликтующие элементы в одном списке. Однако слишком длинный список снижает эффективность поиска, поэтому его можно дополнительно преобразовать в красно-черное дерево.</li> <li>Открытая адресация обрабатывает хеш-коллизии за счет многократного пробирования. Линейное пробирование использует фиксированный шаг, его недостатки - невозможность прямого удаления элементов и склонность к кластеризации. Повторное хеширование использует несколько хеш-функций и по сравнению с линейным пробированием меньше подвержено кластеризации, но требует больше вычислений.</li> <li>Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, <code>HashMap</code> в Java использует метод цепочек, а <code>Dict</code> в Python - открытую адресацию.</li> <li>Для хеш-таблицы желательно, чтобы хеш-алгоритм был детерминированным, быстрым и обеспечивал равномерное распределение. В криптографии от него дополнительно требуют устойчивости к коллизиям и эффекта лавины.</li> <li>В качестве модуля хеш-алгоритмы обычно используют большое простое число, чтобы максимально обеспечить равномерность распределения хеш-значений и снизить число хеш-коллизий.</li> <li>К распространенным хеш-алгоритмам относятся MD5, SHA-1, SHA-2 и SHA-3. MD5 часто применяли для проверки целостности файлов, а SHA-2 широко используется в протоколах и приложениях, связанных с безопасностью.</li> <li>Языки программирования обычно предоставляют для типов данных встроенные хеш-алгоритмы, чтобы вычислять индексы бакетов в хеш-таблице. Как правило, хешируемыми могут быть только неизменяемые объекты.</li> </ul>","path":["Глава 6. Хеширование","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: В каких случаях временная сложность хеш-таблицы становится \\(O(n)\\) ?</p> <p>Когда хеш-коллизии становятся достаточно серьезными, временная сложность хеш-таблицы деградирует до \\(O(n)\\) . Если хеш-функция спроектирована хорошо, емкость выбрана разумно, а конфликты распределены достаточно равномерно, то временная сложность обычно считается \\(O(1)\\) . При использовании встроенной хеш-таблицы языка программирования мы, как правило, и принимаем ее за \\(O(1)\\) .</p> <p>Q: Почему бы не использовать хеш-функцию \\(f(x) = x\\) ? Тогда ведь коллизий не будет.</p> <p>При хеш-функции \\(f(x) = x\\) каждому элементу соответствует уникальный индекс бакета, и такая структура становится эквивалентна массиву. Однако входное пространство обычно намного больше выходного пространства (длины массива), поэтому последним шагом хеш-функции обычно выступает взятие по модулю длины массива. Иначе говоря, цель хеш-таблицы состоит в том, чтобы отобразить большее пространство состояний в меньшее пространство и при этом обеспечить \\(O(1)\\) поиска.</p> <p>Q: В основе хеш-таблицы лежат массив, связный список и двоичное дерево. Почему же она может быть быстрее них?</p> <p>Во-первых, у хеш-таблицы повышается временная эффективность, но снижается пространственная эффективность. Значительная часть ее памяти остается неиспользованной.</p> <p>Во-вторых, она быстрее только в определенных сценариях. Если одну и ту же задачу можно реализовать на массиве или связном списке с той же асимптотикой, то часто такая реализация окажется быстрее, чем хеш-таблица. Причина в том, что вычисление хеш-функции само по себе стоит времени, то есть константа в сложности получается выше.</p> <p>Наконец, временная сложность хеш-таблицы тоже может деградировать. Например, при методе цепочек мы все равно выполняем поиск в связном списке или красно-черном дереве, поэтому риск деградации до \\(O(n)\\) сохраняется.</p> <p>Q: Есть ли у повторного хеширования недостаток \"нельзя напрямую удалять элементы\"? Можно ли повторно использовать место, помеченное как удаленное?</p> <p>Повторное хеширование - это разновидность открытой адресации, а у всех методов открытой адресации есть недостаток: элементы нельзя удалять напрямую, поэтому приходится использовать метку удаления. Пространство, помеченное как удаленное, можно использовать повторно. Когда новый элемент вставляется в хеш-таблицу и в процессе пробирования попадает на такую отмеченную позицию, эта позиция может быть занята новым элементом. Такой подход сохраняет последовательность пробирования и одновременно поддерживает приемлемую эффективность использования памяти.</p> <p>Q: Почему при линейном пробировании во время поиска элемента вообще возникает хеш-коллизия?</p> <p>Во время поиска мы через хеш-функцию находим соответствующий бакет и соответствующую пару ключ-значение, но видим, что <code>key</code> не совпадает, а это и означает наличие хеш-коллизии. Поэтому метод линейного пробирования в соответствии с заранее заданным шагом последовательно движется дальше, пока не найдет правильную пару ключ-значение или не убедится, что поиск завершился неудачей.</p> <p>Q: Почему расширение хеш-таблицы помогает смягчать хеш-коллизии?</p> <p>Последний шаг хеш-функции обычно состоит во взятии по модулю длины массива \\(n\\) , чтобы результат попадал в диапазон индексов массива; после расширения длина массива \\(n\\) меняется, а значит, может измениться и индекс, соответствующий данному <code>key</code> . Несколько <code>key</code> , которые раньше попадали в один бакет, после расширения могут распределиться по нескольким бакетам, и тем самым хеш-коллизии будут ослаблены.</p> <p>Q: Если нам нужен быстрый доступ, почему бы просто не использовать массив?</p> <p>Когда <code>key</code> данных - это непрерывные целые числа из маленького диапазона, действительно можно напрямую использовать массив: это просто и эффективно. Но если <code>key</code> имеют другой тип данных (например, строки), тогда нужен хеш-алгоритм, который отобразит <code>key</code> в индекс массива, а хранение элементов будет выполняться через массив бакетов. Такая структура и называется хеш-таблицей.</p>","path":["Глава 6. Хеширование","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"Глава 8.   Куча","text":"<p>Abstract</p> <p>Куча - это полное двоичное дерево, удовлетворяющее определенным условиям.</p> <p>В максимальной и минимальной куче элемент на вершине всегда обладает самым выраженным приоритетом.</p>","path":["Глава 8. Куча","Глава 8. &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>8.1   Куча</li> <li>8.2   Построение кучи</li> <li>8.3   Задача Top-K</li> <li>8.4   Резюме</li> </ul>","path":["Глава 8. Куча","Глава 8. &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   Построение кучи","text":"<p>В некоторых случаях требуется построить кучу, используя сразу все элементы списка. Этот процесс называется построением кучи.</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   Реализация через операцию добавления в кучу","text":"<p>Сначала мы создаем пустую кучу, затем обходим список и для каждого элемента по очереди выполняем операцию добавления в кучу: сначала помещаем элемент в хвост кучи, а затем выполняем для него упорядочивание снизу вверх.</p> <p>Каждый раз, когда элемент добавляется в кучу, ее длина увеличивается на единицу. Поскольку узлы последовательно добавляются в двоичное дерево сверху вниз, куча строится сверху вниз.</p> <p>Пусть число элементов равно \\(n\\) ; так как каждая операция добавления требует \\(O(\\log{n})\\) времени, временная сложность такого построения кучи составляет \\(O(n \\log n)\\) .</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   Реализация через обход и упорядочивание","text":"<p>На самом деле можно реализовать и более эффективный способ построения кучи, который состоит из двух шагов.</p> <ol> <li>Без изменений добавить все элементы списка в кучу; в этот момент свойства кучи еще не выполняются.</li> <li>Обойти кучу в обратном порядке, то есть в порядке, обратном обходу по уровням, и по очереди выполнить упорядочивание сверху вниз для каждого нелистового узла.</li> </ol> <p>После того как некоторый узел был упорядочен, поддерево с этим узлом в качестве корня становится корректной подкучей. А поскольку обход выполняется в обратном порядке, куча строится снизу вверх.</p> <p>Причина выбора обратного обхода в том, что он гарантирует: поддеревья ниже текущего узла уже являются корректными подкучами, а значит, упорядочивание текущего узла действительно будет эффективным.</p> <p>Стоит отметить, что листовые узлы не имеют дочерних узлов, поэтому они естественным образом являются корректными подкучами и не требуют упорядочивания. Как показано в коде ниже, последний нелистовой узел является родителем последнего узла, и именно с него мы начинаем обратный обход и упорядочивание:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"Конструктор, строящий кучу по входному списку\"\"\"\n    # Добавить элементы списка в кучу без изменений\n    self.max_heap = nums\n    # Выполнить heapify для всех узлов, кроме листовых\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(vector&lt;int&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = nums;\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Конструктор: построить кучу по входному списку */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = new List&lt;int&gt;(nums);\n    // Выполнить heapify для всех узлов, кроме листовых\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Конструктор, строящий кучу по срезу */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // Добавить элементы списка в кучу без изменений\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // Выполнить heapify для всех узлов, кроме листовых\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* Конструктор, строящий кучу по входному списку */\ninit(nums: [Int]) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = nums\n    // Выполнить heapify для всех узлов, кроме листовых\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Конструктор, создающий пустую кучу или строящий кучу по входному списку */\nconstructor(nums) {\n    // Добавить элементы списка в кучу без изменений\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Конструктор, создающий пустую кучу или строящий кучу по входному списку */\nconstructor(nums?: number[]) {\n    // Добавить элементы списка в кучу без изменений\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(List&lt;int&gt; nums) {\n  // Добавить элементы списка в кучу без изменений\n  _maxHeap = nums;\n  // Выполнить heapify для всех узлов, кроме листовых\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Конструктор, строящий кучу по входному списку */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // Добавить элементы списка в кучу без изменений\n    let mut heap = MaxHeap { max_heap: nums };\n    // Выполнить heapify для всех узлов, кроме листовых\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* Конструктор, строящий кучу по срезу */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // Поместить все элементы в кучу\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // Выполнить heapify для всех узлов, кроме листовых\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* Максимальная куча */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // Использовать список вместо массива, чтобы не учитывать проблему расширения\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* Конструктор, строящий кучу по входному списку */\n    init {\n        // Добавить элементы списка в кучу без изменений\n        maxHeap.addAll(nums!!)\n        // Выполнить heapify для всех узлов, кроме листовых\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* Получить индекс левого дочернего узла */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Получить индекс родительского узла */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // Округление вниз при делении\n    }\n\n    /* Поменять элементы местами */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* Получение размера кучи */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* Проверка, пуста ли куча */\n    fun isEmpty(): Boolean {\n        /* Проверка, пуста ли куча */\n        return size() == 0\n    }\n\n    /* Доступ к элементу на вершине кучи */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* Добавление элемента в кучу */\n    fun push(_val: Int) {\n        // Добавление узла\n        maxHeap.add(_val)\n        // Просеивание снизу вверх\n        siftUp(size() - 1)\n    }\n\n    /* Начиная с узла i, выполнить просеивание снизу вверх */\n    private fun siftUp(it: Int) {\n        // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n        var i = it\n        while (true) {\n            // Получение родительского узла для узла i\n            val p = parent(i)\n            // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // Поменять два узла местами\n            swap(i, p)\n            // Циклическое просеивание вверх\n            i = p\n        }\n    }\n\n    /* Извлечение элемента из кучи */\n    fun pop(): Int {\n        // Обработка пустого случая\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        swap(0, size() - 1)\n        // Удаление узла\n        val _val = maxHeap.removeAt(size() - 1)\n        // Просеивание сверху вниз\n        siftDown(0)\n        // Вернуть элемент с вершины кучи\n        return _val\n    }\n\n    /* Начиная с узла i, выполнить просеивание сверху вниз */\n    private fun siftDown(it: Int) {\n        // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n        var i = it\n        while (true) {\n            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n            if (ma == i) break\n            // Поменять два узла местами\n            swap(i, ma)\n            // Циклическое просеивание вниз\n            i = ma\n        }\n    }\n\n    /* Вывести кучу (двоичное дерево) */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Конструктор, строящий кучу по входному списку ###\ndef initialize(nums)\n  # Добавить элементы списка в кучу без изменений\n  @max_heap = nums\n  # Выполнить heapify для всех узлов, кроме листовых\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   Анализ сложности","text":"<p>Теперь попробуем оценить временную сложность второго способа построения кучи.</p> <ul> <li>Пусть число узлов полного двоичного дерева равно \\(n\\) , тогда число листовых узлов равно \\((n + 1) / 2\\) , где \\(/\\) означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно \\((n - 1) / 2\\) .</li> <li>В процессе упорядочивания сверху вниз каждый узел в худшем случае может просеяться до листа, поэтому максимальное число итераций равно высоте двоичного дерева \\(\\log n\\) .</li> </ul> <p>Перемножив эти два значения, можно получить временную сложность построения кучи \\(O(n \\log n)\\) . Но эта оценка неточна, потому что мы не учли свойство двоичного дерева: на нижних уровнях узлов гораздо больше, чем на верхних.</p> <p>Далее выполним более точный расчет. Чтобы упростить вычисления, предположим, что дано \"идеальное двоичное дерево\" высоты \\(h\\) с числом узлов \\(n\\) ; это предположение не повлияет на корректность результата.</p> <p></p> <p> Рисунок 8-5   Число узлов на каждом уровне идеального двоичного дерева </p> <p>Как показано на рисунке 8-5, максимальное число итераций упорядочивания сверху вниз для некоторого узла равно расстоянию от этого узла до листового узла, а это расстояние как раз и есть высота узла. Поэтому мы можем просуммировать для каждого уровня выражение \"число узлов \\(\\times\\) высота узла\" и получить суммарное число итераций упорядочивания для всех узлов.</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>Чтобы упростить это выражение, воспользуемся школьными знаниями о последовательностях и сначала умножим \\(T(h)\\) на \\(2\\) :</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>Используя метод вычитания со сдвигом, вычтем из нижней строки \\(2 T(h)\\) верхнюю строку \\(T(h)\\) , тогда получим:</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>Из этого выражения видно, что \\(T(h)\\) представляет собой геометрическую прогрессию, поэтому можно напрямую применить формулу суммы и получить временную сложность:</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>Далее, число узлов идеального двоичного дерева высоты \\(h\\) равно \\(n = 2^{h+1} - 1\\) , поэтому несложно получить сложность \\(O(2^h) = O(n)\\) . Из этого вывода следует, что построение кучи из входного списка имеет временную сложность \\(O(n)\\) , то есть выполняется очень эффективно.</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   Куча","text":"<p>Куча (heap) - это полное двоичное дерево, удовлетворяющее определенным условиям. Основных типов кучи два, как показано на рисунке 8-1.</p> <ul> <li>Минимальная куча (min heap): значение любого узла \\(\\leq\\) значения его дочерних узлов.</li> <li>Максимальная куча (max heap): значение любого узла \\(\\geq\\) значения его дочерних узлов.</li> </ul> <p></p> <p> Рисунок 8-1   Минимальная куча и максимальная куча </p> <p>Куча, являясь частным случаем полного двоичного дерева, обладает следующими свойствами.</p> <ul> <li>Узлы самого нижнего уровня заполняются слева, а все остальные уровни заполнены полностью.</li> <li>Корневой узел двоичного дерева мы называем вершиной кучи, а самый правый узел нижнего уровня - основанием кучи.</li> <li>Для максимальной (минимальной) кучи значение элемента на вершине, то есть у корневого узла, является максимальным (минимальным).</li> </ul>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   Распространенные операции с кучей","text":"<p>Нужно отметить, что многие языки программирования предоставляют не саму кучу, а очередь с приоритетом (priority queue) - абстрактную структуру данных, определяемую как очередь, в которой элементы извлекаются в соответствии с приоритетом.</p> <p>На практике куча обычно используется для реализации очереди с приоритетом, а максимальная куча эквивалентна очереди с приоритетом, в которой элементы извлекаются по убыванию. С точки зрения использования очередь с приоритетом и куча могут считаться эквивалентными структурами данных. Поэтому в этой книге мы не будем специально различать их и в дальнейшем будем единообразно называть кучей.</p> <p>Распространенные операции с кучей приведены в таблице 8-1. Конкретные имена методов зависят от языка программирования.</p> <p> Таблица 8-1   Эффективность операций с кучей </p> Имя метода Описание Временная сложность <code>push()</code> Поместить элемент в кучу \\(O(\\log n)\\) <code>pop()</code> Извлечь элемент с вершины кучи \\(O(\\log n)\\) <code>peek()</code> Получить доступ к вершине кучи (для max / min кучи это соответственно максимум / минимум) \\(O(1)\\) <code>size()</code> Получить число элементов в куче \\(O(1)\\) <code>isEmpty()</code> Проверить, пуста ли куча \\(O(1)\\) <p>В реальных приложениях мы можем напрямую использовать классы кучи, предоставляемые языком программирования, или классы очереди с приоритетом.</p> <p>Подобно сортировкам \"по возрастанию\" и \"по убыванию\", мы можем переключаться между \"минимальной кучей\" и \"максимальной кучей\", изменяя <code>flag</code> или модифицируя <code>Comparator</code> . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># Инициализация минимальной кучи\nmin_heap, flag = [], 1\n# Инициализация максимальной кучи\nmax_heap, flag = [], -1\n\n# Модуль heapq в Python по умолчанию реализует минимальную кучу\n# Если инвертировать знак элемента перед добавлением, то отношение порядка перевернется и так реализуется максимальная куча\n# В этом примере flag = 1 соответствует минимальной куче, а flag = -1 - максимальной\n\n# Добавление элементов в кучу\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# Получение элемента на вершине кучи\npeek: int = flag * max_heap[0] # 5\n\n# Извлечение элемента с вершины кучи\n# Извлеченные элементы образуют последовательность по убыванию\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# Получение размера кучи\nsize: int = len(max_heap)\n\n# Проверка, пуста ли куча\nis_empty: bool = not max_heap\n\n# Построение кучи из входного списка\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// Инициализация максимальной кучи\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* Добавление элементов в кучу */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.top(); // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* Получение размера кучи */\nint size = maxHeap.size();\n\n/* Проверка, пуста ли куча */\nbool isEmpty = maxHeap.empty();\n\n/* Построение кучи из входного списка */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// Инициализация максимальной кучи (достаточно изменить Comparator через lambda)\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* Добавление элементов в кучу */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.peek(); // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* Получение размера кучи */\nint size = maxHeap.size();\n\n/* Проверка, пуста ли куча */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* Построение кучи из входного списка */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// Инициализация максимальной кучи (достаточно изменить Comparer через lambda)\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* Добавление элементов в кучу */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.Peek();//5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* Получение размера кучи */\nint size = maxHeap.Count;\n\n/* Проверка, пуста ли куча */\nbool isEmpty = maxHeap.Count == 0;\n\n/* Построение кучи из входного списка */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// В Go можно построить целочисленную максимальную кучу, реализовав heap.Interface\n// Для реализации heap.Interface также нужно реализовать sort.Interface\ntype intHeap []any\n\n// Метод Push из heap.Interface, реализует добавление элемента в кучу\nfunc (h *intHeap) Push(x any) {\n    // Push и Pop используют pointer receiver\n    // Потому что они не только изменяют содержимое среза, но и его длину\n    *h = append(*h, x.(int))\n}\n\n// Метод Pop из heap.Interface, реализует извлечение элемента с вершины кучи\nfunc (h *intHeap) Pop() any {\n    // Извлекаемый элемент хранится в конце\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Метод Len из sort.Interface\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Метод Less из sort.Interface\nfunc (h *intHeap) Less(i, j int) bool {\n    // Для минимальной кучи здесь нужно заменить сравнение на &lt;\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Метод Swap из sort.Interface\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top получает элемент на вершине кучи\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* Инициализация кучи */\n    // Инициализация максимальной кучи\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* Добавление элементов в кучу */\n    // Вызываем методы heap.Interface для добавления элементов\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* Получение элемента на вершине кучи */\n    top := maxHeap.Top()\n    fmt.Printf(\"Элемент на вершине кучи: %d\\n\", top)\n\n    /* Извлечение элемента с вершины кучи */\n    // Вызываем методы heap.Interface для удаления элементов\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* Получение размера кучи */\n    size := len(*maxHeap)\n    fmt.Printf(\"Число элементов в куче: %d\\n\", size)\n\n    /* Проверка, пуста ли куча */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"Пуста ли куча: %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* Инициализация кучи */\n// Тип Heap в Swift поддерживает и max-heap, и min-heap, но требует swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* Добавление элементов в кучу */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* Получение элемента на вершине кучи */\nvar peek = heap.max()!\n\n/* Извлечение элемента с вершины кучи */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* Получение размера кучи */\nlet size = heap.count\n\n/* Проверка, пуста ли куча */\nlet isEmpty = heap.isEmpty\n\n/* Построение кучи из входного списка */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// В JavaScript нет встроенного класса Heap\n</code></pre> heap.ts<pre><code>// В TypeScript нет встроенного класса Heap\n</code></pre> heap.dart<pre><code>// В Dart нет встроенного класса Heap\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* Инициализация кучи */\n// Инициализация минимальной кучи\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// Инициализация максимальной кучи\nlet mut max_heap = BinaryHeap::new();\n\n/* Добавление элементов в кучу */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* Получение элемента на вершине кучи */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* Получение размера кучи */\nlet size = max_heap.len();\n\n/* Проверка, пуста ли куча */\nlet is_empty = max_heap.is_empty();\n\n/* Построение кучи из входного списка */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// В C нет встроенного класса Heap\n</code></pre> heap.kt<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// Инициализация максимальной кучи (достаточно изменить Comparator через lambda)\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* Добавление элементов в кучу */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* Получение элемента на вершине кучи */\nvar peek = maxHeap.peek() // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* Получение размера кучи */\nval size = maxHeap.size\n\n/* Проверка, пуста ли куча */\nval isEmpty = maxHeap.isEmpty()\n\n/* Построение кучи из входного списка */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># В Ruby нет встроенного класса Heap\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20min-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20min_heap%2C%20flag%20%3D%20%5B%5D%2C%201%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20max-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20max_heap%2C%20flag%20%3D%20%5B%5D%2C%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9C%D0%BE%D0%B4%D1%83%D0%BB%D1%8C%20heapq%20%D0%B2%20Python%20%D0%BF%D0%BE%20%D1%83%D0%BC%D0%BE%D0%BB%D1%87%D0%B0%D0%BD%D0%B8%D1%8E%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D1%83%D0%B5%D1%82%20min-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%20%D0%BF%D0%BE%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%20%D0%B1%D1%80%D0%B0%D1%82%D1%8C%20%D0%BE%D1%82%D1%80%D0%B8%D1%86%D0%B0%D0%BD%D0%B8%D0%B5%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%2C%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D1%82%D0%BD%D0%BE%D1%88%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B0%20%D0%B8%20%D1%82%D0%B5%D0%BC%20%D1%81%D0%B0%D0%BC%D1%8B%D0%BC%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20max-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%23%20%D0%92%20%D1%8D%D1%82%D0%BE%D0%BC%20%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%B5%20flag%20%3D%201%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20min-%D0%BA%D1%83%D1%87%D0%B5%2C%20%D0%B0%20flag%20%3D%20-1%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20max-%D0%BA%D1%83%D1%87%D0%B5%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%201%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%203%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%202%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%205%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20peek%20%3D%20flag%20%2A%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%D0%B7%20%D0%BA%D1%83%D1%87%D0%B8%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D1%83%D1%8E%D1%82%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%D0%BE%D1%82%20%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B3%D0%BE%20%D0%BA%20%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BC%D1%83%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BA%D1%83%D1%87%D0%B0%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%92%D1%85%D0%BE%D0%B4%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D0%B8%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20min_heap%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   Реализация кучи","text":"<p>Ниже реализуется максимальная куча. Чтобы преобразовать ее в минимальную кучу, достаточно инвертировать всю логику сравнений по величине, например заменить \\(\\geq\\) на \\(\\leq\\) . Заинтересованные читатели могут попробовать реализовать это самостоятельно.</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   Хранение и представление кучи","text":"<p>В разделе \"Двоичные деревья\" мы уже говорили, что полное двоичное дерево очень удобно представлять массивом. Поскольку куча как раз и является полным двоичным деревом, для хранения кучи мы также будем использовать массив.</p> <p>Когда двоичное дерево представляется массивом, элементы массива соответствуют значениям узлов, а индексы - положениям этих узлов в двоичном дереве. Указатели на узлы реализуются через формулы отображения индексов.</p> <p>Как показано на рисунке 8-2, для заданного индекса \\(i\\) индекс левого дочернего узла равен \\(2i + 1\\) , правого дочернего узла - \\(2i + 2\\) , а родительского узла - \\((i - 1) / 2\\) с округлением вниз. Если индекс выходит за допустимые границы, это означает пустой узел или отсутствие узла.</p> <p></p> <p> Рисунок 8-2   Представление и хранение кучи </p> <p>Мы можем инкапсулировать формулы отображения индексов в функции, чтобы потом было удобнее ими пользоваться:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"Получить индекс левого дочернего узла\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"Получить индекс правого дочернего узла\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"Получить индекс родительского узла\"\"\"\n    return (i - 1) // 2  # Округление вниз при делении\n</code></pre> my_heap.cpp<pre><code>/* Получить индекс левого дочернего узла */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.java<pre><code>/* Получить индекс левого дочернего узла */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.cs<pre><code>/* Получить индекс левого дочернего узла */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint Parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.go<pre><code>/* Получить индекс левого дочернего узла */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* Получить индекс родительского узла */\nfunc (h *maxHeap) parent(i int) int {\n    // Округление вниз при делении\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* Получить индекс левого дочернего узла */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.js<pre><code>/* Получить индекс левого дочернего узла */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // Округление вниз при делении\n}\n</code></pre> my_heap.ts<pre><code>/* Получить индекс левого дочернего узла */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // Округление вниз при делении\n}\n</code></pre> my_heap.dart<pre><code>/* Получить индекс левого дочернего узла */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // Округление вниз при делении\n}\n</code></pre> my_heap.rs<pre><code>/* Получить индекс левого дочернего узла */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.c<pre><code>/* Получить индекс левого дочернего узла */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // Округление вниз\n}\n</code></pre> my_heap.kt<pre><code>/* Получить индекс левого дочернего узла */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.rb<pre><code>### Получить индекс левого дочернего узла ###\ndef left(i)\n  2 * i + 1\nend\n\n### Получить индекс правого дочернего узла ###\ndef right(i)\n  2 * i + 2\nend\n\n### Получить индекс родительского узла ###\ndef parent(i)\n  (i - 1) / 2     # Округление вниз при делении\nend\n</code></pre>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   Доступ к элементу на вершине кучи","text":"<p>Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"Доступ к элементу на вершине кучи\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* Доступ к элементу на вершине кучи */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* Доступ к элементу на вершине кучи */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* Доступ к элементу на вершине кучи */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* Доступ к элементу на вершине кучи */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* Доступ к элементу на вершине кучи */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* Доступ к элементу на вершине кучи */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* Доступ к элементу на вершине кучи */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* Доступ к элементу на вершине кучи */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### Доступ к элементу на вершине кучи ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   Добавление элемента в кучу","text":"<p>Пусть дан элемент <code>val</code> . Сначала мы помещаем его в основание кучи. После добавления свойства кучи могут нарушиться, потому что <code>val</code> может оказаться больше, чем другие элементы в куче. Поэтому необходимо восстановить порядок на пути от вставленного узла к корню ; эта операция называется упорядочиванием кучи.</p> <p>Рассмотрим ситуацию, когда упорядочивание выполняется снизу вверх, начиная от только что вставленного узла. Как показано на рисунках ниже, мы сравниваем значение вставленного узла со значением его родителя; если вставленный узел больше, то меняем их местами. Затем продолжаем выполнять ту же операцию и последовательно восстанавливать корректность всех узлов по пути снизу вверх, пока не выйдем за корень или не встретим узел, для которого обмен не требуется.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-3   Шаги добавления элемента в кучу </p> <p>Пусть общее число узлов равно \\(n\\) , тогда высота дерева равна \\(O(\\log n)\\) . Следовательно, максимальное число итераций операции упорядочивания кучи тоже не превышает \\(O(\\log n)\\) . Отсюда временная сложность добавления элемента в кучу равна \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"Добавление элемента в кучу\"\"\"\n    # Добавление узла\n    self.max_heap.append(val)\n    # Просеивание снизу вверх\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"Начиная с узла i, выполнить просеивание снизу вверх\"\"\"\n    while True:\n        # Получение родительского узла для узла i\n        p = self.parent(i)\n        # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # Поменять два узла местами\n        self.swap(i, p)\n        # Циклическое просеивание вверх\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n    // Добавление узла\n    maxHeap.push_back(val);\n    // Просеивание снизу вверх\n    siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Поменять два узла местами\n        swap(maxHeap[i], maxHeap[p]);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n    // Добавление узла\n    maxHeap.add(val);\n    // Просеивание снизу вверх\n    siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // Поменять два узла местами\n        swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Добавление элемента в кучу */\nvoid Push(int val) {\n    // Добавление узла\n    maxHeap.Add(val);\n    // Просеивание снизу вверх\n    SiftUp(Size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid SiftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = Parent(i);\n        // Если «выход за пределы корневого узла» или «узел не требует исправления», завершить просеивание\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Поменять два узла местами\n        Swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Добавление элемента в кучу */\nfunc (h *maxHeap) push(val any) {\n    // Добавление узла\n    h.data = append(h.data, val)\n    // Просеивание снизу вверх\n    h.siftUp(len(h.data) - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // Получение родительского узла для узла i\n        p := h.parent(i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // Поменять два узла местами\n        h.swap(i, p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Добавление элемента в кучу */\nfunc push(val: Int) {\n    // Добавление узла\n    maxHeap.append(val)\n    // Просеивание снизу вверх\n    siftUp(i: size() - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // Получение родительского узла для узла i\n        let p = parent(i: i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // Поменять два узла местами\n        swap(i: i, j: p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Добавление элемента в кучу */\npush(val) {\n    // Добавление узла\n    this.#maxHeap.push(val);\n    // Просеивание снизу вверх\n    this.#siftUp(this.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\n#siftUp(i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        const p = this.#parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // Поменять два узла местами\n        this.#swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Добавление элемента в кучу */\npush(val: number): void {\n    // Добавление узла\n    this.maxHeap.push(val);\n    // Просеивание снизу вверх\n    this.siftUp(this.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nsiftUp(i: number): void {\n    while (true) {\n        // Получение родительского узла для узла i\n        const p = this.parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // Поменять два узла местами\n        this.swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n  // Добавление узла\n  _maxHeap.add(val);\n  // Просеивание снизу вверх\n  siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n  while (true) {\n    // Получение родительского узла для узла i\n    int p = _parent(i);\n    // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // Поменять два узла местами\n    _swap(i, p);\n    // Циклическое просеивание вверх\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Добавление элемента в кучу */\nfn push(&amp;mut self, val: i32) {\n    // Добавление узла\n    self.max_heap.push(val);\n    // Просеивание снизу вверх\n    self.sift_up(self.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // Если узел i уже является вершиной кучи, завершить просеивание\n        if i == 0 {\n            break;\n        }\n        // Получение родительского узла для узла i\n        let p = Self::parent(i);\n        // Когда «узел не требует исправления», завершить просеивание\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // Поменять два узла местами\n        self.swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Добавление элемента в кучу */\nvoid push(MaxHeap *maxHeap, int val) {\n    // По умолчанию не следует добавлять так много узлов\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // Добавление узла\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // Просеивание снизу вверх\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(maxHeap, i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(maxHeap, i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Добавление элемента в кучу */\nfun push(_val: Int) {\n    // Добавление узла\n    maxHeap.add(_val)\n    // Просеивание снизу вверх\n    siftUp(size() - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfun siftUp(it: Int) {\n    // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n    var i = it\n    while (true) {\n        // Получение родительского узла для узла i\n        val p = parent(i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // Поменять два узла местами\n        swap(i, p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Добавление элемента в кучу ###\ndef push(val)\n  # Добавление узла\n  @max_heap &lt;&lt; val\n  # Просеивание снизу вверх\n  sift_up(size - 1)\nend\n\n### Начиная с узла i, выполнить просеивание снизу вверх ###\ndef sift_up(i)\n  loop do\n    # Получение родительского узла для узла i\n    p = parent(i)\n    # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # Поменять два узла местами\n    swap(i, p)\n    # Циклическое просеивание вверх\n    i = p\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   Извлечение элемента с вершины кучи","text":"<p>Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка. Если просто удалить первый элемент списка, то индексы всех узлов двоичного дерева изменятся, и это сильно затруднит последующее восстановление структуры при помощи упорядочивания кучи. Чтобы по возможности минимизировать изменение индексов элементов, мы используем следующий порядок действий.</p> <ol> <li>Поменять местами элемент на вершине кучи и элемент у основания кучи, то есть поменять корневой узел с самым правым листовым узлом.</li> <li>После обмена удалить основание кучи из списка. Стоит отметить, что, поскольку обмен уже выполнен, фактически удаляется исходный элемент вершины кучи.</li> <li>Начиная от корневого узла, выполнить упорядочивание кучи сверху вниз.</li> </ol> <p>Как показано на рисунках ниже, направление операции упорядочивания кучи сверху вниз противоположно операции упорядочивания кучи снизу вверх. Мы сравниваем значение корневого узла со значениями двух дочерних узлов, выбираем больший дочерний узел и меняем его местами с корневым узлом. Затем циклически повторяем ту же операцию, пока не выйдем за листовой узел или не встретим узел, который уже не требует обмена.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-4   Шаги извлечения элемента с вершины кучи </p> <p>Как и операция добавления в кучу, операция извлечения элемента с вершины кучи также имеет временную сложность \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"Извлечение элемента из кучи\"\"\"\n    # Обработка пустого случая\n    if self.is_empty():\n        raise IndexError(\"куча пуста\")\n    # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    self.swap(0, self.size() - 1)\n    # Удаление узла\n    val = self.max_heap.pop()\n    # Просеивание сверху вниз\n    self.sift_down(0)\n    # Вернуть элемент с вершины кучи\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"Начиная с узла i, выполнить просеивание сверху вниз\"\"\"\n    while True:\n        # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i:\n            break\n        # Поменять два узла местами\n        self.swap(i, ma)\n        # Циклическое просеивание вниз\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* Извлечение элемента из кучи */\nvoid pop() {\n    // Обработка пустого случая\n    if (isEmpty()) {\n        throw out_of_range(\"куча пуста\");\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // Удаление узла\n    maxHeap.pop_back();\n    // Просеивание сверху вниз\n    siftDown(0);\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Извлечение элемента из кучи */\nint pop() {\n    // Обработка пустого случая\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(0, size() - 1);\n    // Удаление узла\n    int val = maxHeap.remove(size() - 1);\n    // Просеивание сверху вниз\n    siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Извлечение элемента из кучи */\nint Pop() {\n    // Обработка пустого случая\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    Swap(0, Size() - 1);\n    // Удаление узла\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // Просеивание сверху вниз\n    SiftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid SiftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Если «узел i максимален» или «выход за пределы листовых узлов», завершить просеивание\n        if (ma == i) break;\n        // Поменять два узла местами\n        Swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Извлечение элемента из кучи */\nfunc (h *maxHeap) pop() any {\n    // Обработка пустого случая\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    h.swap(0, h.size()-1)\n    // Удаление узла\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // Просеивание сверху вниз\n    h.siftDown(0)\n\n    // Вернуть элемент с вершины кучи\n    return val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if max == i {\n            break\n        }\n        // Поменять два узла местами\n        h.swap(i, max)\n        // Циклическое просеивание вниз\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Извлечение элемента из кучи */\nfunc pop() -&gt; Int {\n    // Обработка пустого случая\n    if isEmpty() {\n        fatalError(\"куча пуста\")\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(i: 0, j: size() - 1)\n    // Удаление узла\n    let val = maxHeap.remove(at: size() - 1)\n    // Просеивание сверху вниз\n    siftDown(i: 0)\n    // Вернуть элемент с вершины кучи\n    return val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        swap(i: i, j: ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Извлечение элемента из кучи */\npop() {\n    // Обработка пустого случая\n    if (this.isEmpty()) throw new Error('куча пуста');\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    this.#swap(0, this.size() - 1);\n    // Удаление узла\n    const val = this.#maxHeap.pop();\n    // Просеивание сверху вниз\n    this.#siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\n#siftDown(i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) break;\n        // Поменять два узла местами\n        this.#swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Извлечение элемента из кучи */\npop(): number {\n    // Обработка пустого случая\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    this.swap(0, this.size() - 1);\n    // Удаление узла\n    const val = this.maxHeap.pop();\n    // Просеивание сверху вниз\n    this.siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nsiftDown(i: number): void {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) break;\n        // Поменять два узла местами\n        this.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Извлечение элемента из кучи */\nint pop() {\n  // Обработка пустого случая\n  if (isEmpty()) throw Exception('куча пуста');\n  // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n  _swap(0, size() - 1);\n  // Удаление узла\n  int val = _maxHeap.removeLast();\n  // Просеивание сверху вниз\n  siftDown(0);\n  // Вернуть элемент с вершины кучи\n  return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n  while (true) {\n    // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    if (ma == i) break;\n    // Поменять два узла местами\n    _swap(i, ma);\n    // Циклическое просеивание вниз\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Извлечение элемента из кучи */\nfn pop(&amp;mut self) -&gt; i32 {\n    // Обработка пустого случая\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    self.swap(0, self.size() - 1);\n    // Удаление узла\n    let val = self.max_heap.pop().unwrap();\n    // Просеивание сверху вниз\n    self.sift_down(0);\n    // Вернуть элемент с вершины кучи\n    val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break;\n        }\n        // Поменять два узла местами\n        self.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Извлечение элемента из кучи */\nint pop(MaxHeap *maxHeap) {\n    // Обработка пустого случая\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // Удаление узла\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // Просеивание сверху вниз\n    siftDown(maxHeap, 0);\n\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (max == i) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(maxHeap, i, max);\n        // Циклическое просеивание вниз\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Извлечение элемента из кучи */\nfun pop(): Int {\n    // Обработка пустого случая\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(0, size() - 1)\n    // Удаление узла\n    val _val = maxHeap.removeAt(size() - 1)\n    // Просеивание сверху вниз\n    siftDown(0)\n    // Вернуть элемент с вершины кучи\n    return _val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfun siftDown(it: Int) {\n    // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n    var i = it\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) break\n        // Поменять два узла местами\n        swap(i, ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Извлечение элемента из кучи ###\ndef pop\n  # Обработка пустого случая\n  raise IndexError, \"куча пуста\" if is_empty?\n  # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n  swap(0, size - 1)\n  # Удаление узла\n  val = @max_heap.pop\n  # Просеивание сверху вниз\n  sift_down(0)\n  # Вернуть элемент с вершины кучи\n  val\nend\n\n### Начиная с узла i, выполнить просеивание сверху вниз ###\ndef sift_down(i)\n  loop do\n    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    break if ma == i\n\n    # Поменять два узла местами\n    swap(i, ma)\n    # Циклическое просеивание вниз\n    i = ma\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   Типичные применения кучи","text":"<ul> <li>Очередь с приоритетом: куча обычно является предпочтительной структурой данных для реализации очереди с приоритетом; добавление и извлечение элементов имеют временную сложность \\(O(\\log n)\\) , а построение кучи - \\(O(n)\\) , и все эти операции выполняются очень эффективно.</li> <li>Пирамидальная сортировка: для заданного набора данных можно построить кучу, а затем непрерывно извлекать из нее элементы, получая отсортированные данные. Однако на практике мы обычно используем более изящную реализацию пирамидальной сортировки; подробности см. в разделе \"Пирамидальная сортировка\".</li> <li>Получение наибольших \\(k\\) элементов: это классическая алгоритмическая задача и одновременно типичное применение кучи. Например, выбор 10 самых горячих новостей для списка популярных тем или выбор 10 самых продаваемых товаров.</li> </ul>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   Резюме","text":"","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Куча представляет собой полное двоичное дерево и делится на максимальную кучу и минимальную кучу. Элемент на вершине максимальной (минимальной) кучи является наибольшим (наименьшим).</li> <li>Очередь с приоритетом определяется как очередь, элементы которой извлекаются в соответствии с приоритетом; обычно ее реализуют с помощью кучи.</li> <li>К основным операциям кучи и их временным сложностям относятся: добавление элемента в кучу \\(O(\\log n)\\) , извлечение элемента с вершины кучи \\(O(\\log n)\\) и доступ к вершине кучи \\(O(1)\\) .</li> <li>Полное двоичное дерево очень удобно представлять массивом, поэтому кучу обычно тоже хранят в массиве.</li> <li>Операция упорядочивания кучи используется для поддержания свойств кучи и применяется как при добавлении элемента, так и при извлечении элемента.</li> <li>Временную сложность построения кучи из \\(n\\) элементов можно оптимизировать до \\(O(n)\\) , что очень эффективно.</li> <li>Top-k - это классическая алгоритмическая задача, которую можно эффективно решать с помощью кучи за \\(O(n \\log k)\\) .</li> </ul>","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Является ли \"куча\" как структура данных тем же самым понятием, что и \"куча\" в управлении памятью?</p> <p>Это не одно и то же, просто у них случайно совпало название. Куча в памяти компьютерной системы является частью динамического распределения памяти: во время выполнения программы она используется для хранения данных. Программа может запросить определенный объем памяти в куче для хранения сложных структур, таких как объекты и массивы. Когда эти данные больше не нужны, память нужно освободить, чтобы не допустить утечек. По сравнению со стековой памятью управление памятью в куче требует большей осторожности, а неправильное использование может привести к утечкам памяти и проблемам с указателями.</p>","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Задача Top-k","text":"<p>Question</p> <p>Дан неупорядоченный массив <code>nums</code> длины \\(n\\) . Требуется вернуть наибольшие \\(k\\) элементов массива.</p> <p>Для этой задачи мы сначала покажем два относительно прямолинейных способа решения, а затем более эффективный способ на основе кучи.</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#831-1","level":2,"title":"8.3.1   Метод 1: выбор через обход","text":"<p>Как показано на рисунке 8-6, можно выполнить \\(k\\) проходов по массиву и на каждом проходе извлекать соответственно \\(1\\)-й, \\(2\\)-й, \\(\\dots\\) , \\(k\\)-й по величине элемент; временная сложность такого подхода равна \\(O(nk)\\) .</p> <p>Этот метод подходит только для случая \\(k \\ll n\\) , потому что когда \\(k\\) приближается к \\(n\\) , его временная сложность стремится к \\(O(n^2)\\) , а это уже очень затратно.</p> <p></p> <p> Рисунок 8-6   Поиск наибольших k элементов через обход </p> <p>Tip</p> <p>Когда \\(k = n\\) , мы получаем полную упорядоченную последовательность, и в этот момент задача становится эквивалентной алгоритму \"сортировка выбором\".</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#832-2","level":2,"title":"8.3.2   Метод 2: сортировка","text":"<p>Как показано на рисунке 8-7, можно сначала отсортировать массив <code>nums</code> , а затем вернуть его крайние правые \\(k\\) элементов; временная сложность такого метода равна \\(O(n \\log n)\\) .</p> <p>Очевидно, что этот способ делает слишком много, потому что нам нужно только найти наибольшие \\(k\\) элементов, а сортировать остальные элементы совсем не обязательно.</p> <p></p> <p> Рисунок 8-7   Поиск наибольших k элементов через сортировку </p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#833-3","level":2,"title":"8.3.3   Метод 3: куча","text":"<p>Задачу Top-k можно решить гораздо эффективнее с помощью кучи, как показано на рисунках ниже.</p> <ol> <li>Инициализировать минимальную кучу, у которой вершина содержит наименьший элемент.</li> <li>Сначала по очереди поместить в кучу первые \\(k\\) элементов массива.</li> <li>Начиная с элемента номер \\(k + 1\\) , если текущий элемент больше элемента на вершине кучи, то извлечь вершину кучи и поместить в кучу текущий элемент.</li> <li>После завершения обхода в куче будут храниться как раз наибольшие \\(k\\) элементов.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-8   Поиск наибольших k элементов с помощью кучи </p> <p>Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"Найти k наибольших элементов массива с помощью кучи\"\"\"\n    # Инициализация минимальной кучи\n    heap = []\n    # Поместить первые k элементов массива в кучу\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i in range(k, len(nums)):\n        # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // Инициализация минимальной кучи\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // Инициализация минимальной кучи\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // Инициализация минимальной кучи\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // Инициализация минимальной кучи\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // Поместить первые k элементов массива в кучу\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i := k; i &lt; len(nums); i++ {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // Инициализировать минимальную кучу и построить ее по первым k элементам\n    var heap = Heap(nums.prefix(k))\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i in nums.indices.dropFirst(k) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* Добавление элемента в кучу */\nfunction pushMinHeap(maxHeap, val) {\n    // Инвертировать знак элемента\n    maxHeap.push(-val);\n}\n\n/* Извлечение элемента из кучи */\nfunction popMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return -maxHeap.pop();\n}\n\n/* Доступ к элементу на вершине кучи */\nfunction peekMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return -maxHeap.peek();\n}\n\n/* Извлечь элементы из кучи */\nfunction getMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* Найти k наибольших элементов массива с помощью кучи */\nfunction topKHeap(nums, k) {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    const maxHeap = new MaxHeap([]);\n    // Поместить первые k элементов массива в кучу\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (let i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Вернуть элементы кучи\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* Добавление элемента в кучу */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // Инвертировать знак элемента\n    maxHeap.push(-val);\n}\n\n/* Извлечение элемента из кучи */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // Инвертировать знак элемента\n    return -maxHeap.pop();\n}\n\n/* Доступ к элементу на вершине кучи */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // Инвертировать знак элемента\n    return -maxHeap.peek();\n}\n\n/* Извлечь элементы из кучи */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // Инвертировать знак элемента\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* Найти k наибольших элементов массива с помощью кучи */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    const maxHeap = new MaxHeap([]);\n    // Поместить первые k элементов массива в кучу\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (let i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Вернуть элементы кучи\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // Инициализировать минимальную кучу, поместив в нее первые k элементов массива\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // Начиная с элемента k+1, поддерживать длину кучи равной k\n  for (int i = k; i &lt; nums.length; i++) {\n    // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap — это максимальная куча; с помощью Reverse элементы инвертируются, чтобы реализовать минимальную кучу\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // Поместить первые k элементов массива в кучу\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for &amp;num in nums.iter().skip(k) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* Добавление элемента в кучу */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // Инвертировать знак элемента\n    push(maxHeap, -val);\n}\n\n/* Извлечение элемента из кучи */\nint popMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать знак элемента\n    return -pop(maxHeap);\n}\n\n/* Доступ к элементу на вершине кучи */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать знак элемента\n    return -peek(maxHeap);\n}\n\n/* Извлечь элементы из кучи */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать все элементы кучи и записать их в массив res\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* Извлечь элементы из кучи */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать все элементы кучи и записать их в массив res\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// Функция поиска k наибольших элементов массива на основе кучи\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // Освободить память\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // Инициализация минимальной кучи\n    val heap = PriorityQueue&lt;Int&gt;()\n    // Поместить первые k элементов массива в кучу\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (i in k..&lt;nums.size) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### Поиск k наибольших элементов массива с помощью кучи ###\ndef top_k_heap(nums, k)\n  # Инициализация минимальной кучи\n  # Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n  max_heap = MaxHeap.new([])\n\n  # Поместить первые k элементов массива в кучу\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # Начиная с элемента k+1, поддерживать длину кучи равной k\n  for i in k...nums.length\n    # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Всего выполняется \\(n\\) операций добавления и извлечения из кучи, а максимальная длина кучи равна \\(k\\) , поэтому временная сложность равна \\(O(n \\log k)\\) . Этот метод очень эффективен: когда \\(k\\) мало, временная сложность стремится к \\(O(n)\\) ; когда \\(k\\) велико, она все равно не превышает \\(O(n \\log n)\\) .</p> <p>Кроме того, этот метод подходит и для сценариев с динамическим потоком данных. При непрерывном поступлении новых данных мы можем продолжать поддерживать содержимое кучи, тем самым динамически обновляя наибольшие \\(k\\) элементов.</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"Перед началом","text":"<p>Несколько лет назад я публиковал на LeetCode разборы серии задач \"Sword for Offer\" и получил поддержку и ободрение от многих читателей. Во время общения с ними мне чаще всего задавали один и тот же вопрос: \"как начать изучать алгоритмы?\" Постепенно этот вопрос начал меня по-настоящему занимать.</p> <p>Слепо бросаться в решение задач кажется самым популярным способом: он прост, прямолинеен и действительно работает. Но решение задач похоже на игру в \"Сапера\": люди с сильными навыками самообучения способны обезвредить мины одну за другой, а тем, у кого не хватает базы, легко набить себе шишки и шаг за шагом отступить под давлением неудач. Полностью проходить учебники тоже принято часто, но для тех, кто готовится к поиску работы, диплом, резюме, письменные тесты и собеседования уже отнимают большую часть сил, и потому толстые книги нередко превращаются в тяжелое испытание.</p> <p>Если ты тоже сталкиваешься с такими трудностями, то можно сказать, что эта книга сама \"нашла\" тебя. Она стала моим ответом на этот вопрос: пусть и не идеальным, но как минимум честной и активной попыткой. Эта книга сама по себе не гарантирует предложения о работе, но поможет тебе увидеть \"карту знаний\" по структурам данных и алгоритмам, понять форму, размер и расположение разных \"мин\" и освоить разные \"способы разминирования\". Освоив это, ты сможешь увереннее решать задачи и читать технические материалы, шаг за шагом выстраивая целостную систему знаний.</p> <p>Я глубоко согласен со словами профессора Фейнмана: \"Knowledge isn't free. You have to pay attention.\" В этом смысле книга не совсем \"бесплатна\". Чтобы не подвести то драгоценное \"внимание\", которое ты ей уделишь, я постараюсь вложить в ее создание максимум собственного \"внимания\".</p> <p>Я хорошо понимаю пределы собственных знаний. Хотя материал этой книги уже довольно долго шлифовался, в нем наверняка все еще осталось немало ошибок, поэтому я искренне прошу преподавателей и читателей указывать на неточности и недоработки.</p> <p></p> Hello, алгоритмы! <p>Появление компьютеров радикально изменило мир. Благодаря высокой скорости вычислений и отличной программируемости они стали идеальной средой для исполнения алгоритмов и обработки данных. Реалистичная графика в играх, интеллектуальные решения в автономном вождении, впечатляющие партии AlphaGo и естественное взаимодействие ChatGPT: все это изящные проявления алгоритмов на компьютере.</p> <p>На самом деле еще до появления компьютеров алгоритмы и структуры данных уже существовали во всех уголках мира. Ранние алгоритмы были сравнительно простыми: например, древние способы счета или последовательности действий при изготовлении инструментов. По мере развития цивилизации алгоритмы становились тоньше и сложнее. За мастерством ремесленников, промышленными продуктами, освобождающими производительные силы, и даже за научными законами движения Вселенной почти всегда стоит изобретательная алгоритмическая мысль.</p> <p>Точно так же структуры данных встречаются повсюду: от социальных сетей до схем метро многие системы можно моделировать как \"граф\"; от государства до семьи основные формы общественной организации обладают свойствами \"дерева\"; зимняя одежда похожа на \"стек\", где то, что надевают первым, снимают последним; тубус для бадминтонных воланов похож на \"очередь\", где элементы добавляются с одного конца и извлекаются с другого; словарь похож на \"хеш-таблицу\", позволяющую быстро находить нужную статью.</p> <p>Эта книга стремится с помощью понятных анимированных иллюстраций и исполняемых примеров кода помочь читателю понять ключевые идеи алгоритмов и структур данных и научиться реализовывать их программно. На этой основе книга также пытается показать живые проявления алгоритмов в сложном мире и раскрыть их красоту. Надеюсь, она окажется для тебя полезной.</p>","path":["Перед началом"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"Глава 1.   Введение в алгоритмы","text":"<p>Abstract</p> <p>Юная девушка кружится в танце, переплетаясь с данными, а по подолу ее платья струится мелодия алгоритмов.</p> <p>Она приглашает вас присоединиться к танцу: следуйте за ее шагами и войдите в мир алгоритмов, полный логики и красоты.</p>","path":["Глава 1. Знакомство с алгоритмами","Глава 1. &nbsp; Введение в алгоритмы"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>1.1   Алгоритмы повсюду</li> <li>1.2   Что такое структуры данных и алгоритмы</li> <li>1.3   Резюме</li> </ul>","path":["Глава 1. Знакомство с алгоритмами","Глава 1. &nbsp; Введение в алгоритмы"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   Алгоритмы повсюду","text":"<p>Говоря об алгоритмах, естественно вспомнить о математике. Однако на самом деле многие алгоритмы не связаны со сложной математикой, а больше полагаются на базовую логику, которая повсеместно встречается в нашей повседневной жизни.</p> <p>Прежде чем углубиться в обсуждение алгоритмов, стоит упомянуть интересный факт: вы уже точно освоили множество алгоритмов и привыкли применять их в повседневной жизни. Далее приведем несколько конкретных примеров, чтобы подтвердить этот факт.</p> <p>Пример 1: поиск в словаре. В словаре все слова упорядочены по алфавиту. Предположим, нам нужно найти слово, начинающееся на букву \\(r\\); обычно для этого нужно выполнить следующие действия.</p> <ol> <li>Откройте словарь примерно на половине страниц и посмотрите, какая буква является первой на этой странице; предположим, это буква \\(m\\).</li> <li>Поскольку в алфавите буква \\(r\\) идет после \\(m\\), исключаем первую половину словаря, и область поиска сужается до второй половины.</li> <li>Продолжайте повторять шаги <code>1.</code> и <code>2.</code> , пока не найдете страницу, где первой буквой слов будет \\(r\\).</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 1-1   Этапы поиска в словаре. Шаг 1 </p> <p>Навык поиска в словаре, которым владеет каждый школьник, на самом деле является известным алгоритмом двоичного поиска. С точки зрения структуры данных словарь можно рассматривать как отсортированный массив; с точки зрения алгоритма последовательность операций по поиску в словаре можно считать двоичным поиском.</p> <p>Пример 2: упорядочивание карт. Во время игры в карты необходимо каждый раз упорядочивать карты в руке от меньшего к большему. Для этого нужно выполнить следующие действия.</p> <ol> <li>Разделите карты на упорядоченную и неупорядоченную части, предполагая, что изначально самая левая карта уже упорядочена.</li> <li>Из неупорядоченной части извлеките одну карту и вставьте ее в правильное место в упорядоченной части; после этого две самые левые карты станут упорядоченными.</li> <li>Повторяйте шаг <code>2.</code> , каждый раз перемещая одну карту из неупорядоченной части в упорядоченную, пока все карты не станут упорядоченными.</li> </ol> <p></p> <p> Рисунок 1-2   Этапы упорядочивания карт </p> <p>Метод упорядочивания карт по своей сути является алгоритмом сортировки вставками, который весьма эффективен при обработке небольших наборов данных. Многие функции сортировки в библиотеках программирования используют именно этот алгоритм.</p> <p>Пример 3: сдача. Предположим, что в супермаркете мы купили товар стоимостью \\(69\\) руб. и дали кассиру купюру в \\(100\\) руб. Кассир должен вернуть нам \\(31\\) руб. Для этого ему нужно выполнить следующие действия.</p> <ol> <li>Варианты выбора - это купюры номиналом меньше \\(31\\) руб. Пусть у нас имеются номиналы \\(1\\) , \\(5\\) , \\(10\\) и \\(20\\) руб.</li> <li>Возьмем самую крупную доступную купюру в \\(20\\) руб. Остаток сдачи составит \\(31 - 20 = 11\\) руб.</li> <li>Возьмем самую крупную из оставшихся купюр в \\(10\\) руб. Остаток составит \\(11 - 10 = 1\\) руб.</li> <li>Возьмем самую крупную из оставшихся купюр в \\(1\\) руб. Остаток составит \\(1 - 1 = 0\\) руб.</li> <li>Завершим выдачу сдачи, схема: \\(20 + 10 + 1 = 31\\) руб.</li> </ol> <p></p> <p> Рисунок 1-3   Этапы выдачи сдачи </p> <p>В этих шагах мы на каждом этапе выбираем наилучший вариант, используя купюры наибольшего номинала, и в итоге получаем рабочую схему сдачи. С точки зрения структуры данных и алгоритмов этот метод по своей сути является жадным алгоритмом.</p> <p>От приготовления блюда до межзвездных путешествий решение практически любой задачи неразрывно связано с алгоритмами. Появление компьютеров позволило нам с помощью программирования хранить структуры данных в памяти, а также писать код для вызовов к CPU и GPU для выполнения алгоритмов. Таким образом, мы можем переносить задачи из реальной жизни в компьютер и решать различные сложные проблемы более эффективно.</p> <p>Tip</p> <p>Если представление о структурах данных, алгоритмах, массивах и двоичном поиске пока остается расплывчатым, просто продолжайте читать. Эта книга постепенно введет вас в мир структур данных и алгоритмов.</p>","path":["Глава 1. Знакомство с алгоритмами","1.1 &nbsp; Алгоритмы повсюду"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   Резюме","text":"","path":["Глава 1. Знакомство с алгоритмами","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Алгоритмы повсеместно присутствуют в нашей повседневной жизни и не являются недосягаемыми сложными знаниями. На самом деле мы уже освоили множество алгоритмов, которые помогают решать различные жизненные задачи.</li> <li>Принцип поиска в словаре соответствует алгоритму двоичного поиска. Двоичный поиск иллюстрирует важную идею алгоритмов \"разделяй и властвуй\".</li> <li>Процесс сортировки карт в колоде очень похож на алгоритм сортировки вставками, который хорошо подходит для сортировки небольших наборов данных.</li> <li>Процесс размена по своей сути является жадным алгоритмом, в котором на каждом этапе принимается наилучшее на данный момент решение.</li> <li>Алгоритм представляет собой набор инструкций или шагов, предназначенных для решения конкретной задачи в ограниченное время, а структура данных - это способ организации и хранения данных в компьютере.</li> <li>Структуры данных и алгоритмы тесно связаны. Структуры данных являются основой для алгоритмов, а алгоритмы оживляют структуры данных.</li> <li>Структуры данных и алгоритмы можно сравнить с конструктором: детали конструктора представляют данные, их форма и способы соединения - структуры данных, а этапы сборки конструктора соответствуют алгоритмам.</li> </ul>","path":["Глава 1. Знакомство с алгоритмами","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Я программист и в повседневной работе никогда не использовал алгоритмы для решения задач, поскольку часто используемые алгоритмы уже встроены в языки программирования и ими можно пользоваться напрямую. Значит ли это, что рабочие задачи еще не требуют применения алгоритмов?</p> <p>Если сравнить конкретные профессиональные навыки с приемами в боевых искусствах, то базовые дисциплины скорее напоминают \"внутреннюю силу\".</p> <p>Я считаю, что изучение алгоритмов и других базовых дисциплин важно не для того, чтобы реализовывать их с нуля в работе, а для того, чтобы на основе полученных знаний принимать профессиональные решения и оценки при решении задач, тем самым повышая общее качество работы. Простой пример: каждый язык программирования имеет встроенные функции сортировки.</p> <ul> <li>Если бы мы не изучали структуры данных и алгоритмы, то, получив любые данные, возможно, просто передали бы их этой функции сортировки. Все работает гладко, производительность хорошая, и на первый взгляд проблем нет.</li> <li>Однако если мы изучили алгоритмы, то знаем, что временная сложность встроенной функции сортировки составляет \\(O(n \\log n)\\) ; если же данные представлены целыми числами фиксированной разрядности, например номерами студентов, то можно использовать более эффективный метод поразрядной сортировки, снизив временную сложность до \\(O(nk)\\) , где \\(k\\) - это количество разрядов, а при больших объемах данных выиграть во времени, затратах и пользовательском опыте.</li> </ul> <p>В инженерной практике множество задач трудно решить оптимальным образом, и многие из них решаются \"как-то\". Сложность задачи зависит как от ее природы, так и от уровня знаний и опыта человека, который ее анализирует. Чем более полными знаниями и большим опытом обладает человек, тем глубже он может проанализировать проблему и тем изящнее может быть ее решение.</p>","path":["Глава 1. Знакомство с алгоритмами","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   Что такое алгоритм","text":"","path":["Глава 1. Знакомство с алгоритмами","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   Определение алгоритма","text":"<p>Алгоритм (algorithm) - это набор инструкций или шагов, предназначенных для решения конкретной задачи за ограниченное время. Он обладает следующими свойствами.</p> <ul> <li>Задача четко определена и включает ясные определения входных и выходных данных.</li> <li>Обладает осуществимостью и может быть выполнен за ограниченное количество шагов, времени и памяти.</li> <li>Каждый шаг имеет определенное значение, и при одинаковых входных данных и условиях выполнения результат всегда будет одинаковым.</li> </ul>","path":["Глава 1. Знакомство с алгоритмами","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   Определение структуры данных","text":"<p>Структура данных (data structure) - это способ организации и хранения данных, включающий содержимое данных, их взаимосвязи и методы операций с ними. Структура данных преследует следующие цели.</p> <ul> <li>Минимизировать занимаемое пространство для экономии памяти компьютера.</li> <li>Обеспечивать максимально быструю обработку данных, включая доступ, добавление, удаление и обновление данных.</li> <li>Обеспечивать простое представление данных и логическую информацию для эффективного выполнения алгоритмов.</li> </ul> <p>Проектирование структуры данных - это процесс, полный компромиссов. Если вы хотите улучшить один аспект, часто приходится идти на уступки в другом. Приведем два примера.</p> <ul> <li>Связный список, по сравнению с массивом, более удобен для добавления и удаления данных, но имеет проблемы со скоростью доступа к данным.</li> <li>Граф, по сравнению со связным списком, предоставляет более богатую логическую информацию, но требует большего объема памяти.</li> </ul>","path":["Глава 1. Знакомство с алгоритмами","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   Связь между структурами данных и алгоритмами","text":"<p>Как показано на рисунке 1-4, структуры данных и алгоритмы тесно взаимосвязаны, что проявляется в следующих трех аспектах.</p> <ul> <li>Структуры данных являются основой алгоритмов. Они обеспечивают структурированное хранение данных и методы их обработки.</li> <li>Алгоритмы оживляют структуры данных. Сами по себе структуры данных лишь хранят информацию, но в сочетании с алгоритмами они позволяют решать конкретные задачи.</li> <li>Алгоритмы можно реализовать на основе различных структур данных, однако эффективность их выполнения может значительно различаться, поэтому выбор подходящей структуры данных является ключевым фактором.</li> </ul> <p></p> <p> Рисунок 1-4   Связь между структурами данных и алгоритмами </p> <p>Структуры данных и алгоритмы подобны конструктору, как показано на рисунке 1-5. Комплект конструктора, помимо множества деталей, содержит также подробную инструкцию по сборке. Следуя этой инструкции шаг за шагом, можно собрать красивую модель.</p> <p></p> <p> Рисунок 1-5   Сборка конструктора </p> <p>Подробное описание аналогии с конструктором представлено в таблице 1-1.</p> <p> Таблица 1-1   Сравнение структур данных и алгоритмов с конструктором </p> Структуры данных и алгоритмы Конструктор Входные данные Несобранные детали конструктора Структура данных Организация деталей конструктора, включая форму, размер, способы соединения и т. д. Алгоритм Последовательность действий по сборке деталей в целевую модель Выходные данные Собранная модель конструктора <p>Стоит отметить, что структуры данных и алгоритмы не зависят от языка программирования. Именно поэтому данная книга предлагает их реализации на различных языках.</p> <p>Принятое сокращение</p> <p>В реальных обсуждениях выражение \"структуры данных и алгоритмы\" обычно сокращают до просто \"алгоритмы\". Например, хорошо известные задачи LeetCode на деле одновременно проверяют знания и по структурам данных, и по алгоритмам.</p>","path":["Глава 1. Знакомство с алгоритмами","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"Глава 0.   Предисловие","text":"<p>Abstract</p> <p>Алгоритмы подобны прекрасной симфонии, а каждая строка кода льется подобно мелодии.</p> <p>Пусть эта книга тихо зазвучит в вашем сознании и оставит после себя особую и глубокую мелодию.</p>","path":["Глава 0. Предисловие","Глава 0. &nbsp; Предисловие"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>0.1   Об этой книге</li> <li>0.2   Как пользоваться этой книгой</li> <li>0.3   Резюме</li> </ul>","path":["Глава 0. Предисловие","Глава 0. &nbsp; Предисловие"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   Об этой книге","text":"<p>Этот проект задуман как открытое, бесплатное и дружелюбное к новичкам введение в структуры данных и алгоритмы.</p> <ul> <li>В книге используются анимированные иллюстрации: материал изложен ясно и последовательно, что облегчает освоение и помогает начинающим выстроить карту знаний по структурам данных и алгоритмам.</li> <li>Исходный код можно запустить одним нажатием, что позволяет тренироваться, развивать навыки программирования и понимать принципы работы алгоритмов и реализации структур данных на фундаментальном уровне.</li> <li>Мы призываем читателей к взаимопомощи: задавайте вопросы и делитесь идеями в комментариях. Обсуждения помогают двигаться вперед всем вместе.</li> </ul>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   Целевая аудитория","text":"<p>Если вы новичок в алгоритмах, никогда с ними не сталкивались или уже имеете некоторый опыт решения задач, но еще не обладаете четким пониманием структур данных и алгоритмов, эта книга создана специально для вас!</p> <p>Если у вас уже есть определенный опыт решения задач и вы знакомы с большинством типов задач, эта книга поможет вам освежить и систематизировать знания об алгоритмах, а исходный код может служить набором инструментов для решения задач или алгоритмическим словарем.</p> <p>Если вы владеете алгоритмами на экспертном уровне, мы будем рады вашим ценным советам или совместному участию в создании книги.</p> <p>Предварительные требования</p> <p>Необходимо иметь хотя бы базовую подготовку в одном из языков программирования, чтобы читать и писать простой код.</p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   Структура содержания","text":"<p>Основное содержание книги представлено на рисунке 0-1.</p> <ul> <li>Анализ сложности: критерии и методы оценки структур данных и алгоритмов. Методы расчета временной и пространственной сложности, распространенные типы, примеры и т. д.</li> <li>Структуры данных: классификация основных типов данных и структур данных. Определение, преимущества и недостатки, основные операции, распространенные типы, типичные приложения и методы реализации массивов, списков, стеков, очередей, хеш-таблиц, деревьев, куч и графов.</li> <li>Алгоритмы: определение, преимущества и недостатки, эффективность, области применения, этапы решения и примеры задач для поиска, сортировки, алгоритма \"разделяй и властвуй\", поиска с возвратом, динамического программирования и жадных алгоритмов.</li> </ul> <p></p> <p> Рисунок 0-1   Основное содержание книги </p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   Благодарности","text":"<p>Эта книга постоянно совершенствуется благодаря совместным усилиям множества участников открытого сообщества. Благодарим каждого автора, вложившего свое время и силы; их имена перечислены в порядке, автоматически сгенерированном GitHub: krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, rongyi, msk397, gvenusleo, khoaxuantu, rivertwilight, K3v123, gyt95, zhuoqinyue, yuelinxin, Zuoxun, mingXta, Phoenix0415, FangYuan33, GN-Yu, longsizhuo, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, pengchzn, QiLOL, magentaqin, hello-ikun, JoseHung, qualifier1024, thomasq0, sunshinesDL, L-Super, Guanngxu, Transmigration-zhou, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, Shyam-Chen, theNefelibatas, longranger2, codeberg-user, xiongsp, JeffersonHuang, prinpal, seven1240, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, SamJin98, hongyun-robot, nanlei, XiaChuerwu, yd-j, iron-irax, mgisr, steventimes, junminhong, heshuyue, danny900714, MolDuM, Nigh, Dr-XYZ, XC-Zero, reeswell, PXG-XPG, NI-SW, Horbin-Magician, Enlightenus, YangXuanyi, beatrix-chan, DullSword, xjr7670, jiaxianhua, qq909244296, iStig, boloboloda, hts0000, gledfish, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, linyejoe2, liuxjerry, llql1211, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, ZhongGuanbin, hezhizhen, linzeyan, ZJKung, luluxia, xb534, ztkuaikuai, yw-1021, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yanedie, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, lyl625760, lucaswangdev, 0130w, shanghai-Jerry, EJackYang, Javesun99, eltociear, lipusheng, KNChiu, BlindTerran, ShiMaRing, lovelock, FreddieLi, FloranceYeh, fanchenggang, gltianwen, goerll, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, Asashishi, Asa0oo0o0o, fanenr, eagleanurag, akshiterate, 52coder, foursevenlove, KorsChen, GaochaoZhu, hopkings2008, yang-le, realwujing, Evilrabbit520, Umer-Jahangir, Turing-1024-Lee, Suremotoo, paoxiaomooo, Chieko-Seren, Allen-Scai, ymmmas, Risuntsy, Richard-Zhang1019, RafaelCaso, qingpeng9802, primexiao, Urbaner3, zhongfq, nidhoggfgg, MwumLi, CreatorMetaSky, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai и KawaiiAsh.</p> <p>Рецензирование кода книги выполнили coderonion, curtishd, Gonglja, gvenusleo, hpstory, justin-tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon и rongyi (в алфавитном порядке). Благодарим их за потраченное время и силы, которые обеспечили стандартизацию и единообразие кода на различных языках.</p> <p>Традиционную китайскую версию книги вычитали Shyam-Chen и Dr-XYZ, английскую версию - yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0 и magentaqin, а японскую версию - eltociear. Именно благодаря их постоянному вкладу эта книга может служить более широкому кругу читателей, и мы искренне благодарим их.</p> <p>Инструмент генерации ePub-версии этой книги разработал zhongfq. Благодарим его за вклад, который дал читателям более свободный способ чтения.</p> <p>В процессе создания этой книги мне помогало много людей.</p> <ul> <li>Благодарю моего наставника в компании, доктора Ли Си: в одной из бесед вы вдохновили меня быстрее начать, что укрепило мою решимость написать эту книгу;</li> <li>Благодарю мою девушку Bubble, первого читателя этой книги: с позиции новичка в алгоритмах она дала много ценных советов, благодаря которым книга стала более понятной и доступной;</li> <li>Благодарю Tengbao, Qibao и Feibao за креативное название книги, которое навевает приятные воспоминания о первой строке кода \"Hello World!\";</li> <li>Благодарю Xiaoquan за профессиональную помощь в вопросах интеллектуальной собственности, что сыграло важную роль в совершенствовании этой открытой книги;</li> <li>Благодарю Sutong за дизайн обложки и логотипа книги, а также за терпение при многочисленных исправлениях по моим просьбам;</li> <li>Благодарю @squidfunk за советы по оформлению и за разработку открытой темы документации Material-for-MkDocs.</li> </ul> <p>В процессе написания книги я ознакомился с множеством учебников и статей по структурам данных и алгоритмам. Эти работы послужили отличным образцом для этой книги, обеспечив ее точность и качество. Я искренне благодарю всех преподавателей и предшественников за их выдающийся вклад!</p> <p>Эта книга пропагандирует метод обучения, сочетающий умственную и практическую деятельность; в этом отношении на меня сильно повлияла Dive into Deep Learning. Я настоятельно рекомендую эту замечательную работу всем читателям.</p> <p>Сердечно благодарю моих родителей: именно ваша постоянная поддержка и ободрение дали мне возможность заняться этим увлекательным делом.</p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   Как пользоваться этой книгой","text":"<p>Tip</p> <p>Для получения наилучшего опыта чтения рекомендуется полностью прочитать этот раздел.</p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   Соглашения о стиле изложения","text":"<ul> <li>Главы, помеченные <code>*</code> в заголовке, являются дополнительными и содержат более сложный материал. Если времени мало, их можно пропустить.</li> <li>Профессиональные термины выделяются полужирным шрифтом в печатной и PDF-версии или подчеркиванием в веб-версии, например массив (array). Рекомендуется запоминать их для удобства чтения литературы.</li> <li>Важные моменты и обобщающие фразы будут выделяться полужирным шрифтом, и на такие тексты следует обращать особое внимание.</li> <li>Слова и выражения со специальным смыслом будут отмечаться \"кавычками\", чтобы избежать неоднозначности.</li> <li>Когда термины различаются между языками программирования, в качестве стандарта используется Python; например, <code>None</code> применяется для обозначения \"пустого\" значения.</li> <li>В некоторых местах книга отходит от стандартов комментирования программного кода ради более компактного оформления. Комментарии в основном делятся на три типа: заголовочные, содержательные и многострочные.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п.\"\"\"\n\n# Содержательный комментарий: подробно поясняет код\n\n\"\"\"\nМногострочный\nкомментарий\n\"\"\"\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n// Многострочный\n// комментарий\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>### Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. ###\n\n# Содержательный комментарий: подробно поясняет код\n\n# Многострочный\n# комментарий\n</code></pre>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   Эффективное обучение с помощью анимированных иллюстраций","text":"<p>По сравнению с текстом видео и изображения обладают более высокой плотностью информации и более четкой структурой, поэтому их легче воспринимать. В этой книге ключевые и сложные моменты в основном представлены в виде анимированных иллюстраций, а текст служит пояснением и дополнением.</p> <p>Если во время чтения вы встречаете фрагмент с анимированной иллюстрацией, как на рисунке 0-2, используйте иллюстрацию в качестве основного источника информации, а текст - в качестве вспомогательного, объединяя оба источника для понимания материала.</p> <p></p> <p> Рисунок 0-2   Пример анимированной иллюстрации </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   Углубление понимания через практику кода","text":"<p>Сопроводительный код этой книги размещен в репозитории GitHub. Как показано ниже, исходный код содержит тестовые примеры и может быть запущен одним нажатием кнопки.</p> <p>Если позволяет время, рекомендуется самостоятельно набирать код. Если времени на обучение мало, по крайней мере просмотрите и выполните весь код.</p> <p>Процесс написания кода приносит больше пользы, чем его чтение. Настоящее обучение - это обучение на практике.</p> <p></p> <p> Рисунок 0-3   Пример запуска кода </p> <p>Подготовка к запуску кода в основном состоит из трех этапов.</p> <p>Шаг 1: установка локальной среды программирования. Воспользуйтесь руководством из приложения. Если среда уже установлена, этот шаг можно пропустить.</p> <p>Шаг 2: клонирование или загрузка репозитория кода. Перейдите в репозиторий GitHub. Если у вас уже установлен Git, репозиторий можно клонировать следующей командой:</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>Также можно нажать кнопку \"Download ZIP\" в месте, показанном на рисунке 0-4, напрямую скачать архив с кодом и затем распаковать его локально.</p> <p></p> <p> Рисунок 0-4   Клонирование репозитория и загрузка кода </p> <p>Шаг 3: запуск исходного кода. Как показано на рисунке 0-5, для блоков кода, у которых сверху указано имя файла, соответствующий исходный файл можно найти в папке <code>codes</code> репозитория. Исходные файлы запускаются одним нажатием, что помогает не тратить лишнее время на отладку и сосредоточиться на изучении материала.</p> <p></p> <p> Рисунок 0-5   Блоки кода и соответствующие исходные файлы </p> <p>Помимо локального запуска, веб-версия также поддерживает визуальное выполнение Python-кода (на базе pythontutor). Как показано ниже, можно нажать \"Визуализировать выполнение\" под блоком кода, чтобы раскрыть окно и наблюдать за выполнением алгоритма; также можно нажать \"Полноэкранный режим\" для более удобного просмотра.</p> <p></p> <p> Рисунок 0-6   Визуальный запуск Python-кода </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   Совместный рост через вопросы и обсуждения","text":"<p>Во время чтения книги не стоит пропускать те места, которые остались непонятными. Мы призываем вас задавать вопросы в разделе комментариев: я и мои коллеги постараемся ответить вам как можно тщательнее, обычно в течение двух дней.</p> <p>Как показано на рисунке 0-7, в веб-версии у каждой главы внизу есть раздел комментариев. Рекомендуется уделять внимание его содержанию. С одной стороны, это поможет увидеть, с какими трудностями сталкиваются другие читатели, восполнить пробелы и подтолкнуть себя к более глубокому пониманию. С другой стороны, мы надеемся, что вы будете отвечать на вопросы других участников и делиться своими мнениями.</p> <p></p> <p> Рисунок 0-7   Пример раздела комментариев </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   Дорожная карта изучения алгоритмов","text":"<p>В целом процесс изучения структур данных и алгоритмов можно разделить на три этапа.</p> <ol> <li>Этап 1: введение в алгоритмы. Необходимо познакомиться с особенностями и применением различных структур данных, изучить принципы, процессы, назначение и эффективность различных алгоритмов.</li> <li>Этап 2: решение алгоритмических задач. Рекомендуется начинать с популярных задач и решить не менее 100 из них, чтобы познакомиться с основными алгоритмическими проблемами. При первых попытках \"забывание знаний\" может стать испытанием, но это нормально. Следуйте при повторении задач \"кривой забывания Эббингауза\", и обычно после 3-5 циклов повторения материал хорошо запоминается. Рекомендуемые списки задач и планы практики см. в этом репозитории GitHub.</li> <li>Этап 3: построение системы знаний. В процессе обучения можно читать статьи по алгоритмам, изучать каркасы решений и учебники, чтобы постоянно обогащать свою систему знаний. В решении задач можно применять продвинутые стратегии, например классификацию по темам, несколько решений одной задачи или одно решение для нескольких задач; соответствующий опыт можно найти в различных сообществах.</li> </ol> <p>Как показано на рисунке 0-8, содержание этой книги в основном охватывает \"этап 1\" и призвано помочь вам более эффективно перейти к обучению на этапах 2 и 3.</p> <p></p> <p> Рисунок 0-8   Дорожная карта изучения алгоритмов </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   Резюме","text":"","path":["Глава 0. Предисловие","0.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Основная аудитория этой книги - новички в изучении алгоритмов. Если у вас уже есть определенная база, книга поможет систематизировать знания, а исходный код послужит инструментальной библиотекой для решения задач.</li> <li>Содержание книги включает три основные части - анализ сложности, структуры данных и алгоритмы - и охватывает большинство тем в этой области.</li> <li>Для новичков в алгоритмах крайне важно изучить начальные разделы книги, чтобы избежать множества ошибок в будущем.</li> <li>Анимированные иллюстрации в книге обычно используются для представления ключевых и сложных аспектов. При чтении книги следует уделять этим материалам больше внимания.</li> <li>Практика - лучший способ изучения программирования. Настоятельно рекомендуется запускать исходный код и самостоятельно писать программы.</li> <li>В веб-версии книги каждая глава имеет область комментариев, где можно задавать вопросы и делиться своими мыслями.</li> </ul>","path":["Глава 0. Предисловие","0.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"Список литературы","text":"<p>[1] Thomas H. Cormen и др. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick и др. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] Yan Weimin. Data Structures (C Language Edition).</p> <p>[5] Deng Junhui. Data Structures (C++ Language Edition, 3<sup>rd</sup> Edition).</p> <p>[6] Mark Allen Weiss; пер. Chen Yue. Data Structures and Algorithm Analysis: Java Description (3<sup>rd</sup> Edition).</p> <p>[7] Cheng Jie. A Plainspoken Guide to Data Structures.</p> <p>[8] Wang Zheng. The Beauty of Data Structures and Algorithms.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang и др. Dive into Deep Learning.</p>","path":["Список литературы"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"Глава 10.   Поиск","text":"<p>Abstract</p> <p>Поиск - это движение в неизвестность: иногда приходится пройти каждый уголок пространства, а иногда удается быстро найти цель.</p> <p>В этом пути каждый новый шаг может привести к ответу, которого мы не ожидали.</p>","path":["Глава 10. Поиск","Глава 10. &nbsp; Поиск"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>10.1   Двоичный поиск</li> <li>10.2   Точка вставки двоичного поиска</li> <li>10.3   Граничные случаи двоичного поиска</li> <li>10.4   Стратегия оптимизации через хеширование</li> <li>10.5   Алгоритмы поиска: новый взгляд</li> <li>10.6   Резюме</li> </ul>","path":["Глава 10. Поиск","Глава 10. &nbsp; Поиск"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   Двоичный поиск","text":"<p>Двоичный поиск (binary search) - это эффективный алгоритм поиска, основанный на стратегии \"разделяй и властвуй\". Он использует упорядоченность данных, сокращая на каждом шаге область поиска вдвое, пока не будет найден целевой элемент или пока интервал поиска не опустеет.</p> <p>Question</p> <p>Дан массив <code>nums</code> длины \\(n\\), элементы которого расположены в порядке возрастания и не повторяются. Найдите и верните индекс элемента <code>target</code> в этом массиве. Если массив не содержит этого элемента, верните \\(-1\\) . Пример показан на рисунке 10-1.</p> <p></p> <p> Рисунок 10-1   Пример данных для двоичного поиска </p> <p>Как показано на рисунке 10-2, сначала инициализируем указатели \\(i = 0\\) и \\(j = n - 1\\) , которые указывают на первый и последний элементы массива и задают интервал поиска \\([0, n - 1]\\) . Обратите внимание: квадратные скобки обозначают замкнутый интервал и включают граничные значения.</p> <p>Далее в цикле выполняются следующие два шага.</p> <ol> <li>Вычислить индекс середины \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) , где \\(\\lfloor \\: \\rfloor\\) означает операцию округления вниз.</li> <li>Сравнить <code>nums[m]</code> и <code>target</code> , после чего возможны три случая.<ol> <li>Если <code>nums[m] &lt; target</code> , это означает, что <code>target</code> находится в интервале \\([m + 1, j]\\) , поэтому выполняется \\(i = m + 1\\) .</li> <li>Если <code>nums[m] &gt; target</code> , это означает, что <code>target</code> находится в интервале \\([i, m - 1]\\) , поэтому выполняется \\(j = m - 1\\) .</li> <li>Если <code>nums[m] = target</code> , значит, элемент <code>target</code> найден, поэтому возвращается индекс \\(m\\) .</li> </ol> </li> </ol> <p>Если массив не содержит целевой элемент, область поиска в итоге сузится до пустого интервала. В этом случае возвращается \\(-1\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 10-2   Процесс двоичного поиска </p> <p>Стоит отметить, что поскольку и \\(i\\) , и \\(j\\) имеют тип <code>int</code> , то сумма \\(i + j\\) может выйти за пределы диапазона типа <code>int</code>. Чтобы избежать переполнения, обычно используют формулу \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) для вычисления середины.</p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск (двусторонне замкнутый интервал)\"\"\"\n    # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    i, j = 0, len(nums) - 1\n    # Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j:\n        # Теоретически числа в Python могут быть сколь угодно большими (ограничены только объемом памяти), поэтому не нужно учитывать переполнение больших чисел\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # Это означает, что target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # Это означает, что target находится в интервале [i, m-1]\n        else:\n            return m  # Целевой элемент найден, вернуть его индекс\n    return -1  # Целевой элемент не найден, вернуть -1\n</code></pre> binary_search.cpp<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.size() - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(int[] nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint BinarySearch(int[] nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.Length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // Вычислить индекс середины m\n        if (nums[m] &lt; target)      // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else                       // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunc binarySearch(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    i, j := 0, len(nums)-1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    for i &lt;= j {\n        m := i + (j-i)/2      // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunction binarySearch(nums, target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let i = 0,\n        j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        // Вычислить индекс середины m, используя parseInt() для округления вниз\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else return m; // Целевой элемент найден, вернуть его индекс\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunction binarySearch(nums: number[], target: number): number {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let i = 0,\n        j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        // Вычислить индекс середины m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    return -1; // Целевой элемент не найден, вернуть -1\n}\n</code></pre> binary_search.dart<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n  int i = 0, j = nums.length - 1;\n  // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      // Это означает, что target находится в интервале [m+1, j]\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // Это означает, что target находится в интервале [i, m-1]\n      j = m - 1;\n    } else {\n      // Целевой элемент найден, вернуть его индекс\n      return m;\n    }\n  }\n  // Целевой элемент не найден, вернуть -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(int *nums, int len, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = len - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    var i = 0\n    var j = nums.size - 1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        else  // Целевой элемент найден, вернуть его индекс\n            return m\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Бинарный поиск (двусторонне замкнутый интервал) ###\ndef binary_search(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n  i, j = 0, nums.length - 1\n\n  # Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n  while i &lt;= j\n    # Теоретически числа в Ruby могут быть сколь угодно большими (ограничены только объемом памяти), поэтому не нужно учитывать переполнение больших чисел\n    m = (i + j) / 2   # Вычислить индекс середины m\n\n    if nums[m] &lt; target\n      i = m + 1 # Это означает, что target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # Это означает, что target находится в интервале [i, m-1]\n    else\n      return m  # Целевой элемент найден, вернуть его индекс\n    end\n  end\n\n  -1  # Целевой элемент не найден, вернуть -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Временная сложность равна \\(O(\\log n)\\) : в цикле двоичного поиска интервал каждый раз сокращается вдвое, поэтому число итераций равно \\(\\log_2 n\\) .</p> <p>Пространственная сложность равна \\(O(1)\\) : указатели \\(i\\) и \\(j\\) занимают константный объем памяти.</p>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   Методы представления интервалов","text":"<p>Помимо описанного выше двойного замкнутого интервала, часто используется и левозамкнутый правооткрытый интервал, который задается как \\([0, n)\\) , то есть левая граница включается, а правая - нет. В этом представлении интервал \\([i, j)\\) пуст, когда \\(i = j\\) .</p> <p>На основе этого представления можно реализовать двоичный поиск с той же функциональностью:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск (лево замкнутый, право открытый интервал)\"\"\"\n    # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    i, j = 0, len(nums)\n    # Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # Это означает, что target находится в интервале [m+1, j)\n        elif nums[m] &gt; target:\n            j = m  # Это означает, что target находится в интервале [i, m)\n        else:\n            return m  # Целевой элемент найден, вернуть его индекс\n    return -1  # Целевой элемент не найден, вернуть -1\n</code></pre> binary_search.cpp<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.size();\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(int[] nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint BinarySearchLCRO(int[] nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.Length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // Вычислить индекс середины m\n        if (nums[m] &lt; target)      // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else                       // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    i, j := 0, len(nums)\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    for i &lt; j {\n        m := i + (j-i)/2      // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m)\n            j = m\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m)\n            j = m\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunction binarySearchLCRO(nums, target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let i = 0,\n        j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        // Вычислить индекс середины m, используя parseInt() для округления вниз\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        // Целевой элемент найден, вернуть его индекс\n        else return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let i = 0,\n        j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        // Вычислить индекс середины m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    return -1; // Целевой элемент не найден, вернуть -1\n}\n</code></pre> binary_search.dart<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n  int i = 0, j = nums.length;\n  // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      // Это означает, что target находится в интервале [m+1, j)\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // Это означает, что target находится в интервале [i, m)\n      j = m;\n    } else {\n      // Целевой элемент найден, вернуть его индекс\n      return m;\n    }\n  }\n  // Целевой элемент не найден, вернуть -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = len;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    var i = 0\n    var j = nums.size\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m\n        else  // Целевой элемент найден, вернуть его индекс\n            return m\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Бинарный поиск (лево замкнутый, право открытый интервал) ###\ndef binary_search_lcro(nums, target)\n  # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n  i, j = 0, nums.length\n\n  # Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n  while i &lt; j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # Это означает, что target находится в интервале [m+1, j)\n    elsif nums[m] &gt; target\n      j = m - 1 # Это означает, что target находится в интервале [i, m)\n    else\n      return m  # Целевой элемент найден, вернуть его индекс\n    end\n  end\n\n  -1  # Целевой элемент не найден, вернуть -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 10-3, в этих двух вариантах представления интервала различаются инициализация, условие цикла и операция сужения интервала в алгоритме двоичного поиска.</p> <p>Поскольку в записи \"двойной замкнутый интервал\" обе границы являются закрытыми, операции сужения интервала при помощи указателей \\(i\\) и \\(j\\) тоже получаются симметричными. Из-за этого в таком варианте сложнее допустить ошибку, поэтому обычно рекомендуется использовать именно запись \"двойной замкнутый интервал\".</p> <p></p> <p> Рисунок 10-3   Два определения интервалов </p>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   Преимущества и ограничения","text":"<p>Двоичный поиск показывает хорошие результаты и по времени, и по памяти.</p> <ul> <li>Двоичный поиск очень эффективен по времени. На больших объемах данных логарифмическая временная сложность дает заметное преимущество. Например, когда размер данных \\(n = 2^{20}\\) , линейный поиск потребует \\(2^{20} = 1048576\\) итераций, тогда как двоичный поиск выполнится всего за \\(\\log_2 2^{20} = 20\\) итераций.</li> <li>Двоичный поиск не требует дополнительной памяти. По сравнению с алгоритмами поиска, которым нужно внешнее пространство (например, с хеш-поиском), двоичный поиск заметно экономнее по памяти.</li> </ul> <p>Однако двоичный поиск подходит не для всех ситуаций, и основные причины таковы.</p> <ul> <li>Двоичный поиск применим только к упорядоченным данным. Если входные данные неупорядочены, специально сортировать их ради двоичного поиска невыгодно. Это связано с тем, что временная сложность алгоритмов сортировки обычно составляет \\(O(n \\log n)\\) , что выше, чем у линейного и двоичного поиска. Если элементы приходится часто вставлять, то для сохранения порядка в массиве их нужно помещать в конкретные позиции, а это требует \\(O(n)\\) времени и тоже обходится дорого.</li> <li>Двоичный поиск применим только к массивам. Для него нужен скачкообразный доступ к элементам, а в связном списке такой доступ малоэффективен, поэтому двоичный поиск не подходит для списков и структур данных, построенных на их основе.</li> <li>При малом объеме данных линейный поиск работает лучше. В линейном поиске на каждом шаге нужна всего одна операция сравнения; в двоичном поиске требуется 1 сложение, 1 деление, от 1 до 3 сравнений и еще 1 сложение или вычитание, то есть всего от 4 до 6 элементарных операций. Поэтому при небольшом \\(n\\) линейный поиск может оказаться быстрее двоичного.</li> </ul>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   Двоичный поиск границ","text":"","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   Поиск левой границы","text":"<p>Question</p> <p>Дан упорядоченный массив <code>nums</code> длины \\(n\\), который может содержать повторяющиеся элементы. Верните индекс самого левого элемента <code>target</code> в массиве. Если массив не содержит этот элемент, верните \\(-1\\) .</p> <p>Вспомним метод поиска точки вставки при двоичном поиске: после завершения поиска указатель \\(i\\) указывает на самый левый <code>target</code> , поэтому поиск точки вставки по сути является поиском индекса самого левого <code>target</code>.</p> <p>Рассмотрим реализацию поиска левой границы через функцию поиска точки вставки. Обратите внимание: массив может не содержать <code>target</code> , и тогда возможны две ситуации.</p> <ul> <li>Индекс точки вставки \\(i\\) выходит за границы массива.</li> <li>Элемент <code>nums[i]</code> не равен <code>target</code> .</li> </ul> <p>Если возникает любая из этих ситуаций, достаточно сразу вернуть \\(-1\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск самого левого target\"\"\"\n    # Эквивалентно поиску точки вставки target\n    i = binary_search_insertion(nums, target)\n    # target не найден, вернуть -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # Найти target и вернуть индекс i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Бинарный поиск самого левого target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Бинарный поиск самого левого target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // Эквивалентно поиску точки вставки target\n    i := binarySearchInsertion(nums, target)\n    // target не найден, вернуть -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Бинарный поиск самого левого target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // Эквивалентно поиску точки вставки target\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // target не найден, вернуть -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* Бинарный поиск самого левого target */\nfunction binarySearchLeftEdge(nums, target) {\n    // Эквивалентно поиску точки вставки target\n    const i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Бинарный поиск самого левого target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Эквивалентно поиску точки вставки target\n    const i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // Эквивалентно поиску точки вставки target\n  int i = binarySearchInsertion(nums, target);\n  // target не найден, вернуть -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // Найти target и вернуть индекс i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Бинарный поиск самого левого target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Эквивалентно поиску точки вставки target\n    let i = binary_search_insertion(nums, target);\n    // target не найден, вернуть -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binarySearchInsertion(nums, numSize, target);\n    // target не найден, вернуть -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Бинарный поиск самого левого target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // Эквивалентно поиску точки вставки target\n    val i = binarySearchInsertion(nums, target)\n    // target не найден, вернуть -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### Бинарный поиск самого левого target ###\ndef binary_search_left_edge(nums, target)\n  # Эквивалентно поиску точки вставки target\n  i = binary_search_insertion(nums, target)\n\n  # target не найден, вернуть -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # Найти target и вернуть индекс i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   Поиск правой границы","text":"<p>Как тогда найти самый правый <code>target</code> ? Самый прямой способ - изменить код, заменив операцию сужения указателя в случае <code>nums[m] == target</code> . Мы не будем приводить этот код, заинтересованные читатели могут реализовать его самостоятельно.</p> <p>Ниже представлены два более изящных способа.</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   Повторное использование поиска левой границы","text":"<p>На самом деле функцию поиска самого левого элемента можно использовать и для поиска самого правого элемента. Конкретная идея такова: преобразовать поиск самого правого <code>target</code> в поиск самого левого <code>target + 1</code>.</p> <p>Как показано на рисунке 10-7, после завершения поиска указатель \\(i\\) указывает на самый левый <code>target + 1</code> (если он существует), а указатель \\(j\\) указывает на самый правый <code>target</code> , поэтому достаточно вернуть \\(j\\).</p> <p></p> <p> Рисунок 10-7   Преобразование поиска правой границы в поиск левой </p> <p>Обратите внимание: функция возвращает точку вставки \\(i\\) , поэтому из нее нужно вычесть \\(1\\) , чтобы получить \\(j\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск самого правого target\"\"\"\n    # Преобразовать задачу в поиск самого левого target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j указывает на самый правый target, а i — на первый элемент больше target\n    j = i - 1\n    # target не найден, вернуть -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # Найти target и вернуть индекс j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Бинарный поиск самого правого target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Бинарный поиск самого правого target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    j := i - 1\n    // target не найден, вернуть -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Бинарный поиск самого правого target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    let j = i - 1\n    // target не найден, вернуть -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* Бинарный поиск самого правого target */\nfunction binarySearchRightEdge(nums, target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    const j = i - 1;\n    // target не найден, вернуть -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Бинарный поиск самого правого target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Преобразовать задачу в поиск самого левого target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    const j = i - 1;\n    // target не найден, вернуть -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // Преобразовать задачу в поиск самого левого target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j указывает на самый правый target, а i — на первый элемент больше target\n  int j = i - 1;\n  // target не найден, вернуть -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // Найти target и вернуть индекс j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Бинарный поиск самого правого target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Преобразовать задачу в поиск самого левого target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    let j = i - 1;\n    // target не найден, вернуть -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Бинарный поиск самого правого target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    val j = i - 1\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### Бинарный поиск самого правого target ###\ndef binary_search_right_edge(nums, target)\n  # Преобразовать задачу в поиск самого левого target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j указывает на самый правый target, а i — на первый элемент больше target\n  j = i - 1\n\n  # target не найден, вернуть -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # Найти target и вернуть индекс j\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   Преобразование в поиск элемента","text":"<p>Мы знаем, что если массив не содержит <code>target</code> , то в конце поиска указатели \\(i\\) и \\(j\\) будут указывать соответственно на первый элемент, больший <code>target</code> , и на первый элемент, меньший <code>target</code> .</p> <p>Следовательно, как показано на рисунке 10-8, для поиска левой и правой границы можно сконструировать элемент, которого нет в массиве.</p> <ul> <li>Поиск самого левого <code>target</code> : можно преобразовать в поиск <code>target - 0.5</code> и вернуть указатель \\(i\\) .</li> <li>Поиск самого правого <code>target</code> : можно преобразовать в поиск <code>target + 0.5</code> и вернуть указатель \\(j\\) .</li> </ul> <p></p> <p> Рисунок 10-8   Преобразование поиска границ в поиск элемента </p> <p>Код здесь опущен, но стоит обратить внимание на два момента.</p> <ul> <li>По условию массив не содержит дробных чисел, поэтому нам не нужно беспокоиться о том, как обрабатывать случай равенства другим элементам массива.</li> <li>Поскольку этот метод вводит дробные числа, переменную <code>target</code> в функции нужно изменить на тип с плавающей запятой (в Python менять ничего не требуется).</li> </ul>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   Двоичный поиск точки вставки","text":"<p>Двоичный поиск можно использовать не только для поиска целевого элемента, но и для решения многих вариаций задачи, например для поиска позиции вставки целевого элемента.</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   Случай без повторяющихся элементов","text":"<p>Question</p> <p>Дан упорядоченный массив <code>nums</code> длины \\(n\\) и элемент <code>target</code> , причем в массиве нет повторяющихся элементов. Нужно вставить <code>target</code> в массив <code>nums</code> , сохранив порядок. Если элемент <code>target</code> уже присутствует в массиве, вставьте его слева от него. Верните индекс, который будет иметь <code>target</code> после вставки. Пример показан на рисунке 10-4.</p> <p></p> <p> Рисунок 10-4   Пример данных для точки вставки </p> <p>Если мы хотим переиспользовать код двоичного поиска из предыдущего раздела, нужно ответить на два вопроса.</p> <p>Вопрос 1: если массив содержит <code>target</code> , будет ли индекс вставки совпадать с индексом этого элемента?</p> <p>По условию <code>target</code> нужно вставить слева от равного элемента, а это означает, что новый <code>target</code> занимает место старого <code>target</code> . Иначе говоря, если массив содержит <code>target</code> , то индекс вставки совпадает с индексом этого <code>target</code>.</p> <p>Вопрос 2: если массив не содержит <code>target</code> , индекс какого элемента будет точкой вставки?</p> <p>Рассмотрим процесс двоичного поиска подробнее: когда <code>nums[m] &lt; target</code> , указатель \\(i\\) сдвигается вправо и тем самым приближается к элементу, который больше либо равен <code>target</code> . Аналогично указатель \\(j\\) постепенно приближается к элементу, который меньше либо равен <code>target</code> .</p> <p>Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель \\(i\\) указывает на первый элемент, больший <code>target</code> , а указатель \\(j\\) указывает на первый элемент, меньший <code>target</code> . Нетрудно сделать вывод, что если массив не содержит <code>target</code> , то индекс вставки равен \\(i\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск точки вставки (без повторяющихся элементов)\"\"\"\n    i, j = 0, len(nums) - 1  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target находится в интервале [i, m-1]\n        else:\n            return m  # Найти target и вернуть точку вставки m\n    # target не найден, вернуть точку вставки i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Вычислить индекс середины m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target находится в интервале [i, m-1]\n            j = m - 1\n        } else {\n            // Найти target и вернуть точку вставки m\n            return m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            return m // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target находится в интервале [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target находится в интервале [i, m-1]\n    } else {\n      return m; // Найти target и вернуть точку вставки m\n    }\n  }\n  // target не найден, вернуть точку вставки i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m;\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            return m // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Бинарный поиск точки вставки (без повторяющихся элементов) ###\ndef binary_search_insertion_simple(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target находится в интервале [i, m-1]\n    else\n      return m  # Найти target и вернуть точку вставки m\n    end\n  end\n\n  i # target не найден, вернуть точку вставки i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   Случай с повторяющимися элементами","text":"<p>Question</p> <p>В предыдущей задаче теперь допускается, что массив может содержать повторяющиеся элементы, а все остальные условия остаются без изменений.</p> <p>Если в массиве есть несколько элементов <code>target</code> , то обычный двоичный поиск сможет вернуть индекс только одного из них, но не позволит определить, сколько элементов <code>target</code> находится слева и справа от него.</p> <p>По условию целевой элемент нужно вставить в самую левую позицию, поэтому нам нужно найти индекс самого левого <code>target</code> в массиве. На первом этапе можно рассмотреть решение, показанное на рисунке 10-5.</p> <ol> <li>Выполнить двоичный поиск и получить индекс любого элемента <code>target</code> , обозначив его как \\(k\\) .</li> <li>Начиная с индекса \\(k\\) , линейно двигаться влево и вернуть результат, когда будет найден самый левый <code>target</code> .</li> </ol> <p></p> <p> Рисунок 10-5   Линейный поиск точки вставки среди повторяющихся элементов </p> <p>Этот метод применим на практике, однако в нем есть линейный поиск, поэтому его временная сложность равна \\(O(n)\\) . Когда в массиве имеется много повторяющихся <code>target</code> , такой подход работает неэффективно.</p> <p>Теперь рассмотрим расширение кода двоичного поиска. Как показано на рисунке 10-6, общий процесс остается прежним: на каждом шаге мы сначала вычисляем индекс середины \\(m\\) , а затем сравниваем <code>target</code> и <code>nums[m]</code> , после чего возможны следующие случаи.</p> <ul> <li>Когда <code>nums[m] &lt; target</code> или <code>nums[m] &gt; target</code> , это означает, что <code>target</code> еще не найден, поэтому используется стандартная операция сужения интервала в двоичном поиске, благодаря чему указатели \\(i\\) и \\(j\\) приближаются к <code>target</code>.</li> <li>Когда <code>nums[m] == target</code> , это означает, что элементы меньше <code>target</code> находятся в интервале \\([i, m - 1]\\) , поэтому мы используем \\(j = m - 1\\) для сужения интервала, тем самым приближая указатель \\(j\\) к элементам, меньшим <code>target</code>.</li> </ul> <p>После завершения цикла указатель \\(i\\) будет указывать на самый левый <code>target</code> , а указатель \\(j\\) - на первый элемент, меньший <code>target</code> , поэтому индекс \\(i\\) и является точкой вставки.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 10-6   Шаги поиска точки вставки для повторяющихся элементов </p> <p>Если посмотреть на следующий код, то видно, что действия в ветвях <code>nums[m] &gt; target</code> и <code>nums[m] == target</code> совпадают, поэтому эти две ветви можно объединить.</p> <p>Даже в этом случае можно оставить условия развернутыми, потому что так логика выглядит более ясной и код легче читать.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск точки вставки (с повторяющимися элементами)\"\"\"\n    i, j = 0, len(nums) - 1  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target находится в интервале [i, m-1]\n        else:\n            j = m - 1  # Первый элемент меньше target находится в интервале [i, m-1]\n    # Вернуть точку вставки i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Вычислить индекс середины m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target находится в интервале [i, m-1]\n            j = m - 1\n        } else {\n            // Первый элемент меньше target находится в интервале [i, m-1]\n            j = m - 1\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1 // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target находится в интервале [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target находится в интервале [i, m-1]\n    } else {\n      j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n    }\n  }\n  // Вернуть точку вставки i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1 // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Бинарный поиск точки вставки (с повторяющимися элементами) ###\ndef binary_search_insertion(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target находится в интервале [i, m-1]\n    else\n      j = m - 1 # Первый элемент меньше target находится в интервале [i, m-1]\n    end\n  end\n\n  i # Вернуть точку вставки i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Tip</p> <p>Код в этом разделе записан в стиле \"двойного замкнутого интервала\". При желании можно самостоятельно реализовать вариант \"слева закрыт, справа открыт\".</p> <p>Если смотреть в целом, суть двоичного поиска сводится к тому, что для указателей \\(i\\) и \\(j\\) заранее задаются ориентиры поиска; целью может быть конкретный элемент, например <code>target</code> , а может быть и диапазон элементов, например все элементы, меньшие <code>target</code> .</p> <p>В ходе непрерывного двоичного деления указатели \\(i\\) и \\(j\\) постепенно приближаются к заранее заданной цели. В конце они либо успешно находят ответ, либо останавливаются после выхода за границы.</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   Стратегии оптимизации хеширования","text":"<p>В алгоритмических задачах мы часто заменяем линейный поиск на хеш-поиск, чтобы уменьшить временную сложность алгоритма. Разберем одну задачу, чтобы лучше понять этот прием.</p> <p>Question</p> <p>Дан массив целых чисел <code>nums</code> и целевой элемент <code>target</code> . Найдите в массиве два элемента, сумма которых равна <code>target</code> , и верните их индексы. Подойдет любой корректный ответ.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   Линейный поиск: обмен времени на пространство","text":"<p>Рассмотрим прямой перебор всех возможных комбинаций. Как показано на рисунке 10-9, мы запускаем два вложенных цикла и на каждом шаге проверяем, равна ли сумма двух целых чисел <code>target</code> ; если да, то возвращаем их индексы.</p> <p></p> <p> Рисунок 10-9   Линейный поиск для задачи о двух суммах </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Метод 1: полный перебор\"\"\"\n    # Два вложенных цикла, временная сложность O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Метод 1: полный перебор */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Метод 1: полный перебор */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Метод 1: полный перебор */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Метод 1: полный перебор */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Метод 1: полный перебор */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Метод 1: полный перебор */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Метод 1: полный перебор */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Способ 1: полный перебор */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Два вложенных цикла, временная сложность O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Метод 1: полный перебор */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Метод 1: полный перебор */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Метод 1: полный перебор */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Метод 1: полный перебор ###\ndef two_sum_brute_force(nums, target)\n  # Два вложенных цикла, временная сложность O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Временная сложность этого метода равна \\(O(n^2)\\) , а пространственная сложность равна \\(O(1)\\) , поэтому на больших объемах данных он очень медленный.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042-","level":2,"title":"10.4.2   Хеш-поиск: обмен пространства на время","text":"<p>Рассмотрим вариант с использованием хеш-таблицы, где ключами и значениями будут элементы массива и их индексы. При циклическом обходе массива на каждом шаге выполняются действия, показанные на рисунке 10-10.</p> <ol> <li>Проверить, находится ли число <code>target - nums[i]</code> в хеш-таблице; если да, то сразу вернуть индексы этих двух элементов.</li> <li>Добавить в хеш-таблицу пару из ключа <code>nums[i]</code> и индекса <code>i</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> Рисунок 10-10   Вспомогательная хеш-таблица для задачи о двух суммах </p> <p>Код реализации показан ниже, и для него достаточно одного цикла:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Метод 2: вспомогательная хеш-таблица\"\"\"\n    # Вспомогательная хеш-таблица, пространственная сложность O(n)\n    dic = {}\n    # Один цикл, временная сложность O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    hashTable := map[int]int{}\n    // Один цикл, временная сложность O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    var dic: [Int: Int] = [:]\n    // Один цикл, временная сложность O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunction twoSumHashTable(nums, target) {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let m = {};\n    // Один цикл, временная сложность O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // Один цикл, временная сложность O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Способ 2: вспомогательная хеш-таблица */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Вспомогательная хеш-таблица, пространственная сложность O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // Один цикл, временная сложность O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Метод 2: вспомогательная хеш-таблица */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let mut dic = HashMap::new();\n    // Один цикл, временная сложность O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Хеш-таблица */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Реализовано на основе uthash.h\n} HashTable;\n\n/* Поиск в хеш-таблице */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* Вставка элемента в хеш-таблицу */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* Метод 2: вспомогательная хеш-таблица */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // Один цикл, временная сложность O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Метод 2: вспомогательная хеш-таблица ###\ndef two_sum_hash_table(nums, target)\n  # Вспомогательная хеш-таблица, пространственная сложность O(n)\n  dic = {}\n  # Один цикл, временная сложность O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Благодаря хеш-поиску этот метод снижает временную сложность с \\(O(n^2)\\) до \\(O(n)\\) , существенно повышая эффективность работы.</p> <p>Поскольку требуется поддерживать дополнительную хеш-таблицу, пространственная сложность составляет \\(O(n)\\) . Несмотря на это, в целом данный метод лучше сбалансирован по времени и памяти, поэтому именно он является оптимальным решением этой задачи.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   Переосмысление алгоритмов поиска","text":"<p>Алгоритмы поиска (searching algorithm) используются для того, чтобы находить один или несколько элементов, удовлетворяющих определенным условиям, в структурах данных, таких как массивы, списки, деревья или графы.</p> <p>Алгоритмы поиска можно разделить на две категории по способу реализации.</p> <ul> <li>Поиск целевого элемента путем обхода структуры данных, например обход массива, списка, дерева или графа.</li> <li>Эффективный поиск элементов с использованием структуры организации данных или априорной информации, например двоичный поиск, хеш-поиск и поиск в двоичном дереве поиска.</li> </ul> <p>Нетрудно заметить, что эти темы уже рассматривались в предыдущих главах, поэтому алгоритмы поиска нам уже знакомы. В этом разделе мы систематизируем полученные ранее знания и еще раз посмотрим на них как на единую группу методов.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   Полный перебор","text":"<p>Полный перебор заключается в том, что мы обходим каждый элемент структуры данных, чтобы найти целевой элемент.</p> <ul> <li>\"Линейный поиск\" применяется к линейным структурам данных, таким как массивы и списки. Он начинается с одного конца структуры данных и последовательно проверяет элементы, пока не найдет целевой элемент или пока не достигнет другого конца структуры данных.</li> <li>\"Обход в ширину\" и \"обход в глубину\" - это две стратегии обхода графов и деревьев. Обход в ширину стартует из начального узла и исследует все узлы текущего уровня, прежде чем переходить к следующему. Обход в глубину стартует из начального узла, проходит один путь до конца, затем возвращается назад и пробует другие пути, пока не будет полностью пройдена вся структура данных.</li> </ul> <p>Преимущество полного перебора состоит в его простоте и универсальности, поскольку он не требует предварительной обработки данных и использования дополнительных структур данных.</p> <p>Однако временная сложность таких алгоритмов равна \\(O(n)\\) , где \\(n\\) - число элементов, поэтому при больших объемах данных их производительность невысока.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   Адаптивный поиск","text":"<p>Адаптивный поиск использует специфические свойства данных (например, упорядоченность), чтобы оптимизировать процесс поиска и тем самым эффективнее находить целевой элемент.</p> <ul> <li>\"Двоичный поиск\" использует упорядоченность данных для эффективного поиска и применим только к массивам.</li> <li>\"Хеш-поиск\" использует хеш-таблицу для построения отображения между поисковыми данными и целевыми данными, благодаря чему запросы выполняются эффективно.</li> <li>\"Поиск в дереве\" ведется в конкретной древовидной структуре (например, в двоичном дереве поиска) и позволяет быстро отсекать узлы на основе сравнения значений, чтобы найти цель.</li> </ul> <p>Преимущество этих алгоритмов заключается в высокой эффективности: их временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) .</p> <p>Однако для использования таких алгоритмов обычно требуется предварительная обработка данных. Например, для двоичного поиска нужно заранее отсортировать массив, а хеш-поиск и поиск в дереве требуют дополнительных структур данных, поддержание которых тоже отнимает время и память.</p> <p>Tip</p> <p>Адаптивные алгоритмы поиска часто называют алгоритмами поиска в узком смысле, поскольку они в основном предназначены для быстрого нахождения целевого элемента в конкретной структуре данных.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   Выбор метода поиска","text":"<p>Для поиска целевого элемента в наборе данных размера \\(n\\) можно использовать линейный поиск, двоичный поиск, поиск в дереве, хеш-поиск и другие методы. Принципы работы этих методов показаны на рисунке 10-11.</p> <p></p> <p> Рисунок 10-11   Различные стратегии поиска </p> <p>Эффективность и особенности перечисленных методов приведены в таблице 10-1.</p> <p> Таблица 10-1   Сравнение эффективности алгоритмов поиска </p> Линейный поиск Двоичный поиск Поиск в дереве Хеш-поиск Поиск элемента \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) Вставка элемента \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Дополнительное пространство \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) Предварительная обработка / Сортировка \\(O(n \\log n)\\) Построение дерева \\(O(n \\log n)\\) Построение хеш-таблицы \\(O(n)\\) Упорядоченность данных Не требуется Требуется Требуется Не требуется <p>Выбор алгоритма поиска также зависит от масштаба данных, требований к производительности поиска, а также частоты запросов и обновлений данных.</p> <p>Линейный поиск</p> <ul> <li>Обладает хорошей универсальностью и не требует никакой предварительной обработки данных. Если нужно выполнить только один запрос, то время предварительной обработки для остальных трех методов окажется больше, чем время линейного поиска.</li> <li>Подходит для небольших объемов данных, потому что в этом случае влияние временной сложности на эффективность невелико.</li> <li>Подходит для сценариев с высокой частотой обновления данных, поскольку этот метод не требует никакого дополнительного обслуживания данных.</li> </ul> <p>Двоичный поиск</p> <ul> <li>Подходит для больших наборов данных и демонстрирует стабильную эффективность; его худшая временная сложность равна \\(O(\\log n)\\) .</li> <li>Объем данных не должен быть слишком большим, потому что массив требует непрерывного участка памяти.</li> <li>Не подходит для сценариев с частыми вставками и удалениями данных, так как поддержание массива в отсортированном виде требует больших затрат.</li> </ul> <p>Хеш-поиск</p> <ul> <li>Подходит для сценариев, в которых требования к скорости запросов очень высоки; средняя временная сложность равна \\(O(1)\\) .</li> <li>Не подходит для сценариев, где требуется упорядоченность данных или поиск по диапазону, потому что хеш-таблица не умеет поддерживать порядок данных.</li> <li>Сильно зависит от хеш-функции и стратегии обработки коллизий, поэтому риск деградации производительности сравнительно велик.</li> <li>Не подходит для слишком больших объемов данных, так как хеш-таблице требуется дополнительное пространство, чтобы максимально снизить число коллизий и обеспечить хорошую производительность поиска.</li> </ul> <p>Поиск в дереве</p> <ul> <li>Подходит для очень больших объемов данных, потому что узлы дерева распределены в памяти и не требуют непрерывного хранения.</li> <li>Подходит для сценариев, где нужно поддерживать упорядоченные данные или выполнять поиск по диапазону.</li> <li>В процессе постоянных вставок и удалений узлов двоичное дерево поиска может перекоситься, и тогда временная сложность деградирует до \\(O(n)\\) .</li> <li>Если использовать AVL-дерево или красно-черное дерево, то все операции могут стабильно выполняться за \\(O(\\log n)\\) , но поддержание баланса дерева увеличивает дополнительные накладные расходы.</li> </ul>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   Резюме","text":"","path":["Глава 10. Поиск","10.6 &nbsp; Резюме"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Двоичный поиск опирается на упорядоченность данных и выполняет поиск путем циклического сокращения интервала вдвое. Он требует упорядоченных входных данных и подходит только для массивов или структур данных, реализованных на их основе.</li> <li>Полный перебор находит данные путем обхода структуры данных. Линейный поиск подходит для массивов и списков, а обход в ширину и обход в глубину подходят для графов и деревьев. Эти алгоритмы универсальны и не требуют предварительной обработки данных, но их временная сложность \\(O(n)\\) сравнительно велика.</li> <li>Хеш-поиск, поиск в дереве и двоичный поиск относятся к эффективным методам поиска и позволяют быстро находить целевой элемент в конкретных структурах данных. Такие алгоритмы обладают высокой эффективностью, их временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) , но обычно им нужны дополнительные структуры данных.</li> <li>На практике нужно анализировать размер данных, требования к производительности поиска, а также частоту запросов и обновлений данных, чтобы выбрать подходящий метод поиска.</li> <li>Линейный поиск подходит для небольших или часто обновляемых наборов данных; двоичный поиск - для больших отсортированных данных; хеш-поиск - для сценариев с высокими требованиями к скорости запросов и без необходимости поиска по диапазону; поиск в дереве - для больших динамических данных, где нужно поддерживать порядок и выполнять диапазонные запросы.</li> <li>Замена линейного поиска на хеш-поиск - это распространенная стратегия ускорения, которая позволяет снизить временную сложность с \\(O(n)\\) до \\(O(1)\\) .</li> </ul>","path":["Глава 10. Поиск","10.6 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"Глава 11.   Сортировка","text":"<p>Abstract</p> <p>Сортировка упорядочивает хаотичные данные и позволяет быстрее находить закономерности.</p> <p>За кажущейся простотой скрывается целая группа алгоритмов с разными достоинствами и ограничениями.</p>","path":["Глава 11. Сортировка","Глава 11. &nbsp; Сортировка"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>11.1   Алгоритмы сортировки</li> <li>11.2   Сортировка выбором</li> <li>11.3   Пузырьковая сортировка</li> <li>11.4   Сортировка вставкой</li> <li>11.5   Быстрая сортировка</li> <li>11.6   Сортировка слиянием</li> <li>11.7   Пирамидальная сортировка</li> <li>11.8   Блочная сортировка</li> <li>11.9   Сортировка подсчетом</li> <li>11.10   Поразрядная сортировка</li> <li>11.11   Резюме</li> </ul>","path":["Глава 11. Сортировка","Глава 11. &nbsp; Сортировка"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   Сортировка пузырьком","text":"<p>Сортировка пузырьком (bubble sort) реализует сортировку путем последовательного сравнения и обмена соседних элементов. Этот процесс напоминает всплытие пузырьков снизу вверх, откуда и произошло название алгоритма.</p> <p>Как показано на рисунке 11-4, процесс \"всплытия\" можно смоделировать через операцию обмена элементов: начиная от левого края массива и двигаясь вправо, мы последовательно сравниваем соседние элементы и, если \"левый элемент &gt; правый элемент\", меняем их местами. После завершения прохода максимальный элемент будет перемещен в самый правый конец массива.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-4   Моделирование пузырька через обмен элементов </p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   Алгоритм","text":"<p>Пусть длина массива равна \\(n\\) ; тогда шаги сортировки пузырьком показаны на рисунке 11-5.</p> <ol> <li>Сначала выполнить один проход \"всплытия\" по \\(n\\) элементам, переместив максимальный элемент массива на правильную позицию.</li> <li>Затем выполнить \"всплытие\" по оставшимся \\(n - 1\\) элементам, переместив второй по величине элемент на правильную позицию.</li> <li>Продолжать по аналогии; после \\(n - 1\\) раундов \"всплытия\" первые \\(n - 1\\) по величине элементы окажутся на правильных позициях.</li> <li>Оставшийся единственный элемент обязательно является минимальным, сортировать его уже не нужно, поэтому сортировка завершена.</li> </ol> <p></p> <p> Рисунок 11-5   Процесс сортировки пузырьком </p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"Пузырьковая сортировка\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(n - 1, 0, -1):\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                // Здесь используется функция std::swap()\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Пузырьковая сортировка */\nvoid BubbleSort(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Пузырьковая сортировка */\nfunc bubbleSort(nums []int) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Пузырьковая сортировка */\nfunc bubbleSort(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Пузырьковая сортировка */\nfunction bubbleSort(nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Пузырьковая сортировка */\nfunction bubbleSort(nums: number[]): void {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Пузырьковая сортировка */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(int nums[], int size) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Пузырьковая сортировка */\nfun bubbleSort(nums: IntArray) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Пузырьковая сортировка ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   Оптимизация эффективности","text":"<p>Если в каком-либо раунде \"всплытия\" не произошло ни одного обмена, значит, массив уже отсортирован и можно сразу вернуть результат. Поэтому можно добавить флаг <code>flag</code> для отслеживания этой ситуации и немедленного выхода.</p> <p>После такой оптимизации худшая и средняя временные сложности сортировки пузырьком по-прежнему равны \\(O(n^2)\\) ; однако если входной массив уже полностью упорядочен, достигается лучшая временная сложность \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"Пузырьковая сортировка (оптимизация флагом)\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # Инициализировать флаг\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # Записать обмен элементов\n        if not flag:\n            break  # На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n</code></pre> bubble_sort.cpp<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                // Здесь используется функция std::swap()\n                swap(nums[j], nums[j + 1]);\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag)\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag)\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid BubbleSortWithFlag(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // Записать обмен элементов\n            }\n        }\n        if (!flag) break;     // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunc bubbleSortWithFlag(nums []int) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // Записать обмен элементов\n            }\n        }\n        if flag == false { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // Инициализировать флаг\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // Записать обмен элементов\n            }\n        }\n        if !flag { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunction bubbleSortWithFlag(nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // Инициализировать флаг\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // Записать обмен элементов\n      }\n    }\n    if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if !flag {\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // Записать обмен элементов\n            }\n        }\n        if (!flag) break // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Пузырьковая сортировка ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n\n# ## Пузырьковая сортировка (оптимизация флагом) ###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # Инициализировать флаг\n\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # Записать обмен элементов\n      end\n    end\n\n    break unless flag # На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), алгоритм адаптивен: длины диапазонов, проходящих \"всплытие\" в разных раундах, последовательно равны \\(n - 1\\), \\(n - 2\\), \\(\\dots\\), \\(2\\), \\(1\\) , а их сумма равна \\((n - 1) n / 2\\) . После добавления оптимизации с <code>flag</code> лучшая временная сложность может достигать \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Стабильная сортировка: поскольку при \"всплытии\" равные элементы не обмениваются местами.</li> </ul>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   Блочная сортировка","text":"<p>Рассмотренные выше алгоритмы сортировки относятся к \"сортировкам на основе сравнений\": они упорядочивают данные, сравнивая элементы друг с другом. Временная сложность таких алгоритмов не может быть лучше \\(O(n \\log n)\\) . Далее мы рассмотрим несколько \"сортировок без сравнений\", чья временная сложность может достигать линейного порядка.</p> <p>Блочная сортировка (bucket sort) является типичным применением стратегии \"разделяй и властвуй\". Она создает набор упорядоченных по величине блоков, где каждый блок соответствует определенному диапазону данных; затем элементы равномерно распределяются по этим блокам, внутри каждого блока отдельно выполняется сортировка, а в конце результаты объединяются в порядке блоков.</p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   Алгоритм","text":"<p>Рассмотрим массив длины \\(n\\), элементы которого являются числами с плавающей запятой из диапазона \\([0, 1)\\) . Процесс блочной сортировки показан на рисунке 11-13.</p> <ol> <li>Инициализировать \\(k\\) блоков и распределить \\(n\\) элементов по этим \\(k\\) блокам.</li> <li>Отсортировать каждый блок по отдельности (здесь используется встроенная функция сортировки языка программирования).</li> <li>Объединить результаты в порядке следования блоков от меньшего к большему.</li> </ol> <p></p> <p> Рисунок 11-13   Процесс блочной сортировки </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"Сортировка корзинами\"\"\"\n    # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. Распределить элементы массива по корзинам\n    for num in nums:\n        # Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        i = int(num * k)\n        # Добавить num в корзину i\n        buckets[i].append(num)\n    # 2. Выполнить сортировку внутри каждой корзины\n    for bucket in buckets:\n        # Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort()\n    # 3. Обойти корзины и объединить результаты\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* Сортировка корзинами */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. Распределить элементы массива по корзинам\n    for (float num : nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = num * k;\n        // Добавить num в корзину bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. Обойти корзины и объединить результаты\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* Сортировка корзинами */\nvoid bucketSort(float[] nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (float num : nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = (int) (num * k);\n        // Добавить num в корзину i\n        buckets.get(i).add(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (List&lt;Float&gt; bucket : buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        Collections.sort(bucket);\n    }\n    // 3. Обойти корзины и объединить результаты\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* Сортировка корзинами */\nvoid BucketSort(float[] nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    foreach (float num in nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = (int)(num * k);\n        // Добавить num в корзину i\n        buckets[i].Add(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.Sort();\n    }\n    // 3. Обойти корзины и объединить результаты\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* Сортировка корзинами */\nfunc bucketSort(nums []float64) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. Распределить элементы массива по корзинам\n    for _, num := range nums {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        i := int(num * float64(k))\n        // Добавить num в корзину i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for i := 0; i &lt; k; i++ {\n        // Использовать встроенную функцию сортировки среза; ее также можно заменить другим алгоритмом сортировки\n        sort.Float64s(buckets[i])\n    }\n    // 3. Обойти корзины и объединить результаты\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* Сортировка корзинами */\nfunc bucketSort(nums: inout [Double]) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. Распределить элементы массива по корзинам\n    for num in nums {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        let i = Int(num * Double(k))\n        // Добавить num в корзину i\n        buckets[i].append(num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for i in buckets.indices {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        buckets[i].sort()\n    }\n    // 3. Обойти корзины и объединить результаты\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* Сортировка корзинами */\nfunction bucketSort(nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (const num of nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        const i = Math.floor(num * k);\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (const bucket of buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Обойти корзины и объединить результаты\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* Сортировка корзинами */\nfunction bucketSort(nums: number[]): void {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (const num of nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        const i = Math.floor(num * k);\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (const bucket of buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Обойти корзины и объединить результаты\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* Сортировка корзинами */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. Распределить элементы массива по корзинам\n  for (double _num in nums) {\n    // Входные данные находятся в диапазоне [0, 1), используем _num * k для отображения в диапазон индексов [0, k-1]\n    int i = (_num * k).toInt();\n    // Добавить _num в корзину bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. Выполнить сортировку внутри каждой корзины\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. Обойти корзины и объединить результаты\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* Сортировка корзинами */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. Распределить элементы массива по корзинам\n    for &amp;num in nums.iter() {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        let i = (num * k as f64) as usize;\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for bucket in &amp;mut buckets {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. Обойти корзины и объединить результаты\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* Сортировка корзинами */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // Инициализировать k = n/2 корзин\n    int *sizes = malloc(k * sizeof(int));          // Записать размер каждой корзины\n    float **buckets = malloc(k * sizeof(float *)); // Массив динамических массивов (корзины)\n    // Предварительно выделить достаточно места для каждой корзины\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. Объединить отсортированные корзины\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // Освободить память\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* Сортировка корзинами */\nfun bucketSort(nums: FloatArray) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (num in nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        val i = (num * k).toInt()\n        // Добавить num в корзину i\n        buckets[i].add(num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (bucket in buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort()\n    }\n    // 3. Обойти корзины и объединить результаты\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### Сортировка корзинами ###\ndef bucket_sort(nums)\n  # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. Распределить элементы массива по корзинам\n  nums.each do |num|\n    # Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n    i = (num * k).to_i\n    # Добавить num в корзину i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. Выполнить сортировку внутри каждой корзины\n  buckets.each do |bucket|\n    # Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n    bucket.sort!\n  end\n\n  # 3. Обойти корзины и объединить результаты\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   Характеристики алгоритма","text":"<p>Блочная сортировка подходит для обработки очень больших объемов данных. Например, если вход содержит 1 миллион элементов и из-за ограничений памяти система не может загрузить их все сразу, можно разбить данные на 1000 блоков, отсортировать каждый блок отдельно, а затем объединить результаты.</p> <ul> <li>Временная сложность равна \\(O(n + k)\\) : если элементы распределены по блокам равномерно, то в каждом блоке будет \\(\\frac{n}{k}\\) элементов. Если сортировка одного блока требует \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) времени, то сортировка всех блоков потребует \\(O(n \\log\\frac{n}{k})\\) времени. Когда число блоков \\(k\\) достаточно велико, временная сложность приближается к \\(O(n)\\) . На объединение результатов требуется \\(O(n + k)\\) времени, потому что нужно пройти по всем блокам и элементам. В худшем случае все данные попадут в один блок, и если сортировка этого блока использует \\(O(n^2)\\) времени, общая сложность также станет \\(O(n^2)\\) .</li> <li>Пространственная сложность равна \\(O(n + k)\\), сортировка не выполняется на месте: требуются дополнительные блоки в количестве \\(k\\) и место для всех \\(n\\) элементов внутри них.</li> <li>Является ли блочная сортировка стабильной, зависит от того, стабилен ли алгоритм сортировки внутри каждого блока.</li> </ul>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   Как добиться равномерного распределения","text":"<p>Теоретически временная сложность блочной сортировки может достигать \\(O(n)\\) ; ключ к этому - как можно более равномерно распределить элементы по блокам. На практике данные часто распределены неравномерно. Например, если нужно распределить все товары на маркетплейсе по 10 ценовым блокам, количество товаров дешевле 100 рублей может быть очень большим, а товаров дороже 1000 рублей - очень маленьким. Если просто разбить диапазон цен на 10 равных частей, число товаров в каждом блоке будет сильно различаться.</p> <p>Чтобы добиться более равномерного распределения, можно сначала задать грубую линию раздела и приблизительно распределить данные по 3 блокам. После этого блоки с большим числом товаров можно снова делить на 3 блока и продолжать процесс до тех пор, пока число элементов в каждом блоке не станет примерно одинаковым.</p> <p>Как показано на рисунке 11-14, по сути этот метод строит рекурсивное дерево, цель которого - сделать значения в листьях как можно более равномерными. Конечно, совсем не обязательно каждый раз делить данные именно на 3 блока; конкретную схему разбиения можно выбирать в зависимости от свойств данных.</p> <p></p> <p> Рисунок 11-14   Рекурсивное разбиение по блокам </p> <p>Если нам заранее известна вероятностная модель распределения цен товаров, то границы цен для каждого блока можно задавать в соответствии с этим распределением. Важно отметить, что фактическое распределение данных не обязательно специально измерять - его можно приблизить некоторой вероятностной моделью исходя из свойств данных.</p> <p>Как показано на рисунке 11-15, если предположить, что цены товаров подчиняются нормальному распределению, то можно разумно задать интервалы цен и тем самым распределить товары по блокам достаточно равномерно.</p> <p></p> <p> Рисунок 11-15   Разбиение блоков по вероятностному распределению </p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   Сортировка подсчетом","text":"<p>Сортировка подсчетом (counting sort) реализует сортировку за счет подсчета количества вхождений элементов и обычно используется для массивов целых чисел.</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   Простая реализация","text":"<p>Сначала рассмотрим простой пример. Дан массив <code>nums</code> длины \\(n\\) , элементы которого являются \"неотрицательными целыми числами\". Общий процесс сортировки подсчетом показан на рисунке 11-16.</p> <ol> <li>Пройти по массиву, найти в нем максимальное число, обозначить его как \\(m\\) , а затем создать вспомогательный массив <code>counter</code> длины \\(m + 1\\) .</li> <li>С помощью <code>counter</code> подсчитать, сколько раз каждое число встречается в <code>nums</code>; при этом <code>counter[num]</code> хранит число вхождений значения <code>num</code> . Делается это просто: достаточно пройти по <code>nums</code> (пусть текущее число равно <code>num</code> ) и на каждом шаге увеличить <code>counter[num]</code> на \\(1\\) .</li> <li>Поскольку индексы массива <code>counter</code> изначально упорядочены, можно считать, что все числа уже отсортированы. Далее остается пройти по <code>counter</code> и в соответствии с числом вхождений записать значения обратно в <code>nums</code> в порядке возрастания.</li> </ol> <p></p> <p> Рисунок 11-16   Процесс сортировки подсчетом </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"Сортировка подсчетом\"\"\"\n    # Простая реализация, не подходит для сортировки объектов\n    # 1. Найти максимальный элемент массива m\n    m = max(nums)\n    # 2. Подсчитать число появлений каждой цифры\n    # counter[num] обозначает число появлений num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Обойти counter и заполнить исходный массив nums элементами\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid CountingSortNaive(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunc countingSortNaive(nums []int) {\n    // 1. Найти максимальный элемент массива m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. Найти максимальный элемент массива m\n    let m = nums.max()!\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunction countingSortNaive(nums) {\n    // 1. Найти максимальный элемент массива m\n    let m = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunction countingSortNaive(nums: number[]): void {\n    // 1. Найти максимальный элемент массива m\n    let m: number = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. Найти максимальный элемент массива m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Подсчитать число появлений каждой цифры\n  // counter[_num] обозначает число появлений _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Обойти counter и заполнить исходный массив nums элементами\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. Найти максимальный элемент массива m\n    let m = *nums.iter().max().unwrap();\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(int nums[], int size) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. Освободить память\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfun countingSortNaive(nums: IntArray) {\n    // 1. Найти максимальный элемент массива m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Сортировка подсчетом ###\ndef counting_sort_naive(nums)\n  # Простая реализация, не подходит для сортировки объектов\n  # 1. Найти максимальный элемент массива m\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. Подсчитать число появлений каждой цифры\n  # counter[num] обозначает число появлений num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Обойти counter и заполнить исходный массив nums элементами\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Связь между сортировкой подсчетом и блочной сортировкой</p> <p>Если посмотреть на сортировку подсчетом с точки зрения блочной сортировки, то каждый индекс массива <code>counter</code> можно рассматривать как отдельный блок, а процесс подсчета - как распределение элементов по соответствующим блокам. Иными словами, сортировка подсчетом является частным случаем блочной сортировки для целочисленных данных.</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   Полная реализация","text":"<p>Внимательный читатель мог заметить, что если входные данные представлены объектами, то описанный выше шаг <code>3.</code> перестает работать. Например, если входными данными являются объекты товаров и мы хотим отсортировать их по цене (полю класса), то описанный алгоритм сможет выдать только отсортированный ряд цен, но не исходные объекты в нужном порядке.</p> <p>Как же получить корректный порядок исходных данных? Сначала вычислим \"префиксную сумму\" массива <code>counter</code> . Как следует из названия, префиксная сумма в индексе <code>i</code> , обозначаемая как <code>prefix[i]</code> , равна сумме первых <code>i</code> элементов массива:</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>Префиксная сумма имеет четкий смысл: <code>prefix[num] - 1</code> обозначает индекс последнего вхождения элемента <code>num</code> в результирующем массиве <code>res</code>. Это очень важная информация, потому что она указывает, в какую позицию результирующего массива должен попасть каждый элемент. Далее мы проходим исходный массив <code>nums</code> в обратном порядке и на каждой итерации для очередного элемента <code>num</code> выполняем два действия.</p> <ol> <li>Записать <code>num</code> в массив <code>res</code> по индексу <code>prefix[num] - 1</code> .</li> <li>Уменьшить префиксную сумму <code>prefix[num]</code> на \\(1\\) , чтобы получить индекс следующего размещения элемента <code>num</code> .</li> </ol> <p>После завершения прохода массив <code>res</code> будет содержать отсортированный результат; остается только переписать <code>res</code> обратно в <code>nums</code> . Полный процесс сортировки подсчетом показан на рисунке 11-17.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-17   Шаги сортировки подсчетом </p> <p>Код реализации сортировки подсчетом приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"Сортировка подсчетом\"\"\"\n    # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\n    # 1. Найти максимальный элемент массива m\n    m = max(nums)\n    # 2. Подсчитать число появлений каждой цифры\n    # counter[num] обозначает число появлений num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    # То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    # Инициализировать массив res для хранения результата\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # Поместить num по соответствующему индексу\n        counter[num] -= 1  # Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    # Перезаписать исходный массив nums массивом результата res\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--;              // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid CountingSort(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunc countingSort(nums []int) {\n    // 1. Найти максимальный элемент массива m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // Поместить num по соответствующему индексу\n        res[counter[num]-1] = num\n        // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n        counter[num]--\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunc countingSort(nums: inout [Int]) {\n    // 1. Найти максимальный элемент массива m\n    let m = nums.max()!\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // Поместить num по соответствующему индексу\n        counter[num] -= 1 // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunction countingSort(nums) {\n    // 1. Найти максимальный элемент массива m\n    let m = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunction countingSort(nums: number[]): void {\n    // 1. Найти максимальный элемент массива m\n    let m: number = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. Найти максимальный элемент массива m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Подсчитать число появлений каждой цифры\n  // counter[_num] обозначает число появлений _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n  // То есть counter[_num]-1 — это индекс последнего появления _num в res\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n  // Инициализировать массив res для хранения результата\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // Поместить _num по соответствующему индексу\n    counter[_num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения _num\n  }\n  // Перезаписать исходный массив nums массивом результата res\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. Найти максимальный элемент массива m\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num as usize] -= 1; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(int nums[], int size) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--;              // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    memcpy(nums, res, size * sizeof(int));\n    // 5. Освободить память\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfun countingSort(nums: IntArray) {\n    // 1. Найти максимальный элемент массива m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // Поместить num по соответствующему индексу\n        counter[num]-- // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Сортировка подсчетом ###\ndef counting_sort(nums)\n  # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\n  # 1. Найти максимальный элемент массива m\n  m = nums.max\n  # 2. Подсчитать число появлений каждой цифры\n  # counter[num] обозначает число появлений num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n  # То есть counter[num]-1 — это индекс последнего появления num в res\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n  # Инициализировать массив res для хранения результата\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # Поместить num по соответствующему индексу\n    counter[num] -= 1 # Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n  end\n  # Перезаписать исходный массив nums массивом результата res\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n + m)\\), алгоритм не является адаптивным : необходимо пройти по <code>nums</code> и по <code>counter</code> , а оба этих прохода занимают линейное время. Обычно выполняется \\(n \\gg m\\) , поэтому временная сложность стремится к \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(n + m)\\), сортировка не выполняется на месте: используются массивы <code>res</code> и <code>counter</code> длины \\(n\\) и \\(m\\) соответственно.</li> <li>Стабильная сортировка: порядок заполнения <code>res</code> идет \"справа налево\", поэтому обратный проход по <code>nums</code> позволяет сохранить относительный порядок равных элементов и тем самым реализовать стабильную сортировку. Вообще говоря, прямой проход по <code>nums</code> тоже даст правильный результат сортировки, но он будет нестабильным.</li> </ul>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   Ограничения","text":"<p>На этом этапе сортировка подсчетом может показаться очень изящной: она позволяет эффективно сортировать данные, опираясь только на подсчет числа вхождений. Однако условия ее применения довольно строгие.</p> <p>Сортировка подсчетом применима только к неотрицательным целым числам. Чтобы использовать ее для других типов данных, нужно убедиться, что эти данные можно преобразовать в неотрицательные целые числа и что при преобразовании относительный порядок элементов не изменится. Например, для массива целых чисел с отрицательными значениями можно сначала прибавить ко всем числам константу, превратив их в положительные, затем выполнить сортировку и после этого преобразовать значения обратно.</p> <p>Сортировка подсчетом подходит для случаев, когда объем данных велик, но диапазон значений невелик. Например, в приведенном выше примере \\(m\\) не должно быть слишком большим, иначе будет занято слишком много памяти. А когда \\(n \\ll m\\) , сортировка подсчетом использует \\(O(m)\\) времени и может оказаться медленнее, чем алгоритмы сортировки с \\(O(n \\log n)\\) .</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   Пирамидальная сортировка","text":"<p>Tip</p> <p>Перед чтением этого раздела убедитесь, что вы уже изучили главу \"Куча\".</p> <p>Пирамидальная сортировка (heap sort) - это эффективный алгоритм сортировки, основанный на структуре данных \"куча\". Для его реализации можно использовать уже изученные нами \"построение кучи\" и \"извлечение элементов из кучи\".</p> <ol> <li>Подать на вход массив и построить из него мин-кучу; в этот момент минимальный элемент будет находиться в вершине кучи.</li> <li>Непрерывно выполнять извлечение из кучи и по порядку записывать извлеченные элементы - так получится последовательность, отсортированная по возрастанию.</li> </ol> <p>Хотя этот метод и работоспособен, он требует дополнительного массива для хранения извлеченных элементов и потому расходует лишнюю память. На практике обычно используют более изящную реализацию.</p>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   Алгоритм","text":"<p>Пусть длина массива равна \\(n\\) ; тогда процесс пирамидальной сортировки показан на рисунке 11-12.</p> <ol> <li>Подать на вход массив и построить из него макс-кучу. После этого максимальный элемент окажется в вершине кучи.</li> <li>Обменять элемент в вершине кучи (первый элемент) с элементом внизу кучи (последний элемент). После обмена длина кучи уменьшается на \\(1\\) , а число уже отсортированных элементов увеличивается на \\(1\\) .</li> <li>Начиная с вершины, выполнить операцию просеивания сверху вниз. После этого свойство кучи будет восстановлено.</li> <li>Циклически повторять шаг <code>2.</code> и шаг <code>3.</code> . После \\(n - 1\\) раундов массив будет полностью отсортирован.</li> </ol> <p>Tip</p> <p>На самом деле операция извлечения из кучи тоже включает шаг <code>2.</code> и шаг <code>3.</code> , только дополнительно содержит действие по удалению элемента.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-12   Шаги пирамидальной сортировки </p> <p>В коде используется та же функция просеивания сверху вниз <code>sift_down()</code>, что и в главе \"Куча\". Важно помнить, что длина кучи уменьшается по мере извлечения максимального элемента, поэтому функции <code>sift_down()</code> нужно передавать параметр длины \\(n\\) , чтобы указать текущую действительную длину кучи. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз\"\"\"\n    while True:\n        # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i:\n            break\n        # Поменять два узла местами\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # Циклическое просеивание вниз\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"Сортировка кучей\"\"\"\n    # Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in range(len(nums) - 1, 0, -1):\n        # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums[0], nums[i] = nums[i], nums[0]\n        # Начиная с корневого узла, выполнить просеивание сверху вниз\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(nums[i], nums[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        swap(nums[0], nums[i]);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(int[] nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid HeapSort(int[] nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfunc heapSort(nums *[]int) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        nums.swapAt(i, ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfunc heapSort(nums: inout [Int]) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in nums.indices.dropFirst().reversed() {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums.swapAt(0, i)\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) {\n            break;\n        }\n        // Поменять два узла местами\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfunction heapSort(nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) {\n            break;\n        }\n        // Поменять два узла местами\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfunction heapSort(nums: number[]): void {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    if (ma == i) break;\n    // Поменять два узла местами\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // Циклическое просеивание вниз\n    i = ma;\n  }\n}\n\n/* Сортировка кучей */\nvoid heapSort(List&lt;int&gt; nums) {\n  // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // Извлекать максимальный элемент из кучи в течение n-1 итераций\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // Начиная с корневого узла, выполнить просеивание сверху вниз\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break;\n        }\n        // Поменять два узла местами\n        nums.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in (1..nums.len()).rev() {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums.swap(0, i);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) {\n            break;\n        }\n        // Поменять два узла местами\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(int nums[], int n) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = n - 1; i &gt; 0; --i) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) \n            break\n        // Поменять два узла местами\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfun heapSort(nums: IntArray) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (i in nums.size - 1 downTo 1) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###\ndef sift_down(nums, n, i)\n  while true\n    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    break if ma == i\n    # Поменять два узла местами\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # Циклическое просеивание вниз\n    i = ma\n  end\nend\n\n### Сортировка кучей ###\ndef heap_sort(nums)\n  # Построение кучи: выполнить heapify для всех узлов, кроме листовых\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # Извлекать максимальный элемент из кучи в течение n-1 итераций\n  (nums.length - 1).downto(1) do |i|\n    # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    nums[0], nums[i] = nums[i], nums[0]\n    # Начиная с корневого узла, выполнить просеивание сверху вниз\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: построение кучи занимает \\(O(n)\\) времени. Извлечение максимального элемента из кучи имеет временную сложность \\(O(\\log n)\\) и выполняется \\(n - 1\\) раз.</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: несколько переменных-указателей используют \\(O(1)\\) памяти. Обмен элементов и операции просеивания выполняются прямо в исходном массиве.</li> <li>Нестабильная сортировка: при обмене вершины кучи и нижнего элемента относительный порядок равных элементов может измениться.</li> </ul>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   Сортировка вставками","text":"<p>Сортировка вставками (insertion sort) - это простой алгоритм сортировки, принцип которого очень похож на ручную сортировку карт в колоде.</p> <p>Точнее говоря, в неотсортированном диапазоне выбирается опорный элемент, после чего он сравнивается с элементами слева в уже отсортированном диапазоне и вставляется в правильную позицию.</p> <p>На рисунке 11-6 показан процесс вставки элемента в массив. Пусть опорный элемент обозначен как <code>base</code> ; нам нужно сдвинуть все элементы от целевого индекса до <code>base</code> на одну позицию вправо, а затем записать <code>base</code> в целевой индекс.</p> <p></p> <p> Рисунок 11-6   Одна операция вставки </p>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   Алгоритм","text":"<p>Общий процесс сортировки вставками показан на рисунке 11-7.</p> <ol> <li>В начальном состоянии отсортирован только первый элемент массива.</li> <li>Выбрать второй элемент массива как <code>base</code> ; после вставки в правильную позицию первые два элемента массива окажутся отсортированными.</li> <li>Выбрать третий элемент как <code>base</code> ; после вставки в правильную позицию первые три элемента массива окажутся отсортированными.</li> <li>Продолжать по аналогии; в последнем раунде в качестве <code>base</code> берется последний элемент, и после его вставки все элементы массива будут отсортированы.</li> </ol> <p></p> <p> Рисунок 11-7   Процесс сортировки вставками </p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"Сортировка вставками\"\"\"\n    # Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # Сдвинуть nums[j] на одну позицию вправо\n            j -= 1\n        nums[j + 1] = base  # Поместить base в правильную позицию\n</code></pre> insertion_sort.cpp<pre><code>/* Сортировка вставками */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* Сортировка вставками */\nvoid insertionSort(int[] nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base;        // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* Сортировка вставками */\nvoid InsertionSort(int[] nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = bas;         // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* Сортировка вставками */\nfunc insertionSort(nums []int) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j--\n        }\n        nums[j+1] = base // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* Сортировка вставками */\nfunc insertionSort(nums: inout [Int]) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j -= 1\n        }\n        nums[j + 1] = base // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* Сортировка вставками */\nfunction insertionSort(nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* Сортировка вставками */\nfunction insertionSort(nums: number[]): void {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* Сортировка вставками */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // Внешний цикл: отсортированный диапазон [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n      j--;\n    }\n    nums[j + 1] = base; // Поместить base в правильную позицию\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* Сортировка вставками */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // Сдвинуть nums[j] на одну позицию вправо\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* Сортировка вставками */\nvoid insertionSort(int nums[], int size) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // Сдвинуть nums[j] на одну позицию вправо\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // Поместить base в правильную позицию\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* Сортировка вставками */\nfun insertionSort(nums: IntArray) {\n    // Внешний цикл: отсортированные элементы равны 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j--\n        }\n        nums[j + 1] = base        // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### Сортировка вставками ###\ndef insertion_sort(nums)\n  n = nums.length\n  # Внешний цикл: отсортированный диапазон [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # Сдвинуть nums[j] на одну позицию вправо\n      j -= 1\n    end\n    nums[j + 1] = base # Поместить base в правильную позицию\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), алгоритм адаптивен: в худшем случае каждой операции вставки требуется соответственно \\(n - 1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\) итераций, а их сумма равна \\((n - 1) n / 2\\) , поэтому временная сложность равна \\(O(n^2)\\) . Если входные данные уже упорядочены, операция вставки завершается раньше. Когда входной массив полностью отсортирован, сортировка вставками достигает лучшей временной сложности \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Стабильная сортировка: в процессе вставки элементы помещаются справа от равных им элементов, поэтому их относительный порядок не меняется.</li> </ul>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   Преимущества сортировки вставками","text":"<p>Временная сложность сортировки вставками равна \\(O(n^2)\\) , а у быстрой сортировки, которую мы скоро изучим, временная сложность равна \\(O(n \\log n)\\) . Несмотря на более высокую асимптотическую сложность, на малых объемах данных сортировка вставками обычно работает быстрее.</p> <p>Этот вывод похож на сравнение линейного и двоичного поиска. Алгоритмы уровня \\(O(n \\log n)\\) , такие как быстрая сортировка, относятся к алгоритмам на основе стратегии \"разделяй и властвуй\" и обычно включают больше элементарных вычислений. Когда объем данных мал, значения \\(n^2\\) и \\(n \\log n\\) близки друг к другу, поэтому асимптотика не доминирует, а решающим становится число элементарных операций в каждом раунде.</p> <p>На практике встроенные функции сортировки во многих языках программирования (например, в Java) используют сортировку вставками. Общая идея такова: для длинных массивов применять алгоритмы сортировки на основе стратегии \"разделяй и властвуй\", например быструю сортировку; для коротких массивов сразу использовать сортировку вставками.</p> <p>Хотя сортировка пузырьком, выбором и вставками имеют одинаковую временную сложность \\(O(n^2)\\) , в реальных задачах сортировка вставками используется заметно чаще, чем сортировка пузырьком и сортировка выбором. Основные причины таковы.</p> <ul> <li>Сортировка пузырьком основана на обмене элементов, для чего нужна временная переменная и суммарно выполняются 3 элементарные операции; сортировка вставками основана на присваивании элементов и требует всего 1 элементарной операции. Поэтому вычислительные затраты сортировки пузырьком обычно выше, чем у сортировки вставками.</li> <li>Временная сложность сортировки выбором в любом случае равна \\(O(n^2)\\) . Если входные данные уже частично упорядочены, сортировка вставками обычно эффективнее сортировки выбором.</li> <li>Сортировка выбором нестабильна, поэтому ее нельзя использовать для многоуровневой сортировки.</li> </ul>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   Сортировка слиянием","text":"<p>Сортировка слиянием (merge sort) - это алгоритм сортировки, основанный на стратегии \"разделяй и властвуй\", который включает этапы \"разделения\" и \"слияния\", показанные на рисунке 11-10.</p> <ol> <li>Этап разделения: массив рекурсивно делится пополам, и задача сортировки длинного массива превращается в задачи сортировки более коротких массивов.</li> <li>Этап слияния: когда длина подмассива становится равной 1, разделение завершается и начинается слияние; два коротких упорядоченных массива непрерывно объединяются в один более длинный упорядоченный массив, пока процесс не завершится.</li> </ol> <p></p> <p> Рисунок 11-10   Этапы разделения и слияния в сортировке слиянием </p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   Алгоритм","text":"<p>Как показано на рисунке 11-11, на этапе \"разделения\" массив рекурсивно разбивается сверху вниз по середине на два подмассива.</p> <ol> <li>Вычислить середину массива <code>mid</code> и рекурсивно разделить левый подмассив (интервал <code>[left, mid]</code> ) и правый подмассив (интервал <code>[mid + 1, right]</code> ).</li> <li>Рекурсивно повторять шаг <code>1.</code> , пока длина подмассива не станет равной 1.</li> </ol> <p>Этап \"слияния\" снизу вверх объединяет левый и правый подмассивы в один упорядоченный массив. Следует заметить, что начиная с подмассивов длины 1, каждый подмассив в фазе слияния уже является упорядоченным.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-11   Шаги сортировки слиянием </p> <p>Нетрудно заметить, что порядок рекурсии в сортировке слиянием совпадает с порядком обхода в глубину двоичного дерева.</p> <ul> <li>Обход в глубину: сначала рекурсивно обходится левое поддерево, затем правое поддерево, а в конце обрабатывается корневой узел.</li> <li>Сортировка слиянием: сначала рекурсивно разделяется левый подмассив, затем правый подмассив, а в конце выполняется слияние.</li> </ul> <p>Реализация сортировки слиянием показана в коде ниже. Обратите внимание: в <code>nums</code> объединяемый интервал равен <code>[left, right]</code> , а соответствующий интервал в <code>tmp</code> равен <code>[0, right - left]</code> .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"Объединить левый и правый подмассивы\"\"\"\n    # Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    # Создать временный массив tmp для хранения результата слияния\n    tmp = [0] * (right - left + 1)\n    # Инициализировать начальные индексы левого и правого подмассивов\n    i, j, k = left, mid + 1, 0\n    # Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"Сортировка слиянием\"\"\"\n    # Условие завершения\n    if left &gt;= right:\n        return  # Завершить рекурсию, когда длина подмассива равна 1\n    # Этап разбиения\n    mid = (left + right) // 2 # Вычислить середину\n    merge_sort(nums, left, mid)  # Рекурсивно обработать левый подмассив\n    merge_sort(nums, mid + 1, right)  # Рекурсивно обработать правый подмассив\n    # Этап слияния\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    vector&lt;int&gt; tmp(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    mergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int[] tmp = new int[right - left + 1];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(int[] nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2; // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* Объединить левый и правый подмассивы */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int[] tmp = new int[right - left + 1];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid MergeSort(int[] nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right) return;       // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    MergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    MergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* Объединить левый и правый подмассивы */\nfunc merge(nums []int, left, mid, right int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    tmp := make([]int, right-left+1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    i, j, k := left, mid+1, 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* Сортировка слиянием */\nfunc mergeSort(nums []int, left, right int) {\n    // Условие завершения\n    if left &gt;= right {\n        return\n    }\n    // Этап разбиения\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // Этап слияния\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* Объединить левый и правый подмассивы */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    var i = left, j = mid + 1, k = 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* Сортировка слиянием */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // Условие завершения\n    if left &gt;= right { // Завершить рекурсию, когда длина подмассива равна 1\n        return\n    }\n    // Этап разбиения\n    let mid = left + (right - left) / 2 // Вычислить середину\n    mergeSort(nums: &amp;nums, left: left, right: mid) // Рекурсивно обработать левый подмассив\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* Объединить левый и правый подмассивы */\nfunction merge(nums, left, mid, right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    const tmp = new Array(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfunction mergeSort(nums, left, right) {\n    // Условие завершения\n    if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    let mid = Math.floor(left + (right - left) / 2); // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* Объединить левый и правый подмассивы */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    const tmp = new Array(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // Условие завершения\n    if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    let mid = Math.floor(left + (right - left) / 2); // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n  // Создать временный массив tmp для хранения результата слияния\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // Инициализировать начальные индексы левого и правого подмассивов\n  int i = left, j = mid + 1, k = 0;\n  // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // Условие завершения\n  if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n  // Этап разбиения\n  int mid = left + (right - left) ~/ 2; // Вычислить середину\n  mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n  mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n  // Этап слияния\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* Объединить левый и правый подмассивы */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // Условие завершения\n    if left &gt;= right {\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    }\n\n    // Этап разбиения\n    let mid = left + (right - left) / 2; // Вычислить середину\n    merge_sort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    merge_sort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(int *nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // Освободить память\n    free(tmp);\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(int *nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    mergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* Объединить левый и правый подмассивы */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    val tmp = IntArray(right - left + 1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* Сортировка слиянием */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // Условие завершения\n    if (left &gt;= right) return  // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    val mid = left + (right - left) / 2 // Вычислить середину\n    mergeSort(nums, left, mid) // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right) // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### Слияние левого и правого подмассивов ###\ndef merge(nums, left, mid, right)\n  # Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]\n  # Создать временный массив tmp для хранения результата слияния\n  tmp = Array.new(right - left + 1, 0)\n  # Инициализировать начальные индексы левого и правого подмассивов\n  i, j, k = left, mid + 1, 0\n  # Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### Сортировка слиянием ###\ndef merge_sort(nums, left, right)\n  # Условие завершения\n  # Когда длина подмассива равна 1, рекурсия завершается\n  return if left &gt;= right\n  # Этап разбиения\n  mid = left + (right - left) / 2 # Вычислить середину\n  merge_sort(nums, left, mid) # Рекурсивно обработать левый подмассив\n  merge_sort(nums, mid + 1, right) # Рекурсивно обработать правый подмассив\n  # Этап слияния\n  merge(nums, left, mid, right)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: этап разделения создает дерево рекурсии высоты \\(\\log n\\) , а суммарное число операций слияния на каждом уровне равно \\(n\\) , поэтому общая временная сложность составляет \\(O(n \\log n)\\) .</li> <li>Пространственная сложность равна \\(O(n)\\), сортировка не выполняется на месте: глубина рекурсии равна \\(\\log n\\) , из-за чего требуется \\(O(\\log n)\\) памяти под стек вызовов. Для этапа слияния нужен вспомогательный массив, поэтому дополнительно используется \\(O(n)\\) памяти.</li> <li>Стабильная сортировка: в процессе слияния относительный порядок равных элементов не меняется.</li> </ul>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   Сортировка связного списка","text":"<p>Для связных списков сортировка слиянием имеет заметное преимущество перед другими алгоритмами сортировки: пространственную сложность задачи сортировки списка можно оптимизировать до \\(O(1)\\).</p> <ul> <li>Этап разделения: работу по разбиению списка можно реализовать с помощью \"итерации\" вместо \"рекурсии\", тем самым устранив расход памяти на стек вызовов.</li> <li>Этап слияния: в связном списке добавление и удаление узлов требует только изменения ссылок (указателей), поэтому при слиянии двух коротких упорядоченных списков в один длинный упорядоченный список не нужно создавать дополнительный список.</li> </ul> <p>Детали реализации достаточно сложны; заинтересованные читатели могут обратиться к соответствующим материалам самостоятельно.</p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   Быстрая сортировка","text":"<p>Быстрая сортировка (quick sort) - это алгоритм сортировки, основанный на стратегии \"разделяй и властвуй\"; он работает эффективно и применяется очень широко.</p> <p>Ключевая операция быстрой сортировки - это \"разделение с опорным элементом\". Ее цель такова: выбрать некоторый элемент массива в качестве \"опорного\" и переместить все элементы меньше опорного влево от него, а все элементы больше опорного - вправо. Конкретный процесс показан на рисунке 11-8.</p> <ol> <li>Выбрать самый левый элемент массива как опорный и инициализировать два указателя <code>i</code> и <code>j</code> , направленные на левую и правую границы массива.</li> <li>Запустить цикл, в котором <code>i</code> и <code>j</code> ищут соответственно первый элемент, больший опорного, и первый элемент, меньший опорного, после чего эти два элемента меняются местами.</li> <li>Повторять шаг <code>2.</code> , пока указатели <code>i</code> и <code>j</code> не встретятся, а затем обменять опорный элемент с элементом на границе двух подмассивов.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-8   Шаги разделения с опорным элементом </p> <p>После завершения разделения исходный массив разбивается на три части: левый подмассив, опорный элемент и правый подмассив; при этом выполняется условие \"любой элемент левого подмассива \\(\\leq\\) опорный элемент \\(\\leq\\) любой элемент правого подмассива\". Следовательно, далее нам нужно лишь отсортировать эти два подмассива.</p> <p>Стратегия разделяй и властвуй в быстрой сортировке</p> <p>Иными словами, разделение с опорным элементом сводит задачу сортировки длинного массива к двум задачам сортировки более коротких массивов.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Разбиение с опорными указателями\"\"\"\n    # Взять nums[left] в качестве опорного элемента\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Идти справа налево в поисках первого элемента меньше опорного\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Идти слева направо в поисках первого элемента больше опорного\n        # Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    # Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Вернуть индекс опорного элемента\n</code></pre> quick_sort.cpp<pre><code>/* Разбиение с опорными указателями */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums[i], nums[j]); // Поменять эти два элемента местами\n    }\n    swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов\n    return i;                   // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.java<pre><code>/* Обмен элементов */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint partition(int[] nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.cs<pre><code>/* Обмен элементов */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* Разбиение с опорными указателями */\nint Partition(int[] nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        Swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.go<pre><code>/* Разбиение с опорными указателями */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // Взять nums[left] в качестве опорного элемента\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.swift<pre><code>/* Разбиение с опорными указателями */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swapAt(i, j) // Поменять эти два элемента местами\n    }\n    nums.swapAt(i, left) // Переместить опорный элемент на границу двух подмассивов\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.js<pre><code>/* Обмен элементов */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\npartition(nums, left, right) {\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.ts<pre><code>/* Обмен элементов */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\npartition(nums: number[], left: number, right: number): number {\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.dart<pre><code>/* Обмен элементов */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Взять nums[left] в качестве опорного элемента\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n    _swap(nums, i, j); // Поменять эти два элемента местами\n  }\n  _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n  return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rs<pre><code>/* Разбиение с опорными указателями */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Взять nums[left] в качестве опорного элемента\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swap(i, j); // Поменять эти два элемента местами\n    }\n    nums.swap(i, left); // Переместить опорный элемент на границу двух подмассивов\n    i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.c<pre><code>/* Обмен элементов */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint partition(int nums[], int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Поменять эти два элемента местами\n        swap(nums, i, j);\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    swap(nums, i, left);\n    // Вернуть индекс опорного элемента\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* Обмен элементов */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* Разбиение с опорными указателями */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j)  // Поменять эти два элемента местами\n    }\n    swap(nums, i, left)   // Переместить опорный элемент на границу двух подмассивов\n    return i              // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rb<pre><code>### Разбиение с опорными указателями ###\ndef partition(nums, left, right)\n  # Взять nums[left] в качестве опорного элемента\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   Алгоритм","text":"<p>Общий процесс быстрой сортировки показан на рисунке 11-9.</p> <ol> <li>Сначала выполнить \"разделение с опорным элементом\" для исходного массива и получить неотсортированные левый и правый подмассивы.</li> <li>Затем рекурсивно выполнить \"разделение с опорным элементом\" для левого и правого подмассивов.</li> <li>Продолжать рекурсию до тех пор, пока длина подмассива не станет равной 1; после этого сортировка всего массива будет завершена.</li> </ol> <p></p> <p> Рисунок 11-9   Процесс быстрой сортировки </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Быстрая сортировка\"\"\"\n    # Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right:\n        return\n    # Разбиение с опорными указателями\n    pivot = self.partition(nums, left, right)\n    # Рекурсивно обработать левый и правый подмассивы\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* Быстрая сортировка */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* Быстрая сортировка */\nvoid quickSort(int[] nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* Быстрая сортировка */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = Partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* Быстрая сортировка */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return\n    }\n    // Разбиение с опорными указателями\n    pivot := q.partition(nums, left, right)\n    // Рекурсивно обработать левый и правый подмассивы\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* Быстрая сортировка */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return\n    }\n    // Разбиение с опорными указателями\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Быстрая сортировка */\nquickSort(nums, left, right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) return;\n    // Разбиение с опорными указателями\n    const pivot = this.partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* Быстрая сортировка */\nquickSort(nums: number[], left: number, right: number): void {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Разбиение с опорными указателями\n    const pivot = this.partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* Быстрая сортировка */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Завершить рекурсию, когда длина подмассива равна 1\n  if (left &gt;= right) return;\n  // Разбиение с опорными указателями\n  int pivot = _partition(nums, left, right);\n  // Рекурсивно обработать левый и правый подмассивы\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* Быстрая сортировка */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return;\n    }\n    // Разбиение с опорными указателями\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // Рекурсивно обработать левый и правый подмассивы\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* Быстрая сортировка */\nvoid quickSort(int nums[], int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* Быстрая сортировка */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) return\n    // Разбиение с опорными указателями\n    val pivot = partition(nums, left, right)\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### Класс быстрой сортировки ###\ndef quick_sort(nums, left, right)\n  # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1\n  if left &lt; right\n    # Разбиение с опорными указателями\n    pivot = partition(nums, left, right)\n    # Рекурсивно обработать левый и правый подмассивы\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: в среднем глубина рекурсии при разделении равна \\(\\log n\\) , а суммарное число циклов на каждом уровне равно \\(n\\) , поэтому общая сложность составляет \\(O(n \\log n)\\) . В худшем случае каждое разделение делит массив длины \\(n\\) на подмассивы длины \\(0\\) и \\(n - 1\\) ; тогда глубина рекурсии достигает \\(n\\) , на каждом уровне выполняется \\(n\\) операций, и общая временная сложность вырождается в \\(O(n^2)\\) .</li> <li>Пространственная сложность равна \\(O(n)\\), сортировка выполняется на месте: если входной массив полностью отсортирован в обратном порядке, глубина рекурсии достигает худшего случая \\(n\\) , что требует \\(O(n)\\) памяти под стек вызовов. При этом сама сортировка выполняется в исходном массиве без дополнительного массива.</li> <li>Нестабильная сортировка: на последнем шаге разделения опорный элемент может быть обменян вправо от равного ему элемента.</li> </ul>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   Почему быстрая сортировка быстрая","text":"<p>Уже по названию понятно, что быстрая сортировка должна иметь преимущества по эффективности. Хотя ее средняя временная сложность совпадает со сложностью \"сортировки слиянием\" и \"пирамидальной сортировки\", на практике быстрая сортировка обычно работает быстрее. Основные причины таковы.</p> <ul> <li>Вероятность худшего случая очень мала: хотя худшая временная сложность быстрой сортировки равна \\(O(n^2)\\) и она не так стабильна, как сортировка слиянием, в подавляющем большинстве случаев она работает за \\(O(n \\log n)\\) .</li> <li>Высокая эффективность использования кэша: при выполнении разделения система может загрузить весь подмассив в кэш, поэтому доступ к элементам оказывается быстрым. Алгоритмы вроде \"пирамидальной сортировки\" требуют скачкообразного доступа к элементам и таким свойством не обладают.</li> <li>Небольшой константный множитель в сложности: среди трех перечисленных алгоритмов у быстрой сортировки обычно меньше всего сравнений, присваиваний и обменов. Это похоже на причину, по которой \"сортировка вставками\" часто быстрее \"сортировки пузырьком\".</li> </ul>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   Оптимизация выбора опорного элемента","text":"<p>На некоторых входных данных временная эффективность быстрой сортировки может ухудшаться. Рассмотрим крайний случай: входной массив полностью отсортирован в обратном порядке. Поскольку в качестве опорного мы выбираем самый левый элемент, после разделения он будет обменян в самый правый конец массива, из-за чего длина левого подмассива станет \\(n - 1\\) , а длина правого - \\(0\\) . Если рекурсия будет продолжаться таким образом, то после каждого разделения один из подмассивов будет иметь длину \\(0\\) , стратегия \"разделяй и властвуй\" потеряет смысл, а быстрая сортировка выродится в нечто близкое к \"сортировке пузырьком\".</p> <p>Чтобы по возможности избежать такого сценария, можно улучшить стратегию выбора опорного элемента в процедуре разделения. Например, можно выбирать случайный элемент массива как опорный. Однако если не повезет и каждый раз будет выбираться неудачный опорный элемент, производительность все равно останется неудовлетворительной.</p> <p>Стоит учитывать, что языки программирования обычно генерируют псевдослучайные числа. Если специально построить тестовый пример под такую последовательность, эффективность быстрой сортировки все равно может деградировать.</p> <p>Чтобы улучшить ситуацию, можно взять три кандидата (обычно первый, последний и средний элементы массива) и использовать медиану этих трех значений как опорный элемент. Благодаря этому вероятность того, что опорный элемент окажется \"не слишком маленьким и не слишком большим\", заметно возрастает. Конечно, можно брать и большее число кандидатов, чтобы еще сильнее повысить устойчивость алгоритма. После этого вероятность деградации временной сложности до \\(O(n^2)\\) существенно уменьшается.</p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"Выбрать медиану из трех кандидатов\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m находится между l и r\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l находится между m и r\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Разбиение с опорными указателями (медиана трех)\"\"\"\n    # Взять nums[left] в качестве опорного элемента\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # Переместить медиану в крайний левый элемент массива\n    nums[left], nums[med] = nums[med], nums[left]\n    # Взять nums[left] в качестве опорного элемента\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Идти справа налево в поисках первого элемента меньше опорного\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Идти слева направо в поисках первого элемента больше опорного\n        # Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    # Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Вернуть индекс опорного элемента\n</code></pre> quick_sort.cpp<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums[left], nums[med]);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums[i], nums[j]); // Поменять эти два элемента местами\n    }\n    swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов\n    return i;                   // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.java<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partition(int[] nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.cs<pre><code>/* Выбрать медиану из трех кандидатов */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint Partition(int[] nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    Swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        Swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.go<pre><code>/* Выбрать медиану из трех кандидатов */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l находится между m и r\n    }\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // Взять nums[left] в качестве опорного элемента\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // Переместить медиану в крайний левый элемент массива\n    nums[left], nums[med] = nums[med], nums[left]\n    // Взять nums[left] в качестве опорного элемента\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.swift<pre><code>/* Выбрать медиану из трех кандидатов */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l находится между m и r\n    }\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Выбрать медиану из трех кандидатов\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // Переместить медиану в крайний левый элемент массива\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Выбрать медиану из трех кандидатов */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m находится между l и r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l находится между m и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\npartition(nums, left, right) {\n    // Выбрать медиану из трех кандидатов\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Переместить медиану в крайний левый элемент массива\n    this.swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.ts<pre><code>/* Выбрать медиану из трех кандидатов */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m находится между l и r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l находится между m и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\npartition(nums: number[], left: number, right: number): number {\n    // Выбрать медиану из трех кандидатов\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Переместить медиану в крайний левый элемент массива\n    this.swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.dart<pre><code>/* Выбрать медиану из трех кандидатов */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m находится между l и r\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l находится между m и r\n  return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Выбрать медиану из трех кандидатов\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // Переместить медиану в крайний левый элемент массива\n  _swap(nums, left, med);\n  // Взять nums[left] в качестве опорного элемента\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n    _swap(nums, i, j); // Поменять эти два элемента местами\n  }\n  _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n  return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rs<pre><code>/* Выбрать медиану из трех кандидатов */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l находится между m и r\n    }\n    right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Выбрать медиану из трех кандидатов\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    nums.swap(left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swap(i, j); // Поменять эти два элемента местами\n    }\n    nums.swap(i, left); // Переместить опорный элемент на границу двух подмассивов\n    i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.c<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partitionMedian(int nums[], int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i;            // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.kt<pre><code>/* Выбрать медиану из трех кандидатов */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m находится между l и r\n    if ((l in m..r) || (l in r..m))\n        return left // l находится между m и r\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // Выбрать медиану из трех кандидатов\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med)\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j)             // Поменять эти два элемента местами\n    }\n    swap(nums, i, left)              // Переместить опорный элемент на границу двух подмассивов\n    return i                         // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rb<pre><code>### Выбрать медиану из трех кандидатов ###\ndef median_three(nums, left, mid, right)\n  # Выбрать медиану из трех кандидатов\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m находится между l и r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l находится между m и r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### Выбрать медиану из трех кандидатов ###\ndef median_three(nums, left, mid, right)\n  # Выбрать медиану из трех кандидатов\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m находится между l и r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l находится между m и r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n# ## Разбиение с опорными указателями (медиана трех) ###\ndef partition(nums, left, right)\n  # ## Использовать nums[left] как опорный элемент\n  med = median_three(nums, left, (left + right) / 2, right)\n  # Переместить медиану в крайний левый элемент массива\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   Оптимизация глубины рекурсии","text":"<p>На некоторых входных данных быстрая сортировка может занимать слишком много памяти. Рассмотрим полностью отсортированный входной массив. Пусть длина текущего подмассива в рекурсии равна \\(m\\) ; тогда после каждого разделения будут получаться левый подмассив длины \\(0\\) и правый подмассив длины \\(m - 1\\) . Это означает, что на каждом уровне размер задачи уменьшается совсем немного (лишь на один элемент), а высота дерева рекурсии достигает \\(n - 1\\) , поэтому требуется \\(O(n)\\) памяти под стек вызовов.</p> <p>Чтобы избежать накопления стековых кадров, после каждого разделения можно сравнивать длины двух подмассивов и рекурсивно обрабатывать только более короткий из них. Поскольку длина короткого подмассива не превысит \\(n / 2\\) , такой подход гарантирует, что глубина рекурсии не превысит \\(\\log n\\) , а худшая пространственная сложность будет оптимизирована до \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Быстрая сортировка (оптимизация глубины рекурсии)\"\"\"\n    # Завершить, когда длина подмассива равна 1\n    while left &lt; right:\n        # Операция разбиения с опорными указателями\n        pivot = self.partition(nums, left, right)\n        # Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # Рекурсивно отсортировать левый подмассив\n            left = pivot + 1  # Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # Рекурсивно отсортировать правый подмассив\n            right = pivot - 1  # Оставшийся неотсортированный диапазон: [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1;                 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1;                 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(int[] nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = Partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1;  // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // Завершить, когда длина подмассива равна 1\n    for left &lt; right {\n        // Операция разбиения с опорными указателями\n        pivot := q.partition(nums, left, right)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1                 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1                 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // Завершить, когда длина подмассива равна 1\n    while left &lt; right {\n        // Операция разбиения с опорными указателями\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nquickSort(nums, left, right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        let pivot = this.partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nquickSort(nums: number[], left: number, right: number): void {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        let pivot = this.partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Завершить, когда длина подмассива равна 1\n  while (left &lt; right) {\n    // Операция разбиения с опорными указателями\n    int pivot = _partition(nums, left, right);\n    // Выполнить быструю сортировку для более короткого из двух подмассивов\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n      left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n      right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // Завершить, когда длина подмассива равна 1\n    while left &lt; right {\n        // Операция разбиения с опорными указателями\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            // Рекурсивно отсортировать левый подмассив\n            quickSortTailCall(nums, left, pivot - 1);\n            // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // Рекурсивно отсортировать правый подмассив\n            quickSortTailCall(nums, pivot + 1, right);\n            // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // Завершить, когда длина подмассива равна 1\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // Операция разбиения с опорными указателями\n        val pivot = partition(nums, l, r)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // Рекурсивно отсортировать левый подмассив\n            l = pivot + 1 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // Рекурсивно отсортировать правый подмассив\n            r = pivot - 1 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### Разбиение с опорными указателями ###\ndef partition(nums, left, right)\n  # Использовать nums[left] как опорный элемент\n  i = left\n  j = right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n\n# ## Быстрая сортировка (оптимизация глубины рекурсии) ###\ndef quick_sort(nums, left, right)\n  # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1\n  while left &lt; right\n    # Разбиение с опорными указателями\n    pivot = partition(nums, left, right)\n    # Выполнить быструю сортировку для более короткого из двух подмассивов\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # Оставшийся неотсортированный диапазон: [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # Оставшийся неотсортированный диапазон: [left, pivot - 1]\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   Поразрядная сортировка","text":"<p>В предыдущем разделе была рассмотрена сортировка подсчетом: она хорошо подходит для случаев, когда объем данных \\(n\\) велик, а диапазон значений \\(m\\) сравнительно мал. Предположим теперь, что нужно отсортировать \\(n = 10^6\\) номеров студентов, причем каждый номер представляет собой \\(8\\)-значное число. Тогда диапазон данных \\(m = 10^8\\) оказывается очень большим; сортировка подсчетом потребует огромного объема памяти, а поразрядная сортировка позволяет этого избежать.</p> <p>Поразрядная сортировка (radix sort) по своей основной идее совпадает с сортировкой подсчетом и тоже реализует сортировку через подсчет количества. При этом поразрядная сортировка использует соотношение между разрядами числа и последовательно сортирует данные по каждому разряду, получая итоговый упорядоченный результат.</p>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   Алгоритм","text":"<p>Рассмотрим пример со студенческими номерами: будем считать, что младший разряд имеет номер \\(1\\) , а старший - номер \\(8\\) . Тогда процесс поразрядной сортировки показан на рисунке 11-18.</p> <ol> <li>Инициализировать номер разряда \\(k = 1\\) .</li> <li>Выполнить \"сортировку подсчетом\" по \\(k\\)-му разряду студенческого номера. После этого данные будут упорядочены по \\(k\\)-му разряду по возрастанию.</li> <li>Увеличить \\(k\\) на \\(1\\) и вернуться к шагу <code>2.</code> , продолжая процесс, пока сортировка не будет выполнена для всех разрядов.</li> </ol> <p></p> <p> Рисунок 11-18   Процесс поразрядной сортировки </p> <p>Ниже разберем реализацию кода. Для числа \\(x\\) в системе счисления с основанием \\(d\\) получить его \\(k\\)-й разряд \\(x_k\\) можно по формуле:</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>где \\(\\lfloor a \\rfloor\\) обозначает округление числа \\(a\\) вниз, а \\(\\bmod \\: d\\) означает взятие остатка по модулю \\(d\\) . Для студенческих номеров выполняется \\(d = 10\\) и \\(k \\in [1, 8]\\) .</p> <p>Кроме того, нам нужно слегка изменить код сортировки подсчетом, чтобы он мог сортировать числа по их \\(k\\)-му разряду:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"Получить k-й разряд элемента num, где exp = 10^(k-1)\"\"\"\n    # Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"Сортировка подсчетом (сортировка по k-му разряду nums)\"\"\"\n    # Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    counter = [0] * 10\n    n = len(nums)\n    # Подсчитать число появлений каждой цифры от 0 до 9\n    for i in range(n):\n        d = digit(nums[i], exp)  # Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1  # Подсчитать число появлений цифры d\n    # Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # Получить индекс j цифры d в массиве\n        res[j] = nums[i]  # Поместить текущий элемент по индексу j\n        counter[d] -= 1  # Уменьшить количество d на 1\n    # Перезаписать исходный массив nums результатом\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"Поразрядная сортировка\"\"\"\n    # Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    m = max(nums)\n    # Проходить разряды от младшего к старшему\n    exp = 1\n    while exp &lt;= m:\n        # Выполнить сортировку подсчетом по k-му разряду элементов массива\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # то есть exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = *max_element(nums.begin(), nums.end());\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(int[] nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int[] counter = new int[10];\n    int n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(int[] nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nvoid RadixSort(int[] nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunc countingSortDigit(nums []int, exp int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    counter := make([]int, 10)\n    n := len(nums)\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++             // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i]    // Поместить текущий элемент по индексу j\n        counter[d]--        // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* Поразрядная сортировка */\nfunc radixSort(nums []int) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    var counter = Array(repeating: 0, count: 10)\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1 // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i] // Поместить текущий элемент по индексу j\n        counter[d] -= 1 // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* Поразрядная сортировка */\nfunc radixSort(nums: inout [Int]) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return Math.floor(num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunction countingSortDigit(nums, exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d]--; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nfunction radixSort(nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m = Math.max(... nums);\n    // Проходить разряды от младшего к старшему\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return Math.floor(num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d]--; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nfunction radixSort(nums: number[]): void {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m: number = Math.max(... nums);\n    // Проходить разряды от младшего к старшему\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* Получить k-й разряд элемента _num, где exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n  return (_num ~/ exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // Подсчитать число появлений каждой цифры от 0 до 9\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n    counter[d]++; // Подсчитать число появлений цифры d\n  }\n  // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n    res[j] = nums[i]; // Поместить текущий элемент по индексу j\n    counter[d]--; // Уменьшить количество d на 1\n  }\n  // Перезаписать исходный массив nums результатом\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(List&lt;int&gt; nums) {\n  // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n  // В dart длина int составляет 64 бита\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // Проходить разряды от младшего к старшему\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // Выполнить сортировку подсчетом по k-му разряду элементов массива\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // то есть exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return ((num / exp) % 10) as usize;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i in 0..n {\n        let d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d] -= 1; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    nums.copy_from_slice(&amp;res);\n}\n\n/* Поразрядная сортировка */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m = *nums.into_iter().max().unwrap();\n    // Проходить разряды от младшего к старшему\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // Инициализировать нулем для последующего освобождения памяти\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; size; i++) {\n        // Получить k-й разряд nums[i], обозначив его как d\n        int d = digit(nums[i], exp);\n        // Подсчитать число появлений цифры d\n        counter[d]++;\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // Освободить память\n    free(res);\n    free(counter);\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(int nums[], int size) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    val counter = IntArray(10)\n    val n = nums.size\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i]       // Поместить текущий элемент по индексу j\n        counter[d]--           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* Поразрядная сортировка */\nfun radixSort(nums: IntArray) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // Проходить разряды от младшего к старшему\n    while (exp &lt;= m) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### Получить k-й разряд элемента num, где exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени\n  (num / exp) % 10\nend\n\n### Получить k-й разряд элемента num, где exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени\n  (num / exp) % 10\nend\n\n# ## Сортировка подсчетом (сортировка по k-му разряду nums) ###\ndef counting_sort_digit(nums, exp)\n  # Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n  counter = Array.new(10, 0)\n  n = nums.length\n  # Подсчитать число появлений каждой цифры от 0 до 9\n  for i in 0...n\n    d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d\n    counter[d] += 1 # Подсчитать число появлений цифры d\n  end\n  # Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # Получить индекс j цифры d в массиве\n    res[j] = nums[i] # Поместить текущий элемент по индексу j\n    counter[d] -= 1 # Уменьшить количество d на 1\n  end\n  # Перезаписать исходный массив nums результатом\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### Поразрядная сортировка ###\ndef radix_sort(nums)\n  # Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n  m = nums.max\n  # Проходить разряды от младшего к старшему\n  exp = 1\n  while exp &lt;= m\n    # Выполнить сортировку подсчетом по k-му разряду элементов массива\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # то есть exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Почему сортировка выполняется от младшего разряда к старшему?</p> <p>В последовательных раундах сортировки результаты более позднего раунда перекрывают результаты предыдущего. Например, если после первого раунда получилось \\(a &lt; b\\) , а после второго - \\(a &gt; b\\) , то именно результат второго раунда станет окончательным. Поскольку старшие разряды имеют более высокий приоритет, сначала нужно сортировать по младшим разрядам, а затем по старшим.</p>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   Характеристики алгоритма","text":"<p>По сравнению с сортировкой подсчетом поразрядная сортировка подходит для случаев с большим диапазоном чисел, но только при условии, что данные можно представить в виде чисел фиксированной длины и число разрядов не слишком велико. Например, числа с плавающей запятой плохо подходят для поразрядной сортировки, потому что число разрядов \\(k\\) слишком велико и может привести к ситуации \\(O(nk) \\gg O(n^2)\\) .</p> <ul> <li>Временная сложность равна \\(O(nk)\\), алгоритм не является адаптивным: пусть объем данных равен \\(n\\) , числа записаны в системе счисления с основанием \\(d\\) , а максимальное число разрядов равно \\(k\\) . Тогда выполнение сортировки подсчетом для одного разряда требует \\(O(n + d)\\) времени, а сортировка по всем \\(k\\) разрядам требует \\(O((n + d)k)\\) времени. Обычно \\(d\\) и \\(k\\) сравнительно малы, поэтому временная сложность стремится к \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(n + d)\\), сортировка не выполняется на месте: как и в сортировке подсчетом, здесь требуются массивы <code>res</code> и <code>counter</code> длины \\(n\\) и \\(d\\) .</li> <li>Стабильная сортировка: если сортировка подсчетом стабильна, то и поразрядная сортировка стабильна; если же сортировка подсчетом нестабильна, поразрядная сортировка не может гарантировать корректный результат.</li> </ul>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   Сортировка выбором","text":"<p>Сортировка выбором (selection sort) работает очень просто: запускается цикл, и на каждом шаге из неотсортированного диапазона выбирается минимальный элемент, после чего он переносится в конец уже отсортированного диапазона.</p> <p>Пусть длина массива равна \\(n\\) ; тогда процесс сортировки выбором выглядит так, как показано на рисунке 11-2.</p> <ol> <li>В начальном состоянии все элементы не отсортированы, то есть неотсортированный диапазон индексов равен \\([0, n-1]\\) .</li> <li>Выбрать минимальный элемент из диапазона \\([0, n-1]\\) и поменять его местами с элементом в позиции \\(0\\) . После этого первый элемент массива отсортирован.</li> <li>Выбрать минимальный элемент из диапазона \\([1, n-1]\\) и поменять его местами с элементом в позиции \\(1\\) . После этого первые два элемента массива отсортированы.</li> <li>Продолжать по аналогии. После \\(n - 1\\) раундов выбора и обмена первые \\(n - 1\\) элементов массива будут отсортированы.</li> <li>Оставшийся элемент обязательно является максимальным, сортировать его не нужно, поэтому массив считается отсортированным.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-2   Шаги сортировки выбором </p> <p>В коде мы используем \\(k\\) для записи минимального элемента в пределах неотсортированного диапазона:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"Сортировка выбором\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in range(n - 1):\n        # Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # Записать индекс минимального элемента\n        # Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* Сортировка выбором */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* Сортировка выбором */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* Сортировка выбором */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* Сортировка выбором */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // Записать индекс минимального элемента\n                k = j\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* Сортировка выбором */\nfunc selectionSort(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in nums.indices.dropLast() {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* Сортировка выбором */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* Сортировка выбором */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* Сортировка выбором */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // Внешний цикл: неотсортированный диапазон [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // Записать индекс минимального элемента\n    }\n    // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* Сортировка выбором */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in 0..n - 1 {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* Сортировка выбором */\nvoid selectionSort(int nums[], int n) {\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* Сортировка выбором */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### Сортировка выбором ###\ndef selection_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [i, n-1]\n  for i in 0...(n - 1)\n    # Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # Записать индекс минимального элемента\n      end\n    end\n    # Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.2 &nbsp; Сортировка выбором"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), сортировка не является адаптивной: внешний цикл выполняется \\(n - 1\\) раз; в первом раунде длина неотсортированного диапазона равна \\(n\\) , а в последнем - \\(2\\) , то есть отдельные раунды содержат \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(3\\), \\(2\\) проходов внутреннего цикла, их сумма равна \\(\\frac{(n - 1)(n + 2)}{2}\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Нестабильная сортировка: как показано на рисунке 11-3, элемент <code>nums[i]</code> может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.</li> </ul> <p> Рисунок 11-3   Пример нестабильности сортировки выбором </p>","path":["Глава 11. Сортировка","11.2 &nbsp; Сортировка выбором"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   Алгоритмы сортировки","text":"<p>Алгоритмы сортировки (sorting algorithm) используются для упорядочивания набора данных по определенному правилу. Они применяются очень широко, потому что упорядоченные данные обычно проще анализировать, обрабатывать и искать в них нужные элементы.</p> <p>Как показано на рисунке 11-1, данными в алгоритмах сортировки могут быть целые числа, числа с плавающей запятой, символы, строки и другие типы. Критерий сравнения тоже можно задать по-разному, например по величине чисел, по порядку ASCII-кодов символов или по пользовательскому правилу.</p> <p></p> <p> Рисунок 11-1   Примеры типов данных и правил сравнения </p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   Критерии оценки","text":"<p>Скорость выполнения: мы ожидаем, что временная сложность алгоритма сортировки будет как можно ниже, а общее число операций будет как можно меньше (то есть константа во временной сложности будет небольшой). Для больших объемов данных этот критерий особенно важен.</p> <p>Сортировка на месте: как следует из названия, сортировка на месте выполняется прямо в исходном массиве и не требует дополнительного вспомогательного массива, что позволяет экономить память. Обычно при сортировке на месте переносов данных меньше, а скорость работы выше.</p> <p>Стабильность: стабильная сортировка после завершения не меняет относительный порядок одинаковых элементов в массиве.</p> <p>Стабильность является необходимым условием для многоуровневой сортировки. Предположим, у нас есть таблица со сведениями о студентах, где в первом и втором столбцах записаны имя и возраст. В этом случае нестабильная сортировка может разрушить уже существующий порядок входных данных:</p> <pre><code># Входные данные уже отсортированы по имени\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# Если затем нестабильным алгоритмом отсортировать список по возрасту,\n# относительный порядок ('D', 19) и ('A', 19) изменится,\n# и свойство упорядоченности по имени будет потеряно\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>Адаптивность: адаптивная сортировка умеет использовать уже существующий порядок входных данных, чтобы сократить вычисления и добиться лучшей эффективности. Лучшая временная сложность адаптивных алгоритмов обычно лучше их средней временной сложности.</p> <p>Основанность на сравнении: сортировка на основе сравнений использует операторы сравнения (\\(&lt;\\), \\(=\\), \\(&gt;\\)), чтобы определить относительный порядок элементов и отсортировать массив; ее теоретически лучшая временная сложность равна \\(O(n \\log n)\\) . А вот сортировка без сравнений не опирается на операторы сравнения, поэтому может достигать \\(O(n)\\) , но универсальность у нее ниже.</p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   Идеальный алгоритм сортировки","text":"<p>Быстрый, выполняющийся на месте, стабильный, адаптивный и универсальный. Очевидно, что на сегодняшний день не существует алгоритма сортировки, который одновременно обладал бы всеми этими свойствами. Поэтому при выборе алгоритма сортировки нужно исходить из конкретных особенностей данных и требований задачи.</p> <p>Далее мы последовательно изучим разные алгоритмы сортировки и на основании приведенных выше критериев разберем их преимущества и недостатки.</p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   Резюме","text":"","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Сортировка пузырьком выполняет сортировку за счет обмена соседних элементов. Если добавить флаг для досрочного выхода, лучшую временную сложность пузырьковой сортировки можно оптимизировать до \\(O(n)\\) .</li> <li>Сортировка вставками на каждом раунде вставляет элемент из неотсортированного диапазона в правильную позицию внутри отсортированного диапазона. Хотя ее временная сложность равна \\(O(n^2)\\) , она очень популярна для задач сортировки небольших массивов, поскольку число элементарных операций у нее сравнительно невелико.</li> <li>Быстрая сортировка основана на операции разделения с опорным элементом. При неудачном выборе опорного элемента на каждом раунде ее временная сложность может деградировать до \\(O(n^2)\\) . Использование медианы трех элементов или случайного опорного элемента уменьшает вероятность этой деградации. Если всегда рекурсивно обрабатывать более короткий поддиапазон первым, можно эффективно уменьшить глубину рекурсии и оптимизировать пространственную сложность до \\(O(\\log n)\\) .</li> <li>Сортировка слиянием включает этапы разделения и слияния и служит типичным проявлением стратегии \"разделяй и властвуй\". Для сортировки массива ей требуется вспомогательный массив, поэтому пространственная сложность равна \\(O(n)\\) ; однако при сортировке связного списка пространственную сложность можно оптимизировать до \\(O(1)\\) .</li> <li>Блочная сортировка включает три этапа: распределение данных по блокам, сортировку внутри блоков и объединение результатов. Она тоже отражает стратегию \"разделяй и властвуй\" и подходит для очень больших объемов данных. Ключ к эффективности блочной сортировки - равномерное распределение данных.</li> <li>Сортировка подсчетом является частным случаем блочной сортировки; она реализует сортировку через подсчет числа вхождений данных. Сортировка подсчетом подходит для случаев, когда объем данных велик, но диапазон значений ограничен, и при этом данные можно преобразовать в положительные целые числа.</li> <li>Поразрядная сортировка выполняет сортировку данных путем последовательной сортировки по каждому разряду и требует, чтобы данные можно было представить в виде чисел фиксированной разрядности.</li> <li>В общем случае нам хотелось бы найти алгоритм сортировки, который одновременно обладал бы высокой эффективностью, стабильностью, выполнением на месте и адаптивностью. Но, как и в других разделах алгоритмов и структур данных, не существует одного алгоритма сортировки, способного удовлетворить всем этим требованиям одновременно. На практике приходится выбирать подходящий алгоритм в зависимости от свойств данных.</li> <li>На рисунке 11-19 сравниваются эффективность, стабильность, выполнение на месте и адаптивность основных алгоритмов сортировки.</li> </ul> <p> Рисунок 11-19   Сравнение алгоритмов сортировки </p>","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/summary/#2","level":3,"title":"2.   Вопросы и ответы","text":"<p>В: В каких случаях стабильность алгоритма сортировки является обязательной?</p> <p>В реальных задачах нам может понадобиться сортировать объекты по некоторому атрибуту. Например, у студентов есть два атрибута: имя и рост. Мы хотим выполнить многоуровневую сортировку: сначала отсортировать по имени и получить <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> , а затем отсортировать по росту. Если используемый алгоритм сортировки нестабилен, то мы можем получить <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> .</p> <p>Нетрудно увидеть, что в этом случае студенты D и C поменялись местами, порядок по имени разрушился, а именно этого мы и не хотим.</p> <p>В: Можно ли поменять местами порядок \"поиска справа налево\" и \"поиска слева направо\" в разделении с опорным элементом?</p> <p>Нет. Если в качестве опорного элемента выбирается самый левый элемент, необходимо сначала выполнять \"поиск справа налево\", а уже затем - \"поиск слева направо\". Этот вывод кажется немного неочевидным, поэтому разберем его подробнее.</p> <p>Последний шаг <code>partition()</code> - это обмен <code>nums[left]</code> и <code>nums[i]</code> . После обмена все элементы слева от опорного должны быть <code>&lt;=</code> опорного, а значит, перед этим обменом должно выполняться условие <code>nums[left] &gt;= nums[i]</code>. Если сначала выполнять \"поиск слева направо\", то в случае, когда не удается найти элемент больше опорного, цикл завершится в состоянии <code>i == j</code> , и при этом может оказаться, что <code>nums[j] == nums[i] &gt; nums[left]</code>. Иными словами, на последнем шаге обмена элемент, больший опорного, будет помещен в начало массива, из-за чего разделение завершится неверно.</p> <p>Например, для массива <code>[0, 0, 0, 0, 1]</code> , если сначала выполнять \"поиск слева направо\", после разделения получится <code>[1, 0, 0, 0, 0]</code> , а это неправильный результат.</p> <p>Если же выбрать <code>nums[right]</code> в качестве опорного элемента, то ситуация станет противоположной, и тогда сначала нужно выполнять \"поиск слева направо\".</p> <p>В: Почему при оптимизации глубины рекурсии в быстрой сортировке выбор короткого массива гарантирует, что глубина рекурсии не превысит \\(\\log n\\) ?</p> <p>Глубина рекурсии - это число текущих рекурсивных вызовов, которые еще не завершились. На каждом раунде разделения исходный массив разбивается на два подмассива. После оптимизации глубины рекурсии длина подмассива, в который мы продолжаем рекурсивный спуск, не превышает половины длины исходного массива. Если рассматривать худший случай, когда длина каждый раз становится ровно вдвое меньше, итоговая глубина рекурсии и будет равна \\(\\log n\\) .</p> <p>В исходной версии быстрой сортировки может происходить последовательный рекурсивный вызов для более длинных массивов; в худшем случае это будут длины \\(n\\) , \\(n - 1\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) , а глубина рекурсии окажется равной \\(n\\) . Оптимизация глубины рекурсии как раз и позволяет избежать такого сценария.</p> <p>В: Если все элементы массива равны, будет ли временная сложность быстрой сортировки равна \\(O(n^2)\\) ? Как справиться с таким вырождением?</p> <p>Да. Для этого случая можно рассмотреть разделение массива на три части: элементы меньше опорного, равные опорному и большие опорного. Рекурсию нужно продолжать только для частей меньше и больше опорного. При таком подходе массив, целиком состоящий из одинаковых элементов, будет отсортирован всего за один раунд разделения.</p> <p>В: Почему худшая временная сложность блочной сортировки равна \\(O(n^2)\\) ?</p> <p>В худшем случае все элементы попадут в один и тот же блок. Если затем сортировать этот блок алгоритмом со сложностью \\(O(n^2)\\) , то общая временная сложность тоже станет \\(O(n^2)\\) .</p>","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"Глава 5.   Стек и очередь","text":"<p>Abstract</p> <p>Стек и очередь - две базовые линейные структуры данных.</p> <p>Они соответственно воплощают принципы \"последним пришел - первым вышел\" и \"первым пришел - первым вышел\".</p>","path":["Глава 5. Стек и очередь","Глава 5. &nbsp; Стек и очередь"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>5.1   Стек</li> <li>5.2   Очередь</li> <li>5.3   Двусторонняя очередь</li> <li>5.4   Резюме</li> </ul>","path":["Глава 5. Стек и очередь","Глава 5. &nbsp; Стек и очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   Двусторонняя очередь","text":"<p>В обычной очереди мы можем удалять элементы только из головы и добавлять их только в хвост. Как показано на рисунке 5-7, двусторонняя очередь (double-ended queue) обеспечивает большую гибкость и позволяет выполнять добавление и удаление элементов как с головы, так и с хвоста.</p> <p></p> <p> Рисунок 5-7   Операции двусторонней очереди </p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   Основные операции с двусторонней очередью","text":"<p>Распространенные операции двусторонней очереди приведены в таблице 5-3. Конкретные названия методов зависят от используемого языка программирования.</p> <p> Таблица 5-3   Эффективность операций двусторонней очереди </p> Имя метода Описание Временная сложность <code>push_first()</code> Добавить элемент в голову очереди \\(O(1)\\) <code>push_last()</code> Добавить элемент в хвост очереди \\(O(1)\\) <code>pop_first()</code> Удалить элемент из головы очереди \\(O(1)\\) <code>pop_last()</code> Удалить элемент из хвоста очереди \\(O(1)\\) <code>peek_first()</code> Просмотреть элемент в голове очереди \\(O(1)\\) <code>peek_last()</code> Просмотреть элемент в хвосте очереди \\(O(1)\\) <p>Точно так же мы можем напрямую использовать уже реализованные в языках программирования классы двусторонней очереди:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# Инициализация двусторонней очереди\ndeq: deque[int] = deque()\n\n# Поместить элементы в очередь\ndeq.append(2)      # Добавить в хвост\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # Добавить в голову\ndeq.appendleft(1)\n\n# Просмотреть элементы\nfront: int = deq[0]  # Элемент в голове\nrear: int = deq[-1]  # Элемент в хвосте\n\n# Извлечь элементы из очереди\npop_front: int = deq.popleft()  # Извлечь элемент из головы\npop_rear: int = deq.pop()       # Извлечь элемент из хвоста\n\n# Получить длину двусторонней очереди\nsize: int = len(deq)\n\n# Проверить, пуста ли двусторонняя очередь\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* Инициализация двусторонней очереди */\ndeque&lt;int&gt; deque;\n\n/* Поместить элементы в очередь */\ndeque.push_back(2);   // Добавить в хвост\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Добавить в голову\ndeque.push_front(1);\n\n/* Просмотреть элементы */\nint front = deque.front(); // Элемент в голове\nint back = deque.back();   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.pop_front();  // Извлечь элемент из головы\ndeque.pop_back();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.size();\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* Инициализация двусторонней очереди */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* Поместить элементы в очередь */\ndeque.offerLast(2);   // Добавить в хвост\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Добавить в голову\ndeque.offerFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.peekFirst();  // Элемент в голове\nint peekLast = deque.peekLast();    // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nint popFirst = deque.pollFirst();  // Извлечь элемент из головы\nint popLast = deque.pollLast();    // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.size();\n\n/* Проверить, пуста ли двусторонняя очередь */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* Инициализация двусторонней очереди */\n// В C# двустороннюю очередь обычно моделируют через связный список LinkedList\nLinkedList&lt;int&gt; deque = new();\n\n/* Поместить элементы в очередь */\ndeque.AddLast(2);   // Добавить в хвост\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Добавить в голову\ndeque.AddFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.First.Value;  // Элемент в голове\nint peekLast = deque.Last.Value;    // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.RemoveFirst();  // Извлечь элемент из головы\ndeque.RemoveLast();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.Count;\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* Инициализация двусторонней очереди */\n// В Go list обычно используется как двусторонняя очередь\ndeque := list.New()\n\n/* Поместить элементы в очередь */\ndeque.PushBack(2)      // Добавить в хвост\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Добавить в голову\ndeque.PushFront(1)\n\n/* Просмотреть элементы */\nfront := deque.Front() // Элемент в голове\nrear := deque.Back()   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.Remove(front)    // Извлечь элемент из головы\ndeque.Remove(rear)     // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nsize := deque.Len()\n\n/* Проверить, пуста ли двусторонняя очередь */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* Инициализация двусторонней очереди */\n// В Swift нет встроенного класса двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nvar deque: [Int] = []\n\n/* Поместить элементы в очередь */\ndeque.append(2) // Добавить в хвост\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Добавить в голову\ndeque.insert(1, at: 0)\n\n/* Просмотреть элементы */\nlet peekFirst = deque.first! // Элемент в голове\nlet peekLast = deque.last! // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\n// При моделировании через Array сложность popFirst равна O(n)\nlet popFirst = deque.removeFirst() // Извлечь элемент из головы\nlet popLast = deque.removeLast() // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nlet size = deque.count\n\n/* Проверить, пуста ли двусторонняя очередь */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* Инициализация двусторонней очереди */\n// В JavaScript нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nconst deque = [];\n\n/* Поместить элементы в очередь */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Обрати внимание: поскольку это массив, метод unshift() имеет сложность O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Просмотреть элементы */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* Извлечь элементы из очереди */\n// Обрати внимание: поскольку это массив, метод shift() имеет сложность O(n)\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* Получить длину двусторонней очереди */\nconst size = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* Инициализация двусторонней очереди */\n// В TypeScript нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nconst deque: number[] = [];\n\n/* Поместить элементы в очередь */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Обрати внимание: поскольку это массив, метод unshift() имеет сложность O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Просмотреть элементы */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* Извлечь элементы из очереди */\n// Обрати внимание: поскольку это массив, метод shift() имеет сложность O(n)\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* Получить длину двусторонней очереди */\nconst size: number = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* Инициализация двусторонней очереди */\n// В Dart Queue определена как двусторонняя очередь\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* Поместить элементы в очередь */\ndeque.addLast(2);  // Добавить в хвост\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Добавить в голову\ndeque.addFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.first; // Элемент в голове\nint peekLast = deque.last;   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nint popFirst = deque.removeFirst(); // Извлечь элемент из головы\nint popLast = deque.removeLast();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* Инициализация двусторонней очереди */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Поместить элементы в очередь */\ndeque.push_back(2);  // Добавить в хвост\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Добавить в голову\ndeque.push_front(1);\n\n/* Просмотреть элементы */\nif let Some(front) = deque.front() { // Элемент в голове\n}\nif let Some(rear) = deque.back() {   // Элемент в хвосте\n}\n\n/* Извлечь элементы из очереди */\nif let Some(pop_front) = deque.pop_front() { // Извлечь элемент из головы\n}\nif let Some(pop_rear) = deque.pop_back() {   // Извлечь элемент из хвоста\n}\n\n/* Получить длину двусторонней очереди */\nlet size = deque.len();\n\n/* Проверить, пуста ли двусторонняя очередь */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// В C нет встроенной двусторонней очереди\n</code></pre> deque.kt<pre><code>/* Инициализация двусторонней очереди */\nval deque = LinkedList&lt;Int&gt;()\n\n/* Поместить элементы в очередь */\ndeque.offerLast(2)  // Добавить в хвост\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // Добавить в голову\ndeque.offerFirst(1)\n\n/* Просмотреть элементы */\nval peekFirst = deque.peekFirst() // Элемент в голове\nval peekLast = deque.peekLast()   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nval popFirst = deque.pollFirst() // Извлечь элемент из головы\nval popLast = deque.pollLast()   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nval size = deque.size\n\n/* Проверить, пуста ли двусторонняя очередь */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># Инициализация двусторонней очереди\n# В Ruby нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\ndeque = []\n\n# Поместить элементы в очередь\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# Обрати внимание: поскольку это массив, метод Array#unshift имеет сложность O(n)\ndeque.unshift(3)\ndeque.unshift(1)\n\n# Просмотреть элементы\npeek_first = deque.first\npeek_last = deque.last\n\n# Извлечь элементы из очереди\n# Обрати внимание: поскольку это массив, метод Array#shift имеет сложность O(n)\npop_front = deque.shift\npop_back = deque.pop\n\n# Получить длину двусторонней очереди\nsize = deque.length\n\n# Проверить, пуста ли двусторонняя очередь\nis_empty = size.zero?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8E%D1%8E%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20deq.append%282%29%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%83%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20deque%20%3D%22%2C%20deq%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%20%D0%BA%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%83%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20front%20%3D%22%2C%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20rear%20%3D%22%2C%20rear%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%8B%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20pop_front%20%3D%22%2C%20pop_front%29%0A%20%20%20%20print%28%22deque%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B8%D0%B7%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%8B%20%3D%22%2C%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20pop_rear%20%3D%22%2C%20pop_rear%29%0A%20%20%20%20print%28%22deque%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B8%D0%B7%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B0%20%3D%22%2C%20deq%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%D0%B9%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%D0%B9%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   Реализация двусторонней очереди *","text":"<p>Реализация двусторонней очереди похожа на реализацию обычной очереди: в качестве базовой структуры данных можно выбрать связный список или массив.</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   Реализация на основе двусвязного списка","text":"<p>Вспомним предыдущий раздел: там мы использовали обычный односвязный список для реализации очереди, потому что он позволяет удобно удалять головной узел, что соответствует операции <code>dequeue</code> , и добавлять новый узел после хвостового узла, что соответствует операции <code>enqueue</code> .</p> <p>Для двусторонней очереди и голова, и хвост допускают операции добавления и удаления элементов. Иначе говоря, двусторонняя очередь требует реализации еще одного симметричного направления операций. Поэтому в качестве базовой структуры данных двусторонней очереди удобно использовать двусвязный список.</p> <p>Как показано на рисунках ниже, мы рассматриваем головной и хвостовой узлы двусвязного списка как голову и хвост двусторонней очереди и одновременно реализуем функции добавления и удаления узлов с обеих сторон.</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 5-8   Операции enqueue и dequeue для двусторонней очереди на связном списке </p> <p>Код реализации приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"Узел двусвязного списка\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"Конструктор\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # Ссылка на узел-преемник\n        self.prev: ListNode | None = None  # Ссылка на узел-предшественник\n\nclass LinkedListDeque:\n    \"\"\"Двусторонняя очередь на основе двусвязного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._front: ListNode | None = None  # Головной узел front\n        self._rear: ListNode | None = None  # Хвостовой узел rear\n        self._size: int = 0  # Длина двусторонней очереди\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины двусторонней очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли двусторонняя очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"Операция добавления в очередь\"\"\"\n        node = ListNode(num)\n        # Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if self.is_empty():\n            self._front = self._rear = node\n        # Операция добавления в голову очереди\n        elif is_front:\n            # Добавить node в голову списка\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # Обновить головной узел\n        # Операция добавления в хвост очереди\n        else:\n            # Добавить node в хвост списка\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # Обновить хвостовой узел\n        self._size += 1  # Обновить длину очереди\n\n    def push_first(self, num: int):\n        \"\"\"Добавление в голову очереди\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"Добавление в хвост очереди\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"Операция извлечения из очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        # Операция извлечения из головы очереди\n        if is_front:\n            val: int = self._front.val  # Временно сохранить значение головного узла\n            # Удалить головной узел\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # Обновить головной узел\n        # Операция извлечения из хвоста очереди\n        else:\n            val: int = self._rear.val  # Временно сохранить значение хвостового узла\n            # Удалить хвостовой узел\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # Обновить хвостовой узел\n        self._size -= 1  # Обновить длину очереди\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Извлечение из головы очереди\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Извлечение из хвоста очереди\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Доступ к элементу в конце очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть массив для вывода\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* Узел двусвязного списка */\nstruct DoublyListNode {\n    int val;              // Значение узла\n    DoublyListNode *next; // Указатель на узел-преемник\n    DoublyListNode *prev; // Указатель на узел-предшественник\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize = 0;              // Длина двусторонней очереди\n\n  public:\n    /* Конструктор */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* Метод-деструктор */\n    ~LinkedListDeque() {\n        // Обходить связный список, удалять узлы и освобождать память\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* Получение длины двусторонней очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty())\n            front = rear = node;\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // Обновить головной узел\n        // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // Обновить хвостовой узел\n        }\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"очередь пуста\");\n        int val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front-&gt;val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // Обновить головной узел\n        // Операция извлечения из хвоста очереди\n        } else {\n            val = rear-&gt;val; // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // Обновить хвостовой узел\n        }\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return front-&gt;val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return rear-&gt;val;\n    }\n\n    /* Вернуть массив для вывода */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    int val; // Значение узла\n    ListNode next; // Ссылка на узел-преемник\n    ListNode prev; // Ссылка на узел-предшественник\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private ListNode front, rear; // Головной узел front, хвостовой узел rear\n    private int queSize = 0; // Длина двусторонней очереди\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty())\n            front = rear = node;\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front.prev = node;\n            node.next = front;\n            front = node; // Обновить головной узел\n        // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // Обновить хвостовой узел\n        }\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front.val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // Обновить головной узел\n        // Операция извлечения из хвоста очереди\n        } else {\n            val = rear.val; // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // Обновить хвостовой узел\n        }\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* Узел двусвязного списка */\nclass ListNode(int val) {\n    public int val = val;       // Значение узла\n    public ListNode? next = null; // Ссылка на узел-преемник\n    public ListNode? prev = null; // Ссылка на узел-предшественник\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    ListNode? front, rear; // Головной узел front, хвостовой узел rear\n    int queSize = 0;      // Длина двусторонней очереди\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front!.prev = node;\n            node.next = front;\n            front = node; // Обновить головной узел\n        }\n        // Операция добавления в хвост очереди\n        else {\n            // Добавить node в хвост списка\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // Обновить хвостовой узел\n        }\n\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front?.val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // Обновить головной узел\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            val = rear?.val;  // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // Обновить хвостовой узел\n        }\n\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* Вернуть массив для вывода */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* Двусторонняя очередь на основе двусвязного списка */\ntype linkedListDeque struct {\n    // Использовать встроенный пакет list\n    data *list.List\n}\n\n/* Инициализировать двустороннюю очередь */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* Поместить элемент в голову очереди */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* Поместить элемент в хвост очереди */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь элемент из головы очереди */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Извлечь элемент из хвоста очереди */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Доступ к элементу в конце очереди */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Получение длины очереди */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуста ли очередь */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на узел-преемник\n    weak var prev: ListNode? // Ссылка на узел-предшественник\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private var front: ListNode? // Головной узел front\n    private var rear: ListNode? // Хвостовой узел rear\n    private var _size: Int // Длина двусторонней очереди\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины двусторонней очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Операция добавления в очередь */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // Операция добавления в голову очереди\n        else if isFront {\n            // Добавить node в голову списка\n            front?.prev = node\n            node.next = front\n            front = node // Обновить головной узел\n        }\n        // Операция добавления в хвост очереди\n        else {\n            // Добавить node в хвост списка\n            rear?.next = node\n            node.prev = rear\n            rear = node // Обновить хвостовой узел\n        }\n        _size += 1 // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* Добавление в хвост очереди */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* Операция извлечения из очереди */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        let val: Int\n        // Операция извлечения из головы очереди\n        if isFront {\n            val = front!.val // Временно сохранить значение головного узла\n            // Удалить головной узел\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // Обновить головной узел\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            val = rear!.val // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // Обновить хвостовой узел\n        }\n        _size -= 1 // Обновить длину очереди\n        return val\n    }\n\n    /* Извлечение из головы очереди */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* Извлечение из хвоста очереди */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return front!.val\n    }\n\n    /* Доступ к элементу в конце очереди */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return rear!.val\n    }\n\n    /* Вернуть массив для вывода */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    prev; // Ссылка на узел-предшественник (указатель)\n    next; // Ссылка на узел-преемник (указатель)\n    val; // Значение узла\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    #front; // Головной узел front\n    #rear; // Хвостовой узел rear\n    #queSize; // Длина двусторонней очереди\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* Операция добавления в хвост очереди */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Добавить node в хвост списка\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // Обновить хвостовой узел\n        }\n        this.#queSize++;\n    }\n\n    /* Операция добавления в голову очереди */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Добавить node в голову списка\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // Обновить головной узел\n        }\n        this.#queSize++;\n    }\n\n    /* Операция извлечения из хвоста очереди */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // Сохранить значение хвостового узла\n        // Удалить хвостовой узел\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // Обновить хвостовой узел\n        this.#queSize--;\n        return value;\n    }\n\n    /* Операция извлечения из головы очереди */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // Сохранить значение хвостового узла\n        // Удалить головной узел\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // Обновить головной узел\n        this.#queSize--;\n        return value;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Вывести двустороннюю очередь */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    prev: ListNode; // Ссылка на узел-предшественник (указатель)\n    next: ListNode; // Ссылка на узел-преемник (указатель)\n    val: number; // Значение узла\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private front: ListNode; // Головной узел front\n    private rear: ListNode; // Хвостовой узел rear\n    private queSize: number; // Длина двусторонней очереди\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* Операция добавления в хвост очереди */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Добавить node в хвост списка\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // Обновить хвостовой узел\n        }\n        this.queSize++;\n    }\n\n    /* Операция добавления в голову очереди */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Добавить node в голову списка\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // Обновить головной узел\n        }\n        this.queSize++;\n    }\n\n    /* Операция извлечения из хвоста очереди */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // Сохранить значение хвостового узла\n        // Удалить хвостовой узел\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // Обновить хвостовой узел\n        this.queSize--;\n        return value;\n    }\n\n    /* Операция извлечения из головы очереди */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // Сохранить значение хвостового узла\n        // Удалить головной узел\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // Обновить головной узел\n        this.queSize--;\n        return value;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Вывести двустороннюю очередь */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n  int val; // Значение узла\n  ListNode? next; // Ссылка на узел-преемник\n  ListNode? prev; // Ссылка на узел-предшественник\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n  late ListNode? _front; // Головной узел _front\n  late ListNode? _rear; // Хвостовой узел _rear\n  int _queSize = 0; // Длина двусторонней очереди\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* Получить длину двусторонней очереди */\n  int size() {\n    return this._queSize;\n  }\n\n  /* Проверка, пуста ли двусторонняя очередь */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* Операция добавления в очередь */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // Если связный список пуст, пусть _front и _rear оба указывают на node\n      _front = _rear = node;\n    } else if (isFront) {\n      // Операция добавления в голову очереди\n      // Добавить node в начало связного списка\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // Обновить головной узел\n    } else {\n      // Операция добавления в хвост очереди\n      // Добавить node в конец связного списка\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // Обновить хвостовой узел\n    }\n    _queSize++; // Обновить длину очереди\n  }\n\n  /* Добавление в голову очереди */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* Добавление в хвост очереди */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* Операция извлечения из очереди */\n  int? pop(bool isFront) {\n    // Если очередь пуста, сразу вернуть null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // Операция извлечения из головы очереди\n      val = _front!.val; // Временно сохранить значение головного узла\n      // Удалить головной узел\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // Обновить головной узел\n    } else {\n      // Операция извлечения из хвоста очереди\n      val = _rear!.val; // Временно сохранить значение хвостового узла\n      // Удалить хвостовой узел\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // Обновить хвостовой узел\n    }\n    _queSize--; // Обновить длину очереди\n    return val;\n  }\n\n  /* Извлечение из головы очереди */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* Извлечение из хвоста очереди */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* Доступ к элементу в конце очереди */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* Вернуть массив для вывода */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* Узел двусвязного списка */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // Значение узла\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Указатель на узел-преемник\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Указатель на узел-предшественник\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Головной узел front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Хвостовой узел rear\n    que_size: usize,                         // Длина двусторонней очереди\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Получение длины двусторонней очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Операция добавления в очередь */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // Операция добавления в голову очереди\n        if is_front {\n            match self.front.take() {\n                // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // Добавить node в голову списка\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // Обновить головной узел\n                }\n            }\n        }\n        // Операция добавления в хвост очереди\n        else {\n            match self.rear.take() {\n                // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // Добавить node в хвост списка\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // Обновить хвостовой узел\n                }\n            }\n        }\n        self.que_size += 1; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // Если очередь пуста, сразу вернуть None\n        if self.is_empty() {\n            return None;\n        };\n        // Операция извлечения из головы очереди\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // Обновить головной узел\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // Обновить длину очереди\n                old_front.borrow().val\n            })\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // Обновить хвостовой узел\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // Обновить длину очереди\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* Извлечение из головы очереди */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Доступ к элементу в конце очереди */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* Вернуть массив для вывода */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* Узел двусвязного списка */\ntypedef struct DoublyListNode {\n    int val;                     // Значение узла\n    struct DoublyListNode *next; // Узел-преемник\n    struct DoublyListNode *prev; // Узел-предшественник\n} DoublyListNode;\n\n/* Конструктор */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* Деструктор */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\ntypedef struct {\n    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize;                  // Длина двусторонней очереди\n} LinkedListDeque;\n\n/* Конструктор */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Деструктор */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // Освободить все узлы\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Освободить структуру deque\n    free(deque);\n}\n\n/* Получение длины очереди */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* Поместить в очередь */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // Если связный список пуст, пусть front и rear оба указывают на node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // Операция добавления в голову очереди\n    else if (isFront) {\n        // Добавить node в голову списка\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // Обновить головной узел\n    }\n    // Операция добавления в хвост очереди\n    else {\n        // Добавить node в хвост списка\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // Обновить длину очереди\n}\n\n/* Добавление в голову очереди */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* Добавление в хвост очереди */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* Доступ к элементу в начале очереди */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* Доступ к элементу в конце очереди */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* Извлечь из очереди */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // Операция извлечения из головы очереди\n    if (isFront) {\n        val = peekFirst(deque); // Временно сохранить значение головного узла\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // Обновить головной узел\n    }\n    // Операция извлечения из хвоста очереди\n    else {\n        val = peekLast(deque); // Временно сохранить значение хвостового узла\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // Обновить хвостовой узел\n    }\n    deque-&gt;queSize--; // Обновить длину очереди\n    return val;\n}\n\n/* Извлечение из головы очереди */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* Извлечение из хвоста очереди */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* Вывести очередь */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // Скопировать данные связного списка в массив\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* Узел двусвязного списка */\nclass ListNode(var _val: Int) {\n    // Значение узла\n    var next: ListNode? = null // Ссылка на узел-преемник\n    var prev: ListNode? = null // Ссылка на узел-предшественник\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private var front: ListNode? = null // Головной узел front\n    private var rear: ListNode? = null // Хвостовой узел rear\n    private var queSize: Int = 0 // Длина двусторонней очереди\n\n    /* Получение длины двусторонней очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Операция добавления в очередь */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // Операция добавления в голову очереди\n        } else if (isFront) {\n            // Добавить node в голову списка\n            front?.prev = node\n            node.next = front\n            front = node // Обновить головной узел\n            // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear?.next = node\n            node.prev = rear\n            rear = node // Обновить хвостовой узел\n        }\n        queSize++ // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* Добавление в хвост очереди */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* Операция извлечения из очереди */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            _val = front!!._val // Временно сохранить значение головного узла\n            // Удалить головной узел\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // Обновить головной узел\n            // Операция извлечения из хвоста очереди\n        } else {\n            _val = rear!!._val // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // Обновить хвостовой узел\n        }\n        queSize-- // Обновить длину очереди\n        return _val\n    }\n\n    /* Извлечение из головы очереди */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* Извлечение из хвоста очереди */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* Вернуть массив для вывода */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n# ## Узел двусвязного списка\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # Ссылка на узел-преемник\n  attr_accessor :prev # Ссылка на узел-предшественник\n\n  ### Конструктор ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### Двусторонняя очередь на основе двусвязного списка ###\nclass LinkedListDeque\n  ### Получение длины двусторонней очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @front = nil  # Головной узел front\n    @rear = nil   # Хвостовой узел rear\n    @size = 0     # Длина двусторонней очереди\n  end\n\n  ### Проверка, пуста ли двусторонняя очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Операция добавления в очередь ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # Если связный список пуст, пусть front и rear оба указывают на node\n    if is_empty?\n      @front = @rear = node\n    # Операция добавления в голову очереди\n    elsif is_front\n      # Добавить node в голову списка\n      @front.prev = node\n      node.next = @front\n      @front = node # Обновить головной узел\n    # Операция добавления в хвост очереди\n    else\n      # Добавить node в хвост списка\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # Обновить хвостовой узел\n    end\n    @size += 1 # Обновить длину очереди\n  end\n\n  ### Добавление в голову очереди ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### Добавление в хвост очереди ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### Операция извлечения из очереди ###\n  def pop(is_front)\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    # Операция извлечения из головы очереди\n    if is_front\n      val = @front.val # Временно сохранить значение головного узла\n      # Удалить головной узел\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # Обновить головной узел\n    # Операция извлечения из хвоста очереди\n    else\n      val = @rear.val # Временно сохранить значение хвостового узла\n      # Удалить хвостовой узел\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # Обновить хвостовой узел\n    end\n    @size -= 1 # Обновить длину очереди\n\n    val\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_first\n    pop(true)\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_last\n    pop(false)\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek_first\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @front.val\n  end\n\n  ### Доступ к элементу в хвосте очереди ###\n  def peek_last\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @rear.val\n  end\n\n  ### Вернуть массив для вывода ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Как показано на рисунках ниже, аналогично реализации обычной очереди на массиве мы также можем использовать кольцевой массив для реализации двусторонней очереди.</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 5-9   Операции enqueue и dequeue для двусторонней очереди на массиве </p> <p>На основе реализации обычной очереди нужно лишь добавить методы добавления в голову очереди и удаления из хвоста:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"Двусторонняя очередь на основе кольцевого массива\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"Конструктор\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость двусторонней очереди\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины двусторонней очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли двусторонняя очередь\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"Вычислить индекс в кольцевом массиве\"\"\"\n        # С помощью операции взятия по модулю соединить начало и конец массива\n        # Когда i выходит за конец массива, он возвращается в начало\n        # Когда i выходит за начало массива, он возвращается в конец\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"Добавление в голову очереди\"\"\"\n        if self._size == self.capacity():\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        # Указатель головы сдвигается на одну позицию влево\n        # С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        self._front = self.index(self._front - 1)\n        # Добавить num в голову очереди\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"Добавление в хвост очереди\"\"\"\n        if self._size == self.capacity():\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        rear = self.index(self._front + self._size)\n        # Добавить num в хвост очереди\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Извлечение из головы очереди\"\"\"\n        num = self.peek_first()\n        # Указатель головы сдвигается на одну позицию назад\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Извлечение из хвоста очереди\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Доступ к элементу в конце очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        # Вычислить индекс хвостового элемента\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть массив для вывода\"\"\"\n        # Преобразовывать только элементы списка в пределах фактической длины\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // Массив для хранения элементов двусторонней очереди\n    int front;        // Указатель head, указывающий на первый элемент очереди\n    int queSize;      // Длина двусторонней очереди\n\n  public:\n    /* Конструктор */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* Получение длины двусторонней очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    int index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity();\n    }\n\n    /* Добавление в голову очереди */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Двусторонняя очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Двусторонняя очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    int popFirst() {\n        int num = peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        // Вычислить индекс хвостового элемента\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private int[] nums; // Массив для хранения элементов двусторонней очереди\n    private int front; // Указатель head, указывающий на первый элемент очереди\n    private int queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private int index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity();\n    }\n\n    /* Добавление в голову очереди */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    public int popFirst() {\n        int num = peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // Вычислить индекс хвостового элемента\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    int[] nums;  // Массив для хранения элементов двусторонней очереди\n    int front;   // Указатель head, указывающий на первый элемент очереди\n    int queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    int Index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* Добавление в голову очереди */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = Index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = Index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // Вычислить индекс хвостового элемента\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\ntype arrayDeque struct {\n    nums        []int // Массив для хранения элементов двусторонней очереди\n    front       int   // Указатель head, указывающий на первый элемент очереди\n    queSize     int   // Длина двусторонней очереди\n    queCapacity int   // Вместимость очереди (то есть максимальное число элементов)\n}\n\n/* Инициализация очереди */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Получение длины двусторонней очереди */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* Проверка, пуста ли двусторонняя очередь */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Вычислить индекс в кольцевом массиве */\nfunc (q *arrayDeque) index(i int) int {\n    // С помощью операции взятия по модулю соединить начало и конец массива\n    // Когда i выходит за конец массива, он возвращается в начало\n    // Когда i выходит за начало массива, он возвращается в конец\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* Добавление в голову очереди */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Двусторонняя очередь заполнена\")\n        return\n    }\n    // Указатель головы сдвигается на одну позицию влево\n    // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n    q.front = q.index(q.front - 1)\n    // Добавить num в голову очереди\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* Добавление в хвост очереди */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Двусторонняя очередь заполнена\")\n        return\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    rear := q.index(q.front + q.queSize)\n    // Добавить num в хвост очереди\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Извлечение из головы очереди */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // Указатель головы сдвигается на одну позицию назад\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* Извлечение из хвоста очереди */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Доступ к элементу в конце очереди */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // Вычислить индекс хвостового элемента\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* Получить Slice для вывода */\nfunc (q *arrayDeque) toSlice() []int {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private var nums: [Int] // Массив для хранения элементов двусторонней очереди\n    private var front: Int // Указатель head, указывающий на первый элемент очереди\n    private var _size: Int // Длина двусторонней очереди\n\n    /* Конструктор */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Получение длины двусторонней очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private func index(i: Int) -&gt; Int {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        (i + capacity()) % capacity()\n    }\n\n    /* Добавление в голову очереди */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(i: front - 1)\n        // Добавить num в голову очереди\n        nums[front] = num\n        _size += 1\n    }\n\n    /* Добавление в хвост очереди */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        let rear = index(i: front + size())\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Извлечение из головы очереди */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* Извлечение из хвоста очереди */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return nums[front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        // Вычислить индекс хвостового элемента\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    func toArray() -&gt; [Int] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    #nums; // Массив для хранения элементов двусторонней очереди\n    #front; // Указатель head, указывающий на первый элемент очереди\n    #queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    index(i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Добавление в голову очереди */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        this.#front = this.index(this.#front - 1);\n        // Добавить num в голову очереди\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // Добавить num в хвост очереди\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    popFirst() {\n        const num = this.peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Вычислить индекс хвостового элемента\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private nums: number[]; // Массив для хранения элементов двусторонней очереди\n    private front: number; // Указатель head, указывающий на первый элемент очереди\n    private queSize: number; // Длина двусторонней очереди\n\n    /* Конструктор */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    index(i: number): number {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Добавление в голову очереди */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        this.front = this.index(this.front - 1);\n        // Добавить num в голову очереди\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // Добавить num в хвост очереди\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Вычислить индекс хвостового элемента\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    toArray(): number[] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // Массив для хранения элементов двусторонней очереди\n  late int _front; // Указатель head, указывающий на первый элемент очереди\n  late int _queSize; // Длина двусторонней очереди\n\n  /* Конструктор */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* Получить вместимость двусторонней очереди */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* Получение длины двусторонней очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли двусторонняя очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Вычислить индекс в кольцевом массиве */\n  int index(int i) {\n    // С помощью операции взятия по модулю соединить начало и конец массива\n    // Когда i выходит за конец массива, он возвращается в начало\n    // Когда i выходит за начало массива, он возвращается в конец\n    return (i + capacity()) % capacity();\n  }\n\n  /* Добавление в голову очереди */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Двусторонняя очередь заполнена\");\n    }\n    // Указатель головы сместить влево на одну позицию\n    // С помощью операции взятия остатка реализовать возврат _front к хвосту после выхода за начало массива\n    _front = index(_front - 1);\n    // Добавить _num в голову очереди\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* Добавление в хвост очереди */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Двусторонняя очередь заполнена\");\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    int rear = index(_front + _queSize);\n    // Добавить _num в хвост очереди\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Извлечение из головы очереди */\n  int popFirst() {\n    int _num = peekFirst();\n    // Указатель головы сместить вправо на одну позицию\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* Извлечение из хвоста очереди */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"двусторонняя очередь пуста\");\n    }\n    return _nums[_front];\n  }\n\n  /* Доступ к элементу в конце очереди */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"двусторонняя очередь пуста\");\n    }\n    // Вычислить индекс хвостового элемента\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* Вернуть массив для вывода */\n  List&lt;int&gt; toArray() {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // Массив для хранения элементов двусторонней очереди\n    front: usize,    // Указатель head, указывающий на первый элемент очереди\n    que_size: usize, // Длина двусторонней очереди\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* Конструктор */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* Получение длины двусторонней очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* Добавление в голову очереди */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        self.front = self.index(self.front as i32 - 1);\n        // Добавить num в голову очереди\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* Добавление в хвост очереди */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // Добавить num в хвост очереди\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* Извлечение из головы очереди */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // Указатель головы сдвигается на одну позицию назад\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* Извлечение из хвоста очереди */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"двусторонняя очередь пуста\")\n        };\n        self.nums[self.front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"двусторонняя очередь пуста\")\n        };\n        // Вычислить индекс хвостового элемента\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\ntypedef struct {\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Указатель хвоста, указывающий на позицию после хвоста\n    int queCapacity; // Вместимость очереди\n} ArrayDeque;\n\n/* Конструктор */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // Инициализация массива\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Деструктор */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* Получить вместимость двусторонней очереди */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* Получение длины двусторонней очереди */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Проверка, пуста ли двусторонняя очередь */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* Вычислить индекс в кольцевом массиве */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // С помощью операции взятия остатка соединить начало и конец массива\n    // Когда i выходит за хвост массива, вернуться к началу\n    // Когда i выходит за голову массива, вернуться к концу\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* Добавление в голову очереди */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Дек заполнен\\r\\n\");\n        return;\n    }\n    // Указатель головы сместить влево на одну позицию\n    // С помощью операции взятия остатка реализовать возврат front к хвосту после выхода за начало массива\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // Добавить num в голову очереди\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* Добавление в хвост очереди */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Дек заполнен\\r\\n\");\n        return;\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // Добавить num в хвост очереди\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* Доступ к элементу в начале очереди */\nint peekFirst(ArrayDeque *deque) {\n    // Ошибка доступа: двусторонняя очередь пуста\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* Доступ к элементу в конце очереди */\nint peekLast(ArrayDeque *deque) {\n    // Ошибка доступа: двусторонняя очередь пуста\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* Извлечение из головы очереди */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // Указатель головы сдвигается на одну позицию назад\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Извлечение из хвоста очереди */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Вернуть массив для вывода */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* Конструктор */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // Массив для хранения элементов двусторонней очереди\n    private var front: Int = 0 // Указатель head, указывающий на первый элемент очереди\n    private var queSize: Int = 0 // Длина двусторонней очереди\n\n    /* Получить вместимость двусторонней очереди */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Получение длины двусторонней очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private fun index(i: Int): Int {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity()\n    }\n\n    /* Добавление в голову очереди */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1)\n        // Добавить num в голову очереди\n        nums[front] = num\n        queSize++\n    }\n\n    /* Добавление в хвост очереди */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        val rear = index(front + queSize)\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Извлечение из головы очереди */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* Извлечение из хвоста очереди */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Вычислить индекс хвостового элемента\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    fun toArray(): IntArray {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### Двусторонняя очередь на основе кольцевого массива ###\nclass ArrayDeque\n  ### Получение длины двусторонней очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### Получить вместимость двусторонней очереди ###\n  def capacity\n    @nums.length\n  end\n\n  ### Проверка, пуста ли двусторонняя очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Добавление в голову очереди ###\n  def push_first(num)\n    if size == capacity\n      puts 'Двусторонняя очередь заполнена'\n      return\n    end\n\n    # Указатель головы сдвигается на одну позицию влево\n    # С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n    @front = index(@front - 1)\n    # Добавить num в голову очереди\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### Добавление в хвост очереди ###\n  def push_last(num)\n    if size == capacity\n      puts 'Двусторонняя очередь заполнена'\n      return\n    end\n\n    # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    rear = index(@front + size)\n    # Добавить num в хвост очереди\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_first\n    num = peek_first\n    # Указатель головы сдвигается на одну позицию назад\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### Извлечение из хвоста очереди ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek_first\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Доступ к элементу в хвосте очереди ###\n  def peek_last\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    # Вычислить индекс хвостового элемента\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### Вернуть массив для вывода ###\n  def to_array\n    # Преобразовывать только элементы списка в пределах фактической длины\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### Вычислить индекс в кольцевом массиве ###\n  def index(i)\n    # С помощью операции взятия по модулю соединить начало и конец массива\n    # Когда i выходит за конец массива, он возвращается в начало\n    # Когда i выходит за начало массива, он возвращается в конец\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   Применение двусторонней очереди","text":"<p>Двусторонняя очередь сочетает в себе логику стека и очереди, поэтому она может покрыть все сценарии применения обеих структур и при этом предоставляет более высокую степень свободы.</p> <p>Мы знаем, что функция \"undo\" в программном обеспечении обычно реализуется с помощью стека: система помещает каждое изменение в стек с помощью <code>push</code> , а затем использует <code>pop</code> для отмены. Однако, учитывая ограниченность системных ресурсов, программы обычно ограничивают число шагов отмены, например разрешают хранить только \\(50\\) шагов. Когда длина стека превышает этот предел, программе нужно удалить элемент с дна стека, то есть с головы очереди. Но стек не может реализовать такую операцию, и в этом случае его приходится заменять двусторонней очередью. Обрати внимание: основная логика \"undo\" по-прежнему следует стековому правилу LIFO, просто двусторонняя очередь позволяет более гибко реализовать некоторые дополнительные механизмы.</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   Очередь","text":"<p>Очередь (queue) - это линейная структура данных, подчиняющаяся правилу \"первым пришел - первым вышел\". Как видно из названия, очередь моделирует обычную ситуацию ожидания: новые люди непрерывно присоединяются к хвосту очереди, а стоящие в начале по одному уходят.</p> <p>Как показано на рисунке 5-4, начало очереди называется головой очереди, а конец - хвостом очереди; операцию добавления элемента в хвост называют <code>enqueue</code>, а операцию удаления элемента из головы - <code>dequeue</code>.</p> <p></p> <p> Рисунок 5-4   Правило FIFO для очереди </p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   Основные операции с очередью","text":"<p>Распространенные операции с очередью показаны в таблице 5-2. Следует учитывать, что названия методов в разных языках могут различаться. Здесь мы используем те же названия, что и для стека.</p> <p> Таблица 5-2   Эффективность операций с очередью </p> Имя метода Описание Временная сложность <code>push()</code> Поместить элемент в очередь, то есть добавить его в хвост \\(O(1)\\) <code>pop()</code> Извлечь элемент из головы очереди \\(O(1)\\) <code>peek()</code> Просмотреть элемент в голове очереди \\(O(1)\\) <p>Обычно достаточно использовать готовые классы очереди, предоставляемые языками программирования:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# Инициализация очереди\n# В Python обычно используют двустороннюю очередь deque как обычную очередь\n# Хотя queue.Queue() является \"чистой\" очередью, она не слишком удобна, поэтому ее не рекомендуют\nque: deque[int] = deque()\n\n# Поместить элементы в очередь\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Просмотреть элемент в голове очереди\nfront: int = que[0]\n\n# Извлечь элемент из очереди\npop: int = que.popleft()\n\n# Получить длину очереди\nsize: int = len(que)\n\n# Проверить, пуста ли очередь\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* Инициализация очереди */\nqueue&lt;int&gt; queue;\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nint front = queue.front();\n\n/* Извлечь элемент из очереди */\nqueue.pop();\n\n/* Получить длину очереди */\nint size = queue.size();\n\n/* Проверить, пуста ли очередь */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* Инициализация очереди */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* Поместить элементы в очередь */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.peek();\n\n/* Извлечь элемент из очереди */\nint pop = queue.poll();\n\n/* Получить длину очереди */\nint size = queue.size();\n\n/* Проверить, пуста ли очередь */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* Инициализация очереди */\nQueue&lt;int&gt; queue = new();\n\n/* Поместить элементы в очередь */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.Peek();\n\n/* Извлечь элемент из очереди */\nint pop = queue.Dequeue();\n\n/* Получить длину очереди */\nint size = queue.Count;\n\n/* Проверить, пуста ли очередь */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* Инициализация очереди */\n// В Go очередь обычно реализуют через list\nqueue := list.New()\n\n/* Поместить элементы в очередь */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Просмотреть элемент в голове очереди */\npeek := queue.Front()\n\n/* Извлечь элемент из очереди */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Получить длину очереди */\nsize := queue.Len()\n\n/* Проверить, пуста ли очередь */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* Инициализация очереди */\n// В Swift нет встроенного класса очереди, поэтому можно использовать Array как очередь\nvar queue: [Int] = []\n\n/* Поместить элементы в очередь */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Просмотреть элемент в голове очереди */\nlet peek = queue.first!\n\n/* Извлечь элемент из очереди */\n// Поскольку в основе лежит массив, removeFirst имеет сложность O(n)\nlet pool = queue.removeFirst()\n\n/* Получить длину очереди */\nlet size = queue.count\n\n/* Проверить, пуста ли очередь */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* Инициализация очереди */\n// В JavaScript нет встроенной очереди, поэтому можно использовать Array как очередь\nconst queue = [];\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nconst peek = queue[0];\n\n/* Извлечь элемент из очереди */\n// В основе лежит массив, поэтому shift() имеет сложность O(n)\nconst pop = queue.shift();\n\n/* Получить длину очереди */\nconst size = queue.length;\n\n/* Проверить, пуста ли очередь */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* Инициализация очереди */\n// В TypeScript нет встроенной очереди, поэтому можно использовать Array как очередь\nconst queue: number[] = [];\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nconst peek = queue[0];\n\n/* Извлечь элемент из очереди */\n// В основе лежит массив, поэтому shift() имеет сложность O(n)\nconst pop = queue.shift();\n\n/* Получить длину очереди */\nconst size = queue.length;\n\n/* Проверить, пуста ли очередь */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* Инициализация очереди */\n// В Dart класс Queue является двусторонней очередью и может использоваться как обычная очередь\nQueue&lt;int&gt; queue = Queue();\n\n/* Поместить элементы в очередь */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.first;\n\n/* Извлечь элемент из очереди */\nint pop = queue.removeFirst();\n\n/* Получить длину очереди */\nint size = queue.length;\n\n/* Проверить, пуста ли очередь */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* Инициализация двусторонней очереди */\n// В Rust двусторонняя очередь может использоваться как обычная очередь\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Поместить элементы в очередь */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Просмотреть элемент в голове очереди */\nif let Some(front) = deque.front() {\n}\n\n/* Извлечь элемент из очереди */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Получить длину очереди */\nlet size = deque.len();\n\n/* Проверить, пуста ли очередь */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// В C нет встроенной очереди\n</code></pre> queue.kt<pre><code>/* Инициализация очереди */\nval queue = LinkedList&lt;Int&gt;()\n\n/* Поместить элементы в очередь */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* Просмотреть элемент в голове очереди */\nval peek = queue.peek()\n\n/* Извлечь элемент из очереди */\nval pop = queue.poll()\n\n/* Получить длину очереди */\nval size = queue.size\n\n/* Проверить, пуста ли очередь */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># Инициализация очереди\n# Встроенная очередь в Ruby (Thread::Queue) не имеет методов peek и traverse, поэтому можно использовать Array как очередь\nqueue = []\n\n# Поместить элементы в очередь\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# Просмотреть элемент очереди\npeek = queue.first\n\n# Извлечь элемент из очереди\n# Обрати внимание: поскольку это массив, метод Array#shift имеет сложность O(n)\npop = queue.shift\n\n# Получить длину очереди\nsize = queue.length\n\n# Проверить, пуста ли очередь\nis_empty = queue.empty?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20%23%20%D0%92%20Python%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8E%D1%8E%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20deque%20%D0%BE%D0%B1%D1%8B%D1%87%D0%BD%D0%BE%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D1%8E%D1%82%20%D0%BA%D0%B0%D0%BA%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20%23%20%D0%A5%D0%BE%D1%82%D1%8F%20queue.Queue%28%29%20%D1%8F%D0%B2%D0%BB%D1%8F%D0%B5%D1%82%D1%81%D1%8F%20%D0%BD%D0%B0%D1%81%D1%82%D0%BE%D1%8F%D1%89%D0%B8%D0%BC%20%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%BC%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%D1%81%D1%8F%20%D0%B8%D0%BC%20%D0%BD%D0%B5%20%D1%81%D0%BB%D0%B8%D1%88%D0%BA%D0%BE%D0%BC%20%D1%83%D0%B4%D0%BE%D0%B1%D0%BD%D0%BE%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20que%20%3D%22%2C%20que%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20front%20%3D%22%2C%20front%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20pop%20%3D%22%2C%20pop%29%0A%20%20%20%20print%28%22que%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%3D%22%2C%20que%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   Реализация очереди","text":"<p>Чтобы реализовать очередь, нам нужна такая структура данных, которая позволяет добавлять элементы с одного конца и удалять их с другого; и связный список, и массив этим требованиям удовлетворяют.</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   Реализация на основе связного списка","text":"<p>Как показано на рисунке 5-5, мы можем рассматривать головной узел и хвостовой узел связного списка как голову очереди и хвост очереди соответственно, договорившись, что добавлять узлы можно только в хвост, а удалять - только из головы.</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-5   Операции enqueue и dequeue в реализации очереди на связном списке </p> <p>Ниже приведен код реализации очереди на связном списке:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"Очередь на основе связного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._front: ListNode | None = None  # Головной узел front\n        self._rear: ListNode | None = None  # Хвостовой узел rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Поместить в очередь\"\"\"\n        # Добавить num после хвостового узла\n        node = ListNode(num)\n        # Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # Если очередь не пуста, добавить этот узел после хвостового узла\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из очереди\"\"\"\n        num = self.peek()\n        # Удалить головной узел\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"очередь пуста\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Преобразовать в список для вывода\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // Обходить связный список, удалять узлы и освобождать память\n        freeMemoryLinkedList(front);\n    }\n\n    /* Получение длины очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    void push(int num) {\n        // Добавить num после хвостового узла\n        ListNode *node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    int pop() {\n        int num = peek();\n        // Удалить головной узел\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // Освободить память\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"очередь пуста\");\n        return front-&gt;val;\n    }\n\n    /* Преобразовать связный список в Vector и вернуть */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private ListNode front, rear; // Головной узел front, хвостовой узел rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в очередь */\n    public void push(int num) {\n        // Добавить num после хвостового узла\n        ListNode node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node;\n            rear = node;\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int pop() {\n        int num = peek();\n        // Удалить головной узел\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    ListNode? front, rear;  // Головной узел front, хвостовой узел rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в очередь */\n    public void Push(int num) {\n        // Добавить num после хвостового узла\n        ListNode node = new(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node;\n            rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int Pop() {\n        int num = Peek();\n        // Удалить головной узел\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* Очередь на основе связного списка */\ntype linkedListQueue struct {\n    // Использовать встроенный пакет list для реализации очереди\n    data *list.List\n}\n\n/* Инициализация очереди */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* Поместить в очередь */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь из очереди */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Получение длины очереди */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуста ли очередь */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private var front: ListNode? // Головной узел\n    private var rear: ListNode? // Хвостовой узел\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в очередь */\n    func push(num: Int) {\n        // Добавить num после хвостового узла\n        let node = ListNode(x: num)\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* Извлечь из очереди */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Удалить головной узел\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"очередь пуста\")\n        }\n        return front!.val\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    #front; // Головной узел #front\n    #rear; // Хвостовой узел #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* Получение длины очереди */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num) {\n        // Добавить num после хвостового узла\n        const node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop() {\n        const num = this.peek();\n        // Удалить головной узел\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek() {\n        if (this.size === 0) throw new Error('очередь пуста');\n        return this.#front.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private front: ListNode | null; // Головной узел front\n    private rear: ListNode | null; // Хвостовой узел rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* Получение длины очереди */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num: number): void {\n        // Добавить num после хвостового узла\n        const node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('очередь пуста');\n        // Удалить головной узел\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek(): number {\n        if (this.size === 0) throw new Error('очередь пуста');\n        return this.front!.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n  ListNode? _front; // Головной узел _front\n  ListNode? _rear; // Хвостовой узел _rear\n  int _queSize = 0; // Длина очереди\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* Получение длины очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Поместить в очередь */\n  void push(int _num) {\n    // Добавить _num после хвостового узла\n    final node = ListNode(_num);\n    // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // Если очередь не пуста, добавить этот узел после хвостового узла\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* Извлечь из очереди */\n  int pop() {\n    final int _num = peek();\n    // Удалить головной узел\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('очередь пуста');\n    }\n    return _front!.val;\n  }\n\n  /* Преобразовать связный список в Array и вернуть */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* Очередь на основе связного списка */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Головной узел front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Хвостовой узел rear\n    que_size: usize,                         // Длина очереди\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Получение длины очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Проверка, пуста ли очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Поместить в очередь */\n    pub fn push(&amp;mut self, num: T) {\n        // Добавить num после хвостового узла\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* Извлечь из очереди */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* Доступ к элементу в начале очереди */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* Очередь на основе связного списка */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* Конструктор */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Деструктор */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // Освободить все узлы\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Освободить структуру queue\n    free(queue);\n}\n\n/* Получение длины очереди */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* Поместить в очередь */\nvoid push(LinkedListQueue *queue, int num) {\n    // Добавить node в хвост\n    ListNode *node = newListNode(num);\n    // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // Если очередь не пуста, добавить этот узел после хвостового узла\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* Доступ к элементу в начале очереди */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* Извлечь из очереди */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Вывести очередь */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // Скопировать данные связного списка в массив\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue(\n    // Головной узел front, хвостовой узел rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* Получение длины очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли очередь */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в очередь */\n    fun push(num: Int) {\n        // Добавить num после хвостового узла\n        val node = ListNode(num)\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node\n            rear = node\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* Извлечь из очереди */\n    fun pop(): Int {\n        val num = peek()\n        // Удалить головной узел\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### Очередь на основе связного списка ###\nclass LinkedListQueue\n  ### Получение длины очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @front = nil  # Головной узел front\n    @rear = nil   # Хвостовой узел rear\n    @size = 0\n  end\n\n  ### Проверка, пуста ли очередь ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### Добавление в очередь ###\n  def push(num)\n    # Добавить num после хвостового узла\n    node = ListNode.new(num)\n\n    # Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if @front.nil?\n      @front = node\n      @rear = node\n    # Если очередь не пуста, добавить этот узел после хвостового узла\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### Извлечение из очереди ###\n  def pop\n    num = peek\n    # Удалить головной узел\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek\n    raise IndexError, 'очередь пуста' if is_empty?\n\n    @front.val\n  end\n\n  ### Преобразовать связный список в Array и вернуть ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Удаление первого элемента из массива имеет временную сложность \\(O(n)\\) , из-за чего операция <code>dequeue</code> оказывается неэффективной. Однако этого можно избежать с помощью следующего приема.</p> <p>Мы можем использовать переменную <code>front</code> , указывающую на индекс элемента в голове очереди, и поддерживать переменную <code>size</code> , которая хранит длину очереди. Определим <code>rear = front + size</code> ; эта формула дает позицию <code>rear</code>, указывающую на ячейку сразу после хвоста очереди.</p> <p>Исходя из этого, эффективный диапазон элементов массива равен <code>[front, rear - 1]</code>, а различные операции реализуются, как показано на рисунке 5-6.</p> <ul> <li>Операция <code>enqueue</code>: записать входной элемент по индексу <code>rear</code> и увеличить <code>size</code> на 1.</li> <li>Операция <code>dequeue</code>: просто увеличить <code>front</code> на 1 и уменьшить <code>size</code> на 1.</li> </ul> <p>Можно увидеть, что и <code>enqueue</code> , и <code>dequeue</code> требуют всего одной операции, а значит обе имеют временную сложность \\(O(1)\\) .</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-6   Операции enqueue и dequeue в реализации очереди на массиве </p> <p>Ты можешь заметить еще одну проблему: при непрерывных операциях <code>enqueue</code> и <code>dequeue</code> значения <code>front</code> и <code>rear</code> оба движутся вправо, и когда они доходят до конца массива, дальше сдвигаться уже нельзя. Чтобы решить эту проблему, можно рассматривать массив как кольцевой массив, у которого начало и конец соединены.</p> <p>Для кольцевого массива нужно сделать так, чтобы <code>front</code> или <code>rear</code>, перешагнув конец массива, сразу возвращались к его началу и продолжали движение. Такую периодичность удобно реализовать с помощью операции взятия остатка, как показано в коде ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"Очередь на основе кольцевого массива\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"Конструктор\"\"\"\n        self._nums: list[int] = [0] * size  # Массив для хранения элементов очереди\n        self._front: int = 0  # Указатель head, указывающий на первый элемент очереди\n        self._size: int = 0  # Длина очереди\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость очереди\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Поместить в очередь\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"очередь заполнена\")\n        # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        # С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        rear: int = (self._front + self._size) % self.capacity()\n        # Добавить num в хвост очереди\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из очереди\"\"\"\n        num: int = self.peek()\n        # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"очередь пуста\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Вернуть список для вывода\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n  private:\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Длина очереди\n    int queCapacity; // Вместимость очереди\n\n  public:\n    ArrayQueue(int capacity) {\n        // Инициализация массива\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* Получить вместимость очереди */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* Получение длины очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в очередь */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"Очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % queCapacity;\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    int pop() {\n        int num = peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"очередь пуста\");\n        return nums[front];\n    }\n\n    /* Преобразовать массив в Vector и вернуть */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private int[] nums; // Массив для хранения элементов очереди\n    private int front; // Указатель head, указывающий на первый элемент очереди\n    private int queSize; // Длина очереди\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Получение длины очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % capacity();\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int pop() {\n        int num = peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Вернуть массив */\n    public int[] toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    int[] nums;  // Массив для хранения элементов очереди\n    int front;   // Указатель head, указывающий на первый элемент очереди\n    int queSize; // Длина очереди\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Получение длины очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % Capacity();\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int Pop() {\n        int num = Peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* Вернуть массив */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* Очередь на основе кольцевого массива */\ntype arrayQueue struct {\n    nums        []int // Массив для хранения элементов очереди\n    front       int   // Указатель head, указывающий на первый элемент очереди\n    queSize     int   // Длина очереди\n    queCapacity int   // Вместимость очереди (то есть максимальное число элементов)\n}\n\n/* Инициализация очереди */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Получение длины очереди */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* Проверка, пуста ли очередь */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Поместить в очередь */\nfunc (q *arrayQueue) push(num int) {\n    // Когда rear == queCapacity, очередь заполнена\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    rear := (q.front + q.queSize) % q.queCapacity\n    // Добавить num в хвост очереди\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Извлечь из очереди */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Получить Slice для вывода */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private var nums: [Int] // Массив для хранения элементов очереди\n    private var front: Int // Указатель head, указывающий на первый элемент очереди\n    private var _size: Int // Длина очереди\n\n    init(capacity: Int) {\n        // Инициализация массива\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Получить вместимость очереди */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Получение длины очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в очередь */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"Очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        let rear = (front + size()) % capacity()\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Извлечь из очереди */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"очередь пуста\")\n        }\n        return nums[front]\n    }\n\n    /* Вернуть массив */\n    func toArray() -&gt; [Int] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    #nums; // Массив для хранения элементов очереди\n    #front = 0; // Указатель head, указывающий на первый элемент очереди\n    #queSize = 0; // Длина очереди\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* Получить вместимость очереди */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* Получение длины очереди */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('Очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        const rear = (this.#front + this.size) % this.capacity;\n        // Добавить num в хвост очереди\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop() {\n        const num = this.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek() {\n        if (this.isEmpty()) throw new Error('очередь пуста');\n        return this.#nums[this.#front];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private nums: number[]; // Массив для хранения элементов очереди\n    private front: number; // Указатель head, указывающий на первый элемент очереди\n    private queSize: number; // Длина очереди\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Получение длины очереди */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('Очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        const rear = (this.front + this.queSize) % this.capacity;\n        // Добавить num в хвост очереди\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop(): number {\n        const num = this.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('очередь пуста');\n        return this.nums[this.front];\n    }\n\n    /* Вернуть Array */\n    toArray(): number[] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // Массив для хранения элементов очереди\n  late int _front; // Указатель head, указывающий на первый элемент очереди\n  late int _queSize; // Длина очереди\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* Получить вместимость очереди */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* Получение длины очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Поместить в очередь */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"Очередь заполнена\");\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    int rear = (_front + _queSize) % capaCity();\n    // Добавить _num в хвост очереди\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Извлечь из очереди */\n  int pop() {\n    int _num = peek();\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"очередь пуста\");\n    }\n    return _nums[_front];\n  }\n\n  /* Вернуть Array */\n  List&lt;int&gt; toArray() {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* Очередь на основе кольцевого массива */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // Массив для хранения элементов очереди\n    front: i32,        // Указатель head, указывающий на первый элемент очереди\n    que_size: i32,     // Длина очереди\n    que_capacity: i32, // Вместимость очереди\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* Конструктор */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* Получить вместимость очереди */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* Получение длины очереди */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* Проверка, пуста ли очередь */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Поместить в очередь */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // Добавить num в хвост очереди\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* Извлечь из очереди */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* Вернуть массив */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* Очередь на основе кольцевого массива */\ntypedef struct {\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Указатель хвоста, указывающий на позицию после хвоста\n    int queCapacity; // Вместимость очереди\n} ArrayQueue;\n\n/* Конструктор */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // Инициализация массива\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Деструктор */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* Получить вместимость очереди */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* Получение длины очереди */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* Доступ к элементу в начале очереди */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* Поместить в очередь */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"Очередь заполнена\\r\\n\");\n        return;\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // Добавить num в хвост очереди\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* Извлечь из очереди */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Вернуть массив для вывода */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // Массив для хранения элементов очереди\n    private var front: Int = 0 // Указатель head, указывающий на первый элемент очереди\n    private var queSize: Int = 0 // Длина очереди\n\n    /* Получить вместимость очереди */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Получение длины очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли очередь */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Поместить в очередь */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        val rear = (front + queSize) % capacity()\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Извлечь из очереди */\n    fun pop(): Int {\n        val num = peek()\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Вернуть массив */\n    fun toArray(): IntArray {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### Очередь на основе кольцевого массива ###\nclass ArrayQueue\n  ### Получение длины очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # Массив для хранения элементов очереди\n    @front = 0 # Указатель head, указывающий на первый элемент очереди\n    @size = 0 # Длина очереди\n  end\n\n  ### Получить вместимость очереди ###\n  def capacity\n    @nums.length\n  end\n\n  ### Проверка, пуста ли очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Добавление в очередь ###\n  def push(num)\n    raise IndexError, 'очередь заполнена' if size == capacity\n\n    # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    # С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    rear = (@front + size) % capacity\n    # Добавить num в хвост очереди\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Извлечение из очереди ###\n  def pop\n    num = peek\n    # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek\n    raise IndexError, 'очередь пуста' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Вернуть список для вывода ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Даже такая реализация очереди остается ограниченной: ее длина неизменяема. Однако это несложно исправить, заменив массив на динамический массив и тем самым введя механизм расширения. Заинтересованные читатели могут попробовать реализовать это самостоятельно.</p> <p>Выводы сравнения двух реализаций в целом такие же, как и для стека, поэтому здесь мы не будем повторяться.</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   Типичные применения очереди","text":"<ul> <li>Очереди заказов. После оформления заказа покупателем заказ попадает в очередь, а затем система обрабатывает заказы по порядку. Во время крупных распродаж за короткое время возникает огромный поток заказов, и высокая конкурентная нагрузка становится ключевой инженерной проблемой.</li> <li>Различные отложенные задачи. Любой сценарий, где нужно реализовать принцип \"кто раньше пришел, тот раньше обслуживается\", например очередь заданий принтера или очередь блюд на кухне ресторана, хорошо моделируется очередью, которая эффективно поддерживает нужный порядок обработки.</li> </ul>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   Стек","text":"<p>Стек (stack) - это линейная структура данных, подчиняющаяся логике \"последним пришел - первым вышел\".</p> <p>Стек можно сравнить со стопкой тарелок на столе. Если разрешено перемещать только одну тарелку за раз, то, чтобы достать тарелку снизу, сначала придется по одной убрать все тарелки сверху. Если заменить тарелки различными элементами, например целыми числами, символами, объектами и т.д., получится структура данных \"стек\".</p> <p>Как показано на рисунке 5-1, верхнюю часть стопки элементов мы называем вершиной стека, а нижнюю - основанием стека. Операция добавления элемента на вершину называется <code>push</code>, а операция удаления верхнего элемента - <code>pop</code>.</p> <p></p> <p> Рисунок 5-1   Правило LIFO для стека </p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   Основные операции со стеком","text":"<p>Основные операции со стеком показаны в таблице 5-1. Конкретные имена методов зависят от используемого языка программирования. Здесь в качестве примера используются распространенные названия <code>push()</code> , <code>pop()</code> и <code>peek()</code> .</p> <p> Таблица 5-1   Эффективность операций со стеком </p> Метод Описание Временная сложность <code>push()</code> Поместить элемент в стек (на вершину) \\(O(1)\\) <code>pop()</code> Извлечь верхний элемент стека \\(O(1)\\) <code>peek()</code> Просмотреть верхний элемент \\(O(1)\\) <p>Обычно достаточно использовать встроенный стек, предоставляемый языком программирования. Однако в некоторых языках специальный класс стека может отсутствовать. В таком случае можно использовать массив или связный список как стек и в логике программы игнорировать операции, не относящиеся к стеку.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># Инициализация стека\n# В Python нет встроенного класса стека, поэтому можно использовать list как стек\nstack: list[int] = []\n\n# Поместить элементы в стек\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Просмотреть верхний элемент\npeek: int = stack[-1]\n\n# Извлечь элемент\npop: int = stack.pop()\n\n# Получить длину стека\nsize: int = len(stack)\n\n# Проверить, пуст ли стек\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* Инициализация стека */\nstack&lt;int&gt; stack;\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nint top = stack.top();\n\n/* Извлечь элемент */\nstack.pop(); // Без возвращаемого значения\n\n/* Получить длину стека */\nint size = stack.size();\n\n/* Проверить, пуст ли стек */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* Инициализация стека */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.peek();\n\n/* Извлечь элемент */\nint pop = stack.pop();\n\n/* Получить длину стека */\nint size = stack.size();\n\n/* Проверить, пуст ли стек */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* Инициализация стека */\nStack&lt;int&gt; stack = new();\n\n/* Поместить элементы в стек */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.Peek();\n\n/* Извлечь элемент */\nint pop = stack.Pop();\n\n/* Получить длину стека */\nint size = stack.Count;\n\n/* Проверить, пуст ли стек */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* Инициализация стека */\n// В Go рекомендуется использовать Slice как стек\nvar stack []int\n\n/* Поместить элементы в стек */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Просмотреть верхний элемент */\npeek := stack[len(stack)-1]\n\n/* Извлечь элемент */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Получить длину стека */\nsize := len(stack)\n\n/* Проверить, пуст ли стек */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* Инициализация стека */\n// В Swift нет встроенного класса стека, поэтому можно использовать Array как стек\nvar stack: [Int] = []\n\n/* Поместить элементы в стек */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Просмотреть верхний элемент */\nlet peek = stack.last!\n\n/* Извлечь элемент */\nlet pop = stack.removeLast()\n\n/* Получить длину стека */\nlet size = stack.count\n\n/* Проверить, пуст ли стек */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* Инициализация стека */\n// В JavaScript нет встроенного класса стека, поэтому можно использовать Array как стек\nconst stack = [];\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nconst peek = stack[stack.length-1];\n\n/* Извлечь элемент */\nconst pop = stack.pop();\n\n/* Получить длину стека */\nconst size = stack.length;\n\n/* Проверить, пуст ли стек */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* Инициализация стека */\n// В TypeScript нет встроенного класса стека, поэтому можно использовать Array как стек\nconst stack: number[] = [];\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nconst peek = stack[stack.length - 1];\n\n/* Извлечь элемент */\nconst pop = stack.pop();\n\n/* Получить длину стека */\nconst size = stack.length;\n\n/* Проверить, пуст ли стек */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* Инициализация стека */\n// В Dart нет встроенного класса стека, поэтому можно использовать List как стек\nList&lt;int&gt; stack = [];\n\n/* Поместить элементы в стек */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.last;\n\n/* Извлечь элемент */\nint pop = stack.removeLast();\n\n/* Получить длину стека */\nint size = stack.length;\n\n/* Проверить, пуст ли стек */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* Инициализация стека */\n// Используем Vec как стек\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nlet top = stack.last().unwrap();\n\n/* Извлечь элемент */\nlet pop = stack.pop().unwrap();\n\n/* Получить длину стека */\nlet size = stack.len();\n\n/* Проверить, пуст ли стек */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// В C нет встроенного стека\n</code></pre> stack.kt<pre><code>/* Инициализация стека */\nval stack = Stack&lt;Int&gt;()\n\n/* Поместить элементы в стек */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* Просмотреть верхний элемент */\nval peek = stack.peek()\n\n/* Извлечь элемент */\nval pop = stack.pop()\n\n/* Получить длину стека */\nval size = stack.size\n\n/* Проверить, пуст ли стек */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># Инициализация стека\n# В Ruby нет встроенного класса стека, поэтому можно использовать Array как стек\nstack = []\n\n# Поместить элементы в стек\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# Просмотреть верхний элемент\npeek = stack.last\n\n# Извлечь элемент\npop = stack.pop\n\n# Получить длину стека\nsize = stack.length\n\n# Проверить, пуст ли стек\nis_empty = stack.empty?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20%23%20%D0%92%20Python%20%D0%BD%D0%B5%D1%82%20%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%2C%20%D0%BF%D0%BE%D1%8D%D1%82%D0%BE%D0%BC%D1%83%20list%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BA%D0%B0%D0%BA%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%D1%81%D1%82%D0%B5%D0%BA%20stack%20%3D%22%2C%20stack%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%D0%92%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20peek%20%3D%22%2C%20peek%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20pop%20%3D%22%2C%20pop%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20stack%20%3D%22%2C%20stack%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%20%D0%BB%D0%B8%20%D1%81%D1%82%D0%B5%D0%BA%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   Реализация стека","text":"<p>Чтобы глубже понять механизм работы стека, попробуем самостоятельно реализовать класс стека.</p> <p>Стек подчиняется принципу LIFO, поэтому мы можем добавлять и удалять элементы только на вершине. Однако и массив, и связный список позволяют добавлять и удалять элементы в произвольном месте. Следовательно, стек можно рассматривать как ограниченный массив или связный список. Иными словами, мы можем скрыть часть нерелевантных операций массива или списка, так чтобы внешняя логика соответствовала свойствам стека.</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   Реализация на основе связного списка","text":"<p>Если реализовывать стек на основе связного списка, то головной узел списка можно рассматривать как вершину стека, а хвостовой - как основание.</p> <p>Как показано на рисунке 5-2, для операции <code>push</code> достаточно вставить элемент в голову связного списка. Такой способ вставки называется вставкой в голову. Для операции <code>pop</code> достаточно удалить головной узел из списка.</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-2   Операции push и pop в реализации стека на связном списке </p> <p>Ниже приведен пример кода реализации стека на основе связного списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"Стек на основе связного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины стека\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуст ли стек\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"Поместить в стек\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из стека\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к верхнему элементу стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Преобразовать в список для вывода\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // Использовать головной узел как вершину стека\n    int stkSize;        // Длина стека\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // Обходить связный список, удалять узлы и освобождать память\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* Получение длины стека */\n    int size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // Освободить память\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"стек пуст\");\n        return stackTop-&gt;val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private ListNode stackPeek; // Использовать головной узел как вершину стека\n    private int stkSize = 0; // Длина стека\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    public int size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    ListNode? stackPeek;  // Использовать головной узел как вершину стека\n    int stkSize = 0;   // Длина стека\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* Стек на основе связного списка */\ntype linkedListStack struct {\n    // Использовать встроенный пакет list для реализации стека\n    data *list.List\n}\n\n/* Инициализация стека */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* Поместить в стек */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь из стека */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к верхнему элементу стека */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Получение длины стека */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуст ли стек */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private var _peek: ListNode? // Использовать головной узел как вершину стека\n    private var _size: Int // Длина стека\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины стека */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуст ли стек */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в стек */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* Извлечь из стека */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к верхнему элементу стека */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return _peek!.val\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    #stackPeek; // Использовать головной узел как вершину стека\n    #stkSize = 0; // Длина стека\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Поместить в стек */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* Извлечь из стека */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    peek() {\n        if (!this.#stackPeek) throw new Error('стек пуст');\n        return this.#stackPeek.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // Использовать головной узел как вершину стека\n    private stkSize: number = 0; // Длина стека\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Поместить в стек */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* Извлечь из стека */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('стек пуст');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('стек пуст');\n        return this.stackPeek.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* Стек на основе класса связного списка */\nclass LinkedListStack {\n  ListNode? _stackPeek; // Использовать головной узел как вершину стека\n  int _stkSize = 0; // Длина стека\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* Получение длины стека */\n  int size() {\n    return _stkSize;\n  }\n\n  /* Проверка, пуст ли стек */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* Поместить в стек */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* Извлечь из стека */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* Доступ к верхнему элементу стека */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* Преобразовать связный список в List и вернуть */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* Стек на основе связного списка */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Использовать головной узел как вершину стека\n    stk_size: usize,                              // Длина стека\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* Получение длины стека */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* Проверка, пуст ли стек */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* Поместить в стек */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* Извлечь из стека */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* Доступ к верхнему элементу стека */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* Стек на основе связного списка */\ntypedef struct {\n    ListNode *top; // Использовать головной узел как вершину стека\n    int size;      // Длина стека\n} LinkedListStack;\n\n/* Конструктор */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* Деструктор */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* Получение длины стека */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* Проверка, пуст ли стек */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* Поместить в стек */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // Обновить поле указателя нового узла\n    node-&gt;val = num;     // Обновить поле данных нового узла\n    s-&gt;top = node;       // Обновить вершину стека\n    s-&gt;size++;           // Обновить размер стека\n}\n\n/* Доступ к верхнему элементу стека */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"стек пуст\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* Извлечь из стека */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // Освободить память\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // Использовать головной узел как вершину стека\n    private var stkSize: Int = 0 // Длина стека\n) {\n\n    /* Получение длины стека */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* Проверка, пуст ли стек */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в стек */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* Извлечь из стека */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### Стек на основе связного списка ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @size = 0\n  end\n\n  ### Проверка, пуст ли стек ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### Помещение в стек ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### Извлечение из стека ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### Доступ к верхнему элементу стека ###\n  def peek\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @peek.val\n  end\n\n  ### Преобразовать связный список в Array и вернуть ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Если реализовывать стек на основе массива, то хвост массива можно рассматривать как вершину стека. Как показано на рисунке 5-3, операции <code>push</code> и <code>pop</code> соответствуют добавлению элемента в конец массива и удалению элемента из конца, обе имеют временную сложность \\(O(1)\\) .</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-3   Операции push и pop в реализации стека на массиве </p> <p>Поскольку количество элементов, помещаемых в стек, может непрерывно расти, мы можем использовать динамический массив и тем самым не заниматься расширением массива вручную. Ниже приведен пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"Стек на основе массива\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины стека\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуст ли стек\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"Поместить в стек\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к верхнему элементу стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Вернуть список для вывода\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* Получение длины стека */\n    int size() {\n        return stack.size();\n    }\n\n    /* Проверка, пуст ли стек */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* Поместить в стек */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* Извлечь из стека */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"стек пуст\");\n        return stack.back();\n    }\n\n    /* Вернуть Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // Инициализация списка (динамического массива)\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* Получение длины стека */\n    public int size() {\n        return stack.size();\n    }\n\n    /* Проверка, пуст ли стек */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* Извлечь из стека */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // Инициализация списка (динамического массива)\n        stack = [];\n    }\n\n    /* Получение длины стека */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* Проверка, пуст ли стек */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* Извлечь из стека */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* Стек на основе массива */\ntype arrayStack struct {\n    data []int // Данные\n}\n\n/* Инициализация стека */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // Установить длину стека равной 0, а емкость равной 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* Длина стека */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* Пуст ли стек */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* Поместить в стек */\nfunc (s *arrayStack) push(v int) {\n    // Срез автоматически расширяется\n    s.data = append(s.data, v)\n}\n\n/* Извлечь из стека */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* Получить элемент на вершине стека */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* Получить Slice для вывода */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // Инициализация списка (динамического массива)\n        stack = []\n    }\n\n    /* Получение длины стека */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* Проверка, пуст ли стек */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* Поместить в стек */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* Извлечь из стека */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return stack.removeLast()\n    }\n\n    /* Доступ к верхнему элементу стека */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return stack.last!\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* Получение длины стека */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* Поместить в стек */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    pop() {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.#stack.pop();\n    }\n\n    /* Доступ к верхнему элементу стека */\n    top() {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* Получение длины стека */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* Поместить в стек */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.stack.pop();\n    }\n\n    /* Доступ к верхнему элементу стека */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* Получение длины стека */\n  int size() {\n    return _stack.length;\n  }\n\n  /* Проверка, пуст ли стек */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* Поместить в стек */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* Извлечь из стека */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* Доступ к верхнему элементу стека */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stack.last;\n  }\n\n  /* Преобразовать стек в Array и вернуть */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* Стек на основе массива */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* Инициализация стека */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* Получение длины стека */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* Проверка, пуст ли стек */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* Поместить в стек */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"стек пуст\")\n        };\n        self.stack.last()\n    }\n\n    /* Вернуть &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* Стек на основе массива */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* Конструктор */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // Инициализировать большую вместимость, чтобы избежать расширения\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* Деструктор */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* Получение длины стека */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* Проверка, пуст ли стек */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* Поместить в стек */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"Стек заполнен\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* Доступ к верхнему элементу стека */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"стек пуст\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* Извлечь из стека */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    // Инициализация списка (динамического массива)\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* Получение длины стека */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* Проверка, пуст ли стек */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в стек */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* Извлечь из стека */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### Стек на основе массива ###\nclass ArrayStack\n  ### Конструктор ###\n  def initialize\n    @stack = []\n  end\n\n  ### Получить длину стека ###\n  def size\n    @stack.length\n  end\n\n  ### Проверка, пуст ли стек ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### Помещение в стек ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### Извлечение из стека ###\n  def pop\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @stack.pop\n  end\n\n  ### Доступ к верхнему элементу стека ###\n  def peek\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @stack.last\n  end\n\n  ### Вернуть список для вывода ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513","level":2,"title":"5.1.3   Сравнение двух реализаций","text":"<p>Поддерживаемые операции</p> <p>Обе реализации поддерживают все операции, определенные для стека. Реализация на массиве дополнительно позволяет выполнять произвольный доступ, но это уже выходит за рамки определения стека и обычно не используется.</p> <p>Временная эффективность</p> <p>В реализации на массиве и <code>push</code> , и <code>pop</code> выполняются в заранее выделенной непрерывной памяти, которая хорошо использует локальность кэша, поэтому такие операции обычно эффективнее. Однако если при <code>push</code> емкость массива оказывается превышена, включается механизм расширения, и временная сложность именно этой операции становится \\(O(n)\\) .</p> <p>В реализации на связном списке расширение выполняется очень гибко, и проблемы падения эффективности из-за расширения массива здесь нет. Но сама операция <code>push</code> требует инициализации объекта-узла и изменения указателей, поэтому в среднем она немного менее эффективна. Впрочем, если помещаемые в стек элементы уже сами являются объектами-узлами, шаг инициализации можно пропустить и тем самым повысить эффективность.</p> <p>Итак, когда элементами, помещаемыми и извлекаемыми из стека, являются базовые типы данных, например <code>int</code> или <code>double</code> , можно сделать следующие выводы.</p> <ul> <li>Стек на основе массива теряет в эффективности в моменты расширения, но поскольку расширение происходит редко, его средняя эффективность выше.</li> <li>Стек на основе связного списка может обеспечивать более стабильную производительность.</li> </ul> <p>Пространственная эффективность</p> <p>При инициализации массива система выделяет начальную емкость, которая может превышать реальную потребность. Кроме того, механизм расширения обычно увеличивает емкость по некоторому коэффициенту, например в 2 раза, и расширенная емкость тоже может оказаться больше фактически необходимой. Поэтому реализация стека на основе массива может приводить к некоторым потерям памяти.</p> <p>Однако, поскольку узлы связного списка должны дополнительно хранить указатели, узлы списка сами по себе занимают больше пространства.</p> <p>В итоге нельзя просто сказать, какая из реализаций более экономна по памяти; это нужно анализировать в контексте конкретной задачи.</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   Типичные применения стека","text":"<ul> <li>Кнопки \"назад\" и \"вперед\" в браузере, undo и redo в программах. Каждый раз, когда мы открываем новую страницу, браузер помещает предыдущую страницу в стек, чтобы по операции \"назад\" можно было вернуться к ней. Операция \"назад\" по сути является <code>pop</code> . Если нужно одновременно поддерживать и \"назад\", и \"вперед\", то обычно используются два стека.</li> <li>Управление памятью программы. Каждый раз при вызове функции система помещает на вершину стека стековый кадр, в котором хранится контекст функции. В рекурсивной функции на этапе углубления рекурсии непрерывно выполняются операции <code>push</code> , а на этапе возврата - операции <code>pop</code> .</li> </ul>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   Резюме","text":"","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   Основные выводы","text":"<ul> <li>Стек - это структура данных, следующая правилу \"последним пришел - первым вышел\", и его можно реализовать с помощью массива или связного списка.</li> <li>С точки зрения временной эффективности реализация стека на массиве обычно работает быстрее в среднем, но во время расширения емкости временная сложность отдельной операции <code>push</code> может ухудшаться до \\(O(n)\\) . Напротив, реализация стека на связном списке дает более стабильные характеристики.</li> <li>С точки зрения использования памяти реализация стека на массиве может приводить к некоторой потере пространства. Однако следует учитывать, что узлы связного списка занимают больше памяти, чем элементы массива.</li> <li>Очередь - это структура данных, следующая правилу \"первым пришел - первым вышел\", и ее также можно реализовать с помощью массива или связного списка. Сравнение временной и пространственной эффективности для очереди в целом приводит к тем же выводам, что и для стека.</li> <li>Двусторонняя очередь - это очередь с более высокой степенью свободы, которая позволяет добавлять и удалять элементы с обоих концов.</li> </ul>","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Реализованы ли кнопки \"вперед\" и \"назад\" в браузере с помощью двусвязного списка?</p> <p>По сути, функция переходов \"вперед/назад\" в браузере отражает логику стека. Когда пользователь открывает новую страницу, она помещается на вершину стека; когда пользователь нажимает кнопку \"назад\", эта страница снимается с вершины стека. Двусторонняя очередь позволяет удобно реализовать некоторые дополнительные операции, об этом уже упоминалось в разделе \"Двусторонняя очередь\".</p> <p>Q: Нужно ли освобождать память узла после извлечения его из стека?</p> <p>Если извлеченный узел еще понадобится, память освобождать не нужно. Если он больше не нужен, то в языках <code>Java</code> и <code>Python</code> есть автоматический сборщик мусора, поэтому ручное освобождение памяти не требуется; в <code>C</code> и <code>C++</code> память нужно освобождать вручную.</p> <p>Q: Двусторонняя очередь выглядит как два соединенных стека. Для чего она нужна?</p> <p>Двусторонняя очередь похожа на комбинацию стека и очереди или на два соединенных стека. Она объединяет логику обеих структур, поэтому может покрыть все их применения и при этом остается более гибкой.</p> <p>Q: Как именно реализуются отмена (undo) и повтор (redo)?</p> <p>Используются два стека: стек <code>A</code> для отмены и стек <code>B</code> для повтора.</p> <ol> <li>Каждый раз, когда пользователь выполняет действие, это действие помещается в стек <code>A</code> , а стек <code>B</code> очищается.</li> <li>Когда пользователь выполняет \"undo\", последнее действие извлекается из стека <code>A</code> и помещается в стек <code>B</code> .</li> <li>Когда пользователь выполняет \"redo\", последнее действие извлекается из стека <code>B</code> и помещается обратно в стек <code>A</code> .</li> </ol>","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"Глава 7.   Деревья","text":"<p>Abstract</p> <p>Высокое дерево полно жизни: мощные корни, густая листва и раскидистые ветви.</p> <p>Оно наглядно показывает нам живую форму данных, построенную на принципе \"разделяй и властвуй\".</p>","path":["Глава 7. Дерево","Глава 7. &nbsp; Деревья"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>7.1   Двоичное дерево</li> <li>7.2   Обход двоичного дерева</li> <li>7.3   Представление дерева массивом</li> <li>7.4   Двоичное дерево поиска</li> <li>7.5   AVL-дерево *</li> <li>7.6   Резюме</li> </ul>","path":["Глава 7. Дерево","Глава 7. &nbsp; Деревья"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   Представление двоичного дерева массивом","text":"<p>В представлении через связную структуру единицей хранения двоичного дерева является узел <code>TreeNode</code> , а между узлами существуют связи через указатели. В предыдущем разделе были рассмотрены основные операции двоичного дерева в таком представлении.</p> <p>Возникает вопрос: можно ли представить двоичное дерево с помощью массива? Ответ: да.</p>","path":["Глава 7. Дерево","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   Представление идеального двоичного дерева","text":"<p>Сначала разберем простой случай. Если дана идеальная двоичная структура и все ее узлы хранятся в массиве в порядке обхода по уровням, то каждому узлу будет соответствовать единственный индекс массива.</p> <p>Из свойств обхода по уровням можно вывести формулу соответствия между индексом родителя и индексами дочерних узлов: если индекс некоторого узла равен \\(i\\) , то индекс его левого дочернего узла равен \\(2i + 1\\) , а правого - \\(2i + 2\\) . На рисунке 7-12 показано соответствие между индексами разных узлов.</p> <p></p> <p> Рисунок 7-12   Представление идеального двоичного дерева массивом </p> <p>Эта формула соответствия играет ту же роль, что и ссылки на узлы в связной структуре . Имея любой узел в массиве, мы можем с ее помощью получить доступ к его левому и правому дочерним узлам.</p>","path":["Глава 7. Дерево","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   Представление произвольного двоичного дерева","text":"<p>Идеальное двоичное дерево - лишь частный случай; в обычной двоичной структуре на промежуточных уровнях часто существует множество <code>None</code> . Поскольку последовательность обхода по уровням не содержит этих <code>None</code> , мы не можем по одной лишь этой последовательности определить их количество и расположение. Это означает, что одному и тому же обходу по уровням может соответствовать сразу несколько различных структур двоичного дерева.</p> <p>Как показано на рисунке 7-13, для неполной двоичной структуры описанный выше способ представления массивом уже перестает работать.</p> <p></p> <p> Рисунок 7-13   Одной последовательности обхода по уровням соответствуют разные двоичные структуры </p> <p>Чтобы решить эту проблему, мы можем явно записывать все <code>None</code> в последовательности обхода по уровням . Как показано на рисунке 7-14, после такой обработки последовательность обхода по уровням уже сможет однозначно задавать двоичное дерево. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Представление двоичного дерева массивом\n# Используем None для обозначения пустых позиций\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем максимальное значение int, INT_MAX, для обозначения пустых позиций\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя обертку Integer для int, можно применять null для обозначения пустых позиций\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип int? , можно применять null для обозначения пустых позиций\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем срез типа any, чтобы можно было применять nil для обозначения пустых позиций\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип Int? , можно применять nil для обозначения пустых позиций\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип int? , можно применять null для обозначения пустых позиций\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем None для обозначения пустых позиций\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем максимальное значение int для обозначения пустых позиций, поэтому узлы не должны принимать значение INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### Представление двоичного дерева массивом ###\n# Используем nil для обозначения пустых позиций\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> Рисунок 7-14   Представление произвольного двоичного дерева массивом </p> <p>Стоит отметить, что полное двоичное дерево очень удобно представлять массивом . Если вспомнить определение полного двоичного дерева, то <code>None</code> появляются только на самом нижнем уровне и справа, а значит, все <code>None</code> обязательно находятся в конце последовательности обхода по уровням.</p> <p>Это означает, что при представлении полного двоичного дерева массивом можно не хранить все <code>None</code> , что очень удобно. На рисунке 7-15 приведен пример.</p> <p></p> <p> Рисунок 7-15   Представление полного двоичного дерева массивом </p> <p>Ниже приведен код реализации двоичного дерева, представленного массивом. Он включает следующие операции.</p> <ul> <li>Для заданного узла получить его значение, левого дочернего узла, правого дочернего узла и родительский узел.</li> <li>Получить последовательности прямого, симметричного, обратного обходов и обхода по уровням.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"Класс двоичного дерева в массивном представлении\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"Конструктор\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"Вместимость списка\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"Получить значение узла с индексом i\"\"\"\n        # Если индекс выходит за границы, вернуть None, обозначающий пустую позицию\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс левого дочернего узла узла с индексом i\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс правого дочернего узла узла с индексом i\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс родительского узла узла с индексом i\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"Обход в ширину\"\"\"\n        self.res = []\n        # Непосредственно обходить массив\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"Обход в глубину\"\"\"\n        if self.val(i) is None:\n            return\n        # Предварительный обход\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # Симметричный обход\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # Обратный обход\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"Предварительный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"Симметричный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"Обратный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n  public:\n    /* Конструктор */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* Вместимость списка */\n    int size() {\n        return tree.size();\n    }\n\n    /* Получить значение узла с индексом i */\n    int val(int i) {\n        // Если индекс выходит за границы, вернуть INT_MAX, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* Предварительный обход */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* Обход в глубину */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // Если это пустая позиция, вернуть\n        if (val(i) == INT_MAX)\n            return;\n        // Предварительный обход\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // Симметричный обход\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // Обратный обход\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* Конструктор */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* Вместимость списка */\n    public int size() {\n        return tree.size();\n    }\n\n    /* Получить значение узла с индексом i */\n    public Integer val(int i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // Если это пустая позиция, вернуть\n        if (val(i) == null)\n            return;\n        // Предварительный обход\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // Симметричный обход\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // Обратный обход\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* Предварительный обход */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* Вместимость списка */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* Получить значение узла с индексом i */\n    public int? Val(int i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // Если это пустая позиция, вернуть\n        if (!Val(i).HasValue)\n            return;\n        // Предварительный обход\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // Симметричный обход\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // Обратный обход\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* Предварительный обход */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* Класс двоичного дерева в массивном представлении */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* Конструктор */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* Вместимость списка */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* Получить значение узла с индексом i */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* Получить индекс левого дочернего узла узла с индексом i */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* Получить индекс правого дочернего узла узла с индексом i */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* Получить индекс родительского узла узла с индексом i */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* Обход в ширину */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // Непосредственно обходить массив\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* Обход в глубину */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // Если это пустая позиция, вернуть\n    if abt.val(i) == nil {\n        return\n    }\n    // Предварительный обход\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // Симметричный обход\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // Обратный обход\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* Предварительный обход */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* Симметричный обход */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* Обратный обход */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* Конструктор */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* Вместимость списка */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* Получить значение узла с индексом i */\n    func val(i: Int) -&gt; Int? {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // Непосредственно обходить массив\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* Обход в глубину */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // Если это пустая позиция, вернуть\n        guard let val = val(i: i) else {\n            return\n        }\n        // Предварительный обход\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // Симметричный обход\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // Обратный обход\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* Предварительный обход */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* Симметричный обход */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* Обратный обход */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* Конструктор */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* Вместимость списка */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* Получить значение узла с индексом i */\n    val(i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // Округление вниз при делении\n    }\n\n    /* Обход в ширину */\n    levelOrder() {\n        let res = [];\n        // Непосредственно обходить массив\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    #dfs(i, order, res) {\n        // Если это пустая позиция, вернуть\n        if (this.val(i) === null) return;\n        // Предварительный обход\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Симметричный обход\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Обратный обход\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Предварительный обход */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Обратный обход */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* Конструктор */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* Вместимость списка */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* Получить значение узла с индексом i */\n    val(i: number): number | null {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // Округление вниз при делении\n    }\n\n    /* Обход в ширину */\n    levelOrder(): number[] {\n        let res = [];\n        // Непосредственно обходить массив\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // Если это пустая позиция, вернуть\n        if (this.val(i) === null) return;\n        // Предварительный обход\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Симметричный обход\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Обратный обход\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Предварительный обход */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Обратный обход */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* Конструктор */\n  ArrayBinaryTree(this._tree);\n\n  /* Вместимость списка */\n  int size() {\n    return _tree.length;\n  }\n\n  /* Получить значение узла с индексом i */\n  int? val(int i) {\n    // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* Получить индекс левого дочернего узла узла с индексом i */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* Получить индекс правого дочернего узла узла с индексом i */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* Получить индекс родительского узла узла с индексом i */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* Обход в ширину */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* Обход в глубину */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // Если это пустая позиция, вернуть\n    if (val(i) == null) {\n      return;\n    }\n    // Предварительный обход\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // Симметричный обход\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // Обратный обход\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* Предварительный обход */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* Симметричный обход */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* Обратный обход */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* Класс двоичного дерева в массивном представлении */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* Конструктор */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* Вместимость списка */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* Получить значение узла с индексом i */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // Если индекс выходит за границы, вернуть None, обозначающий пустую позицию\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* Обход в глубину */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // Предварительный обход\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // Симметричный обход\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // Обратный обход\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* Предварительный обход */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* Симметричный обход */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* Обратный обход */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* Структура двоичного дерева в представлении массивом */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* Конструктор */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* Деструктор */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* Вместимость списка */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* Получить значение узла с индексом i */\nint val(ArrayBinaryTree *abt, int i) {\n    // Если индекс выходит за границы, вернуть INT_MAX, обозначающий пустую позицию\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* Обход в ширину */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // Непосредственно обходить массив\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* Обход в глубину */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // Если это пустая позиция, вернуть\n    if (val(abt, i) == INT_MAX)\n        return;\n    // Предварительный обход\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // Симметричный обход\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // Обратный обход\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* Предварительный обход */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Симметричный обход */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Обратный обход */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* Вместимость списка */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* Получить значение узла с индексом i */\n    fun _val(i: Int): Int? {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // Непосредственно обходить массив\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* Обход в глубину */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // Если это пустая позиция, вернуть\n        if (_val(i) == null)\n            return\n        // Предварительный обход\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // Симметричный обход\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // Обратный обход\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* Предварительный обход */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* Симметричный обход */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* Обратный обход */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### Класс двоичного дерева в массивном представлении ###\nclass ArrayBinaryTree\n  ### Конструктор ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### Вместимость списка ###\n  def size\n    @tree.length\n  end\n\n  ### Получить значение узла с индексом i ###\n  def val(i)\n    # Если индекс выходит за границы, вернуть nil, обозначающий пустую ячейку\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### Получить индекс левого дочернего узла узла с индексом i ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### Получить индекс правого дочернего узла узла с индексом i ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### Получить индекс родительского узла узла с индексом i ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### Обход в ширину ###\n  def level_order\n    @res = []\n\n    # Непосредственно обходить массив\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### Обход в глубину ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # Предварительный обход\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # Симметричный обход\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # Обратный обход\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### Предварительный обход ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### Симметричный обход ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### Обратный обход ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Дерево","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   Преимущества и ограничения","text":"<p>Представление двоичного дерева массивом имеет в основном следующие преимущества.</p> <ul> <li>Массив хранится в непрерывной области памяти, хорошо работает с кешем и обеспечивает высокую скорость доступа и обхода.</li> <li>Не нужно хранить указатели, поэтому память расходуется экономнее.</li> <li>Разрешается произвольный доступ к узлам.</li> </ul> <p>Однако у представления массивом есть и некоторые ограничения.</p> <ul> <li>Для хранения массива требуется непрерывная область памяти, поэтому такой способ не подходит для деревьев с очень большим объемом данных.</li> <li>Добавление и удаление узлов приходится реализовывать через вставку и удаление элементов массива, а это не слишком эффективно.</li> <li>Когда в двоичном дереве имеется большое число <code>None</code> , доля действительно полезных данных в массиве оказывается низкой, и эффективность использования пространства падает.</li> </ul>","path":["Глава 7. Дерево","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL-дерево *","text":"<p>В разделе \"Двоичное дерево поиска\" мы упоминали, что после многократных операций вставки и удаления узлов двоичное дерево поиска может выродиться в связный список. В таком случае временная сложность всех операций ухудшается с \\(O(\\log n)\\) до \\(O(n)\\) .</p> <p>Как показано на рисунке 7-24, после двух операций удаления узлов это двоичное дерево поиска вырождается в связный список.</p> <p></p> <p> Рисунок 7-24   Деградация AVL-дерева после удаления узлов </p> <p>Другой пример: если в идеальное двоичное дерево, показанное на рисунке 7-25, вставить два узла, то дерево сильно наклонится влево, а временная сложность поиска тоже ухудшится.</p> <p></p> <p> Рисунок 7-25   Деградация AVL-дерева после вставки узлов </p> <p>В 1962 году Г. М. Adelson-Velsky и Е. М. Landis в статье \"An algorithm for the organization of information\" предложили AVL-дерево. В статье подробно описан набор операций, гарантирующий, что при непрерывном добавлении и удалении узлов AVL-дерево не вырождается, благодаря чему временная сложность различных операций сохраняется на уровне \\(O(\\log n)\\) . Иначе говоря, в сценариях, где часто выполняются вставка, удаление, поиск и изменение, AVL-дерево всегда поддерживает эффективную работу с данными и потому имеет высокую практическую ценность.</p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl-","level":2,"title":"7.5.1   Распространенные термины AVL-дерева","text":"<p>AVL-дерево одновременно является и двоичным деревом поиска, и сбалансированным двоичным деревом, то есть одновременно удовлетворяет всем свойствам обеих этих структур. Поэтому AVL-дерево является разновидностью сбалансированного двоичного дерева поиска (balanced binary search tree).</p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   Высота узла","text":"<p>Поскольку операции AVL-дерева требуют получать высоту узла, нам нужно добавить в класс узла переменную <code>height</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Класс узла AVL-дерева\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # Значение узла\n        self.height: int = 0                # Высота узла\n        self.left: TreeNode | None = None   # Ссылка на левого дочернего узла\n        self.right: TreeNode | None = None  # Ссылка на правого дочернего узла\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nstruct TreeNode {\n    int val{};          // Значение узла\n    int height = 0;     // Высота узла\n    TreeNode *left{};   // Левый дочерний узел\n    TreeNode *right{};  // Правый дочерний узел\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    public int val;        // Значение узла\n    public int height;     // Высота узла\n    public TreeNode left;  // Левый дочерний узел\n    public TreeNode right; // Правый дочерний узел\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode(int? x) {\n    public int? val = x;    // Значение узла\n    public int height;      // Высота узла\n    public TreeNode? left;  // Ссылка на левого дочернего узла\n    public TreeNode? right; // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Структура узла AVL-дерева */\ntype TreeNode struct {\n    Val    int       // Значение узла\n    Height int       // Высота узла\n    Left   *TreeNode // Ссылка на левого дочернего узла\n    Right  *TreeNode // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    var val: Int // Значение узла\n    var height: Int // Высота узла\n    var left: TreeNode? // Левый дочерний узел\n    var right: TreeNode? // Правый дочерний узел\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    val; // Значение узла\n    height; // Высота узла\n    left; // Указатель на левого дочернего узла\n    right; // Указатель на правого дочернего узла\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    val: number;            // Значение узла\n    height: number;         // Высота узла\n    left: TreeNode | null;  // Указатель на левого дочернего узла\n    right: TreeNode | null; // Указатель на правого дочернего узла\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n  int val;         // Значение узла\n  int height;      // Высота узла\n  TreeNode? left;  // Левый дочерний узел\n  TreeNode? right; // Правый дочерний узел\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура узла AVL-дерева */\nstruct TreeNode {\n    val: i32,                               // Значение узла\n    height: i32,                            // Высота узла\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Левый дочерний узел\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Правый дочерний узел\n}\n\nimpl TreeNode {\n    /* Конструктор */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Структура узла AVL-дерева */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* Конструктор */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode(val _val: Int) {  // Значение узла\n    val height: Int = 0          // Высота узла\n    val left: TreeNode? = null   // Левый дочерний узел\n    val right: TreeNode? = null  // Правый дочерний узел\n}\n</code></pre> <pre><code>### Класс узла AVL-дерева ###\nclass TreeNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :height # Высота узла\n  attr_accessor :left   # Ссылка на левого дочернего узла\n  attr_accessor :right  # Ссылка на правого дочернего узла\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>\"Высота узла\" означает расстояние от этого узла до самого удаленного листового узла, то есть число пройденных \"ребер\". Особенно важно помнить, что высота листового узла равна \\(0\\) , а высота пустого узла равна \\(-1\\) . Мы создадим две вспомогательные функции: одну для получения высоты узла, другую для ее обновления:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Получить высоту узла\"\"\"\n    # Высота пустого узла равна -1, высота листового узла равна 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"Обновить высоту узла\"\"\"\n    # Высота узла равна высоте более высокого поддерева + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* Получить высоту узла */\nint height(TreeNode *node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode *node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* Получить высоту узла */\nint height(TreeNode node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* Получить высоту узла */\nint Height(TreeNode? node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid UpdateHeight(TreeNode node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* Получить высоту узла */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* Обновить высоту узла */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // Высота узла равна высоте более высокого поддерева + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* Получить высоту узла */\nfunc height(node: TreeNode?) -&gt; Int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    node?.height ?? -1\n}\n\n/* Обновить высоту узла */\nfunc updateHeight(node: TreeNode?) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* Получить высоту узла */\nheight(node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node === null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\n#updateHeight(node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* Получить высоту узла */\nheight(node: TreeNode): number {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node === null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nupdateHeight(node: TreeNode): void {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* Получить высоту узла */\nint height(TreeNode? node) {\n  // Высота пустого узла равна -1, высота листового узла равна 0\n  return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode? node) {\n  // Высота узла равна высоте более высокого поддерева + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* Получить высоту узла */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* Обновить высоту узла */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // Высота узла равна высоте более высокого поддерева + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Получить высоту узла */\nint height(TreeNode *node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // Высота узла равна высоте более высокого поддерева + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* Получить высоту узла */\nfun height(node: TreeNode?): Int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node?.height ?: -1\n}\n\n/* Обновить высоту узла */\nfun updateHeight(node: TreeNode?) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### Получить высоту узла ###\ndef height(node)\n  # Высота пустого узла равна -1, высота листового узла равна 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### Обновить высоту узла ###\ndef update_height(node)\n  # Высота узла равна высоте более высокого поддерева + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-","level":3,"title":"2.   Баланс-фактор узла","text":"<p>Баланс-фактор (balance factor) узла определяется как высота левого поддерева минус высота правого поддерева; при этом баланс-фактор пустого узла считается равным \\(0\\) . Мы также инкапсулируем получение баланс-фактора в отдельную функцию, чтобы потом было удобнее ее использовать:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Получить коэффициент баланса\"\"\"\n    # Коэффициент баланса пустого узла равен 0\n    if node is None:\n        return 0\n    # Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode *node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == nullptr)\n        return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null)\n        return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* Получить коэффициент баланса */\nint BalanceFactor(TreeNode? node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* Получить коэффициент баланса */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // Коэффициент баланса пустого узла равен 0\n    if node == nil {\n        return 0\n    }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* Получить коэффициент баланса */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // Коэффициент баланса пустого узла равен 0\n    guard let node = node else { return 0 }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* Получить коэффициент баланса */\nbalanceFactor(node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node === null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* Получить коэффициент баланса */\nbalanceFactor(node: TreeNode): number {\n    // Коэффициент баланса пустого узла равен 0\n    if (node === null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode? node) {\n  // Коэффициент баланса пустого узла равен 0\n  if (node == null) return 0;\n  // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* Получить коэффициент баланса */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // Коэффициент баланса пустого узла равен 0\n        None =&gt; 0,\n        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode *node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == NULL) {\n        return 0;\n    }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* Получить коэффициент баланса */\nfun balanceFactor(node: TreeNode?): Int {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null) return 0\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### Получить коэффициент баланса ###\ndef balance_factor(node)\n  # Коэффициент баланса пустого узла равен 0\n  return 0 if node.nil?\n\n  # Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>Пусть баланс-фактор равен \\(f\\) ; тогда для любого узла AVL-дерева выполняется \\(-1 \\le f \\le 1\\) .</p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl-","level":2,"title":"7.5.2   Вращения AVL-дерева","text":"<p>Особенность AVL-дерева заключается в операции \"вращения\", которая позволяет заново сбалансировать разбалансированный узел, не нарушая последовательность симметричного обхода двоичного дерева. Иначе говоря, операция вращения одновременно сохраняет свойство \"двоичного дерева поиска\" и возвращает дерево в состояние \"сбалансированного двоичного дерева\".</p> <p>Узлы, для которых абсолютное значение баланс-фактора больше \\(1\\) , мы называем \"разбалансированными узлами\". В зависимости от вида разбаланса вращения делятся на четыре типа: правое вращение, левое вращение, сначала левое затем правое, и сначала правое затем левое. Ниже разберем их подробно.</p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   Правое вращение","text":"<p>Как показано на рисунках ниже, под узлом указан его баланс-фактор. Если двигаться снизу вверх, то первым разбалансированным узлом в двоичном дереве будет \"узел 3\". Рассмотрим поддерево с этим узлом в качестве корня, обозначим данный узел как <code>node</code> , его левого дочернего узла как <code>child</code> и выполним \"правое вращение\". После завершения правого вращения поддерево снова станет сбалансированным и при этом сохранит свойство двоичного дерева поиска.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-26   Шаги правого вращения </p> <p>Как показано на рисунке 7-27, когда у узла <code>child</code> есть правый дочерний узел, который мы обозначим как <code>grand_child</code> , в правое вращение нужно добавить еще один шаг: сделать <code>grand_child</code> левым дочерним узлом <code>node</code> .</p> <p></p> <p> Рисунок 7-27   Правое вращение при наличии grand_child </p> <p>\"Поворот вправо\" - это лишь образное описание; в реальности он реализуется через изменение указателей узлов. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Операция правого вращения\"\"\"\n    child = node.left\n    grand_child = child.right\n    # Выполнить правое вращение узла node вокруг child\n    child.right = node\n    node.left = grand_child\n    # Обновить высоту узла\n    self.update_height(node)\n    self.update_height(child)\n    # Вернуть корневой узел поддерева после вращения\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Операция правого вращения */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // Выполнить правое вращение узла node вокруг child\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Операция правого вращения */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Операция правого вращения */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Операция правого вращения */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // Выполнить правое вращение узла node вокруг child\n    child.Right = node\n    node.Left = grandChild\n    // Обновить высоту узла\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Операция правого вращения */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // Выполнить правое вращение узла node вокруг child\n    child?.right = node\n    node?.left = grandChild\n    // Обновить высоту узла\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Операция правого вращения */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Операция правого вращения */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Операция правого вращения */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // Выполнить правое вращение узла node вокруг child\n  child.right = node;\n  node.left = grandChild;\n  // Обновить высоту узла\n  updateHeight(node);\n  updateHeight(child);\n  // Вернуть корневой узел поддерева после вращения\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Операция правого вращения */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // Выполнить правое вращение узла node вокруг child\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // Обновить высоту узла\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Вернуть корневой узел поддерева после вращения\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Операция правого вращения */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // Выполнить правое вращение узла node вокруг child\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Операция правого вращения */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node\n    node.left = grandChild\n    // Обновить высоту узла\n    updateHeight(node)\n    updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Операция правого вращения ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # Выполнить правое вращение узла node вокруг child\n  child.right = node\n  node.left = grand_child\n  # Обновить высоту узла\n  update_height(node)\n  update_height(child)\n  # Вернуть корневой узел поддерева после вращения\n  child\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   Левое вращение","text":"<p>Соответственно, если рассмотреть \"зеркальную\" версию приведенного выше разбалансированного двоичного дерева, то понадобится выполнить \"левое вращение\", показанное на рисунке 7-28.</p> <p></p> <p> Рисунок 7-28   Левое вращение </p> <p>По той же причине, когда у узла <code>child</code> есть левый дочерний узел, который обозначим как <code>grand_child</code> , в левое вращение также требуется добавить шаг: сделать <code>grand_child</code> правым дочерним узлом <code>node</code> .</p> <p></p> <p> Рисунок 7-29   Левое вращение при наличии grand_child </p> <p>Можно заметить, что операции правого и левого вращения логически зеркально симметричны, и два вида разбаланса, которые они исправляют, тоже симметричны. Поэтому, опираясь на эту симметрию, достаточно заменить в коде правого вращения все <code>left</code> на <code>right</code> , а все <code>right</code> на <code>left</code> , чтобы получить реализацию левого вращения:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Операция левого вращения\"\"\"\n    child = node.right\n    grand_child = child.left\n    # Выполнить левое вращение узла node вокруг child\n    child.left = node\n    node.right = grand_child\n    # Обновить высоту узла\n    self.update_height(node)\n    self.update_height(child)\n    # Вернуть корневой узел поддерева после вращения\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Операция левого вращения */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // Выполнить левое вращение узла node вокруг child\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Операция левого вращения */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Операция левого вращения */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Операция левого вращения */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // Выполнить левое вращение узла node вокруг child\n    child.Left = node\n    node.Right = grandChild\n    // Обновить высоту узла\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Операция левого вращения */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // Выполнить левое вращение узла node вокруг child\n    child?.left = node\n    node?.right = grandChild\n    // Обновить высоту узла\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Операция левого вращения */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Операция левого вращения */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Операция левого вращения */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // Выполнить левое вращение узла node вокруг child\n  child.left = node;\n  node.right = grandChild;\n  // Обновить высоту узла\n  updateHeight(node);\n  updateHeight(child);\n  // Вернуть корневой узел поддерева после вращения\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Операция левого вращения */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // Выполнить левое вращение узла node вокруг child\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // Обновить высоту узла\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Вернуть корневой узел поддерева после вращения\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Операция левого вращения */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // Выполнить левое вращение узла node вокруг child\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Операция левого вращения */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node\n    node.right = grandChild\n    // Обновить высоту узла\n    updateHeight(node)\n    updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Операция левого вращения ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # Выполнить левое вращение узла node вокруг child\n  child.left = node\n  node.right = grand_child\n  # Обновить высоту узла\n  update_height(node)\n  update_height(child)\n  # Вернуть корневой узел поддерева после вращения\n  child\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   Сначала левое, затем правое вращение","text":"<p>Для разбалансированного узла 3 на рисунке 7-30 ни одно лишь левое вращение, ни одно лишь правое вращение не способны вернуть поддерево в баланс. В этом случае нужно сначала выполнить \"левое вращение\" для <code>child</code> , а затем выполнить \"правое вращение\" для <code>node</code> .</p> <p></p> <p> Рисунок 7-30   Сначала левое, затем правое вращение </p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   Сначала правое, затем левое вращение","text":"<p>Как показано на рисунке 7-31, для зеркальной ситуации предыдущего разбалансированного двоичного дерева нужно сначала выполнить \"правое вращение\" для <code>child</code> , а затем \"левое вращение\" для <code>node</code> .</p> <p></p> <p> Рисунок 7-31   Сначала правое, затем левое вращение </p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   Выбор вращения","text":"<p>Четыре вида разбаланса, показанные на рисунке 7-32, по одному соответствуют рассмотренным выше случаям; для них соответственно требуются правое вращение, сначала левое затем правое, сначала правое затем левое и левое вращение.</p> <p></p> <p> Рисунок 7-32   Четыре случая вращений AVL-дерева </p> <p>Как показано в таблице 7-3, мы определяем, какому из этих четырех случаев соответствует разбалансированный узел, по знаку баланс-фактора самого разбалансированного узла и по знаку баланс-фактора дочернего узла на более высокой стороне.</p> <p> Таблица 7-3   Условия выбора для четырех случаев вращений </p> Баланс-фактор разбалансированного узла Баланс-фактор дочернего узла Какое вращение использовать \\(&gt; 1\\) (левостороннее дерево) \\(\\geq 0\\) Правое вращение \\(&gt; 1\\) (левостороннее дерево) \\(&lt;0\\) Сначала левое, затем правое \\(&lt; -1\\) (правостороннее дерево) \\(\\leq 0\\) Левое вращение \\(&lt; -1\\) (правостороннее дерево) \\(&gt;0\\) Сначала правое, затем левое <p>Для удобства мы инкапсулируем операцию вращения в отдельную функцию. С помощью этой функции можно выполнить корректное вращение для любой ситуации разбаланса и снова привести узел в сбалансированное состояние. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Выполнить вращение, чтобы снова сбалансировать поддерево\"\"\"\n    # Получить коэффициент баланса узла node\n    balance_factor = self.balance_factor(node)\n    # Левосторонне перекошенное дерево\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # Правое вращение\n            return self.right_rotate(node)\n        else:\n            # Сначала левое вращение, затем правое\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # Правосторонне перекошенное дерево\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # Левое вращение\n            return self.left_rotate(node)\n        else:\n            # Сначала правое вращение, затем левое\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode *rotate(TreeNode *node) {\n    // Получить коэффициент баланса узла node\n    int _balanceFactor = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode rotate(TreeNode node) {\n    // Получить коэффициент баланса узла node\n    int balanceFactor = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode? Rotate(TreeNode? node) {\n    // Получить коэффициент баланса узла node\n    int balanceFactorInt = BalanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // Правое вращение\n            return RightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // Левое вращение\n            return LeftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // Получить коэффициент баланса узла node\n    // В Go рекомендуется использовать короткие имена переменных, здесь bf обозначает t.balanceFactor\n    bf := t.balanceFactor(node)\n    // Левосторонне перекошенное дерево\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // Правое вращение\n            return t.rightRotate(node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // Левое вращение\n            return t.leftRotate(node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // Получить коэффициент баланса узла node\n    let balanceFactor = balanceFactor(node: node)\n    // Левосторонне перекошенное дерево\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // Правое вращение\n            return rightRotate(node: node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // Левое вращение\n            return leftRotate(node: node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\n#rotate(node) {\n    // Получить коэффициент баланса узла node\n    const balanceFactor = this.balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return this.#rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return this.#leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nrotate(node: TreeNode): TreeNode {\n    // Получить коэффициент баланса узла node\n    const balanceFactor = this.balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return this.rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return this.leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode? rotate(TreeNode? node) {\n  // Получить коэффициент баланса узла node\n  int factor = balanceFactor(node);\n  // Левосторонне перекошенное дерево\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // Правое вращение\n      return rightRotate(node);\n    } else {\n      // Сначала левое вращение, затем правое\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // Правосторонне перекошенное дерево\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // Левое вращение\n      return leftRotate(node);\n    } else {\n      // Сначала правое вращение, затем левое\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // Дерево сбалансировано, вращение не требуется, вернуть сразу\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // Получить коэффициент баланса узла node\n    let balance_factor = Self::balance_factor(node.clone());\n    // Левосторонне перекошенное дерево\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // Правое вращение\n            Self::right_rotate(Some(node))\n        } else {\n            // Сначала левое вращение, затем правое\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // Правосторонне перекошенное дерево\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // Левое вращение\n            Self::left_rotate(Some(node))\n        } else {\n            // Сначала правое вращение, затем левое\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // Дерево сбалансировано, вращение не требуется, вернуть сразу\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode *rotate(TreeNode *node) {\n    // Получить коэффициент баланса узла node\n    int bf = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfun rotate(node: TreeNode): TreeNode {\n    // Получить коэффициент баланса узла node\n    val balanceFactor = balanceFactor(node)\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Выполнить вращение, чтобы снова сбалансировать поддерево ###\ndef rotate(node)\n  # Получить коэффициент баланса узла node\n  balance_factor = balance_factor(node)\n  # Обойти левое поддерево\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # Правое вращение\n      return right_rotate(node)\n    else\n      # Сначала левое вращение, затем правое\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # Правостороннее дерево обхода\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # Левое вращение\n      return left_rotate(node)\n    else\n      # Сначала правое вращение, затем левое\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # Дерево сбалансировано, вращение не требуется, вернуть сразу\n  node\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl-","level":2,"title":"7.5.3   Распространенные операции AVL-дерева","text":"","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   Вставка узла","text":"<p>Операция вставки узла в AVL-дерево по основному процессу похожа на вставку в двоичное дерево поиска. Единственная разница состоит в том, что после вставки в AVL-дерево на пути от вставленного узла к корню может появиться цепочка разбалансированных узлов. Поэтому начиная от этого узла, мы должны выполнять вращения снизу вверх, чтобы вернуть в баланс все разбалансированные узлы. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"Вставка узла\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"Рекурсивная вставка узла (вспомогательный метод)\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. Найти позицию вставки и вставить узел\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # Повторяющийся узел не вставлять, сразу вернуть\n        return node\n    # Обновить высоту узла\n    self.update_height(node)\n    # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Вставка узла */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Вставка узла */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Вставка узла */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // Повторяющийся узел не вставлять, сразу вернуть\n    UpdateHeight(node);  // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = Rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Вставка узла */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* Рекурсивная вставка узла (вспомогательная функция) */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // Повторяющийся узел не вставлять, сразу вернуть\n        return node\n    }\n    // Обновить высоту узла\n    t.updateHeight(node)\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = t.rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Вставка узла */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // Повторяющийся узел не вставлять, сразу вернуть\n    }\n    updateHeight(node: node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node: node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Вставка узла */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // Повторяющийся узел не вставлять, сразу вернуть\n    this.#updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.#rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Вставка узла */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // Повторяющийся узел не вставлять, сразу вернуть\n    }\n    this.updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Вставка узла */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. Найти позицию вставки и вставить узел */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // Повторяющийся узел не вставлять, сразу вернуть\n  updateHeight(node); // Обновить высоту узла\n  /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n  node = rotate(node);\n  // Вернуть корневой узел поддерева\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Вставка узла */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Найти позицию вставки и вставить узел */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // Повторяющийся узел не вставлять, сразу вернуть\n                }\n            }\n            Self::update_height(Some(node.clone())); // Обновить высоту узла\n\n            /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n            node = Self::rotate(Some(node)).unwrap();\n            // Вернуть корневой узел поддерева\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Вставка узла */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательная функция) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // Повторяющийся узел не вставлять, сразу вернуть\n        return node;\n    }\n    // Обновить высоту узла\n    updateHeight(node);\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Вставка узла */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. Найти позицию вставки и вставить узел */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Вставка узла ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### Вставка узла ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n# ## Рекурсивная вставка узла (вспомогательный метод) ###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. Найти позицию вставки и вставить узел\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # Повторяющийся узел не вставлять, сразу вернуть\n    return node\n  end\n  # Обновить высоту узла\n  update_height(node)\n  # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n  rotate(node)\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   Удаление узла","text":"<p>Аналогично, на основе метода удаления узла из двоичного дерева поиска нужно добавить вращения снизу вверх, чтобы восстановить баланс всех разбалансированных узлов. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"Удаление узла\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"Рекурсивное удаление узла (вспомогательный метод)\"\"\"\n    if node is None:\n        return None\n    # 1. Найти узел и удалить его\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # Число дочерних узлов = 0, удалить node и сразу вернуть\n            if child is None:\n                return None\n            # Число дочерних узлов = 1, удалить node напрямую\n            else:\n                node = child\n        else:\n            # Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # Обновить высоту узла\n    self.update_height(node)\n    # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Удаление узла */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // Число дочерних узлов = 1, удалить node напрямую\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Удаление узла */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Удаление узла */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = Rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Удаление узла */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* Рекурсивное удаление узла (вспомогательная функция) */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. Найти узел и удалить его */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // Число дочерних узлов = 0, удалить node и сразу вернуть\n                return nil\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // Обновить высоту узла\n    t.updateHeight(node)\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = t.rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Удаление узла */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. Найти узел и удалить его */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if child == nil {\n                return nil\n            }\n            // Число дочерних узлов = 1, удалить node напрямую\n            else {\n                node = child\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node: node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Удаление узла */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child === null) return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.#rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Удаление узла */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child === null) {\n                return null;\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Удаление узла */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. Найти узел и удалить его */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // Число дочерних узлов = 0, удалить node и сразу вернуть\n      if (child == null)\n        return null;\n      // Число дочерних узлов = 1, удалить node напрямую\n      else\n        node = child;\n    } else {\n      // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // Обновить высоту узла\n  /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n  node = rotate(node);\n  // Вернуть корневой узел поддерева\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Удаление узла */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Найти узел и удалить его */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // Число дочерних узлов = 0, удалить node и сразу вернуть\n                    None =&gt; {\n                        return None;\n                    }\n                    // Число дочерних узлов = 1, удалить node напрямую\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // Обновить высоту узла\n\n            /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n            node = Self::rotate(Some(node)).unwrap();\n            // Вернуть корневой узел поддерева\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Удаление узла */\n// Из-за подключения stdio.h здесь нельзя использовать ключевое слово remove\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательная функция) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // Обновить высоту узла\n    updateHeight(node);\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Удаление узла */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. Найти узел и удалить его */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Удаление узла ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### Удаление узла ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n# ## Рекурсивное удаление узла (вспомогательный метод) ###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. Найти узел и удалить его\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # Число дочерних узлов = 0, удалить node и сразу вернуть\n      return if child.nil?\n      # Число дочерних узлов = 1, удалить node напрямую\n      node = child\n    else\n      # Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # Обновить высоту узла\n  update_height(node)\n  # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n  rotate(node)\nend\n</code></pre>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   Поиск узла","text":"<p>Операция поиска узла в AVL-дереве совпадает с поиском в двоичном дереве поиска, поэтому здесь она повторно не рассматривается.</p>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl-","level":2,"title":"7.5.4   Типичные применения AVL-дерева","text":"<ul> <li>Организация и хранение больших массивов данных, особенно в сценариях с частым поиском и относительно редкими вставками и удалениями.</li> <li>Использование при построении индексных систем в базах данных.</li> <li>Красно-черное дерево тоже является распространенным видом сбалансированного двоичного дерева поиска. По сравнению с AVL-деревом условия баланса у красно-черного дерева мягче, поэтому при вставке и удалении требуется меньше вращений, а средняя эффективность операций добавления и удаления выше.</li> </ul>","path":["Глава 7. Дерево","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   Двоичное дерево поиска","text":"<p>Как показано на рисунке 7-16, двоичное дерево поиска (binary search tree) удовлетворяет следующим условиям.</p> <ol> <li>Для корневого узла все значения в левом поддереве меньше значения корневого узла, а все значения в правом поддереве больше значения корневого узла.</li> <li>Левое и правое поддеревья любого узла также являются двоичными деревьями поиска, то есть тоже удовлетворяют условию <code>1.</code> .</li> </ol> <p></p> <p> Рисунок 7-16   Двоичное дерево поиска </p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   Операции с двоичным деревом поиска","text":"<p>Мы инкапсулируем двоичное дерево поиска в класс <code>BinarySearchTree</code> и объявляем переменную-член <code>root</code> , которая указывает на корневой узел дерева.</p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   Поиск узла","text":"<p>Для заданного целевого значения узла <code>num</code> можно выполнить поиск, опираясь на свойства двоичного дерева поиска. Как показано на рисунках ниже, мы объявляем узел <code>cur</code> , стартуем от корня дерева <code>root</code> и циклически сравниваем значения <code>cur.val</code> и <code>num</code> .</p> <ul> <li>Если <code>cur.val &lt; num</code> , это означает, что целевой узел находится в правом поддереве <code>cur</code> , поэтому выполняем <code>cur = cur.right</code> .</li> <li>Если <code>cur.val &gt; num</code> , это означает, что целевой узел находится в левом поддереве <code>cur</code> , поэтому выполняем <code>cur = cur.left</code> .</li> <li>Если <code>cur.val = num</code> , это означает, что целевой узел найден, и мы выходим из цикла, возвращая этот узел.</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-17   Пример поиска узла в двоичном дереве поиска </p> <p>Операция поиска в двоичном дереве поиска работает по тому же принципу, что и двоичный поиск: на каждом шаге она отбрасывает половину вариантов. Число итераций не превосходит высоты двоичного дерева, а когда дерево сбалансировано, требуется \\(O(\\log n)\\) времени. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"Поиск узла\"\"\"\n    cur = self._root\n    # Искать в цикле и выйти после прохода за листовой узел\n    while cur is not None:\n        # Целевой узел находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Целевой узел находится в левом поддереве cur\n        elif cur.val &gt; num:\n            cur = cur.left\n        # Найти целевой узел и выйти из цикла\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* Поиск узла */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Поиск узла */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Поиск узла */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* Поиск узла */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // Искать в цикле и выйти после прохода за листовой узел\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // Целевой узел находится в правом поддереве cur\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // Целевой узел находится в левом поддереве cur\n            node = node.Left\n        } else {\n            // Найти целевой узел и выйти из цикла\n            break\n        }\n    }\n    // Вернуть целевой узел\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Поиск узла */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Целевой узел находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Целевой узел находится в левом поддереве cur\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // Найти целевой узел и выйти из цикла\n        else {\n            break\n        }\n    }\n    // Вернуть целевой узел\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* Поиск узла */\nsearch(num) {\n    let cur = this.root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num) cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Поиск узла */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num) cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Поиск узла */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Целевой узел находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Целевой узел находится в левом поддереве cur\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // Найти целевой узел и выйти из цикла\n    else\n      break;\n  }\n  // Вернуть целевой узел\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Поиск узла */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Целевой узел находится в правом поддереве cur\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // Целевой узел находится в левом поддереве cur\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // Найти целевой узел и выйти из цикла\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // Вернуть целевой узел\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* Поиск узла */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // Целевой узел находится в правом поддереве cur\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // Целевой узел находится в левом поддереве cur\n            cur = cur-&gt;left;\n        } else {\n            // Найти целевой узел и выйти из цикла\n            break;\n        }\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Поиск узла */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Целевой узел находится в левом поддереве cur\n        else if (cur._val &gt; num)\n            cur.left\n        // Найти целевой узел и выйти из цикла\n        else\n            break\n    }\n    // Вернуть целевой узел\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### Поиск узла ###\ndef search(num)\n  cur = @root\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  while !cur.nil?\n    # Целевой узел находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Целевой узел находится в левом поддереве cur\n    elsif cur.val &gt; num\n      cur = cur.left\n    # Найти целевой узел и выйти из цикла\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   Вставка узла","text":"<p>Пусть дан элемент <code>num</code> , который нужно вставить. Чтобы сохранить свойство двоичного дерева поиска \"левое поддерево &lt; корень &lt; правое поддерево\", процесс вставки выглядит следующим образом.</p> <ol> <li>Найти позицию для вставки: как и в операции поиска, начиная от корня, мы циклически спускаемся вниз в зависимости от соотношения между текущим значением узла и <code>num</code> , пока не выйдем за листовой узел (то есть не дойдем до <code>None</code> ).</li> <li>Вставить узел в найденную позицию: инициализировать узел <code>num</code> и поставить его на место этого <code>None</code> .</li> </ol> <p></p> <p> Рисунок 7-18   Вставка узла в двоичное дерево поиска </p> <p>В реализации кода нужно обратить внимание на следующие два момента.</p> <ul> <li>Двоичное дерево поиска не допускает дублирующихся узлов, иначе его определение будет нарушено. Поэтому если вставляемый узел уже существует в дереве, вставка не выполняется и функция сразу возвращается.</li> <li>Чтобы реализовать вставку, нам нужно использовать узел <code>pre</code> для сохранения узла предыдущей итерации цикла. Тогда, когда обход дойдет до <code>None</code> , мы сможем получить его родителя и завершить вставку.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"Вставка узла\"\"\"\n    # Если дерево пусто, инициализировать корневой узел\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # Искать в цикле и выйти после прохода за листовой узел\n    cur, pre = self._root, None\n    while cur is not None:\n        # Найти повторяющийся узел и сразу вернуть\n        if cur.val == num:\n            return\n        pre = cur\n        # Позиция вставки находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Позиция вставки находится в левом поддереве cur\n        else:\n            cur = cur.left\n    # Вставка узла\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* Вставка узла */\nvoid insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur-&gt;left;\n    }\n    // Вставка узла\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Вставка узла */\nvoid insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Вставка узла\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Вставка узла */\nvoid Insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n\n    // Вставка узла\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Вставка узла */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // Если дерево пусто, инициализировать корневой узел\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // Позиция узла, предшествующего вставляемому\n    var pre *TreeNode = nil\n    // Искать в цикле и выйти после прохода за листовой узел\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // Вставка узла\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Вставка узла */\nfunc insert(num: Int) {\n    // Если дерево пусто, инициализировать корневой узел\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Найти повторяющийся узел и сразу вернуть\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // Позиция вставки находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Позиция вставки находится в левом поддереве cur\n        else {\n            cur = cur?.left\n        }\n    }\n    // Вставка узла\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Вставка узла */\ninsert(num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val === num) return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Вставка узла\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Вставка узла */\ninsert(num: number): void {\n    // Если дерево пусто, инициализировать корневой узел\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val === num) return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Вставка узла\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Вставка узла */\nvoid insert(int _num) {\n  // Если дерево пусто, инициализировать корневой узел\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Найти повторяющийся узел и сразу вернуть\n    if (cur.val == _num) return;\n    pre = cur;\n    // Позиция вставки находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Позиция вставки находится в левом поддереве cur\n    else\n      cur = cur.left;\n  }\n  // Вставка узла\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Вставка узла */\npub fn insert(&amp;mut self, num: i32) {\n    // Если дерево пусто, инициализировать корневой узел\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Найти повторяющийся узел и сразу вернуть\n            Ordering::Equal =&gt; return,\n            // Позиция вставки находится в правом поддереве cur\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Позиция вставки находится в левом поддереве cur\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Вставка узла\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Вставка узла */\nvoid insert(BinarySearchTree *bst, int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Позиция вставки находится в правом поддереве cur\n            cur = cur-&gt;right;\n        } else {\n            // Позиция вставки находится в левом поддереве cur\n            cur = cur-&gt;left;\n        }\n    }\n    // Вставка узла\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Вставка узла */\nfun insert(num: Int) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur._val == num)\n            return\n        pre = cur\n        // Позиция вставки находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur.left\n    }\n    // Вставка узла\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### Вставка узла ###\ndef insert(num)\n  # Если дерево пусто, инициализировать корневой узел\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Найти повторяющийся узел и сразу вернуть\n    return if cur.val == num\n\n    pre = cur\n    # Позиция вставки находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Позиция вставки находится в левом поддереве cur\n    else\n      cur = cur.left\n    end\n  end\n\n  # Вставка узла\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как и поиск узла, вставка узла требует \\(O(\\log n)\\) времени.</p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   Удаление узла","text":"<p>Сначала нужно найти в двоичном дереве целевой узел, а затем удалить его. Как и при вставке, после удаления необходимо сохранить свойство двоичного дерева поиска: \"левое поддерево &lt; корень &lt; правое поддерево\". Поэтому в зависимости от числа дочерних узлов у удаляемого узла, то есть для случаев со степенью 0, 1 и 2, выполняются разные операции удаления.</p> <p>Как показано на рисунке 7-19, когда степень удаляемого узла равна \\(0\\) , это значит, что узел является листом и может быть удален напрямую.</p> <p></p> <p> Рисунок 7-19   Удаление узла в двоичном дереве поиска (степень 0) </p> <p>Как показано на рисунке 7-20, когда степень удаляемого узла равна \\(1\\) , достаточно заменить удаляемый узел его дочерним узлом.</p> <p></p> <p> Рисунок 7-20   Удаление узла в двоичном дереве поиска (степень 1) </p> <p>Когда степень удаляемого узла равна \\(2\\) , мы уже не можем удалить его напрямую и должны использовать для замены другой узел. Чтобы сохранить свойство двоичного дерева поиска \"левое поддерево \\(&lt;\\) корень \\(&lt;\\) правое поддерево\", этим узлом может быть минимальный узел правого поддерева или максимальный узел левого поддерева.</p> <p>Предположим, мы выбираем минимальный узел правого поддерева, то есть следующий узел в симметричном обходе. Тогда процесс удаления выглядит так.</p> <ol> <li>Найти следующий узел в \"последовательности симметричного обхода\" для удаляемого узла и обозначить его как <code>tmp</code> .</li> <li>Значением <code>tmp</code> перезаписать значение удаляемого узла, а затем рекурсивно удалить узел <code>tmp</code> из дерева.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-21   Удаление узла в двоичном дереве поиска (степень 2) </p> <p>Операция удаления узла также требует \\(O(\\log n)\\) времени, где поиск удаляемого узла стоит \\(O(\\log n)\\) , а получение следующего узла симметричного обхода также требует \\(O(\\log n)\\) . Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"Удаление узла\"\"\"\n    # Если дерево пусто, сразу вернуть\n    if self._root is None:\n        return\n    # Искать в цикле и выйти после прохода за листовой узел\n    cur, pre = self._root, None\n    while cur is not None:\n        # Найти узел для удаления и выйти из цикла\n        if cur.val == num:\n            break\n        pre = cur\n        # Узел для удаления находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Узел для удаления находится в левом поддереве cur\n        else:\n            cur = cur.left\n    # Если узел для удаления отсутствует, сразу вернуть\n    if cur is None:\n        return\n\n    # Число дочерних узлов = 0 или 1\n    if cur.left is None or cur.right is None:\n        # Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        child = cur.left or cur.right\n        # Удалить узел cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # Если удаляемый узел является корнем, заново назначить корневой узел\n            self._root = child\n    # Число дочерних узлов = 2\n    else:\n        # Получить следующий узел после cur в симметричном обходе\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # Рекурсивно удалить узел tmp\n        self.remove(tmp.val)\n        # Перезаписать cur значением tmp\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* Удаление узла */\nvoid remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur-&gt;left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == nullptr)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n        // Освободить память\n        delete cur;\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Рекурсивно удалить узел tmp\n        remove(tmp-&gt;val);\n        // Перезаписать cur значением tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* Удаление узла */\nvoid remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        remove(tmp.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Удаление узла */\nvoid Remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        TreeNode? child = cur.left ?? cur.right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        Remove(tmp.val!.Value);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Удаление узла */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // Если дерево пусто, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Позиция узла, предшествующего удаляемому\n    var pre *TreeNode = nil\n    // Искать в цикле и выйти после прохода за листовой узел\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // Удаляемый узел находится в правом поддереве\n            cur = cur.Right\n        } else {\n            // Удаляемый узел находится в левом поддереве\n            cur = cur.Left\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Число дочерних узлов равно 0 или 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // Извлечь дочерний узел удаляемого узла\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // Удалить узел cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            bst.root = child\n        }\n        // Число дочерних узлов равно 2\n    } else {\n        // Получить следующий после cur узел в симметричном обходе для удаляемого узла\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // Рекурсивно удалить узел tmp\n        bst.remove(tmp.Val.(int))\n        // Перезаписать cur значением tmp\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Удаление узла */\nfunc remove(num: Int) {\n    // Если дерево пусто, сразу вернуть\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Найти узел для удаления и выйти из цикла\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // Узел для удаления находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Узел для удаления находится в левом поддереве cur\n        else {\n            cur = cur?.left\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Число дочерних узлов = 0 или 1\n    if cur?.left == nil || cur?.right == nil {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        let child = cur?.left ?? cur?.right\n        // Удалить узел cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // Рекурсивно удалить узел tmp\n        remove(num: tmp!.val)\n        // Перезаписать cur значением tmp\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Удаление узла */\nremove(num) {\n    // Если дерево пусто, сразу вернуть\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val === num) break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur === null) return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left === null || cur.right === null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        const child = cur.left !== null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            this.root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        this.remove(tmp.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Удаление узла */\nremove(num: number): void {\n    // Если дерево пусто, сразу вернуть\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val === num) break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur === null) return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left === null || cur.right === null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            this.root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // Рекурсивно удалить узел tmp\n        this.remove(tmp!.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Удаление узла */\nvoid remove(int _num) {\n  // Если дерево пусто, сразу вернуть\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Найти узел для удаления и выйти из цикла\n    if (cur.val == _num) break;\n    pre = cur;\n    // Узел для удаления находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Узел для удаления находится в левом поддереве cur\n    else\n      cur = cur.left;\n  }\n  // Если удаляемого узла нет, сразу вернуть\n  if (cur == null) return;\n  // Число дочерних узлов = 0 или 1\n  if (cur.left == null || cur.right == null) {\n    // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n    TreeNode? child = cur.left ?? cur.right;\n    // Удалить узел cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // Если удаляемый узел является корнем, заново назначить корневой узел\n      _root = child;\n    }\n  } else {\n    // Число дочерних узлов = 2\n    // Получить следующий узел после cur в симметричном обходе\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // Рекурсивно удалить узел tmp\n    remove(tmp.val);\n    // Перезаписать cur значением tmp\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Удаление узла */\npub fn remove(&amp;mut self, num: i32) {\n    // Если дерево пусто, сразу вернуть\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Найти узел для удаления и выйти из цикла\n            Ordering::Equal =&gt; break,\n            // Узел для удаления находится в правом поддереве cur\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Узел для удаления находится в левом поддереве cur\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // Число дочерних узлов = 0 или 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // Удалить узел cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // Если удаляемый узел является корнем, заново назначить корневой узел\n                self.root = child;\n            }\n        }\n        // Число дочерних узлов = 2\n        (Some(_), Some(_)) =&gt; {\n            // Получить следующий узел после cur в симметричном обходе\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // Рекурсивно удалить узел tmp\n            self.remove(tmp_val);\n            // Перезаписать cur значением tmp\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Удаление узла */\n// Из-за подключения stdio.h здесь нельзя использовать ключевое слово remove\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // Если дерево пусто, сразу вернуть\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Удаляемый узел находится в правом поддереве root\n            cur = cur-&gt;right;\n        } else {\n            // Удаляемый узел находится в левом поддереве root\n            cur = cur-&gt;left;\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == NULL)\n        return;\n    // Проверить, есть ли дочерние узлы у удаляемого узла\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* Число дочерних узлов = 0 или 1 */\n        // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // Удалить узел cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // Освободить память\n        free(cur);\n    } else {\n        /* Число дочерних узлов = 2 */\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Рекурсивно удалить узел tmp\n        removeItem(bst, tmp-&gt;val);\n        // Перезаписать cur значением tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Удаление узла */\nfun remove(num: Int) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur._val == num)\n            break\n        pre = cur\n        // Узел для удаления находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur.left\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child\n        }\n        // Число дочерних узлов = 2\n    } else {\n        // Получить следующий узел после cur в симметричном обходе\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // Рекурсивно удалить узел tmp\n        remove(tmp._val)\n        // Перезаписать cur значением tmp\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### Удаление узла ###\ndef remove(num)\n  # Если дерево пусто, сразу вернуть\n  return if @root.nil?\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Найти узел для удаления и выйти из цикла\n    break if cur.val == num\n\n    pre = cur\n    # Узел для удаления находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Узел для удаления находится в левом поддереве cur\n    else\n      cur = cur.left\n    end\n  end\n  # Если узел для удаления отсутствует, сразу вернуть\n  return if cur.nil?\n\n  # Число дочерних узлов = 0 или 1\n  if cur.left.nil? || cur.right.nil?\n    # Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n    child = cur.left || cur.right\n    # Удалить узел cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # Если удаляемый узел является корнем, заново назначить корневой узел\n      @root = child\n    end\n  # Число дочерних узлов = 2\n  else\n    # Получить следующий узел после cur в симметричном обходе\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # Рекурсивно удалить узел tmp\n    remove(tmp.val)\n    # Перезаписать cur значением tmp\n    cur.val = tmp.val\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   Упорядоченность симметричного обхода","text":"<p>Как показано на рисунке 7-22, симметричный обход двоичного дерева следует порядку \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\", а двоичное дерево поиска удовлетворяет соотношению \"левый дочерний узел \\(&lt;\\) корень \\(&lt;\\) правый дочерний узел\".</p> <p>Это означает, что при симметричном обходе двоичного дерева поиска мы всегда сначала будем посещать следующий минимальный узел, и отсюда получается важное свойство: последовательность симметричного обхода двоичного дерева поиска является возрастающей.</p> <p>Используя это свойство возрастающей последовательности симметричного обхода, мы можем получить отсортированные данные из двоичного дерева поиска всего за \\(O(n)\\) времени, без дополнительной сортировки, что очень эффективно.</p> <p></p> <p> Рисунок 7-22   Последовательность симметричного обхода двоичного дерева поиска </p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   Эффективность двоичного дерева поиска","text":"<p>Для заданного набора данных можно рассмотреть хранение либо в массиве, либо в двоичном дереве поиска. Из таблицы ниже видно, что временная сложность операций двоичного дерева поиска имеет логарифмический порядок и обеспечивает стабильную высокую производительность. Только в сценариях с очень частыми вставками и редкими поисками и удалениями массив может быть эффективнее, чем двоичное дерево поиска.</p> <p> Таблица 7-2   Сравнение эффективности массива и дерева поиска </p> Неупорядоченный массив Двоичное дерево поиска Поиск элемента \\(O(n)\\) \\(O(\\log n)\\) Вставка элемента \\(O(1)\\) \\(O(\\log n)\\) Удаление элемента \\(O(n)\\) \\(O(\\log n)\\) <p>В идеальном случае двоичное дерево поиска является \"сбалансированным\", и тогда любой узел можно найти за \\(\\log n\\) итераций.</p> <p>Однако если в двоичное дерево поиска непрерывно вставлять и удалять узлы, оно может выродиться в связный список, как показано на рисунке 7-23. Тогда временная сложность различных операций тоже вырождается до \\(O(n)\\) .</p> <p></p> <p> Рисунок 7-23   Деградация двоичного дерева поиска </p>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   Типичные применения двоичного дерева поиска","text":"<ul> <li>Используется как многоуровневый индекс в системах, обеспечивая эффективный поиск, вставку и удаление.</li> <li>Служит базовой структурой данных для некоторых поисковых алгоритмов.</li> <li>Применяется для хранения потока данных в отсортированном состоянии.</li> </ul>","path":["Глава 7. Дерево","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   Двоичное дерево","text":"<p>Двоичное дерево (binary tree) - это нелинейная структура данных, представляющая отношения между \"предками\" и \"потомками\" и отражающая логику \"разделяй и властвуй\". Подобно связному списку, базовой единицей двоичного дерева является узел; каждый узел содержит значение, ссылку на левого дочернего узла и ссылку на правого дочернего узла.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Класс узла двоичного дерева\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Значение узла\n        self.left: TreeNode | None = None  # Ссылка на левого дочернего узла\n        self.right: TreeNode | None = None # Ссылка на правого дочернего узла\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\nstruct TreeNode {\n    int val;          // Значение узла\n    TreeNode *left;   // Указатель на левого дочернего узла\n    TreeNode *right;  // Указатель на правого дочернего узла\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    int val;         // Значение узла\n    TreeNode left;   // Ссылка на левого дочернего узла\n    TreeNode right;  // Ссылка на правого дочернего узла\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode(int? x) {\n    public int? val = x;    // Значение узла\n    public TreeNode? left;  // Ссылка на левого дочернего узла\n    public TreeNode? right; // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* Конструктор */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // Указатель на левого дочернего узла\n        Right: nil, // Указатель на правого дочернего узла\n        Val:   v,   // Значение узла\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    var val: Int // Значение узла\n    var left: TreeNode? // Ссылка на левого дочернего узла\n    var right: TreeNode? // Ссылка на правого дочернего узла\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    val; // Значение узла\n    left; // Указатель на левого дочернего узла\n    right; // Указатель на правого дочернего узла\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.left = left === undefined ? null : left; // Ссылка на левого дочернего узла\n        this.right = right === undefined ? null : right; // Ссылка на правого дочернего узла\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n  int val;         // Значение узла\n  TreeNode? left;  // Ссылка на левого дочернего узла\n  TreeNode? right; // Ссылка на правого дочернего узла\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура узла двоичного дерева */\nstruct TreeNode {\n    val: i32,                               // Значение узла\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Ссылка на левого дочернего узла\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Ссылка на правого дочернего узла\n}\n\nimpl TreeNode {\n    /* Конструктор */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\ntypedef struct TreeNode {\n    int val;                // Значение узла\n    int height;             // Высота узла\n    struct TreeNode *left;  // Указатель на левого дочернего узла\n    struct TreeNode *right; // Указатель на правого дочернего узла\n} TreeNode;\n\n/* Конструктор */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode(val _val: Int) {  // Значение узла\n    val left: TreeNode? = null   // Ссылка на левого дочернего узла\n    val right: TreeNode? = null  // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>### Класс узла двоичного дерева ###\nclass TreeNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :left   # Ссылка на левого дочернего узла\n  attr_accessor :right  # Ссылка на правого дочернего узла\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>Каждый узел имеет две ссылки (указателя), которые соответственно указывают на левого дочернего узла (left-child node) и правого дочернего узла (right-child node); данный узел называется родительским узлом (parent node) для этих двух дочерних узлов. Если задан некоторый узел двоичного дерева, то дерево, образованное его левым дочерним узлом и всеми узлами ниже него, называется левым поддеревом (left subtree) этого узла; аналогично определяется правое поддерево (right subtree).</p> <p>Узлы, не имеющие дочерних узлов, называют листьями, а все остальные узлы содержат дочерние узлы и непустые поддеревья. Как показано на рисунке 7-1, если рассматривать \"узел 2\" как родительский, то его левым и правым дочерними узлами будут \"узел 4\" и \"узел 5\"; левое поддерево - это \"узел 4 и дерево ниже него\", а правое поддерево - это \"узел 5 и дерево ниже него\".</p> <p></p> <p> Рисунок 7-1   Родительский узел, дочерние узлы и поддеревья </p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   Распространенные термины двоичного дерева","text":"<p>Распространенные термины двоичного дерева показаны на рисунке 7-2.</p> <ul> <li>Корневой узел (root node): узел, расположенный на верхнем уровне двоичного дерева и не имеющий родительского узла.</li> <li>Листовой узел (leaf node): узел без дочерних узлов; оба его указателя направлены на <code>None</code> .</li> <li>Ребро (edge): отрезок, соединяющий два узла, то есть ссылка (указатель) между узлами.</li> <li>Уровень (level) узла: увеличивается сверху вниз; уровень корневого узла равен 1 .</li> <li>Степень (degree) узла: число дочерних узлов данного узла. В двоичном дереве возможны степени 0, 1, 2 .</li> <li>Высота (height) двоичного дерева: число ребер от корневого узла до самого удаленного листового узла.</li> <li>Глубина (depth) узла: число ребер от корневого узла до данного узла.</li> <li>Высота (height) узла: число ребер от самого удаленного листового узла до данного узла.</li> </ul> <p></p> <p> Рисунок 7-2   Распространенные термины двоичного дерева </p> <p>Tip</p> <p>Обычно под \"высотой\" и \"глубиной\" понимают \"число пройденных ребер\", но в некоторых задачах или учебниках их могут определять как \"число пройденных узлов\". В таком случае и высоту, и глубину нужно увеличить на 1 .</p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   Базовые операции двоичного дерева","text":"","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   Инициализация двоичного дерева","text":"<p>Как и в связном списке, сначала инициализируются узлы, а затем между ними строятся ссылки (указатели).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Инициализация двоичного дерева\n# Инициализация узлов\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// Инициализация узлов\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// Построение ссылок (указателей) между узлами\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// Инициализация узлов\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// Инициализация узлов\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// Построение ссылок (указателей) между узлами\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// Инициализация узлов\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># Инициализация двоичного дерева\n# Инициализация узлов\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%D0%9A%D0%BB%D0%B0%D1%81%D1%81%20%D1%83%D0%B7%D0%BB%D0%B0%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BB%D0%B5%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%20%28%D1%83%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8%29%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   Вставка и удаление узлов","text":"<p>Как и в связном списке, вставка и удаление узлов в двоичном дереве могут выполняться через изменение указателей. На рисунке 7-3 приведен пример.</p> <p></p> <p> Рисунок 7-3   Вставка и удаление узлов в двоичном дереве </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Вставка и удаление узлов\np = TreeNode(0)\n# Вставить узел P между n1 -&gt; n2\nn1.left = p\np.left = n2\n# Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* Вставка и удаление узлов */\nTreeNode* P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Удалить узел P\nn1-&gt;left = n2;\n// Освободить память\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* Вставка и удаление узлов */\nTreeNode P = new(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* Вставка и удаление узлов */\n// Вставить узел P между n1 -&gt; n2\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// Удалить узел P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// Вставить узел P между n1 -&gt; n2\nn1.left = P\nP.left = n2\n// Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* Вставка и удаление узлов */\nlet P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* Вставка и удаление узлов */\nconst P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* Вставка и удаление узлов */\nTreeNode P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// Вставить узел P между n1 -&gt; n2\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// Удалить узел p\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* Вставка и удаление узлов */\nTreeNode *P = newTreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Удалить узел P\nn1-&gt;left = n2;\n// Освободить память\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// Вставить узел P между n1 -&gt; n2\nn1.left = P\nP.left = n2\n// Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># Вставка и удаление узлов\n_p = TreeNode.new(0)\n# Вставить узел _p между n1 -&gt; n2\nn1.left = _p\n_p.left = n2\n# Удалить узел\nn1.left = n2\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%D0%9A%D0%BB%D0%B0%D1%81%D1%81%20%D1%83%D0%B7%D0%BB%D0%B0%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BB%D0%B5%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%20%28%D1%83%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8%29%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%20%D0%B8%20%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%BE%D0%B2%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%20P%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20n1%20-%3E%20n2%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%20P%0A%20%20%20%20n1.left%20%3D%20n2&amp;cumulative=false&amp;curInstr=37&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Tip</p> <p>Стоит помнить, что вставка узла может изменить исходную логическую структуру двоичного дерева, а удаление узла обычно означает удаление этого узла вместе со всеми его поддеревьями. Поэтому в двоичном дереве операции вставки и удаления обычно являются частью более крупного набора операций, который и реализует осмысленное действие.</p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   Распространенные типы двоичных деревьев","text":"","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   Идеальное двоичное дерево","text":"<p>Как показано на рисунке 7-4, идеальное двоичное дерево (perfect binary tree) полностью заполнено на всех уровнях. В идеальном двоичном дереве степень листовых узлов равна \\(0\\) , а у всех остальных узлов степень равна \\(2\\) ; если высота дерева равна \\(h\\) , то общее число узлов равно \\(2^{h+1} - 1\\) , что образует стандартную экспоненциальную зависимость и отражает часто встречающееся в природе явление клеточного деления.</p> <p>Tip</p> <p>В китайскоязычном сообществе идеальное двоичное дерево часто называют полностью заполненным двоичным деревом.</p> <p></p> <p> Рисунок 7-4   Идеальное двоичное дерево </p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   Полное двоичное дерево","text":"<p>Как показано на рисунке 7-5, полное двоичное дерево (complete binary tree) допускает неполное заполнение только на самом нижнем уровне, причем узлы этого уровня должны непрерывно заполняться слева направо. Стоит отметить, что идеальное двоичное дерево тоже является полным двоичным деревом.</p> <p></p> <p> Рисунок 7-5   Полное двоичное дерево </p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   Строгое двоичное дерево","text":"<p>Как показано на рисунке 7-6, строгое двоичное дерево (full binary tree) имеет у всех нелистовых узлов ровно двух дочерних узлов.</p> <p></p> <p> Рисунок 7-6   Строгое двоичное дерево </p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   Сбалансированное двоичное дерево","text":"<p>Как показано на рисунке 7-7, в сбалансированном двоичном дереве (balanced binary tree) для любого узла абсолютное значение разности высот левого и правого поддеревьев не превышает 1 .</p> <p></p> <p> Рисунок 7-7   Сбалансированное двоичное дерево </p>","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   Вырождение двоичного дерева","text":"<p>На рисунке 7-8 показаны идеальная структура двоичного дерева и вырожденная структура. Когда каждый уровень двоичного дерева полностью заполнен узлами, мы получаем \"идеальное двоичное дерево\"; когда же все узлы смещаются к одной стороне, двоичное дерево вырождается в \"связный список\".</p> <ul> <li>Идеальное двоичное дерево соответствует лучшему случаю и позволяет в полной мере раскрыть преимущества подхода \"разделяй и властвуй\".</li> <li>Связный список представляет противоположную крайность: все операции становятся линейными, а временная сложность деградирует до \\(O(n)\\) .</li> </ul> <p></p> <p> Рисунок 7-8   Лучший и худший случаи структуры двоичного дерева </p> <p>Как показано в таблице 7-1, в лучшем и худшем случаях число листовых узлов, общее число узлов, высота и другие характеристики двоичного дерева достигают максимума или минимума.</p> <p> Таблица 7-1   Лучший и худший случаи структуры двоичного дерева </p> Идеальное двоичное дерево Связный список Число узлов на уровне \\(i\\) \\(2^{i-1}\\) \\(1\\) Число листьев у дерева высоты \\(h\\) \\(2^h\\) \\(1\\) Общее число узлов у дерева высоты \\(h\\) \\(2^{h+1} - 1\\) \\(h + 1\\) Высота дерева с \\(n\\) узлами \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["Глава 7. Дерево","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   Обход двоичного дерева","text":"<p>С точки зрения физической структуры дерево представляет собой разновидность структуры данных на основе связей, поэтому его обход выполняется через последовательный доступ к узлам по указателям. Однако дерево является нелинейной структурой данных, а значит, его обход сложнее, чем обход связного списка, и для него требуется использовать поисковые алгоритмы.</p> <p>К распространенным способам обхода двоичного дерева относятся обход по уровням, прямой обход, симметричный обход и обратный обход.</p>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   Обход по уровням","text":"<p>Как показано на рисунке 7-9, обход по уровням (level-order traversal) проходит двоичное дерево сверху вниз по уровням и на каждом уровне посещает узлы слева направо.</p> <p>По своей сути обход по уровням относится к обходу в ширину (breadth-first traversal), также называемому поиском в ширину (breadth-first search, BFS); он отражает идею \"расширяться от центра к периферии слой за слоем\".</p> <p></p> <p> Рисунок 7-9   Обход двоичного дерева по уровням </p>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   Код реализации","text":"<p>Обход в ширину обычно реализуется с помощью \"очереди\". Очередь подчиняется правилу \"первым пришел - первым вышел\", а обход в ширину подчиняется правилу \"продвигаться по уровням\", поэтому стоящая за ними идея согласована. Код реализации приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"Обход в ширину\"\"\"\n    # Инициализировать очередь и добавить корневой узел\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # Инициализировать список для хранения последовательности обхода\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # Извлечение из очереди\n        res.append(node.val)  # Сохранить значение узла\n        if node.left is not None:\n            queue.append(node.left)  # Поместить левый дочерний узел в очередь\n        if node.right is not None:\n            queue.append(node.right)  # Поместить правый дочерний узел в очередь\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* Обход в ширину */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // Инициализировать очередь и добавить корневой узел\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // Инициализировать список для хранения последовательности обхода\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // Извлечение из очереди\n        vec.push_back(node-&gt;val); // Сохранить значение узла\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // Поместить левый дочерний узел в очередь\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // Поместить правый дочерний узел в очередь\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* Обход в ширину */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // Инициализировать очередь и добавить корневой узел\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // Инициализировать список для хранения последовательности обхода\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // Извлечение из очереди\n        list.add(node.val);           // Сохранить значение узла\n        if (node.left != null)\n            queue.offer(node.left);   // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.offer(node.right);  // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* Обход в ширину */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // Инициализировать очередь и добавить корневой узел\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // Инициализировать список для хранения последовательности обхода\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // Извлечение из очереди\n        list.Add(node.val!.Value);       // Сохранить значение узла\n        if (node.left != null)\n            queue.Enqueue(node.left);    // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.Enqueue(node.right);   // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* Обход в ширину */\nfunc levelOrder(root *TreeNode) []any {\n    // Инициализировать очередь и добавить корневой узел\n    queue := list.New()\n    queue.PushBack(root)\n    // Инициализировать срез для хранения последовательности обхода\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // Извлечение из очереди\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // Сохранить значение узла\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // Поместить левый дочерний узел в очередь\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // Поместить правый дочерний узел в очередь\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* Обход в ширину */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // Инициализировать очередь и добавить корневой узел\n    var queue: [TreeNode] = [root]\n    // Инициализировать список для хранения последовательности обхода\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // Извлечение из очереди\n        list.append(node.val) // Сохранить значение узла\n        if let left = node.left {\n            queue.append(left) // Поместить левый дочерний узел в очередь\n        }\n        if let right = node.right {\n            queue.append(right) // Поместить правый дочерний узел в очередь\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* Обход в ширину */\nfunction levelOrder(root) {\n    // Инициализировать очередь и добавить корневой узел\n    const queue = [root];\n    // Инициализировать список для хранения последовательности обхода\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // Извлечение из очереди\n        list.push(node.val); // Сохранить значение узла\n        if (node.left) queue.push(node.left); // Поместить левый дочерний узел в очередь\n        if (node.right) queue.push(node.right); // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* Обход в ширину */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // Инициализировать очередь и добавить корневой узел\n    const queue = [root];\n    // Инициализировать список для хранения последовательности обхода\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // Извлечение из очереди\n        list.push(node.val); // Сохранить значение узла\n        if (node.left) {\n            queue.push(node.left); // Поместить левый дочерний узел в очередь\n        }\n        if (node.right) {\n            queue.push(node.right); // Поместить правый дочерний узел в очередь\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* Обход в ширину */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // Инициализировать очередь и добавить корневой узел\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // Инициализировать список для хранения последовательности обхода\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // Извлечение из очереди\n    res.add(node!.val); // Сохранить значение узла\n    if (node.left != null) queue.add(node.left); // Поместить левый дочерний узел в очередь\n    if (node.right != null) queue.add(node.right); // Поместить правый дочерний узел в очередь\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* Обход в ширину */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // Инициализировать очередь и добавить корневой узел\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // Инициализировать список для хранения последовательности обхода\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // Извлечение из очереди\n        vec.push(node.borrow().val); // Сохранить значение узла\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // Поместить левый дочерний узел в очередь\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // Поместить правый дочерний узел в очередь\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* Обход в ширину */\nint *levelOrder(TreeNode *root, int *size) {\n    /* Вспомогательная очередь */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* Вспомогательная очередь */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // Указатель очереди\n    front = 0, rear = 0;\n    // Добавить корневой узел\n    queue[rear++] = root;\n    // Инициализировать список для хранения последовательности обхода\n    /* Вспомогательный массив */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // Указатель на массив\n    index = 0;\n    while (front &lt; rear) {\n        // Извлечение из очереди\n        node = queue[front++];\n        // Сохранить значение узла\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // Поместить левый дочерний узел в очередь\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // Поместить правый дочерний узел в очередь\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // Обновить значение длины массива\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // Освободить память вспомогательного массива\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* Обход в ширину */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // Инициализировать очередь и добавить корневой узел\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // Инициализировать список для хранения последовательности обхода\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // Извлечение из очереди\n        list.add(node?._val!!)       // Сохранить значение узла\n        if (node.left != null)\n            queue.offer(node.left)   // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.offer(node.right)  // Поместить правый дочерний узел в очередь\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### Обход в ширину ###\ndef level_order(root)\n  # Инициализировать очередь и добавить корневой узел\n  queue = [root]\n  # Инициализировать список для хранения последовательности обхода\n  res = []\n  while !queue.empty?\n    node = queue.shift # Извлечение из очереди\n    res &lt;&lt; node.val # Сохранить значение узла\n    queue &lt;&lt; node.left unless node.left.nil? # Поместить левый дочерний узел в очередь\n    queue &lt;&lt; node.right unless node.right.nil? # Поместить правый дочерний узел в очередь\n  end\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   Анализ сложности","text":"<ul> <li>Временная сложность равна \\(O(n)\\) : все узлы посещаются по одному разу, поэтому требуется \\(O(n)\\) времени, где \\(n\\) - число узлов.</li> <li>Пространственная сложность равна \\(O(n)\\) : в худшем случае, то есть для полной двоичной деревообразной структуры, до достижения самого нижнего уровня в очереди одновременно может находиться до \\((n + 1) / 2\\) узлов, что требует \\(O(n)\\) памяти.</li> </ul>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   Прямой, симметричный и обратный обходы","text":"<p>Соответственно, прямой, симметричный и обратный обходы относятся к обходу в глубину (depth-first traversal), также называемому поиском в глубину (depth-first search, DFS); он отражает идею \"сначала идти до конца, затем возвращаться и продолжать\".</p> <p>На рисунке 7-10 показан принцип работы обхода двоичного дерева в глубину. Обход в глубину можно представить как обход всей двоичной структуры по внешнему контуру , и у каждого узла встречаются три позиции, соответствующие прямому, симметричному и обратному обходам.</p> <p></p> <p> Рисунок 7-10   Прямой, симметричный и обратный обходы двоичного дерева поиска </p>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   Код реализации","text":"<p>Поиск в глубину обычно реализуется через рекурсию:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"Предварительный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"Симметричный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"Обратный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* Предварительный обход */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* Симметричный обход */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* Обратный обход */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* Предварительный обход */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* Симметричный обход */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* Обратный обход */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* Предварительный обход */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* Симметричный обход */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* Обратный обход */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* Предварительный обход */\nfunction preOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nfunction inOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nfunction postOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* Предварительный обход */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* Предварительный обход */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Симметричный обход */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Обратный обход */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* Предварительный обход */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* Симметричный обход */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* Обратный обход */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### Предварительный обход ###\ndef pre_order(root)\n  return if root.nil?\n\n  # Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### Симметричный обход ###\ndef in_order(root)\n  return if root.nil?\n\n  # Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### Обратный обход ###\ndef post_order(root)\n  return if root.nil?\n\n  # Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Tip</p> <p>Поиск в глубину можно реализовать и итеративно; заинтересованные читатели могут изучить это самостоятельно.</p> <p>На рисунках ниже показан рекурсивный процесс прямого обхода двоичного дерева. Его можно разделить на две противоположные части: \"вход в рекурсию\" и \"возврат\".</p> <ol> <li>\"Вход в рекурсию\" означает запуск нового вызова функции; в этом процессе программа переходит к следующему узлу.</li> <li>\"Возврат\" означает завершение вызова функции и возврат назад, то есть текущий узел уже полностью обработан.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-11   Рекурсивный процесс прямого обхода </p>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   Анализ сложности","text":"<ul> <li>Временная сложность равна \\(O(n)\\) : все узлы посещаются по одному разу, поэтому требуется \\(O(n)\\) времени.</li> <li>Пространственная сложность равна \\(O(n)\\) : в худшем случае, когда дерево вырождается в связный список, глубина рекурсии достигает \\(n\\) , и система тратит \\(O(n)\\) памяти на стек вызовов.</li> </ul>","path":["Глава 7. Дерево","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   Краткие итоги","text":"","path":["Глава 7. Дерево","7.6 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   Основные моменты","text":"<ul> <li>Двоичное дерево - это нелинейная структура данных, отражающая логику \"разделяй и властвуй\". Каждый узел двоичного дерева содержит значение и два указателя, которые соответственно ведут к левому и правому дочерним узлам.</li> <li>Для любого узла двоичного дерева дерево, образованное его левым (правым) дочерним узлом и всеми нижележащими узлами, называется левым (правым) поддеревом этого узла.</li> <li>К связанным с двоичным деревом терминам относятся корневой узел, листовой узел, уровень, степень, ребро, высота, глубина и так далее.</li> <li>Инициализация двоичного дерева, вставка узлов и удаление узлов аналогичны операциям со связным списком.</li> <li>К распространенным видам двоичного дерева относятся идеальное двоичное дерево, полное двоичное дерево, строгое двоичное дерево и сбалансированное двоичное дерево. Идеальное двоичное дерево - наиболее желательное состояние, а связный список - худший случай после вырождения.</li> <li>Двоичное дерево можно представить массивом: значения узлов и пустые позиции располагаются в порядке обхода по уровням, а связи между родителем и детьми реализуются через индексацию.</li> <li>Обход двоичного дерева по уровням является методом поиска в ширину; он отражает идею \"расширяться от центра к периферии слой за слоем\" и обычно реализуется через очередь.</li> <li>Прямой, симметричный и обратный обходы относятся к поиску в глубину; они отражают идею \"сначала дойти до конца, затем вернуться и продолжить\" и обычно реализуются рекурсивно.</li> <li>Двоичное дерево поиска - это эффективная структура данных для поиска элементов; его поиск, вставка и удаление имеют временную сложность \\(O(\\log n)\\) . Когда двоичное дерево поиска вырождается в связный список, все эти сложности деградируют до \\(O(n)\\) .</li> <li>AVL-дерево, также называемое сбалансированным двоичным деревом поиска, с помощью вращений гарантирует, что после постоянных вставок и удалений узлов дерево остается сбалансированным.</li> <li>Вращения AVL-дерева включают правое вращение, левое вращение, сначала правое затем левое и сначала левое затем правое. После вставки или удаления узла AVL-дерево выполняет вращения снизу вверх, чтобы снова восстановить баланс.</li> </ul>","path":["Глава 7. Дерево","7.6 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Для двоичного дерева, состоящего из одного узла, высота дерева и глубина корня обе равны \\(0\\) ?</p> <p>Да, потому что высота и глубина обычно определяются как \"число пройденных ребер\".</p> <p>Q: Вставка и удаление в двоичном дереве обычно выполняются в составе набора операций. Что именно означает этот \"набор операций\"? Можно ли понимать это как освобождение ресурсов у дочерних узлов ресурса?</p> <p>Возьмем в качестве примера двоичное дерево поиска: операция удаления узла делится на три случая, и каждый из этих случаев требует нескольких последовательных шагов работы с узлами.</p> <p>Q: Почему у DFS для двоичного дерева есть три порядка: прямой, симметричный и обратный? Для чего они нужны?</p> <p>Подобно прямому и обратному обходу массива, прямой, симметричный и обратный обходы - это три способа обхода двоичного дерева, с помощью которых можно получить результаты в определенном порядке. Например, в двоичном дереве поиска, где соблюдается отношение <code>значение левого дочернего узла &lt; значение корня &lt; значение правого дочернего узла</code> , если обходить дерево с приоритетом \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\", то получится упорядоченная последовательность узлов.</p> <p>Q: Правое вращение работает с отношениями между <code>node</code> , <code>child</code> и <code>grand_child</code> . А связь между <code>node</code> и его исходным родителем разве не нужно поддерживать? После правого вращения она ведь не оборвется?</p> <p>На это нужно смотреть с точки зрения рекурсии. В правое вращение <code>right_rotate(root)</code> передается корень поддерева, а затем через <code>return child</code> возвращается корень этого поддерева уже после вращения. Соединение между новым корнем поддерева и его родителем восстанавливается после возврата функции и не входит в обязанности самой операции правого вращения.</p> <p>Q: В C++ функции делятся на <code>private</code> и <code>public</code> . Какая логика стоит за этим? Почему <code>height()</code> и <code>updateHeight()</code> помещают в разные области видимости?</p> <p>Главный критерий - область использования метода. Если метод нужен только внутри класса, его следует проектировать как <code>private</code> . Например, самостоятельный вызов <code>updateHeight()</code> пользователем не имеет смысла: это лишь один из шагов внутри вставки или удаления. А <code>height()</code> используется для чтения высоты узла, подобно <code>vector.size()</code> , поэтому его разумно делать <code>public</code> .</p> <p>Q: Как построить двоичное дерево поиска из набора входных данных? Важен ли выбор корневого узла?</p> <p>Да, важен. Способ построения дерева уже показан в методе <code>build_tree()</code> в коде двоичного дерева поиска. Что касается выбора корня, обычно входные данные сортируют, берут средний элемент как корень, а затем рекурсивно строят левое и правое поддеревья. Это позволяет в наибольшей степени сохранить баланс дерева.</p> <p>Q: Нужно ли в Java всегда использовать <code>equals()</code> для сравнения строк?</p> <p>В Java для базовых типов <code>==</code> используется, чтобы сравнивать, равны ли значения двух переменных. Для ссылочных типов логика у этих двух способов уже разная.</p> <ul> <li><code>==</code> : сравнивает, ссылаются ли две переменные на один и тот же объект, то есть совпадает ли их адрес в памяти.</li> <li><code>equals()</code>: сравнивает, равны ли значения двух объектов.</li> </ul> <p>Поэтому если нужно сравнить значения, то следует использовать <code>equals()</code> . Но строки, инициализированные как <code>String a = \"hi\"; String b = \"hi\";</code> , хранятся в строковом пуле констант и указывают на один и тот же объект, поэтому в таком случае <code>a == b</code> тоже может дать истинный результат при сравнении содержимого.</p> <p>Q: До достижения самого нижнего уровня при обходе в ширину число узлов в очереди равно \\(2^h\\) ?</p> <p>Да. Например, для полного двоичного дерева высоты \\(h = 2\\) общее число узлов равно \\(n = 7\\) , а число узлов на нижнем уровне равно \\(4 = 2^h = (n + 1) / 2\\) .</p>","path":["Глава 7. Дерево","7.6 &nbsp; Краткие итоги"],"tags":[]}]}
\ No newline at end of file
+{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"Глава 16.   Приложение","text":"","path":["Глава 16. Приложение","Глава 16. &nbsp; Приложение"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>16.1   Установка среды программирования</li> <li>16.2   Присоединяйтесь к созданию книги</li> <li>16.3   Глоссарий</li> </ul>","path":["Глава 16. Приложение","Глава 16. &nbsp; Приложение"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   Присоединяйтесь к созданию книги","text":"<p>Возможности автора ограничены, поэтому в книге неизбежно могут встречаться упущения и ошибки. Просим отнестись к этому с пониманием. Если вы заметите опечатки, неработающие ссылки, пропуски в содержании, двусмысленные формулировки, неясные объяснения или неудачную структуру изложения, пожалуйста, помогите нам это исправить, чтобы читатели получили более качественный учебный ресурс.</p> <p>Все GitHub ID авторов будут указаны на главных страницах репозитория книги, веб-версии и PDF-версии в знак благодарности за их бескорыстный вклад в сообщество открытого исходного кода.</p> <p>Сила открытого исходного кода</p> <p>Интервал между двумя тиражами бумажной книги обычно довольно велик, поэтому обновлять содержание очень неудобно.</p> <p>В этой же открытой книге цикл обновления содержания сокращается до нескольких дней, а иногда даже до нескольких часов.</p>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   Небольшие правки содержания","text":"<p>Как показано на рисунке 16-3, в правом верхнем углу каждой страницы есть \"значок редактирования\". Текст или код можно изменить следующим образом.</p> <ol> <li>Нажмите на \"значок редактирования\". Если появится сообщение \"You need to fork this repository\", согласитесь с этим действием.</li> <li>Измените содержимое исходного Markdown-файла, проверьте корректность правок и постарайтесь сохранить единый стиль оформления.</li> <li>Внизу страницы заполните описание изменений, затем нажмите кнопку \"Propose file change\". После перехода на следующую страницу нажмите кнопку \"Create pull request\", чтобы отправить pull request.</li> </ol> <p></p> <p> Рисунок 16-3   Кнопка редактирования страницы </p> <p>Изображения нельзя изменить напрямую, поэтому проблему с ними нужно описывать через новый Issue или комментарий. Мы постараемся как можно быстрее исправить и обновить изображение.</p>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   Создание содержания","text":"<p>Если вам интересно участвовать в этом проекте с открытым исходным кодом, например переводить код на другие языки программирования или расширять содержание статей, то следует придерживаться следующего процесса Pull Request.</p> <ol> <li>Войдите в GitHub и сделайте Fork репозитория книги в свой личный аккаунт.</li> <li>Перейдите на страницу своего Fork-репозитория и с помощью команды <code>git clone</code> клонируйте репозиторий локально.</li> <li>Создавайте и редактируйте содержание локально, затем проведите полное тестирование и проверьте корректность кода.</li> <li>Зафиксируйте локальные изменения, после чего выполните Push в удаленный репозиторий.</li> <li>Обновите страницу репозитория и нажмите кнопку \"Create pull request\", чтобы инициировать pull request.</li> </ol>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Развертывание Docker","text":"<p>В корневом каталоге <code>hello-algo</code> выполните следующий Docker-скрипт, после чего проект станет доступен по адресу <code>http://localhost:8000</code>:</p> <pre><code>docker-compose up -d\n</code></pre> <p>Удалить развертывание можно следующей командой:</p> <pre><code>docker-compose down\n</code></pre>","path":["Глава 16. Приложение","16.2 &nbsp; Присоединяйтесь к созданию книги"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   Установка среды программирования","text":"","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   Установка IDE","text":"<p>В качестве локальной интегрированной среды разработки (IDE) рекомендуется использовать открытую и быструю VS Code. Перейдите на официальный сайт VS Code, выберите версию для своей операционной системы и установите ее.</p> <p></p> <p> Рисунок 16-1   Загрузка VS Code с официального сайта </p> <p>VS Code обладает мощной экосистемой расширений и поддерживает выполнение и отладку большинства языков программирования. Например, после установки расширения \"Python Extension Pack\" можно отлаживать код на Python. Процесс установки показан на рисунке 16-2.</p> <p></p> <p> Рисунок 16-2   Установка расширений VS Code </p>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   Установка языковой среды","text":"","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Среда Python","text":"<ol> <li>Загрузите и установите Miniconda3, требуется Python 3.10 или более поздняя версия.</li> <li>В магазине расширений VS Code найдите <code>python</code> и установите Python Extension Pack.</li> <li>(Необязательно) Введите в командной строке <code>pip install black</code>, чтобы установить инструмент форматирования кода.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   Среда C/C++","text":"<ol> <li>В Windows требуется установить MinGW (руководство по настройке); в macOS компилятор Clang уже установлен по умолчанию.</li> <li>В магазине расширений VS Code найдите <code>c++</code> и установите C/C++ Extension Pack.</li> <li>(Необязательно) Откройте страницу Settings, найдите параметр форматирования <code>Clang_format_fallback Style</code> и задайте значение <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code>.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Среда Java","text":"<ol> <li>Загрузите и установите OpenJDK (требуемая версия: &gt; JDK 9).</li> <li>В магазине расширений VS Code найдите <code>java</code> и установите Extension Pack for Java.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   Среда C","text":"<ol> <li>Загрузите и установите .Net 8.0.</li> <li>В магазине расширений VS Code найдите <code>C# Dev Kit</code> и установите C# Dev Kit (руководство по настройке).</li> <li>Также можно использовать Visual Studio (руководство по установке).</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Среда Go","text":"<ol> <li>Загрузите и установите go.</li> <li>В магазине расширений VS Code найдите <code>go</code> и установите Go.</li> <li>Нажмите <code>Ctrl + Shift + P</code>, чтобы открыть командную палитру, введите <code>go</code>, выберите <code>Go: Install/Update Tools</code>, отметьте все инструменты и установите их.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Среда Swift","text":"<ol> <li>Загрузите и установите Swift.</li> <li>В магазине расширений VS Code найдите <code>swift</code> и установите Swift for Visual Studio Code.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   Среда JavaScript","text":"<ol> <li>Загрузите и установите Node.js.</li> <li>(Необязательно) В магазине расширений VS Code найдите <code>Prettier</code> и установите инструмент форматирования кода.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   Среда TypeScript","text":"<ol> <li>Выполните те же шаги, что и для среды JavaScript.</li> <li>Установите TypeScript Execute (tsx).</li> <li>В магазине расширений VS Code найдите <code>typescript</code> и установите Pretty TypeScript Errors.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Среда Dart","text":"<ol> <li>Загрузите и установите Dart.</li> <li>В магазине расширений VS Code найдите <code>dart</code> и установите Dart.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Среда Rust","text":"<ol> <li>Загрузите и установите Rust.</li> <li>В магазине расширений VS Code найдите <code>rust</code> и установите rust-analyzer.</li> </ol>","path":["Глава 16. Приложение","16.1 &nbsp; Установка среды программирования"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   Глоссарий","text":"<p>В таблице 16-1 приведены важные термины, встречающиеся в книге. Обратите внимание на следующие моменты.</p> <ul> <li>Рекомендуем запомнить английские названия терминов, чтобы легче читать англоязычные материалы.</li> <li>В русской версии для каждого термина приводится единый рекомендуемый перевод.</li> </ul> <p> Таблица 16-1   Важные термины по структурам данных и алгоритмам </p> English Русский algorithm алгоритм data structure структура данных code код file файл function функция method метод variable переменная asymptotic complexity analysis асимптотический анализ сложности time complexity временная сложность space complexity пространственная сложность loop цикл iteration итерация recursion рекурсия tail recursion хвостовая рекурсия recursion tree дерево рекурсии big-\\(O\\) notation нотация big-\\(O\\) asymptotic upper bound асимптотическая верхняя граница sign-magnitude прямой код 1’s complement обратный код 2’s complement дополнительный код array массив index индекс linked list связный список linked list node, list node узел связного списка head node головной узел tail node хвостовой узел list список dynamic array динамический массив hard disk жесткий диск random-access memory (RAM) оперативная память cache memory кеш-память cache miss промах кеша cache hit rate коэффициент попадания в кеш stack стек top of the stack вершина стека bottom of the stack основание стека queue очередь double-ended queue двусторонняя очередь front of the queue голова очереди rear of the queue хвост очереди hash table хеш-таблица hash set хеш-набор bucket бакет hash function хеш-функция hash collision хеш-коллизия load factor коэффициент заполнения separate chaining цепная адресация open addressing открытая адресация linear probing линейное зондирование lazy deletion ленивое удаление binary tree двоичное дерево tree node узел дерева left-child node левый дочерний узел right-child node правый дочерний узел parent node родительский узел left subtree левое поддерево right subtree правое поддерево root node корневой узел leaf node листовой узел edge ребро level уровень degree степень height высота depth глубина perfect binary tree идеальное двоичное дерево complete binary tree полное двоичное дерево full binary tree строгое двоичное дерево balanced binary tree сбалансированное двоичное дерево binary search tree двоичное дерево поиска AVL tree АВЛ-дерево red-black tree красно-черное дерево level-order traversal обход по уровням breadth-first traversal обход в ширину depth-first traversal обход в глубину pre-order traversal прямой обход in-order traversal симметричный обход post-order traversal обратный обход balanced binary search tree сбалансированное двоичное дерево поиска balance factor фактор баланса heap куча max heap максимальная куча min heap минимальная куча priority queue приоритетная очередь heapify упорядочивание кучи top-\\(k\\) problem поиск \\(k\\) наибольших элементов graph граф vertex вершина undirected graph неориентированный граф directed graph ориентированный граф connected graph связный граф disconnected graph несвязный граф weighted graph взвешенный граф adjacency смежность path путь in-degree входящая степень out-degree исходящая степень adjacency matrix матрица смежности adjacency list список смежности breadth-first search поиск в ширину depth-first search поиск в глубину binary search двоичный поиск searching algorithm алгоритм поиска sorting algorithm алгоритм сортировки selection sort сортировка выбором bubble sort сортировка пузырьком insertion sort сортировка вставкой quick sort быстрая сортировка merge sort сортировка слиянием heap sort пирамидальная сортировка bucket sort блочная сортировка counting sort сортировка подсчетом radix sort поразрядная сортировка divide and conquer разделяй и властвуй hanota problem задача о Ханойской башне backtracking algorithm алгоритм поиска с возвратом constraint ограничение solution решение state состояние pruning отсечение permutations problem задача о перестановках subset-sum problem задача о сумме подмножеств \\(n\\)-queens problem задача о \\(n\\) ферзях dynamic programming динамическое программирование initial state начальное состояние state-transition equation уравнение перехода состояния knapsack problem задача о рюкзаке edit distance problem задача о расстоянии редактирования greedy algorithm жадный алгоритм","path":["Глава 16. Приложение","16.3 &nbsp; Глоссарий"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"Глава 4.   Массивы и списки","text":"<p>Abstract</p> <p>Мир структур данных напоминает прочную кирпичную стену.</p> <p>Кирпичи массива уложены ровно и плотно прилегают друг к другу. Узлы связного списка, напротив, разбросаны в разных местах, а соединяющие их связи свободно тянутся между промежутками.</p>","path":["Глава 4. Массивы и списки","Глава 4. &nbsp; Массивы и списки"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>4.1   Массив</li> <li>4.2   Связный список</li> <li>4.3   Список</li> <li>4.4   Оперативная память и кэш *</li> <li>4.5   Резюме</li> </ul>","path":["Глава 4. Массивы и списки","Глава 4. &nbsp; Массивы и списки"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   Массив","text":"<p>Массив (array) - это линейная структура данных, в которой элементы одного типа хранятся в непрерывной области памяти. Положение элемента в массиве называется его индексом (index). На рисунке 4-1 показаны основные понятия, связанные с массивом, и способ его хранения.</p> <p></p> <p> Рисунок 4-1   Определение массива и способ хранения </p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   Основные операции с массивом","text":"","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   Инициализация массива","text":"<p>Существует два способа инициализации массива: без начальных значений и с заданными начальными значениями. Если начальные значения не указаны, большинство языков программирования инициализируют элементы массива нулями:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># Инициализация массива\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* Инициализация массива */\n// Хранится в стеке\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Хранится в куче (требуется ручное освобождение памяти)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* Инициализация массива */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* Инициализация массива */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* Инициализация массива */\nvar arr [5]int\n// В Go указание длины ([5]int) создает массив, а отсутствие длины ([]int) - срез\n// Поскольку длина массива в Go определяется на этапе компиляции, для задания длины можно использовать только константы\n// Чтобы упростить реализацию метода extend(), ниже будем рассматривать срезы (Slice) как массивы (Array)\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* Инициализация массива */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* Инициализация массива */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* Инициализация массива */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* Инициализация массива */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* Инициализация массива */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// В Rust указание длины ([i32; 5]) создает массив, а отсутствие длины (&amp;[i32]) - срез\n// Поскольку длина массива в Rust определяется на этапе компиляции, для задания длины можно использовать только константы\n// Vector в Rust обычно используется как динамический массив\n// Чтобы упростить реализацию метода extend(), ниже будем рассматривать vector как массив (array)\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* Инициализация массива */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* Инициализация массива */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># Инициализация массива\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%0Aarr%20%3D%20%5B0%5D%20%2A%205%20%20%23%20%5B%200%2C%200%2C%200%2C%200%2C%200%20%5D%0Anums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D&amp;cumulative=false&amp;curInstr=0&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   Доступ к элементам","text":"<p>Элементы массива хранятся в непрерывной области памяти, что упрощает вычисление их адресов. Зная адрес массива в памяти (то есть адрес первого элемента) и индекс некоторого элемента, мы можем по формуле с рисунка ниже вычислить адрес этого элемента и напрямую обратиться к нему.</p> <p></p> <p> Рисунок 4-2   Вычисление адреса элемента массива </p> <p>Если посмотреть на рисунок 4-2, можно заметить, что индекс первого элемента массива равен \\(0\\) , и это кажется не слишком интуитивным, ведь естественнее было бы начинать счет с \\(1\\) . Однако с точки зрения формулы адресации индекс по сути является смещением относительно адреса памяти. Смещение первого элемента равно \\(0\\) , поэтому индекс \\(0\\) полностью логичен.</p> <p>Доступ к элементам массива очень эффективен: любой элемент массива можно получить за \\(O(1)\\) времени.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"Случайный доступ к элементу\"\"\"\n    # Случайным образом выбрать число из интервала [0, len(nums)-1]\n    random_index = random.randint(0, len(nums) - 1)\n    # Получить и вернуть случайный элемент\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int *nums, int size) {\n    // Случайным образом выбрать число из интервала [0, size)\n    int randomIndex = rand() % size;\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int[] nums) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* Случайный доступ к элементу */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // Случайным образом выбрать число из интервала [0, nums.Length)\n    int randomIndex = random.Next(nums.Length);\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* Случайный доступ к элементу */\nfunc randomAccess(nums []int) (randomNum int) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    randomIndex := rand.Intn(len(nums))\n    // Получить и вернуть случайный элемент\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* Случайный доступ к элементу */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // Случайным образом выбрать число из интервала [0, nums.count)\n    let randomIndex = nums.indices.randomElement()!\n    // Получить и вернуть случайный элемент\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* Случайный доступ к элементу */\nfunction randomAccess(nums) {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Получить и вернуть случайный элемент\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* Случайный доступ к элементу */\nfunction randomAccess(nums: number[]): number {\n    // Случайным образом выбрать число из интервала [0, nums.length)\n    const random_index = Math.floor(Math.random() * nums.length);\n    // Получить и вернуть случайный элемент\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* Случайный доступ к элементу */\nint randomAccess(List&lt;int&gt; nums) {\n  // Случайным образом выбрать число из интервала [0, nums.length)\n  int randomIndex = Random().nextInt(nums.length);\n  // Получить и вернуть случайный элемент\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* Случайный доступ к элементу */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // Случайным образом выбрать число из интервала [0, nums.len())\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // Получить и вернуть случайный элемент\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* Случайный доступ к элементу */\nint randomAccess(int *nums, int size) {\n    // Случайным образом выбрать число из интервала [0, size)\n    int randomIndex = rand() % size;\n    // Получить и вернуть случайный элемент\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* Случайный доступ к элементу */\nfun randomAccess(nums: IntArray): Int {\n    // Случайным образом выбрать число из интервала [0, nums.size)\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // Получить и вернуть случайный элемент\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### Случайный доступ к элементу ###\ndef random_access(nums)\n  # Случайным образом выбрать число из интервала [0, nums.length)\n  random_index = Random.rand(0...nums.length)\n\n  # Получить и вернуть случайный элемент\n  nums[random_index]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   Вставка элемента","text":"<p>Элементы массива в памяти расположены вплотную друг к другу, и между ними нет места для размещения новых данных. Как показано на рисунке 4-3, если мы хотим вставить элемент в середину массива, то все элементы после этой позиции нужно сдвинуть на одну позицию вправо, а затем записать новое значение в освободившийся индекс.</p> <p></p> <p> Рисунок 4-3   Пример вставки элемента в массив </p> <p>Стоит отметить, что длина массива фиксирована, поэтому вставка нового элемента неизбежно приведет к потере элемента на конце массива. Решение этой проблемы мы оставим для обсуждения в разделе о \"списках\".</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"Вставить элемент num по индексу index в массив\"\"\"\n    # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # Присвоить num элементу по индексу index\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int *nums, int size, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int[] nums, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid Insert(int[] nums, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* Вставить элемент num по индексу index в массив */\nfunc insert(nums []int, num int, index int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* Вставить элемент num по индексу index в массив */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* Вставить элемент num по индексу index в массив */\nfunction insert(nums, num, index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* Вставить элемент num по индексу index в массив */\nfunction insert(nums: number[], num: number, index: number): void {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* Вставить элемент _num по индексу index в массив */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // Присвоить _num элементу по индексу index\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* Вставить элемент num по индексу index в массив */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* Вставить элемент num по индексу index в массив */\nvoid insert(int *nums, int size, int num, int index) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* Вставить элемент num по индексу index в массив */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // Присвоить num элементу по индексу index\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### Вставка элемента num по индексу index в массив ###\ndef insert(nums, num, index)\n  # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # Присвоить num элементу по индексу index\n  nums[index] = num\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   Удаление элемента","text":"<p>Аналогично, как показано на рисунке 4-4, если нужно удалить элемент по индексу \\(i\\) , то все элементы после индекса \\(i\\) необходимо сдвинуть на одну позицию влево.</p> <p></p> <p> Рисунок 4-4   Пример удаления элемента из массива </p> <p>Обрати внимание: после удаления исходный последний элемент становится бессмысленным, поэтому специально изменять его не требуется.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"Удалить элемент по индексу index\"\"\"\n    # Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* Удалить элемент по индексу index */\nvoid remove(int *nums, int size, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* Удалить элемент по индексу index */\nvoid remove(int[] nums, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* Удалить элемент по индексу index */\nvoid Remove(int[] nums, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* Удалить элемент по индексу index */\nfunc remove(nums []int, index int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* Удалить элемент по индексу index */\nfunc remove(nums: inout [Int], index: Int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* Удалить элемент по индексу index */\nfunction remove(nums, index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* Удалить элемент по индексу index */\nfunction remove(nums: number[], index: number): void {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* Удалить элемент по индексу index */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // Сдвинуть все элементы после индекса index на одну позицию вперед\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* Удалить элемент по индексу index */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* Удалить элемент по индексу index */\n// Внимание: stdio.h уже использует ключевое слово remove\nvoid removeItem(int *nums, int size, int index) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* Удалить элемент по индексу index */\nfun remove(nums: IntArray, index: Int) {\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### Удаление элемента по индексу index ###\ndef remove(nums, index)\n  # Сдвинуть все элементы после индекса index на одну позицию вперед\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В целом операции вставки и удаления в массиве имеют следующие недостатки.</p> <ul> <li>Высокая временная сложность: средняя временная сложность и вставки, и удаления равна \\(O(n)\\) , где \\(n\\) - длина массива.</li> <li>Потеря элементов: поскольку длина массива неизменяема, после вставки элементы, выходящие за пределы длины массива, будут потеряны.</li> <li>Потери памяти: можно заранее инициализировать более длинный массив и использовать только его переднюю часть; тогда теряемые при вставке элементы на конце не будут нести смысла, но такой подход приводит к лишнему расходу памяти.</li> </ul>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   Обход массива","text":"<p>В большинстве языков программирования массив можно обходить как по индексу, так и напрямую перебирая каждый элемент:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"Обход массива\"\"\"\n    count = 0\n    # Обход массива по индексам\n    for i in range(len(nums)):\n        count += nums[i]\n    # Непосредственно обходить элементы массива\n    for num in nums:\n        count += num\n    # Одновременно обходить индексы и элементы данных\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* Обход массива */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* Обход массива */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* Обход массива */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* Обход массива */\nfunc traverse(nums []int) {\n    count := 0\n    // Обход массива по индексам\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // Непосредственно обходить элементы массива\n    for _, num := range nums {\n        count += num\n    }\n    // Одновременно обходить индексы и элементы данных\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* Обход массива */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // Обход массива по индексам\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // Непосредственно обходить элементы массива\n    for num in nums {\n        count += num\n    }\n    // Одновременно обходить индексы и элементы данных\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* Обход массива */\nfunction traverse(nums) {\n    let count = 0;\n    // Обход массива по индексам\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* Обход массива */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // Обход массива по индексам\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* Перебрать элементы массива */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // Обход массива по индексам\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // Непосредственно обходить элементы массива\n  for (int _num in nums) {\n    count += _num;\n  }\n  // Перебрать массив методом forEach\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* Обход массива */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // Обход массива по индексам\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // Непосредственно обходить элементы массива\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* Обход массива */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // Обход массива по индексам\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* Обход массива */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // Обход массива по индексам\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // Непосредственно обходить элементы массива\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### Обход массива ###\ndef traverse(nums)\n  count = 0\n\n  # Обход массива по индексам\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # Непосредственно обходить элементы массива\n  for num in nums\n    count += num\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   Поиск элемента","text":"<p>Чтобы найти заданный элемент в массиве, нужно пройти по массиву и на каждой итерации проверять, совпадает ли значение; если совпадает, вернуть соответствующий индекс.</p> <p>Поскольку массив - это линейная структура данных, такая операция поиска называется линейным поиском.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"Найти заданный элемент в массиве\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* Найти заданный элемент в массиве */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* Найти заданный элемент в массиве */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* Найти заданный элемент в массиве */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* Найти заданный элемент в массиве */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* Найти заданный элемент в массиве */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* Найти заданный элемент в массиве */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* Найти заданный элемент в массиве */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* Найти заданный элемент в массиве */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* Найти заданный элемент в массиве */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* Найти заданный элемент в массиве */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* Найти заданный элемент в массиве */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### Поиск заданного элемента в массиве ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   Расширение массива","text":"<p>В сложной системной среде программа не может гарантировать, что память сразу после массива доступна, поэтому безопасно расширить емкость массива невозможно. Поэтому в большинстве языков программирования длина массива неизменяема.</p> <p>Если мы хотим расширить массив, нужно заново создать больший массив и затем по одному скопировать в него элементы исходного массива. Это операция с временной сложностью \\(O(n)\\) , и при больших массивах она очень затратна. Соответствующий код показан ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"Увеличить длину массива\"\"\"\n    # Инициализировать массив увеличенной длины\n    res = [0] * (len(nums) + enlarge)\n    # Скопировать все элементы исходного массива в новый массив\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # Вернуть новый массив после расширения\n    return res\n</code></pre> array.cpp<pre><code>/* Увеличить длину массива */\nint *extend(int *nums, int size, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int *res = new int[size + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Освободить память\n    delete[] nums;\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.java<pre><code>/* Увеличить длину массива */\nint[] extend(int[] nums, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int[] res = new int[nums.length + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.cs<pre><code>/* Увеличить длину массива */\nint[] Extend(int[] nums, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int[] res = new int[nums.Length + enlarge];\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.go<pre><code>/* Увеличить длину массива */\nfunc extend(nums []int, enlarge int) []int {\n    // Инициализировать массив увеличенной длины\n    res := make([]int, len(nums)+enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for i, num := range nums {\n        res[i] = num\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.swift<pre><code>/* Увеличить длину массива */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // Инициализировать массив увеличенной длины\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.js<pre><code>/* Увеличить длину массива */\n// Обратите внимание: Array в JavaScript — это динамический массив, его можно расширять напрямую\n// Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\nfunction extend(nums, enlarge) {\n    // Инициализировать массив увеличенной длины\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Скопировать все элементы исходного массива в новый массив\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.ts<pre><code>/* Увеличить длину массива */\n// Обратите внимание: Array в TypeScript — это динамический массив, его можно расширять напрямую\n// Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\nfunction extend(nums: number[], enlarge: number): number[] {\n    // Инициализировать массив увеличенной длины\n    const res = new Array(nums.length + enlarge).fill(0);\n    // Скопировать все элементы исходного массива в новый массив\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.dart<pre><code>/* Увеличить длину массива */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // Инициализировать массив увеличенной длины\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // Скопировать все элементы исходного массива в новый массив\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // Вернуть новый массив после расширения\n  return res;\n}\n</code></pre> array.rs<pre><code>/* Увеличить длину массива */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // Инициализировать массив увеличенной длины\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // Скопировать все элементы исходного массива в новый\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // Вернуть новый массив после расширения\n    res\n}\n</code></pre> array.c<pre><code>/* Увеличить длину массива */\nint *extend(int *nums, int size, int enlarge) {\n    // Инициализировать массив увеличенной длины\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // Скопировать все элементы исходного массива в новый массив\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // Инициализировать расширенное пространство\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // Вернуть новый массив после расширения\n    return res;\n}\n</code></pre> array.kt<pre><code>/* Увеличить длину массива */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // Инициализировать массив увеличенной длины\n    val res = IntArray(nums.size + enlarge)\n    // Скопировать все элементы исходного массива в новый массив\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // Вернуть новый массив после расширения\n    return res\n}\n</code></pre> array.rb<pre><code>### Увеличить длину массива ###\n# Обратите внимание: Array в Ruby является динамическим массивом и может расширяться напрямую\n# Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины\ndef extend(nums, enlarge)\n  # Инициализировать массив увеличенной длины\n  res = Array.new(nums.length + enlarge, 0)\n\n  # Скопировать все элементы исходного массива в новый массив\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # Вернуть новый массив после расширения\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   Преимущества и ограничения массива","text":"<p>Массив хранится в непрерывной области памяти, и все его элементы имеют один и тот же тип. Такой подход содержит богатую априорную информацию, которую система может использовать для оптимизации эффективности операций с этой структурой данных.</p> <ul> <li>Высокая пространственная эффективность: массив выделяет для данных непрерывный блок памяти без дополнительного структурного накладного расхода.</li> <li>Поддержка произвольного доступа: массив позволяет обращаться к любому элементу за \\(O(1)\\) времени.</li> <li>Локальность кэша: при обращении к элементу массива компьютер загружает не только сам элемент, но и соседние данные, что позволяет использовать кэш для ускорения последующих операций.</li> </ul> <p>Непрерывное хранение данных - это палка о двух концах, и у него есть следующие ограничения.</p> <ul> <li>Низкая эффективность вставки и удаления: когда элементов в массиве много, вставка и удаление требуют сдвига большого количества элементов.</li> <li>Неизменяемая длина: после инициализации длина массива фиксирована; расширение массива требует копирования всех данных в новый массив, что стоит дорого.</li> <li>Потери памяти: если выделенный массив больше, чем реально необходимо, лишнее пространство пропадает впустую.</li> </ul>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   Типичные применения массива","text":"<p>Массив - это базовая и очень распространенная структура данных. Он часто используется как в различных алгоритмах, так и при реализации более сложных структур данных.</p> <ul> <li>Произвольный доступ: если мы хотим случайным образом выбирать некоторые образцы, можно сохранить их в массиве и сгенерировать случайную последовательность индексов для выборки.</li> <li>Сортировка и поиск: массив - самая распространенная структура данных для алгоритмов сортировки и поиска. Быстрая сортировка, сортировка слиянием, двоичный поиск и многие другие алгоритмы в основном работают именно с массивами.</li> <li>Таблица поиска: когда нужно быстро находить элемент или его соответствие, массив можно использовать как таблицу поиска. Например, если мы хотим реализовать отображение символов в коды ASCII, можно использовать значение ASCII как индекс, а соответствующий элемент хранить по этой позиции массива.</li> <li>Машинное обучение: в нейронных сетях широко используются операции линейной алгебры над векторами, матрицами и тензорами, и все эти данные строятся в форме массивов. Массив - самая часто используемая структура данных в программировании нейросетей.</li> <li>Реализация структур данных: массивы можно использовать для реализации стеков, очередей, хеш-таблиц, куч, графов и других структур данных. Например, матрица смежности графа по сути является двумерным массивом.</li> </ul>","path":["Глава 4. Массивы и списки","4.1 &nbsp; Массив"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   Связный список","text":"<p>Память - общий ресурс для всех программ, и в сложной среде выполнения свободные участки памяти могут быть разбросаны по всему адресному пространству. Мы знаем, что память для хранения массива должна быть непрерывной, а если массив очень велик, в памяти может не оказаться столь большого непрерывного блока. Именно здесь и проявляется преимущество гибкости связного списка.</p> <p>Связный список (linked list) - это линейная структура данных, в которой каждый элемент представляет собой объект-узел, а сами узлы соединены между собой с помощью ссылок. Ссылка хранит адрес памяти следующего узла, благодаря чему из текущего узла можно перейти к следующему.</p> <p>Конструкция связного списка позволяет хранить отдельные узлы в разных местах памяти, и их адреса вовсе не обязаны быть последовательными.</p> <p></p> <p> Рисунок 4-5   Определение связного списка и способ хранения </p> <p>Как видно на рисунке 4-5, базовой единицей связного списка является объект узел (node). Каждый узел содержит две части данных: значение узла и ссылку на следующий узел.</p> <ul> <li>Первый узел связного списка называется головным узлом, а последний - хвостовым узлом.</li> <li>Хвостовой узел указывает на пустое значение, что в Java, C++ и Python обозначается как <code>null</code> , <code>nullptr</code> и <code>None</code> соответственно.</li> <li>В языках, поддерживающих указатели, таких как C, C++, Go и Rust, упомянутую выше ссылку следует заменить на указатель.</li> </ul> <p>Как показано в коде ниже, узел связного списка <code>ListNode</code> хранит не только значение, но и дополнительную ссылку (указатель). Поэтому при одинаковом объеме данных связный список занимает больше памяти, чем массив.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Класс узла связного списка\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Значение узла\n        self.next: ListNode | None = None # Ссылка на следующий узел\n</code></pre> <pre><code>/* Структура узла связного списка */\nstruct ListNode {\n    int val;         // Значение узла\n    ListNode *next;  // Указатель на следующий узел\n    ListNode(int x) : val(x), next(nullptr) {}  // Конструктор\n};\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode(int x) { val = x; }  // Конструктор\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode(int x) {  // Конструктор\n    int val = x;         // Значение узла\n    ListNode? next;      // Ссылка на следующий узел\n}\n</code></pre> <pre><code>/* Структура узла связного списка */\ntype ListNode struct {\n    Val  int       // Значение узла\n    Next *ListNode // Указатель на следующий узел\n}\n\n// NewListNode Конструктор, создает новый узел\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на следующий узел\n\n    init(x: Int) { // Конструктор\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Значение узла\n        this.next = (next === undefined ? null : next); // Ссылка на следующий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Значение узла\n        this.next = next === undefined ? null : next;  // Ссылка на следующий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\nclass ListNode {\n  int val; // Значение узла\n  ListNode? next; // Ссылка на следующий узел\n  ListNode(this.val, [this.next]); // Конструктор\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* Класс узла связного списка */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Значение узла\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на следующий узел\n}\n</code></pre> <pre><code>/* Структура узла связного списка */\ntypedef struct ListNode {\n    int val;               // Значение узла\n    struct ListNode *next; // Указатель на следующий узел\n} ListNode;\n\n/* Конструктор */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла связного списка */\n// Конструктор\nclass ListNode(x: Int) {\n    val _val: Int = x          // Значение узла\n    val next: ListNode? = null // Ссылка на следующий узел\n}\n</code></pre> <pre><code># Класс узла связного списка\nclass ListNode\n  attr_accessor :val  # Значение узла\n  attr_accessor :next # Ссылка на следующий узел\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   Основные операции со связным списком","text":"","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   Инициализация связного списка","text":"<p>Построение связного списка состоит из двух шагов: сначала нужно инициализировать объекты всех узлов, затем установить ссылочные связи между ними. После завершения инициализации мы можем, начиная с головы списка, последовательно проходить все узлы по ссылке <code>next</code>.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Инициализация отдельных узлов\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Построение ссылок между узлами\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// Инициализация отдельных узлов\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Построение ссылок между узлами\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Построение ссылок между узлами\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// Инициализация отдельных узлов\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// Построение ссылок между узлами\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># Инициализация связного списка 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# Инициализация отдельных узлов\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# Построение ссылок между узлами\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%201%20-%3E%203%20-%3E%202%20-%3E%205%20-%3E%204%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n0%20%3D%20ListNode%281%29%0A%20%20%20%20n1%20%3D%20ListNode%283%29%0A%20%20%20%20n2%20%3D%20ListNode%282%29%0A%20%20%20%20n3%20%3D%20ListNode%285%29%0A%20%20%20%20n4%20%3D%20ListNode%284%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%0A%20%20%20%20n0.next%20%3D%20n1%0A%20%20%20%20n1.next%20%3D%20n2%0A%20%20%20%20n2.next%20%3D%20n3%0A%20%20%20%20n3.next%20%3D%20n4&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Массив в целом - это одна переменная: например, массив <code>nums</code> содержит элементы <code>nums[0]</code> , <code>nums[1]</code> и т.д. Связный список же состоит из множества независимых объектов-узлов. Обычно в качестве обозначения всего связного списка используют головной узел; например, в приведенном выше коде связный список можно обозначить как <code>n0</code> .</p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   Вставка узла","text":"<p>Вставить узел в связный список очень легко. Как показано на рисунке 4-6, предположим, что мы хотим вставить новый узел <code>P</code> между двумя соседними узлами <code>n0</code> и <code>n1</code> ; для этого нужно изменить всего две ссылки (указателя), а временная сложность будет равна \\(O(1)\\) .</p> <p>Для сравнения: временная сложность вставки элемента в массив составляет \\(O(n)\\) , и при большом объеме данных это менее эффективно.</p> <p></p> <p> Рисунок 4-6   Пример вставки узла в связный список </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"Вставить узел P после узла n0 в связном списке\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* Вставить узел P после узла n0 в связном списке */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* Вставить узел P после узла n0 в связном списке */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* Вставить узел P после узла n0 в связном списке */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### Вставка узла _p после узла n0 в связном списке ###\n# В Ruby `p` является встроенной функцией, а `P` — константой, поэтому вместо них можно использовать `_p`\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   Удаление узла","text":"<p>Как показано на рисунке 4-7, удалить узел из связного списка тоже очень просто: нужно изменить всего одну ссылку (указатель).</p> <p>Стоит отметить, что хотя после завершения операции удаления узел <code>P</code> все еще указывает на <code>n1</code> , при обходе связного списка до <code>P</code> уже нельзя добраться. Это означает, что <code>P</code> фактически больше не принадлежит данному списку.</p> <p></p> <p> Рисунок 4-7   Удаление узла из связного списка </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"Удалить первый узел после узла n0 в связном списке\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Освободить память\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* Удалить первый узел после узла n0 в связном списке */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* Удалить первый узел после узла n0 в связном списке */\n// Внимание: stdio.h уже использует ключевое слово remove\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // Освободить память\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* Удалить первый узел после узла n0 в связном списке */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### Удаление первого узла после узла n0 в связном списке ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   Доступ к узлу","text":"<p>Доступ к узлам в связном списке менее эффективен. Как уже обсуждалось в предыдущем разделе, к любому элементу массива можно обратиться за \\(O(1)\\) времени. Со связным списком это не так: программе нужно начать с головного узла и последовательно двигаться дальше, пока не будет найден целевой узел. То есть для доступа к \\(i\\) -му узлу списка нужно выполнить \\(i - 1\\) итераций, а временная сложность составляет \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"Доступ к узлу связного списка по индексу index\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* Доступ к узлу связного списка по индексу index */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* Доступ к узлу связного списка по индексу index */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* Доступ к узлу связного списка по индексу index */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* Доступ к узлу связного списка по индексу index */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### Доступ к узлу связного списка по индексу index ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   Поиск узла","text":"<p>Поиск узла заключается в обходе связного списка, нахождении узла со значением <code>target</code> и возврате его индекса в списке. Этот процесс тоже относится к линейному поиску. Код выглядит следующим образом:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"Найти в связном списке первый узел со значением target\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* Найти в связном списке первый узел со значением target */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* Найти в связном списке первый узел со значением target */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* Найти в связном списке первый узел со значением target */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* Найти в связном списке первый узел со значением target */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* Найти в связном списке первый узел со значением target */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* Найти в связном списке первый узел со значением target */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* Найти в связном списке первый узел со значением target */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* Найти в связном списке первый узел со значением target */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### Поиск первого узла со значением target в связном списке ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422","level":2,"title":"4.2.2   Сравнение массива и связного списка","text":"<p>В таблице 4-1 обобщаются свойства массива и связного списка, а также сравнивается эффективность соответствующих операций. Поскольку они используют противоположные стратегии хранения, их свойства и эффективность операций тоже во многом противоположны.</p> <p> Таблица 4-1   Сравнение эффективности массива и связного списка </p> Массив Связный список Способ хранения Непрерывная область памяти Разрозненная область памяти Расширение емкости Длина неизменяема Гибкое расширение Эффективность памяти Элементы занимают меньше памяти, но возможны потери пространства Элементы занимают больше памяти Доступ к элементу \\(O(1)\\) \\(O(n)\\) Добавление элемента \\(O(n)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(1)\\)","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   Основные типы связных списков","text":"<p>Как показано на рисунке 4-8, существует три распространенных типа связных списков.</p> <ul> <li>Односвязный список: это обычный связный список, рассмотренный выше. Узел односвязного списка содержит значение и ссылку на следующий узел. Первый узел называется головным, последний - хвостовым, и хвост указывает на <code>None</code> .</li> <li>Циклический список: если заставить хвостовой узел односвязного списка указывать на головной, то есть соединить хвост с головой, получится циклический список. В циклическом списке любой узел можно рассматривать как головной.</li> <li>Двусвязный список: по сравнению с односвязным списком двусвязный хранит ссылки в двух направлениях. Определение узла двусвязного списка включает как ссылку на следующий узел, так и ссылку на предыдущий узел. По сравнению с односвязным списком двусвязный более гибок и позволяет обходить список в обе стороны, но за это приходится платить дополнительной памятью.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"Класс узла двусвязного списка\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Значение узла\n        self.next: ListNode | None = None  # Ссылка на следующий узел\n        self.prev: ListNode | None = None  # Ссылка на предыдущий узел\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\nstruct ListNode {\n    int val;         // Значение узла\n    ListNode *next;  // Указатель на следующий узел\n    ListNode *prev;  // Указатель на предыдущий узел\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Конструктор\n};\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode prev;  // Ссылка на предыдущий узел\n    ListNode(int x) { val = x; }  // Конструктор\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode(int x) {  // Конструктор\n    int val = x;    // Значение узла\n    ListNode next;  // Ссылка на следующий узел\n    ListNode prev;  // Ссылка на предыдущий узел\n}\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\ntype DoublyListNode struct {\n    Val  int             // Значение узла\n    Next *DoublyListNode // Указатель на следующий узел\n    Prev *DoublyListNode // Указатель на предыдущий узел\n}\n\n// NewDoublyListNode Инициализация\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на следующий узел\n    var prev: ListNode? // Ссылка на предыдущий узел\n\n    init(x: Int) { // Конструктор\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Значение узла\n        this.next = next  ===  undefined ? null : next;  // Ссылка на следующий узел\n        this.prev = prev  ===  undefined ? null : prev;  // Ссылка на предыдущий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Значение узла\n        this.next = next  ===  undefined ? null : next;  // Ссылка на следующий узел\n        this.prev = prev  ===  undefined ? null : prev;  // Ссылка на предыдущий узел\n    }\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\nclass ListNode {\n    int val;        // Значение узла\n    ListNode? next;  // Ссылка на следующий узел\n    ListNode? prev;  // Ссылка на предыдущий узел\n    ListNode(this.val, [this.next, this.prev]);  // Конструктор\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Тип узла двусвязного списка */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Значение узла\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на следующий узел\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // Указатель на предыдущий узел\n}\n\n/* Конструктор */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* Структура узла двусвязного списка */\ntypedef struct ListNode {\n    int val;               // Значение узла\n    struct ListNode *next; // Указатель на следующий узел\n    struct ListNode *prev; // Указатель на предыдущий узел\n} ListNode;\n\n/* Конструктор */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла двусвязного списка */\n// Конструктор\nclass ListNode(x: Int) {\n    val _val: Int = x           // Значение узла\n    val next: ListNode? = null  // Ссылка на следующий узел\n    val prev: ListNode? = null  // Ссылка на предыдущий узел\n}\n</code></pre> <pre><code># Класс узла двусвязного списка\nclass ListNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :next   # Ссылка на следующий узел\n  attr_accessor :prev   # Ссылка на предыдущий узел\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> Рисунок 4-8   Распространенные типы связных списков </p>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   Типичные применения связных списков","text":"<p>Односвязные списки обычно используются для реализации стеков, очередей, хеш-таблиц и графов.</p> <ul> <li>Стеки и очереди: если операции вставки и удаления выполняются на одном конце связного списка, он проявляет свойства LIFO, соответствующие стеку; если вставка происходит на одном конце, а удаление на другом, он проявляет свойства FIFO, соответствующие очереди.</li> <li>Хеш-таблицы: метод цепочек - один из основных способов разрешения коллизий в хеш-таблицах. В этом подходе все конфликтующие элементы помещаются в связный список.</li> <li>Графы: список смежности - это распространенный способ представления графа, при котором каждой вершине графа соответствует связный список, а каждый элемент этого списка представляет другую вершину, соединенную с данной.</li> </ul> <p>Двусвязные списки обычно используются там, где нужен быстрый доступ как к предыдущему, так и к следующему элементу.</p> <ul> <li>Продвинутые структуры данных: например, в красно-черных деревьях и B-деревьях нам нужен доступ к родительскому узлу; этого можно добиться, сохранив в узле ссылку на родителя, по аналогии с двусвязным списком.</li> <li>История браузера: когда пользователь в браузере нажимает кнопки \"вперед\" или \"назад\", браузеру нужно знать предыдущую и следующую посещенные страницы. Свойства двусвязного списка делают такую операцию простой.</li> <li>Алгоритм LRU: в алгоритмах вытеснения из кэша (LRU) нужно быстро находить наименее недавно использованные данные, а также быстро добавлять и удалять узлы. Для этого двусвязный список подходит очень хорошо.</li> </ul> <p>Циклические списки часто применяются в сценариях, требующих циклических операций, например при планировании ресурсов в операционной системе.</p> <ul> <li>Алгоритм циклического распределения кванта времени: в операционных системах round-robin scheduling - это распространенный алгоритм планирования CPU, который циклически обходит набор процессов. Каждому процессу выделяется квант времени, и когда он исчерпан, CPU переключается на следующий процесс. Такую циклическую операцию удобно реализовать с помощью кольцевого списка.</li> <li>Буферы данных: в некоторых реализациях буферов данных также могут использоваться циклические списки. Например, в аудио- и видеоплеерах поток данных может делиться на несколько буферных блоков и помещаться в кольцевой список для обеспечения непрерывного воспроизведения.</li> </ul>","path":["Глава 4. Массивы и списки","4.2 &nbsp; Связный список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   Список","text":"<p>Список (list) - это абстрактное понятие структуры данных, обозначающее упорядоченную коллекцию элементов, которая поддерживает доступ к элементам, их изменение, добавление, удаление и обход, не требуя от пользователя учитывать ограничения по емкости. Список может быть реализован как на основе связного списка, так и на основе массива.</p> <ul> <li>Связный список естественным образом можно рассматривать как список: он поддерживает операции добавления, удаления, поиска и изменения элементов и может гибко расширяться динамически.</li> <li>Массив тоже поддерживает операции добавления, удаления, поиска и изменения элементов, но из-за неизменяемости длины его можно считать лишь списком с ограниченной длиной.</li> </ul> <p>Когда список реализуется с помощью массива, неизменяемость длины снижает его практическую полезность. Причина в том, что мы обычно не можем заранее точно знать, сколько данных нужно хранить, а значит, трудно выбрать подходящую длину списка. Если длина слишком мала, она может не покрыть реальные потребности; если слишком велика, будет зря расходоваться память.</p> <p>Чтобы решить эту проблему, можно использовать динамический массив (dynamic array) для реализации списка. Он сохраняет все преимущества массива и при этом может динамически расширяться во время выполнения программы.</p> <p>На практике списки из стандартных библиотек многих языков программирования реализованы именно на основе динамических массивов, например <code>list</code> в Python, <code>ArrayList</code> в Java, <code>vector</code> в C++ и <code>List</code> в C#. В дальнейшем обсуждении мы будем считать понятия \"список\" и \"динамический массив\" эквивалентными.</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   Основные операции со списком","text":"","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   Инициализация списка","text":"<p>Обычно используются два способа инициализации: без начальных значений и с начальными значениями:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Инициализация списка\n# Без начальных значений\nnums1: list[int] = []\n# С начальными значениями\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* Инициализация списка */\n// Обрати внимание: в C++ vector соответствует описываемому здесь nums\n// Без начальных значений\nvector&lt;int&gt; nums1;\n// С начальными значениями\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// С начальными значениями (обрати внимание: элементы массива должны использовать обертку Integer[] вместо int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;int&gt; nums1 = [];\n// С начальными значениями\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* Инициализация списка */\n// Без начальных значений\nnums1 := []int{}\n// С начальными значениями\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* Инициализация списка */\n// Без начальных значений\nlet nums1: [Int] = []\n// С начальными значениями\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* Инициализация списка */\n// Без начальных значений\nconst nums1 = [];\n// С начальными значениями\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* Инициализация списка */\n// Без начальных значений\nconst nums1: number[] = [];\n// С начальными значениями\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* Инициализация списка */\n// Без начальных значений\nList&lt;int&gt; nums1 = [];\n// С начальными значениями\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* Инициализация списка */\n// Без начальных значений\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// С начальными значениями\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Инициализация списка */\n// Без начальных значений\nvar nums1 = listOf&lt;Int&gt;()\n// С начальными значениями\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># Инициализация списка\n# Без начальных значений\nnums1 = []\n# С начальными значениями\nnums = [1, 3, 2, 5, 4]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20%23%20%D0%91%D0%B5%D0%B7%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D1%85%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9%0A%20%20%20%20nums1%20%3D%20%5B%5D%0A%20%20%20%20%23%20%D0%A1%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%BC%D0%B8%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D&amp;cumulative=false&amp;curInstr=4&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   Доступ к элементам","text":"<p>Поскольку в этом разделе список рассматривается как структура на основе динамического массива, доступ к элементам и их обновление можно выполнять за \\(O(1)\\) времени, что очень эффективно.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Доступ к элементу\nnum: int = nums[1]  # Доступ к элементу по индексу 1\n\n# Обновление элемента\nnums[1] = 0    # Обновить элемент по индексу 1 значением 0\n</code></pre> list.cpp<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.java<pre><code>/* Доступ к элементу */\nint num = nums.get(1);  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums.set(1, 0);  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.cs<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list_test.go<pre><code>/* Доступ к элементу */\nnum := nums[1]  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0     // Обновить элемент по индексу 1 значением 0\n</code></pre> list.swift<pre><code>/* Доступ к элементу */\nlet num = nums[1] // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0 // Обновить элемент по индексу 1 значением 0\n</code></pre> list.js<pre><code>/* Доступ к элементу */\nconst num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.ts<pre><code>/* Доступ к элементу */\nconst num: number = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.dart<pre><code>/* Доступ к элементу */\nint num = nums[1];  // Доступ к элементу по индексу 1\n\n/* Обновление элемента */\nnums[1] = 0;  // Обновить элемент по индексу 1 значением 0\n</code></pre> list.rs<pre><code>/* Доступ к элементу */\nlet num: i32 = nums[1];  // Доступ к элементу по индексу 1\n/* Обновление элемента */\nnums[1] = 0;             // Обновить элемент по индексу 1 значением 0\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Доступ к элементу */\nval num = nums[1]       // Доступ к элементу по индексу 1\n/* Обновление элемента */\nnums[1] = 0             // Обновить элемент по индексу 1 значением 0\n</code></pre> list.rb<pre><code># Доступ к элементу\nnum = nums[1] # Доступ к элементу по индексу 1\n# Обновление элемента\nnums[1] = 0 # Обновить элемент по индексу 1 значением 0\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%20%D0%BA%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%83%0A%20%20%20%20num%20%3D%20nums%5B1%5D%20%20%23%20%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%B8%D1%82%D1%8C%D1%81%D1%8F%20%D0%BA%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%201%20%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%0A%20%20%20%20%23%20%D0%9E%D0%B1%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%20%20%20%20nums%5B1%5D%20%3D%200%20%20%20%20%23%20%D0%9E%D0%B1%D0%BD%D0%BE%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%201%20%D0%B4%D0%BE%200&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   Вставка и удаление элементов","text":"<p>В отличие от массива список позволяет свободно добавлять и удалять элементы. Добавление элемента в конец списка имеет временную сложность \\(O(1)\\) , но операции вставки и удаления по-прежнему имеют ту же эффективность, что и у массива, то есть \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Очистить список\nnums.clear()\n\n# Добавить элементы в конец\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Вставить элемент в середину\nnums.insert(3, 6)  # Вставить число 6 по индексу 3\n\n# Удалить элемент\nnums.pop(3)        # Удалить элемент по индексу 3\n</code></pre> list.cpp<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Вставить элемент в середину */\nnums.insert(nums.begin() + 3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.erase(nums.begin() + 3);      // Удалить элемент по индексу 3\n</code></pre> list.java<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.add(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);  // Удалить элемент по индексу 3\n</code></pre> list.cs<pre><code>/* Очистить список */\nnums.Clear();\n\n/* Добавить элементы в конец */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Вставить элемент в середину */\nnums.Insert(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.RemoveAt(3);  // Удалить элемент по индексу 3\n</code></pre> list_test.go<pre><code>/* Очистить список */\nnums = nil\n\n/* Добавить элементы в конец */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Вставить элемент в середину */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums = append(nums[:3], nums[4:]...) // Удалить элемент по индексу 3\n</code></pre> list.swift<pre><code>/* Очистить список */\nnums.removeAll()\n\n/* Добавить элементы в конец */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Вставить элемент в середину */\nnums.insert(6, at: 3) // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(at: 3) // Удалить элемент по индексу 3\n</code></pre> list.js<pre><code>/* Очистить список */\nnums.length = 0;\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.splice(3, 0, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.splice(3, 1);  // Удалить элемент по индексу 3\n</code></pre> list.ts<pre><code>/* Очистить список */\nnums.length = 0;\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.splice(3, 0, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.splice(3, 1);  // Удалить элемент по индексу 3\n</code></pre> list.dart<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.insert(3, 6); // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.removeAt(3); // Удалить элемент по индексу 3\n</code></pre> list.rs<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Вставить элемент в середину */\nnums.insert(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);    // Удалить элемент по индексу 3\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Очистить список */\nnums.clear();\n\n/* Добавить элементы в конец */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Вставить элемент в середину */\nnums.add(3, 6);  // Вставить число 6 по индексу 3\n\n/* Удалить элемент */\nnums.remove(3);  // Удалить элемент по индексу 3\n</code></pre> list.rb<pre><code># Очистить список\nnums.clear\n\n# Добавить элементы в конец\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# Вставить элемент в середину\nnums.insert(3, 6) # Вставить число 6 по индексу 3\n\n# Удалить элемент\nnums.delete_at(3) # Удалить элемент по индексу 3\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%A1%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%BC%D0%B8%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D1%87%D0%B8%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums.clear%28%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20nums.append%281%29%0A%20%20%20%20nums.append%283%29%0A%20%20%20%20nums.append%282%29%0A%20%20%20%20nums.append%285%29%0A%20%20%20%20nums.append%284%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D1%83%0A%20%20%20%20nums.insert%283%2C%206%29%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%87%D0%B8%D1%81%D0%BB%D0%BE%206%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%203%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%0A%20%20%20%20nums.pop%283%29%20%20%20%20%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%83%203&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   Обход списка","text":"<p>Как и массив, список можно обходить как по индексам, так и напрямую по элементам.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Обход списка по индексам\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Прямой обход элементов списка\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Прямой обход элементов списка */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* Обход списка по индексам */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* Обход списка по индексам */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* Обход списка по индексам */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* Обход списка по индексам */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* Обход списка по индексам */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* Прямой обход элементов списка */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// Обход списка по индексам\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Прямой обход элементов списка\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Обход списка по индексам */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* Прямой обход элементов списка */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># Обход списка по индексам\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# Прямой обход элементов списка\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%B1%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%20%D0%BF%D0%BE%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%B0%D0%BC%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20nums%5Bi%5D%0A%0A%20%20%20%20%23%20%D0%9D%D0%B5%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%20%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%20num&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   Конкатенация списков","text":"<p>Создав новый список <code>nums1</code> , мы можем присоединить его к хвосту исходного списка.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Конкатенация двух списков\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Присоединить список nums1 к концу nums\n</code></pre> list.cpp<pre><code>/* Конкатенация двух списков */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// Присоединить список nums1 к концу nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* Конкатенация двух списков */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.cs<pre><code>/* Конкатенация двух списков */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list_test.go<pre><code>/* Конкатенация двух списков */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Присоединить список nums1 к концу nums\n</code></pre> list.swift<pre><code>/* Конкатенация двух списков */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Присоединить список nums1 к концу nums\n</code></pre> list.js<pre><code>/* Конкатенация двух списков */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.ts<pre><code>/* Конкатенация двух списков */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.dart<pre><code>/* Конкатенация двух списков */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Присоединить список nums1 к концу nums\n</code></pre> list.rs<pre><code>/* Конкатенация двух списков */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Конкатенация двух списков */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // Присоединить список nums1 к концу nums\n</code></pre> list.rb<pre><code># Конкатенация двух списков\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D0%B4%D0%B2%D0%B0%20%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20nums1%20%3D%20%5B6%2C%208%2C%207%2C%2010%2C%209%5D%0A%20%20%20%20nums%20%2B%3D%20nums1%20%20%23%20%D0%9F%D1%80%D0%B8%D1%81%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%20nums1%20%D0%BA%20nums&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   Сортировка списка","text":"<p>После сортировки списка мы сможем применять алгоритмы \"двоичный поиск\" и \"два указателя\", которые очень часто встречаются в задачах по массивам.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># Отсортировать список\nnums.sort()  # После сортировки элементы списка идут по возрастанию\n</code></pre> list.cpp<pre><code>/* Отсортировать список */\nsort(nums.begin(), nums.end());  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.java<pre><code>/* Отсортировать список */\nCollections.sort(nums);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.cs<pre><code>/* Отсортировать список */\nnums.Sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list_test.go<pre><code>/* Отсортировать список */\nsort.Ints(nums)  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.swift<pre><code>/* Отсортировать список */\nnums.sort() // После сортировки элементы списка идут по возрастанию\n</code></pre> list.js<pre><code>/* Отсортировать список */\nnums.sort((a, b) =&gt; a - b);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.ts<pre><code>/* Отсортировать список */\nnums.sort((a, b) =&gt; a - b);  // После сортировки элементы списка идут по возрастанию\n</code></pre> list.dart<pre><code>/* Отсортировать список */\nnums.sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list.rs<pre><code>/* Отсортировать список */\nnums.sort(); // После сортировки элементы списка идут по возрастанию\n</code></pre> list.c<pre><code>// В C нет встроенного динамического массива\n</code></pre> list.kt<pre><code>/* Отсортировать список */\nnums.sort() // После сортировки элементы списка идут по возрастанию\n</code></pre> list.rb<pre><code># Отсортировать список\nnums = nums.sort { |a, b| a &lt;=&gt; b } # После сортировки элементы списка идут по возрастанию\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%0A%20%20%20%20nums.sort%28%29%20%20%23%20%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%2C%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%80%D0%B0%D1%81%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D1%8B%20%D0%BF%D0%BE%20%D0%B2%D0%BE%D0%B7%D1%80%D0%B0%D1%81%D1%82%D0%B0%D0%BD%D0%B8%D1%8E&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   Реализация списка","text":"<p>Во многих языках программирования списки встроены в стандартную библиотеку, например в Java, C++, Python и других языках. Их реализация довольно сложна, а настройки параметров тщательно продуманы: начальная емкость, коэффициент расширения и так далее. Если это интересно, стоит заглянуть в исходный код.</p> <p>Чтобы лучше понять принцип работы списка, попробуем реализовать его упрощенную версию, в которой есть три ключевых аспекта проектирования.</p> <ul> <li>Начальная емкость: выбрать разумную начальную емкость внутреннего массива. В этом примере мы берем 10.</li> <li>Учет количества элементов: объявить переменную <code>size</code> , которая будет хранить текущее число элементов в списке и обновляться в реальном времени при вставке и удалении элементов. С помощью этой переменной можно определять конец списка и понимать, требуется ли расширение.</li> <li>Механизм расширения: если при вставке элементов емкость списка исчерпана, нужно выполнить расширение. Для этого сначала создается больший массив с учетом коэффициента расширения, а затем все элементы текущего массива по порядку переносятся в новый. В этом примере мы считаем, что каждый раз массив расширяется в 2 раза.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"Класс списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._capacity: int = 10  # Вместимость списка\n        self._arr: list[int] = [0] * self._capacity  # Массив (для хранения элементов списка)\n        self._size: int = 0  # Длина списка (текущее число элементов)\n        self._extend_ratio: int = 2  # Коэффициент увеличения списка при каждом расширении\n\n    def size(self) -&gt; int:\n        \"\"\"Получить длину списка (текущее число элементов)\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость списка\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"Доступ к элементу\"\"\"\n        # Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"Обновление элемента\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"Добавление элемента в конец\"\"\"\n        # При превышении вместимости по числу элементов запускается расширение\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"Вставка элемента в середину\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        # При превышении вместимости по числу элементов запускается расширение\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # Обновить число элементов\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"Удаление элемента\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"индекс выходит за границы\")\n        num = self._arr[index]\n        # Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # Обновить число элементов\n        self._size -= 1\n        # Вернуть удаленный элемент\n        return num\n\n    def extend_capacity(self):\n        \"\"\"Расширение списка\"\"\"\n        # Создать новый массив длиной в _extend_ratio раз больше исходного массива и скопировать в него исходный массив\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # Обновить вместимость списка\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть список фактической длины\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* Класс списка */\nclass MyList {\n  private:\n    int *arr;             // Массив (для хранения элементов списка)\n    int arrCapacity = 10; // Вместимость списка\n    int arrSize = 0;      // Длина списка (текущее число элементов)\n    int extendRatio = 2;   // Коэффициент увеличения списка при каждом расширении\n\n  public:\n    /* Конструктор */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Метод-деструктор */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    int size() {\n        return arrSize;\n    }\n\n    /* Получить вместимость списка */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* Доступ к элементу */\n    int get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    void add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Вставка элемента в середину */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size() == capacity())\n            extendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Удаление элемента */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        arrSize--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    void extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного массива\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // Скопировать все элементы исходного массива в новый массив\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // Освободить память\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* Преобразовать список в Vector для вывода */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* Класс списка */\nclass MyList {\n    private int[] arr; // Массив (для хранения элементов списка)\n    private int capacity = 10; // Вместимость списка\n    private int size = 0; // Длина списка (текущее число элементов)\n    private int extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public int size() {\n        return size;\n    }\n\n    /* Получить вместимость списка */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* Доступ к элементу */\n    public int get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public void add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // Обновить число элементов\n        size++;\n    }\n\n    /* Вставка элемента в середину */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        size++;\n    }\n\n    /* Удаление элемента */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public void extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // Обновить вместимость списка\n        capacity = arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    public int[] toArray() {\n        int size = size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* Класс списка */\nclass MyList {\n    private int[] arr;           // Массив (для хранения элементов списка)\n    private int arrCapacity = 10;    // Вместимость списка\n    private int arrSize = 0;         // Длина списка (текущее число элементов)\n    private readonly int extendRatio = 2;  // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public int Size() {\n        return arrSize;\n    }\n\n    /* Получить вместимость списка */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* Доступ к элементу */\n    public int Get(int index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        return arr[index];\n    }\n\n    /* Обновление элемента */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public void Add(int num) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Вставка элемента в середину */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        // При превышении вместимости по числу элементов запускается расширение\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // Обновить число элементов\n        arrSize++;\n    }\n\n    /* Удаление элемента */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"индекс выходит за границы\");\n        int num = arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // Обновить число элементов\n        arrSize--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public void ExtendCapacity() {\n        // Создать новый массив длиной arrCapacity * extendRatio и скопировать в него исходный массив\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // Обновить вместимость списка\n        arrCapacity = arr.Length;\n    }\n\n    /* Преобразовать список в массив */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* Класс списка */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* Конструктор */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // Вместимость списка\n        arr:         make([]int, 10), // Массив (для хранения элементов списка)\n        arrSize:     0,               // Длина списка (текущее число элементов)\n        extendRatio: 2,               // Коэффициент увеличения списка при каждом расширении\n    }\n}\n\n/* Получить длину списка (текущее число элементов) */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/* Получить вместимость списка */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* Доступ к элементу */\nfunc (l *myList) get(index int) int {\n    // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    return l.arr[index]\n}\n\n/* Обновление элемента */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    l.arr[index] = num\n}\n\n/* Добавление элемента в конец */\nfunc (l *myList) add(num int) {\n    // При превышении вместимости по числу элементов запускается расширение\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // Обновить число элементов\n    l.arrSize++\n}\n\n/* Вставка элемента в середину */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    // При превышении вместимости по числу элементов запускается расширение\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // Обновить число элементов\n    l.arrSize++\n}\n\n/* Удаление элемента */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"индекс выходит за границы\")\n    }\n    num := l.arr[index]\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // Обновить число элементов\n    l.arrSize--\n    // Вернуть удаленный элемент\n    return num\n}\n\n/* Расширение списка */\nfunc (l *myList) extendCapacity() {\n    // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // Обновить вместимость списка\n    l.arrCapacity = len(l.arr)\n}\n\n/* Вернуть список фактической длины */\nfunc (l *myList) toArray() []int {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* Класс списка */\nclass MyList {\n    private var arr: [Int] // Массив (для хранения элементов списка)\n    private var _capacity: Int // Вместимость списка\n    private var _size: Int // Длина списка (текущее число элементов)\n    private let extendRatio: Int // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Получить вместимость списка */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* Доступ к элементу */\n    func get(index: Int) -&gt; Int {\n        // Если индекс выходит за границы, выбросить ошибку; далее аналогично\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        return arr[index]\n    }\n\n    /* Обновление элемента */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        arr[index] = num\n    }\n\n    /* Добавление элемента в конец */\n    func add(num: Int) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // Обновить число элементов\n        _size += 1\n    }\n\n    /* Вставка элемента в середину */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        // При превышении вместимости по числу элементов запускается расширение\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // Обновить число элементов\n        _size += 1\n    }\n\n    /* Удаление элемента */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"индекс выходит за границы\")\n        }\n        let num = arr[index]\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // Обновить число элементов\n        _size -= 1\n        // Вернуть удаленный элемент\n        return num\n    }\n\n    /* Расширение списка */\n    func extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // Обновить вместимость списка\n        _capacity = arr.count\n    }\n\n    /* Преобразовать список в массив */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* Класс списка */\nclass MyList {\n    #arr = new Array(); // Массив (для хранения элементов списка)\n    #capacity = 10; // Вместимость списка\n    #size = 0; // Длина списка (текущее число элементов)\n    #extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    size() {\n        return this.#size;\n    }\n\n    /* Получить вместимость списка */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* Доступ к элементу */\n    get(index) {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        return this.#arr[index];\n    }\n\n    /* Обновление элемента */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        this.#arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    add(num) {\n        // Если длина равна вместимости, требуется расширение\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Добавить новый элемент в конец списка\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* Вставка элемента в середину */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        // При превышении вместимости по числу элементов запускается расширение\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // Обновить число элементов\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* Удаление элемента */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('индекс выходит за границы');\n        let num = this.#arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // Обновить число элементов\n        this.#size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // Обновить вместимость списка\n        this.#capacity = this.#arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    toArray() {\n        let size = this.size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* Класс списка */\nclass MyList {\n    private arr: Array&lt;number&gt;; // Массив (для хранения элементов списка)\n    private _capacity: number = 10; // Вместимость списка\n    private _size: number = 0; // Длина списка (текущее число элементов)\n    private extendRatio: number = 2; // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    public size(): number {\n        return this._size;\n    }\n\n    /* Получить вместимость списка */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* Доступ к элементу */\n    public get(index: number): number {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        return this.arr[index];\n    }\n\n    /* Обновление элемента */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        this.arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    public add(num: number): void {\n        // Если длина равна вместимости, требуется расширение\n        if (this._size === this._capacity) this.extendCapacity();\n        // Добавить новый элемент в конец списка\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* Вставка элемента в середину */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        // При превышении вместимости по числу элементов запускается расширение\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // Обновить число элементов\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* Удаление элемента */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('индекс выходит за границы');\n        let num = this.arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // Обновить число элементов\n        this._size--;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    public extendCapacity(): void {\n        // Создать новый массив длиной size и скопировать в него исходный массив\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // Обновить вместимость списка\n        this._capacity = this.arr.length;\n    }\n\n    /* Преобразовать список в массив */\n    public toArray(): number[] {\n        let size = this.size();\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* Класс списка */\nclass MyList {\n  late List&lt;int&gt; _arr; // Массив (для хранения элементов списка)\n  int _capacity = 10; // Вместимость списка\n  int _size = 0; // Длина списка (текущее число элементов)\n  int _extendRatio = 2; // Коэффициент увеличения списка при каждом расширении\n\n  /* Конструктор */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* Получить длину списка (текущее число элементов) */\n  int size() =&gt; _size;\n\n  /* Получить вместимость списка */\n  int capacity() =&gt; _capacity;\n\n  /* Доступ к элементу */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    return _arr[index];\n  }\n\n  /* Обновление элемента */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    _arr[index] = _num;\n  }\n\n  /* Добавление элемента в конец */\n  void add(int _num) {\n    // При превышении вместимости по числу элементов запускается расширение\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // Обновить число элементов\n    _size++;\n  }\n\n  /* Вставка элемента в середину */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    // При превышении вместимости по числу элементов запускается расширение\n    if (_size == _capacity) extendCapacity();\n    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // Обновить число элементов\n    _size++;\n  }\n\n  /* Удаление элемента */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('индекс выходит за границы');\n    int _num = _arr[index];\n    // Сдвинуть все элементы после индекса index на одну позицию вперед\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // Обновить число элементов\n    _size--;\n    // Вернуть удаленный элемент\n    return _num;\n  }\n\n  /* Расширение списка */\n  void extendCapacity() {\n    // Создать новый массив длиной в _extendRatio раз больше исходного массива\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // Скопировать исходный массив в новый массив\n    List.copyRange(_newNums, 0, _arr);\n    // Обновить ссылку на _arr\n    _arr = _newNums;\n    // Обновить вместимость списка\n    _capacity = _arr.length;\n  }\n\n  /* Преобразовать список в массив */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* Класс списка */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // Массив (для хранения элементов списка)\n    capacity: usize,     // Вместимость списка\n    size: usize,         // Длина списка (текущее число элементов)\n    extend_ratio: usize, // Коэффициент увеличения списка при каждом расширении\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* Конструктор */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* Получить вместимость списка */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* Доступ к элементу */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if index &gt;= self.size {\n            panic!(\"индекс выходит за границы\")\n        };\n        return self.arr[index];\n    }\n\n    /* Обновление элемента */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"индекс выходит за границы\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* Добавление элемента в конец */\n    pub fn add(&amp;mut self, num: i32) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // Обновить число элементов\n        self.size += 1;\n    }\n\n    /* Вставка элемента в середину */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"индекс выходит за границы\")\n        };\n        // При превышении вместимости по числу элементов запускается расширение\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // Обновить число элементов\n        self.size += 1;\n    }\n\n    /* Удаление элемента */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"индекс выходит за границы\")\n        };\n        let num = self.arr[index];\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // Обновить число элементов\n        self.size -= 1;\n        // Вернуть удаленный элемент\n        return num;\n    }\n\n    /* Расширение списка */\n    pub fn extend_capacity(&amp;mut self) {\n        // Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // Обновить вместимость списка\n        self.capacity = new_capacity;\n    }\n\n    /* Преобразовать список в массив */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* Класс списка */\ntypedef struct {\n    int *arr;        // Массив (для хранения элементов списка)\n    int capacity;    // Вместимость списка\n    int size;        // Размер списка\n    int extendRatio; // Коэффициент расширения списка при каждом увеличении\n} MyList;\n\n/* Конструктор */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* Деструктор */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* Получить длину списка */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* Получить вместимость списка */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* Доступ к элементу */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* Обновление элемента */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* Добавление элемента в конец */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Расширение емкости\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* Вставка элемента в середину */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // При превышении вместимости по числу элементов запускается расширение\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // Расширение емкости\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* Удаление элемента */\n// Внимание: stdio.h уже использует ключевое слово remove\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* Расширение списка */\nvoid extendCapacity(MyList *nums) {\n    // Сначала выделить память\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // Скопировать старые данные в новые\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // Освободить старые данные\n    free(temp);\n\n    // Обновить новые данные\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* Преобразовать список в Array для вывода */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* Класс списка */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // Массив (для хранения элементов списка)\n    private var capacity: Int = 10 // Вместимость списка\n    private var size: Int = 0 // Длина списка (текущее число элементов)\n    private var extendRatio: Int = 2 // Коэффициент увеличения списка при каждом расширении\n\n    /* Конструктор */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* Получить длину списка (текущее число элементов) */\n    fun size(): Int {\n        return size\n    }\n\n    /* Получить вместимость списка */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* Доступ к элементу */\n    fun get(index: Int): Int {\n        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        return arr[index]\n    }\n\n    /* Обновление элемента */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        arr[index] = num\n    }\n\n    /* Добавление элемента в конец */\n    fun add(num: Int) {\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // Обновить число элементов\n        size++\n    }\n\n    /* Вставка элемента в середину */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        // При превышении вместимости по числу элементов запускается расширение\n        if (size == capacity())\n            extendCapacity()\n        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // Обновить число элементов\n        size++\n    }\n\n    /* Удаление элемента */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"индекс выходит за границы\")\n        val num = arr[index]\n        // Сдвинуть все элементы после индекса index на одну позицию вперед\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // Обновить число элементов\n        size--\n        // Вернуть удаленный элемент\n        return num\n    }\n\n    /* Расширение списка */\n    fun extendCapacity() {\n        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив\n        arr = arr.copyOf(capacity() * extendRatio)\n        // Обновить вместимость списка\n        capacity = arr.size\n    }\n\n    /* Преобразовать список в массив */\n    fun toArray(): IntArray {\n        val size = size()\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### Класс списка ###\nclass MyList\n  attr_reader :size       # Получить длину списка (текущее число элементов)\n  attr_reader :capacity   # Получить вместимость списка\n\n  ### Конструктор ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### Доступ к элементу ###\n  def get(index)\n    # Если индекс выходит за границы, выбрасывается исключение; далее аналогично\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### Доступ к элементу ###\n  def set(index, num)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### Добавление элемента в конец ###\n  def add(num)\n    # При превышении вместимости по числу элементов запускается расширение\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # Обновить число элементов\n    @size += 1\n  end\n\n  ### Вставка элемента в середину ###\n  def insert(index, num)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n\n    # При превышении вместимости по числу элементов запускается расширение\n    extend_capacity if size == capacity\n\n    # Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # Обновить число элементов\n    @size += 1\n  end\n\n  ### Удаление элемента ###\n  def remove(index)\n    raise IndexError, \"индекс выходит за границы\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # Сдвинуть все элементы после индекса index на одну позицию вперед\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # Обновить число элементов\n    @size -= 1\n\n    # Вернуть удаленный элемент\n    num\n  end\n\n  ### Расширение списка ###\n  def extend_capacity\n    # Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # Обновить вместимость списка\n    @capacity = arr.length\n  end\n\n  ### Преобразование списка в массив ###\n  def to_array\n    sz = size\n    # Преобразовывать только элементы списка в пределах фактической длины\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 4. Массивы и списки","4.3 &nbsp; Список"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   Оперативная память и кэш *","text":"<p>В первых двух разделах этой главы мы разобрали массивы и связные списки - две базовые и важные структуры данных, которые представляют соответственно непрерывное хранение и разрозненное хранение.</p> <p>На практике физическая структура во многом определяет, насколько эффективно программа использует память и кэш, а это, в свою очередь, влияет на общую производительность алгоритма.</p>","path":["Глава 4. Массивы и списки","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   Устройства хранения данных в компьютере","text":"<p>В компьютере есть три типа устройств хранения данных: жесткий диск (hard disk) , оперативная память (random-access memory, RAM) и кэш-память (cache memory) . В таблице 4-2 показаны их различные роли и характеристики в компьютерной системе.</p> <p> Таблица 4-2   Устройства хранения данных в компьютере </p> Жесткий диск Оперативная память Кэш Назначение Долговременное хранение данных, включая ОС, программы, файлы и т.д. Временное хранение выполняемых программ и обрабатываемых данных Хранение часто используемых данных и инструкций, уменьшающее число обращений CPU к памяти Энергозависимость Данные не теряются после отключения питания Данные теряются после отключения питания Данные теряются после отключения питания Емкость Большая, уровень TB Меньшая, уровень GB Очень малая, уровень MB Скорость Низкая, от сотен до тысяч MB/s Высокая, десятки GB/s Очень высокая, десятки и сотни GB/s Цена Низкая, единицы валюты за GB Высокая, десятки и сотни валютных единиц за GB Очень высокая, входит в стоимость CPU <p>Компьютерную систему хранения можно представить в виде пирамиды, показанной на рисунке 4-9. Чем ближе устройство хранения к вершине пирамиды, тем оно быстрее, тем меньше его емкость и тем выше его стоимость. Такая многоуровневая конструкция возникла не случайно, а стала результатом тщательных инженерных компромиссов.</p> <ul> <li>Жесткий диск трудно заменить оперативной памятью. Во-первых, данные в оперативной памяти исчезают после отключения питания, поэтому она не подходит для долговременного хранения. Во-вторых, память стоит в разы дороже жесткого диска, что мешает ее широкому применению.</li> <li>Кэш не может одновременно быть и очень большим, и очень быстрым. По мере роста емкости кэшей L1, L2 и L3 их физический размер увеличивается, расстояние до ядра CPU становится больше, время передачи данных растет, а задержка доступа к элементам увеличивается. При текущем уровне технологий многоуровневая структура кэша является лучшим балансом между емкостью, скоростью и стоимостью.</li> </ul> <p></p> <p> Рисунок 4-9   Система хранения данных компьютера </p> <p>Tip</p> <p>Иерархия памяти компьютера отражает тонкий баланс между скоростью, емкостью и стоимостью. Подобные компромиссы встречаются почти во всех областях инженерии: приходится искать оптимальный баланс между преимуществами и ограничениями.</p> <p>В итоге жесткий диск используется для долговременного хранения больших объемов данных, оперативная память - для временного хранения данных, с которыми программа работает прямо сейчас, а кэш - для хранения часто используемых данных и инструкций, чтобы ускорять выполнение программ. Все три уровня работают совместно и обеспечивают эффективную работу компьютерной системы.</p> <p>Как показано на рисунке 4-10, во время выполнения программы данные читаются с жесткого диска в оперативную память, а затем используются CPU в вычислениях. Кэш можно рассматривать как часть CPU: он подгружает данные из оперативной памяти, обеспечивая CPU высокоскоростной доступ и тем самым значительно ускоряя выполнение программы и уменьшая зависимость от более медленной RAM.</p> <p></p> <p> Рисунок 4-10   Поток данных между жестким диском, RAM и кэшем </p>","path":["Глава 4. Массивы и списки","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   Эффективность использования памяти структурами данных","text":"<p>С точки зрения использования пространства памяти массивы и связные списки имеют свои преимущества и ограничения.</p> <p>С одной стороны, память ограничена, и один и тот же участок памяти не может совместно использоваться несколькими программами, поэтому нам хочется, чтобы структуры данных использовали пространство как можно эффективнее. Элементы массива расположены плотно и не требуют дополнительного места для хранения ссылок (указателей) между узлами списка, поэтому массивы эффективнее по памяти. Однако массиву нужно сразу выделить достаточно большой непрерывный участок памяти, что может приводить к потерям пространства, а его расширение требует дополнительных затрат времени и памяти. Напротив, связные списки выделяют и освобождают память на уровне узлов, что дает большую гибкость.</p> <p>С другой стороны, во время выполнения программы при многократном выделении и освобождении памяти фрагментация свободной памяти становится все более серьезной, что снижает эффективность ее использования. Массивы из-за непрерывного хранения относительно менее подвержены фрагментации. Напротив, элементы связного списка распределены по памяти, и частые операции вставки и удаления легче приводят к фрагментации.</p>","path":["Глава 4. Массивы и списки","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   Эффективность использования кэша структурами данных","text":"<p>Хотя по объему кэш намного меньше оперативной памяти, он значительно быстрее и играет критически важную роль в скорости выполнения программ. Поскольку объем кэша ограничен и в нем можно хранить только небольшую долю часто используемых данных, когда CPU пытается обратиться к данным, которых в кэше нет, происходит промах кэша (cache miss) , и CPU вынужден загружать нужные данные из более медленной памяти.</p> <p>Очевидно, что чем меньше промахов кэша, тем выше эффективность чтения и записи данных CPU, а значит, тем лучше производительность программы. Долю обращений, при которых CPU успешно получает данные из кэша, называют коэффициентом попадания в кэш (cache hit rate) ; этот показатель обычно используют для оценки эффективности кэша.</p> <p>Чтобы добиться как можно большей эффективности, кэш использует следующие механизмы загрузки данных.</p> <ul> <li>Строки кэша: кэш хранит и загружает данные не по одному байту, а строками кэша. По сравнению с передачей по байтам это гораздо эффективнее.</li> <li>Механизм предвыборки: процессор старается предсказать шаблон доступа к данным (например последовательный доступ, доступ с фиксированным шагом и т.д.) и на основе этого шаблона заранее загружает данные в кэш, повышая вероятность попадания.</li> <li>Пространственная локальность: если к некоторым данным уже обратились, то велика вероятность, что в ближайшее время понадобятся и соседние данные. Поэтому, загружая некоторые данные, кэш часто подгружает и окружающие их данные.</li> <li>Временная локальность: если к данным уже обратились, то высока вероятность, что к ним снова обратятся в ближайшем будущем. Кэш использует это свойство, сохраняя недавно использованные данные.</li> </ul> <p>На практике массивы и связные списки по-разному используют кэш, и это проявляется в нескольких аспектах.</p> <ul> <li>Занимаемое пространство: элементы связного списка занимают больше места, чем элементы массива, поэтому в кэше помещается меньше полезных данных.</li> <li>Строки кэша: данные списка разбросаны по памяти, а кэш загружает данные строками, поэтому доля бесполезно загружаемых данных оказывается выше.</li> <li>Механизм предвыборки: шаблон доступа к данным у массивов более предсказуем, чем у списков, то есть системе легче угадать, какие данные понадобятся следующими.</li> <li>Пространственная локальность: массив хранится в компактной области памяти, поэтому данные рядом с уже загруженными с большей вероятностью скоро будут использованы.</li> </ul> <p>В целом массивы имеют более высокий коэффициент попадания в кэш, поэтому по эффективности операций они обычно превосходят связные списки. Именно поэтому при решении алгоритмических задач структуры данных на основе массивов часто оказываются предпочтительнее.</p> <p>Важно понимать, что высокая эффективность кэша не означает, что массивы во всех случаях лучше связных списков. В реальных приложениях выбор структуры данных должен определяться конкретными требованиями. Например, и массивы, и списки могут использоваться для реализации \"стека\" (подробнее об этом будет рассказано в следующей главе), но подходят они для разных сценариев.</p> <ul> <li>При решении алгоритмических задач мы обычно предпочитаем стек на основе массива, потому что он дает более высокую эффективность операций и поддерживает произвольный доступ, а цена за это - необходимость заранее выделить некоторый объем памяти под массив.</li> <li>Если объем данных очень велик, структура сильно динамична, а ожидаемый размер стека трудно оценить заранее, то более уместен стек на основе связного списка. Список позволяет распределить большой объем данных по разным участкам памяти и избегает накладных расходов, связанных с расширением массива.</li> </ul>","path":["Глава 4. Массивы и списки","4.4 &nbsp; Оперативная память и кэш *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   Резюме","text":"","path":["Глава 4. Массивы и списки","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Массивы и связные списки - это две базовые структуры данных, представляющие два способа хранения данных в памяти компьютера: хранение в непрерывном пространстве и хранение в разрозненном пространстве. Их свойства во многом взаимно дополняют друг друга.</li> <li>Массив поддерживает произвольный доступ и занимает меньше памяти; однако вставка и удаление элементов в нем неэффективны, а длина после инициализации фиксирована.</li> <li>Связный список позволяет эффективно вставлять и удалять узлы путем изменения ссылок (указателей), а также гибко менять длину; однако доступ к узлам менее эффективен, а памяти он занимает больше. Распространенные типы списков включают односвязные, циклические и двусвязные списки.</li> <li>Список - это упорядоченная коллекция элементов, поддерживающая добавление, удаление, поиск и изменение, и обычно реализуемая на основе динамического массива. Он сохраняет преимущества массива и при этом может гибко менять длину.</li> <li>Появление списка значительно повысило практическую ценность массива, хотя это и может приводить к потере части памяти.</li> <li>Во время работы программы данные в основном хранятся в оперативной памяти. Массив обеспечивает более высокую эффективность использования пространства памяти, а связный список дает большую гибкость в использовании памяти.</li> <li>Кэш, используя строки кэша, механизм предвыборки, а также пространственную и временную локальность, предоставляет CPU быстрый доступ к данным и заметно повышает эффективность выполнения программ.</li> <li>Поскольку массивы обычно имеют более высокий коэффициент попадания в кэш, они в большинстве случаев работают эффективнее списков. При выборе структуры данных нужно исходить из конкретных требований и сценариев.</li> </ul>","path":["Глава 4. Массивы и списки","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Влияет ли хранение массива в стеке или в куче на временную и пространственную эффективность?</p> <p>Массивы, расположенные и в стеке, и в куче, все равно хранятся в непрерывной области памяти, поэтому эффективность операций с данными у них в целом одинакова. Однако у стека и кучи есть собственные особенности, из-за которых возникают следующие различия.</p> <ol> <li>Эффективность выделения и освобождения: стек представляет собой относительно небольшой участок памяти, а выделение в нем обычно выполняется автоматически компилятором; куча же обычно больше, может выделяться динамически из кода и легче фрагментируется. Поэтому выделение и освобождение памяти в куче обычно медленнее, чем в стеке.</li> <li>Ограничение размера: объем стека относительно невелик, а размер кучи обычно ограничивается доступной памятью. Поэтому куча лучше подходит для хранения больших массивов.</li> <li>Гибкость: размер массива в стеке должен быть известен во время компиляции, а размер массива в куче может определяться динамически во время выполнения.</li> </ol> <p>Q: Почему для массива требуется, чтобы все элементы были одного типа, а для связного списка это не подчеркивается?</p> <p>Связный список состоит из узлов, а узлы соединяются между собой через ссылки (указатели), поэтому каждый узел в принципе может хранить данные разного типа, например <code>int</code> , <code>double</code> , <code>string</code> , <code>object</code> и т.д.</p> <p>Напротив, элементы массива должны быть одного типа, иначе нельзя будет вычислять адрес элемента через смещение. Например, если массив одновременно содержит <code>int</code> и <code>long</code> , один элемент занимает 4 байта, а другой - 8 байт ; в этом случае формула ниже уже не позволит вычислить смещение, потому что в массиве будут присутствовать элементы разной длины.</p> <pre><code># Адрес элемента в памяти = адрес массива в памяти (адрес первого элемента) + длина элемента * индекс элемента\n</code></pre> <p>Q: После удаления узла <code>P</code> нужно ли присваивать <code>P.next = None</code> ?</p> <p>Можно и не изменять <code>P.next</code> . С точки зрения данного списка, при обходе от головы к хвосту узел <code>P</code> уже больше не встретится. Это означает, что узел <code>P</code> уже удален из списка, и то, куда он указывает после этого, на сам список больше не влияет.</p> <p>С точки зрения задач по структурам данных и алгоритмам, отсутствие такого разрыва обычно не критично, если логика программы остается корректной. Но с точки зрения стандартной библиотеки разорвать связь безопаснее и логичнее. Если этого не сделать и удаленный узел не будет нормально собран, он может мешать освобождению памяти последующих узлов.</p> <p>Q: Временная сложность вставки и удаления в связном списке равна \\(O(1)\\) . Но до вставки или удаления обычно еще нужно потратить \\(O(n)\\) на поиск элемента. Почему тогда общая сложность не \\(O(n)\\) ?</p> <p>Если сначала искать элемент, а потом удалять его, то временная сложность действительно будет \\(O(n)\\) . Однако преимущество связного списка с \\(O(1)\\) вставкой и удалением проявляется в других сценариях. Например, двустороннюю очередь удобно реализовывать именно на связном списке: мы поддерживаем указатели на голову и хвост, и тогда каждая операция вставки или удаления остается \\(O(1)\\) .</p> <p>Q: На рисунке \"Определение связного списка и способ хранения\" светло-голубой блок с указателем узла - это отдельный адрес памяти? Или он делит память пополам со значением узла?</p> <p>Этот рисунок дает только качественное представление; количественно все зависит от конкретных условий.</p> <ul> <li>Значения узлов разных типов занимают разный объем памяти, например <code>int</code> , <code>long</code> , <code>double</code> и объекты-экземпляры.</li> <li>Размер памяти, занимаемой переменной-указателем, зависит от операционной системы и среды компиляции и обычно составляет 8 байт или 4 байта.</li> </ul> <p>Q: Всегда ли добавление элемента в конец списка имеет сложность \\(O(1)\\) ?</p> <p>Если при добавлении элемента длина списка превышается, то сначала приходится расширять список, а уже затем добавлять новый элемент. Система выделяет новый участок памяти и переносит туда все элементы исходного списка, и в этот момент временная сложность становится \\(O(n)\\) .</p> <p>Q: В утверждении \"появление списка сильно повысило практическую полезность массива, но может приводить к потере части памяти\" под потерями памяти имеется в виду дополнительная память под такие переменные, как емкость, длина и коэффициент расширения?</p> <p>Потери памяти здесь в основном имеют два значения: во-первых, список обычно имеет некоторую начальную емкость, которая может быть нам не нужна целиком; во-вторых, чтобы избежать слишком частых расширений, емкость при расширении обычно умножается на некоторый коэффициент, например \\(\\times 1.5\\) . Из-за этого появляется много пустых слотов, которые обычно нельзя полностью заполнить.</p> <p>Q: В Python после инициализации <code>n = [1, 2, 3]</code> адреса этих трех элементов выглядят непрерывными, но после <code>m = [2, 1, 3]</code> можно заметить, что <code>id</code> элементов не идут подряд, а совпадают с одинаковыми числами из <code>n</code> . Если адреса элементов не непрерывны, остается ли <code>m</code> массивом?</p> <p>Предположим, что элементами списка являются узлы <code>n = [n1, n2, n3, n4, n5]</code> . Обычно эти 5 объектов-узлов тоже будут храниться в разных местах памяти. Однако, имея индекс списка, мы по-прежнему можем за \\(O(1)\\) получить адрес памяти соответствующего узла и обратиться к нему. Это связано с тем, что в массиве хранятся ссылки на узлы, а не сами узлы.</p> <p>В отличие от многих других языков, в Python даже числа обернуты в объекты, и в списке хранятся не сами числа, а ссылки на них. Поэтому мы и наблюдаем, что одинаковые числа в двух массивах имеют один и тот же <code>id</code> , а адреса этих чисел не обязаны быть непрерывными.</p> <p>Q: В C++ STL уже есть двусвязный список <code>std::list</code> , но в некоторых учебниках по алгоритмам им пользуются не так часто. Это связано с какими-то ограничениями?</p> <p>С одной стороны, при разработке алгоритмов мы обычно предпочитаем структуры на основе массива, а к связным спискам прибегаем только при необходимости, по двум главным причинам.</p> <ul> <li>Накладные расходы по памяти: поскольку каждому элементу нужны два дополнительных указателя (на предыдущий и следующий элементы), <code>std::list</code> обычно занимает больше памяти, чем <code>std::vector</code> .</li> <li>Низкая дружелюбность к кэшу: поскольку данные не лежат непрерывно, <code>std::list</code> хуже использует кэш. В большинстве случаев <code>std::vector</code> показывает лучшую производительность.</li> </ul> <p>С другой стороны, случаи, когда связный список действительно необходим, в основном возникают в деревьях и графах. Для стеков и очередей чаще используют предоставляемые языком <code>stack</code> и <code>queue</code> , а не связный список напрямую.</p> <p>Q: Операция <code>res = [[0]] * n</code> создает двумерный список. Каждый <code>[0]</code> в нем независим?</p> <p>Нет, они не независимы. В таком двумерном списке все <code>[0]</code> на самом деле являются ссылками на один и тот же объект. Если изменить один из них, окажется, что меняются и все остальные соответствующие элементы.</p> <p>Если нужно, чтобы каждый <code>[0]</code> был независимым, можно использовать <code>res = [[0] for _ in range(n)]</code> . В этом варианте создаются \\(n\\) независимых объектов-списков <code>[0]</code> .</p> <p>Q: Операция <code>res = [0] * n</code> создает список. Каждый целочисленный <code>0</code> в нем независим?</p> <p>В этом списке все целые числа <code>0</code> являются ссылками на один и тот же объект. Это связано с тем, что Python использует механизм кэш-пула для маленьких целых чисел (обычно от -5 до 256), чтобы максимально переиспользовать объекты и повысить производительность.</p> <p>Хотя все элементы указывают на один и тот же объект, мы все равно можем независимо изменять элементы списка, потому что целые числа в Python - это \"неизменяемые объекты\". Когда мы изменяем некоторый элемент, на самом деле происходит переключение ссылки на другой объект, а не изменение исходного объекта.</p> <p>Однако если элементами списка являются \"изменяемые объекты\" (например списки, словари или экземпляры классов), то изменение одного элемента прямо меняет сам объект, и все элементы, ссылающиеся на него, увидят одно и то же изменение.</p>","path":["Глава 4. Массивы и списки","4.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"Глава 13.   Поиск с возвратом","text":"<p>Abstract</p> <p>Мы словно исследователи в лабиринте: на пути вперед могут встречаться тупики и трудности.</p> <p>Сила возврата позволяет нам начать заново, пробовать снова и снова и в конце концов найти выход к свету.</p>","path":["Глава 13. Поиск с возвратом","Глава 13. &nbsp; Поиск с возвратом"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>13.1   Алгоритм поиска с возвратом</li> <li>13.2   Задача о перестановках</li> <li>13.3   Задача о сумме подмножеств</li> <li>13.4   Задача о n ферзях</li> <li>13.5   Резюме</li> </ul>","path":["Глава 13. Поиск с возвратом","Глава 13. &nbsp; Поиск с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   Алгоритм поиска с возвратом","text":"<p>Алгоритм поиска с возвратом (backtracking algorithm) - это метод решения задач путем полного перебора. Его основная идея состоит в том, чтобы, начиная с некоторого исходного состояния, грубо перебрать все возможные решения, записывать корректные решения и продолжать поиск до тех пор, пока решение не будет найдено или пока не будут исчерпаны все возможные варианты.</p> <p>Обычно алгоритмы поиска с возвратом используют обход в глубину для обхода пространства решений. В главе \"Бинарные деревья\" мы уже упоминали, что прямой, симметричный и обратный обходы относятся к обходу в глубину. Теперь мы на основе прямого обхода построим задачу поиска с возвратом и постепенно разберем принцип работы этого алгоритма.</p> <p>Пример 1</p> <p>Дано двоичное дерево. Найдите и запишите все узлы со значением \\(7\\) ; верните список этих узлов.</p> <p>Для этой задачи мы выполняем прямой обход дерева и проверяем, равно ли значение текущего узла \\(7\\) ; если да, то добавляем значение этого узла в список результатов <code>res</code> . Соответствующий процесс показан на рисунке 13-1 и в коде:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 1\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # Записать решение\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Записать решение\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* Предварительный обход: пример 1 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* Предварительный обход: пример 1 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // Записать решение\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* Предварительный обход: пример 1 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // Записать решение\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* Предварительный обход: пример 1 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Записать решение\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* Предварительный обход: пример 1 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // Записать решение\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // Записать решение\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* Предварительный обход: пример 1 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* Предварительный обход: пример 1 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* Предварительный обход: пример 1 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### Предварительный обход: пример 1 ###\ndef pre_order(root)\n  return unless root\n\n  # Записать решение\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 13-1   Поиск узлов при прямом обходе </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   Попытка и откат","text":"<p>Алгоритм называется поиском с возвратом, потому что при поиске в пространстве решений он использует стратегию \"попытка\" и \"откат\". Когда в процессе поиска алгоритм приходит в состояние, из которого нельзя двигаться дальше или нельзя получить удовлетворяющее условиям решение, он отменяет предыдущий выбор, возвращается к более раннему состоянию и пробует другие возможные варианты.</p> <p>Для примера 1 посещение каждого узла представляет собой \"попытку\", а прохождение листового узла или возврат к родителю через <code>return</code> означает \"откат\".</p> <p>Важно понимать, что откат не сводится только к возврату из функции. Чтобы показать это, слегка расширим пример 1.</p> <p>Пример 2</p> <p>Найдите в двоичном дереве все узлы со значением \\(7\\) и верните пути от корня до этих узлов.</p> <p>Взяв за основу код примера 1, добавим список <code>path</code> для записи пути посещенных узлов. Когда встречается узел со значением \\(7\\) , мы копируем <code>path</code> и добавляем его в список результатов <code>res</code> . После завершения обхода именно <code>res</code> будет содержать все решения. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 2\"\"\"\n    if root is None:\n        return\n    # Попытка\n    path.append(root)\n    if root.val == 7:\n        # Записать решение\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Откат\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // Попытка\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // Попытка\n    path.add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Откат\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* Предварительный обход: пример 2 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // Попытка\n    path.Add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Откат\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* Предварительный обход: пример 2 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // Попытка\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Записать решение\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // Откат\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* Предварительный обход: пример 2 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Попытка\n    path.append(root)\n    if root.val == 7 {\n        // Записать решение\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Откат\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* Предварительный обход: пример 2 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* Предварительный обход: пример 2 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // Попытка\n  path.add(root);\n  if (root.val == 7) {\n    // Записать решение\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Откат\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* Предварительный обход: пример 2 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // Попытка\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Откат\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* Предварительный обход: пример 2 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // Попытка\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Записать решение\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* Предварительный обход: пример 2 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // Попытка\n    path!!.add(root)\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Откат\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### Предварительный обход: пример 2 ###\ndef pre_order(root)\n  return unless root\n\n  # Попытка\n  $path &lt;&lt; root\n\n  # Записать решение\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Откат\n  $path.pop\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В каждой \"попытке\" мы добавляем текущий узел в <code>path</code> , чтобы записать путь; а перед \"откатом\" нам нужно удалить этот узел из <code>path</code> , чтобы восстановить состояние, существовавшее до текущей попытки.</p> <p>Если посмотреть на процесс, изображенный на рисунке 13-2, то попытку и откат можно понимать как \"движение вперед\" и \"отмену\": это два взаимно противоположных действия.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 13-2   Попытка и откат </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   Обрезка","text":"<p>Сложные задачи поиска с возвратом обычно содержат одно или несколько ограничений, которые часто можно использовать для \"обрезки\".</p> <p>Пример 3</p> <p>Найдите в двоичном дереве все узлы со значением \\(7\\) , верните пути от корня до этих узлов, причем путь не должен содержать узлы со значением \\(3\\).</p> <p>Чтобы выполнить это ограничение, нам нужно добавить операцию обрезки: во время поиска, если встречается узел со значением \\(3\\) , мы сразу возвращаемся и не продолжаем дальнейший поиск. Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"Предварительный обход: пример 3\"\"\"\n    # Отсечение\n    if root is None or root.val == 3:\n        return\n    # Попытка\n    path.append(root)\n    if root.val == 7:\n        # Записать решение\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # Откат\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode *root) {\n    // Отсечение\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // Попытка\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // Записать решение\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode root) {\n    // Отсечение\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Попытка\n    path.add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // Откат\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* Предварительный обход: пример 3 */\nvoid PreOrder(TreeNode? root) {\n    // Отсечение\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // Попытка\n    path.Add(root);\n    if (root.val == 7) {\n        // Записать решение\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // Откат\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* Предварительный обход: пример 3 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // Отсечение\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // Попытка\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // Записать решение\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // Откат\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* Предварительный обход: пример 3 */\nfunc preOrder(root: TreeNode?) {\n    // Отсечение\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // Попытка\n    path.append(root)\n    if root.val == 7 {\n        // Записать решение\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // Откат\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* Предварительный обход: пример 3 */\nfunction preOrder(root, path, res) {\n    // Отсечение\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* Предварительный обход: пример 3 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Отсечение\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // Попытка\n    path.push(root);\n    if (root.val === 7) {\n        // Записать решение\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // Откат\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // Попытка\n  path.add(root);\n  if (root.val == 7) {\n    // Записать решение\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // Откат\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* Предварительный обход: пример 3 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // Отсечение\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // Попытка\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // Записать решение\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // Откат\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* Предварительный обход: пример 3 */\nvoid preOrder(TreeNode *root) {\n    // Отсечение\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // Попытка\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // Записать решение\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // Откат\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* Предварительный обход: пример 3 */\nfun preOrder(root: TreeNode?) {\n    // Отсечение\n    if (root == null || root._val == 3) {\n        return\n    }\n    // Попытка\n    path!!.add(root)\n    if (root._val == 7) {\n        // Записать решение\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // Откат\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### Предварительный обход: пример 3 ###\ndef pre_order(root)\n  # Отсечение\n  return if !root || root.val == 3\n\n  # Попытка\n  $path.append(root)\n\n  # Записать решение\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # Откат\n  $path.pop\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Термин \"обрезка\" очень нагляден. Как показано на рисунке 13-3, во время поиска мы отсекаем ветви, не удовлетворяющие ограничениям , тем самым избегая множества бессмысленных попыток и повышая эффективность поиска.</p> <p></p> <p> Рисунок 13-3   Обрезка по условиям задачи </p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   Каркас кода","text":"<p>Теперь попробуем извлечь общий каркас из действий \"попытка\", \"откат\" и \"обрезка\", чтобы сделать код более универсальным.</p> <p>В следующем каркасе кода <code>state</code> обозначает текущее состояние задачи, а <code>choices</code> - список выборов, доступных в текущем состоянии:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"Каркас алгоритма поиска с возвратом\"\"\"\n    # Проверка, является ли текущее состояние решением\n    if is_solution(state):\n        # Запись решения\n        record_solution(state, res)\n        # Дальше не продолжаем поиск\n        return\n    # Перебор всех возможных выборов\n    for choice in choices:\n        # Обрезка: проверка допустимости выбора\n        if is_valid(state, choice):\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (Choice choice : choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (Choice choice : choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // Проверка, является ли текущее состояние решением\n    if (IsSolution(state)) {\n        // Запись решения\n        RecordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    foreach (Choice choice in choices) {\n        // Обрезка: проверка допустимости выбора\n        if (IsValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // Проверка, является ли текущее состояние решением\n    if isSolution(state) {\n        // Запись решения\n        recordSolution(state, res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for _, choice := range choices {\n        // Обрезка: проверка допустимости выбора\n        if isValid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // Проверка, является ли текущее состояние решением\n    if isSolution(state: state) {\n        // Запись решения\n        recordSolution(state: state, res: &amp;res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for choice in choices {\n        // Обрезка: проверка допустимости выбора\n        if isValid(state: state, choice: choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunction backtrack(state, choices, res) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (let choice of choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (let choice of choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // Проверка, является ли текущее состояние решением\n  if (isSolution(state)) {\n    // Запись решения\n    recordSolution(state, res);\n    // Дальше не продолжаем поиск\n    return;\n  }\n  // Перебор всех возможных выборов\n  for (Choice choice in choices) {\n    // Обрезка: проверка допустимости выбора\n    if (isValid(state, choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // Проверка, является ли текущее состояние решением\n    if is_solution(state) {\n        // Запись решения\n        record_solution(state, res);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for choice in choices {\n        // Обрезка: проверка допустимости выбора\n        if is_valid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res, numRes);\n        // Дальше не продолжаем поиск\n        return;\n    }\n    // Перебор всех возможных выборов\n    for (int i = 0; i &lt; numChoices; i++) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, &amp;choices[i])) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* Каркас алгоритма поиска с возвратом */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // Проверка, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Запись решения\n        recordSolution(state, res)\n        // Дальше не продолжаем поиск\n        return\n    }\n    // Перебор всех возможных выборов\n    for (choice in choices) {\n        // Обрезка: проверка допустимости выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### Каркас алгоритма поиска с возвратом ###\ndef backtrack(state, choices, res)\n    # Проверка, является ли текущее состояние решением\n    if is_solution?(state)\n        # Запись решения\n        record_solution(state, res)\n        return\n    end\n\n    # Перебор всех возможных выборов\n    for choice in choices\n        # Обрезка: проверка допустимости выбора\n        if is_valid?(state, choice)\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>Теперь, опираясь на этот каркас, решим пример 3. Состояние <code>state</code> здесь - это путь обхода узлов, выбор <code>choices</code> - левый и правый потомки текущего узла, а результат <code>res</code> - список путей:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"Проверить, является ли текущее состояние решением\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"Записать решение\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"Проверить, допустим ли этот выбор в текущем состоянии\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Обновить состояние\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"Восстановить состояние\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"Алгоритм бэктрекинга: пример 3\"\"\"\n    # Проверить, является ли текущее состояние решением\n    if is_solution(state):\n        # Записать решение\n        record_solution(state, res)\n    # Перебор всех вариантов выбора\n    for choice in choices:\n        # Отсечение: проверить допустимость выбора\n        if is_valid(state, choice):\n            # Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice)\n            # Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (TreeNode *choice : choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* Проверить, является ли текущее состояние решением */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (TreeNode choice : choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* Проверить, является ли текущее состояние решением */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* Записать решение */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* Восстановить состояние */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // Проверить, является ли текущее состояние решением\n    if (IsSolution(state)) {\n        // Записать решение\n        RecordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    foreach (TreeNode choice in choices) {\n        // Отсечение: проверить допустимость выбора\n        if (IsValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            MakeChoice(state, choice);\n            // Перейти к следующему выбору\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* Проверить, является ли текущее состояние решением */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* Записать решение */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* Обновить состояние */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* Восстановить состояние */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // Проверить, является ли текущее состояние решением\n    if isSolution(state) {\n        // Записать решение\n        recordSolution(state, res)\n    }\n    // Перебор всех вариантов выбора\n    for _, choice := range *choices {\n        // Отсечение: проверить допустимость выбора\n        if isValid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            // Перейти к следующему выбору\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* Проверить, является ли текущее состояние решением */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* Записать решение */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* Обновить состояние */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* Восстановить состояние */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // Проверить, является ли текущее состояние решением\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // Перебор всех вариантов выбора\n    for choice in choices {\n        // Отсечение: проверить допустимость выбора\n        if isValid(state: state, choice: choice) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state: &amp;state, choice: choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* Проверить, является ли текущее состояние решением */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Записать решение */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Обновить состояние */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunction backtrack(state, choices, res) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* Проверить, является ли текущее состояние решением */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* Записать решение */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* Обновить состояние */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice);\n            // Перейти к следующему выбору\n            backtrack(state, [choice.left, choice.right], res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* Восстановить состояние */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // Проверить, является ли текущее состояние решением\n  if (isSolution(state)) {\n    // Записать решение\n    recordSolution(state, res);\n  }\n  // Перебор всех вариантов выбора\n  for (TreeNode? choice in choices) {\n    // Отсечение: проверить допустимость выбора\n    if (isValid(state, choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      makeChoice(state, choice);\n      // Перейти к следующему выбору\n      backtrack(state, [choice!.left, choice.right], res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* Проверить, является ли текущее состояние решением */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* Записать решение */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* Обновить состояние */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* Восстановить состояние */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // Проверить, является ли текущее состояние решением\n    if is_solution(state) {\n        // Записать решение\n        record_solution(state, res);\n    }\n    // Перебор всех вариантов выбора\n    for &amp;choice in choices.iter() {\n        // Отсечение: проверить допустимость выбора\n        if is_valid(state, choice) {\n            // Попытка: сделать выбор и обновить состояние\n            make_choice(state, choice.unwrap().clone());\n            // Перейти к следующему выбору\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* Проверить, является ли текущее состояние решением */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* Записать решение */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* Обновить состояние */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* Восстановить состояние */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nvoid backtrack(TreeNode *choices[2]) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution()) {\n        // Записать решение\n        recordSolution();\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // Отсечение: проверить допустимость выбора\n        if (isValid(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(choice);\n            // Перейти к следующему выбору\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* Проверить, является ли текущее состояние решением */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* Записать решение */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* Проверить, допустим ли этот выбор в текущем состоянии */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* Обновить состояние */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* Восстановить состояние */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* Алгоритм бэктрекинга: пример 3 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // Проверить, является ли текущее состояние решением\n    if (isSolution(state)) {\n        // Записать решение\n        recordSolution(state, res)\n    }\n    // Перебор всех вариантов выбора\n    for (choice in choices) {\n        // Отсечение: проверить допустимость выбора\n        if (isValid(state, choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            makeChoice(state, choice)\n            // Перейти к следующему выбору\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### Проверка, является ли текущее состояние решением ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### Записать решение ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### Проверка допустимости этого выбора в текущем состоянии ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### Обновить состояние ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### Восстановить состояние ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### Алгоритм бэктрекинга: пример 3 ###\ndef backtrack(state, choices, res)\n  # Проверить, является ли текущее состояние решением\n  record_solution(state, res) if is_solution?(state)\n\n  # Перебор всех вариантов выбора\n  for choice in choices\n    # Отсечение: проверить допустимость выбора\n    if is_valid?(state, choice)\n      # Попытка: сделать выбор и обновить состояние\n      make_choice(state, choice)\n      # Перейти к следующему выбору\n      backtrack(state, [choice.left, choice.right], res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Согласно условию задачи, после нахождения узла со значением \\(7\\) мы должны продолжать поиск, поэтому оператор <code>return</code> после записи решения нужно удалить. На рисунке 13-4 сравниваются процессы поиска в случаях, когда <code>return</code> сохраняется и когда он удаляется.</p> <p></p> <p> Рисунок 13-4   Сравнение поиска при сохранении и удалении return </p> <p>По сравнению с реализацией на основе прямого обхода, версия на основе общего каркаса поиска с возвратом выглядит более громоздкой, но при этом обладает лучшей универсальностью. На практике многие задачи поиска с возвратом можно решать в рамках этого каркаса. Для этого нужно лишь определить <code>state</code> и <code>choices</code> под конкретную задачу и реализовать соответствующие методы каркаса.</p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   Часто используемые термины","text":"<p>Чтобы яснее анализировать алгоритмические задачи, подытожим значения часто используемых терминов поиска с возвратом и сопоставим их с примером 3, как показано в таблице 13-1.</p> <p> Таблица 13-1   Часто используемые термины алгоритма поиска с возвратом </p> Термин Определение Пример 3 Решение (solution) Решение - это ответ, удовлетворяющий условиям задачи; решений может быть одно или несколько Все пути от корня до узла \\(7\\) , удовлетворяющие ограничениям Ограничение (constraint) Ограничение определяет допустимость решения и обычно используется для обрезки Путь не содержит узлы со значением \\(3\\) Состояние (state) Состояние описывает ситуацию задачи в некоторый момент времени, включая уже сделанные выборы Текущий путь посещенных узлов, то есть список узлов <code>path</code> Попытка (attempt) Попытка - это исследование пространства решений на основе доступных выборов, включая выбор, обновление состояния и проверку, является ли состояние решением Рекурсивный переход к левому или правому потомку, добавление узла в <code>path</code> и проверка, равно ли значение узла \\(7\\) Откат (backtracking) Откат означает отмену предыдущих выборов и возврат к более раннему состоянию при встрече состояния, не удовлетворяющего ограничениям Завершение поиска при проходе через лист, окончании посещения узла или встрече узла со значением \\(3\\) , то есть возврат из функции Обрезка (pruning) Обрезка - это способ избегать бессмысленных путей поиска на основе свойств задачи и ее ограничений, повышающий эффективность При встрече узла со значением \\(3\\) поиск по этой ветви прекращается <p>Tip</p> <p>Такие понятия, как задача, решение и состояние, являются общими и встречаются не только в поиске с возвратом, но и в \"разделяй и властвуй\", динамическом программировании, жадных алгоритмах и других темах.</p>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   Преимущества и ограничения","text":"<p>Алгоритм поиска с возвратом по своей сути представляет собой алгоритм обхода в глубину, который перебирает все возможные решения, пока не найдет удовлетворяющее условиям. Преимущество этого подхода в том, что он позволяет находить все возможные решения и при разумной обрезке может работать весьма эффективно.</p> <p>Однако при работе с большими или сложными задачами эффективность поиска с возвратом может оказаться неприемлемой.</p> <ul> <li>Время: поиск с возвратом обычно требует обхода всех возможных состояний пространства состояний, и его временная сложность может достигать экспоненциального или факториального порядка.</li> <li>Память: при рекурсивных вызовах нужно хранить текущее состояние (например, путь, вспомогательные переменные для обрезки и т.д.), поэтому при большой глубине рекурсии потребность в памяти может стать значительной.</li> </ul> <p>Тем не менее поиск с возвратом по-прежнему остается лучшим решением для некоторых поисковых задач и задач удовлетворения ограничений. В таких задачах заранее невозможно предсказать, какие выборы приведут к эффективному решению, поэтому приходится перебирать все возможные варианты. В этой ситуации ключевым становится вопрос оптимизации эффективности , и для этого обычно используют две стратегии.</p> <ul> <li>Обрезка: избегать поиска по тем путям, которые заведомо не приведут к решению, тем самым экономя время и память.</li> <li>Эвристический поиск: вводить во время поиска дополнительные стратегии или оценки, чтобы в первую очередь исследовать пути, наиболее вероятно ведущие к эффективному решению.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   Типичные задачи поиска с возвратом","text":"<p>Алгоритм поиска с возвратом можно использовать для решения множества поисковых задач, задач удовлетворения ограничений и задач комбинаторной оптимизации.</p> <p>Поисковые задачи: целью таких задач является поиск решений, удовлетворяющих определенным условиям.</p> <ul> <li>Задача о перестановках: дано множество, требуется найти все возможные перестановки его элементов.</li> <li>Задача о сумме подмножеств: даны множество и целевая сумма; нужно найти все подмножества, сумма элементов которых равна целевой.</li> <li>Задача о Ханойской башне: даны три стержня и набор дисков разного размера; требуется перенести все диски с одного стержня на другой, перемещая за раз только один диск и не помещая больший диск на меньший.</li> </ul> <p>Задачи удовлетворения ограничений: целью таких задач является поиск решений, удовлетворяющих всем ограничениям.</p> <ul> <li>Задача о \\(n\\) ферзях: разместить \\(n\\) ферзей на шахматной доске размера \\(n \\times n\\) так, чтобы они не атаковали друг друга.</li> <li>Судоку: заполнить сетку \\(9 \\times 9\\) числами от \\(1\\) до \\(9\\) так, чтобы в каждой строке, каждом столбце и каждом блоке \\(3 \\times 3\\) числа не повторялись.</li> <li>Задача раскраски графа: дан неориентированный граф; требуется раскрасить его вершины минимальным числом цветов так, чтобы соседние вершины имели разные цвета.</li> </ul> <p>Задачи комбинаторной оптимизации: целью таких задач является поиск оптимального решения в некотором комбинаторном пространстве при заданных ограничениях.</p> <ul> <li>Задача о рюкзаке 0-1: даны набор предметов и рюкзак; у каждого предмета есть ценность и вес, и нужно выбрать предметы так, чтобы при ограниченной вместимости рюкзака суммарная ценность была максимальной.</li> <li>Задача коммивояжера: начиная из некоторой вершины графа, требуется посетить все остальные вершины ровно по одному разу и вернуться в исходную вершину, найдя при этом кратчайший путь.</li> <li>Задача о максимальной клике: дан неориентированный граф; требуется найти в нем максимальный полный подграф, то есть подграф, в котором любая пара вершин соединена ребром.</li> </ul> <p>Стоит отметить: для многих задач комбинаторной оптимизации поиск с возвратом не является оптимальным способом решения.</p> <ul> <li>Задача о рюкзаке 0-1 обычно решается с помощью динамического программирования, что дает более высокую временную эффективность.</li> <li>Задача коммивояжера является известной NP-Hard задачей; для ее решения часто используют генетические алгоритмы, муравьиные алгоритмы и другие методы.</li> <li>Задача о максимальной клике является классической задачей теории графов и может решаться жадными и другими эвристическими алгоритмами.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.1 &nbsp; Алгоритм поиска с возвратом"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   Задача о n ферзях","text":"<p>Question</p> <p>Согласно правилам шахмат ферзь может атаковать фигуры, находящиеся с ним на одной строке, в одном столбце или на одной диагонали. Даны \\(n\\) ферзей и шахматная доска размера \\(n \\times n\\) ; требуется найти такие расстановки, при которых ни одна пара ферзей не может атаковать друг друга.</p> <p>Как показано на рисунке 13-15, при \\(n = 4\\) существует два решения. С точки зрения поиска с возвратом доска размера \\(n \\times n\\) содержит \\(n^2\\) клеток, которые образуют все возможные выборы <code>choices</code> . По мере поочередного размещения ферзей состояние доски непрерывно меняется, и текущее содержимое доски образует состояние <code>state</code> .</p> <p></p> <p> Рисунок 13-15   Решения задачи о 4 ферзях </p> <p>На рисунке 13-16 показаны три ограничения этой задачи: несколько ферзей не могут находиться на одной строке, в одном столбце или на одной диагонали. При этом нужно помнить, что диагонали бывают двух типов: главная <code>\\</code> и побочная <code>/</code> .</p> <p></p> <p> Рисунок 13-16   Ограничения задачи о n ферзях </p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   Построчная стратегия размещения","text":"<p>Число ферзей и число строк доски одинаково и равно \\(n\\) , поэтому легко получить следующий вывод: в каждой строке доски разрешено и нужно разместить ровно одного ферзя.</p> <p>Иначе говоря, можно использовать построчную стратегию: начиная с первой строки, размещать по одному ферзю в каждой строке, пока не будет достигнута последняя.</p> <p>На рисунке 13-17 показан процесс построчного размещения для задачи о 4 ферзях. Из-за ограничений размера изображения на нем раскрыта только одна ветвь поиска для первой строки, а все варианты, не удовлетворяющие ограничениям по столбцам и диагоналям, были отсечены.</p> <p></p> <p> Рисунок 13-17   Построчная стратегия размещения </p> <p>По своей сути построчная стратегия сама по себе выполняет роль обрезки , потому что заранее исключает все ветви поиска, в которых в одной строке оказалось бы несколько ферзей.</p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   Обрезка по столбцам и диагоналям","text":"<p>Чтобы удовлетворить ограничению по столбцам, можно использовать булев массив <code>cols</code> длины \\(n\\) , который записывает, есть ли ферзь в каждом столбце. Перед каждым размещением мы используем <code>cols</code> для отсечения столбцов, уже занятых ферзями, а затем динамически обновляем состояние <code>cols</code> во время отката.</p> <p>Tip</p> <p>Обратите внимание: начало координат матрицы находится в левом верхнем углу, при этом индексы строк растут сверху вниз, а индексы столбцов - слева направо.</p> <p>Как теперь обработать ограничения по диагоналям? Пусть клетка на доске имеет координаты \\((row, col)\\) . Выбрав некоторую главную диагональ в матрице, можно заметить, что разность индексов строки и столбца одинакова для всех клеток этой диагонали, то есть для всех клеток главной диагонали значение \\(row - col\\) постоянно.</p> <p>Это означает, что если для двух клеток выполняется равенство \\(row_1 - col_1 = row_2 - col_2\\) , то они обязательно лежат на одной и той же главной диагонали. Используя это правило, можно с помощью массива <code>diags1</code> , показанного на рисунке 13-18, отмечать наличие ферзя на каждой главной диагонали.</p> <p>Аналогично для всех клеток побочной диагонали значение \\(row + col\\) является постоянным. Поэтому для обработки ограничений по побочным диагоналям можно использовать еще один массив <code>diags2</code> .</p> <p></p> <p> Рисунок 13-18   Обработка ограничений по столбцам и диагоналям </p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>Заметим, что в квадратной матрице размера \\(n\\) диапазон значений \\(row - col\\) равен \\([-n + 1, n - 1]\\) , а диапазон значений \\(row + col\\) равен \\([0, 2n - 2]\\) . Следовательно, число главных и побочных диагоналей равно \\(2n - 1\\) , а значит, длины массивов <code>diags1</code> и <code>diags2</code> тоже равны \\(2n - 1\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"Алгоритм бэктрекинга: n ферзей\"\"\"\n    # Когда все строки уже обработаны, записать решение\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # Обойти все столбцы\n    for col in range(n):\n        # Вычислить главную и побочную диагонали, соответствующие этой клетке\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"Решить задачу о n ферзях\"\"\"\n    # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # Отмечать, есть ли ферзь в столбце\n    diags1 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на главной диагонали\n    diags2 = [False] * (2 * n - 1)  # Отмечать наличие ферзя на побочной диагонали\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // Отмечать, есть ли ферзь в столбце\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // Отмечать, есть ли ферзь в столбце\n    boolean[] diags1 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    boolean[] diags2 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // Отмечать, есть ли ферзь в столбце\n    bool[] diags1 = new bool[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    bool[] diags2 = new bool[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все столбцы\n    for col := 0; col &lt; n; col++ {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // Перейти к размещению следующей строки\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // Откат: восстановить эту клетку как пустую\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunc nQueens(n int) [][][]string {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // Отмечать, есть ли ферзь в столбце\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        res.append(state)\n        return\n    }\n    // Обойти все столбцы\n    for col in 0 ..&lt; n {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // Перейти к размещению следующей строки\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // Отмечать, есть ли ферзь в столбце\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на главной диагонали\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // Отмечать наличие ферзя на побочной диагонали\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // Когда все строки уже обработаны, записать решение\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Обойти все столбцы\n    for (let col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunction nQueens(n) {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце\n    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали\n    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // Когда все строки уже обработаны, записать решение\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // Обойти все столбцы\n    for (let col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfunction nQueens(n: number): string[][][] {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце\n    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали\n    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // Когда все строки уже обработаны, записать решение\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // Обойти все столбцы\n  for (int col = 0; col &lt; n; col++) {\n    // Вычислить главную и побочную диагонали, соответствующие этой клетке\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // Попытка: поставить ферзя в эту клетку\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // Перейти к размещению следующей строки\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // Откат: восстановить эту клетку как пустую\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* Решить задачу о n ферзях */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // Отмечать, есть ли ферзь в столбце\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // Когда все строки уже обработаны, записать решение\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все столбцы\n    for col in 0..n {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // Отмечать, есть ли ферзь в столбце\n    let mut diags1 = vec![false; 2 * n - 1]; // Отмечать наличие ферзя на главной диагонали\n    let mut diags2 = vec![false; 2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // Обойти все столбцы\n    for (int col = 0; col &lt; n; col++) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // Отмечать, есть ли ферзь в столбце\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // Отмечать наличие ферзя на главной диагонали\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // Отмечать наличие ферзя на побочной диагонали\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* Алгоритм бэктрекинга: n ферзей */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // Когда все строки уже обработаны, записать решение\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // Обойти все столбцы\n    for (col in 0..&lt;n) {\n        // Вычислить главную и побочную диагонали, соответствующие этой клетке\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // Попытка: поставить ферзя в эту клетку\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // Перейти к размещению следующей строки\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // Откат: восстановить эту клетку как пустую\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* Решить задачу о n ферзях */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // Отмечать, есть ли ферзь в столбце\n    val diags1 = BooleanArray(2 * n - 1) // Отмечать наличие ферзя на главной диагонали\n    val diags2 = BooleanArray(2 * n - 1) // Отмечать наличие ферзя на побочной диагонали\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### Алгоритм бэктрекинга: n ферзей ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # Когда все строки уже обработаны, записать решение\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # Обойти все столбцы\n  for col in 0...n\n    # Вычислить главную и побочную диагонали, соответствующие этой клетке\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # Попытка: поставить ферзя в эту клетку\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # Перейти к размещению следующей строки\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # Откат: восстановить эту клетку как пустую\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### Решить задачу о n ферзях ###\ndef n_queens(n)\n  # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # Отмечать, есть ли ферзь в столбце\n  diags1 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на главной диагонали\n  diags2 = Array.new(2 * n - 1, false) # Отмечать наличие ферзя на побочной диагонали\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если размещать ферзей построчно \\(n\\) раз, учитывая ограничение по столбцам, то начиная с первой строки и заканчивая последней мы получаем соответственно \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\) вариантов выбора, что дает \\(O(n!)\\) времени. При записи решения нужно скопировать матрицу <code>state</code> и добавить ее в <code>res</code> , а копирование требует \\(O(n^2)\\) времени. Следовательно, общая временная сложность равна \\(O(n! \\cdot n^2)\\) . На практике обрезка по диагональным ограничениям дополнительно сильно уменьшает пространство поиска, поэтому фактическая эффективность часто лучше этой оценки.</p> <p>Массив <code>state</code> использует \\(O(n^2)\\) пространства, а массивы <code>cols</code> , <code>diags1</code> и <code>diags2</code> используют по \\(O(n)\\) пространства. Максимальная глубина рекурсии равна \\(n\\) , что требует \\(O(n)\\) памяти стека. Следовательно, пространственная сложность равна \\(O(n^2)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.4 &nbsp; Задача о n ферзях"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   Задача о перестановках","text":"<p>Задача о перестановках является типичным применением алгоритма поиска с возвратом. Ее определение состоит в том, чтобы для данного множества элементов (например, массива или строки) найти все возможные перестановки этих элементов.</p> <p>В таблице 13-2 приведено несколько примеров входных массивов и соответствующих им перестановок.</p> <p> Таблица 13-2   Примеры перестановок </p> Входной массив Все перестановки \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   Случай без равных элементов","text":"<p>Question</p> <p>Дан массив целых чисел, в котором нет повторяющихся элементов. Верните все возможные перестановки.</p> <p>С точки зрения поиска с возвратом процесс построения перестановок можно представить как результат последовательности выборов. Пусть входной массив равен \\([1, 2, 3]\\) ; если мы сначала выберем \\(1\\) , затем \\(3\\) , а потом \\(2\\) , то получим перестановку \\([1, 3, 2]\\) . Откат здесь означает отмену одного из выборов с последующей попыткой других вариантов.</p> <p>С точки зрения кода поиска с возвратом множество кандидатов <code>choices</code> состоит из всех элементов входного массива, а состояние <code>state</code> - из элементов, уже выбранных к текущему моменту. Поскольку каждый элемент разрешено выбирать только один раз, все элементы в <code>state</code> должны быть уникальны.</p> <p>Как показано на рисунке 13-5, процесс поиска можно развернуть в дерево рекурсии, где каждый узел представляет текущее состояние <code>state</code> . Начиная от корня, после трех раундов выбора мы попадаем в листья, и каждый лист соответствует одной перестановке.</p> <p></p> <p> Рисунок 13-5   Дерево рекурсии для перестановок </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   Обрезка повторного выбора","text":"<p>Чтобы гарантировать, что каждый элемент выбирается только один раз, введем булев массив <code>selected</code> , где <code>selected[i]</code> обозначает, был ли уже выбран <code>choices[i]</code> , и на его основе выполним следующую обрезку.</p> <ul> <li>После того как сделан выбор <code>choice[i]</code> , мы присваиваем <code>selected[i]</code> значение \\(\\text{True}\\) , тем самым отмечая, что этот элемент уже выбран.</li> <li>При обходе списка вариантов <code>choices</code> пропускаем все уже выбранные элементы, то есть выполняем обрезку.</li> </ul> <p>Как показано на рисунке 13-6, если в первом раунде мы выберем 1 , во втором - 3 , а в третьем - 2 , то во втором раунде нужно отсечь ветвь элемента 1 , а в третьем - ветви элементов 1 и 3 .</p> <p></p> <p> Рисунок 13-6   Пример обрезки в задаче о перестановках </p> <p>Из рисунка видно, что такая обрезка уменьшает размер пространства поиска с \\(O(n^n)\\) до \\(O(n!)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   Реализация кода","text":"<p>После прояснения всей логики можно просто \"заполнить пропуски\" в шаблоне поиска с возвратом. Чтобы сократить общий объем кода, мы не будем отдельно реализовывать каждую функцию из каркаса, а раскроем их прямо внутри <code>backtrack()</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: все перестановки I\"\"\"\n    # Когда длина состояния равна числу элементов, записать решение\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    for i, choice in enumerate(choices):\n        # Отсечение: нельзя выбирать один и тот же элемент повторно\n        if not selected[i]:\n            # Попытка: сделать выбор и обновить состояние\n            selected[i] = True\n            state.append(choice)\n            # Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Все перестановки I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push_back(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Все перестановки I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.add(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.Add(choice);\n            // Перейти к следующему выбору\n            Backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Перебор всех вариантов выбора\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !(*selected)[i] {\n            // Попытка: сделать выбор и обновить состояние\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Перейти к следующему выбору\n            backtrackI(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Все перестановки I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i, choice) in choices.enumerated() {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !selected[i] {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true\n            state.append(choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Все перестановки I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunction backtrack(state, choices, selected, res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Когда длина состояния равна числу элементов, записать решение\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Отсечение: нельзя выбирать один и тот же элемент повторно\n    if (!selected[i]) {\n      // Попытка: сделать выбор и обновить состояние\n      selected[i] = true;\n      state.add(choice);\n      // Перейти к следующему выбору\n      backtrack(state, choices, selected, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Все перестановки I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if !selected[i] {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state.clone(), choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Все перестановки I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // Состояние (подмножество)\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Перейти к следующему выбору\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n        }\n    }\n}\n\n/* Все перестановки I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* Алгоритм бэктрекинга: все перестановки I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно\n        if (!selected[i]) {\n            // Попытка: сделать выбор и обновить состояние\n            selected[i] = true\n            state.add(choice)\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Все перестановки I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### Алгоритм бэктрекинга: все перестановки I ###\ndef backtrack(state, choices, selected, res)\n  # Когда длина состояния равна числу элементов, записать решение\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  choices.each_with_index do |choice, i|\n    # Отсечение: нельзя выбирать один и тот же элемент повторно\n    unless selected[i]\n      # Попытка: сделать выбор и обновить состояние\n      selected[i] = true\n      state &lt;&lt; choice\n      # Перейти к следующему выбору\n      backtrack(state, choices, selected, res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Все перестановки I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   Учет равных элементов","text":"<p>Question</p> <p>Дан массив целых чисел, который может содержать повторяющиеся элементы. Верните все неповторяющиеся перестановки.</p> <p>Пусть входной массив равен \\([1, 1, 2]\\) . Чтобы различать два одинаковых элемента \\(1\\) , будем обозначать второй из них как \\(\\hat{1}\\) .</p> <p>Как показано на рисунке 13-7, описанный выше метод создаст результат, половина которого окажется дублирующейся.</p> <p></p> <p> Рисунок 13-7   Повторяющиеся перестановки </p> <p>Как же убрать повторяющиеся перестановки? Самый прямолинейный способ - воспользоваться хеш-множеством и удалить дубликаты уже после генерации результата. Но это не слишком изящно, потому что ветви поиска, порождающие дубликаты, вообще не нужно посещать: их следует распознавать заранее и отсекать, что дополнительно повышает эффективность алгоритма.</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   Обрезка равных элементов","text":"<p>Посмотрите на рисунок 13-8: в первом раунде выбрать \\(1\\) или выбрать \\(\\hat{1}\\) - это одно и то же, а значит, все перестановки, полученные из этих двух выборов, будут дублироваться. Поэтому ветвь \\(\\hat{1}\\) нужно отсечь.</p> <p>Точно так же, если в первом раунде выбрать \\(2\\) , то во втором раунде выборы \\(1\\) и \\(\\hat{1}\\) снова создадут дублирующиеся ветви, поэтому и в этом случае ветвь \\(\\hat{1}\\) нужно отсечь.</p> <p>Иначе говоря, наша цель заключается в том, чтобы на каждом раунде выбора каждый из нескольких равных элементов выбирался только один раз.</p> <p></p> <p> Рисунок 13-8   Обрезка повторяющихся перестановок </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"<p>На основе решения из предыдущей задачи можно на каждом раунде выбора заводить хеш-множество <code>duplicated</code> , которое будет записывать элементы, уже встречавшиеся в этом раунде, и отсекать повторы:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: все перестановки II\"\"\"\n    # Когда длина состояния равна числу элементов, записать решение\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if not selected[i] and choice not in duplicated:\n            # Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice)  # Записать значения уже выбранных элементов\n            selected[i] = True\n            state.append(choice)\n            # Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            # Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"Все перестановки II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.emplace(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push_back(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* Все перестановки II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.add(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.Add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.Add(choice);\n            // Перейти к следующему выбору\n            Backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // Перебор всех вариантов выбора\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // Попробовать: сделать выбор, обновить состояние\n            // Записать значение уже выбранного элемента\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // Перейти к следующему выбору\n            backtrackII(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* Все перестановки II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if !selected[i], !duplicated.contains(choice) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.insert(choice) // Записать значения уже выбранных элементов\n            selected[i] = true\n            state.append(choice)\n            // Перейти к следующему выбору\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* Все перестановки II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunction backtrack(state, choices, selected, res) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* Все перестановки II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Когда длина состояния равна числу элементов, записать решение\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // Попытка: сделать выбор и обновить состояние\n      duplicated.add(choice); // Записать значения уже выбранных элементов\n      selected[i] = true;\n      state.add(choice);\n      // Перейти к следующему выбору\n      backtrack(state, choices, selected, res);\n      // Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* Все перестановки II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.insert(choice); // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state.push(choice);\n            // Перейти к следующему выбору\n            backtrack(state.clone(), choices, selected, res);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* Все перестановки II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated[choice] = true; // Записать значения уже выбранных элементов\n            selected[i] = true;\n            state[stateSize] = choice;\n            // Перейти к следующему выбору\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false;\n        }\n    }\n}\n\n/* Все перестановки II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* Алгоритм бэктрекинга: все перестановки II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Когда длина состояния равна числу элементов, записать решение\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // Попытка: сделать выбор и обновить состояние\n            duplicated.add(choice) // Записать значения уже выбранных элементов\n            selected[i] = true\n            state.add(choice)\n            // Перейти к следующему выбору\n            backtrack(state, choices, selected, res)\n            // Откат: отменить выбор и восстановить предыдущее состояние\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* Все перестановки II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### Алгоритм бэктрекинга: все перестановки II ###\ndef backtrack(state, choices, selected, res)\n  # Когда длина состояния равна числу элементов, записать решение\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # Попытка: сделать выбор и обновить состояние\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # Перейти к следующему выбору\n      backtrack(state, choices, selected, res)\n      # Откат: отменить выбор и восстановить предыдущее состояние\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### Все перестановки II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если предположить, что все элементы попарно различны, то из \\(n\\) элементов можно получить \\(n!\\) перестановок; при записи результата требуется копировать список длины \\(n\\) , что занимает \\(O(n)\\) времени. Следовательно, временная сложность равна \\(O(n!n)\\) .</p> <p>Максимальная глубина рекурсии равна \\(n\\) , что требует \\(O(n)\\) стековой памяти. Массив <code>selected</code> занимает \\(O(n)\\) пространства. Одновременно может существовать до \\(n\\) хеш-множеств <code>duplicated</code> , что дает \\(O(n^2)\\) памяти. Следовательно, пространственная сложность равна \\(O(n^2)\\) .</p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3","level":3,"title":"3.   Сравнение двух видов обрезки","text":"<p>Обратите внимание: хотя и <code>selected</code> , и <code>duplicated</code> используются для обрезки, их цели различаются.</p> <ul> <li>Обрезка повторного выбора: во всем процессе поиска существует только один <code>selected</code> . Он записывает, какие элементы уже входят в текущее состояние, и нужен для того, чтобы один и тот же элемент не появлялся в <code>state</code> дважды.</li> <li>Обрезка равных элементов: каждый раунд выбора (каждый вызов <code>backtrack</code>) содержит собственный <code>duplicated</code> . Он записывает, какие элементы уже выбирались в текущем раунде (<code>for</code> цикле), и нужен для того, чтобы равные элементы выбирались только один раз.</li> </ul> <p>На рисунке 13-9 показана область действия двух условий обрезки. Помните, что каждый узел дерева соответствует одному выбору, а путь от корня до листа образует одну перестановку.</p> <p></p> <p> Рисунок 13-9   Область действия двух условий обрезки </p>","path":["Глава 13. Поиск с возвратом","13.2 &nbsp; Задача о перестановках"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   Задача о сумме подмножеств","text":"","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   Случай без повторяющихся элементов","text":"<p>Question</p> <p>Дан массив положительных целых чисел <code>nums</code> и целое положительное значение <code>target</code> . Найдите все возможные комбинации, сумма элементов которых равна <code>target</code> . Во входном массиве нет повторяющихся элементов, и каждый элемент можно выбирать неограниченное число раз. Верните эти комбинации в виде списка; в результате не должно быть повторяющихся комбинаций.</p> <p>Например, для входного множества \\(\\{3, 4, 5\\}\\) и целевого значения \\(9\\) решениями будут \\(\\{3, 3, 3\\}\\) и \\(\\{4, 5\\}\\) . При этом важно учитывать два обстоятельства.</p> <ul> <li>Элементы входного множества можно выбирать повторно неограниченное число раз.</li> <li>Подмножество не различает порядок элементов, поэтому \\(\\{4, 5\\}\\) и \\(\\{5, 4\\}\\) считаются одним и тем же подмножеством.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   Отталкиваемся от решения задачи о перестановках","text":"<p>Как и в задаче о перестановках, можно представлять построение подмножеств как результат последовательности выборов и во время выбора динамически обновлять \"сумму элементов\"; когда эта сумма становится равной <code>target</code> , соответствующее подмножество записывается в список результатов.</p> <p>Однако в отличие от задачи о перестановках в этой задаче элементы множества можно выбирать неограниченное число раз, поэтому нам не нужен булев список <code>selected</code> для записи того, был ли выбран элемент. Можно слегка изменить код для перестановок и получить первоначальную версию решения:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств I\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if total == target:\n        res.append(list(state))\n        return\n    # Перебор всех вариантов выбора\n    for i in range(len(choices)):\n        # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target:\n            continue\n        # Попытка: сделать выбор и обновить элемент и total\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств I (с повторяющимися подмножествами)\"\"\"\n    state = []  # Состояние (подмножество)\n    total = 0  # Сумма подмножеств\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // Состояние (подмножество)\n    int total = 0;           // Сумма подмножеств\n    vector&lt;vector&lt;int&gt;&gt; res; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    int total = 0; // Сумма подмножеств\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    int total = 0; // Сумма подмножеств\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for i := 0; i &lt; len(*choices); i++ {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    total := 0              // Сумма подмножеств\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if total == target {\n        res.append(state)\n        return\n    }\n    // Перебор всех вариантов выбора\n    for i in choices.indices {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let total = 0 // Сумма подмножеств\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(state, target, total, choices, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // Состояние (подмножество)\n    const total = 0; // Сумма подмножеств\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (let i = 0; i &lt; choices.length; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    const total = 0; // Сумма подмножеств\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // Перебор всех вариантов выбора\n  for (int i = 0; i &lt; choices.length; i++) {\n    // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // Попытка: сделать выбор и обновить элемент и total\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  int total = 0; // Сумма элементов\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for i in 0..choices.len() {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    let total = 0; // Сумма подмножеств\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state[stateSize++] = choices[i];\n        // Перейти к следующему выбору\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // Инициализировать число решений нулем\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Перебор всех вариантов выбора\n    for (i in choices.indices) {\n        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // Попытка: сделать выбор и обновить элемент и total\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target, total + choices[i], choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    val total = 0 // Сумма подмножеств\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, total, choices, res)\n  # Если сумма подмножества равна target, записать решение\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  for i in 0...choices.length\n    # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    next if total + choices[i] &gt; target\n    # Попытка: сделать выбор и обновить элемент и total\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, total, choices, res)\n  # Если сумма подмножества равна target, записать решение\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Перебор всех вариантов выбора\n  for i in 0...choices.length\n    # Отсечение: если сумма подмножества превышает target, пропустить этот выбор\n    next if total + choices[i] &gt; target\n    # Попытка: сделать выбор и обновить элемент и total\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target, total + choices[i], choices, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n# ## Решить задачу суммы подмножеств I (с повторяющимися подмножествами) ###\ndef subset_sum_i_naive(nums, target)\n  state = [] # Состояние (подмножество)\n  total = 0 # Сумма подмножеств\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Если подать на этот код массив \\([3, 4, 5]\\) и целевое значение \\(9\\) , то на выходе мы получим \\([3, 3, 3], [4, 5], [5, 4]\\) . Хотя все подмножества с суммой \\(9\\) успешно найдены, среди них все же присутствуют дубликаты: \\([4, 5]\\) и \\([5, 4]\\) .</p> <p>Причина в том, что процесс поиска различает порядок выбора, тогда как для подмножеств порядок не важен. Как показано на рисунке 13-10, сначала выбрать \\(4\\) , а затем \\(5\\) , и сначала выбрать \\(5\\) , а затем \\(4\\) - это разные ветви поиска, но им соответствует одно и то же подмножество.</p> <p></p> <p> Рисунок 13-10   Поиск подмножеств и обрезка по выходу за границу </p> <p>Чтобы убрать повторяющиеся подмножества, одна из прямых идей - удалить дубликаты уже из итогового списка результатов. Но это решение малоэффективно по двум причинам.</p> <ul> <li>Когда массив содержит много элементов, а особенно когда <code>target</code> велик, процесс поиска порождает огромное число повторяющихся подмножеств.</li> <li>Сравнение подмножеств (то есть массивов) само по себе довольно затратно: сначала приходится сортировать массивы, а затем поэлементно сравнивать их.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   Обрезка повторяющихся подмножеств","text":"<p>Поэтому стоит выполнять устранение дубликатов прямо во время поиска, с помощью обрезки. Посмотрите на рисунок 13-11: повторяющиеся подмножества возникают тогда, когда элементы массива выбираются в разном порядке, например так.</p> <ol> <li>Если в первом и втором раундах выбрать соответственно \\(3\\) и \\(4\\) , то будут сгенерированы все подмножества, содержащие эти два элемента, и их можно обозначить как \\([3, 4, \\dots]\\) .</li> <li>После этого, если в первом раунде выбрать \\(4\\) , то во втором раунде нужно пропустить \\(3\\) , потому что подмножества \\([4, 3, \\dots]\\) полностью дублируют подмножества, уже построенные на шаге <code>1.</code> .</li> </ol> <p>Во время поиска варианты на каждом уровне пробуются по одному слева направо, поэтому чем правее ветвь, тем больше ветвей оказывается отсечено.</p> <ol> <li>В первых двух раундах выбираются \\(3\\) и \\(5\\) , что дает подмножества \\([3, 5, \\dots]\\) .</li> <li>В первых двух раундах выбираются \\(4\\) и \\(5\\) , что дает подмножества \\([4, 5, \\dots]\\) .</li> <li>Если же в первом раунде выбрать \\(5\\) , то во втором раунде нужно пропустить \\(3\\) и \\(4\\) , потому что подмножества \\([5, 3, \\dots]\\) и \\([5, 4, \\dots]\\) полностью дублируют случаи, описанные в шагах <code>1.</code> и <code>2.</code> .</li> </ol> <p></p> <p> Рисунок 13-11   Повторяющиеся подмножества из-за разного порядка выбора </p> <p>В общем виде, если входной массив имеет вид \\([x_1, x_2, \\dots, x_n]\\) , а последовательность выборов в ходе поиска равна \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) , то она должна удовлетворять условию \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ; все последовательности выборов, не удовлетворяющие этому условию, приводят к дубликатам и должны отсекаться.</p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>Чтобы реализовать такую обрезку, инициализируем переменную <code>start</code> , которая будет указывать начальную точку обхода. После выбора элемента \\(x_i\\) следующий раунд начинается с индекса \\(i\\). Благодаря этому последовательность выборов всегда удовлетворяет условию \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) , а значит, каждое подмножество создается только один раз.</p> <p>Помимо этого, мы внесем в код еще два улучшения.</p> <ul> <li>Перед началом поиска отсортируем массив <code>nums</code> . Тогда при обходе всех вариантов можно сразу прервать цикл, как только сумма подмножества превысит <code>target</code> , потому что все последующие элементы будут еще больше и их сумма тоже превысит <code>target</code> .</li> <li>Откажемся от отдельной переменной суммы <code>total</code> и будем учитывать сумму через вычитание из <code>target</code> ; когда <code>target</code> станет равным \\(0\\) , решение фиксируется.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств I\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if target == 0:\n        res.append(list(state))\n        return\n    # Обойти все варианты выбора\n    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in range(start, len(choices)):\n        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0:\n            break\n        # Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств I\"\"\"\n    state = []  # Состояние (подмножество)\n    nums.sort()  # Отсортировать nums\n    start = 0  # Стартовая вершина обхода\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // Состояние (подмножество)\n    sort(nums.begin(), nums.end()); // Отсортировать nums\n    int start = 0;                  // Стартовая вершина обхода\n    vector&lt;vector&lt;int&gt;&gt; res;        // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    Arrays.sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    Array.Sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i := start; i &lt; len(*choices); i++ {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    sort.Ints(nums)         // Отсортировать nums\n    start := 0              // Стартовая вершина обхода\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in choices.indices.dropFirst(start) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let nums = nums.sorted() // Отсортировать nums\n    let start = 0 // Стартовая вершина обхода\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(state, target, choices, start, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunction subsetSumI(nums, target) {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Обойти все варианты выбора\n  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  for (int i = start; i &lt; choices.length; i++) {\n    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Попытка: сделать выбор и обновить target и start\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  nums.sort(); // Отсортировать nums\n  int start = 0; // Стартовая вершина обхода\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for i in start..choices.len() {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    nums.sort(); // Отсортировать nums\n    let start = 0; // Стартовая вершина обхода\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Перейти к следующему выбору\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // Отсортировать nums\n    int start = 0;                           // Стартовая вершина обхода\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    for (i in start..&lt;choices.size) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    nums.sort() // Отсортировать nums\n    val start = 0 // Стартовая вершина обхода\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств I ###\ndef backtrack(state, target, choices, start, res)\n  # Если сумма подмножества равна target, записать решение\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # Обойти все варианты выбора\n  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  for i in start...choices.length\n    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    break if target - choices[i] &lt; 0\n    # Попытка: сделать выбор и обновить target и start\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Решить задачу суммы подмножеств I ###\ndef subset_sum_i(nums, target)\n  state = [] # Состояние (подмножество)\n  nums.sort! # Отсортировать nums\n  start = 0 # Стартовая вершина обхода\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 13-12 показан полный процесс поиска с возвратом для массива \\([3, 4, 5]\\) и целевого значения \\(9\\) .</p> <p></p> <p> Рисунок 13-12   Процесс поиска с возвратом для задачи о сумме подмножеств I </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   Учет повторяющихся элементов","text":"<p>Question</p> <p>Дан массив положительных целых чисел <code>nums</code> и целое положительное значение <code>target</code> . Найдите все возможные комбинации, сумма элементов которых равна <code>target</code> . Во входном массиве могут присутствовать повторяющиеся элементы, и каждый элемент разрешено выбирать только один раз. Верните эти комбинации в виде списка; в результате не должно быть повторяющихся комбинаций.</p> <p>По сравнению с предыдущей задачей во входном массиве теперь могут присутствовать повторяющиеся элементы, и это создает новую проблему. Например, если дан массив \\([4, \\hat{4}, 5]\\) и целевое значение \\(9\\) , то существующий код вернет результат \\([4, 5], [\\hat{4}, 5]\\) , то есть с повторяющимся подмножеством.</p> <p>Причина появления дублей в том, что равные элементы выбираются несколько раз в одном и том же раунде. На рисунке 13-13 в первом раунде существует три варианта выбора, и два из них равны \\(4\\) ; из-за этого появляются две дублирующиеся ветви поиска и, соответственно, повторяющиеся подмножества. Точно так же два элемента \\(4\\) во втором раунде тоже порождают дубликаты.</p> <p></p> <p> Рисунок 13-13   Повторяющиеся подмножества из-за равных элементов </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   Обрезка равных элементов","text":"<p>Чтобы решить эту проблему, нужно ограничить выбор равных элементов так, чтобы в каждом раунде каждый из них выбирался только один раз. Реализуется это довольно естественно: поскольку массив отсортирован, равные элементы стоят рядом. Значит, если в текущем раунде текущий элемент равен соседнему слева, то этот вариант уже был рассмотрен, и текущий элемент нужно пропустить.</p> <p>Одновременно по условию этой задачи каждый элемент массива можно выбрать только один раз. К счастью, это ограничение тоже можно реализовать через переменную <code>start</code> : после выбора элемента \\(x_i\\) следующий раунд начинается с индекса \\(i + 1\\) . Так мы одновременно убираем повторяющиеся подмножества и исключаем повторный выбор одного и того же элемента.</p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"Алгоритм бэктрекинга: сумма подмножеств II\"\"\"\n    # Если сумма подмножества равна target, записать решение\n    if target == 0:\n        res.append(list(state))\n        return\n    # Обойти все варианты выбора\n    # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in range(start, len(choices)):\n        # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0:\n            break\n        # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        # Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"Решить задачу суммы подмножеств II\"\"\"\n    state = []  # Состояние (подмножество)\n    nums.sort()  # Отсортировать nums\n    start = 0  # Стартовая вершина обхода\n    res = []  # Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.size(); i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push_back(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop_back();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // Состояние (подмножество)\n    sort(nums.begin(), nums.end()); // Отсортировать nums\n    int start = 0;                  // Стартовая вершина обхода\n    vector&lt;vector&lt;int&gt;&gt; res;        // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.remove(state.size() - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // Состояние (подмножество)\n    Arrays.sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choices.Length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.Add(choices[i]);\n        // Перейти к следующему выбору\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // Состояние (подмножество)\n    Array.Sort(nums); // Отсортировать nums\n    int start = 0; // Стартовая вершина обхода\n    List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i := start; i &lt; len(*choices); i++ {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        *state = append(*state, (*choices)[i])\n        // Перейти к следующему выбору\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // Состояние (подмножество)\n    sort.Ints(nums)         // Отсортировать nums\n    start := 0              // Стартовая вершина обхода\n    res := make([][]int, 0) // Список результатов (список подмножеств)\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in choices.indices.dropFirst(start) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.append(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeLast()\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // Состояние (подмножество)\n    let nums = nums.sorted() // Отсортировать nums\n    let start = 0 // Стартовая вершина обхода\n    var res: [[Int]] = [] // Список результатов (список подмножеств)\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunction backtrack(state, target, choices, start, res) {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunction subsetSumII(nums, target) {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // Если сумма подмножества равна target, записать решение\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (let i = start; i &lt; choices.length; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // Состояние (подмножество)\n    nums.sort((a, b) =&gt; a - b); // Отсортировать nums\n    const start = 0; // Стартовая вершина обхода\n    const res = []; // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // Если сумма подмножества равна target, записать решение\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // Обойти все варианты выбора\n  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n  for (int i = start; i &lt; choices.length; i++) {\n    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // Попытка: сделать выбор и обновить target и start\n    state.add(choices[i]);\n    // Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // Откат: отменить выбор и восстановить предыдущее состояние\n    state.removeLast();\n  }\n}\n\n/* Решить задачу суммы подмножеств II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // Состояние (подмножество)\n  nums.sort(); // Отсортировать nums\n  int start = 0; // Стартовая вершина обхода\n  List&lt;List&lt;int&gt;&gt; res = []; // Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // Если сумма подмножества равна target, записать решение\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for i in start..choices.len() {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.push(choices[i]);\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.pop();\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // Состояние (подмножество)\n    nums.sort(); // Отсортировать nums\n    let start = 0; // Стартовая вершина обхода\n    let mut res = Vec::new(); // Список результатов (список подмножеств)\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (int i = start; i &lt; choicesSize; i++) {\n        // Отсечение 1: если сумма подмножества превышает target, сразу пропустить\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // Перейти к следующему выбору\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        stateSize--;\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // Отсортировать nums\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // Начать бэктрекинг\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* Алгоритм бэктрекинга: сумма подмножеств II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // Если сумма подмножества равна target, записать решение\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // Обойти все варианты выбора\n    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n    for (i in start..&lt;choices.size) {\n        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // Попытка: сделать выбор и обновить target и start\n        state.add(choices[i])\n        // Перейти к следующему выбору\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // Откат: отменить выбор и восстановить предыдущее состояние\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* Решить задачу суммы подмножеств II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // Состояние (подмножество)\n    nums.sort() // Отсортировать nums\n    val start = 0 // Стартовая вершина обхода\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // Список результатов (список подмножеств)\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### Алгоритм бэктрекинга: сумма подмножеств II ###\ndef backtrack(state, target, choices, start, res)\n  # Если сумма подмножества равна target, записать решение\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # Обойти все варианты выбора\n  # Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств\n  # Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента\n  for i in start...choices.length\n    # Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл\n    # Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target\n    break if target - choices[i] &lt; 0\n    # Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # Попытка: сделать выбор и обновить target и start\n    state &lt;&lt; choices[i]\n    # Перейти к следующему выбору\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # Откат: отменить выбор и восстановить предыдущее состояние\n    state.pop\n  end\nend\n\n### Решить задачу суммы подмножеств II ###\ndef subset_sum_ii(nums, target)\n  state = [] # Состояние (подмножество)\n  nums.sort! # Отсортировать nums\n  start = 0 # Стартовая вершина обхода\n  res = [] # Список результатов (список подмножеств)\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 13-14 показан процесс поиска с возвратом для массива \\([4, 4, 5]\\) и целевого значения \\(9\\) . В нем используются четыре вида обрезки. Попробуйте сопоставить рисунок с комментариями в коде, чтобы понять полный процесс поиска и то, как работает каждый тип обрезки.</p> <p></p> <p> Рисунок 13-14   Процесс поиска с возвратом для задачи о сумме подмножеств II </p>","path":["Глава 13. Поиск с возвратом","13.3 &nbsp; Задача о сумме подмножеств"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   Резюме","text":"","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Алгоритм поиска с возвратом по своей сути является методом полного перебора: он ищет решения путем обхода пространства решений в глубину. Во время поиска он фиксирует решения, удовлетворяющие условиям, пока не найдет все такие решения или пока обход не завершится.</li> <li>Процесс поиска с возвратом состоит из двух частей: попытки и отката. Он с помощью поиска в глубину пробует разные варианты выбора; когда встречается состояние, не удовлетворяющее ограничениям, алгоритм отменяет предыдущий выбор, возвращается к прошлому состоянию и продолжает пробовать другие варианты. Попытка и откат являются двумя противоположными по направлению действиями.</li> <li>Задачи поиска с возвратом обычно содержат несколько ограничений, которые можно использовать для обрезки. Обрезка позволяет заранее завершать ненужные ветви поиска и тем самым значительно повышать эффективность.</li> <li>Алгоритм поиска с возвратом в первую очередь применяется для решения поисковых задач и задач с ограничениями. Задачи комбинаторной оптимизации тоже можно решать с его помощью, но для них часто существуют более эффективные или более подходящие методы.</li> <li>Задача о перестановках нацелена на поиск всех возможных перестановок элементов данного множества. Мы используем массив для записи того, был ли выбран каждый элемент, и отсекаем ветви, где один и тот же элемент выбирается повторно, чтобы гарантировать однократный выбор каждого элемента.</li> <li>В задаче о перестановках, если во множестве присутствуют повторяющиеся элементы, в итоговом результате возникнут повторяющиеся перестановки. Поэтому нужно ограничить выбор равных элементов так, чтобы в каждом раунде каждый из них выбирался только один раз; обычно это реализуется с помощью хеш-множества.</li> <li>Цель задачи о сумме подмножеств - найти все подмножества данного множества, сумма которых равна целевому значению. В множестве порядок элементов не важен, однако процесс поиска порождает результаты во всех возможных порядках, из-за чего появляются повторяющиеся подмножества. Поэтому перед запуском поиска с возвратом мы сортируем данные и вводим переменную, указывающую начальную точку обхода в каждом раунде, чтобы отсечь ветви, создающие дубликаты.</li> <li>В задаче о сумме подмножеств равные элементы массива также порождают повторяющиеся множества. При наличии предварительной сортировки их можно отсекать, проверяя равенство соседних элементов, и тем самым гарантировать, что в каждом раунде равные элементы будут выбираться только один раз.</li> <li>Задача о \\(n\\) ферзях состоит в поиске способов разместить \\(n\\) ферзей на доске размера \\(n \\times n\\) так, чтобы никакие два ферзя не атаковали друг друга. Ограничения этой задачи включают строки, столбцы, главные диагонали и побочные диагонали. Чтобы выполнить ограничение по строкам, используется построчная стратегия размещения, гарантирующая по одному ферзю в каждой строке.</li> <li>Обработка ограничений по столбцам и диагоналям устроена похожим образом. Для ограничения по столбцам используется массив, фиксирующий наличие ферзя в каждом столбце. Для диагоналей используются два массива, записывающие наличие ферзей на главных и побочных диагоналях. Основная сложность здесь состоит в том, чтобы найти закономерность индексов строк и столбцов клеток, лежащих на одной и той же главной или побочной диагонали.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_backtracking/summary/#2","level":3,"title":"2.   Вопросы и ответы","text":"<p>Q: Как понять связь между поиском с возвратом и рекурсией?</p> <p>В целом поиск с возвратом - это скорее \"алгоритмическая стратегия\", а рекурсия больше похожа на \"инструмент\".</p> <ul> <li>Алгоритмы поиска с возвратом обычно реализуются на основе рекурсии. Однако поиск с возвратом - это лишь один из вариантов применения рекурсии, а именно ее использование в поисковых задачах.</li> <li>Структура рекурсии отражает парадигму разбиения на подзадачи и часто применяется для решения задач \"разделяй и властвуй\", поиска с возвратом, динамического программирования (мемоизированной рекурсии) и других подобных задач.</li> </ul>","path":["Глава 13. Поиск с возвратом","13.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"Глава 2.   Анализ сложности","text":"<p>Abstract</p> <p>Анализ сложности подобен пространственно-временному проводнику в необъятной вселенной алгоритмов.</p> <p>Он ведет нас в глубину двух измерений - времени и пространства, помогая искать более изящные решения.</p>","path":["Глава 2. Анализ сложности","Глава 2. &nbsp; Анализ сложности"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>2.1   Оценка эффективности алгоритмов</li> <li>2.2   Итерация и рекурсия</li> <li>2.3   Временная сложность</li> <li>2.4   Пространственная сложность</li> <li>2.5   Резюме</li> </ul>","path":["Глава 2. Анализ сложности","Глава 2. &nbsp; Анализ сложности"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   Итерация и рекурсия","text":"<p>В алгоритмах часто требуется повторное выполнение определенной задачи, что тесно связано с анализом сложности. Поэтому, прежде чем перейти к обсуждению временной и пространственной сложности, рассмотрим, как реализовать повторное выполнение задач в программе, а именно две основные структуры управления программой: итерацию и рекурсию.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   Итерация","text":"<p>Итерация (iteration) - это структура управления, которая позволяет повторно выполнять определенную задачу. В итерации программа повторяет выполнение определенного участка кода, пока выполняется определенное условие.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   Цикл for","text":"<p>Цикл <code>for</code> - одна из наиболее распространенных форм итерации, которая подходит для использования, когда количество итераций известно заранее.</p> <p>Следующая функция реализует суммирование \\(1 + 2 + \\dots + n\\) с использованием цикла <code>for</code> , а результат суммирования сохраняется в переменной <code>res</code> . Следует отметить, что в Python диапазон <code>range(a, b)</code> соответствует левому закрытому, правому открытому интервалу, то есть перебираются значения \\(a, a + 1, \\dots, b-1\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"Цикл for\"\"\"\n    res = 0\n    # Циклическое суммирование 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл for */\nint ForLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл for */\nfunc forLoop(n int) int {\n    res := 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл for */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл for */\nfunction forLoop(n) {\n    let res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл for */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл for */\nint forLoop(int n) {\n  int res = 0;\n  // Циклическое суммирование 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл for */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл for */\nint forLoop(int n) {\n    int res = 0;\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл for */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл for ###\ndef for_loop(n)\n  res = 0\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже представлена блок-схема этой функции суммирования.</p> <p></p> <p> Рисунок 2-1   Блок-схема функции суммирования </p> <p>Количество операций этой функции суммирования пропорционально размеру входных данных \\(n\\) , или, другими словами, линейно зависит от него. На самом деле временная сложность описывает именно эту линейную зависимость. Соответствующий материал будет подробно рассмотрен в следующем разделе.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   Цикл while","text":"<p>Подобно циклу <code>for</code> , цикл <code>while</code> также представляет собой метод реализации итерации. В цикле <code>while</code> программа перед каждой итерацией проверяет условие: если условие истинно, то выполнение продолжается, иначе цикл завершается.</p> <p>Ниже приведен пример реализации суммирования \\(1 + 2 + \\dots + n\\) с использованием цикла <code>while</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"Цикл while\"\"\"\n    res = 0\n    i = 1  # Инициализация условной переменной\n    # Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # Обновить условную переменную\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл while */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл while */\nfunc whileLoop(n int) int {\n    res := 0\n    // Инициализация условной переменной\n    i := 1\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл while */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // Обновить условную переменную\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл while */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл while */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл while */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // Инициализация условной переменной\n  // Циклическое суммирование 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // Обновить условную переменную\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл while */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Инициализация условной переменной\n\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // Обновить условную переменную\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл while */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // Обновить условную переменную\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл while */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // Обновить условную переменную\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл while ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Обновить условную переменную\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>**Цикл <code>while</code> обладает большей степенью свободы по сравнению с циклом <code>for</code> **. В цикле <code>while</code> можно свободно управлять инициализацией и обновлением условной переменной.</p> <p>Например, в следующем коде условная переменная \\(i\\) обновляется дважды на каждой итерации, что затруднительно сделать с использованием цикла <code>for</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"Цикл while (двойное обновление)\"\"\"\n    res = 0\n    i = 1  # Инициализация условной переменной\n    # Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # Обновить условную переменную\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* Цикл while (двойное обновление) */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* Цикл while (двойное обновление) */\nfunc whileLoopII(n int) int {\n    res := 0\n    // Инициализация условной переменной\n    i := 1\n    // Циклическое суммирование 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Цикл while (двойное обновление) */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // Обновить условную переменную\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Цикл while (двойное обновление) */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Цикл while (двойное обновление) */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // Инициализация условной переменной\n  // Циклическое суммирование 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // Обновить условную переменную\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Цикл while (двойное обновление) */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // Инициализация условной переменной\n\n    // Циклическое суммирование 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // Обновить условную переменную\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* Цикл while (двойное обновление) */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // Обновить условную переменную\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Цикл while (двойное обновление) */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // Инициализация условной переменной\n    // Циклическое суммирование 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // Обновить условную переменную\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### Цикл while ###\ndef while_loop(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # Обновить условную переменную\n  end\n\n  res\nend\n\n# ## Цикл while (двойное обновление) ###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # Инициализация условной переменной\n\n  # Циклическое суммирование 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # Обновить условную переменную\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В целом код с использованием цикла <code>for</code> более компактный, а цикл <code>while</code> более гибкий. Но они оба могут реализовать итерационную структуру. Выбор между ними определяется требованиями конкретной задачи.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   Вложенные циклы","text":"<p>Внутрь одной циклической структуры можно вложить другую, например используя два цикла <code>for</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"Двойной цикл for\"\"\"\n    res = \"\"\n    # Цикл по i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # Цикл по j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* Двойной цикл for */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* Двойной цикл for */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* Двойной цикл for */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* Двойной цикл for */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // Цикл по j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* Двойной цикл for */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* Двойной цикл for */\nfunction nestedForLoop(n) {\n    let res = '';\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* Двойной цикл for */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* Двойной цикл for */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // Цикл по i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // Цикл по j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* Двойной цикл for */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // Цикл по i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* Двойной цикл for */\nchar *nestedForLoop(int n) {\n    // n * n — это число соответствующих точек, а максимальная длина строки \"(i, j), \" равна 6+10*2, плюс дополнительное место для завершающего нулевого символа \\0\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* Двойной цикл for */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // Цикл по i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // Цикл по j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### Двойной цикл for ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # Цикл по i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # Цикл по j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже приведена блок-схема такого вложенного цикла.</p> <p></p> <p> Рисунок 2-2   Блок-схема вложенного цикла </p> <p>В этом случае количество выполненных действий пропорционально \\(n^2\\) , или, другими словами, время выполнения алгоритма и размер входных данных \\(n\\) находятся в квадратичной зависимости.</p> <p>Можно и дальше добавлять вложенные циклы, тогда каждое вложение будет повышать размерность, увеличивая временную сложность до кубической зависимости, зависимости четвертой степени и так далее.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   Рекурсия","text":"<p>Рекурсия (recursion) - это стратегия алгоритма, при которой функция вызывает саму себя для решения задачи. Она включает два основных этапа.</p> <ol> <li>Вызов: программа постоянно вызывает саму себя, обычно передавая меньшие или более упрощенные параметры, пока не будет достигнуто условие завершения.</li> <li>Возврат: после срабатывания условия завершения программа начинает возвращаться из самой глубокой рекурсивной функции, объединяя результаты каждого уровня.</li> </ol> <p>С точки зрения реализации рекурсивный код включает три основных элемента.</p> <ol> <li>Условие завершения: используется для определения момента перехода от вызова к возврату.</li> <li>Рекурсивный вызов: соответствует вызову, функция вызывает саму себя, обычно с меньшими или упрощенными параметрами.</li> <li>Возврат результата: соответствует возврату, возвращает результат текущего уровня рекурсии на предыдущий уровень.</li> </ol> <p>Рассмотрим следующий код: вызов функции <code>recur(n)</code> позволяет вычислить сумму \\(1 + 2 + \\dots + n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"Рекурсия\"\"\"\n    # Условие завершения\n    if n == 1:\n        return 1\n    # Рекурсия: рекурсивный вызов\n    res = recur(n - 1)\n    # Возврат: вернуть результат\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* Рекурсия */\nint Recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = Recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* Рекурсия */\nfunc recur(n int) int {\n    // Условие завершения\n    if n == 1 {\n        return 1\n    }\n    // Рекурсия: рекурсивный вызов\n    res := recur(n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* Рекурсия */\nfunc recur(n: Int) -&gt; Int {\n    // Условие завершения\n    if n == 1 {\n        return 1\n    }\n    // Рекурсия: рекурсивный вызов\n    let res = recur(n: n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* Рекурсия */\nfunction recur(n) {\n    // Условие завершения\n    if (n === 1) return 1;\n    // Рекурсия: рекурсивный вызов\n    const res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* Рекурсия */\nfunction recur(n: number): number {\n    // Условие завершения\n    if (n === 1) return 1;\n    // Рекурсия: рекурсивный вызов\n    const res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* Рекурсия */\nint recur(int n) {\n  // Условие завершения\n  if (n == 1) return 1;\n  // Рекурсия: рекурсивный вызов\n  int res = recur(n - 1);\n  // Возврат: вернуть результат\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* Рекурсия */\nfn recur(n: i32) -&gt; i32 {\n    // Условие завершения\n    if n == 1 {\n        return 1;\n    }\n    // Рекурсия: рекурсивный вызов\n    let res = recur(n - 1);\n    // Возврат: вернуть результат\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* Рекурсия */\nint recur(int n) {\n    // Условие завершения\n    if (n == 1)\n        return 1;\n    // Рекурсия: рекурсивный вызов\n    int res = recur(n - 1);\n    // Возврат: вернуть результат\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* Рекурсия */\nfun recur(n: Int): Int {\n    // Условие завершения\n    if (n == 1)\n        return 1\n    // Рекурсивный шаг: рекурсивный вызов\n    val res = recur(n - 1)\n    // Возврат: вернуть результат\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### Рекурсия ###\ndef recur(n)\n  # Условие завершения\n  return 1 if n == 1\n  # Рекурсия: рекурсивный вызов\n  res = recur(n - 1)\n  # Возврат: вернуть результат\n  n + res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Ниже представлен рекурсивный процесс этой функции.</p> <p></p> <p> Рисунок 2-3   Рекурсивный процесс функции суммирования </p> <p>Хотя с точки зрения вычислений итерация и рекурсия могут давать одинаковый результат, они представляют собой совершенно разные парадигмы мышления и решения задач.</p> <ul> <li>Итерация: решение задачи снизу вверх. Начинаем с самых базовых шагов, которые затем повторяются или накапливаются до завершения задачи.</li> <li>Рекурсия: решение задачи сверху вниз. Исходная задача разбивается на более мелкие подзадачи, которые имеют ту же форму, что и исходная задача. Далее подзадачи продолжают делиться на еще более мелкие, пока не достигается базовый случай, решение которого известно.</li> </ul> <p>Рассмотрим в качестве примера вышеупомянутую функцию суммирования, где решается задача \\(f(n) = 1 + 2 + \\dots + n\\) .</p> <ul> <li>Итерация: моделирование процесса суммирования в цикле проходит от \\(1\\) до \\(n\\) , выполняя операцию суммирования на каждом шаге, чтобы получить итоговое значение \\(f(n)\\) .</li> <li>Рекурсия: последовательное разбиение задачи на подзадачи вида \\(f(n) = n + f(n - 1)\\) до достижения базового случая \\(f(1) = 1\\) .</li> </ul>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   Стек вызовов","text":"<p>Каждый раз, когда рекурсивная функция вызывает саму себя, система выделяет память для нового вызова функции, чтобы хранить локальные переменные, адрес вызова и другую информацию. Это поведение имеет два последствия.</p> <ul> <li>Контекстные данные функции хранятся в области памяти, называемой пространством стекового кадра, и освобождаются только после возврата функции. Поэтому рекурсия обычно требует больше памяти, чем итерация.</li> <li>Рекурсивный вызов функции создает дополнительные накладные расходы. Поэтому рекурсия обычно менее эффективна по времени, чем цикл.</li> </ul> <p>Как показано на рисунке 2-4, до срабатывания условия завершения одновременно существует \\(n\\) невозвращенных рекурсивных функций, а глубина рекурсии равна \\(n\\) .</p> <p></p> <p> Рисунок 2-4   Глубина рекурсивного вызова </p> <p>На практике глубина рекурсии, разрешенная языком программирования, обычно ограничена, и слишком глубокая рекурсия может привести к ошибке переполнения стека.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   Хвостовая рекурсия","text":"<p>Интересно, что если рекурсивный вызов происходит на последнем шаге перед возвратом функции , то компилятор или интерпретатор может оптимизировать этот вызов, сделав его по эффективности использования памяти сопоставимым с итерацией. Это называется хвостовой рекурсией (tail recursion).</p> <ul> <li>Обычная рекурсия: когда функция возвращается на предыдущий уровень, необходимо продолжить выполнение кода, поэтому системе нужно сохранить контекст предыдущего вызова.</li> <li>Хвостовая рекурсия: рекурсивный вызов является последней операцией перед возвратом функции, что означает, что после возврата на предыдущий уровень не требуется выполнять другие операции, поэтому системе не нужно сохранять контекст предыдущей функции.</li> </ul> <p>В качестве примера вычисления суммы \\(1 + 2 + \\dots + n\\) можно установить переменную результата <code>res</code> в качестве параметра функции, чтобы реализовать хвостовую рекурсию:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"Хвостовая рекурсия\"\"\"\n    # Условие завершения\n    if n == 0:\n        return res\n    # Хвостовой рекурсивный вызов\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* Хвостовая рекурсия */\nint TailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* Хвостовая рекурсия */\nfunc tailRecur(n int, res int) int {\n    // Условие завершения\n    if n == 0 {\n        return res\n    }\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* Хвостовая рекурсия */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // Условие завершения\n    if n == 0 {\n        return res\n    }\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* Хвостовая рекурсия */\nfunction tailRecur(n, res) {\n    // Условие завершения\n    if (n === 0) return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* Хвостовая рекурсия */\nfunction tailRecur(n: number, res: number): number {\n    // Условие завершения\n    if (n === 0) return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n  // Условие завершения\n  if (n == 0) return res;\n  // Хвостовой рекурсивный вызов\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* Хвостовая рекурсия */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // Условие завершения\n    if n == 0 {\n        return res;\n    }\n    // Хвостовой рекурсивный вызов\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* Хвостовая рекурсия */\nint tailRecur(int n, int res) {\n    // Условие завершения\n    if (n == 0)\n        return res;\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* Хвостовая рекурсия */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // Добавить ключевое слово tailrec, чтобы включить оптимизацию хвостовой рекурсии\n    // Условие завершения\n    if (n == 0)\n        return res\n    // Хвостовой рекурсивный вызов\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### Хвостовая рекурсия ###\ndef tail_recur(n, res)\n  # Условие завершения\n  return res if n == 0\n  # Хвостовой рекурсивный вызов\n  tail_recur(n - 1, res + n)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Процесс выполнения хвостовой рекурсии показан на рисунке 2-5. Сравнивая обычную и хвостовую рекурсии, можно заметить, что точка выполнения операции суммирования у них различается.</p> <ul> <li>Обычная рекурсия: операция суммирования выполняется в процессе возврата, после каждого возврата необходимо снова выполнить операцию суммирования.</li> <li>Хвостовая рекурсия: операция суммирования выполняется в процессе вызова, а процесс возврата требует только последовательного возврата.</li> </ul> <p></p> <p> Рисунок 2-5   Процесс хвостовой рекурсии </p> <p>Tip</p> <p>Обратите внимание: многие компиляторы и интерпретаторы не поддерживают оптимизацию хвостовой рекурсии. Например, Python по умолчанию такую оптимизацию не выполняет, поэтому даже функция в хвостово-рекурсивной форме все равно может привести к переполнению стека.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   Дерево рекурсии","text":"<p>При решении задач, связанных с алгоритмами типа \"разделяй и властвуй\", рекурсия часто оказывается более интуитивной и читабельной, чем итерация. Рассмотрим в качестве примера последовательность Фибоначчи.</p> <p>Question</p> <p>Дана последовательность Фибоначчи \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) ; найди \\(n\\)-й элемент этой последовательности.</p> <p>Обозначив \\(n\\)-й член последовательности Фибоначчи как \\(f(n)\\) , можно сформулировать два утверждения.</p> <ul> <li>Первые два числа последовательности: \\(f(1) = 0\\) и \\(f(2) = 1\\) .</li> <li>Каждое число последовательности является суммой двух предыдущих чисел, то есть \\(f(n) = f(n - 1) + f(n - 2)\\) .</li> </ul> <p>Используя рекурсивные вызовы в соответствии с рекуррентным соотношением и принимая первые два числа за условия остановки, можно написать рекурсивный код. Вызов <code>fib(n)</code> позволит получить \\(n\\)-й член последовательности Фибоначчи:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"Последовательность Фибоначчи: рекурсия\"\"\"\n    # Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # Вернуть результат f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint Fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunc fib(n int) int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunc fib(n: Int) -&gt; Int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunction fib(n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfunction fib(n: number): number {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n  // Условие завершения: f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // Вернуть результат f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfn fib(n: i32) -&gt; i32 {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат\n    res\n}\n</code></pre> recursion.c<pre><code>/* Последовательность Фибоначчи: рекурсия */\nint fib(int n) {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // Вернуть результат f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Последовательность Фибоначчи: рекурсия */\nfun fib(n: Int): Int {\n    // Условие завершения: f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // Вернуть результат f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Последовательность Фибоначчи: рекурсия ###\ndef fib(n)\n  # Условие завершения: f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # Рекурсивный вызов f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # Вернуть результат f(n)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Проанализировав приведенный код, можно заметить, что внутри функции осуществляется рекурсивный вызов двух функций, то есть из одного вызова образуются два ветвления. Как показано на рисунке 2-6, при последующем выполнении рекурсивных вызовов в итоге образуется дерево рекурсии (recursion tree) глубиной \\(n\\) .</p> <p></p> <p> Рисунок 2-6   Дерево рекурсии последовательности Фибоначчи </p> <p>По своей сути рекурсия отражает парадигму мышления \"разбиение задачи на более мелкие подзадачи\", что делает стратегию \"разделяй и властвуй\" крайне важной.</p> <ul> <li>С точки зрения алгоритмов многие важные алгоритмические стратегии, такие как поиск, сортировка, возврат, \"разделяй и властвуй\" и динамическое программирование, прямо или косвенно используют этот подход.</li> <li>С точки зрения структур данных рекурсия естественно подходит для решения задач, связанных со списками, деревьями и графами, поскольку они очень хорошо поддаются анализу с использованием идеи \"разделяй и властвуй\".</li> </ul>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   Сравнение","text":"<p>Подводя итог, можно сказать, что итерация и рекурсия различаются по реализации, производительности и применимости, как показано в таблице 2-1.</p> <p> Таблица 2-1   Сравнение итерации и рекурсии </p> Итерация Рекурсия Способ реализации Циклическая структура Функция вызывает саму себя Временная эффективность Обычно высокая эффективность, нет затрат на вызов функции Каждый вызов функции создает затраты Использование памяти Обычно используется фиксированный объем памяти Накопление вызовов функции может использовать значительное количество пространства стека Сфера использования Подходит для простых циклических задач, код интуитивно понятен и хорошо читаем Подходит для разбиения на подзадачи, для структур деревья и графы, алгоритмов \"разделяй и властвуй\", возврата и т. д.; структура кода проста и ясна <p>Tip</p> <p>Если дальнейшее содержание кажется сложным, можно вернуться к нему после чтения главы о \"стеке\".</p> <p>Какова же внутренняя связь между итерацией и рекурсией? В рассмотренном примере рекурсивной функции операция сложения выполняется на этапе возврата рекурсии. Это означает, что функция, вызванная первой, фактически завершает операцию сложения последней, что соответствует принципу стека \"первым пришел - последним вышел\".</p> <p>На самом деле такие термины рекурсии, как \"стек вызовов\" и \"пространство стекового кадра\", уже намекают на тесную связь между рекурсией и стеком.</p> <ol> <li>Вызов: когда вызывается функция, система выделяет для нее новый стековый кадр в \"стеке вызовов\" для хранения локальных переменных функции, параметров, адреса возврата и других данных.</li> <li>Возврат: когда функция завершает выполнение и возвращает результат, соответствующий стековый кадр удаляется из \"стека вызовов\", восстанавливая среду выполнения предыдущей функции.</li> </ol> <p>Таким образом, можно использовать явный стек для моделирования поведения стека вызовов, чтобы преобразовать рекурсию в итеративную форму:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"Имитация рекурсии итерацией\"\"\"\n    # Использовать явный стек для имитации системного стека вызовов\n    stack = []\n    res = 0\n    # Рекурсия: рекурсивный вызов\n    for i in range(n, 0, -1):\n        # Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.append(i)\n    # Возврат: вернуть результат\n    while stack:\n        # Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (!stack.empty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (!stack.isEmpty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* Имитация рекурсии итерацией */\nint ForLoopRecur(int n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.Push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.Count &gt; 0) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* Имитация рекурсии итерацией */\nfunc forLoopRecur(n int) int {\n    // Использовать явный стек для имитации системного стека вызовов\n    stack := list.New()\n    res := 0\n    // Рекурсия: рекурсивный вызов\n    for i := n; i &gt; 0; i-- {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.PushBack(i)\n    }\n    // Возврат: вернуть результат\n    for stack.Len() != 0 {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* Имитация рекурсии итерацией */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // Использовать явный стек для имитации системного стека вызовов\n    var stack: [Int] = []\n    var res = 0\n    // Рекурсия: рекурсивный вызов\n    for i in (1 ... n).reversed() {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.append(i)\n    }\n    // Возврат: вернуть результат\n    while !stack.isEmpty {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* Имитация рекурсии итерацией */\nfunction forLoopRecur(n) {\n    // Использовать явный стек для имитации системного стека вызовов\n    const stack = [];\n    let res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (let i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.length) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* Имитация рекурсии итерацией */\nfunction forLoopRecur(n: number): number {\n    // Использовать явный стек для имитации системного стека вызовов\n    const stack: number[] = [];\n    let res: number = 0;\n    // Рекурсия: рекурсивный вызов\n    for (let i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while (stack.length) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n  // Использовать явный стек для имитации системного стека вызовов\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // Рекурсия: рекурсивный вызов\n  for (int i = n; i &gt; 0; i--) {\n    // Имитировать «рекурсию» с помощью операции помещения в стек\n    stack.add(i);\n  }\n  // Возврат: вернуть результат\n  while (!stack.isEmpty) {\n    // Имитировать «возврат» с помощью операции извлечения из стека\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* Имитация рекурсии итерацией */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // Использовать явный стек для имитации системного стека вызовов\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // Рекурсия: рекурсивный вызов\n    for i in (1..=n).rev() {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i);\n    }\n    // Возврат: вернуть результат\n    while !stack.is_empty() {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* Имитация рекурсии итерацией */\nint forLoopRecur(int n) {\n    int stack[1000]; // Использовать большой массив для имитации стека\n    int top = -1;    // Индекс вершины стека\n    int res = 0;\n    // Рекурсия: рекурсивный вызов\n    for (int i = n; i &gt; 0; i--) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack[1 + top++] = i;\n    }\n    // Возврат: вернуть результат\n    while (top &gt;= 0) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* Имитация рекурсии итерацией */\nfun forLoopRecur(n: Int): Int {\n    // Использовать явный стек для имитации системного стека вызовов\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // Рекурсивный шаг: рекурсивный вызов\n    for (i in n downTo 0) {\n        // Имитировать «рекурсию» с помощью операции помещения в стек\n        stack.push(i)\n    }\n    // Возврат: вернуть результат\n    while (stack.isNotEmpty()) {\n        // Имитировать «возврат» с помощью операции извлечения из стека\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### Имитация рекурсии итерацией ###\ndef for_loop_recur(n)\n  # Использовать явный стек для имитации системного стека вызовов\n  stack = []\n  res = 0\n\n  # Рекурсия: рекурсивный вызов\n  for i in n.downto(0)\n    # Имитировать «рекурсию» с помощью операции помещения в стек\n    stack &lt;&lt; i\n  end\n  # Возврат: вернуть результат\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Наблюдая за приведенным выше кодом, можно заметить, что после преобразования рекурсии в итерацию код становится более сложным. Хотя во многих случаях итерация и рекурсия действительно могут быть преобразованы друг в друга, это не всегда стоит делать по двум причинам.</p> <ul> <li>Преобразованный код может стать труднее для понимания и менее читаемым.</li> <li>Для некоторых сложных задач моделирование поведения системного стека вызовов может оказаться очень трудным.</li> </ul> <p>Итак, выбор между итерацией и рекурсией зависит от природы конкретной задачи. В практическом программировании крайне важно взвешивать преимущества и недостатки обоих подходов и выбирать подходящий метод с учетом контекста.</p>","path":["Глава 2. Анализ сложности","2.2 &nbsp; Итерация и рекурсия"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   Оценка эффективности алгоритмов","text":"<p>В процессе разработки алгоритмов мы стремимся к достижению следующих целей.</p> <ol> <li>Найти решение задачи: алгоритм должен надежно находить правильное решение задачи в заданных пределах входных данных.</li> <li>Найти оптимальное решение: для одной и той же задачи может существовать несколько решений, и мы стремимся найти максимально эффективный алгоритм.</li> </ol> <p>Таким образом, при условии возможности решения задачи эффективность алгоритма становится основным критерием его оценки, который включает два аспекта.</p> <ul> <li>Временная эффективность: продолжительность выполнения алгоритма.</li> <li>Пространственная эффективность: объем памяти, занимаемой алгоритмом.</li> </ul> <p>В двух словах, наша цель - разработка быстрых и экономных структур данных и алгоритмов. Эффективная оценка алгоритмов крайне важна, так как только так можно сравнивать различные алгоритмы и управлять процессом их разработки и оптимизации.</p> <p>Методы оценки эффективности делятся на два типа: практическое тестирование и теоретическую оценку.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   Практическое тестирование","text":"<p>Предположим, у нас есть алгоритмы <code>A</code> и <code>B</code>, которые решают одну и ту же задачу, и необходимо сравнить их эффективность. Самый прямой метод - это запустить оба алгоритма на компьютере и зафиксировать время их выполнения и объем используемой памяти. Этот метод отражает реальную ситуацию, но имеет значительные ограничения.</p> <p>С одной стороны, сложно исключить влияние факторов тестовой среды. Аппаратная конфигурация влияет на производительность алгоритма. Например, если алгоритм обладает высокой степенью параллелизма, он будет лучше работать на многоядерных CPU; если алгоритм интенсивно использует память, его производительность будет выше на высокопроизводительной памяти. Это означает, что результаты тестирования на разных машинах могут значительно отличаться, а для получения средней эффективности пришлось бы тестировать на различных платформах, что крайне затруднительно.</p> <p>С другой стороны, проведение полного тестирования требует значительных ресурсов. С изменением объема входных данных алгоритмы демонстрируют разную эффективность. Например, при небольшом объеме данных алгоритм <code>A</code> может работать быстрее, чем алгоритм <code>B</code>, но при большом объеме данных результат может быть противоположным. Следовательно, для получения убедительных выводов необходимо тестировать различные масштабы входных данных, что требует значительных вычислительных ресурсов.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   Теоретическая оценка","text":"<p>Из-за значительных ограничений практического тестирования можно рассмотреть возможность оценки эффективности алгоритмов только с помощью вычислений. Такой метод называется анализом асимптотической сложности (asymptotic complexity analysis), или сокращенно анализом сложности.</p> <p>Анализ сложности позволяет отразить зависимость между ресурсами времени и пространства, необходимыми для выполнения алгоритма, и размером входных данных. Он описывает тенденцию роста времени и пространства, необходимых для выполнения алгоритма, по мере увеличения размера входных данных. Это определение может показаться сложным, но его можно разбить на три ключевых момента.</p> <ul> <li>\"Ресурсы времени и пространства\" соответствуют временной сложности (time complexity) и пространственной сложности (space complexity).</li> <li>\"По мере увеличения размера входных данных\" означает, что сложность отражает зависимость эффективности алгоритма от объема входных данных.</li> <li>\"Тенденция роста времени и пространства\" указывает, что анализ сложности фокусируется не на конкретных значениях времени выполнения или объема занимаемой памяти, а на скорости их роста.</li> </ul> <p>Анализ сложности преодолевает недостатки метода практического тестирования, что выражается в следующих аспектах.</p> <ul> <li>Он не требует фактического выполнения кода, что делает его более экологичным и энергосберегающим.</li> <li>Он независим от тестовой среды, а результаты анализа применимы ко всем платформам выполнения.</li> <li>Он может продемонстрировать эффективность алгоритма при различных объемах данных, особенно при больших объемах.</li> </ul> <p>Tip</p> <p>Если понятие сложности пока все еще кажется вам запутанным, не переживайте: мы подробно разберем его в следующих разделах.</p> <p>Анализ сложности предоставляет нам мерило оценки эффективности алгоритмов, позволяя измерять время и ресурсы, необходимые для выполнения конкретного алгоритма, а также сравнивать эффективность различных алгоритмов.</p> <p>Сложность - это математическое понятие, которое новичкам может показаться абстрактным и сложным для изучения. С этой точки зрения анализ сложности не то, с чего стоит начинать изучение алгоритмов. Однако, обсуждая особенности той или иной структуры данных или алгоритма, невозможно избежать анализа их скорости выполнения и использования памяти.</p> <p>Таким образом, перед погружением в изучение структур данных и алгоритмов рекомендуется получить базовое представление об анализе сложности, чтобы иметь возможность выполнять хотя бы базовую оценку их эффективности.</p>","path":["Глава 2. Анализ сложности","2.1 &nbsp; Оценка эффективности алгоритмов"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   Пространственная сложность","text":"<p>Пространственная сложность (space complexity) служит для оценки того, как меняется объем памяти, требуемой алгоритму, по мере роста объема данных. Это понятие очень похоже на временную сложность, только вместо времени выполнения рассматривается объем используемой памяти.</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   Пространство, связанное с алгоритмом","text":"<p>Память, которую использует алгоритм во время работы, в основном делится на следующие части.</p> <ul> <li>Входное пространство: используется для хранения входных данных алгоритма.</li> <li>Временное пространство: используется для хранения переменных, объектов, контекста функций и других данных, возникающих во время выполнения алгоритма.</li> <li>Выходное пространство: используется для хранения выходных данных алгоритма.</li> </ul> <p>Как правило, при анализе пространственной сложности в расчет включают временное пространство и выходное пространство.</p> <p>Временное пространство можно дополнительно разделить на три части.</p> <ul> <li>Временные данные: используются для хранения различных констант, переменных, объектов и т.д., возникающих во время выполнения алгоритма.</li> <li>Пространство кадров стека: используется для хранения контекстных данных вызываемых функций. При каждом вызове функции система создает на вершине стека новый кадр; после возврата функции пространство этого кадра освобождается.</li> <li>Пространство инструкций: используется для хранения скомпилированных инструкций программы и в реальном подсчете обычно не учитывается.</li> </ul> <p>При анализе пространственной сложности программы обычно учитываются временные данные, пространство стека и выходные данные, как показано на рисунке 2-15.</p> <p></p> <p> Рисунок 2-15   Пространство, используемое алгоритмом </p> <p>Ниже приведен соответствующий код:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"Класс\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # Значение узла\n        self.next: Node | None = None  # Ссылка на следующий узел\n\ndef function() -&gt; int:\n    \"\"\"Функция\"\"\"\n    # Выполнить некоторые операции...\n    return 0\n\ndef algorithm(n) -&gt; int:  # Входные данные\n    A = 0                 # Временные данные (константа, обычно обозначается заглавной буквой)\n    b = 0                 # Временные данные (переменная)\n    node = Node(0)        # Временные данные (объект)\n    c = function()        # Пространство кадра стека (вызов функции)\n    return A + b + c      # Выходные данные\n</code></pre> <pre><code>/* Структура */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Функция */\nint func() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) {        // Входные данные\n    const int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node* node = new Node(0); // Временные данные (объект)\n    int c = func();           // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Функция */\nint function() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) {        // Входные данные\n    final int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node node = new Node(0);  // Временные данные (объект)\n    int c = function();       // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* Функция */\nint Function() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint Algorithm(int n) {        // Входные данные\n    const int a = 0;          // Временные данные (константа)\n    int b = 0;                // Временные данные (переменная)\n    Node node = new(0);       // Временные данные (объект)\n    int c = Function();       // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Структура */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Создать структуру node */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* Функция */\nfunc function() int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfunc algorithm(n int) int { // Входные данные\n    const a = 0             // Временные данные (константа)\n    b := 0                  // Временные данные (переменная)\n    newNode(0)              // Временные данные (объект)\n    c := function()         // Пространство кадра стека (вызов функции)\n    return a + b + c        // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Функция */\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // Входные данные\n    let a = 0             // Временные данные (константа)\n    var b = 0             // Временные данные (переменная)\n    let node = Node(x: 0) // Временные данные (объект)\n    let c = function()    // Пространство кадра стека (вызов функции)\n    return a + b + c      // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.next = null;                       // Ссылка на следующий узел\n    }\n}\n\n/* Функция */\nfunction constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\nfunction algorithm(n) {       // Входные данные\n    const a = 0;              // Временные данные (константа)\n    let b = 0;                // Временные данные (переменная)\n    const node = new Node(0); // Временные данные (объект)\n    const c = constFunc();    // Пространство кадра стека (вызов функции)\n    return a + b + c;         // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.next = null;                       // Ссылка на следующий узел\n    }\n}\n\n/* Функция */\nfunction constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n\nfunction algorithm(n: number): number { // Входные данные\n    const a = 0;                        // Временные данные (константа)\n    let b = 0;                          // Временные данные (переменная)\n    const node = new Node(0);           // Временные данные (объект)\n    const c = constFunc();              // Пространство кадра стека (вызов функции)\n    return a + b + c;                   // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Функция */\nint function() {\n  // Выполнить некоторые операции...\n  return 0;\n}\n\nint algorithm(int n) {  // Входные данные\n  const int a = 0;      // Временные данные (константа)\n  int b = 0;            // Временные данные (переменная)\n  Node node = Node(0);  // Временные данные (объект)\n  int c = function();   // Пространство кадра стека (вызов функции)\n  return a + b + c;     // Выходные данные\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* Создать структуру Node */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Функция */\nfn function() -&gt; i32 {      \n    // Выполнить некоторые операции...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // Входные данные\n    const a: i32 = 0;               // Временные данные (константа)\n    let mut b = 0;                  // Временные данные (переменная)\n    let node = Node::new(0);        // Временные данные (объект)\n    let c = function();             // Пространство кадра стека (вызов функции)\n    return a + b + c;               // Выходные данные\n}\n</code></pre> <pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции...\n    return 0;\n}\n\nint algorithm(int n) { // Входные данные\n    const int a = 0;   // Временные данные (константа)\n    int b = 0;         // Временные данные (переменная)\n    int c = func();    // Пространство кадра стека (вызов функции)\n    return a + b + c;  // Выходные данные\n}\n</code></pre> <pre><code>/* Класс */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* Функция */\nfun function(): Int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // Входные данные\n    val a = 0                // Временные данные (константа)\n    var b = 0                // Временные данные (переменная)\n    val node = Node(0)       // Временные данные (объект)\n    val c = function()       // Пространство кадра стека (вызов функции)\n    return a + b + c         // Выходные данные\n}\n</code></pre> <pre><code>### Класс ###\nclass Node\n    attr_accessor :val      # Значение узла\n    attr_accessor :next     # Ссылка на следующий узел\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### Функция ###\ndef function\n    # Выполнить некоторые операции...\n    0\nend\n\n### Алгоритм ###\ndef algorithm(n)        # Входные данные\n    a = 0               # Временные данные (константа)\n    b = 0               # Временные данные (переменная)\n    node = Node.new(0)  # Временные данные (объект)\n    c = function        # Пространство кадра стека (вызов функции)\n    a + b + c           # Выходные данные\nend\n</code></pre>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   Метод вывода","text":"<p>Метод вывода пространственной сложности в целом аналогичен выводу временной сложности: меняется только объект подсчета, с количества операций на размер используемого пространства.</p> <p>В отличие от временной сложности, обычно рассматривается только худшая пространственная сложность. Это связано с тем, что память является жестким ограничением: необходимо гарантировать, что для любых входных данных у программы будет достаточно памяти.</p> <p>Рассмотрим следующий код. Понятие худшей пространственной сложности здесь имеет два значения.</p> <ol> <li>Ориентир на худшие входные данные: когда \\(n &lt; 10\\) , пространственная сложность равна \\(O(1)\\) ; но когда \\(n &gt; 10\\) , инициализированный массив <code>nums</code> занимает \\(O(n)\\) пространства, поэтому худшая пространственная сложность равна \\(O(n)\\) .</li> <li>Ориентир на пиковое использование памяти во время выполнения: например, до выполнения последней строки программа занимает \\(O(1)\\) пространства; при инициализации массива <code>nums</code> она занимает \\(O(n)\\) пространства, поэтому худшая пространственная сложность также равна \\(O(n)\\) .</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>В рекурсивных функциях необходимо учитывать пространство кадров стека. Рассмотрим следующий код:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # Выполнить некоторые операции\n    return 0\n\ndef loop(n: int):\n    \"\"\"Пространственная сложность цикла равна O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Пространственная сложность рекурсии равна O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Пространственная сложность цикла равна O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* Пространственная сложность рекурсии равна O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Пространственная сложность цикла равна O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* Пространственная сложность рекурсии равна O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // Выполнить некоторые операции\n  return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n/* Пространственная сложность цикла равна O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // Выполнить некоторые операции\n    return 0\n}\n/* Пространственная сложность цикла равна O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* Пространственная сложность рекурсии равна O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # Выполнить некоторые операции\n    0\nend\n\n### Пространственная сложность цикла равна O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### Пространственная сложность рекурсии равна O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>Функции <code>loop()</code> и <code>recur()</code> имеют временную сложность \\(O(n)\\) , но их пространственная сложность различается.</p> <ul> <li>Функция <code>loop()</code> вызывает <code>function()</code> в цикле \\(n\\) раз; на каждой итерации <code>function()</code> возвращается и освобождает пространство своего кадра стека, поэтому пространственная сложность по-прежнему равна \\(O(1)\\) .</li> <li>Рекурсивная функция <code>recur()</code> во время выполнения одновременно содержит \\(n\\) еще не завершившихся экземпляров <code>recur()</code> , поэтому занимает \\(O(n)\\) пространства кадров стека.</li> </ul>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   Распространенные типы","text":"<p>Пусть размер входных данных равен \\(n\\) . На рисунке 2-16 показаны распространенные типы пространственной сложности в порядке от меньшей к большей.</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{Постоянная} &lt; \\text{Логарифмическая} &lt; \\text{Линейная} &lt; \\text{Квадратичная} &lt; \\text{Экспоненциальная} \\end{aligned} \\] <p></p> <p> Рисунок 2-16   Распространенные типы пространственной сложности </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   Постоянная сложность \\(O(1)\\)","text":"<p>Постоянная сложность обычно встречается у констант, переменных и объектов, количество которых не зависит от размера входных данных \\(n\\) .</p> <p>Следует заметить, что память, занятая инициализацией переменных или вызовом функций внутри цикла, освобождается при переходе к следующей итерации, поэтому она не накапливается, и пространственная сложность по-прежнему остается \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"Функция\"\"\"\n    # Выполнить некоторые операции\n    return 0\n\ndef constant(n: int):\n    \"\"\"Постоянная сложность\"\"\"\n    # Константы, переменные и объекты занимают O(1) памяти\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # Переменные в цикле занимают O(1) памяти\n    for _ in range(n):\n        c = 0\n    # Функции в цикле занимают O(1) памяти\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Функция */\nint function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Функция */\nint Function() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid Constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Функция */\nfunc function() int {\n    // Выполнить некоторые операции...\n    return 0\n}\n\n/* Постоянная сложность */\nfunc spaceConstant(n int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // Переменные в цикле занимают O(1) памяти\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* Функция */\n@discardableResult\nfunc function() -&gt; Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Постоянная сложность */\nfunc constant(n: Int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // Переменные в цикле занимают O(1) памяти\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* Функция */\nfunction constFunc() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nfunction constant(n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Функция */\nfunction constFunc(): number {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nfunction constant(n: number): void {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // Переменные в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Функция */\nint function() {\n  // Выполнить некоторые операции\n  return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n  // Константы, переменные и объекты занимают O(1) памяти\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // Переменные в цикле занимают O(1) памяти\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // Функции в цикле занимают O(1) памяти\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Функция */\nfn function() -&gt; i32 {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\n#[allow(unused)]\nfn constant(n: i32) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // Переменные в цикле занимают O(1) памяти\n    for i in 0..n {\n        let c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Функция */\nint func() {\n    // Выполнить некоторые операции\n    return 0;\n}\n\n/* Постоянная сложность */\nvoid constant(int n) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // Переменные в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Функция */\nfun function(): Int {\n    // Выполнить некоторые операции\n    return 0\n}\n\n/* Постоянная сложность */\nfun constant(n: Int) {\n    // Константы, переменные и объекты занимают O(1) памяти\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // Переменные в цикле занимают O(1) памяти\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // Функции в цикле занимают O(1) памяти\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Функция ###\ndef function\n  # Выполнить некоторые операции\n  0\nend\n\n### Постоянная сложность ###\ndef constant(n)\n  # Константы, переменные и объекты занимают O(1) памяти\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # Переменные в цикле занимают O(1) памяти\n  (0...n).each { c = 0 }\n  # Функции в цикле занимают O(1) памяти\n  (0...n).each { function }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   Линейная сложность \\(O(n)\\)","text":"<p>Линейная сложность часто встречается у массивов, списков, стеков, очередей и других структур, число элементов в которых пропорционально \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"Линейная сложность\"\"\"\n    # Список длины n занимает O(n) памяти\n    nums = [0] * n\n    # Хеш-таблица длины n занимает O(n) памяти\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    vector&lt;int&gt; nums(n);\n    // Список длины n занимает O(n) памяти\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int[] nums = new int[n];\n    // Список длины n занимает O(n) памяти\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Линейная сложность */\nvoid Linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int[] nums = new int[n];\n    // Список длины n занимает O(n) памяти\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Линейная сложность */\nfunc spaceLinear(n int) {\n    // Массив длины n занимает O(n) памяти\n    _ = make([]int, n)\n    // Список длины n занимает O(n) памяти\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Линейная сложность */\nfunc linear(n: Int) {\n    // Массив длины n занимает O(n) памяти\n    let nums = Array(repeating: 0, count: n)\n    // Список длины n занимает O(n) памяти\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // Хеш-таблица длины n занимает O(n) памяти\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* Линейная сложность */\nfunction linear(n) {\n    // Массив длины n занимает O(n) памяти\n    const nums = new Array(n);\n    // Список длины n занимает O(n) памяти\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Линейная сложность */\nfunction linear(n: number): void {\n    // Массив длины n занимает O(n) памяти\n    const nums = new Array(n);\n    // Список длины n занимает O(n) памяти\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Линейная сложность */\nvoid linear(int n) {\n  // Массив длины n занимает O(n) памяти\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // Список длины n занимает O(n) памяти\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // Хеш-таблица длины n занимает O(n) памяти\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Линейная сложность */\n#[allow(unused)]\nfn linear(n: i32) {\n    // Массив длины n занимает O(n) памяти\n    let mut nums = vec![0; n as usize];\n    // Список длины n занимает O(n) памяти\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Хеш-таблица */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Реализовано на основе uthash.h\n} HashTable;\n\n/* Линейная сложность */\nvoid linear(int n) {\n    // Массив длины n занимает O(n) памяти\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // Список длины n занимает O(n) памяти\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // Освобождение памяти\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // Хеш-таблица длины n занимает O(n) памяти\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // Освобождение памяти\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* Линейная сложность */\nfun linear(n: Int) {\n    // Массив длины n занимает O(n) памяти\n    val nums = Array(n) { 0 }\n    // Список длины n занимает O(n) памяти\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // Хеш-таблица длины n занимает O(n) памяти\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  # Список длины n занимает O(n) памяти\n  nums = Array.new(n, 0)\n\n  # Хеш-таблица длины n занимает O(n) памяти\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 2-17, глубина рекурсии этой функции равна \\(n\\) , то есть одновременно существует \\(n\\) еще не завершившихся функций <code>linear_recur()</code> , которые используют \\(O(n)\\) пространства кадров стека:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"Линейная сложность (рекурсивная реализация)\"\"\"\n    print(\"Рекурсия n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"Рекурсия n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    System.out.println(\"Рекурсия n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"Рекурсия n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"Рекурсия n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunc linearRecur(n: Int) {\n    print(\"Рекурсия n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunction linearRecur(n) {\n    console.log(`Рекурсия n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfunction linearRecur(n: number): void {\n    console.log(`Рекурсия n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n  print('Рекурсия n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfn linear_recur(n: i32) {\n    println!(\"Рекурсия n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Линейная сложность (рекурсивная реализация) */\nvoid linearRecur(int n) {\n    printf(\"Рекурсия n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* Линейная сложность (рекурсивная реализация) */\nfun linearRecur(n: Int) {\n    println(\"Рекурсия n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  # Список длины n занимает O(n) памяти\n  nums = Array.new(n, 0)\n\n  # Хеш-таблица длины n занимает O(n) памяти\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n\n# ## Линейная сложность (рекурсивная реализация) ###\ndef linear_recur(n)\n  puts \"Рекурсия n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-17   Линейная пространственная сложность, порождаемая рекурсивной функцией </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   Квадратичная сложность \\(O(n^2)\\)","text":"<p>Квадратичная сложность часто встречается у матриц и графов, где число элементов связано с \\(n\\) квадратичной зависимостью:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"Квадратичная сложность\"\"\"\n    # Двумерный список занимает O(n^2) памяти\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Двумерный список занимает O(n^2) памяти\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Матрица занимает O(n^2) памяти\n    int[][] numMatrix = new int[n][n];\n    // Двумерный список занимает O(n^2) памяти\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* Квадратичная сложность */\nvoid Quadratic(int n) {\n    // Матрица занимает O(n^2) памяти\n    int[,] numMatrix = new int[n, n];\n    // Двумерный список занимает O(n^2) памяти\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* Квадратичная сложность */\nfunc spaceQuadratic(n int) {\n    // Матрица занимает O(n^2) памяти\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* Квадратичная сложность */\nfunc quadratic(n: Int) {\n    // Двумерный список занимает O(n^2) памяти\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* Квадратичная сложность */\nfunction quadratic(n) {\n    // Матрица занимает O(n^2) памяти\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // Двумерный список занимает O(n^2) памяти\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* Квадратичная сложность */\nfunction quadratic(n: number): void {\n    // Матрица занимает O(n^2) памяти\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // Двумерный список занимает O(n^2) памяти\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n  // Матрица занимает O(n^2) памяти\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // Двумерный список занимает O(n^2) памяти\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* Квадратичная сложность */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // Матрица занимает O(n^2) памяти\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // Двумерный список занимает O(n^2) памяти\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* Квадратичная сложность */\nvoid quadratic(int n) {\n    // Двумерный список занимает O(n^2) памяти\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // Освобождение памяти\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* Квадратичная сложность */\nfun quadratic(n: Int) {\n    // Матрица занимает O(n^2) памяти\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // Двумерный список занимает O(n^2) памяти\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 2-18, глубина рекурсии этой функции равна \\(n\\) , и в каждой рекурсивной функции инициализируется массив длины \\(n\\) , \\(n-1\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) ; его средняя длина равна \\(n / 2\\) , поэтому в сумме используется \\(O(n^2)\\) пространства:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"Квадратичная сложность (рекурсивная реализация)\"\"\"\n    if n &lt;= 0:\n        return 0\n    # Длина массива nums равна n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"Рекурсия n = \" &lt;&lt; n &lt;&lt; \" , длина nums = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"В рекурсии n = \" + n + \", длина nums = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"В рекурсии n = \" + n + \", длина nums = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"В рекурсии n = %d, длина nums = %d\\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"В рекурсии n = \\(n), длина nums = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`В рекурсии n = ${n} длина nums = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`В рекурсии n = ${n} длина nums = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('В рекурсии n = $n длина nums = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"В рекурсии n = {} , длина nums = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"Рекурсия n = %d, длина nums = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* Квадратичная сложность (рекурсивная реализация) */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // Длина массива nums равна n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"В рекурсии n = $n длина nums = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## Квадратичная сложность (рекурсивная реализация) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Длина массива nums равна n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-18   Квадратичная пространственная сложность, порождаемая рекурсивной функцией </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   Экспоненциальная сложность \\(O(2^n)\\)","text":"<p>Экспоненциальная сложность часто встречается у бинарных деревьев. Полное бинарное дерево с \\(n\\) уровнями содержит \\(2^n - 1\\) узлов и занимает \\(O(2^n)\\) пространства:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"Экспоненциальная сложность (построение полного двоичного дерева)\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* Экспоненциальная сложность (построение полного двоичного дерева) */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  # Двумерный список занимает O(n^2) памяти\n  Array.new(n) { Array.new(n, 0) }\nend\n\n# ## Квадратичная сложность (рекурсивная реализация) ###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # Длина массива nums равна n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n\n# ## Экспоненциальная сложность (построение полного двоичного дерева) ###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-19   Экспоненциальная пространственная сложность, порождаемая полным бинарным деревом </p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   Логарифмическая сложность \\(O(\\log n)\\)","text":"<p>Логарифмическая сложность часто встречается в алгоритмах \"разделяй и властвуй\". Например, при сортировке слиянием входной массив длины \\(n\\) на каждом шаге рекурсии делится пополам, образуя рекурсивное дерево высоты \\(\\log n\\) и используя \\(O(\\log n)\\) пространства кадров стека.</p> <p>Еще один пример - преобразование числа в строку. Если задано положительное целое число \\(n\\) , то количество его цифр равно \\(\\lfloor \\log_{10} n \\rfloor + 1\\) , то есть длина соответствующей строки тоже равна \\(\\lfloor \\log_{10} n \\rfloor + 1\\) , следовательно, пространственная сложность составляет \\(O(\\log_{10} n + 1) = O(\\log n)\\) .</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   Компромисс между временем и пространством","text":"<p>В идеальных условиях хотелось бы, чтобы и временная, и пространственная сложность алгоритма были оптимальными. Однако на практике одновременно оптимизировать и время, и память обычно очень трудно.</p> <p>Снижение временной сложности обычно достигается ценой увеличения пространственной сложности, и наоборот. Подход, при котором жертвуют памятью ради ускорения работы алгоритма, называется обменом пространства на время; обратный подход называется обменом времени на пространство.</p> <p>Выбор между этими двумя идеями зависит от того, что важнее в конкретной задаче. В большинстве случаев время ценнее памяти, поэтому стратегия обмена пространства на время используется чаще. Но при очень больших объемах данных контроль пространственной сложности тоже становится крайне важным.</p>","path":["Глава 2. Анализ сложности","2.4 &nbsp; Пространственная сложность"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   Резюме","text":"","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<p>Оценка эффективности алгоритмов</p> <ul> <li>Временная и пространственная эффективность являются двумя основными критериями для оценки качества алгоритмов.</li> <li>Эффективность алгоритмов можно оценивать с помощью практических тестов, однако это сложно из-за влияния тестовой среды и значительных затрат вычислительных ресурсов.</li> <li>Анализ сложности позволяет устранить недостатки практических тестов, а результаты анализа применимы ко всем платформам и могут выявить эффективность алгоритма при различных объемах данных.</li> </ul> <p>Временная сложность</p> <ul> <li>Временная сложность используется для оценки тенденции изменения времени выполнения алгоритма с увеличением объема данных, что позволяет оценивать его эффективность. Однако в некоторых случаях она может работать не так хорошо, например когда объем входных данных мал или временная сложность одинакова, что не позволяет точно сравнить эффективность алгоритмов.</li> <li>Худшая временная сложность обозначается символом Big \\(O\\) и соответствует асимптотической верхней границе, отражая уровень роста количества операций \\(T(n)\\) при стремлении \\(n\\) к бесконечности.</li> <li>Определение временной сложности включает два этапа: сначала подсчитывается количество операций, затем определяется асимптотическая верхняя граница.</li> <li>Наиболее распространенные временные сложности в порядке возрастания: \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\) и \\(O(n!)\\).</li> <li>Временная сложность некоторых алгоритмов не является фиксированной и зависит от распределения входных данных. Временная сложность делится на худшую, лучшую и среднюю. Лучшая временная сложность почти не используется, так как для достижения лучшего случая входные данные должны соответствовать строгим критериям.</li> <li>Средняя временная сложность отражает эффективность алгоритма при случайных входных данных и наиболее близка к реальной производительности алгоритма. Для расчета средней временной сложности необходимо учитывать распределение входных данных и математическое ожидание.</li> </ul> <p>Пространственная сложность</p> <ul> <li>Пространственная сложность аналогична временной сложности и используется для оценки тенденции изменения объема памяти, занимаемой алгоритмом, с увеличением объема данных.</li> <li>Память, используемую в процессе выполнения алгоритма, можно разделить на входное пространство, временное пространство и выходное пространство. Обычно при расчете пространственной сложности входное пространство не учитывается. Временное пространство делится на временные данные, пространство стека и пространство инструкций, причем пространство стека обычно влияет на сложность только в рекурсивных функциях.</li> <li>Обычно рассматривается только худшая пространственная сложность, то есть пространственная сложность алгоритма при худших входных данных и в худший момент выполнения.</li> <li>Наиболее распространенные пространственные сложности в порядке возрастания: \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\) и \\(O(2^n)\\).</li> </ul>","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Является ли пространственная сложность хвостовой рекурсии равной \\(O(1)\\)?</p> <p>Теоретически пространственную сложность хвостово-рекурсивных функций можно оптимизировать до \\(O(1)\\) . Однако большинство языков программирования (например Java, Python, C++, Go, C# и другие) не поддерживают автоматическую оптимизацию хвостовой рекурсии, поэтому на практике пространственная сложность обычно считается равной \\(O(n)\\) .</p> <p>Q: В чем разница между терминами function и method?</p> <p>Функция (function) может выполняться независимо, и все ее параметры передаются явно. Метод (method) связан с объектом, неявно получает объект, который его вызывает, и может работать с данными, содержащимися в экземпляре класса.</p> <p>Ниже это проиллюстрировано на примере нескольких распространенных языков программирования.</p> <ul> <li>C - процедурный язык программирования без объектно-ориентированной модели, поэтому в нем есть только функции. Однако мы можем имитировать объектно-ориентированное программирование через структуры (<code>struct</code>), и функции, связанные со структурами, эквивалентны методам в других языках.</li> <li>Java и C# - объектно-ориентированные языки программирования, в которых блоки кода (методы) обычно являются частью класса. Статические методы по поведению похожи на функции, потому что они привязаны к классу и не могут обращаться к конкретным переменным экземпляра.</li> <li>C++ и Python поддерживают как процедурное программирование (функции), так и объектно-ориентированное программирование (методы).</li> </ul> <p>Q: Отражает ли диаграмма \"распространенных типов пространственной сложности\" абсолютный размер занятой памяти?</p> <p>Нет, эта диаграмма показывает пространственную сложность, а значит отражает именно тенденцию роста, а не абсолютный объем занятого пространства.</p> <p>Если взять \\(n = 8\\) , можно заметить, что значения на кривых не совпадают напрямую с соответствующими функциями. Это связано с тем, что каждая кривая содержит константный член, который сжимает диапазон значений до визуально удобного масштаба.</p> <p>На практике, поскольку мы обычно не знаем, какова \"константная\" сложность каждого метода, только по сложности мы, как правило, не можем выбрать оптимальное решение для случая \\(n = 8\\) . Но для \\(n = 8^5\\) выбор уже очевиден: в этой области доминирует именно тенденция роста.</p> <p>Q: Бывают ли случаи, когда в реальных сценариях алгоритм специально проектируют так, чтобы жертвовать временем ради пространства или пространством ради времени?</p> <p>На практике в большинстве случаев выбирают обмен пространства на время. Например, для индексов в базах данных обычно строят B+ деревья или хеш-индексы, расходуя значительный объем памяти ради эффективных запросов уровня \\(O(\\log n)\\) или даже \\(O(1)\\).</p> <p>В сценариях, где память особенно дорога, наоборот, могут жертвовать временем ради пространства. Например, в embedded-разработке память устройства очень ограничена, поэтому инженеры могут отказаться от хеш-таблиц и выбрать последовательный поиск по массиву, экономя память ценой более медленного поиска.</p>","path":["Глава 2. Анализ сложности","2.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   Временная сложность","text":"<p>Время выполнения действительно может наглядно и точно отражать эффективность алгоритма. Но если мы захотим точно оценить время работы некоторого фрагмента кода, то столкнемся со следующими шагами.</p> <ol> <li>Определить платформу выполнения, включая конфигурацию оборудования, язык программирования, системную среду и т.д., поскольку все эти факторы влияют на эффективность выполнения кода.</li> <li>Оценить время выполнения различных вычислительных операций, например операция сложения <code>+</code> требует 1 нс , операция умножения <code>*</code> требует 10 нс , операция вывода <code>print()</code> требует 5 нс и т.д.</li> <li>Подсчитать все вычислительные операции в коде и суммировать время выполнения всех операций, чтобы получить общее время работы.</li> </ol> <p>Например, в следующем коде размер входных данных равен \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># На некоторой платформе выполнения\ndef algorithm(n: int):\n    a = 2      # 1 нс\n    a = a + 1  # 1 нс\n    a = a * 2  # 10 нс\n    # Цикл выполняется n раз\n    for _ in range(n):  # 1 нс\n        print(0)        # 5 нс\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        System.out.println(0);     // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid Algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {  // 1 нс\n        Console.WriteLine(0);      // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunc algorithm(n int) {\n    a := 2     // 1 нс\n    a = a + 1  // 1 нс\n    a = a * 2  // 10 нс\n    // Цикл выполняется n раз\n    for i := 0; i &lt; n; i++ {  // 1 нс\n        fmt.Println(a)        // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunc algorithm(n: Int) {\n    var a = 2 // 1 нс\n    a = a + 1 // 1 нс\n    a = a * 2 // 10 нс\n    // Цикл выполняется n раз\n    for _ in 0 ..&lt; n { // 1 нс\n        print(0) // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunction algorithm(n) {\n    var a = 2; // 1 нс\n    a = a + 1; // 1 нс\n    a = a * 2; // 10 нс\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++) { // 1 нс\n        console.log(0); // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 нс\n    a = a + 1; // 1 нс\n    a = a * 2; // 10 нс\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++) { // 1 нс\n        console.log(0); // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n  int a = 2; // 1 нс\n  a = a + 1; // 1 нс\n  a = a * 2; // 10 нс\n  // Цикл выполняется n раз\n  for (int i = 0; i &lt; n; i++) { // 1 нс\n    print(0); // 5 нс\n  }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 нс\n    a = a + 1;          // 1 нс\n    a = a * 2;          // 10 нс\n    // Цикл выполняется n раз\n    for _ in 0..n {     // 1 нс\n        println!(\"{}\", 0);  // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nvoid algorithm(int n) {\n    int a = 2;  // 1 нс\n    a = a + 1;  // 1 нс\n    a = a * 2;  // 10 нс\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // 1 нс\n        printf(\"%d\", 0);            // 5 нс\n    }\n}\n</code></pre> <pre><code>// На некоторой платформе выполнения\nfun algorithm(n: Int) {\n    var a = 2 // 1 нс\n    a = a + 1 // 1 нс\n    a = a * 2 // 10 нс\n    // Цикл выполняется n раз\n    for (i in 0..&lt;n) {  // 1 нс\n        println(0)      // 5 нс\n    }\n}\n</code></pre> <pre><code># На некоторой платформе выполнения\ndef algorithm(n)\n    a = 2       # 1 нс\n    a = a + 1   # 1 нс\n    a = a * 2   # 10 нс\n    # Цикл выполняется n раз\n    (0...n).each do # 1 нс\n        puts 0      # 5 нс\n    end\nend\n</code></pre> <p>Согласно приведенному выше методу, время работы алгоритма равно \\((6n + 12)\\) нс :</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>Но на практике подсчитывать реальное время выполнения алгоритма и неразумно, и нереалистично. Во-первых, мы не хотим привязывать оценку времени к конкретной платформе, потому что алгоритм должен запускаться на самых разных платформах. Во-вторых, нам трудно определить время выполнения каждого типа операций, а это делает точную оценку крайне затруднительной.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   Подсчет тенденции роста времени","text":"<p>Анализ временной сложности оценивает не само время выполнения алгоритма, а тенденцию роста этого времени по мере увеличения объема данных.</p> <p>Понятие \"тенденции роста времени\" выглядит довольно абстрактным, поэтому разберем его на примере. Предположим, размер входных данных равен \\(n\\) , и даны три алгоритма <code>A</code> , <code>B</code> и <code>C</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Временная сложность алгоритма A: постоянная\ndef algorithm_A(n: int):\n    print(0)\n# Временная сложность алгоритма B: линейная\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Временная сложность алгоритма C: постоянная\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Временная сложность алгоритма B: линейная\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Временная сложность алгоритма B: линейная\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// Временная сложность алгоритма C: постоянная\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Временная сложность алгоритма B: линейная\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Временная сложность алгоритма B: линейная\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithmA(int n) {\n  print(0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Временная сложность алгоритма B: линейная\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Временная сложность алгоритма B: линейная\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Временная сложность алгоритма C: постоянная\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// Временная сложность алгоритма A: постоянная\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// Временная сложность алгоритма B: линейная\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// Временная сложность алгоритма C: постоянная\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># Временная сложность алгоритма A: постоянная\ndef algorithm_A(n)\n    puts 0\nend\n\n# Временная сложность алгоритма B: линейная\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# Временная сложность алгоритма C: постоянная\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>Ниже показаны временные сложности трех приведенных выше функций.</p> <ul> <li>У алгоритма <code>A</code> есть только одна операция вывода, и время его работы не растет с увеличением \\(n\\) . Такую временную сложность называют постоянной.</li> <li>В алгоритме <code>B</code> операция вывода выполняется в цикле \\(n\\) раз, поэтому время работы растет линейно по мере увеличения \\(n\\) . Такая временная сложность называется линейной.</li> <li>В алгоритме <code>C</code> операция вывода выполняется \\(1000000\\) раз; хотя время работы велико, оно не зависит от размера входных данных \\(n\\) . Поэтому временная сложность <code>C</code> такая же, как у <code>A</code> , и тоже является постоянной.</li> </ul> <p></p> <p> Рисунок 2-7   Тенденции роста времени для алгоритмов A, B и C </p> <p>Какие особенности имеет анализ временной сложности по сравнению с непосредственным измерением времени работы алгоритма?</p> <ul> <li>Временная сложность позволяет эффективно оценивать эффективность алгоритма. Например, время работы алгоритма <code>B</code> растет линейно: при \\(n &gt; 1\\) он медленнее алгоритма <code>A</code> , а при \\(n &gt; 1000000\\) медленнее алгоритма <code>C</code> . Если размер входных данных достаточно велик, алгоритм с постоянной сложностью обязательно лучше алгоритма с линейной сложностью. В этом и состоит смысл тенденции роста времени.</li> <li>Метод вывода временной сложности проще. Платформа выполнения и тип вычислительных операций не влияют на тенденцию роста времени работы алгоритма. Поэтому в анализе временной сложности можно считать время выполнения всех вычислительных операций одинаковым единичным временем и тем самым упростить подсчет времени выполнения до подсчета количества операций.</li> <li>У временной сложности есть и определенные ограничения. Например, хотя временная сложность алгоритмов <code>A</code> и <code>C</code> одинакова, их реальное время выполнения сильно различается. Точно так же, хотя временная сложность <code>B</code> выше, чем у <code>C</code> , при малых \\(n\\) алгоритм <code>B</code> очевидно лучше <code>C</code> . Несмотря на эти ограничения, анализ сложности все равно остается самым эффективным и самым распространенным способом оценки алгоритмов.</li> </ul>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   Асимптотическая верхняя граница функции","text":"<p>Для функции с входным размером \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Цикл выполняется n раз\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // +1 (каждый раз выполняется i ++)\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Цикл выполняется n раз\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Цикл выполняется n раз\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++){ // +1 (каждый раз выполняется i ++)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Цикл выполняется n раз\n    for(let i = 0; i &lt; n; i++){ // +1 (каждый раз выполняется i ++)\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Цикл выполняется n раз\n  for (int i = 0; i &lt; n; i++) { // +1 (каждый раз выполняется i ++)\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Цикл выполняется n раз\n    for _ in 0..n { // +1 (каждый раз выполняется i ++)\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Цикл выполняется n раз\n    for (int i = 0; i &lt; n; i++) {   // +1 (каждый раз выполняется i ++)\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Цикл выполняется n раз\n    for (i in 0..&lt;n) { // +1 (каждый раз выполняется i ++)\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # Цикл выполняется n раз\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>Пусть количество операций алгоритма является функцией от размера входных данных \\(n\\) и обозначается как \\(T(n)\\) ; тогда для приведенной выше функции число операций равно:</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) - линейная функция, а это означает, что тенденция роста времени работы линейна, следовательно, временная сложность здесь тоже линейна.</p> <p>Линейную временную сложность записывают как \\(O(n)\\) ; этот математический символ называется нотацией Big \\(O\\) (big-\\(O\\) notation) и обозначает асимптотическую верхнюю границу (asymptotic upper bound) функции \\(T(n)\\) .</p> <p>Иными словами, анализ временной сложности сводится к определению асимптотической верхней границы числа операций \\(T(n)\\), и у этого понятия есть строгое математическое определение.</p> <p>Асимптотическая верхняя граница функции</p> <p>Если существуют положительное действительное число \\(c\\) и действительное число \\(n_0\\) , такие что для всех \\(n &gt; n_0\\) выполняется \\(T(n) \\leq c \\cdot f(n)\\) , то можно считать, что \\(f(n)\\) задает асимптотическую верхнюю границу для \\(T(n)\\) ; это записывается как \\(T(n) = O(f(n))\\) .</p> <p>Как показано на рисунке 2-8, вычислить асимптотическую верхнюю границу - значит найти такую функцию \\(f(n)\\) , что при стремлении \\(n\\) к бесконечности функции \\(T(n)\\) и \\(f(n)\\) имеют один и тот же порядок роста и отличаются только постоянным коэффициентом \\(c\\).</p> <p></p> <p> Рисунок 2-8   Асимптотическая верхняя граница функции </p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   Метод вывода","text":"<p>Математическое определение асимптотической верхней границы выглядит довольно формально, и если оно пока не до конца понятно, переживать не стоит. Сначала можно освоить сам метод вывода, а в процессе дальнейшей практики постепенно почувствовать его математический смысл.</p> <p>Согласно определению, после того как мы определили \\(f(n)\\) , можно получить временную сложность \\(O(f(n))\\) . Но как определить саму асимптотическую верхнюю границу \\(f(n)\\) ? В целом процесс состоит из двух шагов: сначала подсчитать количество операций, затем определить асимптотическую верхнюю границу.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-1","level":3,"title":"1.   Шаг 1: подсчет количества операций","text":"<p>Для кода это можно делать построчно сверху вниз. Однако, поскольку в выражении \\(c \\cdot f(n)\\) постоянный коэффициент \\(c\\) может быть сколь угодно большим, различные коэффициенты и постоянные члены в числе операций \\(T(n)\\) можно игнорировать. Исходя из этого принципа, можно сформулировать следующие упрощающие приемы подсчета.</p> <ol> <li>Игнорировать константы в \\(T(n)\\). Они не зависят от \\(n\\) , а значит не влияют на временную сложность.</li> <li>Опускать все коэффициенты. Например, циклы на \\(2n\\) раз или \\(5n + 1\\) раз можно упростить до \\(n\\) раз, потому что коэффициент перед \\(n\\) не влияет на временную сложность.</li> <li>При вложенных циклах использовать умножение. Общее число операций равно произведению числа операций внешнего и внутреннего циклов; при этом для каждого уровня цикла по-прежнему можно применять приемы из пунктов <code>1.</code> и <code>2.</code> .</li> </ol> <p>Для заданной функции мы можем использовать перечисленные выше приемы и подсчитать число операций:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0 (прием 1)\n    a = a + n  # +0 (прием 1)\n    # +n (прием 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (прием 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0 (прием 1)\n    a = a + n  // +0 (прием 1)\n    // +n (прием 2)\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (прием 3)\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0 (прием 1)\n    a = a + n // +0 (прием 1)\n    // +n (прием 2)\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (прием 3)\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (прием 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (прием 3)\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0 (прием 1)\n  a = a + n; // +0 (прием 1)\n  // +n (прием 2)\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (прием 3)\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (прием 1)\n    a = a + n;        // +0 (прием 1)\n\n    // +n (прием 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (прием 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0 (прием 1)\n    a = a + n;  // +0 (прием 1)\n    // +n (прием 2)\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (прием 3)\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0 (прием 1)\n    a = a + n   // +0 (прием 1)\n    // +n (прием 2)\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n (прием 3)\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0 (прием 1)\n    a = a + n   # +0 (прием 1)\n    # +n (прием 2)\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n (прием 3)\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>Следующая формула показывает результаты подсчета до и после использования перечисленных выше приемов; в обоих случаях выводимая временная сложность равна \\(O(n^2)\\) .</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{полный подсчет (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{ленивый подсчет (o.O)} \\end{aligned} \\]","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-2","level":3,"title":"2.   Шаг 2: определение асимптотической верхней границы","text":"<p>**Временная сложность определяется старшим по степени членом в \\(T(n)\\) **. Это связано с тем, что при стремлении \\(n\\) к бесконечности именно старший член начинает доминировать, а влиянием остальных членов можно пренебречь.</p> <p>В таблице 2-2 приведены несколько примеров. Некоторые значения специально сделаны преувеличенными, чтобы подчеркнуть вывод: коэффициент не способен изменить порядок. Когда \\(n\\) стремится к бесконечности, эти константы становятся несущественными.</p> <p> Таблица 2-2   Временная сложность, соответствующая разному количеству операций </p> Число операций \\(T(n)\\) Временная сложность \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   Распространенные типы","text":"<p>Пусть размер входных данных равен \\(n\\) ; распространенные типы временной сложности показаны на рисунке 2-9 в порядке от меньшей к большей.</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{Постоянная} &lt; \\text{Логарифмическая} &lt; \\text{Линейная} &lt; \\text{Линейно-логарифмическая} &lt; \\text{Квадратичная} &lt; \\text{Экспоненциальная} &lt; \\text{Факториальная} \\end{aligned} \\] <p></p> <p> Рисунок 2-9   Распространенные типы временной сложности </p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   Постоянная сложность \\(O(1)\\)","text":"<p>Число операций при постоянной сложности не зависит от размера входных данных \\(n\\) , то есть не изменяется вместе с изменением \\(n\\) .</p> <p>В следующей функции, хотя число операций <code>size</code> может быть большим, оно не зависит от размера входных данных \\(n\\) , поэтому временная сложность по-прежнему равна \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"Постоянная сложность\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Постоянная сложность */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Постоянная сложность */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Постоянная сложность */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Постоянная сложность */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Постоянная сложность */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Постоянная сложность */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Постоянная сложность */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Постоянная сложность */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Постоянная сложность */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Постоянная сложность ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   Линейная сложность \\(O(n)\\)","text":"<p>Линейная сложность характеризуется тем, что число операций растет линейно относительно размера входных данных \\(n\\) . Линейная сложность обычно встречается в одноуровневых циклах:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"Линейная сложность\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейная сложность */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейная сложность */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейная сложность */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейная сложность */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейная сложность */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейная сложность */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейная сложность */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Линейная сложность */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейная сложность */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Операции обхода массива и обхода связного списка имеют временную сложность \\(O(n)\\) , где \\(n\\) - длина массива или списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"Линейная сложность (обход массива)\"\"\"\n    count = 0\n    # Число итераций пропорционально длине массива\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейная сложность (обход массива) */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейная сложность (обход массива) */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // Число итераций пропорционально длине массива\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейная сложность (обход массива) */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // Число итераций пропорционально длине массива\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейная сложность (обход массива) */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // Число итераций пропорционально длине массива\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейная сложность (обход массива) */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // Число итераций пропорционально длине массива\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // Число итераций пропорционально длине массива\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейная сложность (обход массива) */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // Число итераций пропорционально длине массива\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Линейная сложность (обход массива) */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // Число итераций пропорционально длине массива\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейная сложность (обход массива) */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // Число итераций пропорционально длине массива\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейная сложность ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n\n# ## Линейная сложность (обход массива) ###\ndef array_traversal(nums)\n  count = 0\n\n  # Число итераций пропорционально длине массива\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Стоит отметить, что размер входных данных \\(n\\) нужно определять конкретно в зависимости от типа входа. Например, в первом примере переменная \\(n\\) сама является размером входных данных; во втором примере размером данных служит длина массива.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   Квадратичная сложность \\(O(n^2)\\)","text":"<p>Квадратичная сложность характеризуется тем, что число операций растет квадратично относительно размера входных данных \\(n\\) . Квадратичная сложность обычно встречается во вложенных циклах: временная сложность внешнего и внутреннего циклов равна \\(O(n)\\) , поэтому общая временная сложность составляет \\(O(n^2)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"Квадратичная сложность\"\"\"\n    count = 0\n    # Число итераций квадратично зависит от размера данных n\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Квадратичная сложность */\nint Quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Квадратичная сложность */\nfunc quadratic(n int) int {\n    count := 0\n    // Число итераций квадратично зависит от размера данных n\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Квадратичная сложность */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // Число итераций квадратично зависит от размера данных n\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Квадратичная сложность */\nfunction quadratic(n) {\n    let count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Квадратичная сложность */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n  int count = 0;\n  // Число итераций квадратично зависит от размера данных n\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Квадратичная сложность */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Квадратичная сложность */\nint quadratic(int n) {\n    int count = 0;\n    // Число итераций квадратично зависит от размера данных n\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Квадратичная сложность */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // Число итераций квадратично зависит от размера данных n\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 2-10 сравниваются три временные сложности: постоянная, линейная и квадратичная.</p> <p></p> <p> Рисунок 2-10   Постоянная, линейная и квадратичная временная сложность </p> <p>Возьмем в качестве примера пузырьковую сортировку: внешний цикл выполняется \\(n - 1\\) раз, внутренний цикл выполняется \\(n-1\\) , \\(n-2\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) раз, в среднем это \\(n / 2\\) раз, поэтому временная сложность равна \\(O((n - 1)n / 2) = O(n^2)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"Квадратичная сложность (пузырьковая сортировка)\"\"\"\n    count = 0  # Счетчик\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # Обмен элементов включает 3 элементарные операции\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(int[] nums) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint BubbleSort(int[] nums) {\n    int count = 0;  // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunc bubbleSort(nums []int) int {\n    count := 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunction bubbleSort(nums) {\n    let count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // Счетчик\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // Обмен элементов включает 3 элементарные операции\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // Счетчик\n\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Квадратичная сложность (пузырьковая сортировка) */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // Счетчик\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // Обмен элементов включает 3 элементарные операции\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   Экспоненциальная сложность \\(O(2^n)\\)","text":"<p>Типичный пример экспоненциального роста в биологии - деление клеток: в начальном состоянии есть одна клетка, после одного деления их становится 2, после двух делений - 4 и так далее; после \\(n\\) раундов деления клеток становится \\(2^n\\) .</p> <p>На рисунке 2-11 и в следующем коде моделируется процесс деления клеток; временная сложность равна \\(O(2^n)\\) . Здесь входное значение \\(n\\) обозначает число раундов деления, а возвращаемое значение <code>count</code> обозначает общее число делений.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"Экспоненциальная сложность (итеративная реализация)\"\"\"\n    count = 0\n    base = 1\n    # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Экспоненциальная сложность (итеративная реализация) */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-11   Экспоненциальная временная сложность </p> <p>В реальных алгоритмах экспоненциальная сложность также часто встречается в рекурсивных функциях. Например, в следующем коде процесс рекурсивно делится надвое и останавливается после \\(n\\) разбиений:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"Экспоненциальная сложность (рекурсивная реализация)\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Экспоненциальная сложность (рекурсивная реализация) */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Экспоненциальный рост происходит очень быстро и часто встречается в переборных методах, грубой силе, поиске с возвратом и тому подобных подходах. Для задач большого масштаба экспоненциальная сложность неприемлема, и обычно приходится применять динамическое программирование, жадные алгоритмы и другие стратегии.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   Логарифмическая сложность \\(O(\\log n)\\)","text":"<p>В противоположность экспоненциальной, логарифмическая сложность описывает ситуацию, когда в каждом раунде размер задачи уменьшается вдвое. Пусть размер входных данных равен \\(n\\) ; так как на каждом шаге размер уменьшается вдвое, число итераций равно \\(\\log_2 n\\) , то есть является обратной функцией к \\(2^n\\) .</p> <p>На рисунке 2-12 и в следующем коде моделируется процесс, в котором в каждом раунде размер задачи уменьшается вдвое; временная сложность равна \\(O(\\log_2 n)\\) и кратко записывается как \\(O(\\log n)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"Логарифмическая сложность (итеративная реализация)\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Логарифмическая сложность (итеративная реализация) */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## Логарифмическая сложность (итеративная реализация) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-12   Логарифмическая временная сложность </p> <p>Подобно экспоненциальной сложности, логарифмическая также часто встречается в рекурсивных функциях. Следующий код формирует рекурсивное дерево высотой \\(\\log_2 n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"Логарифмическая сложность (рекурсивная реализация)\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* Логарифмическая сложность (рекурсивная реализация) */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### Квадратичная сложность ###\ndef quadratic(n)\n  count = 0\n\n  # Число итераций квадратично зависит от размера данных n\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n\n# ## Квадратичная сложность (пузырьковая сортировка) ###\ndef bubble_sort(nums)\n  count = 0  # Счетчик\n\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (nums.length - 1).downto(0)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # Обмен элементов включает 3 элементарные операции\n      end\n    end\n  end\n\n  count\nend\n\n# ## Экспоненциальная сложность (итеративная реализация) ###\ndef exponential(n)\n  count, base = 0, 1\n\n  # На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n\n# ## Экспоненциальная сложность (рекурсивная реализация) ###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n\n# ## Логарифмическая сложность (итеративная реализация) ###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n\n# ## Логарифмическая сложность (рекурсивная реализация) ###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Логарифмическая сложность часто встречается в алгоритмах, основанных на стратегии \"разделяй и властвуй\", и отражает идеи разбиения на части и упрощения сложной задачи. Она растет медленно и считается одной из самых желательных временных сложностей после константной.</p> <p>Каково основание у \\(O(\\log n)\\) ?</p> <p>Точнее говоря, \"разделение на \\(m\\) частей\" соответствует временной сложности \\(O(\\log_m n)\\) . А по формуле перехода к другому основанию логарифма мы получаем равные по сложности выражения с разными основаниями:</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>Иными словами, основание \\(m\\) можно менять без влияния на сложность. Поэтому мы обычно опускаем основание \\(m\\) и напрямую записываем логарифмическую сложность как \\(O(\\log n)\\) .</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   Линейно-логарифмическая сложность \\(O(n \\log n)\\)","text":"<p>Линейно-логарифмическая сложность часто встречается в рекурсивных разбиениях, где временная сложность одного измерения равна \\(O(\\log n)\\) , а другого - \\(O(n)\\) . Соответствующий код выглядит следующим образом:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"Линейно-логарифмическая сложность\"\"\"\n    if n &lt;= 1:\n        return 1\n    # Разделение надвое: размер подзадачи уменьшается вдвое\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # Текущая подзадача содержит n операций\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Линейно-логарифмическая сложность */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Линейно-логарифмическая сложность */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Линейно-логарифмическая сложность */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Линейно-логарифмическая сложность */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Линейно-логарифмическая сложность */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Линейно-логарифмическая сложность */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* Линейно-логарифмическая сложность */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Линейно-логарифмическая сложность */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейно-логарифмическая сложность ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 2-13 показано, как возникает линейно-логарифмическая сложность. Общее число операций на каждом уровне бинарного дерева равно \\(n\\) , а дерево имеет \\(\\log_2 n + 1\\) уровней, поэтому временная сложность равна \\(O(n \\log n)\\) .</p> <p></p> <p> Рисунок 2-13   Линейно-логарифмическая временная сложность </p> <p>Временная сложность основных алгоритмов сортировки обычно равна \\(O(n \\log n)\\) , например у быстрой сортировки, сортировки слиянием, пирамидальной сортировки и т.д.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   Факториальная сложность \\(O(n!)\\)","text":"<p>Факториальная сложность соответствует математической задаче полной перестановки. Если даны \\(n\\) попарно различных элементов, то число всех возможных перестановок равно:</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>Факториал обычно реализуют через рекурсию. Как показано на рисунке 2-14 и в следующем коде, на первом уровне происходит ветвление на \\(n\\) подзадач, на втором - на \\(n - 1\\) и так далее, пока на \\(n\\)-м уровне ветвление не прекращается:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"Факториальная сложность (рекурсивная реализация)\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # Из одного получается n\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // Из одного получается n\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // Из одного получается n\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // Из одного получается n\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // Из одного получается n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // Из одного получается n\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // Из одного получается n\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // Из одного получается n\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* Факториальная сложность (рекурсивная реализация) */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // Из одного получается n\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### Линейно-логарифмическая сложность ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n\n# ## Факториальная сложность (рекурсивная реализация) ###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # Из одного получается n\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 2-14   Факториальная временная сложность </p> <p>Следует отметить, что поскольку при \\(n \\geq 4\\) всегда выполняется \\(n! &gt; 2^n\\) , факториальная сложность растет еще быстрее, чем экспоненциальная, и при больших \\(n\\) становится неприемлемой.</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   Худшая, лучшая и средняя временная сложность","text":"<p>Временная эффективность алгоритма часто не фиксирована, а зависит от распределения входных данных. Предположим, на вход подается массив <code>nums</code> длины \\(n\\) , состоящий из чисел от \\(1\\) до \\(n\\) , каждое из которых встречается ровно один раз; при этом порядок элементов случайно перемешан. Задача состоит в том, чтобы вернуть индекс элемента \\(1\\) . Тогда можно сделать следующие выводы.</p> <ul> <li>Когда <code>nums = [?, ?, ..., 1]</code> , то есть когда последний элемент равен \\(1\\) , нужно полностью пройти по массиву, что дает худшую временную сложность \\(O(n)\\) .</li> <li>Когда <code>nums = [1, ?, ?, ...]</code> , то есть когда первый элемент равен \\(1\\) , независимо от длины массива продолжать обход не нужно, что дает лучшую временную сложность \\(\\Omega(1)\\) .</li> </ul> <p>Худшая временная сложность соответствует асимптотической верхней границе функции и обозначается нотацией Big \\(O\\) . Соответственно, лучшая временная сложность соответствует асимптотической нижней границе функции и обозначается символом \\(\\Omega\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"Сгенерировать массив с элементами 1, 2, ..., n в случайном порядке\"\"\"\n    # Создать массив nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # Случайно перемешать элементы массива\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"Найти индекс числа 1 в массиве nums\"\"\"\n    for i in range(len(nums)):\n        # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        # Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Использовать системное время для генерации случайного seed\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // Случайно перемешать элементы массива\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // Случайно перемешать элементы массива\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // Случайно перемешать элементы массива\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // Случайно перемешать элементы массива\n    nums.shuffle()\n    return nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // Создать массив nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // Случайно перемешать элементы массива\n  nums.shuffle();\n\n  return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n    // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // Случайно перемешать элементы массива\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nint *randomNumbers(int n) {\n    // Выделить память в куче (создать одномерный массив переменной длины: число элементов равно n, тип элементов — int)\n    int *nums = (int *)malloc(n * sizeof(int));\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // Случайно перемешать элементы массива\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* Найти индекс числа 1 в массиве nums */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // Создать массив nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // Случайно перемешать элементы массива\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* Найти индекс числа 1 в массиве nums */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### Создать массив с элементами: 1, 2, ..., n в случайном порядке ###\ndef random_numbers(n)\n  # Создать массив nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # Случайно перемешать элементы массива\n  nums.shuffle!\nend\n\n### Найти индекс числа 1 в массиве nums ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)\n    # Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Стоит отметить, что на практике лучшая временная сложность используется редко, поскольку обычно она достигается лишь с очень малой вероятностью и может вводить в заблуждение. Худшая временная сложность гораздо практичнее, потому что задает безопасную оценку эффективности и позволяет уверенно использовать алгоритм.</p> <p>Из приведенного выше примера видно, что худшая и лучшая временные сложности возникают только при особых распределениях данных; вероятность таких случаев может быть низкой, и они не всегда реально отражают эффективность алгоритма. Напротив, средняя временная сложность способна показать эффективность алгоритма на случайных входных данных и обозначается символом \\(\\Theta\\) .</p> <p>Для некоторых алгоритмов можно относительно просто вывести средний случай при случайном распределении данных. Например, в приведенном выше примере входной массив перемешан, а вероятность появления элемента \\(1\\) на любом индексе одинакова; следовательно, среднее число итераций алгоритма равно половине длины массива, то есть \\(n / 2\\) , а средняя временная сложность равна \\(\\Theta(n / 2) = \\Theta(n)\\) .</p> <p>Однако для более сложных алгоритмов вычислить среднюю временную сложность часто непросто, потому что трудно проанализировать полное математическое ожидание на заданном распределении данных. В таких случаях обычно используют худшую временную сложность как критерий оценки эффективности алгоритма.</p> <p>Почему символ \\(\\Theta\\) встречается так редко?</p> <p>Возможно, потому что символ \\(O\\) звучит слишком привычно, и мы часто используем его для обозначения средней временной сложности. Но строго говоря, это некорректно. В этой книге и в других материалах, если встретится выражение вроде \"средняя временная сложность \\(O(n)\\)\", просто понимай его как \\(\\Theta(n)\\) .</p>","path":["Глава 2. Анализ сложности","2.3 &nbsp; Временная сложность"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"Глава 3.   Структуры данных","text":"<p>Abstract</p> <p>Структуры данных подобны прочному и многообразному каркасу.</p> <p>Они задают схему упорядоченной организации данных, на основе которой оживают алгоритмы.</p>","path":["Глава 3. Структуры данных","Глава 3. &nbsp; Структуры данных"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>3.1   Классификация структур данных</li> <li>3.2   Базовые типы данных</li> <li>3.3   Кодирование чисел *</li> <li>3.4   Кодирование символов *</li> <li>3.5   Резюме</li> </ul>","path":["Глава 3. Структуры данных","Глава 3. &nbsp; Структуры данных"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   Базовые типы данных","text":"<p>Когда речь заходит о данных в компьютере, мы в первую очередь вспоминаем текст, изображения, видео, звук, 3D-модели и многие другие формы представления информации. Хотя способы организации этих данных различаются, все они строятся из базовых типов данных.</p> <p>Базовые типы данных - это типы, которые процессор может обрабатывать непосредственно. В алгоритмах они используются напрямую и в основном включают следующее.</p> <ul> <li>Целочисленные типы <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> .</li> <li>Типы с плавающей точкой <code>float</code> , <code>double</code> , используемые для представления дробных чисел.</li> <li>Символьный тип <code>char</code> , используемый для представления букв, знаков препинания и даже эмодзи в разных языках.</li> <li>Логический тип <code>bool</code> , используемый для представления суждений \"да\" и \"нет\".</li> </ul> <p>Базовые типы данных хранятся в компьютере в двоичной форме. Один двоичный разряд равен \\(1\\) биту. В большинстве современных операционных систем \\(1\\) байт (byte) состоит из \\(8\\) битов (bit).</p> <p>Диапазон значений базовых типов данных зависит от объема занимаемого ими пространства. Ниже в качестве примера используется Java.</p> <ul> <li>Целочисленный тип <code>byte</code> занимает \\(1\\) байт = \\(8\\) бит и может представлять \\(2^{8}\\) чисел.</li> <li>Целочисленный тип <code>int</code> занимает \\(4\\) байта = \\(32\\) бита и может представлять \\(2^{32}\\) чисел.</li> </ul> <p>В таблице 3-1 перечислены объем памяти, диапазон значений и значения по умолчанию для различных базовых типов данных в Java. Эту таблицу не нужно заучивать наизусть; достаточно иметь общее представление и при необходимости обращаться к ней.</p> <p> Таблица 3-1   Объем памяти и диапазоны значений базовых типов данных </p> Тип Обозначение Объем памяти Минимальное значение Максимальное значение Значение по умолчанию Целые <code>byte</code> 1 байт \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 байта \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 байта \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 байт \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) Вещественные <code>float</code> 4 байта \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 байт \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) Символы <code>char</code> 2 байта \\(0\\) \\(2^{16} - 1\\) \\(0\\) Логические <code>bool</code> 1 байт \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>Обрати внимание: приведенная выше таблица относится именно к базовым типам данных Java. В каждом языке программирования свои определения типов, поэтому объем памяти, диапазон значений и значения по умолчанию могут различаться.</p> <ul> <li>В Python целочисленный тип <code>int</code> может иметь произвольный размер, ограниченный только доступной памятью; тип <code>float</code> является 64-битным числом двойной точности; типа <code>char</code> нет, а отдельный символ на деле является строкой <code>str</code> длины 1.</li> <li>В C и C++ размер базовых типов данных явно не зафиксирован и зависит от реализации и платформы. таблица 3-1 соответствует модели данных LP64 data model, используемой в 64-битных Unix-системах, включая Linux и macOS.</li> <li>Размер символа <code>char</code> в C и C++ составляет 1 байт, а в большинстве других языков программирования зависит от конкретного способа кодирования символов; подробнее это рассматривается в разделе \"Кодирование символов\".</li> <li>Хотя для представления логического значения достаточно 1 бита ( \\(0\\) или \\(1\\) ), в памяти оно обычно хранится как 1 байт. Это связано с тем, что современные CPU обычно используют 1 байт как минимальную адресуемую единицу памяти.</li> </ul> <p>Какова же связь между базовыми типами данных и структурами данных? Мы знаем, что структура данных - это способ организации и хранения данных в компьютере. Подлежащее в этой фразе - \"структура\", а не \"данные\".</p> <p>Если мы хотим представить \"ряд чисел\", то естественно подумаем об использовании массива. Это связано с тем, что линейная структура массива может выразить отношения соседства и порядка между числами, а то, что именно хранится внутри - целые <code>int</code> , вещественные <code>float</code> или символы <code>char</code> , - к \"структуре данных\" отношения не имеет.</p> <p>Иными словами, базовые типы данных задают \"тип содержимого\" данных, а структуры данных задают \"способ организации\" данных. Например, в следующем коде мы используем одну и ту же структуру данных (массив) для хранения и представления различных базовых типов данных, включая <code>int</code> , <code>float</code> , <code>char</code> , <code>bool</code> и т.д.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Инициализируем массивы с использованием различных базовых типов данных\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# В Python символы фактически являются строками длины 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Списки Python могут свободно хранить различные базовые типы данных и ссылки на объекты\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// Массивы JavaScript могут свободно хранить различные базовые типы данных и объекты\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// Инициализируем массивы с использованием различных базовых типов данных\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Списки Ruby могут свободно хранить различные базовые типы данных и ссылки на объекты\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%20%D1%81%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC%20%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%B8%D1%85%20%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D1%85%20%D1%82%D0%B8%D0%BF%D0%BE%D0%B2%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%0A%20%20%20%20numbers%20%3D%20%5B0%5D%20%2A%205%0A%20%20%20%20decimals%20%3D%20%5B0.0%5D%20%2A%205%0A%20%20%20%20%23%20%D0%92%20Python%20%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D1%8B%20%D0%BD%D0%B0%20%D1%81%D0%B0%D0%BC%D0%BE%D0%BC%20%D0%B4%D0%B5%D0%BB%D0%B5%20%D1%8F%D0%B2%D0%BB%D1%8F%D1%8E%D1%82%D1%81%D1%8F%20%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B0%D0%BC%D0%B8%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%8B%201%0A%20%20%20%20characters%20%3D%20%5B%270%27%5D%20%2A%205%0A%20%20%20%20bools%20%3D%20%5BFalse%5D%20%2A%205%0A%20%20%20%20%23%20%D0%A1%D0%BF%D0%B8%D1%81%D0%BA%D0%B8%20%D0%B2%20Python%20%D0%BC%D0%BE%D0%B3%D1%83%D1%82%20%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%BE%20%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D1%82%D1%8C%20%D1%80%D0%B0%D0%B7%D0%BB%D0%B8%D1%87%D0%BD%D1%8B%D0%B5%20%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B8%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BD%D0%B0%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B%0A%20%20%20%20data%20%3D%20%5B0%2C%200.0%2C%20%27a%27%2C%20False%2C%20ListNode%280%29%5D&amp;cumulative=false&amp;curInstr=12&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 3. Структуры данных","3.2 &nbsp; Базовые типы данных"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   Кодирование символов *","text":"<p>В компьютере все данные хранятся в виде двоичных чисел, и символьный тип данных <code>char</code> не является исключением. Для представления символов необходимо задать \"таблицу символов\", которая устанавливает взаимно-однозначное соответствие между каждым символом и двоичным числом. С помощью этой таблицы компьютер может преобразовывать двоичные числа в символы.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   Таблица символов ASCII","text":"<p>Код ASCII - это самая ранняя таблица символов; ее полное название - American Standard Code for Information Interchange (американский стандартный код обмена информацией). Для представления символов в ней используются 7 двоичных битов (нижние 7 битов одного байта), что позволяет закодировать до 128 различных символов. Как показано на рисунке 3-6, ASCII включает заглавные и строчные буквы английского алфавита, цифры 0 ~ 9, некоторые знаки препинания, а также некоторые управляющие символы (например перевод строки и табуляцию).</p> <p></p> <p> Рисунок 3-6   Таблица ASCII </p> <p>Однако код ASCII может представлять только английский язык. С развитием компьютерных технологий появилась таблица символов EASCII, способная охватывать больше языков. Она расширяет 7-битную основу ASCII до 8 битов и может представлять 256 различных символов.</p> <p>Во всем мире постепенно появились разные таблицы EASCII, подходящие для разных регионов. Первые 128 символов в этих таблицах одинаковы и соответствуют ASCII, а последние 128 символов определяются по-разному, чтобы удовлетворять потребностям разных языков.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   Таблица символов GBK","text":"<p>Позже люди обнаружили, что кодов EASCII все равно недостаточно для количества символов во многих языках. Например, китайских иероглифов существует почти сто тысяч, а в повседневном употреблении нужны тысячи. В 1980 году Государственное управление стандартов Китая выпустило таблицу символов GB2312, включающую 6763 иероглифа, что в основном удовлетворило потребности компьютерной обработки китайского текста.</p> <p>Однако GB2312 не умеет работать с некоторыми редкими иероглифами и традиционными формами письма. Таблица символов GBK представляет собой расширение GB2312 и в общей сложности содержит 21886 иероглифов. В схеме кодирования GBK символы ASCII представляются одним байтом, а китайские иероглифы - двумя байтами.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Таблица символов Unicode","text":"<p>С бурным развитием компьютерной техники таблицы символов и стандарты кодирования начали стремительно множиться, и это породило множество проблем. С одной стороны, такие таблицы обычно определяли символы только для конкретных языков и не могли нормально работать в многоязычной среде. С другой стороны, для одного и того же языка существовало несколько стандартов кодирования; если две машины использовали разные стандарты, при обмене информацией возникали искажения текста.</p> <p>Исследователи той эпохи задумались: если создать достаточно полную таблицу символов, которая включит все языки и знаки мира, разве это не решит проблемы многоязычной среды и искаженного текста? Под влиянием этой идеи и появилась большая и всеобъемлющая таблица символов Unicode.</p> <p>Unicode по-китайски называется \"единый код\" и теоретически способен вместить более миллиона символов. Его цель - собрать символы со всего мира в единую таблицу символов, предоставить универсальный стандарт для обработки и отображения текстов на разных языках и уменьшить количество проблем с искажением текста, вызванных различиями стандартов кодирования.</p> <p>С момента публикации в 1991 году Unicode непрерывно расширялся, добавляя новые языки и символы. По состоянию на сентябрь 2022 года Unicode уже включал 149186 символов, в том числе буквы разных языков, знаки, а также эмодзи. В огромной таблице символов Unicode часто используемые символы занимают 2 байта, а некоторые редкие символы - 3 байта и даже 4 байта.</p> <p>Unicode - это универсальный набор символов, который по сути просто присваивает каждому символу номер (так называемую \"кодовую точку\"), но не определяет, как именно хранить эти кодовые точки в компьютере. Тут неизбежно возникает вопрос: если в одном тексте одновременно встречаются кодовые точки Unicode разной длины, как система должна разбирать символы? Например, если дан код длиной 2 байта, как понять, является ли это одним 2-байтовым символом или двумя 1-байтовыми?</p> <p>Для этой проблемы прямолинейное решение состоит в том, чтобы хранить все символы в кодировке одинаковой длины. Как показано на рисунке 3-7, каждый символ в \"Hello\" занимает 1 байт, а каждый символ в \"алгоритм\" занимает 2 байта. Мы можем дополнить старшие биты нулями и закодировать все символы в \"Hello алгоритм\" в виде 2-байтовых единиц. Тогда система сможет считывать по одному символу каждые 2 байта и восстановить эту фразу.</p> <p></p> <p> Рисунок 3-7   Пример кодирования Unicode </p> <p>Однако ASCII уже показал нам, что для кодирования английского текста достаточно 1 байта. Если использовать описанную выше схему, английский текст будет занимать вдвое больше памяти, чем при ASCII, а это очень неэффективно. Поэтому нам нужен более эффективный способ кодирования Unicode.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   Кодировка UTF-8","text":"<p>Сегодня UTF-8 стала самым широко используемым способом кодирования Unicode в мире. Это кодировка переменной длины, использующая от 1 до 4 байт на символ в зависимости от его сложности. Символам ASCII нужен только 1 байт, латинским и греческим буквам - 2 байта, часто используемым китайским символам - 3 байта, а некоторым редким символам - 4 байта.</p> <p>Правила кодирования UTF-8 не слишком сложны и делятся на два случая.</p> <ul> <li>Для символов длиной 1 байт старший бит устанавливается в \\(0\\) , а оставшиеся 7 битов содержат кодовую точку Unicode. Стоит отметить, что символы ASCII занимают первые 128 кодовых точек в наборе Unicode. Иными словами, кодировка UTF-8 обратно совместима с ASCII. Это означает, что мы можем использовать UTF-8 для разбора очень старых ASCII-текстов.</li> <li>Для символов длиной \\(n\\) байт (где \\(n &gt; 1\\)) старшие \\(n\\) битов первого байта устанавливаются в \\(1\\) , а \\((n + 1)\\)-й бит устанавливается в \\(0\\) ; начиная со второго байта, старшие 2 бита каждого байта устанавливаются в \\(10\\) ; все остальные биты используются для заполнения кодовой точки Unicode соответствующего символа.</li> </ul> <p>На рисунке 3-8 показана UTF-8-кодировка для строки \"Hello алгоритм\". Можно заметить, что поскольку старшие \\(n\\) битов установлены в \\(1\\) , система может определить длину символа как \\(n\\) , подсчитав число ведущих единиц.</p> <p>Но почему старшие 2 бита всех остальных байтов устанавливаются в \\(10\\) ? На самом деле это \\(10\\) играет роль контрольного маркера. Если система начнет разбирать текст с неверного байта, префикс \\(10\\) поможет быстро обнаружить аномалию.</p> <p>Причина выбора \\(10\\) в качестве контрольного маркера в том, что по правилам UTF-8 символ не может иметь старшие два бита, равные \\(10\\) . Это можно доказать от противного: если предположить, что у некоторого символа старшие два бита равны \\(10\\) , то длина такого символа должна быть 1 байт, то есть это ASCII. Но у ASCII старший бит обязан быть \\(0\\) , что противоречит предположению.</p> <p></p> <p> Рисунок 3-8   Пример кодировки UTF-8 </p> <p>Помимо UTF-8, распространены еще два следующих способа кодирования.</p> <ul> <li>Кодировка UTF-16: использует 2 или 4 байта для представления символа. Все символы ASCII и часто используемые неанглийские символы представляются 2 байтами; небольшая часть символов требует 4 байта. Для 2-байтовых символов кодировка UTF-16 совпадает с кодовой точкой Unicode.</li> <li>Кодировка UTF-32: каждый символ занимает 4 байта. Это означает, что UTF-32 требует больше места, чем UTF-8 и UTF-16, особенно в текстах с большой долей ASCII-символов.</li> </ul> <p>С точки зрения занимаемого места UTF-8 очень эффективна для английских символов, потому что им нужен всего 1 байт; а для некоторых неанглийских символов (например китайских) UTF-16 может быть эффективнее, потому что ей требуется только 2 байта, тогда как UTF-8 может потребовать 3 байта.</p> <p>С точки зрения совместимости у UTF-8 наилучшая универсальность, и многие инструменты и библиотеки в первую очередь поддерживают именно UTF-8.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   Кодирование символов в языках программирования","text":"<p>Для большинства языков программирования прошлого строки во время выполнения программы использовали фиксированные по длине кодировки, такие как UTF-16 или UTF-32. При кодировке фиксированной длины строку можно обрабатывать как массив, и такой подход дает следующие преимущества.</p> <ul> <li>Произвольный доступ: к строкам в UTF-16 легко осуществлять произвольный доступ. UTF-8 же является кодировкой переменной длины, поэтому, чтобы найти \\(i\\) -й символ, нужно пройти от начала строки до этого символа, а это требует \\(O(n)\\) времени.</li> <li>Подсчет длины строки: аналогично произвольному доступу, вычисление длины строки в UTF-16 - это операция \\(O(1)\\) . А вот вычисление длины строки в UTF-8 требует обхода всей строки.</li> <li>Строковые операции: многие операции со строками (разделение, конкатенация, вставка, удаление и т.д.) над строками в UTF-16 реализуются проще. При работе с UTF-8 обычно требуются дополнительные вычисления, чтобы не породить некорректную UTF-8-последовательность.</li> </ul> <p>Вообще говоря, проектирование схем кодирования символов в языках программирования - очень интересная тема, в которой учитывается множество факторов.</p> <ul> <li>Тип <code>String</code> в Java использует кодировку UTF-16, и каждый символ занимает 2 байта. Это связано с тем, что на раннем этапе проектирования Java считалось, что 16 битов достаточно для представления всех возможных символов. Но это оказалось неверным предположением. Позднее Unicode вышел за пределы 16 битов, поэтому символы в Java теперь могут представляться парой 16-битных значений (так называемой \"суррогатной парой\").</li> <li>Строки в JavaScript и TypeScript используют UTF-16 по причинам, похожим на Java. Когда Netscape впервые выпустила JavaScript в 1995 году, Unicode еще находился на ранней стадии развития, и 16-битного кодирования тогда было достаточно для представления всех символов Unicode.</li> <li>C# использует UTF-16 главным образом потому, что платформа .NET была разработана Microsoft, а многие технологии Microsoft (включая Windows) широко используют именно UTF-16.</li> </ul> <p>Из-за недооценки общего числа символов перечисленным выше языкам пришлось использовать \"суррогатные пары\" для представления Unicode-символов длиной больше 16 бит. Это вынужденный компромисс. С одной стороны, в строках с суррогатными парами один символ может занимать 2 байта или 4 байта, из-за чего теряется преимущество кодировки фиксированной длины. С другой стороны, обработка суррогатных пар требует дополнительного кода, что повышает сложность разработки и отладки.</p> <p>По этим причинам некоторые языки программирования предложили иные схемы кодирования.</p> <ul> <li><code>str</code> в Python использует Unicode и гибкое строковое представление, где длина хранимого символа зависит от наибольшей кодовой точки Unicode в строке. Если все символы строки принадлежат ASCII, каждый символ занимает 1 байт; если есть символы за пределами ASCII, но все они лежат в базовой многоязычной плоскости (BMP), каждый символ занимает 2 байта; если встречаются символы за пределами BMP, каждый символ занимает 4 байта.</li> <li>Тип <code>string</code> в Go внутри использует кодировку UTF-8. Язык Go также предоставляет тип <code>rune</code>, предназначенный для представления одной кодовой точки Unicode.</li> <li>Типы <code>str</code> и <code>String</code> в Rust внутри используют UTF-8. В Rust также есть тип <code>char</code>, представляющий одну кодовую точку Unicode.</li> </ul> <p>Следует помнить, что выше обсуждался способ хранения строк внутри языков программирования, а это не то же самое, что хранение строк в файлах или передача их по сети. При файловом хранении и сетевой передаче мы обычно кодируем строки в формате UTF-8, чтобы получить наилучшую совместимость и эффективность по занимаемому месту.</p>","path":["Глава 3. Структуры данных","3.4 &nbsp; Кодирование символов *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   Классификация структур данных","text":"<p>К распространенным структурам данных относятся массивы, связные списки, стеки, очереди, хеш-таблицы, деревья, кучи и графы. Их можно классифицировать по двум измерениям: логической структуре и физической структуре.</p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   Логическая структура: линейная и нелинейная","text":"<p>Логическая структура раскрывает логические отношения между элементами данных. В массивах и связных списках данные расположены в определенном порядке, что отражает линейные отношения между элементами. В деревьях данные расположены по уровням сверху вниз, что демонстрирует отношения \"предок\" и \"потомок\". Графы состоят из вершин и ребер, отражая сложные сетевые отношения.</p> <p>Как показано на рисунке 3-1, логические структуры делятся на две большие категории: линейные и нелинейные. Линейные структуры более интуитивны, поскольку в них данные расположены линейно и логически связаны. Нелинейные структуры, напротив, представляют собой нелинейное расположение элементов данных.</p> <ul> <li>Линейные структуры данных: массивы, связные списки, стеки, очереди, хеш-таблицы, в которых элементы связаны отношением \"один к одному\".</li> <li>Нелинейные структуры данных: деревья, кучи, графы, хеш-таблицы.</li> </ul> <p>Нелинейные структуры данных можно дополнительно разделить на древовидные и сетевые.</p> <ul> <li>Древовидные структуры: деревья, кучи, хеш-таблицы, в которых элементы связаны отношением \"один ко многим\".</li> <li>Сетевые структуры: графы, в которых элементы связаны отношением \"многие ко многим\".</li> </ul> <p></p> <p> Рисунок 3-1   Линейные и нелинейные структуры данных </p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   Физическая структура: непрерывная и разрозненная","text":"<p>Во время выполнения программы обрабатываемые данные в основном хранятся в памяти. На рисунке 3-2 показан модуль оперативной памяти компьютера, где каждый черный блок содержит определенный участок памяти. Память можно представить как огромную таблицу Excel, в которой каждая ячейка способна хранить данные определенного размера.</p> <p>Система обращается к данным по адресам памяти соответствующих позиций. Как показано на рисунке 3-2, компьютер по определенным правилам присваивает каждой ячейке в этой таблице номер, чтобы каждый участок памяти имел уникальный адрес. Благодаря этим адресам программа получает доступ к данным, находящимся в памяти.</p> <p></p> <p> Рисунок 3-2   Планка памяти, участок памяти и адрес памяти </p> <p>Tip</p> <p>Стоит отметить, что сравнение памяти с таблицей Excel - это упрощенная аналогия; реальный механизм работы памяти гораздо сложнее и включает такие понятия, как адресное пространство, управление памятью, кэш-механизмы, виртуальная и физическая память.</p> <p>Память - общий ресурс для всех программ. Когда некоторый участок памяти занят одной программой, другие программы обычно не могут использовать его одновременно. Поэтому при проектировании структур данных и алгоритмов память занимает важное место. Например, пиковое потребление памяти алгоритмом не должно превышать объем доступной свободной памяти системы; если не хватает непрерывных крупных участков памяти, выбранная структура данных должна уметь размещаться в разрозненных областях памяти.</p> <p>Как показано на рисунке 3-3, физическая структура отражает способ хранения данных в памяти компьютера. Ее можно разделить на хранение в непрерывном пространстве (массивы) и хранение в разрозненном пространстве (связные списки). Физическая структура на низком уровне определяет способы доступа к данным, их обновления, вставки и удаления. Эти два типа физических структур взаимно дополняют друг друга по временной и пространственной эффективности.</p> <p></p> <p> Рисунок 3-3   Хранение в непрерывном и разрозненном пространстве </p> <p>Стоит отметить, что все структуры данных реализуются на основе массивов, связных списков или их комбинации. Например, стек и очередь можно реализовать как с помощью массивов, так и с помощью связных списков; реализация хеш-таблицы также может одновременно включать массивы и связные списки.</p> <ul> <li>Можно реализовать на основе массивов: стеки, очереди, хеш-таблицы, деревья, кучи, графы, матрицы, тензоры (массивы размерности \\(\\geq 3\\) ) и т.д.</li> <li>Можно реализовать на основе связных списков: стеки, очереди, хеш-таблицы, деревья, кучи, графы и т.д.</li> </ul> <p>После инициализации длину связного списка все еще можно изменять во время выполнения программы, поэтому его также называют \"динамической структурой данных\". Длина массива после инициализации неизменна, поэтому его также называют \"статической структурой данных\". Стоит отметить, что массив может изменять длину за счет повторного выделения памяти, тем самым приобретая определенную \"динамичность\".</p> <p>Tip</p> <p>Если тебе пока трудно понять физическую структуру, рекомендуется сначала прочитать следующую главу, а затем вернуться к этому разделу.</p>","path":["Глава 3. Структуры данных","3.1 &nbsp; Классификация структур данных"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   Кодирование чисел *","text":"<p>Tip</p> <p>В этой книге разделы, помеченные символом <code>*</code>, относятся к дополнительному чтению. Если у тебя мало времени или материал кажется трудным, можно сначала пропустить их и вернуться после изучения обязательных разделов.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331","level":2,"title":"3.3.1   Прямой, обратный и дополнительный коды","text":"<p>В таблице из предыдущего раздела можно заметить, что все целочисленные типы могут представлять на одно отрицательное число больше, чем положительных. Например, диапазон <code>byte</code> равен \\([-128, 127]\\) . Это выглядит не слишком интуитивно, и внутренняя причина связана с прямым, обратным и дополнительным кодами.</p> <p>Прежде всего нужно отметить, что числа хранятся в компьютере в виде \"дополнительного кода\". Прежде чем разбирать причины такого решения, сначала дадим определения всем трем способам представления.</p> <ul> <li>Прямой код: старший бит двоичного представления числа рассматривается как знаковый, где \\(0\\) означает положительное число, а \\(1\\) - отрицательное; остальные биты представляют значение числа.</li> <li>Обратный код: для положительного числа обратный код совпадает с прямым; для отрицательного числа он получается инверсией всех битов прямого кода, кроме знакового бита.</li> <li>Дополнительный код: для положительного числа дополнительный код совпадает с прямым; для отрицательного числа он получается добавлением \\(1\\) к его обратному коду.</li> </ul> <p>На рисунке 3-4 показаны способы преобразования между прямым, обратным и дополнительным кодами.</p> <p></p> <p> Рисунок 3-4   Преобразования между прямым, обратным и дополнительным кодами </p> <p>Прямой код (sign-magnitude), хотя и является самым наглядным, имеет определенные ограничения. С одной стороны, прямой код отрицательных чисел нельзя напрямую использовать в вычислениях. Например, при вычислении \\(1 + (-2)\\) в прямом коде результатом будет \\(-3\\) , что, очевидно, неверно.</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>Чтобы решить эту проблему, компьютеры ввели обратный код (1's complement). Если сначала преобразовать прямой код в обратный и выполнить вычисление \\(1 + (-2)\\) в обратном коде, а затем перевести результат обратно в прямой код, то получится правильный результат \\(-1\\) .</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(прямой код)} + 1000 \\; 0010 \\; \\text{(прямой код)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(обратный код)} + 1111  \\; 1101 \\; \\text{(обратный код)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(обратный код)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(прямой код)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>С другой стороны, **в прямом коде у нуля есть два представления: \\(+0\\) и \\(-0\\) **. Это означает, что числу ноль соответствуют два разных двоичных кода, что может приводить к неоднозначности. Например, если в условном выражении не различать положительный и отрицательный ноль, можно получить ошибочный результат. А если специально обрабатывать такую неоднозначность, придется вводить дополнительные проверки, что может снизить вычислительную эффективность компьютера.</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>Как и прямой код, обратный код тоже страдает от неоднозначности положительного и отрицательного нуля, поэтому компьютеры ввели дополнительный код (2's complement). Сначала посмотрим на процесс преобразования отрицательного нуля из прямого кода в обратный, а затем в дополнительный:</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(прямой код)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(обратный код)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(дополнительный код)} \\newline \\end{aligned} \\] <p>При добавлении \\(1\\) к обратному коду отрицательного нуля возникает перенос, но длина типа <code>byte</code> составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, дополнительный код отрицательного нуля равен \\(0000 \\; 0000\\) и совпадает с дополнительным кодом положительного нуля. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.</p> <p>Остается последний вопрос: диапазон типа <code>byte</code> равен \\([-128, 127]\\) , откуда берется лишнее отрицательное число \\(-128\\) ? Мы замечаем, что у всех целых чисел из интервала \\([-127, +127]\\) есть соответствующие прямой, обратный и дополнительный коды, а прямой и дополнительный коды можно преобразовывать друг в друга.</p> <p>Однако дополнительный код \\(1000 \\; 0000\\) является исключением: у него нет соответствующего прямого кода. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен \\(0000 \\; 0000\\) . Это очевидное противоречие, потому что такой прямой код обозначает число \\(0\\) , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код \\(1000 \\; 0000\\) представляет число \\(-128\\) . На самом деле результат вычисления \\((-1) + (-127)\\) в дополнительном коде как раз и равен \\(-128\\) .</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(прямой код)} + 1000 \\; 0001 \\; \\text{(прямой код)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(обратный код)} + 1111  \\; 1110 \\; \\text{(обратный код)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(дополнительный код)} + 1111  \\; 1111 \\; \\text{(дополнительный код)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(дополнительный код)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>Ты, вероятно, уже заметил, что все приведенные выше вычисления были операциями сложения. Это указывает на важный факт: аппаратные схемы внутри компьютера в основном проектируются на основе операций сложения. Причина в том, что сложение по сравнению с другими операциями (например умножением, делением и вычитанием) проще реализуется на аппаратном уровне, легче распараллеливается и выполняется быстрее.</p> <p>Обрати внимание: это не означает, что компьютер умеет только складывать. Комбинируя сложение с некоторыми базовыми логическими операциями, компьютер может реализовать и другие математические операции. Например, вычитание \\(a - b\\) можно преобразовать в сложение \\(a + (-b)\\) ; умножение и деление можно свести к многократному сложению или вычитанию.</p> <p>Теперь можно подвести итог, почему компьютеры используют дополнительный код: с представлением в дополнительном коде компьютер может использовать одни и те же схемы и операции для сложения положительных и отрицательных чисел, без необходимости проектировать специальные аппаратные схемы для вычитания и без особой обработки неоднозначности положительного и отрицательного нуля. Это значительно упрощает аппаратную архитектуру и повышает эффективность вычислений.</p> <p>Идея дополнительного кода очень изящна; из-за ограничений по объему мы на этом остановимся. Если тебе интересно, стоит изучить эту тему глубже.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   Кодирование чисел с плавающей точкой","text":"<p>Внимательный читатель может заметить: <code>int</code> и <code>float</code> имеют одинаковую длину, по 4 байта , но почему диапазон значений у <code>float</code> намного больше, чем у <code>int</code> ? Это выглядит парадоксально, ведь <code>float</code> должен еще представлять дробные числа, а значит диапазон вроде бы должен быть меньше.</p> <p>На самом деле это связано с тем, что число с плавающей точкой <code>float</code> использует другой способ представления. Обозначим двоичное число длиной 32 бита как:</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>Согласно стандарту IEEE 754, 32-битный <code>float</code> состоит из следующих трех частей.</p> <ul> <li>Бит знака \\(\\mathrm{S}\\) : занимает 1 бит и соответствует \\(b_{31}\\) .</li> <li>Биты экспоненты \\(\\mathrm{E}\\) : занимают 8 бит и соответствуют \\(b_{30} b_{29} \\ldots b_{23}\\) .</li> <li>Биты мантиссы \\(\\mathrm{N}\\) : занимают 23 бита и соответствуют \\(b_{22} b_{21} \\ldots b_0\\) .</li> </ul> <p>Формула вычисления значения, соответствующего двоичному числу <code>float</code>, имеет вид:</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>Если перейти к десятичной записи, формула вычисления будет такой:</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>Диапазоны значений соответствующих частей таковы:</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> Рисунок 3-5   Пример вычисления float по стандарту IEEE 754 </p> <p>Посмотрим на рисунок 3-5: если взять пример \\(\\mathrm{S} = 0\\) , \\(\\mathrm{E} = 124\\) , \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) , то получим:</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>Теперь мы можем ответить на исходный вопрос: в представлении <code>float</code> присутствуют биты экспоненты, поэтому его диапазон значений намного больше, чем у <code>int</code>. Согласно приведенным выше вычислениям, максимально возможное положительное число для <code>float</code> равно \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) ; если изменить бит знака, получим минимальное отрицательное число.</p> <p>Хотя число с плавающей точкой <code>float</code> расширяет диапазон значений, побочным эффектом становится потеря точности. Целочисленный тип <code>int</code> использует все 32 бита для представления числа, и числа распределены равномерно; а из-за существования битов экспоненты у <code>float</code> чем больше число, тем больше обычно становится разница между двумя соседними представимыми значениями.</p> <p>Как показано в таблице 3-2, значения экспоненты \\(\\mathrm{E} = 0\\) и \\(\\mathrm{E} = 255\\) имеют специальный смысл и используются для представления нуля, бесконечности, \\(\\mathrm{NaN}\\) и т.д.</p> <p> Таблица 3-2   Значение поля экспоненты </p> Поле экспоненты E Поле мантиссы \\(\\mathrm{N} = 0\\) Поле мантиссы \\(\\mathrm{N} \\ne 0\\) Формула вычисления \\(0\\) \\(\\pm 0\\) Денормализованное число \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Нормализованное число Нормализованное число \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>Стоит отметить, что денормализованные числа заметно повышают точность чисел с плавающей точкой. Наименьшее положительное нормализованное число равно \\(2^{-126}\\) , а наименьшее положительное денормализованное число равно \\(2^{-126} \\times 2^{-23}\\) .</p> <p>Двойная точность <code>double</code> использует способ представления, аналогичный <code>float</code> , поэтому здесь мы не будем подробно останавливаться на нем.</p>","path":["Глава 3. Структуры данных","3.3 &nbsp; Кодирование чисел *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   Резюме","text":"","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Структуры данных можно классифицировать с точки зрения логической и физической структуры. Логическая структура описывает логические отношения между элементами данных, а физическая структура описывает способ хранения данных в памяти компьютера.</li> <li>К распространенным логическим структурам относятся линейные, древовидные и сетевые. Обычно структуры данных делятся на линейные (массивы, связные списки, стеки, очереди) и нелинейные (деревья, графы, кучи). Реализация хеш-таблицы может включать как линейные, так и нелинейные структуры данных.</li> <li>При выполнении программы данные хранятся в памяти компьютера. Каждый участок памяти имеет соответствующий адрес, с помощью которого программа получает доступ к данным.</li> <li>Физическая структура делится на хранение в непрерывном пространстве (массивы) и хранение в разрозненном пространстве (связные списки). Все структуры данных реализуются на основе массивов, связных списков или их комбинации.</li> <li>Базовые типы данных в компьютере включают целые <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> , числа с плавающей точкой <code>float</code> , <code>double</code> , символы <code>char</code> и логический тип <code>bool</code> . Их диапазон значений зависит от объема занимаемого пространства и способа представления.</li> <li>Прямой код, обратный код и дополнительный код - это три способа кодирования чисел в компьютере, между которыми можно выполнять взаимные преобразования. В прямом коде старший бит целого числа является знаковым, а остальные биты представляют значение числа.</li> <li>Целые числа в компьютере хранятся в виде дополнительного кода. В таком представлении компьютер может одинаково обрабатывать сложение положительных и отрицательных чисел без специальной аппаратной схемы для вычитания, и при этом исчезает неоднозначность положительного и отрицательного нуля.</li> <li>Кодирование числа с плавающей точкой состоит из 1 бита знака, 8 битов экспоненты и 23 битов мантиссы. Благодаря наличию экспоненты диапазон значений у чисел с плавающей точкой намного больше, чем у целых, но это достигается ценой потери точности.</li> <li>ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 127 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.</li> <li>UTF-8 - самый популярный способ кодирования Unicode, обладающий очень хорошей универсальностью. Это кодировка переменной длины, хорошо расширяемая и эффективно использующая память. UTF-16 и UTF-32 относятся к кодировкам фиксированной длины. При кодировании китайского текста UTF-16 занимает меньше места, чем UTF-8. Такие языки программирования, как Java и C#, по умолчанию используют UTF-16.</li> </ul>","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Почему хеш-таблица одновременно включает линейные и нелинейные структуры данных?</p> <p>В основе хеш-таблицы лежит массив, а для разрешения коллизий мы можем использовать \"цепочки адресации\" (об этом будет рассказано в последующем разделе \"Хеш-коллизии\"): каждый бакет массива указывает на связный список, а если длина списка превышает некоторый порог, он может быть преобразован в дерево (обычно в красно-черное дерево).</p> <p>С точки зрения хранения данных в основе хеш-таблицы находится массив, где каждый слот бакета может содержать либо отдельное значение, либо связный список, либо дерево. Поэтому хеш-таблица действительно может одновременно включать линейные структуры данных (массивы, списки) и нелинейные структуры данных (деревья).</p> <p>Q: Длина типа <code>char</code> равна 1 байту?</p> <p>Длина типа <code>char</code> определяется используемым в языке программирования способом кодирования. Например, Java, JavaScript, TypeScript и C# используют кодировку UTF-16 (для хранения кодовых точек Unicode), поэтому длина <code>char</code> у них равна 2 байтам.</p> <p>Q: Не является ли двусмысленным утверждение, что структуры данных, реализованные на основе массива, также называются \"статическими структурами данных\"? Ведь стек тоже поддерживает операции push и pop, а они явно \"динамические\".</p> <p>Стек действительно может поддерживать динамические операции над данными, но сама структура данных при этом остается \"статической\" (ее длина неизменна). Хотя структуры на основе массива могут динамически добавлять и удалять элементы, их емкость фиксирована. Если количество данных превышает заранее выделенный размер, приходится создавать новый, более крупный массив и копировать в него содержимое старого.</p> <p>Q: При построении стека (очереди) его размер не задается явно, почему же его относят к \"статическим структурам данных\"?</p> <p>В языках высокого уровня нам не нужно вручную задавать начальную емкость стека (очереди): это автоматически делает сама реализация класса. Например, начальная емкость <code>ArrayList</code> в Java обычно равна 10. Кроме того, автоматом реализуется и расширение емкости. Подробнее это рассматривается в последующем разделе о \"списках\".</p> <p>Q: Если метод преобразования из прямого кода в дополнительный - это \"сначала инвертировать, затем прибавить 1\", то обратное преобразование из дополнительного кода в прямой, по идее, должно быть обратной операцией \"сначала вычесть 1, затем инвертировать\". Почему же дополнительный код также можно перевести в прямой тем же способом \"сначала инвертировать, затем прибавить 1\"?</p> <p>Это связано с тем, что взаимное преобразование прямого и дополнительного кодов по сути является вычислением \"дополнения\". Сначала дадим определение дополнения: если \\(a + b = c\\) , то говорят, что \\(a\\) является дополнением числа \\(b\\) до \\(c\\) ; аналогично, \\(b\\) является дополнением числа \\(a\\) до \\(c\\) .</p> <p>Для двоичного числа длины \\(n = 4\\) со значением \\(0010\\) , если рассматривать его как прямой код (не учитывая знаковый бит), то его дополнительный код получается правилом \"сначала инвертировать, затем прибавить 1\":</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>Мы видим, что сумма прямого и дополнительного кодов равна \\(0010 + 1110 = 10000\\) , то есть дополнительный код \\(1110\\) является \"дополнением\" прямого кода \\(0010\\) до \\(10000\\) . **Это означает, что описанная выше операция \"сначала инвертировать, затем прибавить 1\" на самом деле вычисляет дополнение до \\(10000\\) **.</p> <p>Тогда чему равно \"дополнение\" дополнительного кода \\(1110\\) до \\(10000\\) ? Мы снова можем получить его правилом \"сначала инвертировать, затем прибавить 1\":</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>Иначе говоря, прямой и дополнительный коды являются взаимными \"дополнениями\" друг друга до \\(10000\\) , поэтому и \"прямой код -&gt; дополнительный код\", и \"дополнительный код -&gt; прямой код\" можно реализовать одной и той же операцией (сначала инвертировать, затем прибавить 1).</p> <p>Разумеется, можно получить прямой код из дополнительного кода \\(1110\\) и обратной операцией, то есть \"сначала вычесть 1, затем инвертировать\":</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>В итоге и \"сначала инвертировать, затем прибавить 1\", и \"сначала вычесть 1, затем инвертировать\" - это два эквивалентных способа вычисления дополнения до \\(10000\\) .</p> <p>По сути операция \"инвертировать\" сама по себе вычисляет дополнение до \\(1111\\) (потому что всегда выполняется <code>прямой код + обратный код = 1111</code> ); а дополнительный код, получающийся после добавления 1 к обратному коду, и есть дополнение до \\(10000\\) .</p> <p>Приведенный выше пример использовал \\(n = 4\\) , но его можно обобщить на двоичные числа любой длины.</p>","path":["Глава 3. Структуры данных","3.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"Глава 12.   Разделяй и властвуй","text":"<p>Abstract</p> <p>Сложная задача раскладывается слой за слоем, и каждое новое разбиение делает ее проще.</p> <p>Принцип \"разделяй и властвуй\" показывает важный факт: если начать с простого, многое перестает быть сложным.</p>","path":["Глава 12. Разделяй и властвуй","Глава 12. &nbsp; Разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>12.1   Стратегия разделяй и властвуй</li> <li>12.2   Поисковая стратегия разделяй и властвуй</li> <li>12.3   Задача построения двоичного дерева</li> <li>12.4   Задача о Ханойской башне</li> <li>12.5   Резюме</li> </ul>","path":["Глава 12. Разделяй и властвуй","Глава 12. &nbsp; Разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   Поисковая стратегия разделяй и властвуй","text":"<p>Мы уже знаем, что алгоритмы поиска делятся на две большие категории.</p> <ul> <li>Полный перебор: реализуется через обход структуры данных, временная сложность равна \\(O(n)\\) .</li> <li>Адаптивный поиск: использует особую организацию данных или априорную информацию, временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) .</li> </ul> <p>На практике алгоритмы поиска с временной сложностью \\(O(\\log n)\\) обычно реализуются на основе стратегии \"разделяй и властвуй\", например двоичный поиск и деревья.</p> <ul> <li>На каждом шаге двоичный поиск раскладывает задачу (поиск целевого элемента в массиве) на более мелкую задачу (поиск целевого элемента в одной половине массива), и этот процесс продолжается, пока массив не станет пустым или пока не будет найден целевой элемент.</li> <li>Деревья являются типичными представителями идей \"разделяй и властвуй\"; в таких структурах данных, как двоичное дерево поиска, AVL-дерево и куча, временная сложность различных операций равна \\(O(\\log n)\\) .</li> </ul> <p>Стратегия \"разделяй и властвуй\" для двоичного поиска выглядит следующим образом.</p> <ul> <li>Задача раскладывается на части: двоичный поиск рекурсивно разбивает исходную задачу (поиск в массиве) на подзадачу (поиск в одной половине массива), и это достигается сравнением среднего элемента с целевым значением.</li> <li>Подзадачи независимы: в двоичном поиске на каждом шаге обрабатывается только одна подзадача, и она не зависит от других подзадач.</li> <li>Решения подзадач не нужно объединять: двоичный поиск нацелен на поиск конкретного элемента, поэтому объединять решения подзадач не требуется. Как только подзадача решена, одновременно считается решенной и исходная задача.</li> </ul> <p>Иными словами, стратегия \"разделяй и властвуй\" повышает эффективность поиска потому, что при полном переборе за один шаг удается исключить только один вариант, тогда как при поиске на основе \"разделяй и властвуй\" за один шаг можно исключить половину вариантов.</p>","path":["Глава 12. Разделяй и властвуй","12.2 &nbsp; Поисковая стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   Реализация двоичного поиска на основе \"разделяй и властвуй\"","text":"<p>В предыдущих главах двоичный поиск реализовывался через итерацию. Теперь реализуем его с помощью стратегии \"разделяй и властвуй\", то есть через рекурсию.</p> <p>Question</p> <p>Дан отсортированный массив <code>nums</code> длины \\(n\\) , в котором все элементы уникальны. Найдите элемент <code>target</code> .</p> <p>С точки зрения стратегии \"разделяй и властвуй\" обозначим подзадачу, соответствующую интервалу поиска \\([i, j]\\) , через \\(f(i, j)\\) .</p> <p>Начиная с исходной задачи \\(f(0, n-1)\\) , выполняем двоичный поиск по следующим шагам.</p> <ol> <li>Вычислить середину \\(m\\) интервала поиска \\([i, j]\\) и с ее помощью исключить половину интервала.</li> <li>Рекурсивно решить подзадачу вдвое меньшего размера; это может быть либо \\(f(i, m-1)\\) , либо \\(f(m+1, j)\\) .</li> <li>Повторять шаг <code>1.</code> и шаг <code>2.</code> , пока не будет найден <code>target</code> или пока интервал не станет пустым.</li> </ol> <p>На рисунке 12-4 показан процесс применения стратегии \"разделяй и властвуй\" для поиска элемента \\(6\\) в массиве.</p> <p></p> <p> Рисунок 12-4   Процесс двоичного поиска в стиле разделяй и властвуй </p> <p>В реализации кода мы объявляем рекурсивную функцию <code>dfs()</code> для решения задачи \\(f(i, j)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"Бинарный поиск: задача f(i, j)\"\"\"\n    # Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j:\n        return -1\n    # Вычислить индекс середины m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # Целевой элемент найден, вернуть его индекс\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск\"\"\"\n    n = len(nums)\n    # Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* Бинарный поиск: задача f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // Решить задачу f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // Если интервал пуст, это означает отсутствие целевого элемента, вернуть -1\n    if i &gt; j {\n        return -1\n    }\n    // Вычислить средний индекс\n    m := i + ((j - i) &gt;&gt; 1)\n    // Сравнить середину и целевой элемент\n    if nums[m] &lt; target {\n        // Если меньше, рекурсивно обрабатывать правую половину массива\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // Если больше, рекурсивно обработать левую половину массива\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m\n    }\n}\n\n/* Бинарный поиск */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j {\n        return -1\n    }\n    // Вычислить индекс середины m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m\n    }\n}\n\n/* Бинарный поиск */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Решить задачу f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* Бинарный поиск: задача f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // Вычислить индекс середины m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // Рекурсивная подзадача f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // Рекурсивная подзадача f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // Целевой элемент найден, вернуть его индекс\n    return m;\n  }\n}\n\n/* Бинарный поиск */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // Решить задачу f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* Бинарный поиск: задача f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // Решить задачу f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* Бинарный поиск: задача f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // Вычислить индекс середины m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        return m;\n    }\n}\n\n/* Бинарный поиск */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* Бинарный поиск: задача f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // Если интервал пуст, целевой элемент отсутствует, вернуть -1\n    if (i &gt; j) {\n        return -1\n    }\n    // Вычислить индекс середины m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // Рекурсивная подзадача f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // Рекурсивная подзадача f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // Целевой элемент найден, вернуть его индекс\n        m\n    }\n}\n\n/* Бинарный поиск */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // Решить задачу f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### Бинарный поиск: задача f(i, j) ###\ndef dfs(nums, target, i, j)\n  # Если интервал пуст, целевой элемент отсутствует, вернуть -1\n  return -1 if i &gt; j\n\n  # Вычислить индекс середины m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # Рекурсивная подзадача f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # Рекурсивная подзадача f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # Целевой элемент найден, вернуть его индекс\n    return m\n  end\nend\n\n### Бинарный поиск ###\ndef binary_search(nums, target)\n  n = nums.length\n  # Решить задачу f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 12. Разделяй и властвуй","12.2 &nbsp; Поисковая стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   Задача построения двоичного дерева","text":"<p>Question</p> <p>Даны прямой обход <code>preorder</code> и симметричный обход <code>inorder</code> некоторого двоичного дерева. Постройте по ним двоичное дерево и верните его корневой узел. Предполагается, что в дереве нет узлов с одинаковыми значениями (как показано на рисунке 12-5).</p> <p></p> <p> Рисунок 12-5   Пример данных для построения двоичного дерева </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   Проверка, является ли это задачей \"разделяй и властвуй\"","text":"<p>Исходная задача - построить двоичное дерево по <code>preorder</code> и <code>inorder</code> - является типичной задачей для стратегии \"разделяй и властвуй\".</p> <ul> <li>Задача раскладывается на части: если смотреть с точки зрения стратегии \"разделяй и властвуй\", исходную задачу можно разбить на две подзадачи: построение левого поддерева и построение правого поддерева, плюс одно действие: инициализация корневого узла. Для каждого поддерева (подзадачи) можно использовать тот же способ разбиения, пока не будет достигнута наименьшая подзадача (пустое поддерево).</li> <li>Подзадачи независимы: левое и правое поддеревья независимы друг от друга и не пересекаются. При построении левого поддерева нам нужно смотреть только на ту часть прямого и симметричного обходов, которая соответствует левому поддереву. Для правого поддерева рассуждение аналогично.</li> <li>Решения подзадач можно объединить: когда левое и правое поддеревья (решения подзадач) уже построены, их можно присоединить к корневому узлу и тем самым получить решение исходной задачи.</li> </ul>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   Как разделить поддеревья","text":"<p>Из анализа выше видно, что эта задача действительно решается через \"разделяй и властвуй\", но как именно, имея прямой обход <code>preorder</code> и симметричный обход <code>inorder</code>, отделить левое и правое поддеревья?</p> <p>По определению и <code>preorder</code> , и <code>inorder</code> можно разбить на три части.</p> <ul> <li>Прямой обход: <code>[ корневой узел | левое поддерево | правое поддерево ]</code> , например для дерева на рисунке 12-5 это <code>[ 3 | 9 | 2 1 7 ]</code> .</li> <li>Симметричный обход: <code>[ левое поддерево | корневой узел | правое поддерево ]</code> , например для дерева на рисунке 12-5 это <code>[ 9 | 3 | 1 2 7 ]</code> .</li> </ul> <p>На примере данных с рисунка можно получить результат разбиения по следующим шагам.</p> <ol> <li>Первый элемент прямого обхода, равный 3, является значением корневого узла.</li> <li>Найти индекс корневого узла 3 в <code>inorder</code> ; используя этот индекс, можно разбить <code>inorder</code> на <code>[ 9 | 3 | 1 2 7 ]</code> .</li> <li>По результату разбиения <code>inorder</code> нетрудно определить, что число узлов в левом и правом поддеревьях равно 1 и 3 соответственно, а значит, <code>preorder</code> можно разбить как <code>[ 3 | 9 | 2 1 7 ]</code> .</li> </ol> <p></p> <p> Рисунок 12-6   Разбиение поддеревьев в прямом и симметричном обходах </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   Описание интервалов поддеревьев через переменные","text":"<p>Согласно описанному выше способу разбиения, мы уже получили интервалы индексов корневого узла, левого и правого поддеревьев в <code>preorder</code> и <code>inorder</code>. Чтобы описывать эти интервалы, нам понадобится несколько указателей-переменных.</p> <ul> <li>Обозначим индекс корневого узла текущего дерева в <code>preorder</code> через \\(i\\) .</li> <li>Обозначим индекс корневого узла текущего дерева в <code>inorder</code> через \\(m\\) .</li> <li>Обозначим интервал индексов текущего дерева в <code>inorder</code> через \\([l, r]\\) .</li> </ul> <p>Как показано в таблице 12-1, этих переменных достаточно для описания индекса корневого узла в <code>preorder</code> и интервалов поддеревьев в <code>inorder</code> .</p> <p> Таблица 12-1   Индексы корневого узла и поддеревьев в прямом и симметричном обходах </p> Индекс корневого узла в <code>preorder</code> Интервал индексов поддерева в <code>inorder</code> Текущее дерево \\(i\\) \\([l, r]\\) Левое поддерево \\(i + 1\\) \\([l, m-1]\\) Правое поддерево \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>Стоит отметить, что \\((m-l)\\) в индексе корневого узла правого поддерева означает число узлов в левом поддереве; лучше всего понимать это выражение вместе с рисунком ниже.</p> <p></p> <p> Рисунок 12-7   Представление индексных интервалов корня и поддеревьев </p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   Реализация кода","text":"<p>Чтобы ускорить поиск \\(m\\) , мы используем хеш-таблицу <code>hmap</code> для хранения отображения значений массива <code>inorder</code> в индексы:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"Построить двоичное дерево: разделяй и властвуй\"\"\"\n    # Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0:\n        return None\n    # Инициализировать корневой узел\n    root = TreeNode(preorder[i])\n    # Найти m, чтобы разделить левое и правое поддеревья\n    m = inorder_map[preorder[i]]\n    # Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # Вернуть корневой узел\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"Построить двоичное дерево\"\"\"\n    # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return NULL;\n    // Инициализировать корневой узел\n    TreeNode *root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return null;\n    // Инициализировать корневой узел\n    TreeNode root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return null;\n    // Инициализировать корневой узел\n    TreeNode root = new(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // Завершить при пустом диапазоне поддерева\n    if r-l &lt; 0 {\n        return nil\n    }\n    // Инициализировать корневой узел\n    root := NewTreeNode(preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    m := inorderMap[preorder[i]]\n    // Подзадача: построить левое поддерево\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // Подзадача: построить правое поддерево\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0 {\n        return nil\n    }\n    // Инициализировать корневой узел\n    let root = TreeNode(x: preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    let m = inorderMap[preorder[i]]!\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null;\n    // Инициализировать корневой узел\n    const root = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    const m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nfunction buildTree(preorder, inorder) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null;\n    // Инициализировать корневой узел\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    const m = inorderMap.get(preorder[i]);\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // Завершить при пустом диапазоне поддерева\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // Инициализировать корневой узел\n  TreeNode? root = TreeNode(preorder[i]);\n  // Найти m, чтобы разделить левое и правое поддеревья\n  int m = inorderMap[preorder[i]]!;\n  // Подзадача: построить левое поддерево\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // Подзадача: построить правое поддерево\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // Вернуть корневой узел\n  return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Завершить при пустом диапазоне поддерева\n    if r - l &lt; 0 {\n        return None;\n    }\n    // Инициализировать корневой узел\n    let root = TreeNode::new(preorder[i as usize]);\n    // Найти m, чтобы разделить левое и правое поддеревья\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // Подзадача: построить левое поддерево\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // Подзадача: построить правое поддерево\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // Вернуть корневой узел\n    Some(root)\n}\n\n/* Построить двоичное дерево */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0)\n        return NULL;\n    // Инициализировать корневой узел\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // Найти m, чтобы разделить левое и правое поддеревья\n    int m = inorderMap[preorder[i]];\n    // Подзадача: построить левое поддерево\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // Подзадача: построить правое поддерево\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // Вернуть корневой узел\n    return root;\n}\n\n/* Построить двоичное дерево */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* Построить двоичное дерево: разделяй и властвуй */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // Завершить при пустом диапазоне поддерева\n    if (r - l &lt; 0) return null\n    // Инициализировать корневой узел\n    val root = TreeNode(preorder[i])\n    // Найти m, чтобы разделить левое и правое поддеревья\n    val m = inorderMap[preorder[i]]!!\n    // Подзадача: построить левое поддерево\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // Подзадача: построить правое поддерево\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // Вернуть корневой узел\n    return root\n}\n\n/* Построить двоичное дерево */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### Построить двоичное дерево: разделяй и властвуй ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # Завершить при пустом диапазоне поддерева\n  return if r - l &lt; 0\n\n  # Инициализировать корневой узел\n  root = TreeNode.new(preorder[i])\n  # Найти m, чтобы разделить левое и правое поддеревья\n  m = inorder_map[preorder[i]]\n  # Подзадача: построить левое поддерево\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # Подзадача: построить правое поддерево\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # Вернуть корневой узел\n  root\nend\n\n### Построить двоичное дерево ###\ndef build_tree(preorder, inorder)\n  # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 12-8 показан рекурсивный процесс построения двоичного дерева: каждый узел создается в фазе \"спуска\", а каждое ребро (ссылка) формируется в фазе \"подъема\".</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-8   Рекурсивный процесс построения двоичного дерева </p> <p>Результаты разбиения <code>preorder</code> и <code>inorder</code> внутри каждого рекурсивного вызова показаны на рисунке 12-9.</p> <p></p> <p> Рисунок 12-9   Результаты разбиения в каждом рекурсивном вызове </p> <p>Пусть число узлов дерева равно \\(n\\) ; инициализация каждого узла (то есть выполнение одного рекурсивного вызова <code>dfs()</code> ) занимает \\(O(1)\\) времени. Следовательно, общая временная сложность равна \\(O(n)\\) .</p> <p>Хеш-таблица хранит отображение значений <code>inorder</code> в индексы, поэтому ее пространственная сложность равна \\(O(n)\\) . В худшем случае, когда двоичное дерево вырождается в связный список, глубина рекурсии достигает \\(n\\) и требует \\(O(n)\\) памяти стека. Следовательно, общая пространственная сложность также равна \\(O(n)\\) .</p>","path":["Глава 12. Разделяй и властвуй","12.3 &nbsp; Задача построения двоичного дерева"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   Стратегия разделяй и властвуй","text":"<p>Разделяй и властвуй (divide and conquer) - это очень важная и широко используемая стратегия построения алгоритмов. Обычно она реализуется через рекурсию и включает два этапа: \"разделение\" и \"объединение\".</p> <ol> <li>Разделение (этап декомпозиции): рекурсивно разбить исходную задачу на две или более подзадачи, пока не будет достигнута наименьшая подзадача.</li> <li>Объединение (этап синтеза): начиная с уже известных решений наименьших подзадач, снизу вверх объединять решения подзадач и тем самым получать решение исходной задачи.</li> </ol> <p>Как показано на рисунке 12-1, \"сортировка слиянием\" является одним из типичных примеров применения стратегии \"разделяй и властвуй\".</p> <ol> <li>Разделение: рекурсивно разделить исходный массив (исходную задачу) на два подмассива (подзадачи), пока в подмассиве не останется только один элемент (наименьшая подзадача).</li> <li>Объединение: снизу вверх объединять упорядоченные подмассивы (решения подзадач), чтобы получить упорядоченный исходный массив (решение исходной задачи).</li> </ol> <p></p> <p> Рисунок 12-1   Стратегия разделяй и властвуй в сортировке слиянием </p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   Как определить задачу \"разделяй и властвуй\"","text":"<p>Чтобы понять, подходит ли задача для решения методом \"разделяй и властвуй\", обычно можно ориентироваться на следующие критерии.</p> <ol> <li>Задача раскладывается на части: исходную задачу можно разбить на более мелкие и похожие подзадачи, причем такое разбиение можно применять рекурсивно.</li> <li>Подзадачи независимы: подзадачи не пересекаются, не зависят друг от друга и могут решаться независимо.</li> <li>Решения подзадач можно объединить: решение исходной задачи получается объединением решений подзадач.</li> </ol> <p>Очевидно, что сортировка слиянием удовлетворяет всем трем критериям.</p> <ol> <li>Задача раскладывается на части: массив (исходная задача) рекурсивно делится на два подмассива (подзадачи).</li> <li>Подзадачи независимы: каждый подмассив можно сортировать отдельно (то есть каждую подзадачу можно решать независимо).</li> <li>Решения подзадач можно объединить: два упорядоченных подмассива (решения подзадач) можно объединить в один упорядоченный массив (решение исходной задачи).</li> </ol>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   Повышение эффективности с помощью \"разделяй и властвуй\"","text":"<p>Стратегия \"разделяй и властвуй\" не только позволяет эффективно решать алгоритмические задачи, но и часто повышает эффективность самих алгоритмов. Именно поэтому быстрая сортировка, сортировка слиянием и пирамидальная сортировка обычно работают быстрее, чем сортировка выбором, пузырьком и вставками.</p> <p>Тогда возникает естественный вопрос: почему стратегия \"разделяй и властвуй\" повышает эффективность алгоритма и какова внутренняя логика этого подхода? Иными словами, почему разбиение большой задачи на несколько подзадач, решение этих подзадач и последующее объединение их решений оказывается эффективнее, чем прямое решение исходной задачи? Этот вопрос можно рассмотреть с двух сторон: через число операций и через параллельные вычисления.</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   Оптимизация числа операций","text":"<p>Рассмотрим \"сортировку пузырьком\": для массива длины \\(n\\) ей требуется \\(O(n^2)\\) времени. Предположим, что мы разделим массив на два подмассива в середине, как показано на рисунке 12-2. Тогда само разбиение потребует \\(O(n)\\) времени, сортировка каждого подмассива займет \\(O((n / 2)^2)\\) времени, а объединение двух подмассивов потребует еще \\(O(n)\\) времени. Общая временная сложность будет равна:</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> Рисунок 12-2   Сортировка пузырьком до и после разбиения массива </p> <p>Теперь рассмотрим следующее неравенство, в котором левая и правая части обозначают общее число операций до разбиения и после него:</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>Это означает, что при \\(n &gt; 4\\) число операций после разбиения становится меньше, а значит, сортировка должна работать быстрее. При этом важно заметить, что временная сложность после разбиения все еще остается квадратичной, то есть \\(O(n^2)\\) ; уменьшается лишь константный множитель.</p> <p>Если пойти дальше и продолжать делить каждый подмассив пополам, пока в нем не останется только один элемент, то мы фактически получим \"сортировку слиянием\", чья временная сложность равна \\(O(n \\log n)\\) .</p> <p>Можно пойти еще дальше и спросить: что если задать несколько точек разделения и равномерно разбить исходный массив на \\(k\\) подмассивов? Такая ситуация очень похожа на блочную сортировку, которая особенно хорошо подходит для сортировки очень больших объемов данных и теоретически может достигать временной сложности \\(O(n + k)\\) .</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   Оптимизация параллельных вычислений","text":"<p>Мы знаем, что подзадачи, порождаемые стратегией \"разделяй и властвуй\", являются независимыми, а значит, их обычно можно решать параллельно. Иначе говоря, \"разделяй и властвуй\" не только может уменьшить временную сложность алгоритма, но и хорошо сочетается с параллельной оптимизацией на уровне системы.</p> <p>Параллельная оптимизация особенно эффективна в среде с несколькими ядрами или несколькими процессорами, потому что система может одновременно обрабатывать разные подзадачи, лучше загружая вычислительные ресурсы и тем самым заметно сокращая общее время работы.</p> <p>Например, в показанной ниже \"блочной сортировке\" большой объем данных равномерно распределяется по блокам. Тогда сортировку каждого блока можно поручить отдельным вычислительным единицам, а после завершения просто объединить результаты.</p> <p></p> <p> Рисунок 12-3   Параллельные вычисления в блочной сортировке </p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   Типичные применения стратегии \"разделяй и властвуй\"","text":"<p>С одной стороны, стратегию \"разделяй и властвуй\" можно использовать для решения многих классических алгоритмических задач.</p> <ul> <li>Поиск ближайшей пары точек: сначала множество точек делится на две части, затем ищется ближайшая пара в каждой части, а затем ближайшая пара, пересекающая границу между двумя частями.</li> <li>Умножение больших чисел: например, алгоритм Карацубы, который раскладывает умножение больших чисел на несколько умножений и сложений меньших чисел.</li> <li>Умножение матриц: например, алгоритм Штрассена, который раскладывает умножение больших матриц на несколько умножений и сложений матриц меньшего размера.</li> <li>Задача о Ханойской башне: задача о Ханойской башне решается рекурсивно и является типичным примером применения стратегии \"разделяй и властвуй\".</li> <li>Подсчет инверсий: если в последовательности предыдущее число больше следующего, то такая пара образует инверсию. Эту задачу можно решить с помощью идей \"разделяй и властвуй\", опираясь на сортировку слиянием.</li> </ul> <p>С другой стороны, стратегия \"разделяй и властвуй\" очень широко применяется при проектировании алгоритмов и структур данных.</p> <ul> <li>Двоичный поиск: двоичный поиск делит отсортированный массив на две части по индексу середины, а затем, в зависимости от результата сравнения целевого значения со средним элементом, исключает одну из половин и повторяет ту же операцию на оставшемся интервале.</li> <li>Сортировка слиянием: она уже была рассмотрена в начале этого раздела, поэтому не будем повторяться.</li> <li>Быстрая сортировка: в ней выбирается опорное значение, после чего массив делится на два подмассива: один содержит элементы меньше опорного, а другой - больше. Затем такая же операция повторяется для обеих частей, пока в подмассиве не останется один элемент.</li> <li>Блочная сортировка: ее основная идея заключается в распределении данных по нескольким блокам, сортировке элементов внутри каждого блока и последующем последовательном извлечении элементов из блоков для построения отсортированного массива.</li> <li>Деревья: например, двоичные деревья поиска, AVL-деревья, красно-черные деревья, B-деревья, B+ деревья и т.д. Их операции поиска, вставки и удаления можно рассматривать как применение стратегии \"разделяй и властвуй\".</li> <li>Кучи: куча является особым видом полного двоичного дерева, а такие операции, как вставка, удаление и упорядочивание, по сути содержат идеи \"разделяй и властвуй\".</li> <li>Хеш-таблицы: хотя хеш-таблицы напрямую не используют стратегию \"разделяй и властвуй\", некоторые способы разрешения коллизий косвенно опираются на эту идею. Например, длинные цепочки в методе цепочек могут преобразовываться в красно-черные деревья для повышения эффективности поиска.</li> </ul> <p>Нетрудно заметить, что \"разделяй и властвуй\" - это \"тихая\" алгоритмическая идея, скрыто присутствующая внутри самых разных алгоритмов и структур данных.</p>","path":["Глава 12. Разделяй и властвуй","12.1 &nbsp; Стратегия разделяй и властвуй"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   Задача о Ханойской башне","text":"<p>В задачах сортировки слиянием и построения двоичного дерева мы делили исходную задачу на две подзадачи, каждая из которых имела размер, равный примерно половине исходной задачи. Однако для задачи о Ханойской башне используется другая стратегия разбиения.</p> <p>Question</p> <p>Даны три стержня, обозначенные как <code>A</code> , <code>B</code> и <code>C</code> . В начальном состоянии на стержне <code>A</code> находятся \\(n\\) дисков, расположенных сверху вниз в порядке от меньшего к большему. Нужно переместить эти \\(n\\) дисков на стержень <code>C</code> , сохранив их исходный порядок (как показано на рисунке 12-10). Во время перемещения дисков необходимо соблюдать следующие правила.</p> <ol> <li>Диск можно снять только с вершины одного стержня и положить только на вершину другого стержня.</li> <li>За один раз можно перемещать только один диск.</li> <li>Меньший диск всегда должен лежать на большем.</li> </ol> <p></p> <p> Рисунок 12-10   Пример задачи о Ханойской башне </p> <p>Обозначим задачу о Ханойской башне размера \\(i\\) как \\(f(i)\\) . Например, \\(f(3)\\) означает задачу перемещения 3 дисков со стержня <code>A</code> на стержень <code>C</code> .</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   Рассмотрим базовые случаи","text":"<p>Как показано на рисунке 12-11, для задачи \\(f(1)\\) , то есть когда имеется только один диск, достаточно просто переместить его напрямую со стержня <code>A</code> на стержень <code>C</code> .</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> Рисунок 12-11   Решение задачи размера 1 </p> <p>Как показано на рисунке 12-12, для задачи \\(f(2)\\) , то есть когда есть два диска, поскольку меньший диск все время должен лежать на большем, приходится использовать <code>B</code> как вспомогательный стержень.</p> <ol> <li>Сначала переместить верхний маленький диск с <code>A</code> на <code>B</code> .</li> <li>Затем переместить большой диск с <code>A</code> на <code>C</code> .</li> <li>Наконец, переместить маленький диск с <code>B</code> на <code>C</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-12   Решение задачи размера 2 </p> <p>Процесс решения задачи \\(f(2)\\) можно кратко описать так: переместить два диска с <code>A</code> на <code>C</code> с помощью <code>B</code> . Здесь <code>C</code> называется целевым стержнем, а <code>B</code> - буферным стержнем.</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   Разбиение на подзадачи","text":"<p>Для задачи \\(f(3)\\) , то есть когда имеется три диска, ситуация становится сложнее.</p> <p>Поскольку решения \\(f(1)\\) и \\(f(2)\\) уже известны, можно подойти к задаче с точки зрения стратегии \"разделяй и властвуй\" и рассматривать два верхних диска на <code>A</code> как единое целое, выполняя шаги, показанные на рисунке 12-13. Так три диска успешно перемещаются с <code>A</code> на <code>C</code> .</p> <ol> <li>Сделать <code>B</code> целевым стержнем, а <code>C</code> буферным, и переместить два диска с <code>A</code> на <code>B</code> .</li> <li>Переместить оставшийся один диск с <code>A</code> напрямую на <code>C</code> .</li> <li>Сделать <code>C</code> целевым стержнем, а <code>A</code> буферным, и переместить два диска с <code>B</code> на <code>C</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 12-13   Решение задачи размера 3 </p> <p>Иначе говоря, мы разбиваем задачу \\(f(3)\\) на две подзадачи \\(f(2)\\) и одну подзадачу \\(f(1)\\) . Если последовательно решить эти три подзадачи, исходная задача тоже будет решена. Это показывает, что подзадачи независимы и что их решения можно объединить.</p> <p>Таким образом, можно сформулировать показанную на рисунке 12-14 стратегию \"разделяй и властвуй\" для задачи о Ханойской башне: исходная задача \\(f(n)\\) разбивается на две подзадачи \\(f(n-1)\\) и одну подзадачу \\(f(1)\\) , которые затем решаются в следующем порядке.</p> <ol> <li>Переместить \\(n-1\\) дисков с <code>A</code> на <code>B</code> с помощью <code>C</code> .</li> <li>Переместить оставшийся \\(1\\) диск напрямую с <code>A</code> на <code>C</code> .</li> <li>Переместить \\(n-1\\) дисков с <code>B</code> на <code>C</code> с помощью <code>A</code> .</li> </ol> <p>Для двух подзадач \\(f(n-1)\\) можно применять тот же способ рекурсивного разбиения, пока не будет достигнута наименьшая подзадача \\(f(1)\\) . А решение для \\(f(1)\\) уже известно и требует всего одного перемещения.</p> <p></p> <p> Рисунок 12-14   Стратегия разделяй и властвуй для решения задачи о Ханойской башне </p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   Реализация кода","text":"<p>В коде мы объявляем рекурсивную функцию <code>dfs(i, src, buf, tar)</code> , которая перемещает \\(i\\) верхних дисков со стержня <code>src</code> на целевой стержень <code>tar</code> с помощью буферного стержня <code>buf</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"Переместить один диск\"\"\"\n    # Снять диск с вершины src\n    pan = src.pop()\n    # Положить диск на вершину tar\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"Решить задачу Ханойской башни f(i)\"\"\"\n    # Если в src остался только один диск, сразу переместить его в tar\n    if i == 1:\n        move(src, tar)\n        return\n    # Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf)\n    # Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    # Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"Решить задачу Ханойской башни\"\"\"\n    n = len(A)\n    # Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* Переместить один диск */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // Снять диск с вершины src\n    int pan = src.back();\n    src.pop_back();\n    // Положить диск на вершину tar\n    tar.push_back(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* Переместить один диск */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // Снять диск с вершины src\n    Integer pan = src.remove(src.size() - 1);\n    // Положить диск на вершину tar\n    tar.add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* Переместить один диск */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // Снять диск с вершины src\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // Положить диск на вершину tar\n    tar.Add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    DFS(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    Move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    DFS(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // Переместить верхние n дисков из A в C с помощью B\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* Переместить один диск */\nfunc move(src, tar *list.List) {\n    // Снять диск с вершины src\n    pan := src.Back()\n    // Положить диск на вершину tar\n    tar.PushBack(pan.Value)\n    // Убрать верхний диск из src\n    src.Remove(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfsHanota(i-1, src, tar, buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* Решить задачу Ханойской башни */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // Переместить верхние n дисков из A в C с помощью B\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* Переместить один диск */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // Снять диск с вершины src\n    let pan = src.popLast()!\n    // Положить диск на вершину tar\n    tar.append(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src: &amp;src, tar: &amp;tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* Решить задачу Ханойской башни */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // Хвост списка соответствует вершине столбца\n    // Переместить верхние n дисков из src в C с помощью B\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* Переместить один диск */\nfunction move(src, tar) {\n    // Снять диск с вершины src\n    const pan = src.pop();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunction dfs(i, src, buf, tar) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* Переместить один диск */\nfunction move(src: number[], tar: number[]): void {\n    // Снять диск с вершины src\n    const pan = src.pop();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* Переместить один диск */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // Снять диск с вершины src\n  int pan = src.removeLast();\n  // Положить диск на вершину tar\n  tar.add(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // Если в src остался только один диск, сразу переместить его в tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n  dfs(i - 1, src, tar, buf);\n  // Подзадача f(1): переместить оставшийся один диск из src в tar\n  move(src, tar);\n  // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n  dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // Переместить верхние n дисков из A в C с помощью B\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* Переместить один диск */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Снять диск с вершины src\n    let pan = src.pop().unwrap();\n    // Положить диск на вершину tar\n    tar.push(pan);\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move_pan(src, tar);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar);\n}\n\n/* Решить задачу Ханойской башни */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* Переместить один диск */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // Снять диск с вершины src\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // Положить диск на вершину tar\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* Решить задачу Ханойской башни f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, srcSize, tar, tarSize);\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* Решить задачу Ханойской башни */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* Переместить один диск */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Снять диск с вершины src\n    val pan = src.removeAt(src.size - 1)\n    // Положить диск на вершину tar\n    tar.add(pan)\n}\n\n/* Решить задачу Ханойской башни f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // Если в src остался только один диск, сразу переместить его в tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n    dfs(i - 1, src, tar, buf)\n    // Подзадача f(1): переместить оставшийся один диск из src в tar\n    move(src, tar)\n    // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n    dfs(i - 1, buf, src, tar)\n}\n\n/* Решить задачу Ханойской башни */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // Переместить верхние n дисков из A в C с помощью B\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### Переместить один диск ###\ndef move(src, tar)\n  # Снять диск с вершины src\n  pan = src.pop\n  # Положить диск на вершину tar\n  tar &lt;&lt; pan\nend\n\n### Решить задачу Ханойской башни f(i) ###\ndef dfs(i, src, buf, tar)\n  # Если в src остался только один диск, сразу переместить его в tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar\n  dfs(i - 1, src, tar, buf)\n  # Подзадача f(1): переместить оставшийся один диск из src в tar\n  move(src, tar)\n  # Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src\n  dfs(i - 1, buf, src, tar)\nend\n\n### Решить задачу Ханойской башни ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # Переместить верхние n дисков из A в C с помощью B\n  dfs(n, _A, _B, _C)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 12-15, задача о Ханойской башне формирует дерево рекурсии высоты \\(n\\) , в котором каждый узел представляет подзадачу и соответствует одному открытому вызову <code>dfs()</code> ; поэтому временная сложность равна \\(O(2^n)\\) , а пространственная сложность равна \\(O(n)\\) .</p> <p></p> <p> Рисунок 12-15   Дерево рекурсии задачи о Ханойской башне </p> <p>Quote</p> <p>Задача о Ханойской башне происходит из древней легенды. В одном из храмов древней Индии монахи имели три высоких алмазных стержня и \\(64\\) золотых диска разного размера. Монахи непрерывно перекладывали диски и верили, что в тот момент, когда последний диск будет правильно перенесен, мир подойдет к концу.</p> <p>Однако даже если бы монахи перемещали по одному диску в секунду, им понадобилось бы примерно \\(2^{64} \\approx 1.84×10^{19}\\) секунд, то есть около \\(585\\) миллиардов лет, что намного превышает текущую оценку возраста Вселенной. Поэтому, если легенда и верна, нам, вероятно, пока не о чем беспокоиться.</p>","path":["Глава 12. Разделяй и властвуй","12.4 &nbsp; Задача о Ханойской башне"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   Резюме","text":"","path":["Глава 12. Разделяй и властвуй","12.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>\"Разделяй и властвуй\" - это распространенная стратегия проектирования алгоритмов, которая включает два этапа: разделение (декомпозицию) и объединение (синтез), и обычно реализуется с помощью рекурсии.</li> <li>Критерии применимости этой стратегии к задаче включают: возможность разложения задачи, независимость подзадач и возможность объединения их решений.</li> <li>Сортировка слиянием является типичным применением стратегии \"разделяй и властвуй\": она рекурсивно делит массив на два равных по длине подмассива, пока не останется массив из одного элемента, после чего начинает поэтапное объединение.</li> <li>Использование стратегии \"разделяй и властвуй\" часто позволяет повысить эффективность алгоритма. С одной стороны, она уменьшает число операций; с другой - после разбиения способствует параллельной оптимизации на уровне системы.</li> <li>\"Разделяй и властвуй\" не только помогает решать многие алгоритмические задачи, но и широко используется при проектировании структур данных и алгоритмов, поэтому его можно встретить буквально повсюду.</li> <li>По сравнению с полным перебором адаптивный поиск работает эффективнее. Алгоритмы поиска со сложностью \\(O(\\log n)\\) обычно реализуются на основе стратегии \"разделяй и властвуй\".</li> <li>Двоичный поиск - еще одно типичное применение стратегии \"разделяй и властвуй\", в котором отсутствует шаг объединения решений подзадач. Его можно реализовать рекурсивно, опираясь на эту стратегию.</li> <li>В задаче построения двоичного дерева исходная задача построения дерева может быть разбита на две подзадачи: построение левого и правого поддеревьев, а реализуется это через разбиение индексных интервалов прямого и симметричного обходов.</li> <li>В задаче о Ханойской башне задача размера \\(n\\) разбивается на две подзадачи размера \\(n-1\\) и одну подзадачу размера \\(1\\) . После последовательного решения этих трех подзадач исходная задача также оказывается решенной.</li> </ul>","path":["Глава 12. Разделяй и властвуй","12.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"Глава 14.   Динамическое программирование","text":"<p>Abstract</p> <p>Ручьи впадают в реки, а реки вливаются в море.</p> <p>Динамическое программирование собирает решения малых задач в ответ на большую задачу и шаг за шагом ведет нас к ее решению.</p>","path":["Глава 14. Динамическое программирование","Глава 14. &nbsp; Динамическое программирование"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>14.1   Первое знакомство с динамическим программированием</li> <li>14.2   Свойства задач динамического программирования</li> <li>14.3   Подход к решению задач динамического программирования</li> <li>14.4   Задача о рюкзаке 0-1</li> <li>14.5   Задача о полном рюкзаке</li> <li>14.6   Задача о расстоянии редактирования</li> <li>14.7   Резюме</li> </ul>","path":["Глава 14. Динамическое программирование","Глава 14. &nbsp; Динамическое программирование"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   Свойства задач динамического программирования","text":"<p>В предыдущем разделе мы увидели, как динамическое программирование решает исходную задачу через разложение на подзадачи. На самом деле разложение на подзадачи - это общий алгоритмический подход, но в методе \"разделяй и властвуй\", динамическом программировании и поиске с возвратом акценты расставлены по-разному.</p> <ul> <li>Алгоритмы \"разделяй и властвуй\" рекурсивно раскладывают исходную задачу на несколько независимых подзадач, пока не будет достигнута наименьшая подзадача, а затем в процессе возврата объединяют решения подзадач в решение исходной задачи.</li> <li>Динамическое программирование тоже раскладывает задачу рекурсивно, но его главное отличие от метода \"разделяй и властвуй\" в том, что подзадачи здесь зависят друг от друга и в процессе разложения возникает много перекрывающихся подзадач.</li> <li>Алгоритм поиска с возвратом перебирает все возможные решения через попытки и откат и с помощью обрезки избегает ненужных ветвей поиска. Решение исходной задачи состоит из последовательности решений, и подзадачей можно считать префикс этой последовательности решений.</li> </ul> <p>На практике динамическое программирование часто применяется для задач оптимизации. Такие задачи не только содержат перекрывающиеся подзадачи, но и обладают еще двумя важными свойствами: оптимальной подструктурой и отсутствием последствий.</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   Оптимальная подструктура","text":"<p>Немного изменим задачу о подъеме по лестнице, чтобы нагляднее показать понятие оптимальной подструктуры.</p> <p>Минимальная стоимость подъема по лестнице</p> <p>Дана лестница, по которой можно подниматься на \\(1\\) или на \\(2\\) ступени за раз. На каждой ступени указано неотрицательное целое число, обозначающее цену попадания на эту ступень. Дан массив неотрицательных целых чисел \\(cost\\) , где \\(cost[i]\\) - это цена для ступени \\(i\\) , а \\(cost[0]\\) соответствует земле (начальной позиции). Найдите минимальную суммарную стоимость, необходимую для достижения вершины.</p> <p>Как показано на рисунке 14-6, если цены для ступеней \\(1\\) , \\(2\\) и \\(3\\) равны соответственно \\(1\\) , \\(10\\) и \\(1\\) , то минимальная стоимость подъема с земли на третью ступень равна \\(2\\) .</p> <p></p> <p> Рисунок 14-6   Минимальная стоимость подъема на 3-ю ступень </p> <p>Пусть \\(dp[i]\\) обозначает накопленную стоимость подъема на ступень \\(i\\) . Поскольку на ступень \\(i\\) можно прийти только со ступени \\(i - 1\\) или со ступени \\(i - 2\\) , значение \\(dp[i]\\) может быть либо \\(dp[i - 1] + cost[i]\\) , либо \\(dp[i - 2] + cost[i]\\) . Чтобы минимизировать стоимость, нужно выбрать меньший из этих двух вариантов:</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>Отсюда и возникает смысл оптимальной подструктуры: оптимальное решение исходной задачи строится из оптимальных решений подзадач.</p> <p>Очевидно, что эта задача обладает оптимальной подструктурой: мы берем лучшее из двух оптимальных решений подзадач \\(dp[i-1]\\) и \\(dp[i-2]\\) и на его основе строим оптимальное решение исходной задачи \\(dp[i]\\) .</p> <p>А обладает ли оптимальной подструктурой исходная задача о числе способов подъема по лестнице из прошлого раздела? Формально она не про оптимум, а про подсчет количества. Но если переформулировать ее как \"найдите максимальное количество способов\", мы неожиданно увидим, что хотя исходная задача осталась по сути той же, оптимальная подструктура стала явной: максимальное число способов добраться до ступени \\(n\\) равно сумме максимальных чисел способов добраться до ступеней \\(n-1\\) и \\(n-2\\) . То есть объяснение оптимальной подструктуры в разных задачах может быть довольно гибким.</p> <p>Зная уравнение перехода состояния, а также начальные состояния \\(dp[1] = cost[1]\\) и \\(dp[2] = cost[2]\\) , мы можем сразу написать код динамического программирования:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"Минимальная стоимость подъема по лестнице: динамическое программирование\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [0] * (n + 1)\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1], dp[2] = cost[1], cost[2]\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;int&gt; dp(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: 0, count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![-1; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // Инициализация таблицы dp для хранения решений подзадач\n    int *dp = calloc(n + 1, sizeof(int));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = IntArray(n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Минимальная стоимость подъема по лестнице: динамическое программирование ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = cost[1], cost[2]\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-7 показан процесс динамического программирования для этой задачи.</p> <p></p> <p> Рисунок 14-7   Процесс динамического программирования для минимальной стоимости подъема </p> <p>В этой задаче тоже можно оптимизировать пространство, сжав одномерное состояние в нулевое измерение и тем самым уменьшив пространственную сложность с \\(O(n)\\) до \\(O(1)\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    a, b := cost[1], cost[2]\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### Минимальная стоимость подъема по лестнице: динамическое программирование ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = cost[1], cost[2]\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   Отсутствие последствий","text":"<p>Отсутствие последствий - одно из ключевых свойств, благодаря которому динамическое программирование вообще может эффективно работать. Его определение таково: если текущее состояние задано однозначно, то его дальнейшее развитие зависит только от него самого и не зависит от всей истории предыдущих состояний.</p> <p>Для примера снова рассмотрим задачу о лестнице. Если дано состояние \\(i\\) , то из него можно перейти в состояния \\(i+1\\) и \\(i+2\\) , соответствующие прыжкам на \\(1\\) и на \\(2\\) ступени. Чтобы сделать один из этих выборов, не нужно знать, какими были состояния до \\(i\\) ; на будущее влияет только текущее состояние \\(i\\) .</p> <p>Однако если добавить в задачу дополнительное ограничение, ситуация изменится.</p> <p>Подъем по лестнице с ограничением</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени, но нельзя два раунда подряд прыгать на \\(1\\) ступень. Сколькими способами можно добраться до вершины?</p> <p>Как показано на рисунке 14-8, на третью ступень теперь существует только \\(2\\) допустимых способа добраться: вариант с тремя последовательными прыжками на \\(1\\) не удовлетворяет ограничению и потому отбрасывается.</p> <p></p> <p> Рисунок 14-8   Число способов подняться на 3-ю ступень при наличии ограничения </p> <p>В этой задаче, если в предыдущем раунде был сделан прыжок на \\(1\\) ступень, то в следующем раунде уже обязательно нужно прыгнуть на \\(2\\) ступени. Иными словами, следующий выбор уже нельзя определить только по текущему состоянию (текущему номеру ступени) - он зависит еще и от предыдущего состояния (с какой ступени мы пришли в прошлый раз).</p> <p>Нетрудно заметить, что в таком виде задача больше не удовлетворяет свойству отсутствия последствий, а уравнение перехода состояния \\(dp[i] = dp[i-1] + dp[i-2]\\) перестает работать, потому что \\(dp[i-1]\\) соответствует прыжку на \\(1\\) ступень, но при этом включает множество вариантов, где предыдущий раунд тоже был прыжком на \\(1\\) ступень. Такие варианты уже нельзя напрямую учитывать в \\(dp[i]\\) , если мы хотим соблюдать ограничение.</p> <p>Поэтому нам нужно расширить определение состояния: состояние \\([i, j]\\) означает, что мы находимся на ступени \\(i\\) и в предыдущем раунде прыгнули на \\(j\\) ступеней, где \\(j \\in \\{1, 2\\}\\) . Такое определение состояния эффективно различает, был ли в прошлом раунде прыжок на \\(1\\) или на \\(2\\) ступени, и позволяет корректно определить, откуда произошло текущее состояние.</p> <ul> <li>Если в предыдущем раунде был прыжок на \\(1\\) ступень, то в раунде перед ним мог быть только прыжок на \\(2\\) ступени, то есть \\(dp[i, 1]\\) может перейти только из \\(dp[i-1, 2]\\) .</li> <li>Если в предыдущем раунде был прыжок на \\(2\\) ступени, то еще шагом раньше можно было прыгнуть либо на \\(1\\) , либо на \\(2\\) ступени, то есть \\(dp[i, 2]\\) может переходить из \\(dp[i-2, 1]\\) или из \\(dp[i-2, 2]\\) .</li> </ul> <p>Как показано на рисунке 14-9, при таком определении \\(dp[i, j]\\) обозначает число способов для состояния \\([i, j]\\) . Тогда уравнение перехода состояния имеет вид:</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> Рисунок 14-9   Рекуррентная связь с учетом ограничения </p> <p>В конце достаточно вернуть \\(dp[n, 1] + dp[n, 2]\\) ; эта сумма и представляет общее число способов добраться до ступени \\(n\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице с ограничениями: динамическое программирование\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[][] dp = new int[n + 1][3];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[,] dp = new int[n + 1, 3];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([][3]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* Подъем по лестнице с ограничениями: динамическое программирование */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = Array(n + 1) { IntArray(3) }\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### Подъем по лестнице с ограничениями: динамическое программирование ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>В этом примере достаточно дополнительно учитывать только одно предыдущее состояние, поэтому после расширения определения состояния задача снова начинает удовлетворять свойству отсутствия последствий. Однако в некоторых задачах \"зависимость от прошлого\" бывает гораздо серьезнее.</p> <p>Подъем по лестнице с порождением препятствий</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени. При этом, если вы попали на ступень \\(i\\) , система автоматически создает препятствие на ступени \\(2i\\) , и на всех последующих шагах становиться на ступень \\(2i\\) уже нельзя. Например, если в первых двух раундах вы попали на ступени \\(2\\) и \\(3\\) , то после этого нельзя будет попадать на ступени \\(4\\) и \\(6\\) . Сколько существует способов добраться до вершины?</p> <p>В этой задаче следующий прыжок зависит от всех предыдущих состояний, потому что каждый прыжок порождает новое препятствие на более высокой ступени и тем самым влияет на все будущие прыжки. Для задач такого типа динамическое программирование обычно оказывается непригодным.</p> <p>Вообще, многие сложные задачи комбинаторной оптимизации (например, задача коммивояжера) не обладают свойством отсутствия последствий. Для таких задач обычно выбирают другие методы - например, эвристический поиск, генетические алгоритмы, обучение с подкреплением и т.д., - чтобы за ограниченное время получить пригодное локально оптимальное решение.</p>","path":["Глава 14. Динамическое программирование","14.2 &nbsp; Свойства задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   Подход к решению задач динамического программирования","text":"<p>В двух предыдущих разделах были рассмотрены основные свойства задач динамического программирования. Теперь исследуем два более практических вопроса.</p> <ol> <li>Как определить, является ли некоторая задача задачей динамического программирования?</li> <li>С чего начинать решение такой задачи и как выглядит полный процесс решения?</li> </ol>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   Определение задачи","text":"<p>В целом, если задача содержит перекрывающиеся подзадачи, оптимальную подструктуру и удовлетворяет свойству отсутствия последствий, то она обычно подходит для решения с помощью динамического программирования. Однако извлечь все эти свойства напрямую из формулировки задачи бывает трудно. Поэтому на практике мы обычно ослабляем требования и сначала смотрим, подходит ли задача для решения методом поиска с возвратом (полного перебора).</p> <p>Задачи, подходящие для поиска с возвратом, обычно удовлетворяют \"модели дерева решений\". Такие задачи можно описать деревом, где каждый узел представляет одно решение, а каждый путь представляет последовательность решений.</p> <p>Иначе говоря, если в задаче есть четко выраженные решения и ответ порождается последовательностью таких решений, то она удовлетворяет модели дерева решений и обычно допускает решение через поиск с возвратом.</p> <p>Поверх этого у задач динамического программирования есть и некоторые дополнительные \"плюсы\".</p> <ul> <li>В условии задачи фигурируют слова \"максимальный\", \"минимальный\", \"наибольший\", \"наименьший\" и другие формулировки оптимизации.</li> <li>Состояния задачи можно описать списком, многомерной матрицей или деревом, и между состоянием и соседними состояниями существует рекуррентная зависимость.</li> </ul> <p>Соответственно, существуют и некоторые \"минусы\".</p> <ul> <li>Цель задачи состоит в поиске всех возможных решений, а не одного оптимального решения.</li> <li>В формулировке явно присутствуют признаки комбинаторного перечисления, и требуется вернуть сразу много конкретных вариантов.</li> </ul> <p>Если задача удовлетворяет модели дерева решений и имеет достаточно явные \"плюсы\", мы можем предположить, что это задача динамического программирования, а затем проверить это предположение уже в процессе решения.</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   Этапы решения задачи","text":"<p>Конкретный процесс решения задач динамического программирования зависит от природы и сложности задачи, но обычно включает следующие шаги: описание решений, определение состояний, построение таблицы \\(dp\\) , вывод уравнения перехода состояния, определение граничных условий и порядка переходов.</p> <p>Чтобы нагляднее показать этот процесс, рассмотрим классическую задачу \"минимальная сумма пути\".</p> <p>Question</p> <p>Дана двумерная сетка <code>grid</code> размера \\(n \\times m\\) , в каждой клетке которой записано неотрицательное целое число, означающее стоимость прохождения через эту клетку. Робот стартует из левой верхней клетки и за один шаг может двигаться только вправо или вниз, пока не достигнет правой нижней клетки. Верните минимальную сумму пути от левой верхней клетки до правой нижней.</p> <p>На рисунке 14-10 показан пример, в котором минимальная сумма пути равна \\(13\\) .</p> <p></p> <p> Рисунок 14-10   Пример данных для задачи о минимальной сумме пути </p> <p>Шаг 1: понять решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>В этой задаче на каждом раунде решение состоит в том, чтобы из текущей клетки сделать один шаг вниз или вправо. Пусть индексы строки и столбца текущей клетки равны \\([i, j]\\) ; тогда после шага вниз или вправо индексы становятся равными \\([i+1, j]\\) или \\([i, j+1]\\) . Значит, состояние должно включать два переменных индекса: строки и столбца, то есть состояние обозначается как \\([i, j]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, j]\\) , такова: минимальная сумма пути от стартовой клетки \\([0, 0]\\) до клетки \\([i, j]\\) . Ее решение обозначается через \\(dp[i, j]\\) .</p> <p>На этом этапе мы получаем двумерную матрицу \\(dp\\) , показанную на рисунке 14-11, размер которой совпадает с размером входной сетки <code>grid</code> .</p> <p></p> <p> Рисунок 14-11   Определение состояния и таблицы dp </p> <p>Note</p> <p>Как в динамическом программировании, так и в поиске с возвратом, решение задачи можно описать как последовательность решений, а состояние образуется всеми переменными решений. Оно должно содержать всю информацию, достаточную для вывода следующего состояния.</p> <p>Каждому состоянию соответствует некоторая подзадача, и для хранения решений всех подзадач мы определяем таблицу \\(dp\\) ; каждая независимая переменная состояния становится одним измерением таблицы \\(dp\\) . По сути таблица \\(dp\\) - это отображение от состояния к решению соответствующей подзадачи.</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>Для состояния \\([i, j]\\) возможны только два источника: клетка сверху \\([i-1, j]\\) и клетка слева \\([i, j-1]\\) . Следовательно, оптимальная подструктура выглядит так: минимальная сумма пути до \\([i, j]\\) определяется меньшим из двух значений - минимальной суммы пути до \\([i-1, j]\\) и минимальной суммы пути до \\([i, j-1]\\) .</p> <p>По этому рассуждению получается уравнение перехода состояния, показанное на рисунке 14-12:</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> Рисунок 14-12   Оптимальная подструктура и уравнение перехода состояния </p> <p>Note</p> <p>Опираясь на уже определенную таблицу \\(dp\\) , нужно продумать отношение между исходной задачей и подзадачами и найти способ построить оптимальное решение исходной задачи из оптимальных решений подзадач, то есть найти оптимальную подструктуру.</p> <p>Как только оптимальная подструктура найдена, на ее основе можно построить уравнение перехода состояния.</p> <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>В этой задаче состояния в первой строке могут переходить только из клетки слева, а состояния в первом столбце - только из клетки сверху, поэтому первая строка \\(i = 0\\) и первый столбец \\(j = 0\\) образуют граничные условия.</p> <p>Как показано на рисунке 14-13, поскольку каждая клетка получается из клетки слева и клетки сверху, мы можем проходить матрицу циклами: внешний цикл по строкам, внутренний - по столбцам.</p> <p></p> <p> Рисунок 14-13   Граничные условия и порядок перехода состояний </p> <p>Note</p> <p>В динамическом программировании граничные условия используются для инициализации таблицы \\(dp\\) , а в поиске - для обрезки.</p> <p>Смысл порядка перехода состояния в том, чтобы к моменту вычисления текущей подзадачи все более мелкие подзадачи, от которых она зависит, уже были вычислены корректно.</p> <p>После этого анализа мы уже можем напрямую написать код динамического программирования. Однако разложение на подзадачи - это мышление \"сверху вниз\", поэтому с точки зрения мышления более естественно реализовывать задачу в порядке \"полный перебор \\(\\rightarrow\\) поиск с мемоизацией \\(\\rightarrow\\) динамическое программирование\".</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1-1","level":3,"title":"1.   Метод 1: полный перебор","text":"<p>Начав со состояния \\([i, j]\\) , мы непрерывно раскладываем его на меньшие состояния \\([i-1, j]\\) и \\([i, j-1]\\) . Рекурсивная функция при этом имеет следующие элементы.</p> <ul> <li>Параметры рекурсии: состояние \\([i, j]\\) .</li> <li>Возвращаемое значение: минимальная сумма пути до \\([i, j]\\) , то есть \\(dp[i, j]\\) .</li> <li>Условие завершения: когда \\(i = 0\\) и \\(j = 0\\) , возвращается стоимость \\(grid[0, 0]\\) .</li> <li>Обрезка: если \\(i &lt; 0\\) или \\(j &lt; 0\\) , индекс выходит за границы, и в этом случае возвращается стоимость \\(+\\infty\\) , обозначающая невозможность.</li> </ul> <p>Код реализации:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"Минимальная сумма пути: полный перебор\"\"\"\n    # Если это верхняя левая ячейка, завершить поиск\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: полный перебор */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: полный перебор */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: полный перебор */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: полный перебор */\nfunction minPathSumDFS(grid, i, j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: полный перебор */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // Если это верхняя левая ячейка, завершить поиск\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  if (i &lt; 0 || j &lt; 0) {\n    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: полный перебор */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: полный перебор */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: полный перебор */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: полный перебор ###\ndef min_path_sum_dfs(grid, i, j)\n  # Если это верхняя левая ячейка, завершить поиск\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  [left, up].min + grid[i][j]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-14 показано дерево рекурсии с корнем в \\(dp[2, 1]\\) ; в нем содержатся перекрывающиеся подзадачи, и их число будет резко расти вместе с размером сетки <code>grid</code> .</p> <p>По своей сути причина появления перекрывающихся подзадач такова: существует много разных путей от левого верхнего угла до одной и той же клетки.</p> <p></p> <p> Рисунок 14-14   Дерево рекурсии полного перебора </p> <p>У каждого состояния есть два выбора - вниз и вправо, а от левого верхнего угла до правого нижнего нужно сделать всего \\(m + n - 2\\) шагов, поэтому худшая временная сложность равна \\(O(2^{m + n})\\) , где \\(n\\) и \\(m\\) - число строк и столбцов сетки соответственно. Заметим, что в этой оценке не учитывается близость к границам сетки: у граничных клеток остается только один выбор, так что фактическое число путей будет несколько меньше.</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2-2","level":3,"title":"2.   Метод 2: поиск с мемоизацией","text":"<p>Введем список памяти <code>mem</code> того же размера, что и сетка <code>grid</code> , для хранения решений всех подзадач и отсечения перекрывающихся подзадач:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"Минимальная сумма пути: поиск с мемоизацией\"\"\"\n    # Если это верхняя левая ячейка, завершить поиск\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # Минимальная стоимость пути для левой и верхней ячеек\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // Если это верхняя левая ячейка, завершить поиск\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  if (i &lt; 0 || j &lt; 0) {\n    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // Если запись уже есть, вернуть сразу\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // Минимальная стоимость пути для левой и верхней ячеек\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // Если это верхняя левая ячейка, завершить поиск\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: поиск с мемоизацией */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // Если это верхняя левая ячейка, завершить поиск\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // Минимальная стоимость пути для левой и верхней ячеек\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: поиск с мемоизацией ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # Если это верхняя левая ячейка, завершить поиск\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # Если индексы строки или столбца выходят за границы, вернуть стоимость +∞\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # Если запись уже есть, вернуть сразу\n  return mem[i][j] if mem[i][j] != -1\n  # Минимальная стоимость пути для левой и верхней ячеек\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-15, после добавления мемоизации решение каждой подзадачи вычисляется только один раз, поэтому временная сложность определяется общим числом состояний, то есть равна \\(O(nm)\\) .</p> <p></p> <p> Рисунок 14-15   Дерево рекурсии для поиска с мемоизацией </p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3-3","level":3,"title":"3.   Метод 3: динамическое программирование","text":"<p>Итеративная реализация динамического программирования выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Минимальная сумма пути: динамическое программирование\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Инициализация таблицы dp\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # Переход состояний: первая строка\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # Переход состояний: первый столбец\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Инициализация таблицы dp\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // Переход состояний: первая строка\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // Переход состояний: первый столбец\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: динамическое программирование */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Инициализация таблицы dp\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // Переход состояний: первый столбец\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // Освободить память\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: динамическое программирование */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Инициализация таблицы dp\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // Переход состояний: первая строка\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // Переход состояний: первый столбец\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: динамическое программирование ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # Инициализация таблицы dp\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # Переход состояний: первая строка\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # Переход состояний: первый столбец\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-16 показан процесс переходов состояний в задаче о минимальной сумме пути. Он проходит по всей сетке, поэтому временная сложность равна \\(O(nm)\\) .</p> <p>Размер массива <code>dp</code> равен \\(n \\times m\\) , поэтому пространственная сложность равна \\(O(nm)\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-16   Процесс динамического программирования для минимальной суммы пути </p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   Оптимизация пространства","text":"<p>Поскольку каждая клетка зависит только от клетки слева и клетки сверху, таблицу \\(dp\\) можно реализовать с помощью одномерного массива, соответствующего одной строке.</p> <p>Обратите внимание: поскольку массив <code>dp</code> теперь может представлять только одну строку состояний, мы не можем заранее инициализировать состояния первого столбца, а должны обновлять их по мере обхода каждой строки:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"Минимальная сумма пути: динамическое программирование с оптимизацией памяти\"\"\"\n    n, m = len(grid), len(grid[0])\n    # Инициализация таблицы dp\n    dp = [0] * m\n    # Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # Переход состояний: остальные строки\n    for i in range(1, n):\n        # Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        # Переход состояний: остальные столбцы\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // Инициализация таблицы dp\n    int[] dp = new int[m];\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // Инициализация таблицы dp\n    dp := make([]int, m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt; n; i++ {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки\n    for i in 1 ..&lt; n {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = new Array(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // Инициализация таблицы dp\n    const dp = new Array(m);\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // Переход состояний: остальные строки\n  for (int i = 1; i &lt; n; i++) {\n    // Переход состояний: первый столбец\n    dp[0] = dp[0] + grid[i][0];\n    // Переход состояний: остальные столбцы\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // Инициализация таблицы dp\n    let mut dp = vec![0; m];\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for i in 1..n {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // Инициализация таблицы dp\n    int *dp = calloc(m, sizeof(int));\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt; n; i++) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0];\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // Инициализация таблицы dp\n    val dp = IntArray(m)\n    // Переход состояний: первая строка\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // Переход состояний: остальные строки\n    for (i in 1..&lt;n) {\n        // Переход состояний: первый столбец\n        dp[0] = dp[0] + grid[i][0]\n        // Переход состояний: остальные столбцы\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # Инициализация таблицы dp\n  dp = Array.new(m, 0)\n  # Переход состояний: первая строка\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # Переход состояний: остальные строки\n  for i in 1...n\n    # Переход состояний: первый столбец\n    dp[0] = dp[0] + grid[i][0]\n    # Переход состояний: остальные столбцы\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.3 &nbsp; Подход к решению задач динамического программирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   Задача о расстоянии редактирования","text":"<p>Расстояние редактирования, также называемое расстоянием Левенштейна, - это минимальное количество изменений, необходимых для преобразования одной строки в другую. Обычно оно используется для измерения сходства двух последовательностей в информационном поиске и обработке естественного языка.</p> <p>Question</p> <p>Даны две строки \\(s\\) и \\(t\\) . Верните минимальное число шагов редактирования, необходимое для преобразования \\(s\\) в \\(t\\) .</p> <p>Для строки допускаются три операции редактирования: вставка одного символа, удаление одного символа и замена одного символа на произвольный другой символ.</p> <p>Как показано на рисунке 14-27, для преобразования <code>kitten</code> в <code>sitting</code> требуется 3 шага редактирования: 2 операции замены и 1 операция вставки; для преобразования <code>hello</code> в <code>algo</code> также требуется 3 шага: 2 замены и 1 удаление.</p> <p></p> <p> Рисунок 14-27   Пример данных для задачи о расстоянии редактирования </p> <p>Задачу о расстоянии редактирования можно естественным образом объяснить с помощью модели дерева решений. Строки соответствуют узлам дерева, а один шаг решения, то есть одна операция редактирования, соответствует одному ребру дерева.</p> <p>Как показано на рисунке 14-28, если не ограничивать число операций, то каждый узел может порождать множество ребер, и каждое из них соответствует одному из вариантов преобразования. Это означает, что преобразовать <code>hello</code> в <code>algo</code> можно множеством разных путей.</p> <p>С точки зрения дерева решений цель этой задачи - найти кратчайший путь между узлом <code>hello</code> и узлом <code>algo</code> .</p> <p></p> <p> Рисунок 14-28   Представление задачи о расстоянии редактирования через дерево решений </p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>На каждом раунде решение состоит в выполнении одной операции редактирования над строкой \\(s\\) .</p> <p>Нам нужно, чтобы в ходе выполнения операций размер задачи постепенно уменьшался; только тогда можно строить подзадачи. Пусть длины строк \\(s\\) и \\(t\\) равны соответственно \\(n\\) и \\(m\\) ; сначала рассмотрим последние символы этих строк, то есть \\(s[n-1]\\) и \\(t[m-1]\\) .</p> <ul> <li>Если \\(s[n-1]\\) и \\(t[m-1]\\) совпадают, их можно просто пропустить и сразу перейти к сравнению \\(s[n-2]\\) и \\(t[m-2]\\) .</li> <li>Если \\(s[n-1]\\) и \\(t[m-1]\\) различны, нужно выполнить над \\(s\\) одну операцию редактирования (вставку, удаление или замену), чтобы последние символы стали одинаковыми, после чего можно перейти к задаче меньшего размера.</li> </ul> <p>Иначе говоря, каждый шаг решения, то есть операция редактирования над строкой \\(s\\) , меняет те символы, которые еще необходимо сопоставить в строках \\(s\\) и \\(t\\) . Поэтому состояние определяется текущими позициями рассматриваемых символов в \\(s\\) и \\(t\\) , то есть состоянием \\([i, j]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, j]\\) , такова: минимальное число операций редактирования, необходимое для преобразования первых \\(i\\) символов строки \\(s\\) в первые \\(j\\) символов строки \\(t\\).</p> <p>Отсюда получается двумерная таблица \\(dp\\) размера \\((i+1) \\times (j+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>Рассмотрим подзадачу \\(dp[i, j]\\) . Ее последние символы - это \\(s[i-1]\\) и \\(t[j-1]\\) . В зависимости от операции редактирования возможны три случая, показанные на рисунке 14-29.</p> <ol> <li>Вставить после \\(s[i-1]\\) символ \\(t[j-1]\\) ; тогда остается подзадача \\(dp[i, j-1]\\) .</li> <li>Удалить \\(s[i-1]\\) ; тогда остается подзадача \\(dp[i-1, j]\\) .</li> <li>Заменить \\(s[i-1]\\) на \\(t[j-1]\\) ; тогда остается подзадача \\(dp[i-1, j-1]\\) .</li> </ol> <p></p> <p> Рисунок 14-29   Переходы состояния в задаче о расстоянии редактирования </p> <p>Согласно этому анализу оптимальная подструктура такова: минимальное число шагов редактирования для \\(dp[i, j]\\) равно минимуму из трех значений - \\(dp[i, j-1]\\) , \\(dp[i-1, j]\\) и \\(dp[i-1, j-1]\\) - плюс \\(1\\) шаг за текущее редактирование. Значит, уравнение перехода состояния имеет вид:</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>Заметим, что если символы \\(s[i-1]\\) и \\(t[j-1]\\) совпадают, то редактировать текущий символ не нужно. В этом случае уравнение перехода состояния имеет вид:</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда обе строки пусты, число операций редактирования равно \\(0\\) , то есть \\(dp[0, 0] = 0\\) . Когда строка \\(s\\) пуста, а строка \\(t\\) непуста, минимальное число операций равно длине строки \\(t\\) , то есть вся первая строка инициализируется как \\(dp[0, j] = j\\) . Когда строка \\(s\\) непуста, а строка \\(t\\) пуста, минимальное число операций равно длине строки \\(s\\) , то есть весь первый столбец инициализируется как \\(dp[i, 0] = i\\) .</p> <p>Из уравнения перехода видно, что решение \\(dp[i, j]\\) зависит от значений слева, сверху и слева сверху, поэтому всю таблицу \\(dp\\) можно обходить двумя вложенными циклами в прямом порядке.</p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"Редакционное расстояние: динамическое программирование\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # Переход состояний: первая строка и первый столбец\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Редакционное расстояние: динамическое программирование */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // Переход состояний: первая строка и первый столбец\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // Переход состояний: первая строка и первый столбец\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // Переход состояний: первая строка и первый столбец\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Редакционное расстояние: динамическое программирование */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // Переход состояний: первая строка и первый столбец\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // Если два символа равны, сразу пропустить их\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Редакционное расстояние: динамическое программирование */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // Переход состояний: первая строка и первый столбец\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* Редакционное расстояние: динамическое программирование */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // Переход состояний: первая строка и первый столбец\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Редакционное расстояние: динамическое программирование */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // Переход состояний: первая строка и первый столбец\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### Редакционное расстояние: динамическое программирование ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # Переход состояний: первая строка и первый столбец\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # Если два символа равны, сразу пропустить их\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-30, процесс переходов состояния в задаче о расстоянии редактирования очень похож на задачи о рюкзаке: и там и здесь его можно рассматривать как заполнение двумерной сетки.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-30   Процесс динамического программирования для расстояния редактирования </p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   Оптимизация пространства","text":"<p>Поскольку \\(dp[i,j]\\) зависит от значения сверху \\(dp[i-1, j]\\) , слева \\(dp[i, j-1]\\) и слева сверху \\(dp[i-1, j-1]\\) , прямой обход после оптимизации памяти теряет значение слева сверху, а обратный обход не позволяет заранее построить значение слева \\(dp[i, j-1]\\) . Значит, оба наивных варианта обхода здесь непригодны.</p> <p>Чтобы решить эту проблему, можно использовать переменную <code>leftup</code> для временного сохранения значения слева сверху \\(dp[i-1, j-1]\\) ; после этого остается учитывать только верхнее и левое значения. Тогда ситуация становится аналогичной задаче о полном рюкзаке, и можно выполнять прямой обход. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"Редакционное расстояние: динамическое программирование с оптимизацией памяти\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # Переход состояний: первая строка\n    for j in range(1, m + 1):\n        dp[j] = j\n    # Переход состояний: остальные строки\n    for i in range(1, n + 1):\n        # Переход состояний: первый столбец\n        leftup = dp[0]  # Временно сохранить dp[i-1, j-1]\n        dp[0] += 1\n        # Переход состояний: остальные столбцы\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            else:\n                # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # Обновить до значения dp[i-1, j-1] для следующей итерации\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // Переход состояний: первая строка\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for i := 1; i &lt;= n; i++ {\n        // Переход состояний: первый столбец\n        leftUp := dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftUp\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // Переход состояний: первая строка\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for i in 1 ... n {\n        // Переход состояний: первый столбец\n        var leftup = dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        let leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // Переход состояний: первая строка\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (let i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        let leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // Переход состояний: первая строка\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // Переход состояний: остальные строки\n  for (int i = 1; i &lt;= n; i++) {\n    // Переход состояний: первый столбец\n    int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n    dp[0] = i;\n    // Переход состояний: остальные столбцы\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // Если два символа равны, сразу пропустить их\n        dp[j] = leftup;\n      } else {\n        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // Переход состояний: первая строка\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // Переход состояний: остальные строки\n    for i in 1..=n {\n        // Переход состояний: первый столбец\n        let mut leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i as i32;\n        // Переход состояний: остальные столбцы\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // Переход состояний: первая строка\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // Переход состояний: остальные строки\n    for (int i = 1; i &lt;= n; i++) {\n        // Переход состояний: первый столбец\n        int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]\n        dp[0] = i;\n        // Переход состояний: остальные столбцы\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup;\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    int res = dp[m];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // Переход состояний: первая строка\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // Переход состояний: остальные строки\n    for (i in 1..n) {\n        // Переход состояний: первый столбец\n        var leftup = dp[0] // Временно сохранить dp[i-1, j-1]\n        dp[0] = i\n        // Переход состояний: остальные столбцы\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // Если два символа равны, сразу пропустить их\n                dp[j] = leftup\n            } else {\n                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // Обновить до значения dp[i-1, j-1] для следующей итерации\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### Редакционное расстояние: динамическое программирование с оптимизацией памяти ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # Переход состояний: первая строка\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # Переход состояний: остальные строки\n  for i in 1...(n + 1)\n    # Переход состояний: первый столбец\n    leftup = dp.first # Временно сохранить dp[i-1, j-1]\n    dp[0] += 1\n    # Переход состояний: остальные столбцы\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # Если два символа равны, сразу пропустить их\n        dp[j] = leftup\n      else\n        # Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # Обновить до значения dp[i-1, j-1] для следующей итерации\n    end\n  end\n  dp[m]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.6 &nbsp; Задача о расстоянии редактирования"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   Первое знакомство с динамическим программированием","text":"<p>Динамическое программирование (dynamic programming) - это важная алгоритмическая парадигма, которая разбивает задачу на последовательность более мелких подзадач и за счет хранения их решений избегает повторных вычислений, тем самым резко повышая эффективность по времени.</p> <p>В этом разделе мы начнем с классического примера: сначала представим его грубое решение методом поиска с возвратом, увидим в нем перекрывающиеся подзадачи, а затем постепенно выведем более эффективное решение на основе динамического программирования.</p> <p>Подъем по лестнице</p> <p>Дана лестница из \\(n\\) ступеней. За один шаг можно подняться на \\(1\\) или на \\(2\\) ступени. Сколькими способами можно добраться до вершины?</p> <p>Как показано на рисунке 14-1, для лестницы из \\(3\\) ступеней существует \\(3\\) способа добраться до вершины.</p> <p></p> <p> Рисунок 14-1   Число способов подняться на 3-ю ступень </p> <p>Цель этой задачи - вычислить количество способов. Поэтому можно попробовать использовать для ее решения метод поиска с возвратом. Если представить подъем по лестнице как последовательность решений, то мы начинаем от земли и на каждом раунде выбираем прыжок на \\(1\\) или на \\(2\\) ступени; всякий раз, когда достигаем вершины, увеличиваем число способов на \\(1\\) , а если перескакиваем вершину, обрезаем эту ветвь. Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"Бэктрекинг\"\"\"\n    # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n:\n        res[0] += 1\n    # Перебор всех вариантов выбора\n    for choice in choices:\n        # Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n:\n            continue\n        # Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res)\n        # Откат\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: бэктрекинг\"\"\"\n    choices = [1, 2]  # Можно подняться на 1 или 2 ступени\n    state = 0  # Начать подъем с 0-й ступени\n    res = [0]  # Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* Бэктрекинг */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    for (auto &amp;choice : choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // Можно подняться на 1 или 2 ступени\n    int state = 0;                // Начать подъем с 0-й ступени\n    vector&lt;int&gt; res = {0};        // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* Бэктрекинг */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (Integer choice : choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // Можно подняться на 1 или 2 ступени\n    int state = 0; // Начать подъем с 0-й ступени\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* Бэктрекинг */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    foreach (int choice in choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        Backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    int state = 0; // Начать подъем с 0-й ступени\n    List&lt;int&gt; res = [0]; // Использовать res[0] для хранения числа решений\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* Бэктрекинг */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // Перебор всех вариантов выбора\n    for _, choice := range choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state+choice &gt; n {\n            continue\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state+choice, n, res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunc climbingStairsBacktrack(n int) int {\n    // Можно подняться на 1 или 2 ступени\n    choices := []int{1, 2}\n    // Начать подъем с 0-й ступени\n    state := 0\n    res := make([]int, 1)\n    // Использовать res[0] для хранения числа решений\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* Бэктрекинг */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] += 1\n    }\n    // Перебор всех вариантов выбора\n    for choice in choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n {\n            continue\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // Можно подняться на 1 или 2 ступени\n    let state = 0 // Начать подъем с 0-й ступени\n    var res: [Int] = []\n    res.append(0) // Использовать res[0] для хранения числа решений\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* Бэктрекинг */\nfunction backtrack(choices, state, n, res) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    const state = 0; // Начать подъем с 0-й ступени\n    const res = new Map();\n    res.set(0, 0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* Бэктрекинг */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // Перебор всех вариантов выбора\n    for (const choice of choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n    const state = 0; // Начать подъем с 0-й ступени\n    const res = new Map();\n    res.set(0, 0); // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* Бэктрекинг */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n  if (state == n) {\n    res[0]++;\n  }\n  // Перебор всех вариантов выбора\n  for (int choice in choices) {\n    // Отсечение: нельзя выходить за n-ю ступень\n    if (state + choice &gt; n) continue;\n    // Попытка: сделать выбор и обновить состояние\n    backtrack(choices, state + choice, n, res);\n    // Откат\n  }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // Можно подняться на 1 или 2 ступени\n  int state = 0; // Начать подъем с 0-й ступени\n  List&lt;int&gt; res = [];\n  res.add(0); // Использовать res[0] для хранения числа решений\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* Бэктрекинг */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // Перебор всех вариантов выбора\n    for &amp;choice in choices {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if state + choice &gt; n {\n            continue;\n        }\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // Можно подняться на 1 или 2 ступени\n    let state = 0; // Начать подъем с 0-й ступени\n    let mut res = Vec::new();\n    res.push(0); // Использовать res[0] для хранения числа решений\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* Бэктрекинг */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0]++;\n    // Перебор всех вариантов выбора\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n)\n            continue;\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res, len);\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // Можно подняться на 1 или 2 ступени\n    int state = 0;           // Начать подъем с 0-й ступени\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // Использовать res[0] для хранения числа решений\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* Бэктрекинг */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n    if (state == n)\n        res[0] = res[0] + 1\n    // Перебор всех вариантов выбора\n    for (choice in choices) {\n        // Отсечение: нельзя выходить за n-ю ступень\n        if (state + choice &gt; n) continue\n        // Попытка: сделать выбор и обновить состояние\n        backtrack(choices, state + choice, n, res)\n        // Откат\n    }\n}\n\n/* Подъем по лестнице: бэктрекинг */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // Можно подняться на 1 или 2 ступени\n    val state = 0 // Начать подъем с 0-й ступени\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // Использовать res[0] для хранения числа решений\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### Бэктрекинг ###\ndef backtrack(choices, state, n, res)\n  # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1\n  res[0] += 1 if state == n\n  # Перебор всех вариантов выбора\n  for choice in choices\n    # Отсечение: нельзя выходить за n-ю ступень\n    next if state + choice &gt; n\n\n    # Попытка: сделать выбор и обновить состояние\n    backtrack(choices, state + choice, n, res)\n  end\n  # Откат\nend\n\n### Подъем по лестнице: бэктрекинг ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # Можно подняться на 1 или 2 ступени\n  state = 0 # Начать подъем с 0-й ступени\n  res = [0] # Использовать res[0] для хранения числа решений\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411-1","level":2,"title":"14.1.1   Метод 1: полный перебор","text":"<p>Алгоритм поиска с возвратом обычно не раскладывает задачу явно на подзадачи; вместо этого он рассматривает решение как последовательность решений, используя попытки и обрезку для поиска всех возможных ответов.</p> <p>Попробуем посмотреть на задачу именно как на разложение подзадач. Пусть число способов добраться до ступени \\(i\\) равно \\(dp[i]\\) ; тогда \\(dp[i]\\) - это исходная задача, а ее подзадачи включают:</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>Поскольку за один раунд можно подняться только на \\(1\\) или на \\(2\\) ступени, стоя на ступени \\(i\\) , в предыдущий раунд мы могли находиться только на ступени \\(i - 1\\) или на ступени \\(i - 2\\) . Иначе говоря, на ступень \\(i\\) можно попасть только со ступени \\(i -1\\) или со ступени \\(i - 2\\) .</p> <p>Отсюда получается важный вывод: число способов добраться до ступени \\(i - 1\\) плюс число способов добраться до ступени \\(i - 2\\) равно числу способов добраться до ступени \\(i\\). Формула имеет вид:</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>Это означает, что в задаче о подъеме по лестнице между подзадачами существует рекуррентная зависимость, и решение исходной задачи может быть построено на основе решений подзадач. Эта связь показана на рисунке 14-2.</p> <p></p> <p> Рисунок 14-2   Рекуррентная связь числа способов </p> <p>По рекуррентной формуле можно получить решение полного перебора. Начиная с \\(dp[n]\\) , мы рекурсивно разлагаем большую задачу в сумму двух меньших задач , пока не дойдем до наименьших подзадач \\(dp[1]\\) и \\(dp[2]\\) . Их решения уже известны: \\(dp[1] = 1\\) и \\(dp[2] = 2\\) , что означает \\(1\\) и \\(2\\) способа подняться соответственно на \\(1\\)-ю и \\(2\\)-ю ступени.</p> <p>Посмотрите на следующий код: как и стандартный поиск с возвратом, он относится к поиску в глубину, но выглядит более компактно:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"Поиск\"\"\"\n    # dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: поиск\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* Поиск */\nint DFS(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* Поиск */\nfunc dfs(i int) int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* Поиск */\nfunc dfs(i: Int) -&gt; Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* Поиск */\nfunction dfs(i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* Поиск */\nfunction dfs(i: number): number {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* Поиск */\nint dfs(int i) {\n  // dp[1] и dp[2] уже известны, вернуть их\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* Поиск */\nfn dfs(i: usize) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* Подъем по лестнице: поиск */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* Поиск */\nint dfs(int i) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* Подъем по лестнице: поиск */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* Поиск */\nfun dfs(i: Int): Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* Подъем по лестнице: поиск */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### Поиск ###\ndef dfs(i)\n  # dp[1] и dp[2] уже известны, вернуть их\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### Подъем по лестнице: поиск ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-3 показано дерево рекурсии, возникающее при полном переборе. Для задачи \\(dp[n]\\) глубина дерева рекурсии равна \\(n\\) , а временная сложность равна \\(O(2^n)\\) . Экспоненциальный рост взрывообразен: если подать на вход достаточно большое значение \\(n\\) , ожидание станет очень долгим.</p> <p></p> <p> Рисунок 14-3   Дерево рекурсии для подъема по лестнице </p> <p>Если посмотреть на рисунок 14-3, то видно, что экспоненциальная временная сложность порождается \"перекрывающимися подзадачами\". Например, \\(dp[9]\\) раскладывается в \\(dp[8]\\) и \\(dp[7]\\) , а \\(dp[8]\\) - в \\(dp[7]\\) и \\(dp[6]\\) ; обе ветви содержат подзадачу \\(dp[7]\\) .</p> <p>Продолжая это рассуждение, мы видим, что подзадачи порождают все более мелкие перекрывающиеся подзадачи без конца. Подавляющая часть вычислительных ресурсов уходит именно на них.</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412-2","level":2,"title":"14.1.2   Метод 2: поиск с мемоизацией","text":"<p>Чтобы ускорить алгоритм, мы хотим, чтобы каждая перекрывающаяся подзадача вычислялась только один раз. Для этого объявим массив <code>mem</code> для хранения решения каждой подзадачи и будем обрезать повторные вычисления в процессе поиска.</p> <ol> <li>Когда \\(dp[i]\\) вычисляется впервые, мы сохраняем его в <code>mem[i]</code> для последующего использования.</li> <li>Когда значение \\(dp[i]\\) требуется снова, мы просто берем его напрямую из <code>mem[i]</code> и тем самым избегаем повторного вычисления подзадачи.</li> </ol> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"Поиск с мемоизацией\"\"\"\n    # dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 or i == 2:\n        return i\n    # Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # Сохранить dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: поиск с мемоизацией\"\"\"\n    # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, int[] mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* Поиск с мемоизацией */\nint DFS(int i, int[] mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* Поиск с мемоизацией */\nfunc dfsMem(i int, mem []int) int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* Поиск с мемоизацией */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* Поиск с мемоизацией */\nfunction dfs(i, mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* Поиск с мемоизацией */\nfunction dfs(i: number, mem: number[]): number {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i === 1 || i === 2) return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, List&lt;int&gt; mem) {\n  // dp[1] и dp[2] уже известны, вернуть их\n  if (i == 1 || i == 2) return i;\n  // Если запись dp[i] существует, сразу вернуть ее\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // Сохранить dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n  // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* Поиск с мемоизацией */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // Если запись dp[i] существует, сразу вернуть ее\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* Поиск с мемоизацией */\nint dfs(int i, int *mem) {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2)\n        return i;\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // Сохранить dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nint climbingStairsDFSMem(int n) {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* Поиск с мемоизацией */\nfun dfs(i: Int, mem: IntArray): Int {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if (i == 1 || i == 2) return i\n    // Если запись dp[i] существует, сразу вернуть ее\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // Сохранить dp[i]\n    mem[i] = count\n    return count\n}\n\n/* Подъем по лестнице: поиск с мемоизацией */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### Поиск с мемоизацией ###\ndef dfs(i, mem)\n  # dp[1] и dp[2] уже известны, вернуть их\n  return i if i == 1 || i == 2\n  # Если запись dp[i] существует, сразу вернуть ее\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # Сохранить dp[i]\n  mem[i] = count\nend\n\n### Подъем по лестнице: поиск с мемоизацией ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-4, после введения мемоизации каждая перекрывающаяся подзадача вычисляется только один раз, и временная сложность оптимизируется до \\(O(n)\\) . Это огромный скачок в эффективности.</p> <p></p> <p> Рисунок 14-4   Дерево рекурсии для поиска с мемоизацией </p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413-3","level":2,"title":"14.1.3   Метод 3: динамическое программирование","text":"<p>Поиск с мемоизацией - это метод \"сверху вниз\" : мы начинаем с исходной задачи (корня), рекурсивно раскладываем более крупные подзадачи на меньшие, пока не достигнем наименьших подзадач с уже известным ответом (листьев). Затем в процессе возврата постепенно собираем решения подзадач и тем самым получаем решение исходной задачи.</p> <p>Напротив, динамическое программирование - это метод \"снизу вверх\" : начиная с решений наименьших подзадач, мы итеративно строим решения для более крупных подзадач, пока не получим ответ на исходную задачу.</p> <p>Поскольку в динамическом программировании нет этапа возврата, для его реализации достаточно обычных циклов, без рекурсии. В приведенном ниже коде мы инициализируем массив <code>dp</code> для хранения решений подзадач; он выполняет ту же роль, что и массив <code>mem</code> в мемоизированном поиске:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: динамическое программирование\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # Инициализация таблицы dp для хранения решений подзадач\n    dp = [0] * (n + 1)\n    # Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1], dp[2] = 1, 2\n    # Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    vector&lt;int&gt; dp(n + 1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Подъем по лестнице: динамическое программирование */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int[] dp = new int[n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    dp := make([]int, n+1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    var dp = Array(repeating: 0, count: n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1).fill(-1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Подъем по лестнице: динамическое программирование */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    const dp = new Array(n + 1).fill(-1);\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // Инициализация таблицы dp для хранения решений подзадач\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1] = 1;\n  dp[2] = 2;\n  // Переход состояний: постепенное решение больших подзадач через меньшие\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Подъем по лестнице: динамическое программирование */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // dp[1] и dp[2] уже известны, вернуть их\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // Инициализация таблицы dp для хранения решений подзадач\n    let mut dp = vec![-1; n + 1];\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Подъем по лестнице: динамическое программирование */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // Инициализация таблицы dp для хранения решений подзадач\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1;\n    dp[2] = 2;\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Подъем по лестнице: динамическое программирование */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // Инициализация таблицы dp для хранения решений подзадач\n    val dp = IntArray(n + 1)\n    // Начальное состояние: заранее задать решения наименьших подзадач\n    dp[1] = 1\n    dp[2] = 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Подъем по лестнице: динамическое программирование ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # Инициализация таблицы dp для хранения решений подзадач\n  dp = Array.new(n + 1, 0)\n  # Начальное состояние: заранее задать решения наименьших подзадач\n  dp[1], dp[2] = 1, 2\n  # Переход состояний: постепенное решение больших подзадач через меньшие\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-5 смоделирован процесс выполнения этого кода.</p> <p></p> <p> Рисунок 14-5   Процесс динамического программирования для подъема по лестнице </p> <p>Как и в поиске с возвратом, в динамическом программировании используется понятие \"состояние\" для обозначения некоторого этапа решения задачи; каждое состояние соответствует одной подзадаче и ее локально оптимальному решению. Например, в задаче о лестнице состояние определяется текущим номером ступени \\(i\\) .</p> <p>На основе сказанного можно подвести несколько часто используемых терминов динамического программирования.</p> <ul> <li>Массив <code>dp</code> называют таблицей dp, а \\(dp[i]\\) обозначает решение подзадачи, соответствующей состоянию \\(i\\) .</li> <li>Состояния, соответствующие наименьшим подзадачам (первая и вторая ступени), называют начальными состояниями.</li> <li>Рекуррентную формулу \\(dp[i] = dp[i-1] + dp[i-2]\\) называют уравнением перехода состояния.</li> </ul>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   Оптимизация пространства","text":"<p>Внимательный читатель мог заметить, что поскольку \\(dp[i]\\) зависит только от \\(dp[i-1]\\) и \\(dp[i-2]\\) , нам не нужен весь массив <code>dp</code> для хранения ответов всех подзадач ; достаточно двух переменных, которые будут \"перекатываться\" вперед. Код имеет вид:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"Подъем по лестнице: динамическое программирование с оптимизацией памяти\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // Переход состояний: постепенное решение больших подзадач через меньшие\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### Подъем по лестнице: динамическое программирование с оптимизацией памяти ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Из кода видно, что после отказа от массива <code>dp</code> пространственная сложность уменьшается с \\(O(n)\\) до \\(O(1)\\) .</p> <p>Во многих задачах динамического программирования текущее состояние зависит лишь от ограниченного числа предыдущих состояний. Тогда можно сохранять только действительно нужные состояния и за счет \"уменьшения размерности\" экономить память. Этот прием оптимизации памяти называют \"скользящими переменными\" или \"скользящим массивом\".</p>","path":["Глава 14. Динамическое программирование","14.1 &nbsp; Первое знакомство с динамическим программированием"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   Задача о рюкзаке 0-1","text":"<p>Задача о рюкзаке является отличным примером для начала изучения динамического программирования и представляет собой одну из наиболее распространенных форм этой задачи. У нее существует множество вариантов, например задача о рюкзаке 0-1, задача о полном рюкзаке, задача о многократном рюкзаке и т.д.</p> <p>В этом разделе сначала разберем самый распространенный вариант - задачу о рюкзаке 0-1.</p> <p>Question</p> <p>Даны \\(n\\) предметов. Вес \\(i\\)-го предмета равен \\(wgt[i-1]\\) , стоимость равна \\(val[i-1]\\) . Также дан рюкзак вместимости \\(cap\\) . Каждый предмет можно выбрать только один раз. Найдите максимальную суммарную стоимость, которую можно поместить в рюкзак при заданной вместимости.</p> <p>Как видно на рисунке 14-17, поскольку номер предмета \\(i\\) начинается с \\(1\\) , а индексы массива начинаются с \\(0\\) , предмету \\(i\\) соответствуют вес \\(wgt[i-1]\\) и стоимость \\(val[i-1]\\) .</p> <p></p> <p> Рисунок 14-17   Пример данных для задачи о рюкзаке 0-1 </p> <p>Задачу о рюкзаке 0-1 можно рассматривать как процесс из \\(n\\) раундов принятия решений: для каждого предмета есть два решения - не класть его в рюкзак или положить в рюкзак. Поэтому задача удовлетворяет модели дерева решений.</p> <p>Цель задачи - найти \"максимальную суммарную стоимость при ограниченной вместимости рюкзака\", а это с большой вероятностью указывает на задачу динамического программирования.</p> <p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>Для каждого предмета возможны два случая: не класть его в рюкзак, тогда вместимость не меняется; или положить его в рюкзак, тогда оставшаяся вместимость уменьшается. Отсюда получается определение состояния: текущий номер предмета \\(i\\) и текущая вместимость рюкзака \\(c\\) , то есть состояние обозначается как \\([i, c]\\) .</p> <p>Подзадача, соответствующая состоянию \\([i, c]\\) , такова: максимальная стоимость, которую можно получить, используя первые \\(i\\) предметов и рюкзак вместимости \\(c\\). Ее решение обозначается через \\(dp[i, c]\\) .</p> <p>Искомым значением является \\(dp[n, cap]\\) , значит, нам нужна двумерная таблица \\(dp\\) размера \\((n+1) \\times (cap+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>После того как мы принимаем решение по предмету \\(i\\) , остается подзадача, связанная с первыми \\(i-1\\) предметами. Здесь возможны два случая.</p> <ul> <li>Не класть предмет \\(i\\) : вместимость рюкзака не меняется, и состояние переходит в \\([i-1, c]\\) .</li> <li>Положить предмет \\(i\\) : вместимость рюкзака уменьшается на \\(wgt[i-1]\\) , а стоимость увеличивается на \\(val[i-1]\\) , и состояние переходит в \\([i-1, c-wgt[i-1]]\\) .</li> </ul> <p>Этот анализ и раскрывает оптимальную подструктуру задачи: максимальная стоимость \\(dp[i, c]\\) равна лучшему из двух вариантов - не брать предмет \\(i\\) или взять предмет \\(i\\). Отсюда получается уравнение перехода состояния:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>Нужно учитывать, что если вес текущего предмета \\(wgt[i - 1]\\) превышает оставшуюся вместимость \\(c\\) , то предмет можно только не брать.</p> <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда предметов нет или вместимость рюкзака равна \\(0\\) , максимальная стоимость равна \\(0\\) ; то есть весь первый столбец \\(dp[i, 0]\\) и вся первая строка \\(dp[0, c]\\) заполняются нулями.</p> <p>Текущее состояние \\([i, c]\\) зависит от состояния сверху \\([i-1, c]\\) и состояния слева сверху \\([i-1, c-wgt[i-1]]\\) , поэтому достаточно двумя вложенными циклами пройти по всей таблице \\(dp\\) в прямом порядке.</p> <p>После этого анализа реализуем по порядку: полный перебор, поиск с мемоизацией и динамическое программирование.</p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1-1","level":3,"title":"1.   Метод 1: полный перебор","text":"<p>Код поиска содержит следующие элементы.</p> <ul> <li>Параметры рекурсии: состояние \\([i, c]\\) .</li> <li>Возвращаемое значение: решение подзадачи \\(dp[i, c]\\) .</li> <li>Условие завершения: когда номер предмета выходит за границу, то есть \\(i = 0\\) , или оставшаяся вместимость равна \\(0\\) , рекурсия завершается и возвращается стоимость \\(0\\) .</li> <li>Обрезка: если вес текущего предмета превышает оставшуюся вместимость рюкзака, то можно только не класть этот предмет.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: полный перебор\"\"\"\n    # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 or c == 0:\n        return 0\n    # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: полный перебор */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: полный перебор */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: полный перебор */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: полный перебор */\nfunction knapsackDFS(wgt, val, i, c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: полный перебор */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Вернуть вариант с большей стоимостью из двух возможных\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: полный перебор */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: полный перебор */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: полный перебор */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: полный перебор ###\ndef knapsack_dfs(wgt, val, i, c)\n  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  return 0 if i == 0 || c == 0\n  # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Вернуть вариант с большей стоимостью из двух возможных\n  [no, yes].max\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-18, поскольку каждый предмет создает две ветви поиска - \"не брать\" и \"брать\", временная сложность равна \\(O(2^n)\\) .</p> <p>Посмотрев на дерево рекурсии, легко заметить наличие перекрывающихся подзадач, например \\(dp[1, 10]\\) и подобных. Когда число предметов растет, вместимость рюкзака велика, а особенно когда много предметов с одинаковым весом, количество перекрывающихся подзадач быстро увеличивается.</p> <p></p> <p> Рисунок 14-18   Дерево полного перебора для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2-2","level":3,"title":"2.   Метод 2: мемоизация","text":"<p>Чтобы каждая перекрывающаяся подзадача вычислялась только один раз, используем таблицу памяти <code>mem</code> для хранения решений подзадач, где <code>mem[i][c]</code> соответствует \\(dp[i, c]\\) .</p> <p>После введения мемоизации временная сложность определяется числом подзадач , то есть равна \\(O(n \\times cap)\\) . Код выглядит так:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"Рюкзак 0-1: поиск с мемоизацией\"\"\"\n    # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 or c == 0:\n        return 0\n    # Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // Вернуть вариант с большей стоимостью из двух возможных\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // Если запись уже есть, вернуть сразу\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // Сохранить и вернуть вариант с большей стоимостью из двух решений\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: поиск с мемоизацией */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // Если запись уже есть, вернуть сразу\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // Сохранить и вернуть вариант с большей стоимостью из двух решений\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: поиск с мемоизацией ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0\n  return 0 if i == 0 || c == 0\n  # Если запись уже есть, вернуть сразу\n  return mem[i][c] if mem[i][c] != -1\n  # Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # Сохранить и вернуть вариант с большей стоимостью из двух решений\n  mem[i][c] = [no, yes].max\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>На рисунке 14-19 показаны ветви поиска, которые были отсечены благодаря мемоизации.</p> <p></p> <p> Рисунок 14-19   Дерево поиска с мемоизацией для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3-3","level":3,"title":"3.   Метод 3: динамическое программирование","text":"<p>По своей сути динамическое программирование здесь - это процесс последовательного заполнения таблицы \\(dp\\) в соответствии с переходами состояний. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: динамическое программирование\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # Переход состояний\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: динамическое программирование */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: динамическое программирование */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: динамическое программирование ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-20, и временная сложность, и пространственная сложность определяются размером массива <code>dp</code> , то есть равны \\(O(n \\times cap)\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-20   Процесс динамического программирования для задачи о рюкзаке 0-1 </p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   Оптимизация пространства","text":"<p>Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с \\(O(n^2)\\) до \\(O(n)\\) .</p> <p>Если пойти дальше, можно спросить: можно ли оптимизировать память так, чтобы использовать только один массив? Наблюдение показывает, что каждое состояние зависит от клетки прямо сверху и клетки слева сверху. Предположим, что у нас есть только один массив, и в момент начала обхода строки \\(i\\) он еще хранит состояния строки \\(i-1\\) .</p> <ul> <li>Если обходить массив слева направо, то к моменту вычисления \\(dp[i, j]\\) значения слева сверху \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) могут уже быть перезаписаны, и правильный результат перехода состояния получить не удастся.</li> <li>Если же обходить массив справа налево, проблема перезаписи не возникает, и переход состояния вычисляется корректно.</li> </ul> <p>На рисунке 14-21 показан процесс перехода от строки \\(i = 1\\) к строке \\(i = 2\\) при использовании одного массива. С его помощью удобно понять различие между прямым и обратным обходом.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-21   Процесс динамического программирования после оптимизации памяти для рюкзака 0-1 </p> <p>В коде для этого достаточно удалить первое измерение массива <code>dp</code> , а внутренний цикл заменить на обратный обход:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Рюкзак 0-1: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [0] * (cap + 1)\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Обход в обратном порядке\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([]int, cap+1)\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Обход в обратном порядке\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: cap + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        // Обход в обратном порядке\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(cap + 1).fill(0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array(cap + 1).fill(0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    // Обход в обратном порядке\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; cap + 1];\n    // Переход состояний\n    for i in 1..=n {\n        // Обход в обратном порядке\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(cap + 1, sizeof(int));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        // Обход в обратном порядке\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = IntArray(cap + 1)\n    // Переход состояний\n    for (i in 1..n) {\n        // Обход в обратном порядке\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(cap + 1, 0)\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Обход в обратном порядке\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.4 &nbsp; Задача о рюкзаке 0-1"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   Резюме","text":"","path":["Глава 14. Динамическое программирование","14.7 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Динамическое программирование раскладывает задачу на подзадачи и повышает вычислительную эффективность за счет хранения решений этих подзадач и устранения повторных вычислений.</li> <li>Если не учитывать затраты времени, то любую задачу динамического программирования можно решить с помощью поиска с возвратом (полного перебора), однако в дереве рекурсии возникает множество перекрывающихся подзадач, из-за чего эффективность крайне низка. После введения таблицы памяти можно хранить решения всех уже вычисленных подзадач и гарантировать, что каждая перекрывающаяся подзадача будет вычисляться только один раз.</li> <li>Поиск с мемоизацией - это рекурсивный метод \"сверху вниз\", а соответствующее ему динамическое программирование - это итеративный метод \"снизу вверх\", похожий на заполнение таблицы. Поскольку текущее состояние обычно зависит только от части локальных состояний, можно убрать одно измерение таблицы \\(dp\\) и тем самым снизить пространственную сложность.</li> <li>Разложение на подзадачи - это общий алгоритмический подход, но в методе \"разделяй и властвуй\", динамическом программировании и поиске с возвратом он имеет разные свойства.</li> <li>Для задач динамического программирования характерны три главных свойства: перекрывающиеся подзадачи, оптимальная подструктура и отсутствие последствий.</li> <li>Если оптимальное решение исходной задачи можно построить из оптимальных решений подзадач, то задача обладает оптимальной подструктурой.</li> <li>Отсутствие последствий означает, что для данного состояния его дальнейшее развитие определяется только этим состоянием и не зависит от всех прошлых состояний. Многие задачи комбинаторной оптимизации этим свойством не обладают и потому не могут эффективно решаться с помощью динамического программирования.</li> </ul> <p>Задачи о рюкзаке</p> <ul> <li>Задача о рюкзаке - один из самых типичных классов задач динамического программирования; она включает варианты 0-1 рюкзака, полного рюкзака, многократного рюкзака и другие.</li> <li>В задаче о рюкзаке 0-1 состояние определяется как максимальная стоимость первых \\(i\\) предметов в рюкзаке вместимости \\(c\\) . Рассматривая два решения - не брать предмет и брать предмет, - можно получить оптимальную подструктуру и вывести уравнение перехода состояния. При оптимизации памяти, поскольку каждое состояние зависит от значения сверху и слева сверху, внутренний цикл нужно выполнять в обратном порядке, чтобы не перезаписать нужное значение.</li> <li>В задаче о полном рюкзаке число экземпляров каждого предмета не ограничено, поэтому при выборе предмета переход состояния отличается от варианта 0-1. Поскольку состояние зависит от значения сверху и слева, после оптимизации памяти внутренний цикл следует выполнять в прямом порядке.</li> <li>Задача о размене монет - это вариант задачи о полном рюкзаке. Здесь вместо \"максимальной стоимости\" ищется \"минимальное число монет\", поэтому в уравнении перехода \\(\\max()\\) заменяется на \\(\\min()\\) . Кроме того, вместо условия \"не превышать вместимость рюкзака\" нужно ровно набрать целевую сумму, поэтому значение \\(amt + 1\\) используется как обозначение недопустимого решения \"сумму набрать нельзя\".</li> <li>В задаче о размене монет II вместо \"минимального числа монет\" требуется найти \"число комбинаций монет\", поэтому в уравнении перехода оператор \\(\\min()\\) заменяется на суммирование.</li> </ul> <p>Задача о расстоянии редактирования</p> <ul> <li>Расстояние редактирования (расстояние Левенштейна) используется для измерения сходства двух строк и определяется как минимальное число операций редактирования, необходимых для преобразования одной строки в другую; допустимые операции - вставка, удаление и замена.</li> <li>В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых \\(i\\) символов строки \\(s\\) в первые \\(j\\) символов строки \\(t\\) . Если \\(s[i] \\ne t[j]\\) , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же \\(s[i] = t[j]\\) , то редактировать текущий символ не нужно.</li> <li>В задаче о расстоянии редактирования состояние зависит от значений сверху, слева и слева сверху. Поэтому после оптимизации памяти ни прямой, ни обратный обход сам по себе не дает корректного перехода состояния. Для решения этой проблемы значение слева сверху временно сохраняется в отдельной переменной, что делает ситуацию эквивалентной задаче о полном рюкзаке и позволяет использовать прямой обход.</li> </ul>","path":["Глава 14. Динамическое программирование","14.7 &nbsp; Резюме"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   Задача о полном рюкзаке","text":"<p>В этом разделе сначала решим еще одну распространенную задачу о рюкзаке - задачу о полном рюкзаке, а затем рассмотрим один из ее типичных частных случаев: задачу о размене монет.</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   Задача о полном рюкзаке","text":"<p>Question</p> <p>Даны \\(n\\) предметов. Вес \\(i\\)-го предмета равен \\(wgt[i-1]\\) , стоимость равна \\(val[i-1]\\) . Также дан рюкзак вместимости \\(cap\\) . Каждый предмет можно выбирать многократно. Найдите максимальную суммарную стоимость, которую можно поместить в рюкзак при заданной вместимости. Пример показан на рисунке 14-22.</p> <p></p> <p> Рисунок 14-22   Пример данных для задачи о полном рюкзаке </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Задача о полном рюкзаке очень похожа на задачу о рюкзаке 0-1; разница состоит только в том, что количество выборов каждого предмета не ограничено.</p> <ul> <li>В задаче о рюкзаке 0-1 каждого предмета существует только один экземпляр, поэтому после того как предмет \\(i\\) помещен в рюкзак, выбирать можно только из первых \\(i-1\\) предметов.</li> <li>В задаче о полном рюкзаке количество предметов не ограничено, поэтому после того как предмет \\(i\\) помещен в рюкзак, можно продолжать выбирать из первых \\(i\\) предметов.</li> </ul> <p>При этом состояние \\([i, c]\\) в задаче о полном рюкзаке может изменяться двумя способами.</p> <ul> <li>Не брать предмет \\(i\\) : как и в задаче о рюкзаке 0-1, переход осуществляется в \\([i-1, c]\\) .</li> <li>Взять предмет \\(i\\) : в отличие от рюкзака 0-1 переход происходит в \\([i, c-wgt[i-1]]\\) .</li> </ul> <p>Следовательно, уравнение перехода состояния принимает вид:</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   Реализация кода","text":"<p>Если сравнить код этой задачи с кодом задачи о рюкзаке 0-1, то окажется, что в переходе состояний меняется только одна деталь: вместо \\(i-1\\) появляется \\(i\\) ; все остальное остается таким же:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Полный рюкзак: динамическое программирование\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # Переход состояний\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Полный рюкзак: динамическое программирование */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Полный рюкзак: динамическое программирование */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Полный рюкзак: динамическое программирование */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Полный рюкзак: динамическое программирование */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Полный рюкзак: динамическое программирование */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Полный рюкзак: динамическое программирование */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Полный рюкзак: динамическое программирование */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Полный рюкзак: динамическое программирование */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Полный рюкзак: динамическое программирование ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   Оптимизация пространства","text":"<p>Поскольку текущее состояние переходит из состояния слева и состояния сверху, после оптимизации памяти каждую строку таблицы \\(dp\\) нужно обходить слева направо.</p> <p>Этот порядок обхода как раз противоположен задаче о рюкзаке 0-1. Разницу удобно понять по рисунку ниже.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-23   Процесс динамического программирования после оптимизации памяти для полного рюкзака </p> <p>Код реализации здесь довольно прост: достаточно просто убрать первое измерение массива <code>dp</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Полный рюкзак: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(wgt)\n    # Инициализация таблицы dp\n    dp = [0] * (cap + 1)\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            else:\n                # Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[cap + 1];\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // Инициализация таблицы dp\n    dp := make([]int, cap+1)\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: cap + 1)\n    // Переход состояний\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c];\n      } else {\n        // Большее из двух решений: не брать или взять предмет i\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; cap + 1];\n    // Переход состояний\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(cap + 1, sizeof(int));\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c];\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* Полный рюкзак: динамическое программирование с оптимизацией памяти */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // Инициализация таблицы dp\n    val dp = IntArray(cap + 1)\n    // Переход состояний\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // Если вместимость рюкзака превышена, предмет i не выбирать\n                dp[c] = dp[c]\n            } else {\n                // Большее из двух решений: не брать или взять предмет i\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### Полный рюкзак: динамическое программирование ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[i][c] = dp[i - 1][c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n# ## Полный рюкзак: динамическое программирование с оптимизацией памяти ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # Инициализация таблицы dp\n  dp = Array.new(cap + 1, 0)\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # Если вместимость рюкзака превышена, предмет i не выбирать\n        dp[c] = dp[c]\n      else\n        # Большее из двух решений: не брать или взять предмет i\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   Задача о размене монет","text":"<p>Задача о рюкзаке представляет собой целый класс задач динамического программирования, у которого есть множество вариантов, и одной из таких вариаций является задача о размене монет.</p> <p>Question</p> <p>Даны \\(n\\) видов монет, номинал монеты \\(i\\) равен \\(coins[i - 1]\\) , а целевая сумма равна \\(amt\\) . Монеты каждого вида можно брать многократно. Требуется найти минимальное число монет, которыми можно набрать целевую сумму. Если набрать сумму невозможно, верните \\(-1\\) . Пример показан на рисунке 14-24.</p> <p></p> <p> Рисунок 14-24   Пример данных для задачи о размене монет </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   Идея динамического программирования","text":"<p>Задачу о размене монет можно рассматривать как частный случай задачи о полном рюкзаке ; между ними существуют следующие соответствия и различия.</p> <ul> <li>Эти две задачи можно взаимно преобразовать: \"предмет\" соответствует \"монете\", \"вес предмета\" соответствует \"номиналу монеты\", а \"вместимость рюкзака\" соответствует \"целевой сумме\".</li> <li>Цель оптимизации противоположна: в задаче о полном рюкзаке нужно максимизировать стоимость предметов, а в задаче о размене монет - минимизировать число монет.</li> <li>В задаче о полном рюкзаке ищется решение, не превышающее вместимость, а в задаче о размене монет требуется ровно набрать целевую сумму.</li> </ul> <p>Шаг 1: продумать решения на каждом раунде, определить состояние и тем самым получить таблицу \\(dp\\)</p> <p>Подзадача, соответствующая состоянию \\([i, a]\\) , выглядит так: минимальное число монет из первых \\(i\\) видов, которыми можно набрать сумму \\(a\\). Решение этой подзадачи обозначается как \\(dp[i, a]\\) .</p> <p>Размер двумерной таблицы \\(dp\\) равен \\((n+1) \\times (amt+1)\\) .</p> <p>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</p> <p>По сравнению с задачей о полном рюкзаке здесь есть два отличия в уравнении перехода состояния.</p> <ul> <li>Нужно искать минимум, а не максимум, поэтому оператор \\(\\max()\\) заменяется на \\(\\min()\\) .</li> <li>Оптимизируемое значение - это число монет, а не суммарная стоимость, поэтому при выборе монеты нужно просто прибавить \\(1\\) .</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>Шаг 3: определить граничные условия и порядок переходов</p> <p>Когда целевая сумма равна \\(0\\) , минимальное число монет для ее набора равно \\(0\\) , то есть весь первый столбец \\(dp[i, 0]\\) заполняется нулями.</p> <p>Когда монет нет, невозможно набрать никакую целевую сумму \\(&gt; 0\\) ; это и есть недопустимое решение. Чтобы функция \\(\\min()\\) в уравнении перехода состояния могла распознавать и отбрасывать такие недопустимые решения, удобно использовать значение \\(+ \\infty\\) ; то есть всю первую строку \\(dp[0, a]\\) нужно инициализировать значением \\(+ \\infty\\) .</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   Реализация кода","text":"<p>Большинство языков программирования не предоставляет представление для \\(+ \\infty\\) в целочисленном виде, поэтому обычно приходится заменять его на максимальное значение типа <code>int</code> . Но тогда возникает риск переполнения: операция \\(+ 1\\) в уравнении перехода может переполнить большое число.</p> <p>Поэтому здесь мы используем число \\(amt + 1\\) как обозначение недопустимого решения, потому что для набора суммы \\(amt\\) максимум нужно не больше чем \\(amt\\) монет. Перед возвратом результата проверяем, равно ли \\(dp[n, amt]\\) значению \\(amt + 1\\) ; если да, то возвращаем \\(-1\\) , что означает невозможность набрать целевую сумму. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: динамическое программирование\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Инициализация таблицы dp\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Переход состояний: первая строка и первый столбец\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # Переход состояний: остальные строки и столбцы\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][amt + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Размен монет: динамическое программирование */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, amt + 1];\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Переход состояний: первая строка и первый столбец\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Переход состояний: первая строка и первый столбец\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Размен монет: динамическое программирование */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Размен монет: динамическое программирование */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Переход состояний: первая строка и первый столбец\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Переход состояний: первая строка и первый столбец\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // Переход состояний: остальные строки и столбцы\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Меньшее из двух решений: не брать или взять монету i\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Размен монет: динамическое программирование */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Переход состояний: первая строка и первый столбец\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Размен монет: динамическое программирование */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Переход состояний: первая строка и первый столбец\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Размен монет: динамическое программирование */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Переход состояний: первая строка и первый столбец\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // Переход состояний: остальные строки и столбцы\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Размен монет: динамическое программирование ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Переход состояний: первая строка и первый столбец\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # Переход состояний: остальные строки и столбцы\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Меньшее из двух решений: не брать или взять монету i\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 14-25, процесс динамического программирования для задачи о размене монет очень похож на задачу о полном рюкзаке.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 14-25   Процесс динамического программирования для задачи о размене монет </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   Оптимизация пространства","text":"<p>Оптимизация пространства для задачи о размене монет выполняется так же, как и для полного рюкзака:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # Инициализация таблицы dp\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            else:\n                # Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* Размен монет: динамическое программирование */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // Инициализация таблицы dp\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Прямой обход\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // Инициализация таблицы dp\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a];\n      } else {\n        // Меньшее из двух решений: не брать или взять монету i\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // Инициализация таблицы dp\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // Инициализация таблицы dp\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* Размен монет: динамическое программирование с оптимизацией памяти */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // Инициализация таблицы dp\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Меньшее из двух решений: не брать или взять монету i\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### Размен монет: динамическое программирование с оптимизацией памяти ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # Инициализация таблицы dp\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a]\n      else\n        # Меньшее из двух решений: не брать или взять монету i\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   Задача о размене монет II","text":"<p>Question</p> <p>Даны \\(n\\) видов монет, номинал монеты \\(i\\) равен \\(coins[i - 1]\\) , а целевая сумма равна \\(amt\\) . Монеты каждого вида можно брать многократно. Найдите число различных комбинаций монет, которыми можно набрать целевую сумму. Пример показан на рисунке 14-26.</p> <p></p> <p> Рисунок 14-26   Пример данных для задачи о размене монет II </p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   Идея динамического программирования","text":"<p>По сравнению с предыдущей задачей здесь целью является число комбинаций. Поэтому подзадача меняется на следующую: число комбинаций из первых \\(i\\) видов монет, которыми можно набрать сумму \\(a\\). При этом таблица \\(dp\\) по-прежнему остается двумерной матрицей размера \\((n+1) \\times (amt + 1)\\) .</p> <p>Число комбинаций для текущего состояния равно сумме числа комбинаций для двух решений: не брать текущую монету и брать текущую монету. Поэтому уравнение перехода состояния принимает вид:</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>Когда целевая сумма равна \\(0\\) , ее можно набрать, не выбирая ни одной монеты, поэтому весь первый столбец \\(dp[i, 0]\\) нужно инициализировать единицами. Когда монет нет, невозможно набрать никакую сумму \\(&gt;0\\) , поэтому вся первая строка \\(dp[0, a]\\) должна быть заполнена нулями.</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   Реализация кода","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет II: динамическое программирование\"\"\"\n    n = len(coins)\n    # Инициализация таблицы dp\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # Инициализация первого столбца\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # Переход состояний\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Инициализация таблицы dp\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // Инициализация таблицы dp\n    int[][] dp = new int[n + 1][amt + 1];\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Размен монет II: динамическое программирование */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // Инициализация таблицы dp\n    int[,] dp = new int[n + 1, amt + 1];\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Размен монет II: динамическое программирование */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // Инициализация таблицы dp\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // Инициализация первого столбца\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // Переход состояний: остальные строки и столбцы\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Размен монет II: динамическое программирование */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // Инициализация первого столбца\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Размен монет II: динамическое программирование */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Инициализация первого столбца\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Размен монет II: динамическое программирование */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // Инициализация первого столбца\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Инициализация таблицы dp\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // Инициализация первого столбца\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // Сумма двух решений: не брать или взять монету i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Размен монет II: динамическое программирование */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // Инициализация первого столбца\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Размен монет II: динамическое программирование */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Инициализация таблицы dp\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // Инициализация первого столбца\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // Освободить память\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Размен монет II: динамическое программирование */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Инициализация таблицы dp\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // Инициализация первого столбца\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Размен монет II: динамическое программирование ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # Инициализация таблицы dp\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # Инициализация первого столбца\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # Переход состояний\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[i][a] = dp[i - 1][a]\n      else\n        # Сумма двух решений: не брать или взять монету i\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   Оптимизация пространства","text":"<p>При оптимизации памяти способ остается тем же самым: достаточно убрать измерение, отвечающее за виды монет:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет II: динамическое программирование с оптимизацией памяти\"\"\"\n    n = len(coins)\n    # Инициализация таблицы dp\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # Переход состояний\n    for i in range(1, n + 1):\n        # Прямой обход\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            else:\n                # Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // Инициализация таблицы dp\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // Инициализация таблицы dp\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // Инициализация таблицы dp\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // Переход состояний\n    for i := 1; i &lt;= n; i++ {\n        // Прямой обход\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // Инициализация таблицы dp\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // Переход состояний\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // Инициализация таблицы dp\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // Переход состояний\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // Инициализация таблицы dp\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // Переход состояний\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a];\n      } else {\n        // Сумма двух решений: не брать или взять монету i\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // Инициализация таблицы dp\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // Переход состояний\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // Инициализация таблицы dp\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // Переход состояний\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a];\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // Освободить память\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* Размен монет II: динамическое программирование с оптимизацией памяти */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // Инициализация таблицы dp\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // Переход состояний\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // Если целевая сумма превышена, монету i не выбирать\n                dp[a] = dp[a]\n            } else {\n                // Сумма двух решений: не брать или взять монету i\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### Размен монет II: динамическое программирование с оптимизацией памяти ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # Инициализация таблицы dp\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # Переход состояний\n  for i in 1...(n + 1)\n    # Прямой обход\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # Если целевая сумма превышена, монету i не выбирать\n        dp[a] = dp[a]\n      else\n        # Сумма двух решений: не брать или взять монету i\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 14. Динамическое программирование","14.5 &nbsp; Задача о полном рюкзаке"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"Глава 9.   Графы","text":"<p>Abstract</p> <p>В жизни мы похожи на вершины, соединенные множеством невидимых ребер.</p> <p>Каждая встреча и каждое расставание оставляют в этой огромной сети свой след.</p>","path":["Глава 9. Графы","Глава 9. &nbsp; Графы"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>9.1   Граф</li> <li>9.2   Базовые операции графа</li> <li>9.3   Обход графа</li> <li>9.4   Краткие итоги</li> </ul>","path":["Глава 9. Графы","Глава 9. &nbsp; Графы"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   Граф","text":"<p>Граф (graph) - это нелинейная структура данных, состоящая из вершин (vertex) и ребер (edge). Граф \\(G\\) можно абстрактно представить как множество вершин \\(V\\) и множество ребер \\(E\\) . Ниже приведен пример графа, содержащего 5 вершин и 7 ребер.</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>Если рассматривать вершины как узлы, а ребра как ссылки, соединяющие узлы, граф можно считать структурой данных, расширяющей связный список. Как показано на рисунке 9-1, по сравнению с линейными отношениями (связный список) и отношениями разделения (дерево), сетевые отношения (граф) обладают большей свободой и потому являются более сложными.</p> <p></p> <p> Рисунок 9-1   Связь между связным списком, деревом и графом </p>","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   Распространенные типы и термины графов","text":"<p>В зависимости от наличия направления у ребер графы делятся на неориентированные графы (undirected graph) и ориентированные графы (directed graph) , как показано на рисунке 9-2.</p> <ul> <li>В неориентированном графе ребро представляет двустороннюю связь между двумя вершинами, например дружеские отношения в социальных сетях.</li> <li>В ориентированном графе ребро имеет направление, то есть ребра \\(A \\rightarrow B\\) и \\(A \\leftarrow B\\) независимы друг от друга, например отношения подписки и подписчиков.</li> </ul> <p></p> <p> Рисунок 9-2   Ориентированный и неориентированный графы </p> <p>В зависимости от того, связаны ли все вершины между собой, граф делится на связный граф (connected graph) и несвязный граф (disconnected graph) , как показано на рисунке 9-3.</p> <ul> <li>В связном графе из любой вершины можно достичь любой другой вершины.</li> <li>В несвязном графе существует по крайней мере одна вершина, недостижимая из текущей.</li> </ul> <p></p> <p> Рисунок 9-3   Связный и несвязный графы </p> <p>Мы также можем добавить к ребрам переменную \"вес\" и получить показанный ниже взвешенный граф (weighted graph). Например, в мобильных играх вроде Honor of Kings система рассчитывает \"близость\" между игроками по времени совместной игры, и такую сеть близости можно представить взвешенным графом.</p> <p></p> <p> Рисунок 9-4   Взвешенный и невзвешенный графы </p> <p>Со структурой данных \"граф\" связаны следующие основные термины.</p> <ul> <li>Смежность (adjacency): если между двумя вершинами существует ребро, то такие вершины называются смежными. На рисунке 9-4 с вершиной 1 смежны вершины 2, 3 и 5.</li> <li>Путь (path): последовательность ребер от вершины A до вершины B называется путем из A в B. На рисунке 9-4 последовательность ребер 1-5-2-4 является одним из путей от вершины 1 к вершине 4.</li> <li>Степень (degree): количество ребер, принадлежащих вершине. Для ориентированного графа входящая степень (in-degree) показывает, сколько ребер входит в вершину, а исходящая степень (out-degree) показывает, сколько ребер из нее выходит.</li> </ul>","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   Представление графа","text":"<p>Распространенные способы представления графа включают \"матрицу смежности\" и \"список смежности\". Ниже для примера рассматривается неориентированный граф.</p>","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   Матрица смежности","text":"<p>Пусть число вершин графа равно \\(n\\) ; тогда матрица смежности (adjacency matrix) использует матрицу размера \\(n \\times n\\) для представления графа, где каждая строка и каждый столбец соответствуют вершине, а элементы матрицы показывают наличие или отсутствие ребра.</p> <p>Как показано на рисунке 9-5, обозначим матрицу смежности через \\(M\\) , а список вершин через \\(V\\) ; тогда элемент матрицы \\(M[i, j] = 1\\) означает наличие ребра между вершинами \\(V[i]\\) и \\(V[j]\\) , а элемент \\(M[i, j] = 0\\) означает отсутствие ребра.</p> <p></p> <p> Рисунок 9-5   Представление графа матрицей смежности </p> <p>Матрица смежности обладает следующими особенностями.</p> <ul> <li>В простом графе вершина не может соединяться сама с собой, поэтому элементы на главной диагонали матрицы смежности не имеют значения.</li> <li>Для неориентированного графа ребра в обоих направлениях эквивалентны, поэтому матрица смежности симметрична относительно главной диагонали.</li> <li>Если заменить в матрице смежности значения \\(1\\) и \\(0\\) на веса, то можно представить взвешенный граф.</li> </ul> <p>При представлении графа матрицей смежности можно напрямую обращаться к элементам матрицы и получать сведения о ребрах, поэтому операции добавления, удаления, поиска и изменения обладают высокой эффективностью и выполняются за \\(O(1)\\) . Однако пространственная сложность матрицы составляет \\(O(n^2)\\) , поэтому она требует значительных затрат памяти.</p>","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   Список смежности","text":"<p>Список смежности (adjacency list) использует \\(n\\) списков для представления графа, где узлы списка обозначают вершины. \\(i\\)-й список соответствует вершине \\(i\\) и хранит все смежные с ней вершины, то есть все вершины, соединенные с данной вершиной. На рисунке 9-6 показан пример графа, представленного списком смежности.</p> <p></p> <p> Рисунок 9-6   Представление графа списком смежности </p> <p>Список смежности хранит только реально существующие ребра, а общее число ребер обычно значительно меньше \\(n^2\\) , поэтому он лучше экономит память. Однако для поиска ребра в списке смежности требуется обходить список, поэтому по времени он уступает матрице смежности.</p> <p>Если посмотреть на рисунок 9-6, можно заметить, что структура списка смежности очень похожа на цепную адресацию в хеш-таблицах, поэтому здесь можно использовать похожие методы оптимизации эффективности. Например, если список слишком длинный, его можно преобразовать в AVL-дерево или красно-черное дерево, чтобы снизить временную сложность с \\(O(n)\\) до \\(O(\\log n)\\) ; также список можно преобразовать в хеш-таблицу, чтобы довести временную сложность до \\(O(1)\\) .</p>","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   Типичные применения графов","text":"<p>Как показано в таблице 9-1, многие реальные системы можно моделировать с помощью графов, а соответствующие задачи затем сводить к задачам вычислений на графах.</p> <p> Таблица 9-1   Распространенные графы в реальной жизни </p> Вершина Ребро Задача вычислений на графе Социальные сети Пользователь Дружеская связь Рекомендация потенциальных друзей Линии метро Станция Связь между станциями Рекомендация кратчайшего маршрута Солнечная система Небесное тело Гравитационное взаимодействие между телами Вычисление орбит планет","path":["Глава 9. Графы","9.1 &nbsp; Граф"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   Базовые операции графа","text":"<p>Базовые операции графа можно разделить на операции над \"ребрами\" и операции над \"вершинами\". При двух способах представления, \"матрице смежности\" и \"списке смежности\", реализация этих операций различается.</p>","path":["Глава 9. Графы","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   Реализация на основе матрицы смежности","text":"<p>Пусть дан неориентированный граф с числом вершин \\(n\\) . Тогда способы реализации различных операций показаны на рисунках ниже.</p> <ul> <li>Добавление или удаление ребра: достаточно изменить соответствующее ребро в матрице смежности, что требует \\(O(1)\\) времени. Поскольку граф неориентированный, необходимо одновременно обновить ребра в обоих направлениях.</li> <li>Добавление вершины: в конец матрицы смежности добавляется строка и столбец, полностью заполненные нулями; это требует \\(O(n)\\) времени.</li> <li>Удаление вершины: из матрицы смежности удаляется строка и столбец. При удалении первой строки и первого столбца достигается худший случай, когда требуется \"сдвинуть влево вверх\" \\((n-1)^2\\) элементов, поэтому используется \\(O(n^2)\\) времени.</li> <li>Инициализация: передаются \\(n\\) вершин, затем инициализируется список вершин <code>vertices</code> длины \\(n\\) , что требует \\(O(n)\\) времени; после этого инициализируется матрица смежности <code>adjMat</code> размера \\(n \\times n\\) , что требует \\(O(n^2)\\) времени.</li> </ul> Инициализация матрицы смежностиДобавление ребраУдаление ребраДобавление вершиныУдаление вершины <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-7   Инициализация матрицы смежности, добавление и удаление ребер и вершин </p> <p>Ниже приведен код реализации графа на основе матрицы смежности:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"Класс неориентированного графа на основе матрицы смежности\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"Конструктор\"\"\"\n        # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n        self.vertices: list[int] = []\n        # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n        self.adj_mat: list[list[int]] = []\n        # Добавление вершины\n        for val in vertices:\n            self.add_vertex(val)\n        # Добавить ребра\n        # Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Получить число вершин\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"Добавление вершины\"\"\"\n        n = self.size()\n        # Добавить значение новой вершины в список вершин\n        self.vertices.append(val)\n        # Добавить строку в матрицу смежности\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # Добавить столбец в матрицу смежности\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"Удаление вершины\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # Удалить вершину с индексом index из списка вершин\n        self.vertices.pop(index)\n        # Удалить строку с индексом index из матрицы смежности\n        self.adj_mat.pop(index)\n        # Удалить столбец с индексом index из матрицы смежности\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"Добавление ребра\"\"\"\n        # Параметры i и j соответствуют индексам элементов vertices\n        # Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"Удаление ребра\"\"\"\n        # Параметры i и j соответствуют индексам элементов vertices\n        # Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"Вывести матрицу смежности\"\"\"\n        print(\"Список вершин =\", self.vertices)\n        print(\"Матрица смежности =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n  public:\n    /* Конструктор */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // Добавление вершины\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* Добавление вершины */\n    void addVertex(int val) {\n        int n = size();\n        // Добавить значение новой вершины в список вершин\n        vertices.push_back(val);\n        // Добавить строку в матрицу смежности\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // Добавить столбец в матрицу смежности\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* Удаление вершины */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        // Удалить вершину с индексом index из списка вершин\n        vertices.erase(vertices.begin() + index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.erase(adjMat.begin() + index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    void addEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    void removeEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"вершина не существует\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    void print() {\n        cout &lt;&lt; \"Список вершин = \";\n        printVector(vertices);\n        cout &lt;&lt; \"Матрица смежности =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // Добавление вершины\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* Добавление вершины */\n    public void addVertex(int val) {\n        int n = size();\n        // Добавить значение новой вершины в список вершин\n        vertices.add(val);\n        // Добавить строку в матрицу смежности\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // Добавить столбец в матрицу смежности\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* Удаление вершины */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // Удалить вершину с индексом index из списка вершин\n        vertices.remove(index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.remove(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void addEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void removeEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* Вывести матрицу смежности */\n    public void print() {\n        System.out.print(\"Список вершин = \");\n        System.out.println(vertices);\n        System.out.println(\"Матрица смежности =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    List&lt;List&lt;int&gt;&gt; adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* Добавление вершины */\n    public void AddVertex(int val) {\n        int n = Size();\n        // Добавить значение новой вершины в список вершин\n        vertices.Add(val);\n        // Добавить строку в матрицу смежности\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // Добавить столбец в матрицу смежности\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* Удаление вершины */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // Удалить вершину с индексом index из списка вершин\n        vertices.RemoveAt(index);\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.RemoveAt(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void AddEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    public void RemoveEdge(int i, int j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    public void Print() {\n        Console.Write(\"Список вершин = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"Матрица смежности =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\ntype graphAdjMat struct {\n    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    vertices []int\n    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    adjMat [][]int\n}\n\n/* Конструктор */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // Добавление вершины\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // Инициализировать граф\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // Добавить ребра\n    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* Получить число вершин */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* Добавление вершины */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // Добавить значение новой вершины в список вершин\n    g.vertices = append(g.vertices, val)\n    // Добавить строку в матрицу смежности\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // Добавить столбец в матрицу смежности\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* Удаление вершины */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // Удалить вершину с индексом index из списка вершин\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // Удалить строку с индексом index из матрицы смежности\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // Удалить столбец с индексом index из матрицы смежности\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* Добавление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* Удаление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* Вывести матрицу смежности */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\tСписок вершин = %v\\n\", g.vertices)\n    fmt.Printf(\"\\tМатрица смежности = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    private var vertices: [Int] // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    private var adjMat: [[Int]] // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // Добавление вершины\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* Получить число вершин */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* Добавление вершины */\n    func addVertex(val: Int) {\n        let n = size()\n        // Добавить значение новой вершины в список вершин\n        vertices.append(val)\n        // Добавить строку в матрицу смежности\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // Добавить столбец в матрицу смежности\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* Удаление вершины */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        // Удалить вершину с индексом index из списка вершин\n        vertices.remove(at: index)\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.remove(at: index)\n        // Удалить столбец с индексом index из матрицы смежности\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    func addEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    func removeEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"Выход за границы диапазона\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Вывести матрицу смежности */\n    func print() {\n        Swift.print(\"Список вершин = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"Матрица смежности =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* Добавление вершины */\n    addVertex(val) {\n        const n = this.size();\n        // Добавить значение новой вершины в список вершин\n        this.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Добавить столбец в матрицу смежности\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Удалить вершину с индексом index из списка вершин\n        this.vertices.splice(index, 1);\n\n        // Удалить строку с индексом index из матрицы смежности\n        this.adjMat.splice(index, 1);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    addEdge(i, j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    removeEdge(i, j) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    print() {\n        console.log('Список вершин = ', this.vertices);\n        console.log('Матрица смежности =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n    vertices: number[]; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    adjMat: number[][]; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // Добавление вершины\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* Добавление вершины */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // Добавить значение новой вершины в список вершин\n        this.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // Добавить столбец в матрицу смежности\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // Удалить вершину с индексом index из списка вершин\n        this.vertices.splice(index, 1);\n\n        // Удалить строку с индексом index из матрицы смежности\n        this.adjMat.splice(index, 1);\n        // Удалить столбец с индексом index из матрицы смежности\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    addEdge(i: number, j: number): void {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    removeEdge(i: number, j: number): void {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    print(): void {\n        console.log('Список вершин = ', this.vertices);\n        console.log('Матрица смежности =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // Элемент вершины: элемент представляет «значение вершины», индекс представляет «индекс вершины»\n  List&lt;List&lt;int&gt;&gt; adjMat = []; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n  /* Конструктор */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // Добавление вершины\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // Добавить ребра\n    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* Получить число вершин */\n  int size() {\n    return vertices.length;\n  }\n\n  /* Добавление вершины */\n  void addVertex(int val) {\n    int n = size();\n    // Добавить значение новой вершины в список вершин\n    vertices.add(val);\n    // Добавить строку в матрицу смежности\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // Добавить столбец в матрицу смежности\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* Удаление вершины */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // Удалить вершину с индексом index из списка вершин\n    vertices.removeAt(index);\n    // Удалить строку с индексом index из матрицы смежности\n    adjMat.removeAt(index);\n    // Удалить столбец с индексом index из матрицы смежности\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* Добавление ребра */\n  // Параметры i и j соответствуют индексам элементов vertices\n  void addEdge(int i, int j) {\n    // Обработка выхода индекса за границы и случая равенства\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* Удаление ребра */\n  // Параметры i и j соответствуют индексам элементов vertices\n  void removeEdge(int i, int j) {\n    // Обработка выхода индекса за границы и случая равенства\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* Вывести матрицу смежности */\n  void printAdjMat() {\n    print(\"Список вершин = $vertices\");\n    print(\"Матрица смежности = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* Тип неориентированного графа на основе матрицы смежности */\npub struct GraphAdjMat {\n    // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    pub vertices: Vec&lt;i32&gt;,\n    // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* Конструктор */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // Добавление вершины\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* Получить число вершин */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* Добавление вершины */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // Добавить значение новой вершины в список вершин\n        self.vertices.push(val);\n        // Добавить строку в матрицу смежности\n        self.adj_mat.push(vec![0; n]);\n        // Добавить столбец в матрицу смежности\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* Удаление вершины */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // Удалить вершину с индексом index из списка вершин\n        self.vertices.remove(index);\n        // Удалить строку с индексом index из матрицы смежности\n        self.adj_mat.remove(index);\n        // Удалить столбец с индексом index из матрицы смежности\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* Добавление ребра */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // Параметры i и j соответствуют индексам элементов vertices\n        // Обработка выхода индекса за границы и случая равенства\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // Параметры i и j соответствуют индексам элементов vertices\n        // Обработка выхода индекса за границы и случая равенства\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* Вывести матрицу смежности */\n    pub fn print(&amp;self) {\n        println!(\"Список вершин = {:?}\", self.vertices);\n        println!(\"Матрица смежности =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* Структура неориентированного графа на основе матрицы смежности */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* Конструктор */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* Деструктор */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* Добавление вершины */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"Количество вершин графа уже достигло максимума\\n\");\n        return;\n    }\n    // Добавить n-ю вершину и обнулить n-ю строку и столбец\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* Удаление вершины */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"индекс вершины выходит за границы\\n\");\n        return;\n    }\n    // Удалить вершину с индексом index из списка вершин\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // Удалить строку с индексом index из матрицы смежности\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // Удалить столбец с индексом index из матрицы смежности\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* Добавление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"индексы ребра выходят за границы или совпадают\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* Удаление ребра */\n// Параметры i и j соответствуют индексам элементов vertices\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"индексы ребра выходят за границы или совпадают\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* Вывести матрицу смежности */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"Список вершин = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"Матрица смежности =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* Класс неориентированного графа на основе матрицы смежности */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n\n    /* Конструктор */\n    init {\n        // Добавление вершины\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // Добавить ребра\n        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* Получить число вершин */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* Добавление вершины */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // Добавить значение новой вершины в список вершин\n        vertices.add(_val)\n        // Добавить строку в матрицу смежности\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // Добавить столбец в матрицу смежности\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* Удаление вершины */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // Удалить вершину с индексом index из списка вершин\n        vertices.removeAt(index)\n        // Удалить строку с индексом index из матрицы смежности\n        adjMat.removeAt(index)\n        // Удалить столбец с индексом index из матрицы смежности\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* Добавление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    fun addEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* Удаление ребра */\n    // Параметры i и j соответствуют индексам элементов vertices\n    fun removeEdge(i: Int, j: Int) {\n        // Обработка выхода индекса за границы и случая равенства\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* Вывести матрицу смежности */\n    fun print() {\n        print(\"Список вершин = \")\n        println(vertices)\n        println(\"Матрица смежности =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### Класс неориентированного графа на основе матрицы смежности ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### Конструктор ###\n    # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»\n    @vertices = []\n    # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»\n    @adj_mat = []\n    # Добавление вершины\n    vertices.each { |val| add_vertex(val) }\n    # Добавить ребра\n    # Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### Получение числа вершин ###\n  def size\n    @vertices.length\n  end\n\n  ### Добавление вершины ###\n  def add_vertex(val)\n    n = size\n    # Добавить значение новой вершины в список вершин\n    @vertices &lt;&lt; val\n    # Добавить строку в матрицу смежности\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # Добавить столбец в матрицу смежности\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### Удаление вершины ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # Удалить вершину с индексом index из списка вершин\n    @vertices.delete_at(index)\n    # Удалить строку с индексом index из матрицы смежности\n    @adj_mat.delete_at(index)\n    # Удалить столбец с индексом index из матрицы смежности\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### Добавление ребра ###\n  def add_edge(i, j)\n    # Параметры i и j соответствуют индексам элементов vertices\n    # Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### Удаление ребра ###\n  def remove_edge(i, j)\n    # Параметры i и j соответствуют индексам элементов vertices\n    # Обработка выхода индекса за границы и случая равенства\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### Вывести матрицу смежности ###\n  def __print__\n    puts \"Список вершин = #{@vertices}\"\n    puts 'Матрица смежности ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 9. Графы","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   Реализация на основе списка смежности","text":"<p>Пусть неориентированный граф содержит в сумме \\(n\\) вершин и \\(m\\) ребер. Тогда различные операции можно реализовать способом, показанным на рисунках ниже.</p> <ul> <li>Добавление ребра: достаточно добавить ребро в конец списка, соответствующего вершине; это требует \\(O(1)\\) времени. Поскольку граф неориентированный, необходимо одновременно добавить ребра в обоих направлениях.</li> <li>Удаление ребра: нужно найти и удалить указанное ребро в списке, соответствующем вершине; это требует \\(O(m)\\) времени. В неориентированном графе необходимо удалить ребра в обоих направлениях.</li> <li>Добавление вершины: в список смежности добавляется еще один список, а новая вершина становится его головным узлом; это требует \\(O(1)\\) времени.</li> <li>Удаление вершины: требуется пройти по всему списку смежности и удалить все ребра, содержащие указанную вершину; это требует \\(O(n + m)\\) времени.</li> <li>Инициализация: в списке смежности создаются \\(n\\) вершин и \\(2m\\) ребер; это требует \\(O(n + m)\\) времени.</li> </ul> Инициализация списка смежностиДобавление ребраУдаление ребраДобавление вершиныУдаление вершины <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-8   Инициализация списка смежности, добавление и удаление ребер и вершин </p> <p>Ниже приведен код списка смежности. По сравнению с рисунками выше, реальная реализация имеет следующие отличия.</p> <ul> <li>Чтобы упростить добавление и удаление вершин, а также сделать код проще, мы используем список, то есть динамический массив, вместо связного списка.</li> <li>Для хранения списка смежности используется хеш-таблица, где <code>key</code> - это экземпляр вершины, а <code>value</code> - список смежных вершин данной вершины.</li> </ul> <p>Кроме того, в списке смежности используется класс <code>Vertex</code> для представления вершины. Причина в том, что если, как и в матрице смежности, различать вершины по индексам списка, то при удалении вершины с индексом \\(i\\) пришлось бы обходить весь список смежности и уменьшать на \\(1\\) все индексы, большие \\(i\\) , что крайне неэффективно. Если же каждая вершина является уникальным экземпляром <code>Vertex</code> , то после удаления одной вершины остальные вершины менять уже не требуется.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"Класс неориентированного графа на основе списка смежности\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"Конструктор\"\"\"\n        # Список смежности, где key — вершина, а value — все смежные ей вершины\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # Добавить все вершины и ребра\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"Получить число вершин\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Добавление ребра\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Добавить ребро vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"Удаление ребра\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # Удалить ребро vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"Добавление вершины\"\"\"\n        if vet in self.adj_list:\n            return\n        # Добавить новый список в список смежности\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"Удаление вершины\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # Удалить из списка смежности список, соответствующий вершине vet\n        self.adj_list.pop(vet)\n        # Обойти списки других вершин и удалить все ребра, содержащие vet\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"Вывести список смежности\"\"\"\n        print(\"Список смежности =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n  public:\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* Удалить указанный узел из vector */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* Конструктор */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // Добавить все вершины и ребра\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int size() {\n        return adjList.size();\n    }\n\n    /* Добавление ребра */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"вершина не существует\");\n        // Добавить ребро vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* Удаление ребра */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"вершина не существует\");\n        // Удалить ребро vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* Добавление вершины */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* Удаление вершины */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"вершина не существует\");\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.erase(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    void print() {\n        cout &lt;&lt; \"Список смежности =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Конструктор */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // Добавить все вершины и ребра\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* Добавление ребра */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Добавить ребро vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* Удаление ребра */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // Удалить ребро vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* Добавление вершины */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* Удаление вершины */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.remove(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    public void print() {\n        System.out.println(\"Список смежности =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* Конструктор */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // Добавить все вершины и ребра\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* Добавление ребра */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Добавить ребро vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* Удаление ребра */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // Удалить ребро vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* Добавление вершины */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // Добавить новый список в список смежности\n        adjList.Add(vet, []);\n    }\n\n    /* Удаление вершины */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.Remove(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    public void Print() {\n        Console.WriteLine(\"Список смежности =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* Класс неориентированного графа на основе списка смежности */\ntype graphAdjList struct {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList map[Vertex][]Vertex\n}\n\n/* Конструктор */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // Добавить все вершины и ребра\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* Получить число вершин */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* Добавление ребра */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Добавить ребро vet1 - vet2, добавив анонимную struct{}\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* Удаление ребра */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // Удалить ребро vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* Добавление вершины */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // Добавить новый список в список смежности\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* Удаление вершины */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // Удалить из списка смежности список, соответствующий вершине vet\n    delete(g.adjList, vet)\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* Вывести список смежности */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"Список смежности = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* Конструктор */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // Добавить все вершины и ребра\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* Получить число вершин */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* Добавление ребра */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Добавить ребро vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* Удаление ребра */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Удалить ребро vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* Добавление вершины */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // Добавить новый список в список смежности\n        adjList[vet] = []\n    }\n\n    /* Удаление вершины */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"Неверный аргумент\")\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.removeValue(forKey: vet)\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* Вывести список смежности */\n    public func print() {\n        Swift.print(\"Список смежности =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList;\n\n    /* Конструктор */\n    constructor(edges) {\n        this.adjList = new Map();\n        // Добавить все вершины и ребра\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* Добавление ребра */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Добавить ребро vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Удаление ребра */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить ребро vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Добавление вершины */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // Добавить новый список в список смежности\n        this.adjList.set(vet, []);\n    }\n\n    /* Удаление вершины */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        this.adjList.delete(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Вывести список смежности */\n    print() {\n        console.log('Список смежности =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* Конструктор */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // Добавить все вершины и ребра\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* Получить число вершин */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* Добавление ребра */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Добавить ребро vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* Удаление ребра */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить ребро vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* Добавление вершины */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // Добавить новый список в список смежности\n        this.adjList.set(vet, []);\n    }\n\n    /* Удаление вершины */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // Удалить из списка смежности список, соответствующий вершине vet\n        this.adjList.delete(vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* Вывести список смежности */\n    print(): void {\n        console.log('Список смежности =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList {\n  // Список смежности, где key — вершина, а value — все смежные ей вершины\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* Конструктор */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* Получить число вершин */\n  int size() {\n    return adjList.length;\n  }\n\n  /* Добавление ребра */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Добавить ребро vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* Удаление ребра */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // Удалить ребро vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* Добавление вершины */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // Добавить новый список в список смежности\n    adjList[vet] = [];\n  }\n\n  /* Удаление вершины */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // Удалить из списка смежности список, соответствующий вершине vet\n    adjList.remove(vet);\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* Вывести список смежности */\n  void printAdjList() {\n    print(\"Список смежности =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* Тип неориентированного графа на основе списка смежности */\npub struct GraphAdjList {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* Конструктор */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // Добавить все вершины и ребра\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* Получить число вершин */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* Добавление ребра */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Добавить ребро vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* Удаление ребра */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // Удалить ребро vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* Добавление вершины */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // Добавить новый список в список смежности\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* Удаление вершины */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // Удалить из списка смежности список, соответствующий вершине vet\n        self.adj_list.remove(&amp;vet);\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* Вывести список смежности */\n    pub fn print(&amp;self) {\n        println!(\"Список смежности =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* Структура узла */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // Вершина\n    struct AdjListNode *next; // Узел-преемник\n} AdjListNode;\n\n/* Найти узел, соответствующий вершине */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Вспомогательная функция добавления ребра */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // Вставка в голову\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* Вспомогательная функция удаления ребра */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // Искать в связном списке узел, соответствующий vet\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // Удалить из связного списка узел, соответствующий vet\n    pre-&gt;next = cur-&gt;next;\n    // Освободить память\n    free(cur);\n}\n\n/* Класс неориентированного графа на основе списка смежности */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // Массив узлов\n    int size;                     // Количество узлов\n} GraphAdjList;\n\n/* Конструктор */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* Деструктор */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* Найти узел, соответствующий вершине */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* Добавление ребра */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // Добавить ребро vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* Удаление ребра */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // Удалить ребро vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* Добавление вершины */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // Добавить новый список в список смежности\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* Удаление вершины */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // Удалить из списка смежности список, соответствующий вершине vet\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // Обойти списки других вершин и удалить все ребра, содержащие vet\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // Сдвинуть вершины после данной вперед, чтобы заполнить образовавшийся пробел\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* Класс неориентированного графа на основе списка смежности */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // Список смежности, где key — вершина, а value — все смежные ей вершины\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* Конструктор */\n    init {\n        // Добавить все вершины и ребра\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* Получить число вершин */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* Добавление ребра */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Добавить ребро vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* Удаление ребра */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // Удалить ребро vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* Добавление вершины */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // Добавить новый список в список смежности\n        adjList[vet] = mutableListOf()\n    }\n\n    /* Удаление вершины */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // Удалить из списка смежности список, соответствующий вершине vet\n        adjList.remove(vet)\n        // Обойти списки других вершин и удалить все ребра, содержащие vet\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* Вывести список смежности */\n    fun print() {\n        println(\"Список смежности =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### Класс неориентированного графа на основе списка смежности ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### Конструктор ###\n  def initialize(edges)\n    # Список смежности, где key — вершина, а value — все смежные ей вершины\n    @adj_list = {}\n    # Добавить все вершины и ребра\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### Получение числа вершин ###\n  def size\n    @adj_list.length\n  end\n\n  ### Добавление ребра ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### Удаление ребра ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # Удалить ребро vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### Добавление вершины ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # Добавить новый список в список смежности\n    @adj_list[vet] = []\n  end\n\n  ### Удаление вершины ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # Удалить из списка смежности список, соответствующий вершине vet\n    @adj_list.delete(vet)\n    # Обойти списки других вершин и удалить все ребра, содержащие vet\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### Вывести список смежности ###\n  def __print__\n    puts 'Список смежности ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 9. Графы","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   Сравнение эффективности","text":"<p>Пусть в графе имеется \\(n\\) вершин и \\(m\\) ребер. В таблице 9-2 сравниваются временная и пространственная эффективность матрицы смежности и списка смежности. Обратите внимание: список смежности (связный список) соответствует реализации из этой статьи, а список смежности (хеш-таблица) означает вариант, в котором все списки заменены хеш-таблицами.</p> <p> Таблица 9-2   Сравнение матрицы смежности и списка смежности </p> Матрица смежности Список смежности (связный список) Список смежности (хеш-таблица) Проверка смежности \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Добавление ребра \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Удаление ребра \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) Добавление вершины \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) Удаление вершины \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) Занимаемая память \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>Если смотреть только на таблицу, может показаться, что список смежности на основе хеш-таблицы является лучшим и по времени, и по памяти. Но на практике операции над ребрами в матрице смежности обычно выполняются быстрее, потому что там нужен лишь один доступ к массиву или одно присваивание. В целом матрица смежности воплощает принцип \"обмена пространства на время\", а список смежности - принцип \"обмена времени на пространство\".</p>","path":["Глава 9. Графы","9.2 &nbsp; Базовые операции графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   Обход графа","text":"<p>Дерево представляет отношение \"один ко многим\", тогда как граф обладает большей свободой и может выражать произвольные отношения \"многие ко многим\". Поэтому дерево можно рассматривать как частный случай графа. Очевидно, что операции обхода дерева также являются частным случаем операций обхода графа.</p> <p>И графы, и деревья требуют применения алгоритмов обхода. Способы обхода графа также делятся на два типа: обход в ширину и обход в глубину.</p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   Обход в ширину","text":"<p>Обход в ширину - это способ обхода от ближнего к дальнему, при котором начиная с некоторого узла сначала посещают ближайшие вершины, а затем слой за слоем расширяются наружу. Как показано на рисунке 9-9, начиная с вершины в левом верхнем углу, мы сначала обходим все смежные вершины этой вершины, затем все смежные вершины следующей вершины и так далее, пока не будут посещены все вершины.</p> <p></p> <p> Рисунок 9-9   Обход графа в ширину </p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   Реализация алгоритма","text":"<p>BFS обычно реализуется с помощью очереди, код приведен ниже. Очередь обладает свойством \"первым пришел - первым вышел\", что хорошо соответствует идее BFS \"от ближнего к дальнему\".</p> <ol> <li>Поместить стартовую вершину обхода <code>startVet</code> в очередь и запустить цикл.</li> <li>На каждой итерации цикла извлекать вершину из головы очереди и записывать ее посещение, после чего добавлять все смежные вершины этой вершины в хвост очереди.</li> <li>Повторять шаг <code>2.</code> до тех пор, пока не будут посещены все вершины.</li> </ol> <p>Чтобы предотвратить повторный обход вершин, нам нужно хеш-множество <code>visited</code> , в котором записывается, какие вершины уже посещены.</p> <p>Tip</p> <p>Хеш-множество можно рассматривать как хеш-таблицу, которая хранит только <code>key</code> и не хранит <code>value</code> . Оно позволяет выполнять добавление, удаление и проверку наличия <code>key</code> за \\(O(1)\\) времени. Благодаря уникальности <code>key</code> хеш-множество обычно используется, например, для устранения повторов.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Обход в ширину\"\"\"\n    # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n    # Последовательность обхода вершин\n    res = []\n    # Хеш-множество для хранения уже посещенных вершин\n    visited = set[Vertex]([start_vet])\n    # Очередь используется для реализации BFS\n    que = deque[Vertex]([start_vet])\n    # Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while len(que) &gt; 0:\n        vet = que.popleft()  # Извлечь головную вершину из очереди\n        res.append(vet)  # Отметить посещенную вершину\n        # Обойти все смежные вершины данной вершины\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # Пропустить уже посещенную вершину\n            que.append(adj_vet)  # Помещать в очередь только непосещенные вершины\n            visited.add(adj_vet)  # Отметить эту вершину как посещенную\n    # Вернуть последовательность обхода вершин\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Последовательность обхода вершин\n    vector&lt;Vertex *&gt; res;\n    // Хеш-множество для хранения уже посещенных вершин\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // Очередь используется для реализации BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // Извлечь головную вершину из очереди\n        res.push_back(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // Пропустить уже посещенную вершину\n            que.push(adjVet);        // Помещать в очередь только непосещенные вершины\n            visited.emplace(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Хеш-множество для хранения уже посещенных вершин\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // Извлечь головную вершину из очереди\n        res.add(vet);            // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // Пропустить уже посещенную вершину\n            que.offer(adjVet);   // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // Очередь используется для реализации BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // Извлечь головную вершину из очереди\n        res.Add(vet);               // Отметить посещенную вершину\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // Пропустить уже посещенную вершину\n            }\n            que.Enqueue(adjVet);   // Помещать в очередь только непосещенные вершины\n            visited.Add(adjVet);   // Отметить эту вершину как посещенную\n        }\n    }\n\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Последовательность обхода вершин\n    res := make([]Vertex, 0)\n    // Хеш-множество для хранения уже посещенных вершин\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // Очередь используется для реализации BFS, срез используется для имитации очереди\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    for len(queue) &gt; 0 {\n        // Извлечь головную вершину из очереди\n        vet := queue[0]\n        queue = queue[1:]\n        // Отметить посещенную вершину\n        res = append(res, vet)\n        // Обойти все смежные вершины данной вершины\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // Помещать в очередь только непосещенные вершины\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Последовательность обхода вершин\n    var res: [Vertex] = []\n    // Хеш-множество для хранения уже посещенных вершин\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // Очередь используется для реализации BFS\n    var que: [Vertex] = [startVet]\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while !que.isEmpty {\n        let vet = que.removeFirst() // Извлечь головную вершину из очереди\n        res.append(vet) // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // Пропустить уже посещенную вершину\n            }\n            que.append(adjVet) // Помещать в очередь только непосещенные вершины\n            visited.insert(adjVet) // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphBFS(graph, startVet) {\n    // Последовательность обхода вершин\n    const res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited = new Set();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    const que = [startVet];\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.length) {\n        const vet = que.shift(); // Извлечь головную вершину из очереди\n        res.push(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            que.push(adjVet); // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Последовательность обхода вершин\n    const res: Vertex[] = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // Очередь используется для реализации BFS\n    const que = [startVet];\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (que.length) {\n        const vet = que.shift(); // Извлечь головную вершину из очереди\n        res.push(vet); // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            que.push(adjVet); // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet); // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* Обход в ширину */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  // Последовательность обхода вершин\n  List&lt;Vertex&gt; res = [];\n  // Хеш-множество для хранения уже посещенных вершин\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // Очередь используется для реализации BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // Извлечь головную вершину из очереди\n    res.add(vet); // Отметить посещенную вершину\n    // Обойти все смежные вершины данной вершины\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // Пропустить уже посещенную вершину\n      }\n      que.add(adjVet); // Помещать в очередь только непосещенные вершины\n      visited.add(adjVet); // Отметить эту вершину как посещенную\n    }\n  }\n  // Вернуть последовательность обхода вершин\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Последовательность обхода вершин\n    let mut res = vec![];\n    // Хеш-множество для хранения уже посещенных вершин\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // Очередь используется для реализации BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // Отметить посещенную вершину\n\n        // Обойти все смежные вершины данной вершины\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // Пропустить уже посещенную вершину\n                }\n                que.push_back(adj_vet); // Помещать в очередь только непосещенные вершины\n                visited.insert(adj_vet); // Отметить эту вершину как посещенную\n            }\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* Структура очереди узлов */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* Конструктор */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* Проверка, пуста ли очередь */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* Операция добавления в очередь */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* Операция извлечения из очереди */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* Проверить, была ли вершина уже посещена */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // Искать узел обходом за O(n) времени\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // Очередь используется для реализации BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // Извлечь головную вершину из очереди\n        res[(*resSize)++] = vet;      // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // Пропустить уже посещенную вершину\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // Помещать в очередь только непосещенные вершины\n                visited[(*visitedSize)++] = node-&gt;vertex; // Отметить эту вершину как посещенную\n            }\n            node = node-&gt;next;\n        }\n    }\n    // Освободить память\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* Обход в ширину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // Последовательность обхода вершин\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Хеш-множество для хранения уже посещенных вершин\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // Очередь используется для реализации BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n    while (!que.isEmpty()) {\n        val vet = que.poll() // Извлечь головную вершину из очереди\n        res.add(vet)         // Отметить посещенную вершину\n        // Обойти все смежные вершины данной вершины\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // Пропустить уже посещенную вершину\n            que.offer(adjVet)   // Помещать в очередь только непосещенные вершины\n            visited.add(adjVet) // Отметить эту вершину как посещенную\n        }\n    }\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### Обход в ширину ###\ndef graph_bfs(graph, start_vet)\n  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  # Последовательность обхода вершин\n  res = []\n  # Хеш-множество для хранения уже посещенных вершин\n  visited = Set.new([start_vet])\n  # Очередь используется для реализации BFS\n  que = [start_vet]\n  # Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины\n  while que.length &gt; 0\n    vet = que.shift # Извлечь головную вершину из очереди\n    res &lt;&lt; vet # Отметить посещенную вершину\n    # Обойти все смежные вершины данной вершины\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # Пропустить уже посещенную вершину\n      que &lt;&lt; adj_vet # Помещать в очередь только непосещенные вершины\n      visited.add(adj_vet) # Отметить эту вершину как посещенную\n    end\n  end\n  # Вернуть последовательность обхода вершин\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Код сравнительно абстрактен, поэтому рекомендуется сверяться с рисунками ниже для лучшего понимания.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-10   Шаги обхода графа в ширину </p> <p>Является ли последовательность обхода в ширину единственной?</p> <p>Нет. Обход в ширину требует только соблюдения порядка \"от ближнего к дальнему\", а порядок обхода нескольких вершин на одинаковом расстоянии может произвольно меняться. Например, на рисунке 9-10 можно поменять местами порядок посещения вершин \\(1\\) и \\(3\\) , а вершины \\(2\\), \\(4\\), \\(6\\) также можно переставлять произвольно.</p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   Анализ сложности","text":"<p>Временная сложность: все вершины по одному разу помещаются в очередь и извлекаются из нее, что требует \\(O(|V|)\\) времени; при обходе смежных вершин, поскольку граф неориентированный, все ребра будут посещены по \\(2\\) раза, что требует \\(O(2|E|)\\) времени; в сумме получается \\(O(|V| + |E|)\\) .</p> <p>Пространственная сложность: список <code>res</code> , хеш-множество <code>visited</code> и очередь <code>que</code> в худшем случае могут содержать до \\(|V|\\) вершин, поэтому требуется \\(O(|V|)\\) памяти.</p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   Обход в глубину","text":"<p>Обход в глубину - это способ обхода, при котором сначала идут до самого конца, а когда дальше идти нельзя, возвращаются назад. Как показано на рисунке 9-11, начиная с вершины в левом верхнем углу, мы выбираем некоторую смежную вершину текущей вершины, идем до упора, затем возвращаемся назад, снова идем до упора и так далее, пока не будут посещены все вершины.</p> <p></p> <p> Рисунок 9-11   Обход графа в глубину </p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   Реализация алгоритма","text":"<p>Такой алгоритмический шаблон \"дойти до конца и вернуться\" обычно реализуется через рекурсию. Подобно обходу в ширину, в обходе в глубину мы также используем хеш-множество <code>visited</code> для записи уже посещенных вершин и тем самым избегаем повторного посещения.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"Вспомогательная функция обхода в глубину\"\"\"\n    res.append(vet)  # Отметить посещенную вершину\n    visited.add(vet)  # Отметить эту вершину как посещенную\n    # Обойти все смежные вершины данной вершины\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # Пропустить уже посещенную вершину\n        # Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"Обход в глубину\"\"\"\n    # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n    # Последовательность обхода вершин\n    res = []\n    # Хеш-множество для хранения уже посещенных вершин\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // Отметить посещенную вершину\n    visited.emplace(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // Последовательность обхода вершин\n    vector&lt;Vertex *&gt; res;\n    // Хеш-множество для хранения уже посещенных вершин\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // Хеш-множество для хранения уже посещенных вершин\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // Отметить посещенную вершину\n    visited.Add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // Последовательность обхода вершин\n    List&lt;Vertex&gt; res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* Вспомогательная функция обхода в глубину */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // Операция append возвращает новую ссылку, поэтому исходную ссылку нужно заново присвоить новому срезу\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // Обойти все смежные вершины данной вершины\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // Рекурсивно обходить смежные вершины\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // Последовательность обхода вершин\n    res := make([]Vertex, 0)\n    // Хеш-множество для хранения уже посещенных вершин\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // Вернуть последовательность обхода вершин\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* Вспомогательная функция обхода в глубину */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // Отметить посещенную вершину\n    visited.insert(vet) // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // Последовательность обхода вершин\n    var res: [Vertex] = []\n    // Хеш-множество для хранения уже посещенных вершин\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphDFS(graph, startVet) {\n    // Последовательность обхода вершин\n    const res = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* Вспомогательная функция обхода в глубину */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // Отметить посещенную вершину\n    visited.add(vet); // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // Пропустить уже посещенную вершину\n        }\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // Последовательность обхода вершин\n    const res: Vertex[] = [];\n    // Хеш-множество для хранения уже посещенных вершин\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* Вспомогательная функция обхода в глубину */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // Отметить посещенную вершину\n  visited.add(vet); // Отметить эту вершину как посещенную\n  // Обойти все смежные вершины данной вершины\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // Пропустить уже посещенную вершину\n    }\n    // Рекурсивно обходить смежные вершины\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* Обход в глубину */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // Последовательность обхода вершин\n  List&lt;Vertex&gt; res = [];\n  // Хеш-множество для хранения уже посещенных вершин\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* Вспомогательная функция обхода в глубину */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // Отметить посещенную вершину\n    visited.insert(vet); // Отметить эту вершину как посещенную\n                         // Обойти все смежные вершины данной вершины\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // Пропустить уже посещенную вершину\n            }\n            // Рекурсивно обходить смежные вершины\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // Последовательность обхода вершин\n    let mut res = vec![];\n    // Хеш-множество для хранения уже посещенных вершин\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* Проверить, была ли вершина уже посещена */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // Искать узел обходом за O(n) времени\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* Вспомогательная функция обхода в глубину */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // Отметить посещенную вершину\n    res[(*resSize)++] = vet;\n    // Обойти все смежные вершины данной вершины\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // Пропустить уже посещенную вершину\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // Рекурсивно обходить смежные вершины\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* Вспомогательная функция обхода в глубину */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // Отметить посещенную вершину\n    visited.add(vet) // Отметить эту вершину как посещенную\n    // Обойти все смежные вершины данной вершины\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // Пропустить уже посещенную вершину\n        // Рекурсивно обходить смежные вершины\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* Обход в глубину */\n// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // Последовательность обхода вершин\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // Хеш-множество для хранения уже посещенных вершин\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### Вспомогательная функция обхода в глубину ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # Отметить посещенную вершину\n  visited.add(vet) # Отметить эту вершину как посещенную\n  # Обойти все смежные вершины данной вершины\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # Пропустить уже посещенную вершину\n    # Рекурсивно обходить смежные вершины\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### Обход в глубину ###\ndef graph_dfs(graph, start_vet)\n  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины\n  # Последовательность обхода вершин\n  res = []\n  # Хеш-множество для хранения уже посещенных вершин\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Алгоритмический процесс обхода в глубину показан на рисунках ниже.</p> <ul> <li>Прямая пунктирная линия обозначает нисходящую рекурсию , то есть запуск нового рекурсивного метода для посещения новой вершины.</li> <li>Изогнутая пунктирная линия обозначает восходящую рекурсию , то есть данный рекурсивный метод завершился и управление вернулось туда, откуда он был вызван.</li> </ul> <p>Чтобы лучше понять алгоритм, рекомендуется совместить рисунки ниже с кодом и мысленно проследить весь процесс DFS, включая моменты запуска и возврата каждого рекурсивного вызова.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 9-12   Шаги обхода графа в глубину </p> <p>Является ли последовательность обхода в глубину единственной?</p> <p>Как и в случае обхода в ширину, последовательность DFS тоже не является единственной. Для заданной вершины допустимо сначала углубиться в любое направление, то есть порядок смежных вершин может быть произвольным, и все такие варианты будут корректными обходами в глубину.</p> <p>Если взять в качестве примера обход дерева, то варианты \"корень \\(\\rightarrow\\) лево \\(\\rightarrow\\) право\", \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\" и \"лево \\(\\rightarrow\\) право \\(\\rightarrow\\) корень\" соответствуют прямому, симметричному и обратному обходам соответственно. Они показывают три разных приоритета обхода, но все они относятся к обходу в глубину.</p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   Анализ сложности","text":"<p>Временная сложность: все вершины будут посещены по \\(1\\) разу, что требует \\(O(|V|)\\) времени; все ребра будут посещены по \\(2\\) раза, что требует \\(O(2|E|)\\) времени; суммарно получается \\(O(|V| + |E|)\\) .</p> <p>Пространственная сложность: число вершин в списке <code>res</code> и хеш-множестве <code>visited</code> в худшем случае достигает \\(|V|\\) , максимальная глубина рекурсии тоже равна \\(|V|\\) , поэтому требуется \\(O(|V|)\\) памяти.</p>","path":["Глава 9. Графы","9.3 &nbsp; Обход графа"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   Краткие итоги","text":"","path":["Глава 9. Графы","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   Основные моменты","text":"<ul> <li>Граф состоит из вершин и ребер и может быть задан как множество вершин и множество ребер.</li> <li>По сравнению с линейными отношениями (связный список) и отношениями разделения (дерево), сетевые отношения (граф) обладают большей свободой и потому более сложны.</li> <li>Ребра ориентированного графа имеют направление, в связном графе любые вершины достижимы, а во взвешенном графе каждое ребро содержит переменную веса.</li> <li>Матрица смежности использует матрицу для представления графа: каждая строка и каждый столбец соответствуют вершине, а элементы матрицы показывают, есть между двумя вершинами ребро или нет. Матрица смежности эффективна в операциях добавления, удаления, поиска и изменения, но расходует больше памяти.</li> <li>Список смежности использует несколько списков для представления графа; \\(i\\)-й список соответствует вершине \\(i\\) и хранит все ее смежные вершины. По сравнению с матрицей смежности список смежности экономит пространство, но для поиска ребра в нем приходится обходить список, поэтому по времени он уступает.</li> <li>Когда списки в списке смежности становятся слишком длинными, их можно преобразовать в красно-черное дерево или хеш-таблицу, чтобы повысить эффективность поиска.</li> <li>С точки зрения алгоритмической идеи матрица смежности отражает принцип \"обмена пространства на время\", а список смежности - принцип \"обмена времени на пространство\".</li> <li>Графы можно использовать для моделирования различных реальных систем, таких как социальные сети, линии метро и так далее.</li> <li>Дерево является частным случаем графа, а обход дерева - частным случаем обхода графа.</li> <li>Обход графа в ширину представляет собой способ поиска, который расширяется от ближнего к дальнему и обычно реализуется с помощью очереди.</li> <li>Обход графа в глубину представляет собой способ поиска, который сначала идет до самого конца, а затем возвращается назад, когда путь исчерпан; обычно он реализуется на основе рекурсии.</li> </ul>","path":["Глава 9. Графы","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Что считается путем: последовательность вершин или последовательность ребер?</p> <p>Определение в разных языковых версиях Википедии различается: в английской версии путь определяется как \"последовательность ребер\", а в русской версии - как \"последовательность вершин\". В английской версии исходная формулировка выглядит так: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>В этой книге путь рассматривается как последовательность ребер, а не как последовательность вершин. Причина в том, что между двумя вершинами может существовать несколько ребер, и в таком случае каждому ребру соответствует свой путь.</p> <p>Q: Есть ли в несвязном графе вершины, до которых нельзя дойти?</p> <p>В несвязном графе, начиная из некоторой вершины, по крайней мере одна вершина оказывается недостижимой. Чтобы обойти весь несвязный граф, нужно задать несколько стартовых точек и обойти все связные компоненты графа.</p> <p>Q: Есть ли требования к порядку вершин в списке \"всех вершин, соединенных с данной вершиной\" в списке смежности?</p> <p>Порядок может быть произвольным. Но на практике может понадобиться сортировка по определенному правилу, например по порядку добавления вершин или по возрастанию значений вершин; это помогает быстро находить вершины с некоторым экстремальным свойством.</p>","path":["Глава 9. Графы","9.4 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"Глава 15.   Жадность","text":"<p>Abstract</p> <p>Подсолнух поворачивается к солнцу, постоянно стремясь к наилучшим условиям для роста.</p> <p>Жадная стратегия через цепочку простых выборов постепенно приводит к наилучшему ответу.</p>","path":["Глава 15. Жадность","Глава 15. &nbsp; Жадность"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>15.1   Жадный алгоритм</li> <li>15.2   Задача о дробном рюкзаке</li> <li>15.3   Задача о максимальной вместимости</li> <li>15.4   Задача о максимальном произведении разбиения</li> <li>15.5   Резюме</li> </ul>","path":["Глава 15. Жадность","Глава 15. &nbsp; Жадность"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   Задача о дробном рюкзаке","text":"<p>Question</p> <p>Дано \\(n\\) предметов. Вес предмета \\(i\\) равен \\(wgt[i-1]\\), ценность равна \\(val[i-1]\\), также дан рюкзак вместимостью \\(cap\\). Каждый предмет можно выбрать только один раз, но разрешается взять лишь часть предмета, а ценность вычисляется пропорционально взятому весу. Требуется найти максимальную ценность предметов в рюкзаке при ограниченной вместимости. Пример показан на рисунке 15-3.</p> <p></p> <p> Рисунок 15-3   Пример данных для задачи о дробном рюкзаке </p> <p>Задача о дробном рюкзаке в целом очень похожа на задачу о рюкзаке 0-1: состояние включает текущий предмет \\(i\\) и вместимость \\(c\\), а цель состоит в нахождении максимальной ценности при заданной вместимости рюкзака.</p> <p>Отличие в том, что здесь разрешено брать только часть предмета. Как показано на рисунке 15-4, мы можем произвольно делить предмет и вычислять соответствующую ценность пропорционально весу.</p> <ol> <li>Для предмета \\(i\\) его ценность на единицу веса равна \\(val[i-1] / wgt[i-1]\\), сокращенно - удельная ценность.</li> <li>Если взять часть предмета \\(i\\) весом \\(w\\), то ценность рюкзака увеличится на \\(w \\times val[i-1] / wgt[i-1]\\).</li> </ol> <p></p> <p> Рисунок 15-4   Ценность предмета на единицу веса </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>Максимизация общей ценности предметов в рюкзаке по сути равносильна максимизации ценности на единицу веса. Отсюда естественно выводится следующая жадная стратегия.</p> <ol> <li>Отсортировать предметы по убыванию удельной ценности.</li> <li>Перебирать все предметы и на каждом шаге жадно выбирать предмет с наибольшей удельной ценностью.</li> <li>Если оставшейся вместимости рюкзака недостаточно, взять часть текущего предмета, чтобы заполнить рюкзак.</li> </ol> <p></p> <p> Рисунок 15-5   Жадная стратегия для задачи о дробном рюкзаке </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Мы вводим класс <code>Item</code>, чтобы можно было сортировать предметы по удельной ценности. Далее циклически выполняем жадный выбор и, когда рюкзак заполнен, выходим и возвращаем ответ:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"Предмет\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # Вес предмета\n        self.v = v  # Стоимость предмета\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"Дробный рюкзак: жадный алгоритм\"\"\"\n    # Создать список предметов с двумя свойствами: вес и стоимость\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # Циклический жадный выбор\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v\n            cap -= item.w\n        else:\n            # Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap\n            # Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* Предмет */\nclass Item {\n  public:\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // Циклический жадный выбор\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double)item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* Предмет */\nclass Item {\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // Циклический жадный выбор\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double) item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* Предмет */\nclass Item(int w, int v) {\n    public int w = w; // Вес предмета\n    public int v = v; // Стоимость предмета\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // Циклический жадный выбор\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (double)item.v / item.w * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* Предмет */\ntype Item struct {\n    w int // Вес предмета\n    v int // Стоимость предмета\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // Циклический жадный выбор\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* Предмет */\nclass Item {\n    var w: Int // Вес предмета\n    var v: Int // Стоимость предмета\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // Циклический жадный выбор\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* Предмет */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // Вес предмета\n        this.v = v; // Стоимость предмета\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Циклический жадный выбор\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* Предмет */\nclass Item {\n    w: number; // Вес предмета\n    v: number; // Стоимость предмета\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // Циклический жадный выбор\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (item.v / item.w) * cap;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* Предмет */\nclass Item {\n  int w; // Вес предмета\n  int v; // Стоимость предмета\n\n  Item(this.w, this.v);\n}\n\n/* Дробный рюкзак: жадный алгоритм */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // Создать список предметов с двумя свойствами: вес и стоимость\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // Циклический жадный выбор\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n      res += item.v / item.w * cap;\n      // Свободной вместимости больше не осталось, поэтому выйти из цикла\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* Предмет */\nstruct Item {\n    w: i32, // Вес предмета\n    v: i32, // Стоимость предмета\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* Дробный рюкзак: жадный алгоритм */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // Циклический жадный выбор\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* Предмет */\ntypedef struct {\n    int w; // Вес предмета\n    int v; // Стоимость предмета\n} Item;\n\n/* Дробный рюкзак: жадный алгоритм */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // Циклический жадный выбор\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* Предмет */\nclass Item(\n    val w: Int, // Предмет\n    val v: Int  // Стоимость предмета\n)\n\n/* Дробный рюкзак: жадный алгоритм */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // Создать список предметов с двумя свойствами: вес и стоимость\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // Циклический жадный выбор\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n            res += item.v\n            cap -= item.w\n        } else {\n            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n            res += item.v.toDouble() / item.w * cap\n            // Свободной вместимости больше не осталось, поэтому выйти из цикла\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### Предмет ###\nclass Item\n  attr_accessor :w # Вес предмета\n  attr_accessor :v # Стоимость предмета\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### Дробный рюкзак: жадный алгоритм ###\ndef fractional_knapsack(wgt, val, cap)\n  # Создать список предметов с двумя свойствами: вес и стоимость\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # Отсортировать по удельной стоимости item.v / item.w в порядке убывания\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # Циклический жадный выбор\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком\n      res += item.v\n      cap -= item.w\n    else\n      # Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета\n      res += (item.v.to_f / item.w) * cap\n      # Свободной вместимости больше не осталось, поэтому выйти из цикла\n      break\n    end\n  end\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Встроенный алгоритм сортировки обычно имеет временную сложность \\(O(n \\log n)\\), а пространственная сложность обычно равна \\(O(\\log n)\\) или \\(O(n)\\), в зависимости от конкретной реализации в языке программирования.</p> <p>Помимо сортировки, в худшем случае потребуется пройти весь список предметов, но это не меняет асимптотику, поэтому итоговая временная сложность равна \\(O(n \\log n)\\), где \\(n\\) - число предметов.</p> <p>Поскольку инициализируется список объектов <code>Item</code>, пространственная сложность равна \\(O(n)\\).</p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Используем доказательство от противного. Предположим, что предмет \\(x\\) имеет наибольшую удельную ценность, некоторый алгоритм получил максимальную ценность <code>res</code>, но в найденном решении предмет \\(x\\) отсутствует.</p> <p>Теперь вынем из рюкзака произвольный предмет единичного веса и заменим его на предмет \\(x\\) того же веса. Поскольку предмет \\(x\\) имеет наибольшую удельную ценность, общая ценность после замены обязательно станет больше <code>res</code>. Это противоречит тому, что <code>res</code> является оптимальным решением, а значит оптимальное решение обязательно содержит предмет \\(x\\).</p> <p>Для других предметов в этом решении можно построить аналогичное противоречие. Иными словами, предметы с большей удельной ценностью всегда являются более выгодным выбором, а значит жадная стратегия корректна.</p> <p>Как показано на рисунке 15-6, если рассматривать вес предметов и их удельную ценность как горизонтальную и вертикальную оси двумерной диаграммы, то задачу о дробном рюкзаке можно интерпретировать как «поиск максимальной площади, ограниченной конечным отрезком по горизонтали». Эта аналогия помогает понять корректность жадной стратегии с геометрической точки зрения.</p> <p></p> <p> Рисунок 15-6   Геометрическая интерпретация задачи о дробном рюкзаке </p>","path":["Глава 15. Жадность","15.2 &nbsp; Задача о дробном рюкзаке"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   Жадный алгоритм","text":"<p>Жадный алгоритм (greedy algorithm) - это распространенный метод решения задач оптимизации. Его основная идея состоит в том, чтобы на каждом этапе принятия решения выбирать вариант, который выглядит наилучшим прямо сейчас, то есть жадно принимать локально оптимальные решения в надежде получить глобально оптимальный результат. Жадные алгоритмы просты и эффективны, поэтому широко применяются во многих практических задачах.</p> <p>Жадные алгоритмы и динамическое программирование часто используются для решения задач оптимизации. У них есть некоторое сходство, например оба метода опираются на свойство оптимальной подструктуры, но принципы работы различаются.</p> <ul> <li>Динамическое программирование при получении текущего решения учитывает все предыдущие решения и использует ответы для прошлых подзадач, чтобы построить ответ для текущей подзадачи.</li> <li>Жадный алгоритм не учитывает предыдущие решения, а просто движется вперед, каждый раз делая жадный выбор и постепенно сужая область задачи, пока она не будет решена.</li> </ul> <p>Чтобы лучше понять принцип работы жадного алгоритма, разберем его на примере задачи «размен монет». Эта задача уже встречалась в разделе «задача о полном рюкзаке», поэтому она наверняка вам знакома.</p> <p>Question</p> <p>Дано \\(n\\) видов монет. Номинал монеты \\(i\\) равен \\(coins[i - 1]\\), целевая сумма равна \\(amt\\), причем каждую монету можно брать неограниченное число раз. Требуется найти минимальное число монет, которыми можно набрать целевую сумму. Если набрать сумму невозможно, верните \\(-1\\).</p> <p>Жадная стратегия для этой задачи показана на рисунке 15-1. Для заданной целевой суммы мы жадно выбираем монету, которая не превышает ее и находится к ней ближе всего, и повторяем этот шаг, пока не получим нужную сумму.</p> <p></p> <p> Рисунок 15-1   Жадная стратегия для задачи о размене монет </p> <p>Ниже приведен код реализации.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"Размен монет: жадный алгоритм\"\"\"\n    # Предположить, что список coins упорядочен\n    i = len(coins) - 1\n    count = 0\n    # Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0:\n        # Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # Выбрать coins[i]\n        amt -= coins[i]\n        count += 1\n    # Если допустимое решение не найдено, вернуть -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.size() - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(int[] coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.length - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* Размен монет: жадный алгоритм */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = coins.Length - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* Размен монет: жадный алгоритм */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // Предположить, что список coins упорядочен\n    i := len(coins) - 1\n    count := 0\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    for amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // Выбрать coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* Размен монет: жадный алгоритм */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // Предположить, что список coins упорядочен\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // Выбрать coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* Размен монет: жадный алгоритм */\nfunction coinChangeGreedy(coins, amt) {\n    // Предположить, что массив coins упорядочен\n    let i = coins.length - 1;\n    let count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* Размен монет: жадный алгоритм */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // Предположить, что массив coins упорядочен\n    let i = coins.length - 1;\n    let count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // Предположить, что список coins упорядочен\n  int i = coins.length - 1;\n  int count = 0;\n  // Циклически выполнять жадный выбор, пока не останется суммы\n  while (amt &gt; 0) {\n    // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // Выбрать coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // Если допустимое решение не найдено, вернуть -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* Размен монет: жадный алгоритм */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // Предположить, что список coins упорядочен\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while amt &gt; 0 {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* Размен монет: жадный алгоритм */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // Предположить, что список coins упорядочен\n    int i = size - 1;\n    int count = 0;\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (amt &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // Выбрать coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* Размен монет: жадный алгоритм */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // Предположить, что список coins упорядочен\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // Циклически выполнять жадный выбор, пока не останется суммы\n    while (am &gt; 0) {\n        // Найти монету, которая меньше остатка суммы и наиболее к нему близка\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // Выбрать coins[i]\n        am -= coins[i]\n        count++\n    }\n    // Если допустимое решение не найдено, вернуть -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### Размен монет: жадный алгоритм ###\ndef coin_change_greedy(coins, amt)\n  # Предположить, что список coins упорядочен\n  i = coins.length - 1\n  count = 0\n  # Циклически выполнять жадный выбор, пока не останется суммы\n  while amt &gt; 0\n    # Найти монету, которая меньше остатка суммы и наиболее к нему близка\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # Выбрать coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # Если допустимое решение не найдено, вернуть -1\n  amt == 0 ? count : -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>У вас может невольно вырваться: «Эврика!» Жадный алгоритм решает задачу размена монет всего примерно десятью строками кода.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   Преимущества и ограничения жадного алгоритма","text":"<p>Жадный алгоритм не только прост в реализации, но и обычно очень эффективен. В приведенном выше коде обозначим минимальный номинал монеты через \\(\\min(coins)\\), тогда жадный выбор выполняется не более чем \\(amt / \\min(coins)\\) раз, а временная сложность равна \\(O(amt / \\min(coins))\\). Это на порядок меньше, чем временная сложность решения через динамическое программирование \\(O(n \\times amt)\\).</p> <p>Однако для некоторых наборов номиналов монет жадный алгоритм не может найти оптимальный ответ. Ниже показаны два примера.</p> <ul> <li>Положительный пример \\(coins = [1, 5, 10, 20, 50, 100]\\): для такого набора монет при любом \\(amt\\) жадный алгоритм находит оптимальное решение.</li> <li>Отрицательный пример \\(coins = [1, 20, 50]\\): пусть \\(amt = 60\\). Жадный алгоритм найдет только комбинацию \\(50 + 1 \\times 10\\), то есть всего \\(11\\) монет, тогда как динамическое программирование находит оптимум \\(20 + 20 + 20\\), где требуется лишь \\(3\\) монеты.</li> <li>Отрицательный пример \\(coins = [1, 49, 50]\\): пусть \\(amt = 98\\). Жадный алгоритм найдет только комбинацию \\(50 + 1 \\times 48\\), то есть всего \\(49\\) монет, тогда как динамическое программирование находит оптимум \\(49 + 49\\), где требуется лишь \\(2\\) монеты.</li> </ul> <p></p> <p> Рисунок 15-2   Примеры, где жадный алгоритм не находит оптимального решения </p> <p>Иными словами, в задаче о размене монет жадный алгоритм не гарантирует нахождение глобально оптимального решения и иногда может приводить к очень плохому ответу. Для этой задачи больше подходит динамическое программирование.</p> <p>В общем случае жадный алгоритм применим в двух следующих ситуациях.</p> <ol> <li>Можно гарантировать нахождение оптимального решения: в таком случае жадный алгоритм часто является лучшим выбором, поскольку обычно он эффективнее, чем поиск с возвратом и динамическое программирование.</li> <li>Можно найти приближенно оптимальное решение: в таком случае жадный алгоритм тоже полезен. Для многих сложных задач поиск глобального оптимума очень труден, и возможность быстро найти субоптимальный ответ уже весьма ценна.</li> </ol>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   Свойства жадного алгоритма","text":"<p>Тогда возникает вопрос: какие задачи подходят для решения жадным алгоритмом? Или, другими словами, в каких случаях жадный алгоритм может гарантировать оптимальный ответ?</p> <p>По сравнению с динамическим программированием условия применения жадного алгоритма более строгие. В основном нас интересуют два свойства задачи.</p> <ul> <li>Свойство жадного выбора: только когда локально оптимальный выбор всегда может привести к глобально оптимальному решению, жадный алгоритм способен гарантировать оптимум.</li> <li>Оптимальная подструктура: оптимальное решение исходной задачи содержит оптимальные решения подзадач.</li> </ul> <p>Оптимальная подструктура уже обсуждалась в главе «Динамическое программирование», поэтому здесь не будем повторяться. Стоит отметить, что у некоторых задач оптимальная подструктура не столь очевидна, но их все равно можно решать жадным алгоритмом.</p> <p>Основное внимание мы уделяем тому, как определить свойство жадного выбора. Хотя формулировка выглядит довольно простой, на практике для многих задач доказать свойство жадного выбора совсем не легко.</p> <p>Например, в задаче о размене монет легко привести контрпример и опровергнуть свойство жадного выбора, но вот доказать его истинность намного сложнее. Если спросить: для каких наборов монет можно использовать жадный алгоритм? - обычно удается дать лишь интуитивный или примерный ответ, а не строгое математическое доказательство.</p> <p>Quote</p> <p>Существует статья, в которой приводится алгоритм со временной сложностью \\(O(n^3)\\) для определения того, можно ли с помощью жадного алгоритма находить оптимальный размен для любой суммы в заданной системе монет.</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   Этапы решения задач жадным алгоритмом","text":"<p>Процесс решения жадной задачи в общем виде можно разбить на три шага.</p> <ol> <li>Анализ задачи: разобраться в свойствах задачи, включая определение состояний, целевой функции и ограничений. Этот этап присутствует и в поиске с возвратом, и в динамическом программировании.</li> <li>Определение жадной стратегии: определить, какой жадный выбор следует делать на каждом шаге. Эта стратегия должна уменьшать размер задачи на каждом этапе и в итоге привести к решению всей задачи.</li> <li>Доказательство корректности: обычно требуется доказать, что задача обладает свойством жадного выбора и оптимальной подструктурой. На этом этапе может понадобиться математическое доказательство, например индукция или доказательство от противного.</li> </ol> <p>Определение жадной стратегии - это ключевой этап решения, но на практике он часто оказывается непростым по следующим причинам.</p> <ul> <li>Жадные стратегии для разных задач сильно различаются. Для многих задач стратегия довольно очевидна, и до нее можно дойти за счет общих рассуждений и нескольких проб. Но в более сложных задачах жадная стратегия может быть очень скрытой, и тут уже многое зависит от опыта решения задач и алгоритмической подготовки.</li> <li>Некоторые жадные стратегии выглядят убедительно, но оказываются обманчивыми. Бывает, что мы с уверенностью придумали жадную стратегию, написали код и отправили его на проверку, а часть тестов не проходит. Причина в том, что спроектированная стратегия лишь «частично верна», и описанная выше задача о размене монет - типичный пример.</li> </ul> <p>Чтобы гарантировать корректность, нужно дать строгое математическое доказательство жадной стратегии, обычно с использованием доказательства от противного или математической индукции.</p> <p>Однако и доказательство корректности может оказаться непростой задачей. Если идей нет, мы обычно начинаем отлаживать код на тестовых примерах, постепенно меняя и проверяя жадную стратегию.</p>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   Типичные задачи для жадного алгоритма","text":"<p>Жадные алгоритмы часто применяются в задачах оптимизации, обладающих свойством жадного выбора и оптимальной подструктурой. Ниже приведены некоторые типичные задачи, решаемые жадным подходом.</p> <ul> <li>Задача о размене монет: при некоторых системах монет жадный алгоритм всегда дает оптимальный ответ.</li> <li>Задача о расписании интервалов: пусть есть несколько задач, каждая выполняется в некотором временном интервале, и требуется завершить как можно больше задач. Если каждый раз выбирать задачу с самым ранним временем окончания, то жадный алгоритм дает оптимальный ответ.</li> <li>Задача о дробном рюкзаке: дана группа предметов и грузоподъемность. Требуется выбрать предметы так, чтобы их общий вес не превышал ограничение, а общая ценность была максимальной. Если каждый раз выбирать предмет с наилучшим отношением стоимости к весу, то в некоторых случаях жадный алгоритм дает оптимальный ответ.</li> <li>Задача о покупке и продаже акций: дана история цен акции. Можно совершать несколько сделок, но если акция уже куплена, то до продажи покупать снова нельзя. Цель - получить максимальную прибыль.</li> <li>Код Хаффмана: это жадный алгоритм для сжатия данных без потерь. Построив дерево Хаффмана и каждый раз объединяя два узла с наименьшей частотой, мы получаем дерево с минимальной взвешенной длиной пути, то есть минимальной длиной кодирования.</li> <li>Алгоритм Дейкстры: это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.</li> </ul>","path":["Глава 15. Жадность","15.1 &nbsp; Жадный алгоритм"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   Задача о максимальной вместимости","text":"<p>Question</p> <p>Дан массив \\(ht\\), где каждый элемент обозначает высоту вертикальной перегородки. Любые две перегородки в массиве вместе с пространством между ними образуют контейнер.</p> <p>Вместимость контейнера равна произведению высоты и ширины (площади), где высота определяется более короткой перегородкой, а ширина - разностью индексов двух перегородок в массиве.</p> <p>Требуется выбрать две перегородки так, чтобы образованный ими контейнер имел максимальную вместимость. Пример показан на рисунке 15-7.</p> <p></p> <p> Рисунок 15-7   Пример данных для задачи о максимальной вместимости </p> <p>Контейнер образуется произвольными двумя перегородками, поэтому состоянием задачи служит пара индексов этих перегородок, обозначим ее как \\([i, j]\\).</p> <p>Согласно условию, вместимость равна произведению высоты на ширину, где высота определяется короткой перегородкой, а ширина - разностью индексов двух перегородок. Обозначим вместимость через \\(cap[i, j]\\), тогда формула принимает вид:</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>Пусть длина массива равна \\(n\\). Тогда число пар перегородок, то есть общее число состояний, равно \\(C_n^2 = \\frac{n(n - 1)}{2}\\). Самый прямолинейный подход - перебрать все состояния, после чего найти максимальную вместимость. Его временная сложность равна \\(O(n^2)\\).</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>У этой задачи есть и более эффективное решение. Как показано на рисунке 15-8, рассмотрим состояние \\([i, j]\\), где индексы удовлетворяют \\(i &lt; j\\), а высоты - условию \\(ht[i] &lt; ht[j]\\), то есть \\(i\\) - короткая перегородка, а \\(j\\) - длинная.</p> <p></p> <p> Рисунок 15-8   Начальное состояние </p> <p>Как показано на рисунке 15-9, если в этот момент сдвинуть длинную перегородку \\(j\\) ближе к короткой перегородке \\(i\\), то вместимость обязательно уменьшится.</p> <p>Причина в том, что после смещения длинной перегородки \\(j\\) ширина \\(j-i\\) обязательно станет меньше, а высота определяется короткой перегородкой, поэтому высота либо останется прежней (если \\(i\\) останется короткой перегородкой), либо уменьшится (если сдвинутая \\(j\\) станет короткой перегородкой).</p> <p></p> <p> Рисунок 15-9   Состояние после перемещения длинной перегородки внутрь </p> <p>Рассуждая в обратную сторону, только сдвигая короткую перегородку \\(i\\) внутрь, мы можем получить шанс увеличить вместимость. Хотя ширина при этом обязательно уменьшится, высота может возрасти (если после перемещения короткая перегородка \\(i\\) станет выше). Например, на рисунке 15-10 после перемещения короткой перегородки площадь увеличивается.</p> <p></p> <p> Рисунок 15-10   Состояние после перемещения короткой перегородки внутрь </p> <p>Отсюда и выводится жадная стратегия для этой задачи: инициализировать два указателя по краям контейнера и на каждом шаге сдвигать внутрь указатель, соответствующий короткой перегородке, пока указатели не встретятся.</p> <p>На рисунках ниже показан процесс выполнения этой жадной стратегии.</p> <ol> <li>В начальном состоянии указатели \\(i\\) и \\(j\\) стоят на двух концах массива.</li> <li>Вычислить вместимость текущего состояния \\(cap[i, j]\\) и обновить максимальную вместимость.</li> <li>Сравнить высоты перегородок \\(i\\) и \\(j\\), после чего сдвинуть короткую перегородку на одну позицию внутрь.</li> <li>Повторять шаги <code>2.</code> и <code>3.</code> до тех пор, пока \\(i\\) и \\(j\\) не встретятся.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 15-11   Жадный процесс решения задачи о максимальной вместимости </p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Цикл в коде выполняется не более \\(n\\) раз, поэтому временная сложность равна \\(O(n)\\).</p> <p>Переменные \\(i\\), \\(j\\), \\(res\\) используют дополнительную память постоянного размера, поэтому пространственная сложность равна \\(O(1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"Максимальная вместимость: жадный алгоритм\"\"\"\n    # Инициализировать i и j так, чтобы они располагались по двум концам массива\n    i, j = 0, len(ht) - 1\n    # Начальная максимальная вместимость равна 0\n    res = 0\n    # Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j:\n        # Обновить максимальную вместимость\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.size() - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(int[] ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint MaxCapacity(int[] ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0, j = ht.Length - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunc maxCapacity(ht []int) int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    i, j := 0, len(ht)-1\n    // Начальная максимальная вместимость равна 0\n    res := 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    for i &lt; j {\n        // Обновить максимальную вместимость\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // Начальная максимальная вместимость равна 0\n    var res = 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j {\n        // Обновить максимальную вместимость\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunction maxCapacity(ht) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let i = 0,\n        j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    let res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfunction maxCapacity(ht: number[]): number {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let i = 0,\n        j = ht.length - 1;\n    // Начальная максимальная вместимость равна 0\n    let res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(List&lt;int&gt; ht) {\n  // Инициализировать i и j так, чтобы они располагались по двум концам массива\n  int i = 0, j = ht.length - 1;\n  // Начальная максимальная вместимость равна 0\n  int res = 0;\n  // Выполнять жадный выбор в цикле, пока две доски не встретятся\n  while (i &lt; j) {\n    // Обновить максимальную вместимость\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // Сдвигать внутрь более короткую сторону\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // Начальная максимальная вместимость равна 0\n    let mut res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while i &lt; j {\n        // Обновить максимальную вместимость\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // Сдвигать внутрь более короткую сторону\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* Максимальная вместимость: жадный алгоритм */\nint maxCapacity(int ht[], int htLength) {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    int i = 0;\n    int j = htLength - 1;\n    // Начальная максимальная вместимость равна 0\n    int res = 0;\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* Максимальная вместимость: жадный алгоритм */\nfun maxCapacity(ht: IntArray): Int {\n    // Инициализировать i и j так, чтобы они располагались по двум концам массива\n    var i = 0\n    var j = ht.size - 1\n    // Начальная максимальная вместимость равна 0\n    var res = 0\n    // Выполнять жадный выбор в цикле, пока две доски не встретятся\n    while (i &lt; j) {\n        // Обновить максимальную вместимость\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // Сдвигать внутрь более короткую сторону\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### Максимальная вместимость: жадный алгоритм ###\ndef max_capacity(ht)\n  # Инициализировать i и j так, чтобы они располагались по двум концам массива\n  i, j = 0, ht.length - 1\n  # Начальная максимальная вместимость равна 0\n  res = 0\n\n  # Выполнять жадный выбор в цикле, пока две доски не встретятся\n  while i &lt; j\n    # Обновить максимальную вместимость\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # Сдвигать внутрь более короткую сторону\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Жадный алгоритм быстрее полного перебора именно потому, что каждый жадный шаг «пропускает» часть состояний.</p> <p>Например, в состоянии \\(cap[i, j]\\) перегородка \\(i\\) является короткой, а \\(j\\) - длинной. Если жадно сдвинуть короткую перегородку \\(i\\) на одну позицию внутрь, то состояния, показанные на рисунке 15-12, будут «пропущены». Это означает, что позже мы уже не сможем проверить вместимость этих состояний.</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> Рисунок 15-12   Состояния, пропущенные из-за смещения короткой перегородки </p> <p>Нетрудно заметить, что эти пропущенные состояния на самом деле и есть все состояния, в которых длинная перегородка \\(j\\) сдвигается внутрь. Ранее мы уже доказали, что перемещение длинной перегородки внутрь обязательно уменьшает вместимость. Иными словами, пропущенные состояния не могут быть оптимальным решением, поэтому их пропуск не приводит к потере оптимума.</p> <p>Приведенный анализ показывает, что операция перемещения короткой перегородки является «безопасной», а жадная стратегия действительно корректна.</p>","path":["Глава 15. Жадность","15.3 &nbsp; Задача о максимальной вместимости"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   Задача о максимальном произведении разбиения","text":"<p>Question</p> <p>Дан положительный целый \\(n\\). Требуется разложить его в сумму как минимум двух положительных целых чисел и найти максимально возможное произведение всех полученных чисел, как показано на рисунке 15-13.</p> <p></p> <p> Рисунок 15-13   Определение задачи о максимальном произведении разбиения </p> <p>Предположим, что мы разбили \\(n\\) на \\(m\\) целочисленных множителей, где \\(i\\)-й множитель обозначим через \\(n_i\\), то есть</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>Цель задачи - найти максимальное произведение всех целочисленных множителей, то есть</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>Нужно понять: каким должно быть число частей \\(m\\) и какими должны быть значения каждого \\(n_i\\)?</p>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   Определение жадной стратегии","text":"<p>Из опыта известно, что произведение двух целых чисел часто больше их суммы. Предположим, что мы выделяем из \\(n\\) множитель \\(2\\), тогда произведение равно \\(2(n-2)\\). Сравним это выражение с \\(n\\):</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>Как показано на рисунке 15-14, когда \\(n \\geq 4\\), выделение множителя \\(2\\) увеличивает произведение. Это означает, что все целые числа, большие либо равные \\(4\\), следует продолжать разбивать.</p> <p>Жадная стратегия 1: если в схеме разбиения присутствует множитель \\(\\geq 4\\), то его нужно дальше разбивать. В конечной схеме разбиения должны остаться только множители \\(1\\), \\(2\\), \\(3\\).</p> <p></p> <p> Рисунок 15-14   Разбиение увеличивает произведение </p> <p>Теперь подумаем, какой множитель является наилучшим. Среди \\(1\\), \\(2\\), \\(3\\) очевидно худшим является \\(1\\), потому что всегда выполняется \\(1 \\times (n-1) &lt; n\\), то есть выделение \\(1\\) уменьшает произведение.</p> <p>Как показано на рисунке 15-15, при \\(n = 6\\) имеем \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\). Это означает, что выделять \\(3\\) выгоднее, чем выделять \\(2\\).</p> <p>Жадная стратегия 2: в схеме разбиения должно быть не более двух множителей \\(2\\). Потому что три двойки всегда можно заменить двумя тройками и получить большее произведение.</p> <p></p> <p> Рисунок 15-15   Оптимальные множители разбиения </p> <p>Итак, получаем следующую жадную стратегию.</p> <ol> <li>Для заданного целого \\(n\\) непрерывно выделять из него множитель \\(3\\), пока остаток не станет равным \\(0\\), \\(1\\) или \\(2\\).</li> <li>Если остаток равен \\(0\\), это означает, что \\(n\\) кратно \\(3\\), и больше ничего делать не нужно.</li> <li>Если остаток равен \\(2\\), дальнейшее разбиение не требуется, его нужно сохранить.</li> <li>Если остаток равен \\(1\\), то поскольку \\(2 \\times 2 &gt; 1 \\times 3\\), последний множитель \\(3\\) следует заменить на \\(2\\).</li> </ol>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   Код реализации","text":"<p>Как показано на рисунке 15-16, нам не нужен цикл, чтобы выполнять разбиение числа. Можно использовать целочисленное деление, чтобы получить число троек \\(a\\), и операцию взятия остатка, чтобы получить остаток \\(b\\). Тогда имеем:</p> \\[ n = 3 a + b \\] <p>Обратите внимание, что для граничного случая \\(n \\leq 3\\) необходимо выделить множитель \\(1\\), и тогда произведение равно \\(1 \\times (n - 1)\\).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"Максимальное произведение разрезания: жадный алгоритм\"\"\"\n    # Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # Жадно выделить множители 3, где a — число троек, а b — остаток\n    a, b = n // 3, n % 3\n    if b == 1:\n        # Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # Если остаток равен 2, ничего не делать\n        return int(math.pow(3, a)) * 2\n    # Если остаток равен 0, ничего не делать\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int)pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int) Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint MaxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunc maxProductCutting(n int) int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        return pow(3, a) * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunction maxProductCutting(n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // Если остаток равен 2, ничего не делать\n        return Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfunction maxProductCutting(n: number): number {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // Если остаток равен 2, ничего не делать\n        return Math.pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n  // Когда n &lt;= 3, обязательно нужно выделить одну 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // Жадно выделить множители 3, где a — число троек, а b — остаток\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // Если остаток равен 2, ничего не делать\n    return (pow(3, a) * 2).toInt();\n  }\n  // Если остаток равен 0, ничего не делать\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // Если остаток равен 2, ничего не делать\n        3_i32.pow(a as u32) * 2\n    } else {\n        // Если остаток равен 0, ничего не делать\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nint maxProductCutting(int n) {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return pow(3, a) * 2;\n    }\n    // Если остаток равен 0, ничего не делать\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* Максимальное произведение разрезания: жадный алгоритм */\nfun maxProductCutting(n: Int): Int {\n    // Когда n &lt;= 3, обязательно нужно выделить одну 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // Жадно выделить множители 3, где a — число троек, а b — остаток\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // Если остаток равен 2, ничего не делать\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // Если остаток равен 0, ничего не делать\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### Максимальное произведение разрезания: жадный алгоритм ###\ndef max_product_cutting(n)\n  # Когда n &lt;= 3, обязательно нужно выделить одну 1\n  return 1 * (n - 1) if n &lt;= 3\n  # Жадно выделить множители 3, где a — число троек, а b — остаток\n  a, b = n / 3, n % 3\n  # Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # Если остаток равен 2, ничего не делать\n  return (3.pow(a) * 2).to_i if b == 2\n  # Если остаток равен 0, ничего не делать\n  3.pow(a).to_i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p></p> <p> Рисунок 15-16   Метод вычисления максимального произведения разбиения </p> <p>Временная сложность зависит от того, как в языке программирования реализовано возведение в степень. Если взять Python, то обычно используются три распространенные функции для вычисления степени.</p> <ul> <li>Оператор <code>**</code> и функция <code>pow()</code> имеют временную сложность \\(O(\\log⁡ a)\\).</li> <li>Функция <code>math.pow()</code> внутри вызывает функцию <code>pow()</code> из библиотеки C, выполняющую возведение в степень с плавающей точкой, и ее временная сложность равна \\(O(1)\\).</li> </ul> <p>Переменные \\(a\\) и \\(b\\) занимают дополнительную память постоянного размера, поэтому пространственная сложность равна \\(O(1)\\).</p>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   Доказательство корректности","text":"<p>Используем доказательство от противного и рассмотрим только случай \\(n \\geq 4\\).</p> <ol> <li>Все множители \\(\\leq 3\\): предположим, что в оптимальной схеме разбиения существует множитель \\(x \\geq 4\\). Тогда его можно дальше разложить в \\(2(x-2)\\) и получить большее или равное произведение. Это противоречит предположению.</li> <li>Схема разбиения не содержит \\(1\\): предположим, что в оптимальной схеме присутствует множитель \\(1\\). Тогда его можно объединить с другим множителем и получить большее произведение. Это противоречит предположению.</li> <li>Схема разбиения содержит не более двух \\(2\\): предположим, что в оптимальной схеме присутствуют три двойки. Тогда их можно заменить двумя тройками и получить большее произведение. Это противоречит предположению.</li> </ol>","path":["Глава 15. Жадность","15.4 &nbsp; Задача о максимальном произведении разбиения"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   Резюме","text":"","path":["Глава 15. Жадность","15.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   Ключевые моменты","text":"<ul> <li>Жадный алгоритм обычно используется для решения задач оптимизации. Его принцип состоит в том, чтобы на каждом этапе принятия решения делать локально оптимальный выбор в надежде получить глобально оптимальный ответ.</li> <li>Жадный алгоритм итеративно делает один жадный выбор за другим, на каждом шаге превращая задачу в подзадачу меньшего размера, пока задача не будет полностью решена.</li> <li>Жадный алгоритм не только прост в реализации, но и часто обладает высокой эффективностью. По сравнению с динамическим программированием его временная сложность обычно ниже.</li> <li>В задаче о размене монет для некоторых наборов монет жадный алгоритм способен гарантировать оптимальный ответ, а для других наборов - нет: он может дать очень плохое решение.</li> <li>Задачи, подходящие для жадного алгоритма, обладают двумя ключевыми свойствами: свойством жадного выбора и оптимальной подструктурой. Свойство жадного выбора отражает корректность жадной стратегии.</li> <li>Для некоторых сложных задач доказать свойство жадного выбора непросто. Относительно легче найти контрпример и опровергнуть его, как это видно на примере задачи о размене монет.</li> <li>Решение жадной задачи обычно состоит из трех шагов: анализ задачи, определение жадной стратегии и доказательство корректности. Из них ключевым является выбор жадной стратегии, а доказательство корректности часто оказывается самым трудным.</li> <li>В задаче о дробном рюкзаке, в отличие от задачи о рюкзаке 0-1, разрешено брать часть предмета, поэтому ее можно решать жадным алгоритмом. Корректность жадной стратегии доказывается методом от противного.</li> <li>Задачу о максимальной вместимости можно решать полным перебором со временной сложностью \\(O(n^2)\\). Разработав жадную стратегию со сдвигом короткой перегородки внутрь на каждом шаге, временную сложность можно оптимизировать до \\(O(n)\\).</li> <li>В задаче о максимальном произведении разбиения мы последовательно выводим две жадные стратегии: все целые числа \\(\\geq 4\\) следует дальше разбивать, а оптимальным множителем разбиения является \\(3\\). В коде присутствуют операции возведения в степень, поэтому временная сложность зависит от способа их реализации и обычно равна \\(O(1)\\) или \\(O(\\log n)\\).</li> </ul>","path":["Глава 15. Жадность","15.5 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"Глава 6.   Хеш-таблицы","text":"<p>Abstract</p> <p>Хеш-таблица устанавливает соответствие между ключом и значением.</p> <p>Благодаря этому она позволяет получать нужное значение по ключу за очень короткое время.</p>","path":["Глава 6. Хеш-таблицы","Глава 6. &nbsp; Хеш-таблицы"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>6.1   Хеш-таблица</li> <li>6.2   Хеш-коллизии</li> <li>6.3   Алгоритмы хеширования</li> <li>6.4   Резюме</li> </ul>","path":["Глава 6. Хеш-таблицы","Глава 6. &nbsp; Хеш-таблицы"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   Алгоритмы хеширования","text":"<p>В двух предыдущих разделах мы рассмотрели принципы работы хеш-таблицы и способы обработки хеш-коллизий. Однако и открытая адресация, и метод цепочек лишь позволяют хеш-таблице корректно работать при возникновении коллизий, но не уменьшают вероятность появления самих коллизий.</p> <p>Если хеш-коллизии происходят слишком часто, производительность хеш-таблицы резко деградирует. Как показано на рисунке 6-8, для хеш-таблицы с методом цепочек в идеальном случае пары ключ-значение равномерно распределены по всем бакетам, и это дает наилучшую эффективность поиска; в худшем же случае все пары ключ-значение оказываются в одном бакете, и временная сложность вырождается до \\(O(n)\\) .</p> <p></p> <p> Рисунок 6-8   Лучший и худший случаи хеш-коллизий </p> <p>Распределение пар ключ-значение определяется хеш-функцией. Вспомним этапы вычисления хеш-функции: сначала вычисляется хеш-значение, затем оно берется по модулю длины массива:</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>Из этой формулы видно: при фиксированной емкости хеш-таблицы <code>capacity</code> **выходное значение определяет именно хеш-алгоритм <code>hash()</code> **, а значит, именно он определяет распределение пар ключ-значение в хеш-таблице.</p> <p>Это означает, что для уменьшения вероятности хеш-коллизий нам следует сосредоточиться на проектировании хеш-алгоритма <code>hash()</code> .</p>","path":["Глава 6. Хеш-таблицы","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631-","level":2,"title":"6.3.1   Цели хеш-алгоритма","text":"<p>Чтобы получить структуру данных хеш-таблицы, которая будет одновременно быстрой и надежной, хеш-алгоритм должен обладать следующими свойствами.</p> <ul> <li>Детерминированность: для одинакового входа хеш-алгоритм всегда должен выдавать одинаковый результат. Только так хеш-таблица остается надежной.</li> <li>Высокая эффективность: вычисление хеш-значения должно быть достаточно быстрым. Чем меньше вычислительные затраты, тем выше практическая ценность хеш-таблицы.</li> <li>Равномерное распределение: хеш-алгоритм должен стараться распределять пары ключ-значение в хеш-таблице равномерно. Чем равномернее распределение, тем ниже вероятность хеш-коллизий.</li> </ul> <p>На практике хеш-алгоритмы используются не только для реализации хеш-таблиц, но и во многих других областях.</p> <ul> <li>Хранение паролей: чтобы защищать пароли пользователей, система обычно хранит не сами пароли в открытом виде, а их хеш-значения. Когда пользователь вводит пароль, система вычисляет хеш-значение введенного пароля и сравнивает его с сохраненным значением. Если они совпадают, пароль считается правильным.</li> <li>Проверка целостности данных: отправитель может вычислить хеш-значение данных и отправить его вместе с самими данными; получатель затем вычисляет хеш-значение повторно и сравнивает его с полученным. Если они совпадают, данные считаются целостными.</li> </ul> <p>Для приложений, связанных с криптографией, чтобы не допустить восстановления исходного пароля по хеш-значению и иных форм обратного анализа, хеш-алгоритм должен обладать более строгими свойствами безопасности.</p> <ul> <li>Односторонность: по хеш-значению нельзя восстановить какую-либо информацию о входных данных.</li> <li>Устойчивость к коллизиям: должно быть крайне трудно найти два разных входа, имеющих одинаковое хеш-значение.</li> <li>Эффект лавины: даже небольшое изменение во входных данных должно приводить к заметному и непредсказуемому изменению результата.</li> </ul> <p>Обрати внимание: \"равномерное распределение\" и \"устойчивость к коллизиям\" - это два независимых понятия , и выполнение первого не означает автоматического выполнения второго. Например, при случайном распределении входных <code>key</code> хеш-функция <code>key % 100</code> может выдавать достаточно равномерное распределение. Однако этот хеш-алгоритм слишком прост: все <code>key</code> с одинаковыми двумя последними цифрами будут иметь одинаковый результат, а значит, по хеш-значению можно легко подобрать подходящие <code>key</code> и, например, взломать пароль.</p>","path":["Глава 6. Хеш-таблицы","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632-","level":2,"title":"6.3.2   Проектирование хеш-алгоритма","text":"<p>Разработка хеш-алгоритма - это сложная задача, в которой нужно учитывать множество факторов. Однако для некоторых нетребовательных сценариев мы можем спроектировать и несколько простых хеш-алгоритмов.</p> <ul> <li>Аддитивный хеш: складываем ASCII-коды всех символов входной строки и используем полученную сумму как хеш-значение.</li> <li>Мультипликативный хеш: используем \"некоррелированность\" умножения; на каждом шаге умножаем текущее значение на константу и добавляем ASCII-код очередного символа.</li> <li>XOR-хеш: последовательно накапливаем элементы входных данных в одном хеш-значении через операцию XOR.</li> <li>Ротационный хеш: последовательно накапливаем ASCII-коды символов, причем перед каждым накоплением выполняем циклический сдвиг хеш-значения.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"Аддитивное хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"Мультипликативное хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"XOR-хеширование\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"Хеширование с циклическим сдвигом\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* Аддитивное хеширование */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* Аддитивное хеширование */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* XOR-хеширование */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* Аддитивное хеширование */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* Аддитивное хеширование */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* Мультипликативное хеширование */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* XOR-хеширование */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* Хеширование с циклическим сдвигом */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* Аддитивное хеширование */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* Мультипликативное хеширование */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* XOR-хеширование */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* Хеширование с циклическим сдвигом */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* Аддитивное хеширование */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Мультипликативное хеширование */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR-хеширование */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* Аддитивное хеширование */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* Мультипликативное хеширование */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* XOR-хеширование */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* Аддитивное хеширование */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* XOR-хеширование */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* Аддитивное хеширование */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* Мультипликативное хеширование */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* XOR-хеширование */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* Хеширование с циклическим сдвигом */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* Аддитивное хеширование */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* Мультипликативное хеширование */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* XOR-хеширование */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* Хеширование с циклическим сдвигом */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* Аддитивное хеширование */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* Мультипликативное хеширование */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* XOR-хеширование */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* Хеширование с циклическим сдвигом */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### Аддитивное хеширование ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### Мультипликативное хеширование ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### XOR-хеширование ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### Хеширование с циклическим сдвигом ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Нетрудно заметить, что последний шаг каждого из этих хеш-алгоритмов - взятие по модулю большого простого числа \\(1000000007\\) , чтобы гарантировать, что хеш-значение остается в разумных границах. Стоит задуматься: почему подчеркивается именно взятие по модулю простого числа, и какие недостатки возникают при использовании составного модуля? Это интересный вопрос.</p> <p>Сначала дадим вывод: использование большого простого числа в качестве модуля позволяет в максимальной степени обеспечивать равномерное распределение хеш-значений. Поскольку простое число не имеет общих делителей с другими числами, это помогает уменьшить периодические закономерности, возникающие из-за операции взятия остатка, и тем самым снизить число хеш-коллизий.</p> <p>Рассмотрим пример. Предположим, мы выбрали составное число \\(9\\) в качестве модуля. Оно делится на \\(3\\) , поэтому все <code>key</code> , которые делятся на \\(3\\) , будут отображаться только в три хеш-значения: \\(0\\) , \\(3\\) , \\(6\\) .</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>Если входные <code>key</code> как раз удовлетворяют такому распределению в виде арифметической прогрессии, то хеш-значения начнут скучиваться, а это усугубит хеш-коллизии. Теперь предположим, что мы заменили <code>modulus</code> на простое число \\(13\\) ; поскольку между <code>key</code> и <code>modulus</code> нет общих делителей, равномерность распределения хеш-значений заметно улучшится.</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>Следует отметить: если можно гарантировать, что <code>key</code> распределены случайно и равномерно, то выбор простого или составного числа в качестве модуля не так важен - оба варианта способны дать равномерное распределение хеш-значений. Но если в распределении <code>key</code> присутствует периодичность, то взятие по модулю составного числа гораздо легче приводит к кластеризации.</p> <p>Итак, на практике мы обычно выбираем простое число в качестве модуля, причем это простое число желательно брать достаточно большим, чтобы по возможности убрать периодические закономерности и повысить устойчивость хеш-алгоритма.</p>","path":["Глава 6. Хеш-таблицы","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633-","level":2,"title":"6.3.3   Распространенные хеш-алгоритмы","text":"<p>Нетрудно заметить, что описанные выше простые хеш-алгоритмы довольно хрупкие и далеки от поставленных целей. Например, сложение и XOR подчиняются коммутативному закону, поэтому аддитивный хеш и XOR-хеш не различают строки, состоящие из одних и тех же символов, но в разном порядке. Это может усиливать хеш-коллизии и даже создавать некоторые проблемы безопасности.</p> <p>На практике мы обычно используем стандартные хеш-алгоритмы, такие как MD5, SHA-1, SHA-2 и SHA-3. Они могут отображать входные данные произвольной длины в хеш-значения фиксированной длины.</p> <p>На протяжении почти ста лет хеш-алгоритмы непрерывно развивались и оптимизировались. Одни исследователи старались повысить их производительность, а другие исследователи и хакеры сосредоточивались на поиске уязвимостей в их безопасности. В таблице 6-2 приведены распространенные хеш-алгоритмы, которые часто встречаются в реальных приложениях.</p> <ul> <li>MD5 и SHA-1 уже многократно были успешно атакованы, поэтому они выведены из большинства сценариев, где требуется безопасность.</li> <li>SHA-256 из семейства SHA-2 является одним из самых надежных хеш-алгоритмов; на сегодняшний день не известно успешных практических атак, поэтому он широко используется в самых разных протоколах и системах безопасности.</li> <li>SHA-3 по сравнению с SHA-2 требует меньших затрат на реализацию и обеспечивает более высокую вычислительную эффективность, но на данный момент распространен слабее, чем семейство SHA-2.</li> </ul> <p> Таблица 6-2   Распространенные хеш-алгоритмы </p> MD5 SHA-1 SHA-2 SHA-3 Год появления 1992 1995 2002 2008 Длина вывода 128 bit 160 bit 256/512 bit 224/256/384/512 bit Хеш-коллизии Частые Частые Редкие Редкие Уровень безопасности Низкий, успешно атакован Низкий, успешно атакован Высокий Высокий Применение Устарел, но еще используется для проверки целостности данных Устарел Проверка криптовалютных транзакций, цифровые подписи и т. д. Может использоваться как замена SHA-2","path":["Глава 6. Хеш-таблицы","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634-","level":2,"title":"6.3.4   Хеш-значения структур данных","text":"<p>Мы знаем, что <code>key</code> в хеш-таблице могут быть целыми числами, вещественными числами, строками и другими типами данных. Языки программирования обычно предоставляют встроенные хеш-алгоритмы для этих типов, чтобы вычислять индексы бакетов в хеш-таблице. Возьмем Python: в нем можно вызвать функцию <code>hash()</code> , чтобы вычислить хеш-значения для различных типов данных.</p> <ul> <li>Хеш-значение целого числа и булева значения совпадает с самим значением.</li> <li>Вычисление хеш-значений для вещественных чисел и строк устроено сложнее; интересующиеся читатели могут изучить это самостоятельно.</li> <li>Хеш-значение кортежа получается путем хеширования каждого элемента, а затем объединения этих хеш-значений в одно итоговое значение.</li> <li>Хеш-значение объекта обычно строится на основе его адреса в памяти. Если переопределить метод хеширования объекта, можно реализовать вычисление хеша по содержимому.</li> </ul> <p>Tip</p> <p>Обрати внимание: определения и способы вычисления встроенных хеш-значений в разных языках программирования отличаются.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# Хеш-значение целого числа 3 равно 3\n\nbol = True\nhash_bol = hash(bol)\n# Хеш-значение булевого значения True равно 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Хеш-значение числа 3.14159 равно 326484311674566659\n\nstr = \"Hello Algo\"\nhash_str = hash(str)\n# Хеш-значение строки \"Hello Algo\" равно 4617003410720528961\n\ntup = (12836, \"Сяо Ха\")\nhash_tup = hash(tup)\n# Хеш-значение кортежа (12836, \"Сяо Ха\") равно 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Хеш-значение объекта узла &lt;ListNode object at 0x1058fd810&gt; равно 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// Хеш-значение целого числа 3 равно 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// Хеш-значение булевого значения 1 равно 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// Хеш-значение числа 3.14159 равно 4614256650576692846\n\nstring str = \"Hello Algo\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// Хеш-значение строки \"Hello Algo\" равно 15466937326284535026\n\n// В C++ встроенный std::hash() предоставляет вычисление хеша только для базовых типов данных\n// Для массивов и объектов хеш-значение обычно приходится реализовывать самостоятельно\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// Хеш-значение целого числа 3 равно 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Хеш-значение булевого значения true равно 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Хеш-значение числа 3.14159 равно -1340954729\n\nString str = \"Hello Algo\";\nint hashStr = str.hashCode();\n// Хеш-значение строки \"Hello Algo\" равно -727081396\n\nObject[] arr = { 12836, \"Сяо Ха\" };\nint hashTup = Arrays.hashCode(arr);\n// Хеш-значение массива [12836, Сяо Ха] равно 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Хеш-значение объекта узла utils.ListNode@7dc5e7b4 равно 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// Хеш-значение целого числа 3 равно 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Хеш-значение булевого значения true равно 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Хеш-значение числа 3.14159 равно -1340954729;\n\nstring str = \"Hello Algo\";\nint hashStr = str.GetHashCode();\n// Хеш-значение строки \"Hello Algo\" равно -586107568;\n\nobject[] arr = [12836, \"Сяо Ха\"];\nint hashTup = arr.GetHashCode();\n// Хеш-значение массива [12836, Сяо Ха] равно 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Хеш-значение объекта узла 0 равно 39053774;\n</code></pre> built_in_hash.go<pre><code>// В Go нет встроенной функции hash code\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// Хеш-значение целого числа 3 равно 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Хеш-значение булевого значения true равно -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Хеш-значение числа 3.14159 равно -2465384235396674631\n\nlet str = \"Hello Algo\"\nlet hashStr = str.hashValue\n// Хеш-значение строки \"Hello Algo\" равно -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"Сяо Ха\")]\nlet hashTup = arr.hashValue\n// Хеш-значение массива [AnyHashable(12836), AnyHashable(\"Сяо Ха\")] равно -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Хеш-значение объекта узла utils.ListNode равно -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// В JavaScript нет встроенной функции hash code\n</code></pre> built_in_hash.ts<pre><code>// В TypeScript нет встроенной функции hash code\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// Хеш-значение целого числа 3 равно 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Хеш-значение булевого значения true равно 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Хеш-значение числа 3.14159 равно 2570631074981783\n\nString str = \"Hello Algo\";\nint hashStr = str.hashCode;\n// Хеш-значение строки \"Hello Algo\" равно 468167534\n\nList arr = [12836, \"Сяо Ха\"];\nint hashArr = arr.hashCode;\n// Хеш-значение массива [12836, Сяо Ха] равно 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Хеш-значение объекта Instance of 'ListNode' равно 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Хеш-значение целого числа 3 равно 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Хеш-значение булевого значения true равно 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Хеш-значение числа 3.14159 равно 2566941990314602357\n\nlet str = \"Hello Algo\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Хеш-значение строки \"Hello Algo\" равно 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"Сяо Ха\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Хеш-значение кортежа (12836, \"Сяо Ха\") равно 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// Хеш-значение объекта RefCell { value: ListNode { val: 42, next: None } } равно 15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// В C нет встроенной функции hash code\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// Хеш-значение целого числа 3 равно 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// Хеш-значение булевого значения true равно 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// Хеш-значение числа 3.14159 равно -1340954729\n\nval str = \"Hello Algo\"\nval hashStr = str.hashCode()\n// Хеш-значение строки \"Hello Algo\" равно -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"Сяо Ха\")\nval hashTup = arr.hashCode()\n// Хеш-значение массива [12836, Сяо Ха] равно 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// Хеш-значение объекта узла utils.ListNode@1d81eb93 равно 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# Хеш-значение целого числа 3 равно -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# Хеш-значение булевого значения true равно -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# Хеш-значение числа 3.14159 равно -1479186995943067893\n\nstr = \"Hello Algo\"\nhash_str = str.hash\n# Хеш-значение строки \"Hello Algo\" равно -4075943250025831763\n\ntup = [12836, 'Сяо Ха']\nhash_tup = tup.hash\n# Хеш-значение кортежа (12836, 'Сяо Ха') равно 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# Хеш-значение объекта #&lt;ListNode:0x000078133140ab70&gt; равно 4302940560806366381\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9%20%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D1%83%D0%B7%D0%B5%D0%BB%D0%BA%D0%BB%D0%B0%D1%81%D1%81%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D0%BB%D0%B5%D0%B4%D1%83%D1%8E%D1%89%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20num%20%3D%203%0A%20%20%20%20hash_num%20%3D%20hash%28num%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%86%D0%B5%D0%BB%D0%BE%D0%B3%D0%BE%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%203%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%203%0A%0A%20%20%20%20bol%20%3D%20True%0A%20%20%20%20hash_bol%20%3D%20hash%28bol%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B1%D1%83%D0%BB%D0%B5%D0%B2%D0%B0%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20True%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%201%0A%0A%20%20%20%20dec%20%3D%203.14159%0A%20%20%20%20hash_dec%20%3D%20hash%28dec%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%203.14159%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%20326484311674566659%0A%0A%20%20%20%20str%20%3D%20%22Hello%20Algo%22%0A%20%20%20%20hash_str%20%3D%20hash%28str%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8%20%22Hello%20Algo%22%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%204617003410720528961%0A%0A%20%20%20%20tup%20%3D%20%2812836%2C%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%29%0A%20%20%20%20hash_tup%20%3D%20hash%28tup%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D0%BE%D1%80%D1%82%D0%B5%D0%B6%D0%B0%20%2812836%2C%20%27%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%27%29%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%201029005403108185979%0A%0A%20%20%20%20obj%20%3D%20ListNode%280%29%0A%20%20%20%20hash_obj%20%3D%20hash%28obj%29%0A%20%20%20%20%23%20%D0%A5%D0%B5%D1%88-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%B0%20%D1%83%D0%B7%D0%BB%D0%B0%20%3CListNode%20object%20at%200x1058fd810%3E%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%20274267521&amp;cumulative=false&amp;curInstr=19&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Во многих языках программирования в качестве <code>key</code> хеш-таблицы можно использовать только неизменяемые объекты . Если, например, использовать список (динамический массив) как <code>key</code> , то после изменения содержимого списка изменится и его хеш-значение, из-за чего мы уже не сможем найти прежнее <code>value</code> в хеш-таблице.</p> <p>Хотя у пользовательских объектов (например, у узла связного списка) поля являются изменяемыми, сам объект все же может быть хешируемым. Причина в том, что хеш-значение объекта обычно строится на основе адреса в памяти : даже если содержимое объекта меняется, его адрес памяти остается прежним, а значит, и хеш-значение не меняется.</p> <p>Внимательный читатель мог заметить, что при запуске программы в разных консолях выводимые хеш-значения отличаются. Это связано с тем, что интерпретатор Python при каждом запуске добавляет в хеш-функцию строк случайную соль (salt). Такой подход эффективно защищает от атак типа HashDoS и повышает безопасность хеш-алгоритма.</p>","path":["Глава 6. Хеш-таблицы","6.3 &nbsp; Алгоритмы хеширования"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   Хеш-коллизии","text":"<p>Как уже говорилось в предыдущем разделе, в обычных условиях входное пространство хеш-функции намного больше выходного пространства , поэтому теоретически хеш-коллизии неизбежны. Например, если входное пространство состоит из всех целых чисел, а выходное пространство ограничено размером массива, то неизбежно несколько целых чисел будут отображаться в один и тот же индекс бакета.</p> <p>Хеш-коллизии могут приводить к ошибочным результатам поиска и серьезно влиять на работоспособность хеш-таблицы. Чтобы решить эту проблему, можно при каждом конфликте выполнять расширение хеш-таблицы, пока конфликт не исчезнет. Этот метод понятен и прост, но слишком неэффективен, потому что расширение хеш-таблицы требует большого объема переноса данных и вычислений хеш-значений. Чтобы повысить эффективность, можно использовать следующие стратегии.</p> <ol> <li>Улучшить структуру данных хеш-таблицы, чтобы она могла корректно работать даже при возникновении хеш-коллизий.</li> <li>Выполнять расширение только тогда, когда это действительно необходимо, то есть когда хеш-коллизии становятся достаточно серьезными.</li> </ol> <p>Основные способы улучшения структуры хеш-таблицы включают метод цепочек и открытую адресацию.</p>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   Метод цепочек","text":"<p>В исходной хеш-таблице каждый бакет может хранить только одну пару ключ-значение. Метод цепочек (separate chaining) превращает отдельный элемент в связный список: пары ключ-значение становятся узлами списка, и все конфликтующие пары ключ-значение хранятся в одном и том же списке. На рисунке 6-5 показан пример хеш-таблицы, реализованной методом цепочек.</p> <p></p> <p> Рисунок 6-5   Хеш-таблица с методом цепочек </p> <p>Методы работы с хеш-таблицей, построенной на основе метода цепочек, меняются следующим образом.</p> <ul> <li>Поиск элемента: передаем <code>key</code> , по хеш-функции получаем индекс бакета, после чего обращаемся к голове списка и обходим список, сравнивая <code>key</code> , пока не найдем целевую пару ключ-значение.</li> <li>Добавление элемента: сначала через хеш-функцию получаем голову списка, затем добавляем узел (пару ключ-значение) в этот список.</li> <li>Удаление элемента: по результату хеш-функции обращаемся к голове списка, затем обходим список, находим целевой узел и удаляем его.</li> </ul> <p>Метод цепочек имеет следующие ограничения.</p> <ul> <li>Рост потребления памяти: связный список содержит указатели на узлы, поэтому по сравнению с массивом он требует больше памяти.</li> <li>Снижение эффективности поиска: для нахождения нужного элемента нужно линейно обходить связный список.</li> </ul> <p>Ниже приведена простая реализация хеш-таблицы методом цепочек. Следует обратить внимание на два момента.</p> <ul> <li>Для упрощения кода вместо связного списка используется список (динамический массив). В этой реализации хеш-таблица (массив) содержит несколько бакетов, и каждый бакет представляет собой список.</li> <li>Ниже включен метод расширения хеш-таблицы. Когда коэффициент загрузки превышает \\(\\frac{2}{3}\\) , мы расширяем хеш-таблицу до \\(2\\) раз от прежней емкости.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"Хеш-таблица с цепочками\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self.size = 0  # Число пар ключ-значение\n        self.capacity = 4  # Вместимость хеш-таблицы\n        self.load_thres = 2.0 / 3.0  # Порог коэффициента загрузки для запуска расширения\n        self.extend_ratio = 2  # Коэффициент расширения\n        self.buckets = [[] for _ in range(self.capacity)]  # Массив корзин\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Коэффициент загрузки\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Операция поиска\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # Если key не найден, вернуть None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Операция добавления\"\"\"\n        # Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # Если такого key нет, добавить пару ключ-значение в конец\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # Обойти корзину и удалить из нее пару ключ-значение\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"Расширить хеш-таблицу\"\"\"\n        # Временно сохранить исходную хеш-таблицу\n        buckets = self.buckets\n        # Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n  private:\n    int size;                       // Число пар ключ-значение\n    int capacity;                   // Вместимость хеш-таблицы\n    double loadThres;               // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;                // Коэффициент расширения\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // Массив корзин\n\n  public:\n    /* Конструктор */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* Метод-деструктор */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // Освободить память\n                delete pair;\n            }\n        }\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        int index = hashFunc(key);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // Если key не найден, вернуть пустую строку\n        return \"\";\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // Удалить из него пару ключ-значение\n                delete tmp;                       // Освободить память\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // Освободить память\n                delete pair;\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    int size; // Число пар ключ-значение\n    int capacity; // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio; // Коэффициент расширения\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n    /* Конструктор */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Операция поиска */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    void put(int key, String val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    int size; // Число пар ключ-значение\n    int capacity; // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio; // Коэффициент расширения\n    List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n    /* Конструктор */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Обойти корзину и удалить из нее пару ключ-значение\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void Extend() {\n        // Временно сохранить исходную хеш-таблицу\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* Хеш-таблица с цепочками */\ntype hashMapChaining struct {\n    size        int      // Число пар ключ-значение\n    capacity    int      // Вместимость хеш-таблицы\n    loadThres   float64  // Порог коэффициента загрузки для запуска расширения\n    extendRatio int      // Коэффициент расширения\n    buckets     [][]pair // Массив корзин\n}\n\n/* Конструктор */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* Хеш-функция */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* Коэффициент загрузки */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* Операция поиска */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // Если key не найден, вернуть пустую строку\n    return \"\"\n}\n\n/* Операция добавления */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // Если такого key нет, добавить пару ключ-значение в конец\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* Операция удаления */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // Обойти корзину и удалить из нее пару ключ-значение\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // Удаление из среза\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* Расширить хеш-таблицу */\nfunc (m *hashMapChaining) extend() {\n    // Временно сохранить исходную хеш-таблицу\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // Инициализация новой хеш-таблицы после расширения\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* Вывести хеш-таблицу */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    var loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    var extendRatio: Int // Коэффициент расширения\n    var buckets: [[Pair]] // Массив корзин\n\n    /* Конструктор */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* Хеш-функция */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // Если key не найден, вернуть nil\n        return nil\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    func extend() {\n        // Временно сохранить исходную хеш-таблицу\n        let bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    #size; // Число пар ключ-значение\n    #capacity; // Вместимость хеш-таблицы\n    #loadThres; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio; // Коэффициент расширения\n    #buckets; // Массив корзин\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key, val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend() {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    #size: number; // Число пар ключ-значение\n    #capacity: number; // Вместимость хеш-таблицы\n    #loadThres: number; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio: number; // Коэффициент расширения\n    #buckets: Pair[][]; // Массив корзин\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* Операция поиска */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // Если key не найден, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key: number, val: string): void {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend(): void {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n  late int size; // Число пар ключ-значение\n  late int capacity; // Вместимость хеш-таблицы\n  late double loadThres; // Порог коэффициента загрузки для запуска расширения\n  late int extendRatio; // Коэффициент расширения\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // Массив корзин\n\n  /* Конструктор */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* Хеш-функция */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* Коэффициент загрузки */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // Если key не найден, вернуть null\n    return null;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // Если такого key нет, добавить пару ключ-значение в конец\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // Обойти корзину и удалить из нее пару ключ-значение\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* Расширить хеш-таблицу */\n  void extend() {\n    // Временно сохранить исходную хеш-таблицу\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* Хеш-таблица с цепочками */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* Конструктор */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* Коэффициент загрузки */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* Операция удаления */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // Если key не найден, вернуть None\n        None\n    }\n\n    /* Расширить хеш-таблицу */\n    fn extend(&amp;mut self) {\n        // Временно сохранить исходную хеш-таблицу\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* Операция добавления */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // Если такого key нет, добавить пару ключ-значение в конец\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* Операция поиска */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // Если key не найден, вернуть None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* Узел связного списка */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* Хеш-таблица с цепочками */\ntypedef struct {\n    int size;         // Число пар ключ-значение\n    int capacity;     // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;  // Коэффициент расширения\n    Node **buckets;   // Массив корзин\n} HashMapChaining;\n\n/* Конструктор */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* Деструктор */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* Хеш-функция */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Коэффициент загрузки */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Операция поиска */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // Обойти корзину; если найден key, вернуть соответствующее val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // Если key не найден, вернуть пустую строку\n}\n\n/* Операция добавления */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // Если встретился указанный key, обновить соответствующий val и вернуть\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // Если такого key нет, добавить пару ключ-значение в голову связного списка\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* Расширить хеш-таблицу */\nvoid extend(HashMapChaining *hashMap) {\n    // Временно сохранить исходную хеш-таблицу\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // Освободить память\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* Операция удаления */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // Удалить из него пару ключ-значение\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // Освободить память\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* Вывести хеш-таблицу */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* Хеш-таблица с цепочками */\nclass HashMapChaining {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    val loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    val extendRatio: Int // Коэффициент расширения\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // Массив корзин\n\n    /* Конструктор */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину; если найден key, вернуть соответствующее val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // Если key не найден, вернуть null\n        return null\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // Если такого key нет, добавить пару ключ-значение в конец\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // Обойти корзину и удалить из нее пару ключ-значение\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fun extend() {\n        // Временно сохранить исходную хеш-таблицу\n        val bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        // mutablelist не имеет фиксированного размера\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### Хеш-таблица с цепочками ###\nclass HashMapChaining\n  ### Конструктор ###\n  def initialize\n    @size = 0 # Число пар ключ-значение\n    @capacity = 4 # Вместимость хеш-таблицы\n    @load_thres = 2.0 / 3.0 # Порог коэффициента загрузки для запуска расширения\n    @extend_ratio = 2 # Коэффициент расширения\n    @buckets = Array.new(@capacity) { [] } # Массив корзин\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Коэффициент загрузки ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину; если найден key, вернуть соответствующее val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # Если key не найден, вернуть nil\n    nil\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    # Когда коэффициент загрузки превышает порог, выполнить расширение\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # Если такого key нет, добавить пару ключ-значение в конец\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # Обойти корзину и удалить из нее пару ключ-значение\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### Расширение хеш-таблицы ###\n  def extend\n    # Временно сохранить исходную хеш-таблицу\n    buckets = @buckets\n    # Инициализация новой хеш-таблицы после расширения\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Следует отметить, что когда связный список становится очень длинным, эффективность поиска \\(O(n)\\) оказывается низкой. В этом случае список можно преобразовать в AVL-дерево или красно-черное дерево , чтобы оптимизировать временную сложность поиска до \\(O(\\log n)\\) .</p>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   Открытая адресация","text":"<p>Открытая адресация (open addressing) не вводит дополнительных структур данных, а обрабатывает хеш-коллизии с помощью многократного пробирования; основные варианты пробирования включают линейное пробирование, квадратичное пробирование и повторное хеширование.</p> <p>Ниже на примере линейного пробирования рассмотрим механизм работы хеш-таблицы с открытой адресацией.</p>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   Линейное пробирование","text":"<p>Линейное пробирование использует линейный поиск с фиксированным шагом. Его методы работы отличаются от обычной хеш-таблицы.</p> <ul> <li>Вставка элемента: по хеш-функции вычисляется индекс бакета; если бакет уже занят, то от места конфликта выполняется линейный обход вперед (шаг обычно равен \\(1\\) ), пока не будет найден пустой бакет, после чего элемент вставляется туда.</li> <li>Поиск элемента: если возник конфликт, то с тем же шагом продолжается линейный обход вперед, пока не будет найден целевой элемент и возвращено <code>value</code> ; если встречается пустой бакет, это означает, что искомого элемента в хеш-таблице нет, и возвращается <code>None</code> .</li> </ul> <p>На рисунке 6-6 показано распределение пар ключ-значение в хеш-таблице с открытой адресацией (линейное пробирование). Для этой хеш-функции все <code>key</code> с одинаковыми двумя последними цифрами отображаются в один и тот же бакет. Благодаря линейному пробированию они по очереди сохраняются в этом бакете и в следующих за ним бакетах.</p> <p></p> <p> Рисунок 6-6   Распределение пар ключ-значение в хеш-таблице с открытой адресацией (линейное пробирование) </p> <p>Однако линейное пробирование легко приводит к кластеризации. Иначе говоря, чем длиннее непрерывная занятая область в массиве, тем выше вероятность новых коллизий в этой области, что еще сильнее способствует росту этой группы и в итоге ухудшает эффективность операций добавления, удаления, поиска и обновления.</p> <p>Стоит заметить, что мы не можем напрямую удалять элементы из хеш-таблицы с открытой адресацией. Причина в том, что удаление создаст внутри массива пустой бакет <code>None</code> , а при поиске элемента линейное пробирование остановится на этом пустом бакете и вернет результат, из-за чего элементы ниже этого бакета уже не смогут быть найдены, и программа может ошибочно посчитать, что их не существует, как показано на рисунке 6-7.</p> <p></p> <p> Рисунок 6-7   Проблема поиска после удаления элемента в открытой адресации </p> <p>Чтобы решить эту проблему, можно использовать механизм ленивого удаления (lazy deletion): он не удаляет элемент из хеш-таблицы напрямую, **а помечает этот бакет специальной константой <code>TOMBSTONE</code> **. В этом механизме и <code>None</code> , и <code>TOMBSTONE</code> означают пустой бакет, и оба могут быть использованы для размещения пары ключ-значение. Но есть важное различие: при линейном пробировании, встретив <code>TOMBSTONE</code> , нужно продолжать обход, потому что ниже него все еще могут существовать пары ключ-значение.</p> <p>Однако ленивое удаление может ускорять деградацию производительности хеш-таблицы. Это связано с тем, что каждая операция удаления создает новую метку удаления; по мере роста числа <code>TOMBSTONE</code> время поиска тоже увеличивается, потому что линейное пробирование может быть вынуждено перескакивать через множество <code>TOMBSTONE</code> , прежде чем найдет целевой элемент.</p> <p>Поэтому имеет смысл при линейном пробировании запоминать индекс первого встреченного <code>TOMBSTONE</code> и затем менять найденный целевой элемент местами с этим <code>TOMBSTONE</code> . Преимущество такого подхода в том, что при каждом поиске или добавлении элемент будет перемещаться в бакет, расположенный ближе к его идеальной позиции (начальной точке пробирования), а значит, эффективность поиска улучшится.</p> <p>Ниже приведена реализация хеш-таблицы с открытой адресацией, то есть с линейным пробированием, включающая ленивое удаление. Чтобы пространство хеш-таблицы использовалось более полно, мы рассматриваем ее как кольцевой массив: когда обход выходит за конец массива, он возвращается к началу и продолжается.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"Хеш-таблица с открытой адресацией\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self.size = 0  # Число пар ключ-значение\n        self.capacity = 4  # Вместимость хеш-таблицы\n        self.load_thres = 2.0 / 3.0  # Порог коэффициента загрузки для запуска расширения\n        self.extend_ratio = 2  # Коэффициент расширения\n        self.buckets: list[Pair | None] = [None] * self.capacity  # Массив корзин\n        self.TOMBSTONE = Pair(-1, \"-1\")  # Удалить метку\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"Коэффициент загрузки\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"Найти индекс корзины, соответствующий key\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while self.buckets[index] is not None:\n            # Если встретился key, вернуть соответствующий индекс корзины\n            if self.buckets[index].key == key:\n                # Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # Вернуть индекс корзины после перемещения\n                return index  # Вернуть индекс корзины\n            # Записать первую встретившуюся метку удаления\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % self.capacity\n        # Если key не существует, вернуть индекс точки добавления\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"Операция поиска\"\"\"\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, вернуть соответствующее val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # Если пара ключ-значение не существует, вернуть None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"Операция добавления\"\"\"\n        # Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, перезаписать val и вернуть\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # Если пары ключ-значение нет, добавить ее\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        # Найти индекс корзины, соответствующий key\n        index = self.find_bucket(key)\n        # Если пара ключ-значение найдена, заменить ее меткой удаления\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"Расширить хеш-таблицу\"\"\"\n        # Временно сохранить исходную хеш-таблицу\n        buckets_tmp = self.buckets\n        # Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // Число пар ключ-значение\n    int capacity = 4;                     // Вместимость хеш-таблицы\n    const double loadThres = 2.0 / 3.0;     // Порог коэффициента загрузки для запуска расширения\n    const int extendRatio = 2;            // Коэффициент расширения\n    vector&lt;Pair *&gt; buckets;               // Массив корзин\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // Удалить метку\n\n  public:\n    /* Конструктор */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* Метод-деструктор */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != nullptr) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index]-&gt;key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // Если пары ключ-значение не существует, вернуть пустую строку\n        return \"\";\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private int size; // Число пар ключ-значение\n    private int capacity = 4; // Вместимость хеш-таблицы\n    private final double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n    private final int extendRatio = 2; // Коэффициент расширения\n    private Pair[] buckets; // Массив корзин\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // Удалить метку\n\n    /* Конструктор */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Хеш-функция */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index].key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    public String get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void put(int key, String val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    public void remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    private void extend() {\n        // Временно сохранить исходную хеш-таблицу\n        Pair[] bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    int size; // Число пар ключ-значение\n    int capacity = 4; // Вместимость хеш-таблицы\n    double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio = 2; // Коэффициент расширения\n    Pair[] buckets; // Массив корзин\n    Pair TOMBSTONE = new(-1, \"-1\"); // Удалить метку\n\n    /* Конструктор */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* Коэффициент загрузки */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index].key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        // Найти индекс корзины, соответствующий key\n        int index = FindBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    void Extend() {\n        // Временно сохранить исходную хеш-таблицу\n        Pair[] bucketsTmp = buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* Хеш-таблица с открытой адресацией */\ntype hashMapOpenAddressing struct {\n    size        int     // Число пар ключ-значение\n    capacity    int     // Вместимость хеш-таблицы\n    loadThres   float64 // Порог коэффициента загрузки для запуска расширения\n    extendRatio int     // Коэффициент расширения\n    buckets     []*pair // Массив корзин\n    TOMBSTONE   *pair   // Удалить метку\n}\n\n/* Конструктор */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* Хеш-функция */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // Вычислить хеш-значение по ключу\n}\n\n/* Коэффициент загрузки */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // Вычислить текущий коэффициент загрузки\n}\n\n/* Найти индекс корзины, соответствующий key */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // Получить начальный индекс\n    firstTombstone := -1     // Запомнить положение первого TOMBSTONE\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // Вернуть индекс корзины после перемещения\n            }\n            return index // Вернуть найденный индекс\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // Запомнить положение первой метки удаления\n        }\n        index = (index + 1) % h.capacity // Линейное пробирование: при выходе за хвост вернуться к началу\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* Операция поиска */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // Если пара ключ-значение найдена, вернуть соответствующее val\n    }\n    return \"\" // Если пара ключ-значение не существует, вернуть \"\"\n}\n\n/* Операция добавления */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // Когда коэффициент загрузки превышает порог, выполнить расширение\n    }\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // Если пары ключ-значение нет, добавить ее\n        h.size++\n    } else {\n        h.buckets[index].val = val // Если пара ключ-значение найдена, перезаписать val\n    }\n}\n\n/* Операция удаления */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // Найти индекс корзины, соответствующий key\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // Если пара ключ-значение найдена, заменить ее меткой удаления\n        h.size--\n    }\n}\n\n/* Расширить хеш-таблицу */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // Временно сохранить исходную хеш-таблицу\n    h.capacity *= h.extendRatio           // Обновить емкость\n    h.buckets = make([]*pair, h.capacity) // Инициализация новой хеш-таблицы после расширения\n    h.size = 0                            // Сбросить размер\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* Вывести хеш-таблицу */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    var size: Int // Число пар ключ-значение\n    var capacity: Int // Вместимость хеш-таблицы\n    var loadThres: Double // Порог коэффициента загрузки для запуска расширения\n    var extendRatio: Int // Коэффициент расширения\n    var buckets: [Pair?] // Массив корзин\n    var TOMBSTONE: Pair // Удалить метку\n\n    /* Конструктор */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* Хеш-функция */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while buckets[index] != nil {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if buckets[index]!.key == key {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Вернуть индекс корзины после перемещения\n                }\n                return index // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return nil\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        // Найти индекс корзины, соответствующий key\n        let index = findBucket(key: key)\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    func extend() {\n        // Временно сохранить исходную хеш-таблицу\n        let bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    #size; // Число пар ключ-значение\n    #capacity; // Вместимость хеш-таблицы\n    #loadThres; // Порог коэффициента загрузки для запуска расширения\n    #extendRatio; // Коэффициент расширения\n    #buckets; // Массив корзин\n    #TOMBSTONE; // Удалить метку\n\n    /* Конструктор */\n    constructor() {\n        this.#size = 0; // Число пар ключ-значение\n        this.#capacity = 4; // Вместимость хеш-таблицы\n        this.#loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n        this.#extendRatio = 2; // Коэффициент расширения\n        this.#buckets = Array(this.#capacity).fill(null); // Массив корзин\n        this.#TOMBSTONE = new Pair(-1, '-1'); // Удалить метку\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* Коэффициент загрузки */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (this.#buckets[index] !== null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (this.#buckets[index].key === key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % this.#capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key, val) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* Операция удаления */\n    remove(key) {\n        // Найти индекс корзины, соответствующий key\n        const index = this.#findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    #extend() {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.#buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private size: number; // Число пар ключ-значение\n    private capacity: number; // Вместимость хеш-таблицы\n    private loadThres: number; // Порог коэффициента загрузки для запуска расширения\n    private extendRatio: number; // Коэффициент расширения\n    private buckets: Array&lt;Pair | null&gt;; // Массив корзин\n    private TOMBSTONE: Pair; // Удалить метку\n\n    /* Конструктор */\n    constructor() {\n        this.size = 0; // Число пар ключ-значение\n        this.capacity = 4; // Вместимость хеш-таблицы\n        this.loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n        this.extendRatio = 2; // Коэффициент расширения\n        this.buckets = Array(this.capacity).fill(null); // Массив корзин\n        this.TOMBSTONE = new Pair(-1, '-1'); // Удалить метку\n    }\n\n    /* Хеш-функция */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* Коэффициент загрузки */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (this.buckets[index] !== null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (this.buckets[index]!.key === key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % this.capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* Операция поиска */\n    get(key: number): string | null {\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null;\n    }\n\n    /* Операция добавления */\n    put(key: number, val: string): void {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* Операция удаления */\n    remove(key: number): void {\n        // Найти индекс корзины, соответствующий key\n        const index = this.findBucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    private extend(): void {\n        // Временно сохранить исходную хеш-таблицу\n        const bucketsTmp = this.buckets;\n        // Инициализация новой хеш-таблицы после расширения\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n  late int _size; // Число пар ключ-значение\n  int _capacity = 4; // Вместимость хеш-таблицы\n  double _loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения\n  int _extendRatio = 2; // Коэффициент расширения\n  late List&lt;Pair?&gt; _buckets; // Массив корзин\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // Удалить метку\n\n  /* Конструктор */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* Хеш-функция */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* Коэффициент загрузки */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* Найти индекс корзины, соответствующий key */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while (_buckets[index] != null) {\n      // Если встретился key, вернуть соответствующий индекс корзины\n      if (_buckets[index]!.key == key) {\n        // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // Вернуть индекс корзины после перемещения\n        }\n        return index; // Вернуть индекс корзины\n      }\n      // Записать первую встретившуюся метку удаления\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // Вычислить индекс корзины; при выходе за конец вернуться к началу\n      index = (index + 1) % _capacity;\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, вернуть соответствующее val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // Если пары ключ-значение не существует, вернуть null\n    return null;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, перезаписать val и вернуть\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // Если пары ключ-значение нет, добавить ее\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(key);\n    // Если пара ключ-значение найдена, заменить ее меткой удаления\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* Расширить хеш-таблицу */\n  void extend() {\n    // Временно сохранить исходную хеш-таблицу\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // Инициализация новой хеш-таблицы после расширения\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* Хеш-таблица с открытой адресацией */\nstruct HashMapOpenAddressing {\n    size: usize,                // Число пар ключ-значение\n    capacity: usize,            // Вместимость хеш-таблицы\n    load_thres: f64,            // Порог коэффициента загрузки для запуска расширения\n    extend_ratio: usize,        // Коэффициент расширения\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // Массив корзин\n    TOMBSTONE: Option&lt;Pair&gt;,    // Удалить метку\n}\n\nimpl HashMapOpenAddressing {\n    /* Конструктор */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* Коэффициент загрузки */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while self.buckets[index].is_some() {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение в этот индекс\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // Вернуть индекс корзины после перемещения\n                }\n                return index; // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % self.capacity;\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* Операция поиска */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        None\n    }\n\n    /* Операция добавления */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // Если пары ключ-значение нет, добавить ее\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* Операция удаления */\n    fn remove(&amp;mut self, key: i32) {\n        // Найти индекс корзины, соответствующий key\n        let index = self.find_bucket(key);\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fn extend(&amp;mut self) {\n        // Временно сохранить исходную хеш-таблицу\n        let buckets_tmp = self.buckets.clone();\n        // Инициализация новой хеш-таблицы после расширения\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* Вывести хеш-таблицу */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* Хеш-таблица с открытой адресацией */\ntypedef struct {\n    int size;         // Число пар ключ-значение\n    int capacity;     // Вместимость хеш-таблицы\n    double loadThres; // Порог коэффициента загрузки для запуска расширения\n    int extendRatio;  // Коэффициент расширения\n    Pair **buckets;   // Массив корзин\n    Pair *TOMBSTONE;  // Удалить метку\n} HashMapOpenAddressing;\n\n/* Конструктор */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* Деструктор */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* Хеш-функция */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* Коэффициент загрузки */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* Найти индекс корзины, соответствующий key */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // Если встретился key, вернуть соответствующий индекс корзины\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // Вернуть индекс корзины после перемещения\n            }\n            return index; // Вернуть индекс корзины\n        }\n        // Записать первую встретившуюся метку удаления\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // Вычислить индекс корзины; при выходе за конец вернуться к началу\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // Если key не существует, вернуть индекс точки добавления\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* Операция поиска */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, вернуть соответствующее val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // Если пары ключ-значение не существует, вернуть пустую строку\n    return \"\";\n}\n\n/* Операция добавления */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // Когда коэффициент загрузки превышает порог, выполнить расширение\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, перезаписать val и вернуть\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // Если пары ключ-значение нет, добавить ее\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* Операция удаления */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // Найти индекс корзины, соответствующий key\n    int index = findBucket(hashMap, key);\n    // Если пара ключ-значение найдена, заменить ее меткой удаления\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* Расширить хеш-таблицу */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // Временно сохранить исходную хеш-таблицу\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // Инициализация новой хеш-таблицы после расширения\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* Вывести хеш-таблицу */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* Хеш-таблица с открытой адресацией */\nclass HashMapOpenAddressing {\n    private var size: Int               // Число пар ключ-значение\n    private var capacity: Int           // Вместимость хеш-таблицы\n    private val loadThres: Double       // Порог коэффициента загрузки для запуска расширения\n    private val extendRatio: Int        // Коэффициент расширения\n    private var buckets: Array&lt;Pair?&gt;   // Массив корзин\n    private val TOMBSTONE: Pair         // Удалить метку\n\n    /* Конструктор */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* Коэффициент загрузки */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* Найти индекс корзины, соответствующий key */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n        while (buckets[index] != null) {\n            // Если встретился key, вернуть соответствующий индекс корзины\n            if (buckets[index]?.key == key) {\n                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // Вернуть индекс корзины после перемещения\n                }\n                return index // Вернуть индекс корзины\n            }\n            // Записать первую встретившуюся метку удаления\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // Вычислить индекс корзины; при выходе за конец вернуться к началу\n            index = (index + 1) % capacity\n        }\n        // Если key не существует, вернуть индекс точки добавления\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, вернуть соответствующее val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // Если пары ключ-значение не существует, вернуть null\n        return null\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        // Когда коэффициент загрузки превышает порог, выполнить расширение\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, перезаписать val и вернуть\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // Если пары ключ-значение нет, добавить ее\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        // Найти индекс корзины, соответствующий key\n        val index = findBucket(key)\n        // Если пара ключ-значение найдена, заменить ее меткой удаления\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* Расширить хеш-таблицу */\n    fun extend() {\n        // Временно сохранить исходную хеш-таблицу\n        val bucketsTmp = buckets\n        // Инициализация новой хеш-таблицы после расширения\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // Перенести пары ключ-значение из исходной хеш-таблицы в новую\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### Хеш-таблица с открытой адресацией ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # Удалить метку\n\n  ### Конструктор ###\n  def initialize\n    @size = 0 # Число пар ключ-значение\n    @capacity = 4 # Вместимость хеш-таблицы\n    @load_thres = 2.0 / 3.0 # Порог коэффициента загрузки для запуска расширения\n    @extend_ratio = 2 # Коэффициент расширения\n    @buckets = Array.new(@capacity) # Массив корзин\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### Коэффициент загрузки ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### Найти индекс корзины, соответствующий key ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # Выполнять линейное пробирование и завершить при встрече с пустой корзиной\n    while !@buckets[index].nil?\n      # Если встретился key, вернуть соответствующий индекс корзины\n      if @buckets[index].key == key\n        # Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # Вернуть индекс корзины после перемещения\n        end\n        return index # Вернуть индекс корзины\n      end\n      # Записать первую встретившуюся метку удаления\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # Вычислить индекс корзины; при выходе за конец вернуться к началу\n      index = (index + 1) % @capacity\n    end\n    # Если key не существует, вернуть индекс точки добавления\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, вернуть соответствующее val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # Если пара ключ-значение не существует, вернуть nil\n    nil\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    # Когда коэффициент загрузки превышает порог, выполнить расширение\n    extend if load_factor &gt; @load_thres\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, перезаписать val и вернуть\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # Если пары ключ-значение нет, добавить ее\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    # Найти индекс корзины, соответствующий key\n    index = find_bucket(key)\n    # Если пара ключ-значение найдена, заменить ее меткой удаления\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### Расширение хеш-таблицы ###\n  def extend\n    # Временно сохранить исходную хеш-таблицу\n    buckets_tmp = @buckets\n    # Инициализация новой хеш-таблицы после расширения\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # Перенести пары ключ-значение из исходной хеш-таблицы в новую\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   Квадратичное пробирование","text":"<p>Квадратичное пробирование похоже на линейное пробирование и тоже является одной из распространенных стратегий открытой адресации. При возникновении конфликта оно не пропускает фиксированное число шагов, а переходит на расстояние, равное \"квадрату числа попыток\", то есть на \\(1, 4, 9, \\dots\\) шагов.</p> <p>Квадратичное пробирование имеет следующие основные преимущества.</p> <ul> <li>Квадратичное пробирование пытается смягчить эффект кластеризации линейного пробирования, так как пропускает расстояния, равные квадрату номера попытки.</li> <li>Квадратичное пробирование перепрыгивает на более дальние позиции в поисках свободного места, что помогает распределять данные более равномерно.</li> </ul> <p>Однако квадратичное пробирование не является идеальным.</p> <ul> <li>Кластеризация все равно существует: некоторые позиции по-прежнему занимают чаще других.</li> <li>Из-за быстрого роста квадрата квадратичное пробирование может не охватить всю хеш-таблицу, а это означает, что даже при наличии пустых бакетов оно может так до них и не добраться.</li> </ul>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   Повторное хеширование","text":"<p>Как видно из названия, метод повторного хеширования использует для пробирования несколько хеш-функций \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) .</p> <ul> <li>Вставка элемента: если хеш-функция \\(f_1(x)\\) вызывает конфликт, то пробуем \\(f_2(x)\\) , и так далее, пока не будет найдено пустое место для вставки элемента.</li> <li>Поиск элемента: поиск идет в том же порядке хеш-функций, пока не будет найден целевой элемент; если встречается пустая позиция или уже были опробованы все хеш-функции, это означает, что элемента в хеш-таблице нет, и возвращается <code>None</code> .</li> </ul> <p>По сравнению с линейным пробированием метод повторного хеширования меньше подвержен кластеризации, но несколько хеш-функций приносят дополнительные вычислительные затраты.</p> <p>Tip</p> <p>Обрати внимание: у хеш-таблиц с открытой адресацией (линейное пробирование, квадратичное пробирование и повторное хеширование) есть общая проблема: в них нельзя напрямую удалять элементы.</p>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   Выбор в языках программирования","text":"<p>Разные языки программирования используют разные стратегии реализации хеш-таблиц. Ниже приведено несколько примеров.</p> <ul> <li>Python использует открытую адресацию. В словаре <code>dict</code> для пробирования применяются псевдослучайные числа.</li> <li>Java использует метод цепочек. Начиная с JDK 1.8, когда длина массива внутри <code>HashMap</code> достигает 64, а длина списка достигает 8, этот список преобразуется в красно-черное дерево для повышения производительности поиска.</li> <li>Go использует метод цепочек. В Go установлено, что каждый бакет может хранить не более 8 пар ключ-значение; при переполнении подключается overflow-бакет, а когда таких бакетов становится слишком много, выполняется специальное расширение того же масштаба, чтобы сохранить производительность.</li> </ul>","path":["Глава 6. Хеш-таблицы","6.2 &nbsp; Хеш-коллизии"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   Хеш-таблица","text":"<p>Хеш-таблица (hash table), также называемая таблицей рассеяния, реализует эффективный поиск элементов за счет установления соответствия между ключом <code>key</code> и значением <code>value</code> . Иначе говоря, если передать в хеш-таблицу ключ <code>key</code> , то можно за \\(O(1)\\) времени получить соответствующее значение <code>value</code> .</p> <p>Как показано на рисунке 6-1, пусть есть \\(n\\) студентов, и у каждого из них есть два поля данных: имя и номер студенческого билета. Если мы хотим реализовать запрос вида \"ввести номер студенческого билета и вернуть соответствующее имя\", то для этого можно использовать показанную ниже хеш-таблицу.</p> <p></p> <p> Рисунок 6-1   Абстрактное представление хеш-таблицы </p> <p>Помимо хеш-таблицы, функцией поиска также обладают массив и связный список. Сравнение их эффективности приведено в таблице 6-1.</p> <ul> <li>Добавление элемента: нужно лишь добавить элемент в конец массива (или списка), что занимает \\(O(1)\\) времени.</li> <li>Поиск элемента: так как массив (или список) неупорядочен, приходится обходить все элементы, что занимает \\(O(n)\\) времени.</li> <li>Удаление элемента: сначала нужно найти элемент, затем удалить его из массива (или списка), что занимает \\(O(n)\\) времени.</li> </ul> <p> Таблица 6-1   Сравнение эффективности поиска элементов </p> Массив Связный список Хеш-таблица Поиск элемента \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Добавление элемента \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>Нетрудно заметить, что операции поиска, добавления и удаления в хеш-таблице имеют временную сложность \\(O(1)\\) , то есть выполняются очень эффективно.</p>","path":["Глава 6. Хеш-таблицы","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#611-","level":2,"title":"6.1.1   Основные операции с хеш-таблицей","text":"<p>К базовым операциям хеш-таблицы относятся инициализация, поиск, добавление пар ключ-значение и удаление пар ключ-значение. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Инициализация хеш-таблицы\nhmap: dict = {}\n\n# Операция добавления\n# Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n# Операция поиска\n# Передать в хеш-таблицу ключ key и получить значение value\nname: str = hmap[15937]\n\n# Операция удаления\n# Удалить пару ключ-значение (key, value) из хеш-таблицы\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* Инициализация хеш-таблицы */\nunordered_map&lt;int, string&gt; map;\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\";\nmap[15937] = \"Сяо Ло\";\nmap[16750] = \"Сяо Суань\";\nmap[13276] = \"Сяо Фа\";\nmap[10583] = \"Сяо Я\";\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nstring name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* Инициализация хеш-таблицы */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.put(12836, \"Сяо Ха\");\nmap.put(15937, \"Сяо Ло\");\nmap.put(16750, \"Сяо Суань\");\nmap.put(13276, \"Сяо Фа\");\nmap.put(10583, \"Сяо Я\");\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nString name = map.get(15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* Инициализация хеш-таблицы */\nDictionary&lt;int, string&gt; map = new() {\n    /* Операция добавления */\n    // Добавить пару ключ-значение (key, value) в хеш-таблицу\n    { 12836, \"Сяо Ха\" },\n    { 15937, \"Сяо Ло\" },\n    { 16750, \"Сяо Суань\" },\n    { 13276, \"Сяо Фа\" },\n    { 10583, \"Сяо Я\" }\n};\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nstring name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* Инициализация хеш-таблицы */\nhmap := make(map[int]string)\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nname := hmap[15937]\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* Инициализация хеш-таблицы */\nvar map: [Int: String] = [:]\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\"\nmap[15937] = \"Сяо Ло\"\nmap[16750] = \"Сяо Суань\"\nmap[13276] = \"Сяо Фа\"\nmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map[15937]!\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* Инициализация хеш-таблицы */\nconst map = new Map();\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.set(12836, 'Сяо Ха');\nmap.set(15937, 'Сяо Ло');\nmap.set(16750, 'Сяо Суань');\nmap.set(13276, 'Сяо Фа');\nmap.set(10583, 'Сяо Я');\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map.get(15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* Инициализация хеш-таблицы */\nconst map = new Map&lt;number, string&gt;();\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.set(12836, 'Сяо Ха');\nmap.set(15937, 'Сяо Ло');\nmap.set(16750, 'Сяо Суань');\nmap.set(13276, 'Сяо Фа');\nmap.set(10583, 'Сяо Я');\nconsole.info('\\nПосле добавления хеш-таблица имеет вид\\nKey -&gt; Value');\nconsole.info(map);\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet name = map.get(15937);\nconsole.info('\\nПо номеру 15937 найдено имя ' + name);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.delete(10583);\nconsole.info('\\nПосле удаления 10583 хеш-таблица имеет вид\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* Инициализация хеш-таблицы */\nMap&lt;int, String&gt; map = {};\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\";\nmap[15937] = \"Сяо Ло\";\nmap[16750] = \"Сяо Суань\";\nmap[13276] = \"Сяо Фа\";\nmap[10583] = \"Сяо Я\";\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nString name = map[15937];\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* Инициализация хеш-таблицы */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap.insert(12836, \"Сяо Ха\".to_string());\nmap.insert(15937, \"Сяо Ло\".to_string());\nmap.insert(16750, \"Сяо Суань\".to_string());\nmap.insert(13279, \"Сяо Фа\".to_string());\nmap.insert(10583, \"Сяо Я\".to_string());\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// В C нет встроенной хеш-таблицы\n</code></pre> hash_map.kt<pre><code>/* Инициализация хеш-таблицы */\nval map = HashMap&lt;Int,String&gt;()\n\n/* Операция добавления */\n// Добавить пару ключ-значение (key, value) в хеш-таблицу\nmap[12836] = \"Сяо Ха\"\nmap[15937] = \"Сяо Ло\"\nmap[16750] = \"Сяо Суань\"\nmap[13276] = \"Сяо Фа\"\nmap[10583] = \"Сяо Я\"\n\n/* Операция поиска */\n// Передать в хеш-таблицу ключ key и получить значение value\nval name = map[15937]\n\n/* Операция удаления */\n// Удалить пару ключ-значение (key, value) из хеш-таблицы\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># Инициализация хеш-таблицы\nhmap = {}\n\n# Операция добавления\n# Добавить пару ключ-значение (key, value) в хеш-таблицу\nhmap[12836] = \"Сяо Ха\"\nhmap[15937] = \"Сяо Ло\"\nhmap[16750] = \"Сяо Суань\"\nhmap[13276] = \"Сяо Фа\"\nhmap[10583] = \"Сяо Я\"\n\n# Операция поиска\n# Передать в хеш-таблицу ключ key и получить значение value\nname = hmap[15937]\n\n# Операция удаления\n# Удалить пару ключ-значение (key, value) из хеш-таблицы\nhmap.delete(10583)\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%9B%D0%BE%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A1%D1%83%D0%B0%D0%BD%D1%8C%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A4%D0%B0%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%D0%A3%D1%82%D0%B5%D0%BD%D0%BE%D0%BA%22%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%82%D1%8C%20%D0%BA%D0%BB%D1%8E%D1%87%20key%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%B8%20%D0%BF%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D0%B8%D0%B7%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap.pop%2810583%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Существует три распространенных способа обхода хеш-таблицы: обход пар ключ-значение, обход ключей и обход значений. Примеры кода приведены ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># Обход хеш-таблицы\n# Обход пар ключ-значение key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# Обход только ключей key\nfor key in hmap.keys():\n    print(key)\n# Обход только значений value\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// Обход key-&gt;value с помощью итератора\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// Обход только ключей key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Обход только значений value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// Обход только ключей key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Обход только значений value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// Обход только ключей key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Обход только значений value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// Обход только ключей Key\nfor key in map.keys {\n    print(key)\n}\n// Обход только значений Value\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* Обход хеш-таблицы */\nconsole.info('\\nОбход пар ключ-значение Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nОбход только ключей Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nОбход только значений Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* Обход хеш-таблицы */\nconsole.info('\\nОбход пар ключ-значение Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\nОбход только ключей Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nОбход только значений Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// Обход только ключей Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// Обход только значений Value\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// Обход только ключей Key\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// Обход только значений Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// В C нет встроенной хеш-таблицы\n</code></pre> hash_map.kt<pre><code>/* Обход хеш-таблицы */\n// Обход пар ключ-значение key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// Обход только ключей key\nfor (key in map.keys) {\n    println(key)\n}\n// Обход только значений value\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># Обход хеш-таблицы\n# Обход пар ключ-значение key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# Обход только ключей key\nhmap.keys.each { |key| puts key }\n\n# Обход только значений value\nhmap.values.each { |val| puts val }\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%20%D0%BF%D0%B0%D1%80%D1%83%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%28key%2C%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A5%D0%B0%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%9B%D0%BE%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A1%D1%83%D0%B0%D0%BD%D1%8C%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%D0%A1%D1%8F%D0%BE%20%D0%A4%D0%B0%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%D0%A3%D1%82%D0%B5%D0%BD%D0%BE%D0%BA%22%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%B5%D1%80%D0%B5%D0%B1%D1%80%D0%B0%D1%82%D1%8C%20%D1%85%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%83%0A%20%20%20%20%23%20%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%BF%D0%B0%D1%80%D0%B0%20%D0%BA%D0%BB%D1%8E%D1%87-%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20key-%3Evalue%0A%20%20%20%20for%20key%2C%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%2C%20%22-%3E%22%2C%20value%29%0A%20%20%20%20%23%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%BA%D0%BB%D1%8E%D1%87%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%D0%BE%D1%82%D0%B4%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&amp;cumulative=false&amp;curInstr=8&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 6. Хеш-таблицы","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#612-","level":2,"title":"6.1.2   Простая реализация хеш-таблицы","text":"<p>Сначала рассмотрим самый простой случай: реализуем хеш-таблицу только с помощью одного массива. В хеш-таблице каждую пустую ячейку массива мы называем бакетом (bucket), и каждый бакет может хранить одну пару ключ-значение. Следовательно, операция поиска сводится к тому, чтобы найти бакет, соответствующий <code>key</code> , и получить из него <code>value</code> .</p> <p>Но как определить бакет, соответствующий заданному <code>key</code> ? Это делается с помощью хеш-функции (hash function). Назначение хеш-функции - отображать большое входное пространство в меньшее выходное пространство. В хеш-таблице входным пространством являются все <code>key</code> , а выходным - все бакеты, то есть индексы массива. Иначе говоря, передав <code>key</code> на вход, мы можем с помощью хеш-функции получить позицию хранения соответствующей пары ключ-значение в массиве.</p> <p>Процесс вычисления хеш-функции для одного <code>key</code> включает два шага.</p> <ol> <li>Сначала с помощью некоторого хеш-алгоритма <code>hash()</code> вычисляется хеш-значение.</li> <li>Затем хеш-значение берется по модулю числа бакетов (длины массива) <code>capacity</code> , чтобы получить бакет (индекс массива) <code>index</code> , соответствующий этому <code>key</code> .</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>После этого можно использовать <code>index</code> для доступа к соответствующему бакету в хеш-таблице и получения <code>value</code> .</p> <p>Пусть длина массива <code>capacity = 100</code> , а хеш-алгоритм <code>hash(key) = key</code> . Тогда легко получить хеш-функцию <code>key % 100</code> . На рисунке 6-2 на примере <code>key</code> \"номер студенческого билета\" и <code>value</code> \"имя\" показан принцип работы хеш-функции.</p> <p></p> <p> Рисунок 6-2   Принцип работы хеш-функции </p> <p>Ниже приведен код простой реализации хеш-таблицы. В нем мы инкапсулируем <code>key</code> и <code>value</code> в класс <code>Pair</code> , чтобы представить пару ключ-значение.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"Пара ключ-значение\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"Хеш-таблица на основе массива\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        # Инициализировать массив, содержащий 100 корзин\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"Хеш-функция\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"Операция поиска\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"Операции добавления и обновления\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"Операция удаления\"\"\"\n        index: int = self.hash_func(key)\n        # Присвоить None, что означает удаление\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"Получить все пары ключ-значение\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"Получить все ключи\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"Получить все значения\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"Вывести хеш-таблицу\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* Пара ключ-значение */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // Освободить память\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* Хеш-функция */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* Операция добавления */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Операция удаления */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // Освободить память и присвоить nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* Получить все пары ключ-значение */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* Пара ключ-значение */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* Хеш-функция */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* Операция удаления */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // Присвоить null, что означает удаление\n        buckets.set(index, null);\n    }\n\n    /* Получить все пары ключ-значение */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* Пара ключ-значение int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* Хеш-функция */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* Операция поиска */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* Операция удаления */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // Присвоить null, что означает удаление\n        buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* Получить все ключи */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* Получить все значения */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* Вывести хеш-таблицу */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* Пара ключ-значение */\ntype pair struct {\n    key int\n    val string\n}\n\n/* Хеш-таблица на основе массива */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* Инициализация хеш-таблицы */\nfunc newArrayHashMap() *arrayHashMap {\n    // Инициализировать массив, содержащий 100 корзин\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* Хеш-функция */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* Операция поиска */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* Операция добавления */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* Операция удаления */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // Присвоить nil, что означает удаление\n    a.buckets[index] = nil\n}\n\n/* Получить все ключи */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* Получить все ключи */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* Получить все значения */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* Вывести хеш-таблицу */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* Пара ключ-значение */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // Инициализировать массив, содержащий 100 корзин\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* Хеш-функция */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* Операция поиска */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* Операция добавления */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* Операция удаления */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // Присвоить nil, что означает удаление\n        buckets[index] = nil\n    }\n\n    /* Получить все пары ключ-значение */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* Получить все ключи */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* Получить все значения */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* Вывести хеш-таблицу */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* Пара ключ-значение Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // Инициализировать массив, содержащий 100 корзин\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* Хеш-функция */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* Операция поиска */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* Операция удаления */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // Присвоить null, что означает удаление\n        this.#buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все ключи */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все значения */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Вывести хеш-таблицу */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* Пара ключ-значение Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // Инициализировать массив, содержащий 100 корзин\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* Хеш-функция */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* Операция поиска */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* Операция добавления */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* Операция удаления */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // Присвоить null, что означает удаление\n        this.buckets[index] = null;\n    }\n\n    /* Получить все пары ключ-значение */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все ключи */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* Получить все значения */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* Вывести хеш-таблицу */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* Пара ключ-значение */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // Инициализировать массив, содержащий 100 корзин\n    _buckets = List.filled(100, null);\n  }\n\n  /* Хеш-функция */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* Операция поиска */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* Операция добавления */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* Операция удаления */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* Получить все пары ключ-значение */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* Получить все ключи */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* Получить все значения */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* Вывести хеш-таблицу */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* Пара ключ-значение */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* Хеш-таблица на основе массива */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // Инициализировать массив, содержащий 100 корзин\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* Хеш-функция */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* Операция поиска */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* Операция добавления */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* Операция удаления */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // Присвоить None, что означает удаление\n        self.buckets[index] = None;\n    }\n\n    /* Получить все пары ключ-значение */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* Получить все ключи */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* Получить все значения */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* Вывести хеш-таблицу */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* Пара ключ-значение int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* Хеш-таблица на основе массива */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* Конструктор */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* Деструктор */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* Операция добавления */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* Операция удаления */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* Получить все пары ключ-значение */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* Получить все ключи */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* Получить все значения */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* Подсчитать число действительных пар ключ-значение */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* Вывести хеш-таблицу */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* Пара ключ-значение */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* Хеш-таблица на основе массива */\nclass ArrayHashMap {\n    // Инициализировать массив, содержащий 100 корзин\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* Хеш-функция */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* Операция поиска */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* Операция добавления */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* Операция удаления */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // Присвоить null, что означает удаление\n        buckets[index] = null\n    }\n\n    /* Получить все пары ключ-значение */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* Получить все ключи */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* Получить все значения */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* Вывести хеш-таблицу */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### Пара ключ-значение ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### Хеш-таблица на основе массива ###\nclass ArrayHashMap\n  ### Конструктор ###\n  def initialize\n    # Инициализировать массив, содержащий 100 корзин\n    @buckets = Array.new(100)\n  end\n\n  ### Хеш-функция ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### Операция поиска ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### Операция добавления ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### Операция удаления ###\n  def remove(key)\n    index = hash_func(key)\n    # Присвоить nil, что означает удаление\n    @buckets[index] = nil\n  end\n\n  ### Получить все пары ключ-значение ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### Получить все ключи ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### Получить все значения ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### Вывести хеш-таблицу ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 6. Хеш-таблицы","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/hash_map/#613-","level":2,"title":"6.1.3   Хеш-коллизии и расширение","text":"<p>По сути, хеш-функция отображает входное пространство, состоящее из всех <code>key</code> , в выходное пространство, состоящее из всех индексов массива, а входное пространство обычно значительно больше выходного. Поэтому теоретически неизбежно существование ситуации \"несколько входов соответствуют одному выходу\".</p> <p>Для хеш-функции из приведенного выше примера, если последние две цифры <code>key</code> совпадают, то совпадает и результат хеш-функции. Например, если искать студентов с номерами 12836 и 20336, то получим:</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>Как показано на рисунке 6-3, два номера указывают на одно и то же имя, что, очевидно, неверно. Такую ситуацию, когда нескольким входам соответствует один и тот же выход, называют хеш-коллизией (hash collision).</p> <p></p> <p> Рисунок 6-3   Пример хеш-коллизии </p> <p>Легко понять, что чем больше емкость хеш-таблицы \\(n\\) , тем ниже вероятность того, что несколько <code>key</code> попадут в один и тот же бакет, а значит, тем меньше коллизий. Поэтому мы можем уменьшать число хеш-коллизий путем расширения хеш-таблицы.</p> <p>Как показано на рисунке 6-4, до расширения пары ключ-значение <code>(136, A)</code> и <code>(236, D)</code> конфликтовали, а после расширения коллизия исчезла.</p> <p></p> <p> Рисунок 6-4   Расширение хеш-таблицы </p> <p>Подобно расширению массива, расширение хеш-таблицы требует перенести все пары ключ-значение из старой таблицы в новую, а это очень затратно по времени; кроме того, поскольку емкость хеш-таблицы <code>capacity</code> изменилась, нам приходится с помощью хеш-функции заново вычислять позиции хранения всех пар ключ-значение, что дополнительно увеличивает вычислительные расходы процесса расширения. Поэтому языки программирования обычно заранее резервируют достаточно большую емкость хеш-таблицы, чтобы избежать частых расширений.</p> <p>Коэффициент загрузки (load factor) - важное понятие хеш-таблицы. Он определяется как отношение числа элементов в хеш-таблице к числу бакетов и используется для оценки степени серьезности хеш-коллизий, а также часто служит условием срабатывания расширения хеш-таблицы. Например, в Java, когда коэффициент загрузки превышает \\(0.75\\) , система расширяет хеш-таблицу до \\(2\\) раз от исходной емкости.</p>","path":["Глава 6. Хеш-таблицы","6.1 &nbsp; Хеш-таблица"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   Резюме","text":"","path":["Глава 6. Хеш-таблицы","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Передав <code>key</code> , мы можем получить <code>value</code> из хеш-таблицы за \\(O(1)\\) времени, поэтому она очень эффективна.</li> <li>К типичным операциям хеш-таблицы относятся поиск, добавление пары ключ-значение, удаление пары ключ-значение и обход хеш-таблицы.</li> <li>Хеш-функция отображает <code>key</code> в индекс массива, после чего можно обратиться к соответствующему бакету и получить <code>value</code> .</li> <li>Два разных <code>key</code> после хеш-функции могут дать один и тот же индекс массива, что приводит к ошибочному результату поиска; это явление называется хеш-коллизией.</li> <li>Чем больше емкость хеш-таблицы, тем ниже вероятность хеш-коллизий. Поэтому хеш-коллизии можно смягчать путем расширения хеш-таблицы. Как и у массива, операция расширения у хеш-таблицы очень затратна.</li> <li>Коэффициент загрузки определяется как отношение числа элементов в хеш-таблице к числу бакетов, отражает степень серьезности хеш-коллизий и часто используется как условие запуска расширения хеш-таблицы.</li> <li>Метод цепочек превращает одиночный элемент в связный список и хранит все конфликтующие элементы в одном списке. Однако слишком длинный список снижает эффективность поиска, поэтому его можно дополнительно преобразовать в красно-черное дерево.</li> <li>Открытая адресация обрабатывает хеш-коллизии за счет многократного пробирования. Линейное пробирование использует фиксированный шаг, его недостатки - невозможность прямого удаления элементов и склонность к кластеризации. Повторное хеширование использует несколько хеш-функций и по сравнению с линейным пробированием меньше подвержено кластеризации, но требует больше вычислений.</li> <li>Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, <code>HashMap</code> в Java использует метод цепочек, а <code>Dict</code> в Python - открытую адресацию.</li> <li>Для хеш-таблицы желательно, чтобы хеш-алгоритм был детерминированным, быстрым и обеспечивал равномерное распределение. В криптографии от него дополнительно требуют устойчивости к коллизиям и эффекта лавины.</li> <li>В качестве модуля хеш-алгоритмы обычно используют большое простое число, чтобы максимально обеспечить равномерность распределения хеш-значений и снизить число хеш-коллизий.</li> <li>К распространенным хеш-алгоритмам относятся MD5, SHA-1, SHA-2 и SHA-3. MD5 часто применяли для проверки целостности файлов, а SHA-2 широко используется в протоколах и приложениях, связанных с безопасностью.</li> <li>Языки программирования обычно предоставляют для типов данных встроенные хеш-алгоритмы, чтобы вычислять индексы бакетов в хеш-таблице. Как правило, хешируемыми могут быть только неизменяемые объекты.</li> </ul>","path":["Глава 6. Хеш-таблицы","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: В каких случаях временная сложность хеш-таблицы становится \\(O(n)\\) ?</p> <p>Когда хеш-коллизии становятся достаточно серьезными, временная сложность хеш-таблицы деградирует до \\(O(n)\\) . Если хеш-функция спроектирована хорошо, емкость выбрана разумно, а конфликты распределены достаточно равномерно, то временная сложность обычно считается \\(O(1)\\) . При использовании встроенной хеш-таблицы языка программирования мы, как правило, и принимаем ее за \\(O(1)\\) .</p> <p>Q: Почему бы не использовать хеш-функцию \\(f(x) = x\\) ? Тогда ведь коллизий не будет.</p> <p>При хеш-функции \\(f(x) = x\\) каждому элементу соответствует уникальный индекс бакета, и такая структура становится эквивалентна массиву. Однако входное пространство обычно намного больше выходного пространства (длины массива), поэтому последним шагом хеш-функции обычно выступает взятие по модулю длины массива. Иначе говоря, цель хеш-таблицы состоит в том, чтобы отобразить большее пространство состояний в меньшее пространство и при этом обеспечить \\(O(1)\\) поиска.</p> <p>Q: В основе хеш-таблицы лежат массив, связный список и двоичное дерево. Почему же она может быть быстрее них?</p> <p>Во-первых, у хеш-таблицы повышается временная эффективность, но снижается пространственная эффективность. Значительная часть ее памяти остается неиспользованной.</p> <p>Во-вторых, она быстрее только в определенных сценариях. Если одну и ту же задачу можно реализовать на массиве или связном списке с той же асимптотикой, то часто такая реализация окажется быстрее, чем хеш-таблица. Причина в том, что вычисление хеш-функции само по себе стоит времени, то есть константа в сложности получается выше.</p> <p>Наконец, временная сложность хеш-таблицы тоже может деградировать. Например, при методе цепочек мы все равно выполняем поиск в связном списке или красно-черном дереве, поэтому риск деградации до \\(O(n)\\) сохраняется.</p> <p>Q: Есть ли у повторного хеширования недостаток \"нельзя напрямую удалять элементы\"? Можно ли повторно использовать место, помеченное как удаленное?</p> <p>Повторное хеширование - это разновидность открытой адресации, а у всех методов открытой адресации есть недостаток: элементы нельзя удалять напрямую, поэтому приходится использовать метку удаления. Пространство, помеченное как удаленное, можно использовать повторно. Когда новый элемент вставляется в хеш-таблицу и в процессе пробирования попадает на такую отмеченную позицию, эта позиция может быть занята новым элементом. Такой подход сохраняет последовательность пробирования и одновременно поддерживает приемлемую эффективность использования памяти.</p> <p>Q: Почему при линейном пробировании во время поиска элемента вообще возникает хеш-коллизия?</p> <p>Во время поиска мы через хеш-функцию находим соответствующий бакет и соответствующую пару ключ-значение, но видим, что <code>key</code> не совпадает, а это и означает наличие хеш-коллизии. Поэтому метод линейного пробирования в соответствии с заранее заданным шагом последовательно движется дальше, пока не найдет правильную пару ключ-значение или не убедится, что поиск завершился неудачей.</p> <p>Q: Почему расширение хеш-таблицы помогает смягчать хеш-коллизии?</p> <p>Последний шаг хеш-функции обычно состоит во взятии по модулю длины массива \\(n\\) , чтобы результат попадал в диапазон индексов массива; после расширения длина массива \\(n\\) меняется, а значит, может измениться и индекс, соответствующий данному <code>key</code> . Несколько <code>key</code> , которые раньше попадали в один бакет, после расширения могут распределиться по нескольким бакетам, и тем самым хеш-коллизии будут ослаблены.</p> <p>Q: Если нам нужен быстрый доступ, почему бы просто не использовать массив?</p> <p>Когда <code>key</code> данных - это непрерывные целые числа из маленького диапазона, действительно можно напрямую использовать массив: это просто и эффективно. Но если <code>key</code> имеют другой тип данных (например, строки), тогда нужен хеш-алгоритм, который отобразит <code>key</code> в индекс массива, а хранение элементов будет выполняться через массив бакетов. Такая структура и называется хеш-таблицей.</p>","path":["Глава 6. Хеш-таблицы","6.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"Глава 8.   Куча","text":"<p>Abstract</p> <p>Куча - это полное двоичное дерево, удовлетворяющее определенным условиям.</p> <p>В максимальной и минимальной куче элемент на вершине всегда обладает самым выраженным приоритетом.</p>","path":["Глава 8. Куча","Глава 8. &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>8.1   Куча</li> <li>8.2   Построение кучи</li> <li>8.3   Задача Top-k</li> <li>8.4   Резюме</li> </ul>","path":["Глава 8. Куча","Глава 8. &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   Построение кучи","text":"<p>В некоторых случаях требуется построить кучу, используя сразу все элементы списка. Этот процесс называется построением кучи.</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   Реализация через операцию добавления в кучу","text":"<p>Сначала мы создаем пустую кучу, затем обходим список и для каждого элемента по очереди выполняем операцию добавления в кучу: сначала помещаем элемент в хвост кучи, а затем выполняем для него упорядочивание снизу вверх.</p> <p>Каждый раз, когда элемент добавляется в кучу, ее длина увеличивается на единицу. Поскольку узлы последовательно добавляются в двоичное дерево сверху вниз, куча строится сверху вниз.</p> <p>Пусть число элементов равно \\(n\\) ; так как каждая операция добавления требует \\(O(\\log{n})\\) времени, временная сложность такого построения кучи составляет \\(O(n \\log n)\\) .</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   Реализация через обход и упорядочивание","text":"<p>На самом деле можно реализовать и более эффективный способ построения кучи, который состоит из двух шагов.</p> <ol> <li>Без изменений добавить все элементы списка в кучу; в этот момент свойства кучи еще не выполняются.</li> <li>Обойти кучу в обратном порядке, то есть в порядке, обратном обходу по уровням, и по очереди выполнить упорядочивание сверху вниз для каждого нелистового узла.</li> </ol> <p>После того как некоторый узел был упорядочен, поддерево с этим узлом в качестве корня становится корректной подкучей. А поскольку обход выполняется в обратном порядке, куча строится снизу вверх.</p> <p>Причина выбора обратного обхода в том, что он гарантирует: поддеревья ниже текущего узла уже являются корректными подкучами, а значит, упорядочивание текущего узла действительно будет эффективным.</p> <p>Стоит отметить, что листовые узлы не имеют дочерних узлов, поэтому они естественным образом являются корректными подкучами и не требуют упорядочивания. Как показано в коде ниже, последний нелистовой узел является родителем последнего узла, и именно с него мы начинаем обратный обход и упорядочивание:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"Конструктор, строящий кучу по входному списку\"\"\"\n    # Добавить элементы списка в кучу без изменений\n    self.max_heap = nums\n    # Выполнить heapify для всех узлов, кроме листовых\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(vector&lt;int&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = nums;\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Конструктор: построить кучу по входному списку */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = new List&lt;int&gt;(nums);\n    // Выполнить heapify для всех узлов, кроме листовых\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Конструктор, строящий кучу по срезу */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // Добавить элементы списка в кучу без изменений\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // Выполнить heapify для всех узлов, кроме листовых\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* Конструктор, строящий кучу по входному списку */\ninit(nums: [Int]) {\n    // Добавить элементы списка в кучу без изменений\n    maxHeap = nums\n    // Выполнить heapify для всех узлов, кроме листовых\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Конструктор, создающий пустую кучу или строящий кучу по входному списку */\nconstructor(nums) {\n    // Добавить элементы списка в кучу без изменений\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Конструктор, создающий пустую кучу или строящий кучу по входному списку */\nconstructor(nums?: number[]) {\n    // Добавить элементы списка в кучу без изменений\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // Выполнить heapify для всех узлов, кроме листовых\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Конструктор, строящий кучу по входному списку */\nMaxHeap(List&lt;int&gt; nums) {\n  // Добавить элементы списка в кучу без изменений\n  _maxHeap = nums;\n  // Выполнить heapify для всех узлов, кроме листовых\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Конструктор, строящий кучу по входному списку */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // Добавить элементы списка в кучу без изменений\n    let mut heap = MaxHeap { max_heap: nums };\n    // Выполнить heapify для всех узлов, кроме листовых\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* Конструктор, строящий кучу по срезу */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // Поместить все элементы в кучу\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // Выполнить heapify для всех узлов, кроме листовых\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* Максимальная куча */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // Использовать список вместо массива, чтобы не учитывать проблему расширения\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* Конструктор, строящий кучу по входному списку */\n    init {\n        // Добавить элементы списка в кучу без изменений\n        maxHeap.addAll(nums!!)\n        // Выполнить heapify для всех узлов, кроме листовых\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* Получить индекс левого дочернего узла */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Получить индекс родительского узла */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // Округление вниз при делении\n    }\n\n    /* Поменять элементы местами */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* Получение размера кучи */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* Проверка, пуста ли куча */\n    fun isEmpty(): Boolean {\n        /* Проверка, пуста ли куча */\n        return size() == 0\n    }\n\n    /* Доступ к элементу на вершине кучи */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* Добавление элемента в кучу */\n    fun push(_val: Int) {\n        // Добавление узла\n        maxHeap.add(_val)\n        // Просеивание снизу вверх\n        siftUp(size() - 1)\n    }\n\n    /* Начиная с узла i, выполнить просеивание снизу вверх */\n    private fun siftUp(it: Int) {\n        // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n        var i = it\n        while (true) {\n            // Получение родительского узла для узла i\n            val p = parent(i)\n            // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // Поменять два узла местами\n            swap(i, p)\n            // Циклическое просеивание вверх\n            i = p\n        }\n    }\n\n    /* Извлечение элемента из кучи */\n    fun pop(): Int {\n        // Обработка пустого случая\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        swap(0, size() - 1)\n        // Удаление узла\n        val _val = maxHeap.removeAt(size() - 1)\n        // Просеивание сверху вниз\n        siftDown(0)\n        // Вернуть элемент с вершины кучи\n        return _val\n    }\n\n    /* Начиная с узла i, выполнить просеивание сверху вниз */\n    private fun siftDown(it: Int) {\n        // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n        var i = it\n        while (true) {\n            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n            if (ma == i) break\n            // Поменять два узла местами\n            swap(i, ma)\n            // Циклическое просеивание вниз\n            i = ma\n        }\n    }\n\n    /* Вывести кучу (двоичное дерево) */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Конструктор, строящий кучу по входному списку ###\ndef initialize(nums)\n  # Добавить элементы списка в кучу без изменений\n  @max_heap = nums\n  # Выполнить heapify для всех узлов, кроме листовых\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   Анализ сложности","text":"<p>Теперь попробуем оценить временную сложность второго способа построения кучи.</p> <ul> <li>Пусть число узлов полного двоичного дерева равно \\(n\\) , тогда число листовых узлов равно \\((n + 1) / 2\\) , где \\(/\\) означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно \\((n - 1) / 2\\) .</li> <li>В процессе упорядочивания сверху вниз каждый узел в худшем случае может просеяться до листа, поэтому максимальное число итераций равно высоте двоичного дерева \\(\\log n\\) .</li> </ul> <p>Перемножив эти два значения, можно получить временную сложность построения кучи \\(O(n \\log n)\\) . Но эта оценка неточна, потому что мы не учли свойство двоичного дерева: на нижних уровнях узлов гораздо больше, чем на верхних.</p> <p>Далее выполним более точный расчет. Чтобы упростить вычисления, предположим, что дано \"идеальное двоичное дерево\" высоты \\(h\\) с числом узлов \\(n\\) ; это предположение не повлияет на корректность результата.</p> <p></p> <p> Рисунок 8-5   Число узлов на каждом уровне идеального двоичного дерева </p> <p>Как показано на рисунке 8-5, максимальное число итераций упорядочивания сверху вниз для некоторого узла равно расстоянию от этого узла до листового узла, а это расстояние как раз и есть высота узла. Поэтому мы можем просуммировать для каждого уровня выражение \"число узлов \\(\\times\\) высота узла\" и получить суммарное число итераций упорядочивания для всех узлов.</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>Чтобы упростить это выражение, воспользуемся школьными знаниями о последовательностях и сначала умножим \\(T(h)\\) на \\(2\\) :</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>Используя метод вычитания со сдвигом, вычтем из нижней строки \\(2 T(h)\\) верхнюю строку \\(T(h)\\) , тогда получим:</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>Из этого выражения видно, что \\(T(h)\\) представляет собой геометрическую прогрессию, поэтому можно напрямую применить формулу суммы и получить временную сложность:</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>Далее, число узлов идеального двоичного дерева высоты \\(h\\) равно \\(n = 2^{h+1} - 1\\) , поэтому несложно получить сложность \\(O(2^h) = O(n)\\) . Из этого вывода следует, что построение кучи из входного списка имеет временную сложность \\(O(n)\\) , то есть выполняется очень эффективно.</p>","path":["Глава 8. Куча","8.2 &nbsp; Построение кучи"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   Куча","text":"<p>Куча (heap) - это полное двоичное дерево, удовлетворяющее определенным условиям. Основных типов кучи два, как показано на рисунке 8-1.</p> <ul> <li>Минимальная куча (min heap): значение любого узла \\(\\leq\\) значения его дочерних узлов.</li> <li>Максимальная куча (max heap): значение любого узла \\(\\geq\\) значения его дочерних узлов.</li> </ul> <p></p> <p> Рисунок 8-1   Минимальная куча и максимальная куча </p> <p>Куча, являясь частным случаем полного двоичного дерева, обладает следующими свойствами.</p> <ul> <li>Узлы самого нижнего уровня заполняются слева, а все остальные уровни заполнены полностью.</li> <li>Корневой узел двоичного дерева мы называем вершиной кучи, а самый правый узел нижнего уровня - основанием кучи.</li> <li>Для максимальной (минимальной) кучи значение элемента на вершине, то есть у корневого узла, является максимальным (минимальным).</li> </ul>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   Распространенные операции с кучей","text":"<p>Нужно отметить, что многие языки программирования предоставляют не саму кучу, а очередь с приоритетом (priority queue) - абстрактную структуру данных, определяемую как очередь, в которой элементы извлекаются в соответствии с приоритетом.</p> <p>На практике куча обычно используется для реализации очереди с приоритетом, а максимальная куча эквивалентна очереди с приоритетом, в которой элементы извлекаются по убыванию. С точки зрения использования очередь с приоритетом и куча могут считаться эквивалентными структурами данных. Поэтому в этой книге мы не будем специально различать их и в дальнейшем будем единообразно называть кучей.</p> <p>Распространенные операции с кучей приведены в таблице 8-1. Конкретные имена методов зависят от языка программирования.</p> <p> Таблица 8-1   Эффективность операций с кучей </p> Имя метода Описание Временная сложность <code>push()</code> Поместить элемент в кучу \\(O(\\log n)\\) <code>pop()</code> Извлечь элемент с вершины кучи \\(O(\\log n)\\) <code>peek()</code> Получить доступ к вершине кучи (для max / min кучи это соответственно максимум / минимум) \\(O(1)\\) <code>size()</code> Получить число элементов в куче \\(O(1)\\) <code>isEmpty()</code> Проверить, пуста ли куча \\(O(1)\\) <p>В реальных приложениях мы можем напрямую использовать классы кучи, предоставляемые языком программирования, или классы очереди с приоритетом.</p> <p>Подобно сортировкам \"по возрастанию\" и \"по убыванию\", мы можем переключаться между \"минимальной кучей\" и \"максимальной кучей\", изменяя <code>flag</code> или модифицируя <code>Comparator</code> . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># Инициализация минимальной кучи\nmin_heap, flag = [], 1\n# Инициализация максимальной кучи\nmax_heap, flag = [], -1\n\n# Модуль heapq в Python по умолчанию реализует минимальную кучу\n# Если инвертировать знак элемента перед добавлением, то отношение порядка перевернется и так реализуется максимальная куча\n# В этом примере flag = 1 соответствует минимальной куче, а flag = -1 - максимальной\n\n# Добавление элементов в кучу\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# Получение элемента на вершине кучи\npeek: int = flag * max_heap[0] # 5\n\n# Извлечение элемента с вершины кучи\n# Извлеченные элементы образуют последовательность по убыванию\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# Получение размера кучи\nsize: int = len(max_heap)\n\n# Проверка, пуста ли куча\nis_empty: bool = not max_heap\n\n# Построение кучи из входного списка\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// Инициализация максимальной кучи\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* Добавление элементов в кучу */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.top(); // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* Получение размера кучи */\nint size = maxHeap.size();\n\n/* Проверка, пуста ли куча */\nbool isEmpty = maxHeap.empty();\n\n/* Построение кучи из входного списка */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// Инициализация максимальной кучи (достаточно изменить Comparator через lambda)\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* Добавление элементов в кучу */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.peek(); // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* Получение размера кучи */\nint size = maxHeap.size();\n\n/* Проверка, пуста ли куча */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* Построение кучи из входного списка */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// Инициализация максимальной кучи (достаточно изменить Comparer через lambda)\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* Добавление элементов в кучу */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* Получение элемента на вершине кучи */\nint peek = maxHeap.Peek();//5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* Получение размера кучи */\nint size = maxHeap.Count;\n\n/* Проверка, пуста ли куча */\nbool isEmpty = maxHeap.Count == 0;\n\n/* Построение кучи из входного списка */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// В Go можно построить целочисленную максимальную кучу, реализовав heap.Interface\n// Для реализации heap.Interface также нужно реализовать sort.Interface\ntype intHeap []any\n\n// Метод Push из heap.Interface, реализует добавление элемента в кучу\nfunc (h *intHeap) Push(x any) {\n    // Push и Pop используют pointer receiver\n    // Потому что они не только изменяют содержимое среза, но и его длину\n    *h = append(*h, x.(int))\n}\n\n// Метод Pop из heap.Interface, реализует извлечение элемента с вершины кучи\nfunc (h *intHeap) Pop() any {\n    // Извлекаемый элемент хранится в конце\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Метод Len из sort.Interface\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Метод Less из sort.Interface\nfunc (h *intHeap) Less(i, j int) bool {\n    // Для минимальной кучи здесь нужно заменить сравнение на &lt;\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Метод Swap из sort.Interface\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top получает элемент на вершине кучи\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* Инициализация кучи */\n    // Инициализация максимальной кучи\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* Добавление элементов в кучу */\n    // Вызываем методы heap.Interface для добавления элементов\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* Получение элемента на вершине кучи */\n    top := maxHeap.Top()\n    fmt.Printf(\"Элемент на вершине кучи: %d\\n\", top)\n\n    /* Извлечение элемента с вершины кучи */\n    // Вызываем методы heap.Interface для удаления элементов\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* Получение размера кучи */\n    size := len(*maxHeap)\n    fmt.Printf(\"Число элементов в куче: %d\\n\", size)\n\n    /* Проверка, пуста ли куча */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"Пуста ли куча: %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* Инициализация кучи */\n// Тип Heap в Swift поддерживает и max-heap, и min-heap, но требует swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* Добавление элементов в кучу */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* Получение элемента на вершине кучи */\nvar peek = heap.max()!\n\n/* Извлечение элемента с вершины кучи */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* Получение размера кучи */\nlet size = heap.count\n\n/* Проверка, пуста ли куча */\nlet isEmpty = heap.isEmpty\n\n/* Построение кучи из входного списка */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// В JavaScript нет встроенного класса Heap\n</code></pre> heap.ts<pre><code>// В TypeScript нет встроенного класса Heap\n</code></pre> heap.dart<pre><code>// В Dart нет встроенного класса Heap\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* Инициализация кучи */\n// Инициализация минимальной кучи\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// Инициализация максимальной кучи\nlet mut max_heap = BinaryHeap::new();\n\n/* Добавление элементов в кучу */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* Получение элемента на вершине кучи */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* Получение размера кучи */\nlet size = max_heap.len();\n\n/* Проверка, пуста ли куча */\nlet is_empty = max_heap.is_empty();\n\n/* Построение кучи из входного списка */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// В C нет встроенного класса Heap\n</code></pre> heap.kt<pre><code>/* Инициализация кучи */\n// Инициализация минимальной кучи\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// Инициализация максимальной кучи (достаточно изменить Comparator через lambda)\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* Добавление элементов в кучу */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* Получение элемента на вершине кучи */\nvar peek = maxHeap.peek() // 5\n\n/* Извлечение элемента с вершины кучи */\n// Извлеченные элементы образуют последовательность по убыванию\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* Получение размера кучи */\nval size = maxHeap.size\n\n/* Проверка, пуста ли куча */\nval isEmpty = maxHeap.isEmpty()\n\n/* Построение кучи из входного списка */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># В Ruby нет встроенного класса Heap\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20min-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20min_heap%2C%20flag%20%3D%20%5B%5D%2C%201%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20max-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20max_heap%2C%20flag%20%3D%20%5B%5D%2C%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9C%D0%BE%D0%B4%D1%83%D0%BB%D1%8C%20heapq%20%D0%B2%20Python%20%D0%BF%D0%BE%20%D1%83%D0%BC%D0%BE%D0%BB%D1%87%D0%B0%D0%BD%D0%B8%D1%8E%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D1%83%D0%B5%D1%82%20min-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%20%D0%BF%D0%BE%D0%BC%D0%B5%D1%89%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%20%D0%B1%D1%80%D0%B0%D1%82%D1%8C%20%D0%BE%D1%82%D1%80%D0%B8%D1%86%D0%B0%D0%BD%D0%B8%D0%B5%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%2C%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%B8%D1%82%D1%8C%20%D0%BE%D1%82%D0%BD%D0%BE%D1%88%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B0%20%D0%B8%20%D1%82%D0%B5%D0%BC%20%D1%81%D0%B0%D0%BC%D1%8B%D0%BC%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20max-%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%23%20%D0%92%20%D1%8D%D1%82%D0%BE%D0%BC%20%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%B5%20flag%20%3D%201%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20min-%D0%BA%D1%83%D1%87%D0%B5%2C%20%D0%B0%20flag%20%3D%20-1%20%D1%81%D0%BE%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82%20max-%D0%BA%D1%83%D1%87%D0%B5%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%201%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%203%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%202%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%205%29%0A%20%20%20%20heapq.heappush%28max_heap%2C%20flag%20%2A%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20peek%20%3D%20flag%20%2A%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%D0%B7%20%D0%BA%D1%83%D1%87%D0%B8%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D1%83%D1%8E%D1%82%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%D0%BE%D1%82%20%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B3%D0%BE%20%D0%BA%20%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BC%D1%83%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20%2A%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BA%D1%83%D1%87%D0%B0%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%D0%92%D1%85%D0%BE%D0%B4%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA%D0%B8%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20min_heap%20%3D%20%5B1%2C%203%2C%202%2C%205%2C%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   Реализация кучи","text":"<p>Ниже реализуется максимальная куча. Чтобы преобразовать ее в минимальную кучу, достаточно инвертировать всю логику сравнений по величине, например заменить \\(\\geq\\) на \\(\\leq\\) . Заинтересованные читатели могут попробовать реализовать это самостоятельно.</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   Хранение и представление кучи","text":"<p>В разделе \"Двоичные деревья\" мы уже говорили, что полное двоичное дерево очень удобно представлять массивом. Поскольку куча как раз и является полным двоичным деревом, для хранения кучи мы также будем использовать массив.</p> <p>Когда двоичное дерево представляется массивом, элементы массива соответствуют значениям узлов, а индексы - положениям этих узлов в двоичном дереве. Указатели на узлы реализуются через формулы отображения индексов.</p> <p>Как показано на рисунке 8-2, для заданного индекса \\(i\\) индекс левого дочернего узла равен \\(2i + 1\\) , правого дочернего узла - \\(2i + 2\\) , а родительского узла - \\((i - 1) / 2\\) с округлением вниз. Если индекс выходит за допустимые границы, это означает пустой узел или отсутствие узла.</p> <p></p> <p> Рисунок 8-2   Представление и хранение кучи </p> <p>Мы можем инкапсулировать формулы отображения индексов в функции, чтобы потом было удобнее ими пользоваться:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"Получить индекс левого дочернего узла\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"Получить индекс правого дочернего узла\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"Получить индекс родительского узла\"\"\"\n    return (i - 1) // 2  # Округление вниз при делении\n</code></pre> my_heap.cpp<pre><code>/* Получить индекс левого дочернего узла */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.java<pre><code>/* Получить индекс левого дочернего узла */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.cs<pre><code>/* Получить индекс левого дочернего узла */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint Parent(int i) {\n    return (i - 1) / 2; // Округление вниз при делении\n}\n</code></pre> my_heap.go<pre><code>/* Получить индекс левого дочернего узла */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* Получить индекс родительского узла */\nfunc (h *maxHeap) parent(i int) int {\n    // Округление вниз при делении\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* Получить индекс левого дочернего узла */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.js<pre><code>/* Получить индекс левого дочернего узла */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // Округление вниз при делении\n}\n</code></pre> my_heap.ts<pre><code>/* Получить индекс левого дочернего узла */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // Округление вниз при делении\n}\n</code></pre> my_heap.dart<pre><code>/* Получить индекс левого дочернего узла */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // Округление вниз при делении\n}\n</code></pre> my_heap.rs<pre><code>/* Получить индекс левого дочернего узла */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.c<pre><code>/* Получить индекс левого дочернего узла */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* Получить индекс правого дочернего узла */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* Получить индекс родительского узла */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // Округление вниз\n}\n</code></pre> my_heap.kt<pre><code>/* Получить индекс левого дочернего узла */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* Получить индекс правого дочернего узла */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* Получить индекс родительского узла */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // Округление вниз при делении\n}\n</code></pre> my_heap.rb<pre><code>### Получить индекс левого дочернего узла ###\ndef left(i)\n  2 * i + 1\nend\n\n### Получить индекс правого дочернего узла ###\ndef right(i)\n  2 * i + 2\nend\n\n### Получить индекс родительского узла ###\ndef parent(i)\n  (i - 1) / 2     # Округление вниз при делении\nend\n</code></pre>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   Доступ к элементу на вершине кучи","text":"<p>Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"Доступ к элементу на вершине кучи\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* Доступ к элементу на вершине кучи */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* Доступ к элементу на вершине кучи */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* Доступ к элементу на вершине кучи */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* Доступ к элементу на вершине кучи */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* Доступ к элементу на вершине кучи */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* Доступ к элементу на вершине кучи */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* Доступ к элементу на вершине кучи */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* Доступ к элементу на вершине кучи */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* Доступ к элементу на вершине кучи */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### Доступ к элементу на вершине кучи ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   Добавление элемента в кучу","text":"<p>Пусть дан элемент <code>val</code> . Сначала мы помещаем его в основание кучи. После добавления свойства кучи могут нарушиться, потому что <code>val</code> может оказаться больше, чем другие элементы в куче. Поэтому необходимо восстановить порядок на пути от вставленного узла к корню ; эта операция называется упорядочиванием кучи.</p> <p>Рассмотрим ситуацию, когда упорядочивание выполняется снизу вверх, начиная от только что вставленного узла. Как показано на рисунках ниже, мы сравниваем значение вставленного узла со значением его родителя; если вставленный узел больше, то меняем их местами. Затем продолжаем выполнять ту же операцию и последовательно восстанавливать корректность всех узлов по пути снизу вверх, пока не выйдем за корень или не встретим узел, для которого обмен не требуется.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-3   Шаги добавления элемента в кучу </p> <p>Пусть общее число узлов равно \\(n\\) , тогда высота дерева равна \\(O(\\log n)\\) . Следовательно, максимальное число итераций операции упорядочивания кучи тоже не превышает \\(O(\\log n)\\) . Отсюда временная сложность добавления элемента в кучу равна \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"Добавление элемента в кучу\"\"\"\n    # Добавление узла\n    self.max_heap.append(val)\n    # Просеивание снизу вверх\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"Начиная с узла i, выполнить просеивание снизу вверх\"\"\"\n    while True:\n        # Получение родительского узла для узла i\n        p = self.parent(i)\n        # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # Поменять два узла местами\n        self.swap(i, p)\n        # Циклическое просеивание вверх\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n    // Добавление узла\n    maxHeap.push_back(val);\n    // Просеивание снизу вверх\n    siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Поменять два узла местами\n        swap(maxHeap[i], maxHeap[p]);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n    // Добавление узла\n    maxHeap.add(val);\n    // Просеивание снизу вверх\n    siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // Поменять два узла местами\n        swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Добавление элемента в кучу */\nvoid Push(int val) {\n    // Добавление узла\n    maxHeap.Add(val);\n    // Просеивание снизу вверх\n    SiftUp(Size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid SiftUp(int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = Parent(i);\n        // Если «выход за пределы корневого узла» или «узел не требует исправления», завершить просеивание\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // Поменять два узла местами\n        Swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Добавление элемента в кучу */\nfunc (h *maxHeap) push(val any) {\n    // Добавление узла\n    h.data = append(h.data, val)\n    // Просеивание снизу вверх\n    h.siftUp(len(h.data) - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // Получение родительского узла для узла i\n        p := h.parent(i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // Поменять два узла местами\n        h.swap(i, p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Добавление элемента в кучу */\nfunc push(val: Int) {\n    // Добавление узла\n    maxHeap.append(val)\n    // Просеивание снизу вверх\n    siftUp(i: size() - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // Получение родительского узла для узла i\n        let p = parent(i: i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // Поменять два узла местами\n        swap(i: i, j: p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Добавление элемента в кучу */\npush(val) {\n    // Добавление узла\n    this.#maxHeap.push(val);\n    // Просеивание снизу вверх\n    this.#siftUp(this.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\n#siftUp(i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        const p = this.#parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // Поменять два узла местами\n        this.#swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Добавление элемента в кучу */\npush(val: number): void {\n    // Добавление узла\n    this.maxHeap.push(val);\n    // Просеивание снизу вверх\n    this.siftUp(this.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nsiftUp(i: number): void {\n    while (true) {\n        // Получение родительского узла для узла i\n        const p = this.parent(i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // Поменять два узла местами\n        this.swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Добавление элемента в кучу */\nvoid push(int val) {\n  // Добавление узла\n  _maxHeap.add(val);\n  // Просеивание снизу вверх\n  siftUp(size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(int i) {\n  while (true) {\n    // Получение родительского узла для узла i\n    int p = _parent(i);\n    // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // Поменять два узла местами\n    _swap(i, p);\n    // Циклическое просеивание вверх\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Добавление элемента в кучу */\nfn push(&amp;mut self, val: i32) {\n    // Добавление узла\n    self.max_heap.push(val);\n    // Просеивание снизу вверх\n    self.sift_up(self.size() - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // Если узел i уже является вершиной кучи, завершить просеивание\n        if i == 0 {\n            break;\n        }\n        // Получение родительского узла для узла i\n        let p = Self::parent(i);\n        // Когда «узел не требует исправления», завершить просеивание\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // Поменять два узла местами\n        self.swap(i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Добавление элемента в кучу */\nvoid push(MaxHeap *maxHeap, int val) {\n    // По умолчанию не следует добавлять так много узлов\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // Добавление узла\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // Просеивание снизу вверх\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Получение родительского узла для узла i\n        int p = parent(maxHeap, i);\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(maxHeap, i, p);\n        // Циклическое просеивание вверх\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Добавление элемента в кучу */\nfun push(_val: Int) {\n    // Добавление узла\n    maxHeap.add(_val)\n    // Просеивание снизу вверх\n    siftUp(size() - 1)\n}\n\n/* Начиная с узла i, выполнить просеивание снизу вверх */\nfun siftUp(it: Int) {\n    // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n    var i = it\n    while (true) {\n        // Получение родительского узла для узла i\n        val p = parent(i)\n        // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // Поменять два узла местами\n        swap(i, p)\n        // Циклическое просеивание вверх\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Добавление элемента в кучу ###\ndef push(val)\n  # Добавление узла\n  @max_heap &lt;&lt; val\n  # Просеивание снизу вверх\n  sift_up(size - 1)\nend\n\n### Начиная с узла i, выполнить просеивание снизу вверх ###\ndef sift_up(i)\n  loop do\n    # Получение родительского узла для узла i\n    p = parent(i)\n    # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # Поменять два узла местами\n    swap(i, p)\n    # Циклическое просеивание вверх\n    i = p\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   Извлечение элемента с вершины кучи","text":"<p>Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка. Если просто удалить первый элемент списка, то индексы всех узлов двоичного дерева изменятся, и это сильно затруднит последующее восстановление структуры при помощи упорядочивания кучи. Чтобы по возможности минимизировать изменение индексов элементов, мы используем следующий порядок действий.</p> <ol> <li>Поменять местами элемент на вершине кучи и элемент у основания кучи, то есть поменять корневой узел с самым правым листовым узлом.</li> <li>После обмена удалить основание кучи из списка. Стоит отметить, что, поскольку обмен уже выполнен, фактически удаляется исходный элемент вершины кучи.</li> <li>Начиная от корневого узла, выполнить упорядочивание кучи сверху вниз.</li> </ol> <p>Как показано на рисунках ниже, направление операции упорядочивания кучи сверху вниз противоположно операции упорядочивания кучи снизу вверх. Мы сравниваем значение корневого узла со значениями двух дочерних узлов, выбираем больший дочерний узел и меняем его местами с корневым узлом. Затем циклически повторяем ту же операцию, пока не выйдем за листовой узел или не встретим узел, который уже не требует обмена.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-4   Шаги извлечения элемента с вершины кучи </p> <p>Как и операция добавления в кучу, операция извлечения элемента с вершины кучи также имеет временную сложность \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"Извлечение элемента из кучи\"\"\"\n    # Обработка пустого случая\n    if self.is_empty():\n        raise IndexError(\"куча пуста\")\n    # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    self.swap(0, self.size() - 1)\n    # Удаление узла\n    val = self.max_heap.pop()\n    # Просеивание сверху вниз\n    self.sift_down(0)\n    # Вернуть элемент с вершины кучи\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"Начиная с узла i, выполнить просеивание сверху вниз\"\"\"\n    while True:\n        # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i:\n            break\n        # Поменять два узла местами\n        self.swap(i, ma)\n        # Циклическое просеивание вниз\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* Извлечение элемента из кучи */\nvoid pop() {\n    // Обработка пустого случая\n    if (isEmpty()) {\n        throw out_of_range(\"куча пуста\");\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // Удаление узла\n    maxHeap.pop_back();\n    // Просеивание сверху вниз\n    siftDown(0);\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* Извлечение элемента из кучи */\nint pop() {\n    // Обработка пустого случая\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(0, size() - 1);\n    // Удаление узла\n    int val = maxHeap.remove(size() - 1);\n    // Просеивание сверху вниз\n    siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* Извлечение элемента из кучи */\nint Pop() {\n    // Обработка пустого случая\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    Swap(0, Size() - 1);\n    // Удаление узла\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // Просеивание сверху вниз\n    SiftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid SiftDown(int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // Если «узел i максимален» или «выход за пределы листовых узлов», завершить просеивание\n        if (ma == i) break;\n        // Поменять два узла местами\n        Swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* Извлечение элемента из кучи */\nfunc (h *maxHeap) pop() any {\n    // Обработка пустого случая\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    h.swap(0, h.size()-1)\n    // Удаление узла\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // Просеивание сверху вниз\n    h.siftDown(0)\n\n    // Вернуть элемент с вершины кучи\n    return val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if max == i {\n            break\n        }\n        // Поменять два узла местами\n        h.swap(i, max)\n        // Циклическое просеивание вниз\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* Извлечение элемента из кучи */\nfunc pop() -&gt; Int {\n    // Обработка пустого случая\n    if isEmpty() {\n        fatalError(\"куча пуста\")\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(i: 0, j: size() - 1)\n    // Удаление узла\n    let val = maxHeap.remove(at: size() - 1)\n    // Просеивание сверху вниз\n    siftDown(i: 0)\n    // Вернуть элемент с вершины кучи\n    return val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        swap(i: i, j: ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* Извлечение элемента из кучи */\npop() {\n    // Обработка пустого случая\n    if (this.isEmpty()) throw new Error('куча пуста');\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    this.#swap(0, this.size() - 1);\n    // Удаление узла\n    const val = this.#maxHeap.pop();\n    // Просеивание сверху вниз\n    this.#siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\n#siftDown(i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) break;\n        // Поменять два узла местами\n        this.#swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* Извлечение элемента из кучи */\npop(): number {\n    // Обработка пустого случая\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    this.swap(0, this.size() - 1);\n    // Удаление узла\n    const val = this.maxHeap.pop();\n    // Просеивание сверху вниз\n    this.siftDown(0);\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nsiftDown(i: number): void {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) break;\n        // Поменять два узла местами\n        this.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* Извлечение элемента из кучи */\nint pop() {\n  // Обработка пустого случая\n  if (isEmpty()) throw Exception('куча пуста');\n  // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n  _swap(0, size() - 1);\n  // Удаление узла\n  int val = _maxHeap.removeLast();\n  // Просеивание сверху вниз\n  siftDown(0);\n  // Вернуть элемент с вершины кучи\n  return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int i) {\n  while (true) {\n    // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    if (ma == i) break;\n    // Поменять два узла местами\n    _swap(i, ma);\n    // Циклическое просеивание вниз\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* Извлечение элемента из кучи */\nfn pop(&amp;mut self) -&gt; i32 {\n    // Обработка пустого случая\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    self.swap(0, self.size() - 1);\n    // Удаление узла\n    let val = self.max_heap.pop().unwrap();\n    // Просеивание сверху вниз\n    self.sift_down(0);\n    // Вернуть элемент с вершины кучи\n    val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break;\n        }\n        // Поменять два узла местами\n        self.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* Извлечение элемента из кучи */\nint pop(MaxHeap *maxHeap) {\n    // Обработка пустого случая\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // Удаление узла\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // Просеивание сверху вниз\n    siftDown(maxHeap, 0);\n\n    // Вернуть элемент с вершины кучи\n    return val;\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (max == i) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(maxHeap, i, max);\n        // Циклическое просеивание вниз\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* Извлечение элемента из кучи */\nfun pop(): Int {\n    // Обработка пустого случая\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    swap(0, size() - 1)\n    // Удаление узла\n    val _val = maxHeap.removeAt(size() - 1)\n    // Просеивание сверху вниз\n    siftDown(0)\n    // Вернуть элемент с вершины кучи\n    return _val\n}\n\n/* Начиная с узла i, выполнить просеивание сверху вниз */\nfun siftDown(it: Int) {\n    // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная\n    var i = it\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) break\n        // Поменять два узла местами\n        swap(i, ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### Извлечение элемента из кучи ###\ndef pop\n  # Обработка пустого случая\n  raise IndexError, \"куча пуста\" if is_empty?\n  # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n  swap(0, size - 1)\n  # Удаление узла\n  val = @max_heap.pop\n  # Просеивание сверху вниз\n  sift_down(0)\n  # Вернуть элемент с вершины кучи\n  val\nend\n\n### Начиная с узла i, выполнить просеивание сверху вниз ###\ndef sift_down(i)\n  loop do\n    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    break if ma == i\n\n    # Поменять два узла местами\n    swap(i, ma)\n    # Циклическое просеивание вниз\n    i = ma\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   Типичные применения кучи","text":"<ul> <li>Очередь с приоритетом: куча обычно является предпочтительной структурой данных для реализации очереди с приоритетом; добавление и извлечение элементов имеют временную сложность \\(O(\\log n)\\) , а построение кучи - \\(O(n)\\) , и все эти операции выполняются очень эффективно.</li> <li>Пирамидальная сортировка: для заданного набора данных можно построить кучу, а затем непрерывно извлекать из нее элементы, получая отсортированные данные. Однако на практике мы обычно используем более изящную реализацию пирамидальной сортировки; подробности см. в разделе \"Пирамидальная сортировка\".</li> <li>Получение наибольших \\(k\\) элементов: это классическая алгоритмическая задача и одновременно типичное применение кучи. Например, выбор 10 самых горячих новостей для списка популярных тем или выбор 10 самых продаваемых товаров.</li> </ul>","path":["Глава 8. Куча","8.1 &nbsp; Куча"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   Резюме","text":"","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Куча представляет собой полное двоичное дерево и делится на максимальную кучу и минимальную кучу. Элемент на вершине максимальной (минимальной) кучи является наибольшим (наименьшим).</li> <li>Очередь с приоритетом определяется как очередь, элементы которой извлекаются в соответствии с приоритетом; обычно ее реализуют с помощью кучи.</li> <li>К основным операциям кучи и их временным сложностям относятся: добавление элемента в кучу \\(O(\\log n)\\) , извлечение элемента с вершины кучи \\(O(\\log n)\\) и доступ к вершине кучи \\(O(1)\\) .</li> <li>Полное двоичное дерево очень удобно представлять массивом, поэтому кучу обычно тоже хранят в массиве.</li> <li>Операция упорядочивания кучи используется для поддержания свойств кучи и применяется как при добавлении элемента, так и при извлечении элемента.</li> <li>Временную сложность построения кучи из \\(n\\) элементов можно оптимизировать до \\(O(n)\\) , что очень эффективно.</li> <li>Top-k - это классическая алгоритмическая задача, которую можно эффективно решать с помощью кучи за \\(O(n \\log k)\\) .</li> </ul>","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Является ли \"куча\" как структура данных тем же самым понятием, что и \"куча\" в управлении памятью?</p> <p>Это не одно и то же, просто у них случайно совпало название. Куча в памяти компьютерной системы является частью динамического распределения памяти: во время выполнения программы она используется для хранения данных. Программа может запросить определенный объем памяти в куче для хранения сложных структур, таких как объекты и массивы. Когда эти данные больше не нужны, память нужно освободить, чтобы не допустить утечек. По сравнению со стековой памятью управление памятью в куче требует большей осторожности, а неправильное использование может привести к утечкам памяти и проблемам с указателями.</p>","path":["Глава 8. Куча","8.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Задача Top-k","text":"<p>Question</p> <p>Дан неупорядоченный массив <code>nums</code> длины \\(n\\) . Требуется вернуть наибольшие \\(k\\) элементов массива.</p> <p>Для этой задачи мы сначала покажем два относительно прямолинейных способа решения, а затем более эффективный способ на основе кучи.</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#831-1","level":2,"title":"8.3.1   Метод 1: выбор через обход","text":"<p>Как показано на рисунке 8-6, можно выполнить \\(k\\) проходов по массиву и на каждом проходе извлекать соответственно \\(1\\)-й, \\(2\\)-й, \\(\\dots\\) , \\(k\\)-й по величине элемент; временная сложность такого подхода равна \\(O(nk)\\) .</p> <p>Этот метод подходит только для случая \\(k \\ll n\\) , потому что когда \\(k\\) приближается к \\(n\\) , его временная сложность стремится к \\(O(n^2)\\) , а это уже очень затратно.</p> <p></p> <p> Рисунок 8-6   Поиск наибольших k элементов через обход </p> <p>Tip</p> <p>Когда \\(k = n\\) , мы получаем полную упорядоченную последовательность, и в этот момент задача становится эквивалентной алгоритму \"сортировка выбором\".</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#832-2","level":2,"title":"8.3.2   Метод 2: сортировка","text":"<p>Как показано на рисунке 8-7, можно сначала отсортировать массив <code>nums</code> , а затем вернуть его крайние правые \\(k\\) элементов; временная сложность такого метода равна \\(O(n \\log n)\\) .</p> <p>Очевидно, что этот способ делает слишком много, потому что нам нужно только найти наибольшие \\(k\\) элементов, а сортировать остальные элементы совсем не обязательно.</p> <p></p> <p> Рисунок 8-7   Поиск наибольших k элементов через сортировку </p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_heap/top_k/#833-3","level":2,"title":"8.3.3   Метод 3: куча","text":"<p>Задачу Top-k можно решить гораздо эффективнее с помощью кучи, как показано на рисунках ниже.</p> <ol> <li>Инициализировать минимальную кучу, у которой вершина содержит наименьший элемент.</li> <li>Сначала по очереди поместить в кучу первые \\(k\\) элементов массива.</li> <li>Начиная с элемента номер \\(k + 1\\) , если текущий элемент больше элемента на вершине кучи, то извлечь вершину кучи и поместить в кучу текущий элемент.</li> <li>После завершения обхода в куче будут храниться как раз наибольшие \\(k\\) элементов.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 8-8   Поиск наибольших k элементов с помощью кучи </p> <p>Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"Найти k наибольших элементов массива с помощью кучи\"\"\"\n    # Инициализация минимальной кучи\n    heap = []\n    # Поместить первые k элементов массива в кучу\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i in range(k, len(nums)):\n        # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // Инициализация минимальной кучи\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // Инициализация минимальной кучи\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // Инициализация минимальной кучи\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // Инициализация минимальной кучи\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // Поместить первые k элементов массива в кучу\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i := k; i &lt; len(nums); i++ {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // Инициализировать минимальную кучу и построить ее по первым k элементам\n    var heap = Heap(nums.prefix(k))\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for i in nums.indices.dropFirst(k) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* Добавление элемента в кучу */\nfunction pushMinHeap(maxHeap, val) {\n    // Инвертировать знак элемента\n    maxHeap.push(-val);\n}\n\n/* Извлечение элемента из кучи */\nfunction popMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return -maxHeap.pop();\n}\n\n/* Доступ к элементу на вершине кучи */\nfunction peekMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return -maxHeap.peek();\n}\n\n/* Извлечь элементы из кучи */\nfunction getMinHeap(maxHeap) {\n    // Инвертировать знак элемента\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* Найти k наибольших элементов массива с помощью кучи */\nfunction topKHeap(nums, k) {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    const maxHeap = new MaxHeap([]);\n    // Поместить первые k элементов массива в кучу\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (let i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Вернуть элементы кучи\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* Добавление элемента в кучу */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // Инвертировать знак элемента\n    maxHeap.push(-val);\n}\n\n/* Извлечение элемента из кучи */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // Инвертировать знак элемента\n    return -maxHeap.pop();\n}\n\n/* Доступ к элементу на вершине кучи */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // Инвертировать знак элемента\n    return -maxHeap.peek();\n}\n\n/* Извлечь элементы из кучи */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // Инвертировать знак элемента\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* Найти k наибольших элементов массива с помощью кучи */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    const maxHeap = new MaxHeap([]);\n    // Поместить первые k элементов массива в кучу\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (let i = k; i &lt; nums.length; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // Вернуть элементы кучи\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // Инициализировать минимальную кучу, поместив в нее первые k элементов массива\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // Начиная с элемента k+1, поддерживать длину кучи равной k\n  for (int i = k; i &lt; nums.length; i++) {\n    // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap — это максимальная куча; с помощью Reverse элементы инвертируются, чтобы реализовать минимальную кучу\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // Поместить первые k элементов массива в кучу\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for &amp;num in nums.iter().skip(k) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* Добавление элемента в кучу */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // Инвертировать знак элемента\n    push(maxHeap, -val);\n}\n\n/* Извлечение элемента из кучи */\nint popMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать знак элемента\n    return -pop(maxHeap);\n}\n\n/* Доступ к элементу на вершине кучи */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать знак элемента\n    return -peek(maxHeap);\n}\n\n/* Извлечь элементы из кучи */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать все элементы кучи и записать их в массив res\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* Извлечь элементы из кучи */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // Инвертировать все элементы кучи и записать их в массив res\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// Функция поиска k наибольших элементов массива на основе кучи\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // Инициализация минимальной кучи\n    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // Поместить первые k элементов массива в кучу\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // Освободить память\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* Найти k наибольших элементов массива с помощью кучи */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // Инициализация минимальной кучи\n    val heap = PriorityQueue&lt;Int&gt;()\n    // Поместить первые k элементов массива в кучу\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // Начиная с элемента k+1, поддерживать длину кучи равной k\n    for (i in k..&lt;nums.size) {\n        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### Поиск k наибольших элементов массива с помощью кучи ###\ndef top_k_heap(nums, k)\n  # Инициализация минимальной кучи\n  # Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную\n  max_heap = MaxHeap.new([])\n\n  # Поместить первые k элементов массива в кучу\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # Начиная с элемента k+1, поддерживать длину кучи равной k\n  for i in k...nums.length\n    # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Всего выполняется \\(n\\) операций добавления и извлечения из кучи, а максимальная длина кучи равна \\(k\\) , поэтому временная сложность равна \\(O(n \\log k)\\) . Этот метод очень эффективен: когда \\(k\\) мало, временная сложность стремится к \\(O(n)\\) ; когда \\(k\\) велико, она все равно не превышает \\(O(n \\log n)\\) .</p> <p>Кроме того, этот метод подходит и для сценариев с динамическим потоком данных. При непрерывном поступлении новых данных мы можем продолжать поддерживать содержимое кучи, тем самым динамически обновляя наибольшие \\(k\\) элементов.</p>","path":["Глава 8. Куча","8.3 &nbsp; Задача Top-k"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"Перед началом","text":"<p>Несколько лет назад я публиковал на LeetCode разборы серии задач \"Sword for Offer\" и получил поддержку и ободрение от многих читателей. Во время общения с ними мне чаще всего задавали один и тот же вопрос: \"как начать изучать алгоритмы?\" Постепенно этот вопрос начал меня по-настоящему занимать.</p> <p>Слепо бросаться в решение задач кажется самым популярным способом: он прост, прямолинеен и действительно работает. Но решение задач похоже на игру в \"Сапера\": люди с сильными навыками самообучения способны обезвредить мины одну за другой, а тем, у кого не хватает базы, легко набить себе шишки и шаг за шагом отступить под давлением неудач. Полностью проходить учебники тоже принято часто, но для тех, кто готовится к поиску работы, диплом, резюме, письменные тесты и собеседования уже отнимают большую часть сил, и потому толстые книги нередко превращаются в тяжелое испытание.</p> <p>Если ты тоже сталкиваешься с такими трудностями, то можно сказать, что эта книга сама \"нашла\" тебя. Она стала моим ответом на этот вопрос: пусть и не идеальным, но как минимум честной и активной попыткой. Эта книга сама по себе не гарантирует предложения о работе, но поможет тебе увидеть \"карту знаний\" по структурам данных и алгоритмам, понять форму, размер и расположение разных \"мин\" и освоить разные \"способы разминирования\". Освоив это, ты сможешь увереннее решать задачи и читать технические материалы, шаг за шагом выстраивая целостную систему знаний.</p> <p>Я глубоко согласен со словами профессора Фейнмана: \"Knowledge isn't free. You have to pay attention.\" В этом смысле книга не совсем \"бесплатна\". Чтобы не подвести то драгоценное \"внимание\", которое ты ей уделишь, я постараюсь вложить в ее создание максимум собственного \"внимания\".</p> <p>Я хорошо понимаю пределы собственных знаний. Хотя материал этой книги уже довольно долго шлифовался, в нем наверняка все еще осталось немало ошибок, поэтому я искренне прошу преподавателей и читателей указывать на неточности и недоработки.</p> <p></p> Hello, алгоритмы! <p>Появление компьютеров радикально изменило мир. Благодаря высокой скорости вычислений и отличной программируемости они стали идеальной средой для исполнения алгоритмов и обработки данных. Реалистичная графика в играх, интеллектуальные решения в автономном вождении, впечатляющие партии AlphaGo и естественное взаимодействие ChatGPT: все это изящные проявления алгоритмов на компьютере.</p> <p>На самом деле еще до появления компьютеров алгоритмы и структуры данных уже существовали во всех уголках мира. Ранние алгоритмы были сравнительно простыми: например, древние способы счета или последовательности действий при изготовлении инструментов. По мере развития цивилизации алгоритмы становились тоньше и сложнее. За мастерством ремесленников, промышленными продуктами, освобождающими производительные силы, и даже за научными законами движения Вселенной почти всегда стоит изобретательная алгоритмическая мысль.</p> <p>Точно так же структуры данных встречаются повсюду: от социальных сетей до схем метро многие системы можно моделировать как \"граф\"; от государства до семьи основные формы общественной организации обладают свойствами \"дерева\"; зимняя одежда похожа на \"стек\", где то, что надевают первым, снимают последним; тубус для бадминтонных воланов похож на \"очередь\", где элементы добавляются с одного конца и извлекаются с другого; словарь похож на \"хеш-таблицу\", позволяющую быстро находить нужную статью.</p> <p>Эта книга стремится с помощью понятных анимированных иллюстраций и исполняемых примеров кода помочь читателю понять ключевые идеи алгоритмов и структур данных и научиться реализовывать их программно. На этой основе книга также пытается показать живые проявления алгоритмов в сложном мире и раскрыть их красоту. Надеюсь, она окажется для тебя полезной.</p>","path":["Перед началом"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"Глава 1.   Введение в алгоритмы","text":"<p>Abstract</p> <p>Юная девушка кружится в танце, переплетаясь с данными, а по подолу ее платья струится мелодия алгоритмов.</p> <p>Она приглашает вас присоединиться к танцу: следуйте за ее шагами и войдите в мир алгоритмов, полный логики и красоты.</p>","path":["Глава 1. Введение в алгоритмы","Глава 1. &nbsp; Введение в алгоритмы"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>1.1   Алгоритмы повсюду</li> <li>1.2   Что такое алгоритм</li> <li>1.3   Резюме</li> </ul>","path":["Глава 1. Введение в алгоритмы","Глава 1. &nbsp; Введение в алгоритмы"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   Алгоритмы повсюду","text":"<p>Говоря об алгоритмах, естественно вспомнить о математике. Однако на самом деле многие алгоритмы не связаны со сложной математикой, а больше полагаются на базовую логику, которая повсеместно встречается в нашей повседневной жизни.</p> <p>Прежде чем углубиться в обсуждение алгоритмов, стоит упомянуть интересный факт: вы уже точно освоили множество алгоритмов и привыкли применять их в повседневной жизни. Далее приведем несколько конкретных примеров, чтобы подтвердить этот факт.</p> <p>Пример 1: поиск в словаре. В словаре все слова упорядочены по алфавиту. Предположим, нам нужно найти слово, начинающееся на букву \\(r\\); обычно для этого нужно выполнить следующие действия.</p> <ol> <li>Откройте словарь примерно на половине страниц и посмотрите, какая буква является первой на этой странице; предположим, это буква \\(m\\).</li> <li>Поскольку в алфавите буква \\(r\\) идет после \\(m\\), исключаем первую половину словаря, и область поиска сужается до второй половины.</li> <li>Продолжайте повторять шаги <code>1.</code> и <code>2.</code> , пока не найдете страницу, где первой буквой слов будет \\(r\\).</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 1-1   Этапы поиска в словаре. Шаг 1 </p> <p>Навык поиска в словаре, которым владеет каждый школьник, на самом деле является известным алгоритмом двоичного поиска. С точки зрения структуры данных словарь можно рассматривать как отсортированный массив; с точки зрения алгоритма последовательность операций по поиску в словаре можно считать двоичным поиском.</p> <p>Пример 2: упорядочивание карт. Во время игры в карты необходимо каждый раз упорядочивать карты в руке от меньшего к большему. Для этого нужно выполнить следующие действия.</p> <ol> <li>Разделите карты на упорядоченную и неупорядоченную части, предполагая, что изначально самая левая карта уже упорядочена.</li> <li>Из неупорядоченной части извлеките одну карту и вставьте ее в правильное место в упорядоченной части; после этого две самые левые карты станут упорядоченными.</li> <li>Повторяйте шаг <code>2.</code> , каждый раз перемещая одну карту из неупорядоченной части в упорядоченную, пока все карты не станут упорядоченными.</li> </ol> <p></p> <p> Рисунок 1-2   Этапы упорядочивания карт </p> <p>Метод упорядочивания карт по своей сути является алгоритмом сортировки вставками, который весьма эффективен при обработке небольших наборов данных. Многие функции сортировки в библиотеках программирования используют именно этот алгоритм.</p> <p>Пример 3: сдача. Предположим, что в супермаркете мы купили товар стоимостью \\(69\\) руб. и дали кассиру купюру в \\(100\\) руб. Кассир должен вернуть нам \\(31\\) руб. Для этого ему нужно выполнить следующие действия.</p> <ol> <li>Варианты выбора - это купюры номиналом меньше \\(31\\) руб. Пусть у нас имеются номиналы \\(1\\) , \\(5\\) , \\(10\\) и \\(20\\) руб.</li> <li>Возьмем самую крупную доступную купюру в \\(20\\) руб. Остаток сдачи составит \\(31 - 20 = 11\\) руб.</li> <li>Возьмем самую крупную из оставшихся купюр в \\(10\\) руб. Остаток составит \\(11 - 10 = 1\\) руб.</li> <li>Возьмем самую крупную из оставшихся купюр в \\(1\\) руб. Остаток составит \\(1 - 1 = 0\\) руб.</li> <li>Завершим выдачу сдачи, схема: \\(20 + 10 + 1 = 31\\) руб.</li> </ol> <p></p> <p> Рисунок 1-3   Этапы выдачи сдачи </p> <p>В этих шагах мы на каждом этапе выбираем наилучший вариант, используя купюры наибольшего номинала, и в итоге получаем рабочую схему сдачи. С точки зрения структуры данных и алгоритмов этот метод по своей сути является жадным алгоритмом.</p> <p>От приготовления блюда до межзвездных путешествий решение практически любой задачи неразрывно связано с алгоритмами. Появление компьютеров позволило нам с помощью программирования хранить структуры данных в памяти, а также писать код для вызовов к CPU и GPU для выполнения алгоритмов. Таким образом, мы можем переносить задачи из реальной жизни в компьютер и решать различные сложные проблемы более эффективно.</p> <p>Tip</p> <p>Если представление о структурах данных, алгоритмах, массивах и двоичном поиске пока остается расплывчатым, просто продолжайте читать. Эта книга постепенно введет вас в мир структур данных и алгоритмов.</p>","path":["Глава 1. Введение в алгоритмы","1.1 &nbsp; Алгоритмы повсюду"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   Резюме","text":"","path":["Глава 1. Введение в алгоритмы","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Алгоритмы повсеместно присутствуют в нашей повседневной жизни и не являются недосягаемыми сложными знаниями. На самом деле мы уже освоили множество алгоритмов, которые помогают решать различные жизненные задачи.</li> <li>Принцип поиска в словаре соответствует алгоритму двоичного поиска. Двоичный поиск иллюстрирует важную идею алгоритмов \"разделяй и властвуй\".</li> <li>Процесс сортировки карт в колоде очень похож на алгоритм сортировки вставками, который хорошо подходит для сортировки небольших наборов данных.</li> <li>Процесс размена по своей сути является жадным алгоритмом, в котором на каждом этапе принимается наилучшее на данный момент решение.</li> <li>Алгоритм представляет собой набор инструкций или шагов, предназначенных для решения конкретной задачи в ограниченное время, а структура данных - это способ организации и хранения данных в компьютере.</li> <li>Структуры данных и алгоритмы тесно связаны. Структуры данных являются основой для алгоритмов, а алгоритмы оживляют структуры данных.</li> <li>Структуры данных и алгоритмы можно сравнить с конструктором: детали конструктора представляют данные, их форма и способы соединения - структуры данных, а этапы сборки конструктора соответствуют алгоритмам.</li> </ul>","path":["Глава 1. Введение в алгоритмы","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Я программист и в повседневной работе никогда не использовал алгоритмы для решения задач, поскольку часто используемые алгоритмы уже встроены в языки программирования и ими можно пользоваться напрямую. Значит ли это, что рабочие задачи еще не требуют применения алгоритмов?</p> <p>Если сравнить конкретные профессиональные навыки с приемами в боевых искусствах, то базовые дисциплины скорее напоминают \"внутреннюю силу\".</p> <p>Я считаю, что изучение алгоритмов и других базовых дисциплин важно не для того, чтобы реализовывать их с нуля в работе, а для того, чтобы на основе полученных знаний принимать профессиональные решения и оценки при решении задач, тем самым повышая общее качество работы. Простой пример: каждый язык программирования имеет встроенные функции сортировки.</p> <ul> <li>Если бы мы не изучали структуры данных и алгоритмы, то, получив любые данные, возможно, просто передали бы их этой функции сортировки. Все работает гладко, производительность хорошая, и на первый взгляд проблем нет.</li> <li>Однако если мы изучили алгоритмы, то знаем, что временная сложность встроенной функции сортировки составляет \\(O(n \\log n)\\) ; если же данные представлены целыми числами фиксированной разрядности, например номерами студентов, то можно использовать более эффективный метод поразрядной сортировки, снизив временную сложность до \\(O(nk)\\) , где \\(k\\) - это количество разрядов, а при больших объемах данных выиграть во времени, затратах и пользовательском опыте.</li> </ul> <p>В инженерной практике множество задач трудно решить оптимальным образом, и многие из них решаются \"как-то\". Сложность задачи зависит как от ее природы, так и от уровня знаний и опыта человека, который ее анализирует. Чем более полными знаниями и большим опытом обладает человек, тем глубже он может проанализировать проблему и тем изящнее может быть ее решение.</p>","path":["Глава 1. Введение в алгоритмы","1.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   Что такое алгоритм","text":"","path":["Глава 1. Введение в алгоритмы","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   Определение алгоритма","text":"<p>Алгоритм (algorithm) - это набор инструкций или шагов, предназначенных для решения конкретной задачи за ограниченное время. Он обладает следующими свойствами.</p> <ul> <li>Задача четко определена и включает ясные определения входных и выходных данных.</li> <li>Обладает осуществимостью и может быть выполнен за ограниченное количество шагов, времени и памяти.</li> <li>Каждый шаг имеет определенное значение, и при одинаковых входных данных и условиях выполнения результат всегда будет одинаковым.</li> </ul>","path":["Глава 1. Введение в алгоритмы","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   Определение структуры данных","text":"<p>Структура данных (data structure) - это способ организации и хранения данных, включающий содержимое данных, их взаимосвязи и методы операций с ними. Структура данных преследует следующие цели.</p> <ul> <li>Минимизировать занимаемое пространство для экономии памяти компьютера.</li> <li>Обеспечивать максимально быструю обработку данных, включая доступ, добавление, удаление и обновление данных.</li> <li>Обеспечивать простое представление данных и логическую информацию для эффективного выполнения алгоритмов.</li> </ul> <p>Проектирование структуры данных - это процесс, полный компромиссов. Если вы хотите улучшить один аспект, часто приходится идти на уступки в другом. Приведем два примера.</p> <ul> <li>Связный список, по сравнению с массивом, более удобен для добавления и удаления данных, но имеет проблемы со скоростью доступа к данным.</li> <li>Граф, по сравнению со связным списком, предоставляет более богатую логическую информацию, но требует большего объема памяти.</li> </ul>","path":["Глава 1. Введение в алгоритмы","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   Связь между структурами данных и алгоритмами","text":"<p>Как показано на рисунке 1-4, структуры данных и алгоритмы тесно взаимосвязаны, что проявляется в следующих трех аспектах.</p> <ul> <li>Структуры данных являются основой алгоритмов. Они обеспечивают структурированное хранение данных и методы их обработки.</li> <li>Алгоритмы оживляют структуры данных. Сами по себе структуры данных лишь хранят информацию, но в сочетании с алгоритмами они позволяют решать конкретные задачи.</li> <li>Алгоритмы можно реализовать на основе различных структур данных, однако эффективность их выполнения может значительно различаться, поэтому выбор подходящей структуры данных является ключевым фактором.</li> </ul> <p></p> <p> Рисунок 1-4   Связь между структурами данных и алгоритмами </p> <p>Структуры данных и алгоритмы подобны конструктору, как показано на рисунке 1-5. Комплект конструктора, помимо множества деталей, содержит также подробную инструкцию по сборке. Следуя этой инструкции шаг за шагом, можно собрать красивую модель.</p> <p></p> <p> Рисунок 1-5   Сборка конструктора </p> <p>Подробное описание аналогии с конструктором представлено в таблице 1-1.</p> <p> Таблица 1-1   Сравнение структур данных и алгоритмов с конструктором </p> Структуры данных и алгоритмы Конструктор Входные данные Несобранные детали конструктора Структура данных Организация деталей конструктора, включая форму, размер, способы соединения и т. д. Алгоритм Последовательность действий по сборке деталей в целевую модель Выходные данные Собранная модель конструктора <p>Стоит отметить, что структуры данных и алгоритмы не зависят от языка программирования. Именно поэтому данная книга предлагает их реализации на различных языках.</p> <p>Принятое сокращение</p> <p>В реальных обсуждениях выражение \"структуры данных и алгоритмы\" обычно сокращают до просто \"алгоритмы\". Например, хорошо известные задачи LeetCode на деле одновременно проверяют знания и по структурам данных, и по алгоритмам.</p>","path":["Глава 1. Введение в алгоритмы","1.2 &nbsp; Что такое алгоритм"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"Глава 0.   Предисловие","text":"<p>Abstract</p> <p>Алгоритмы подобны прекрасной симфонии, а каждая строка кода льется подобно мелодии.</p> <p>Пусть эта книга тихо зазвучит в вашем сознании и оставит после себя особую и глубокую мелодию.</p>","path":["Глава 0. Предисловие","Глава 0. &nbsp; Предисловие"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>0.1   Об этой книге</li> <li>0.2   Как пользоваться этой книгой</li> <li>0.3   Резюме</li> </ul>","path":["Глава 0. Предисловие","Глава 0. &nbsp; Предисловие"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   Об этой книге","text":"<p>Этот проект задуман как открытое, бесплатное и дружелюбное к новичкам введение в структуры данных и алгоритмы.</p> <ul> <li>В книге используются анимированные иллюстрации: материал изложен ясно и последовательно, что облегчает освоение и помогает начинающим выстроить карту знаний по структурам данных и алгоритмам.</li> <li>Исходный код можно запустить одним нажатием, что позволяет тренироваться, развивать навыки программирования и понимать принципы работы алгоритмов и реализации структур данных на фундаментальном уровне.</li> <li>Мы призываем читателей к взаимопомощи: задавайте вопросы и делитесь идеями в комментариях. Обсуждения помогают двигаться вперед всем вместе.</li> </ul>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   Целевая аудитория","text":"<p>Если вы новичок в алгоритмах, никогда с ними не сталкивались или уже имеете некоторый опыт решения задач, но еще не обладаете четким пониманием структур данных и алгоритмов, эта книга создана специально для вас!</p> <p>Если у вас уже есть определенный опыт решения задач и вы знакомы с большинством типов задач, эта книга поможет вам освежить и систематизировать знания об алгоритмах, а исходный код может служить набором инструментов для решения задач или алгоритмическим словарем.</p> <p>Если вы владеете алгоритмами на экспертном уровне, мы будем рады вашим ценным советам или совместному участию в создании книги.</p> <p>Предварительные требования</p> <p>Необходимо иметь хотя бы базовую подготовку в одном из языков программирования, чтобы читать и писать простой код.</p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   Структура содержания","text":"<p>Основное содержание книги представлено на рисунке 0-1.</p> <ul> <li>Анализ сложности: критерии и методы оценки структур данных и алгоритмов. Методы расчета временной и пространственной сложности, распространенные типы, примеры и т. д.</li> <li>Структуры данных: классификация основных типов данных и структур данных. Определение, преимущества и недостатки, основные операции, распространенные типы, типичные приложения и методы реализации массивов, списков, стеков, очередей, хеш-таблиц, деревьев, куч и графов.</li> <li>Алгоритмы: определение, преимущества и недостатки, эффективность, области применения, этапы решения и примеры задач для поиска, сортировки, алгоритма \"разделяй и властвуй\", поиска с возвратом, динамического программирования и жадных алгоритмов.</li> </ul> <p></p> <p> Рисунок 0-1   Основное содержание книги </p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   Благодарности","text":"<p>Эта книга постоянно совершенствуется благодаря совместным усилиям множества участников открытого сообщества. Благодарим каждого автора, вложившего свое время и силы; их имена перечислены в порядке, автоматически сгенерированном GitHub: krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, rongyi, msk397, gvenusleo, khoaxuantu, rivertwilight, K3v123, gyt95, zhuoqinyue, yuelinxin, Zuoxun, mingXta, Phoenix0415, FangYuan33, GN-Yu, longsizhuo, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, pengchzn, QiLOL, magentaqin, hello-ikun, JoseHung, qualifier1024, thomasq0, sunshinesDL, L-Super, Guanngxu, Transmigration-zhou, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, Shyam-Chen, theNefelibatas, longranger2, codeberg-user, xiongsp, JeffersonHuang, prinpal, seven1240, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, SamJin98, hongyun-robot, nanlei, XiaChuerwu, yd-j, iron-irax, mgisr, steventimes, junminhong, heshuyue, danny900714, MolDuM, Nigh, Dr-XYZ, XC-Zero, reeswell, PXG-XPG, NI-SW, Horbin-Magician, Enlightenus, YangXuanyi, beatrix-chan, DullSword, xjr7670, jiaxianhua, qq909244296, iStig, boloboloda, hts0000, gledfish, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, linyejoe2, liuxjerry, llql1211, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, ZhongGuanbin, hezhizhen, linzeyan, ZJKung, luluxia, xb534, ztkuaikuai, yw-1021, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yanedie, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, lyl625760, lucaswangdev, 0130w, shanghai-Jerry, EJackYang, Javesun99, eltociear, lipusheng, KNChiu, BlindTerran, ShiMaRing, lovelock, FreddieLi, FloranceYeh, fanchenggang, gltianwen, goerll, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, Asashishi, Asa0oo0o0o, fanenr, eagleanurag, akshiterate, 52coder, foursevenlove, KorsChen, GaochaoZhu, hopkings2008, yang-le, realwujing, Evilrabbit520, Umer-Jahangir, Turing-1024-Lee, Suremotoo, paoxiaomooo, Chieko-Seren, Allen-Scai, ymmmas, Risuntsy, Richard-Zhang1019, RafaelCaso, qingpeng9802, primexiao, Urbaner3, zhongfq, nidhoggfgg, MwumLi, CreatorMetaSky, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai и KawaiiAsh.</p> <p>Рецензирование кода книги выполнили coderonion, curtishd, Gonglja, gvenusleo, hpstory, justin-tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon и rongyi (в алфавитном порядке). Благодарим их за потраченное время и силы, которые обеспечили стандартизацию и единообразие кода на различных языках.</p> <p>Традиционную китайскую версию книги вычитали Shyam-Chen и Dr-XYZ, английскую версию - yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0 и magentaqin, а японскую версию - eltociear. Именно благодаря их постоянному вкладу эта книга может служить более широкому кругу читателей, и мы искренне благодарим их.</p> <p>Инструмент генерации ePub-версии этой книги разработал zhongfq. Благодарим его за вклад, который дал читателям более свободный способ чтения.</p> <p>В процессе создания этой книги мне помогало много людей.</p> <ul> <li>Благодарю моего наставника в компании, доктора Ли Си: в одной из бесед вы вдохновили меня быстрее начать, что укрепило мою решимость написать эту книгу;</li> <li>Благодарю мою девушку Bubble, первого читателя этой книги: с позиции новичка в алгоритмах она дала много ценных советов, благодаря которым книга стала более понятной и доступной;</li> <li>Благодарю Tengbao, Qibao и Feibao за креативное название книги, которое навевает приятные воспоминания о первой строке кода \"Hello World!\";</li> <li>Благодарю Xiaoquan за профессиональную помощь в вопросах интеллектуальной собственности, что сыграло важную роль в совершенствовании этой открытой книги;</li> <li>Благодарю Sutong за дизайн обложки и логотипа книги, а также за терпение при многочисленных исправлениях по моим просьбам;</li> <li>Благодарю @squidfunk за советы по оформлению и за разработку открытой темы документации Material-for-MkDocs.</li> </ul> <p>В процессе написания книги я ознакомился с множеством учебников и статей по структурам данных и алгоритмам. Эти работы послужили отличным образцом для этой книги, обеспечив ее точность и качество. Я искренне благодарю всех преподавателей и предшественников за их выдающийся вклад!</p> <p>Эта книга пропагандирует метод обучения, сочетающий умственную и практическую деятельность; в этом отношении на меня сильно повлияла Dive into Deep Learning. Я настоятельно рекомендую эту замечательную работу всем читателям.</p> <p>Сердечно благодарю моих родителей: именно ваша постоянная поддержка и ободрение дали мне возможность заняться этим увлекательным делом.</p>","path":["Глава 0. Предисловие","0.1 &nbsp; Об этой книге"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   Как пользоваться этой книгой","text":"<p>Tip</p> <p>Для получения наилучшего опыта чтения рекомендуется полностью прочитать этот раздел.</p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   Соглашения о стиле изложения","text":"<ul> <li>Главы, помеченные <code>*</code> в заголовке, являются дополнительными и содержат более сложный материал. Если времени мало, их можно пропустить.</li> <li>Профессиональные термины выделяются полужирным шрифтом в печатной и PDF-версии или подчеркиванием в веб-версии, например массив (array). Рекомендуется запоминать их для удобства чтения литературы.</li> <li>Важные моменты и обобщающие фразы будут выделяться полужирным шрифтом, и на такие тексты следует обращать особое внимание.</li> <li>Слова и выражения со специальным смыслом будут отмечаться \"кавычками\", чтобы избежать неоднозначности.</li> <li>Когда термины различаются между языками программирования, в качестве стандарта используется Python; например, <code>None</code> применяется для обозначения \"пустого\" значения.</li> <li>В некоторых местах книга отходит от стандартов комментирования программного кода ради более компактного оформления. Комментарии в основном делятся на три типа: заголовочные, содержательные и многострочные.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п.\"\"\"\n\n# Содержательный комментарий: подробно поясняет код\n\n\"\"\"\nМногострочный\nкомментарий\n\"\"\"\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n// Многострочный\n// комментарий\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>/* Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. */\n\n// Содержательный комментарий: подробно поясняет код\n\n/**\n * Многострочный\n * комментарий\n */\n</code></pre> <pre><code>### Комментарий-заголовок: используется для обозначения функций, классов, тестовых примеров и т. п. ###\n\n# Содержательный комментарий: подробно поясняет код\n\n# Многострочный\n# комментарий\n</code></pre>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   Эффективное обучение с помощью анимированных иллюстраций","text":"<p>По сравнению с текстом видео и изображения обладают более высокой плотностью информации и более четкой структурой, поэтому их легче воспринимать. В этой книге ключевые и сложные моменты в основном представлены в виде анимированных иллюстраций, а текст служит пояснением и дополнением.</p> <p>Если во время чтения вы встречаете фрагмент с анимированной иллюстрацией, как на рисунке 0-2, используйте иллюстрацию в качестве основного источника информации, а текст - в качестве вспомогательного, объединяя оба источника для понимания материала.</p> <p></p> <p> Рисунок 0-2   Пример анимированной иллюстрации </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   Углубление понимания через практику кода","text":"<p>Сопроводительный код этой книги размещен в репозитории GitHub. Как показано ниже, исходный код содержит тестовые примеры и может быть запущен одним нажатием кнопки.</p> <p>Если позволяет время, рекомендуется самостоятельно набирать код. Если времени на обучение мало, по крайней мере просмотрите и выполните весь код.</p> <p>Процесс написания кода приносит больше пользы, чем его чтение. Настоящее обучение - это обучение на практике.</p> <p></p> <p> Рисунок 0-3   Пример запуска кода </p> <p>Подготовка к запуску кода в основном состоит из трех этапов.</p> <p>Шаг 1: установка локальной среды программирования. Воспользуйтесь руководством из приложения. Если среда уже установлена, этот шаг можно пропустить.</p> <p>Шаг 2: клонирование или загрузка репозитория кода. Перейдите в репозиторий GitHub. Если у вас уже установлен Git, репозиторий можно клонировать следующей командой:</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>Также можно нажать кнопку \"Download ZIP\" в месте, показанном на рисунке 0-4, напрямую скачать архив с кодом и затем распаковать его локально.</p> <p></p> <p> Рисунок 0-4   Клонирование репозитория и загрузка кода </p> <p>Шаг 3: запуск исходного кода. Как показано на рисунке 0-5, для блоков кода, у которых сверху указано имя файла, соответствующий исходный файл можно найти в папке <code>codes</code> репозитория. Исходные файлы запускаются одним нажатием, что помогает не тратить лишнее время на отладку и сосредоточиться на изучении материала.</p> <p></p> <p> Рисунок 0-5   Блоки кода и соответствующие исходные файлы </p> <p>Помимо локального запуска, веб-версия также поддерживает визуальное выполнение Python-кода (на базе pythontutor). Как показано ниже, можно нажать \"Визуализировать выполнение\" под блоком кода, чтобы раскрыть окно и наблюдать за выполнением алгоритма; также можно нажать \"Полноэкранный режим\" для более удобного просмотра.</p> <p></p> <p> Рисунок 0-6   Визуальный запуск Python-кода </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   Совместный рост через вопросы и обсуждения","text":"<p>Во время чтения книги не стоит пропускать те места, которые остались непонятными. Мы призываем вас задавать вопросы в разделе комментариев: я и мои коллеги постараемся ответить вам как можно тщательнее, обычно в течение двух дней.</p> <p>Как показано на рисунке 0-7, в веб-версии у каждой главы внизу есть раздел комментариев. Рекомендуется уделять внимание его содержанию. С одной стороны, это поможет увидеть, с какими трудностями сталкиваются другие читатели, восполнить пробелы и подтолкнуть себя к более глубокому пониманию. С другой стороны, мы надеемся, что вы будете отвечать на вопросы других участников и делиться своими мнениями.</p> <p></p> <p> Рисунок 0-7   Пример раздела комментариев </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   Дорожная карта изучения алгоритмов","text":"<p>В целом процесс изучения структур данных и алгоритмов можно разделить на три этапа.</p> <ol> <li>Этап 1: введение в алгоритмы. Необходимо познакомиться с особенностями и применением различных структур данных, изучить принципы, процессы, назначение и эффективность различных алгоритмов.</li> <li>Этап 2: решение алгоритмических задач. Рекомендуется начинать с популярных задач и решить не менее 100 из них, чтобы познакомиться с основными алгоритмическими проблемами. При первых попытках \"забывание знаний\" может стать испытанием, но это нормально. Следуйте при повторении задач \"кривой забывания Эббингауза\", и обычно после 3-5 циклов повторения материал хорошо запоминается. Рекомендуемые списки задач и планы практики см. в этом репозитории GitHub.</li> <li>Этап 3: построение системы знаний. В процессе обучения можно читать статьи по алгоритмам, изучать каркасы решений и учебники, чтобы постоянно обогащать свою систему знаний. В решении задач можно применять продвинутые стратегии, например классификацию по темам, несколько решений одной задачи или одно решение для нескольких задач; соответствующий опыт можно найти в различных сообществах.</li> </ol> <p>Как показано на рисунке 0-8, содержание этой книги в основном охватывает \"этап 1\" и призвано помочь вам более эффективно перейти к обучению на этапах 2 и 3.</p> <p></p> <p> Рисунок 0-8   Дорожная карта изучения алгоритмов </p>","path":["Глава 0. Предисловие","0.2 &nbsp; Как пользоваться этой книгой"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   Резюме","text":"","path":["Глава 0. Предисловие","0.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Основная аудитория этой книги - новички в изучении алгоритмов. Если у вас уже есть определенная база, книга поможет систематизировать знания, а исходный код послужит инструментальной библиотекой для решения задач.</li> <li>Содержание книги включает три основные части - анализ сложности, структуры данных и алгоритмы - и охватывает большинство тем в этой области.</li> <li>Для новичков в алгоритмах крайне важно изучить начальные разделы книги, чтобы избежать множества ошибок в будущем.</li> <li>Анимированные иллюстрации в книге обычно используются для представления ключевых и сложных аспектов. При чтении книги следует уделять этим материалам больше внимания.</li> <li>Практика - лучший способ изучения программирования. Настоятельно рекомендуется запускать исходный код и самостоятельно писать программы.</li> <li>В веб-версии книги каждая глава имеет область комментариев, где можно задавать вопросы и делиться своими мыслями.</li> </ul>","path":["Глава 0. Предисловие","0.3 &nbsp; Резюме"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"Список литературы","text":"<p>[1] Thomas H. Cormen и др. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick и др. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] Yan Weimin. Data Structures (C Language Edition).</p> <p>[5] Deng Junhui. Data Structures (C++ Language Edition, 3<sup>rd</sup> Edition).</p> <p>[6] Mark Allen Weiss; пер. Chen Yue. Data Structures and Algorithm Analysis: Java Description (3<sup>rd</sup> Edition).</p> <p>[7] Cheng Jie. A Plainspoken Guide to Data Structures.</p> <p>[8] Wang Zheng. The Beauty of Data Structures and Algorithms.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang и др. Dive into Deep Learning.</p>","path":["Список литературы"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"Глава 10.   Поиск","text":"<p>Abstract</p> <p>Поиск - это движение в неизвестность: иногда приходится пройти каждый уголок пространства, а иногда удается быстро найти цель.</p> <p>В этом пути каждый новый шаг может привести к ответу, которого мы не ожидали.</p>","path":["Глава 10. Поиск","Глава 10. &nbsp; Поиск"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>10.1   Двоичный поиск</li> <li>10.2   Двоичный поиск точки вставки</li> <li>10.3   Двоичный поиск границ</li> <li>10.4   Стратегии оптимизации хеширования</li> <li>10.5   Переосмысление алгоритмов поиска</li> <li>10.6   Резюме</li> </ul>","path":["Глава 10. Поиск","Глава 10. &nbsp; Поиск"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   Двоичный поиск","text":"<p>Двоичный поиск (binary search) - это эффективный алгоритм поиска, основанный на стратегии \"разделяй и властвуй\". Он использует упорядоченность данных, сокращая на каждом шаге область поиска вдвое, пока не будет найден целевой элемент или пока интервал поиска не опустеет.</p> <p>Question</p> <p>Дан массив <code>nums</code> длины \\(n\\), элементы которого расположены в порядке возрастания и не повторяются. Найдите и верните индекс элемента <code>target</code> в этом массиве. Если массив не содержит этого элемента, верните \\(-1\\) . Пример показан на рисунке 10-1.</p> <p></p> <p> Рисунок 10-1   Пример данных для двоичного поиска </p> <p>Как показано на рисунке 10-2, сначала инициализируем указатели \\(i = 0\\) и \\(j = n - 1\\) , которые указывают на первый и последний элементы массива и задают интервал поиска \\([0, n - 1]\\) . Обратите внимание: квадратные скобки обозначают замкнутый интервал и включают граничные значения.</p> <p>Далее в цикле выполняются следующие два шага.</p> <ol> <li>Вычислить индекс середины \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) , где \\(\\lfloor \\: \\rfloor\\) означает операцию округления вниз.</li> <li>Сравнить <code>nums[m]</code> и <code>target</code> , после чего возможны три случая.<ol> <li>Если <code>nums[m] &lt; target</code> , это означает, что <code>target</code> находится в интервале \\([m + 1, j]\\) , поэтому выполняется \\(i = m + 1\\) .</li> <li>Если <code>nums[m] &gt; target</code> , это означает, что <code>target</code> находится в интервале \\([i, m - 1]\\) , поэтому выполняется \\(j = m - 1\\) .</li> <li>Если <code>nums[m] = target</code> , значит, элемент <code>target</code> найден, поэтому возвращается индекс \\(m\\) .</li> </ol> </li> </ol> <p>Если массив не содержит целевой элемент, область поиска в итоге сузится до пустого интервала. В этом случае возвращается \\(-1\\) .</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 10-2   Процесс двоичного поиска </p> <p>Стоит отметить, что поскольку и \\(i\\) , и \\(j\\) имеют тип <code>int</code> , то сумма \\(i + j\\) может выйти за пределы диапазона типа <code>int</code>. Чтобы избежать переполнения, обычно используют формулу \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) для вычисления середины.</p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск (двусторонне замкнутый интервал)\"\"\"\n    # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    i, j = 0, len(nums) - 1\n    # Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j:\n        # Теоретически числа в Python могут быть сколь угодно большими (ограничены только объемом памяти), поэтому не нужно учитывать переполнение больших чисел\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # Это означает, что target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # Это означает, что target находится в интервале [i, m-1]\n        else:\n            return m  # Целевой элемент найден, вернуть его индекс\n    return -1  # Целевой элемент не найден, вернуть -1\n</code></pre> binary_search.cpp<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.size() - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(int[] nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint BinarySearch(int[] nums, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = nums.Length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // Вычислить индекс середины m\n        if (nums[m] &lt; target)      // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else                       // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunc binarySearch(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    i, j := 0, len(nums)-1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    for i &lt;= j {\n        m := i + (j-i)/2      // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunction binarySearch(nums, target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let i = 0,\n        j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        // Вычислить индекс середины m, используя parseInt() для округления вниз\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else return m; // Целевой элемент найден, вернуть его индекс\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfunction binarySearch(nums: number[], target: number): number {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let i = 0,\n        j = nums.length - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        // Вычислить индекс середины m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    return -1; // Целевой элемент не найден, вернуть -1\n}\n</code></pre> binary_search.dart<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n  int i = 0, j = nums.length - 1;\n  // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      // Это означает, что target находится в интервале [m+1, j]\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // Это означает, что target находится в интервале [i, m-1]\n      j = m - 1;\n    } else {\n      // Целевой элемент найден, вернуть его индекс\n      return m;\n    }\n  }\n  // Целевой элемент не найден, вернуть -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nint binarySearch(int *nums, int len, int target) {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    int i = 0, j = len - 1;\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Бинарный поиск (двусторонне замкнутый интервал) */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n    var i = 0\n    var j = nums.size - 1\n    // Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j]\n            i = m + 1\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m-1]\n            j = m - 1\n        else  // Целевой элемент найден, вернуть его индекс\n            return m\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Бинарный поиск (двусторонне замкнутый интервал) ###\ndef binary_search(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно\n  i, j = 0, nums.length - 1\n\n  # Цикл завершается, когда диапазон поиска пуст (при i &gt; j диапазон пуст)\n  while i &lt;= j\n    # Теоретически числа в Ruby могут быть сколь угодно большими (ограничены только объемом памяти), поэтому не нужно учитывать переполнение больших чисел\n    m = (i + j) / 2   # Вычислить индекс середины m\n\n    if nums[m] &lt; target\n      i = m + 1 # Это означает, что target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # Это означает, что target находится в интервале [i, m-1]\n    else\n      return m  # Целевой элемент найден, вернуть его индекс\n    end\n  end\n\n  -1  # Целевой элемент не найден, вернуть -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Временная сложность равна \\(O(\\log n)\\) : в цикле двоичного поиска интервал каждый раз сокращается вдвое, поэтому число итераций равно \\(\\log_2 n\\) .</p> <p>Пространственная сложность равна \\(O(1)\\) : указатели \\(i\\) и \\(j\\) занимают константный объем памяти.</p>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   Методы представления интервалов","text":"<p>Помимо описанного выше двойного замкнутого интервала, часто используется и левозамкнутый правооткрытый интервал, который задается как \\([0, n)\\) , то есть левая граница включается, а правая - нет. В этом представлении интервал \\([i, j)\\) пуст, когда \\(i = j\\) .</p> <p>На основе этого представления можно реализовать двоичный поиск с той же функциональностью:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск (лево замкнутый, право открытый интервал)\"\"\"\n    # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    i, j = 0, len(nums)\n    # Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # Это означает, что target находится в интервале [m+1, j)\n        elif nums[m] &gt; target:\n            j = m  # Это означает, что target находится в интервале [i, m)\n        else:\n            return m  # Целевой элемент найден, вернуть его индекс\n    return -1  # Целевой элемент не найден, вернуть -1\n</code></pre> binary_search.cpp<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.size();\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(int[] nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint BinarySearchLCRO(int[] nums, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = nums.Length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // Вычислить индекс середины m\n        if (nums[m] &lt; target)      // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else                       // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    i, j := 0, len(nums)\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    for i &lt; j {\n        m := i + (j-i)/2      // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m)\n            j = m\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target { // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        } else if nums[m] &gt; target { // Это означает, что target находится в интервале [i, m)\n            j = m\n        } else { // Целевой элемент найден, вернуть его индекс\n            return m\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunction binarySearchLCRO(nums, target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let i = 0,\n        j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        // Вычислить индекс середины m, используя parseInt() для округления вниз\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        // Целевой элемент найден, вернуть его индекс\n        else return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let i = 0,\n        j = nums.length;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        // Вычислить индекс середины m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    return -1; // Целевой элемент не найден, вернуть -1\n}\n</code></pre> binary_search.dart<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n  int i = 0, j = nums.length;\n  // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      // Это означает, что target находится в интервале [m+1, j)\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // Это означает, что target находится в интервале [i, m)\n      j = m;\n    } else {\n      // Целевой элемент найден, вернуть его индекс\n      return m;\n    }\n  }\n  // Целевой элемент не найден, вернуть -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while i &lt; j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // Это означает, что target находится в интервале [i, m)\n            j = m;\n        } else {\n            // Целевой элемент найден, вернуть его индекс\n            return m;\n        }\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    int i = 0, j = len;\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target)    // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1;\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m;\n        else // Целевой элемент найден, вернуть его индекс\n            return m;\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* Бинарный поиск (лево замкнутый, право открытый интервал) */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n    var i = 0\n    var j = nums.size\n    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) // Это означает, что target находится в интервале [m+1, j)\n            i = m + 1\n        else if (nums[m] &gt; target) // Это означает, что target находится в интервале [i, m)\n            j = m\n        else  // Целевой элемент найден, вернуть его индекс\n            return m\n    }\n    // Целевой элемент не найден, вернуть -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### Бинарный поиск (лево замкнутый, право открытый интервал) ###\ndef binary_search_lcro(nums, target)\n  # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно\n  i, j = 0, nums.length\n\n  # Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)\n  while i &lt; j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # Это означает, что target находится в интервале [m+1, j)\n    elsif nums[m] &gt; target\n      j = m - 1 # Это означает, что target находится в интервале [i, m)\n    else\n      return m  # Целевой элемент найден, вернуть его индекс\n    end\n  end\n\n  -1  # Целевой элемент не найден, вернуть -1\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как показано на рисунке 10-3, в этих двух вариантах представления интервала различаются инициализация, условие цикла и операция сужения интервала в алгоритме двоичного поиска.</p> <p>Поскольку в записи \"двойной замкнутый интервал\" обе границы являются закрытыми, операции сужения интервала при помощи указателей \\(i\\) и \\(j\\) тоже получаются симметричными. Из-за этого в таком варианте сложнее допустить ошибку, поэтому обычно рекомендуется использовать именно запись \"двойной замкнутый интервал\".</p> <p></p> <p> Рисунок 10-3   Два определения интервалов </p>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   Преимущества и ограничения","text":"<p>Двоичный поиск показывает хорошие результаты и по времени, и по памяти.</p> <ul> <li>Двоичный поиск очень эффективен по времени. На больших объемах данных логарифмическая временная сложность дает заметное преимущество. Например, когда размер данных \\(n = 2^{20}\\) , линейный поиск потребует \\(2^{20} = 1048576\\) итераций, тогда как двоичный поиск выполнится всего за \\(\\log_2 2^{20} = 20\\) итераций.</li> <li>Двоичный поиск не требует дополнительной памяти. По сравнению с алгоритмами поиска, которым нужно внешнее пространство (например, с хеш-поиском), двоичный поиск заметно экономнее по памяти.</li> </ul> <p>Однако двоичный поиск подходит не для всех ситуаций, и основные причины таковы.</p> <ul> <li>Двоичный поиск применим только к упорядоченным данным. Если входные данные неупорядочены, специально сортировать их ради двоичного поиска невыгодно. Это связано с тем, что временная сложность алгоритмов сортировки обычно составляет \\(O(n \\log n)\\) , что выше, чем у линейного и двоичного поиска. Если элементы приходится часто вставлять, то для сохранения порядка в массиве их нужно помещать в конкретные позиции, а это требует \\(O(n)\\) времени и тоже обходится дорого.</li> <li>Двоичный поиск применим только к массивам. Для него нужен скачкообразный доступ к элементам, а в связном списке такой доступ малоэффективен, поэтому двоичный поиск не подходит для списков и структур данных, построенных на их основе.</li> <li>При малом объеме данных линейный поиск работает лучше. В линейном поиске на каждом шаге нужна всего одна операция сравнения; в двоичном поиске требуется 1 сложение, 1 деление, от 1 до 3 сравнений и еще 1 сложение или вычитание, то есть всего от 4 до 6 элементарных операций. Поэтому при небольшом \\(n\\) линейный поиск может оказаться быстрее двоичного.</li> </ul>","path":["Глава 10. Поиск","10.1 &nbsp; Двоичный поиск"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   Двоичный поиск границ","text":"","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   Поиск левой границы","text":"<p>Question</p> <p>Дан упорядоченный массив <code>nums</code> длины \\(n\\), который может содержать повторяющиеся элементы. Верните индекс самого левого элемента <code>target</code> в массиве. Если массив не содержит этот элемент, верните \\(-1\\) .</p> <p>Вспомним метод поиска точки вставки при двоичном поиске: после завершения поиска указатель \\(i\\) указывает на самый левый <code>target</code> , поэтому поиск точки вставки по сути является поиском индекса самого левого <code>target</code>.</p> <p>Рассмотрим реализацию поиска левой границы через функцию поиска точки вставки. Обратите внимание: массив может не содержать <code>target</code> , и тогда возможны две ситуации.</p> <ul> <li>Индекс точки вставки \\(i\\) выходит за границы массива.</li> <li>Элемент <code>nums[i]</code> не равен <code>target</code> .</li> </ul> <p>Если возникает любая из этих ситуаций, достаточно сразу вернуть \\(-1\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск самого левого target\"\"\"\n    # Эквивалентно поиску точки вставки target\n    i = binary_search_insertion(nums, target)\n    # target не найден, вернуть -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # Найти target и вернуть индекс i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Бинарный поиск самого левого target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Бинарный поиск самого левого target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // Эквивалентно поиску точки вставки target\n    i := binarySearchInsertion(nums, target)\n    // target не найден, вернуть -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Бинарный поиск самого левого target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // Эквивалентно поиску точки вставки target\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // target не найден, вернуть -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* Бинарный поиск самого левого target */\nfunction binarySearchLeftEdge(nums, target) {\n    // Эквивалентно поиску точки вставки target\n    const i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Бинарный поиск самого левого target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Эквивалентно поиску точки вставки target\n    const i = binarySearchInsertion(nums, target);\n    // target не найден, вернуть -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // Эквивалентно поиску точки вставки target\n  int i = binarySearchInsertion(nums, target);\n  // target не найден, вернуть -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // Найти target и вернуть индекс i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Бинарный поиск самого левого target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Эквивалентно поиску точки вставки target\n    let i = binary_search_insertion(nums, target);\n    // target не найден, вернуть -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* Бинарный поиск самого левого target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // Эквивалентно поиску точки вставки target\n    int i = binarySearchInsertion(nums, numSize, target);\n    // target не найден, вернуть -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Бинарный поиск самого левого target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // Эквивалентно поиску точки вставки target\n    val i = binarySearchInsertion(nums, target)\n    // target не найден, вернуть -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // Найти target и вернуть индекс i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### Бинарный поиск самого левого target ###\ndef binary_search_left_edge(nums, target)\n  # Эквивалентно поиску точки вставки target\n  i = binary_search_insertion(nums, target)\n\n  # target не найден, вернуть -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # Найти target и вернуть индекс i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   Поиск правой границы","text":"<p>Как тогда найти самый правый <code>target</code> ? Самый прямой способ - изменить код, заменив операцию сужения указателя в случае <code>nums[m] == target</code> . Мы не будем приводить этот код, заинтересованные читатели могут реализовать его самостоятельно.</p> <p>Ниже представлены два более изящных способа.</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   Повторное использование поиска левой границы","text":"<p>На самом деле функцию поиска самого левого элемента можно использовать и для поиска самого правого элемента. Конкретная идея такова: преобразовать поиск самого правого <code>target</code> в поиск самого левого <code>target + 1</code>.</p> <p>Как показано на рисунке 10-7, после завершения поиска указатель \\(i\\) указывает на самый левый <code>target + 1</code> (если он существует), а указатель \\(j\\) указывает на самый правый <code>target</code> , поэтому достаточно вернуть \\(j\\).</p> <p></p> <p> Рисунок 10-7   Преобразование поиска правой границы в поиск левой </p> <p>Обратите внимание: функция возвращает точку вставки \\(i\\) , поэтому из нее нужно вычесть \\(1\\) , чтобы получить \\(j\\) :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск самого правого target\"\"\"\n    # Преобразовать задачу в поиск самого левого target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j указывает на самый правый target, а i — на первый элемент больше target\n    j = i - 1\n    # target не найден, вернуть -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # Найти target и вернуть индекс j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* Бинарный поиск самого правого target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* Бинарный поиск самого правого target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    j := i - 1\n    // target не найден, вернуть -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* Бинарный поиск самого правого target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    let j = i - 1\n    // target не найден, вернуть -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* Бинарный поиск самого правого target */\nfunction binarySearchRightEdge(nums, target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    const j = i - 1;\n    // target не найден, вернуть -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* Бинарный поиск самого правого target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // Преобразовать задачу в поиск самого левого target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    const j = i - 1;\n    // target не найден, вернуть -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // Преобразовать задачу в поиск самого левого target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j указывает на самый правый target, а i — на первый элемент больше target\n  int j = i - 1;\n  // target не найден, вернуть -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // Найти target и вернуть индекс j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* Бинарный поиск самого правого target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // Преобразовать задачу в поиск самого левого target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    let j = i - 1;\n    // target не найден, вернуть -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* Бинарный поиск самого правого target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // Преобразовать задачу в поиск самого левого target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    int j = i - 1;\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // Найти target и вернуть индекс j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* Бинарный поиск самого правого target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // Преобразовать задачу в поиск самого левого target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j указывает на самый правый target, а i — на первый элемент больше target\n    val j = i - 1\n    // target не найден, вернуть -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // Найти target и вернуть индекс j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### Бинарный поиск самого правого target ###\ndef binary_search_right_edge(nums, target)\n  # Преобразовать задачу в поиск самого левого target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j указывает на самый правый target, а i — на первый элемент больше target\n  j = i - 1\n\n  # target не найден, вернуть -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # Найти target и вернуть индекс j\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   Преобразование в поиск элемента","text":"<p>Мы знаем, что если массив не содержит <code>target</code> , то в конце поиска указатели \\(i\\) и \\(j\\) будут указывать соответственно на первый элемент, больший <code>target</code> , и на первый элемент, меньший <code>target</code> .</p> <p>Следовательно, как показано на рисунке 10-8, для поиска левой и правой границы можно сконструировать элемент, которого нет в массиве.</p> <ul> <li>Поиск самого левого <code>target</code> : можно преобразовать в поиск <code>target - 0.5</code> и вернуть указатель \\(i\\) .</li> <li>Поиск самого правого <code>target</code> : можно преобразовать в поиск <code>target + 0.5</code> и вернуть указатель \\(j\\) .</li> </ul> <p></p> <p> Рисунок 10-8   Преобразование поиска границ в поиск элемента </p> <p>Код здесь опущен, но стоит обратить внимание на два момента.</p> <ul> <li>По условию массив не содержит дробных чисел, поэтому нам не нужно беспокоиться о том, как обрабатывать случай равенства другим элементам массива.</li> <li>Поскольку этот метод вводит дробные числа, переменную <code>target</code> в функции нужно изменить на тип с плавающей запятой (в Python менять ничего не требуется).</li> </ul>","path":["Глава 10. Поиск","10.3 &nbsp; Двоичный поиск границ"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   Двоичный поиск точки вставки","text":"<p>Двоичный поиск можно использовать не только для поиска целевого элемента, но и для решения многих вариаций задачи, например для поиска позиции вставки целевого элемента.</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   Случай без повторяющихся элементов","text":"<p>Question</p> <p>Дан упорядоченный массив <code>nums</code> длины \\(n\\) и элемент <code>target</code> , причем в массиве нет повторяющихся элементов. Нужно вставить <code>target</code> в массив <code>nums</code> , сохранив порядок. Если элемент <code>target</code> уже присутствует в массиве, вставьте его слева от него. Верните индекс, который будет иметь <code>target</code> после вставки. Пример показан на рисунке 10-4.</p> <p></p> <p> Рисунок 10-4   Пример данных для точки вставки </p> <p>Если мы хотим переиспользовать код двоичного поиска из предыдущего раздела, нужно ответить на два вопроса.</p> <p>Вопрос 1: если массив содержит <code>target</code> , будет ли индекс вставки совпадать с индексом этого элемента?</p> <p>По условию <code>target</code> нужно вставить слева от равного элемента, а это означает, что новый <code>target</code> занимает место старого <code>target</code> . Иначе говоря, если массив содержит <code>target</code> , то индекс вставки совпадает с индексом этого <code>target</code>.</p> <p>Вопрос 2: если массив не содержит <code>target</code> , индекс какого элемента будет точкой вставки?</p> <p>Рассмотрим процесс двоичного поиска подробнее: когда <code>nums[m] &lt; target</code> , указатель \\(i\\) сдвигается вправо и тем самым приближается к элементу, который больше либо равен <code>target</code> . Аналогично указатель \\(j\\) постепенно приближается к элементу, который меньше либо равен <code>target</code> .</p> <p>Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель \\(i\\) указывает на первый элемент, больший <code>target</code> , а указатель \\(j\\) указывает на первый элемент, меньший <code>target</code> . Нетрудно сделать вывод, что если массив не содержит <code>target</code> , то индекс вставки равен \\(i\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск точки вставки (без повторяющихся элементов)\"\"\"\n    i, j = 0, len(nums) - 1  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target находится в интервале [i, m-1]\n        else:\n            return m  # Найти target и вернуть точку вставки m\n    # target не найден, вернуть точку вставки i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Вычислить индекс середины m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target находится в интервале [i, m-1]\n            j = m - 1\n        } else {\n            // Найти target и вернуть точку вставки m\n            return m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            return m // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target находится в интервале [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target находится в интервале [i, m-1]\n    } else {\n      return m; // Найти target и вернуть точку вставки m\n    }\n  }\n  // target не найден, вернуть точку вставки i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m;\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            return m; // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Бинарный поиск точки вставки (без повторяющихся элементов) */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            return m // Найти target и вернуть точку вставки m\n        }\n    }\n    // target не найден, вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Бинарный поиск точки вставки (без повторяющихся элементов) ###\ndef binary_search_insertion_simple(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target находится в интервале [i, m-1]\n    else\n      return m  # Найти target и вернуть точку вставки m\n    end\n  end\n\n  i # target не найден, вернуть точку вставки i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   Случай с повторяющимися элементами","text":"<p>Question</p> <p>В предыдущей задаче теперь допускается, что массив может содержать повторяющиеся элементы, а все остальные условия остаются без изменений.</p> <p>Если в массиве есть несколько элементов <code>target</code> , то обычный двоичный поиск сможет вернуть индекс только одного из них, но не позволит определить, сколько элементов <code>target</code> находится слева и справа от него.</p> <p>По условию целевой элемент нужно вставить в самую левую позицию, поэтому нам нужно найти индекс самого левого <code>target</code> в массиве. На первом этапе можно рассмотреть решение, показанное на рисунке 10-5.</p> <ol> <li>Выполнить двоичный поиск и получить индекс любого элемента <code>target</code> , обозначив его как \\(k\\) .</li> <li>Начиная с индекса \\(k\\) , линейно двигаться влево и вернуть результат, когда будет найден самый левый <code>target</code> .</li> </ol> <p></p> <p> Рисунок 10-5   Линейный поиск точки вставки среди повторяющихся элементов </p> <p>Этот метод применим на практике, однако в нем есть линейный поиск, поэтому его временная сложность равна \\(O(n)\\) . Когда в массиве имеется много повторяющихся <code>target</code> , такой подход работает неэффективно.</p> <p>Теперь рассмотрим расширение кода двоичного поиска. Как показано на рисунке 10-6, общий процесс остается прежним: на каждом шаге мы сначала вычисляем индекс середины \\(m\\) , а затем сравниваем <code>target</code> и <code>nums[m]</code> , после чего возможны следующие случаи.</p> <ul> <li>Когда <code>nums[m] &lt; target</code> или <code>nums[m] &gt; target</code> , это означает, что <code>target</code> еще не найден, поэтому используется стандартная операция сужения интервала в двоичном поиске, благодаря чему указатели \\(i\\) и \\(j\\) приближаются к <code>target</code>.</li> <li>Когда <code>nums[m] == target</code> , это означает, что элементы меньше <code>target</code> находятся в интервале \\([i, m - 1]\\) , поэтому мы используем \\(j = m - 1\\) для сужения интервала, тем самым приближая указатель \\(j\\) к элементам, меньшим <code>target</code>.</li> </ul> <p>После завершения цикла указатель \\(i\\) будет указывать на самый левый <code>target</code> , а указатель \\(j\\) - на первый элемент, меньший <code>target</code> , поэтому индекс \\(i\\) и является точкой вставки.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 10-6   Шаги поиска точки вставки для повторяющихся элементов </p> <p>Если посмотреть на следующий код, то видно, что действия в ветвях <code>nums[m] &gt; target</code> и <code>nums[m] == target</code> совпадают, поэтому эти две ветви можно объединить.</p> <p>Даже в этом случае можно оставить условия развернутыми, потому что так логика выглядит более ясной и код легче читать.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"Бинарный поиск точки вставки (с повторяющимися элементами)\"\"\"\n    i, j = 0, len(nums) - 1  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # Вычислить индекс середины m\n        if nums[m] &lt; target:\n            i = m + 1  # target находится в интервале [m+1, j]\n        elif nums[m] &gt; target:\n            j = m - 1  # target находится в интервале [i, m-1]\n        else:\n            j = m - 1  # Первый элемент меньше target находится в интервале [i, m-1]\n    # Вернуть точку вставки i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // Вычислить индекс середины m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target находится в интервале [m+1, j]\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target находится в интервале [i, m-1]\n            j = m - 1\n        } else {\n            // Первый элемент меньше target находится в интервале [i, m-1]\n            j = m - 1\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // Вычислить индекс середины m\n        if nums[m] &lt; target {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if nums[m] &gt; target {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1 // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // Вычислить индекс середины m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target находится в интервале [m+1, j]\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target находится в интервале [i, m-1]\n    } else {\n      j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n    }\n  }\n  // Вернуть точку вставки i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // Вычислить индекс середины m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* Бинарный поиск точки вставки (с повторяющимися элементами) */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // Инициализировать двусторонне замкнутый интервал [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // Вычислить индекс середины m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target находится в интервале [m+1, j]\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target находится в интервале [i, m-1]\n        } else {\n            j = m - 1 // Первый элемент меньше target находится в интервале [i, m-1]\n        }\n    }\n    // Вернуть точку вставки i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### Бинарный поиск точки вставки (с повторяющимися элементами) ###\ndef binary_search_insertion(nums, target)\n  # Инициализировать двусторонне замкнутый интервал [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # Вычислить индекс середины m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target находится в интервале [m+1, j]\n    elsif nums[m] &gt; target\n      j = m - 1 # target находится в интервале [i, m-1]\n    else\n      j = m - 1 # Первый элемент меньше target находится в интервале [i, m-1]\n    end\n  end\n\n  i # Вернуть точку вставки i\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Tip</p> <p>Код в этом разделе записан в стиле \"двойного замкнутого интервала\". При желании можно самостоятельно реализовать вариант \"слева закрыт, справа открыт\".</p> <p>Если смотреть в целом, суть двоичного поиска сводится к тому, что для указателей \\(i\\) и \\(j\\) заранее задаются ориентиры поиска; целью может быть конкретный элемент, например <code>target</code> , а может быть и диапазон элементов, например все элементы, меньшие <code>target</code> .</p> <p>В ходе непрерывного двоичного деления указатели \\(i\\) и \\(j\\) постепенно приближаются к заранее заданной цели. В конце они либо успешно находят ответ, либо останавливаются после выхода за границы.</p>","path":["Глава 10. Поиск","10.2 &nbsp; Двоичный поиск точки вставки"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   Стратегии оптимизации хеширования","text":"<p>В алгоритмических задачах мы часто заменяем линейный поиск на хеш-поиск, чтобы уменьшить временную сложность алгоритма. Разберем одну задачу, чтобы лучше понять этот прием.</p> <p>Question</p> <p>Дан массив целых чисел <code>nums</code> и целевой элемент <code>target</code> . Найдите в массиве два элемента, сумма которых равна <code>target</code> , и верните их индексы. Подойдет любой корректный ответ.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   Линейный поиск: обмен времени на пространство","text":"<p>Рассмотрим прямой перебор всех возможных комбинаций. Как показано на рисунке 10-9, мы запускаем два вложенных цикла и на каждом шаге проверяем, равна ли сумма двух целых чисел <code>target</code> ; если да, то возвращаем их индексы.</p> <p></p> <p> Рисунок 10-9   Линейный поиск для задачи о двух суммах </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Метод 1: полный перебор\"\"\"\n    # Два вложенных цикла, временная сложность O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Метод 1: полный перебор */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Метод 1: полный перебор */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Метод 1: полный перебор */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Метод 1: полный перебор */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Метод 1: полный перебор */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Метод 1: полный перебор */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Метод 1: полный перебор */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Способ 1: полный перебор */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Два вложенных цикла, временная сложность O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Метод 1: полный перебор */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // Два вложенных цикла, временная сложность O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Метод 1: полный перебор */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Метод 1: полный перебор */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Два вложенных цикла, временная сложность O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Метод 1: полный перебор ###\ndef two_sum_brute_force(nums, target)\n  # Два вложенных цикла, временная сложность O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Временная сложность этого метода равна \\(O(n^2)\\) , а пространственная сложность равна \\(O(1)\\) , поэтому на больших объемах данных он очень медленный.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042-","level":2,"title":"10.4.2   Хеш-поиск: обмен пространства на время","text":"<p>Рассмотрим вариант с использованием хеш-таблицы, где ключами и значениями будут элементы массива и их индексы. При циклическом обходе массива на каждом шаге выполняются действия, показанные на рисунке 10-10.</p> <ol> <li>Проверить, находится ли число <code>target - nums[i]</code> в хеш-таблице; если да, то сразу вернуть индексы этих двух элементов.</li> <li>Добавить в хеш-таблицу пару из ключа <code>nums[i]</code> и индекса <code>i</code> .</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> Рисунок 10-10   Вспомогательная хеш-таблица для задачи о двух суммах </p> <p>Код реализации показан ниже, и для него достаточно одного цикла:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"Метод 2: вспомогательная хеш-таблица\"\"\"\n    # Вспомогательная хеш-таблица, пространственная сложность O(n)\n    dic = {}\n    # Один цикл, временная сложность O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // Один цикл, временная сложность O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    hashTable := map[int]int{}\n    // Один цикл, временная сложность O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    var dic: [Int: Int] = [:]\n    // Один цикл, временная сложность O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunction twoSumHashTable(nums, target) {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let m = {};\n    // Один цикл, временная сложность O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // Один цикл, временная сложность O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* Способ 2: вспомогательная хеш-таблица */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // Вспомогательная хеш-таблица, пространственная сложность O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // Один цикл, временная сложность O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* Метод 2: вспомогательная хеш-таблица */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    let mut dic = HashMap::new();\n    // Один цикл, временная сложность O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* Хеш-таблица */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // Реализовано на основе uthash.h\n} HashTable;\n\n/* Поиск в хеш-таблице */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* Вставка элемента в хеш-таблицу */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* Метод 2: вспомогательная хеш-таблица */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* Метод 2: вспомогательная хеш-таблица */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // Вспомогательная хеш-таблица, пространственная сложность O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // Один цикл, временная сложность O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### Метод 2: вспомогательная хеш-таблица ###\ndef two_sum_hash_table(nums, target)\n  # Вспомогательная хеш-таблица, пространственная сложность O(n)\n  dic = {}\n  # Один цикл, временная сложность O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Благодаря хеш-поиску этот метод снижает временную сложность с \\(O(n^2)\\) до \\(O(n)\\) , существенно повышая эффективность работы.</p> <p>Поскольку требуется поддерживать дополнительную хеш-таблицу, пространственная сложность составляет \\(O(n)\\) . Несмотря на это, в целом данный метод лучше сбалансирован по времени и памяти, поэтому именно он является оптимальным решением этой задачи.</p>","path":["Глава 10. Поиск","10.4 &nbsp; Стратегии оптимизации хеширования"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   Переосмысление алгоритмов поиска","text":"<p>Алгоритмы поиска (searching algorithm) используются для того, чтобы находить один или несколько элементов, удовлетворяющих определенным условиям, в структурах данных, таких как массивы, списки, деревья или графы.</p> <p>Алгоритмы поиска можно разделить на две категории по способу реализации.</p> <ul> <li>Поиск целевого элемента путем обхода структуры данных, например обход массива, списка, дерева или графа.</li> <li>Эффективный поиск элементов с использованием структуры организации данных или априорной информации, например двоичный поиск, хеш-поиск и поиск в двоичном дереве поиска.</li> </ul> <p>Нетрудно заметить, что эти темы уже рассматривались в предыдущих главах, поэтому алгоритмы поиска нам уже знакомы. В этом разделе мы систематизируем полученные ранее знания и еще раз посмотрим на них как на единую группу методов.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   Полный перебор","text":"<p>Полный перебор заключается в том, что мы обходим каждый элемент структуры данных, чтобы найти целевой элемент.</p> <ul> <li>\"Линейный поиск\" применяется к линейным структурам данных, таким как массивы и списки. Он начинается с одного конца структуры данных и последовательно проверяет элементы, пока не найдет целевой элемент или пока не достигнет другого конца структуры данных.</li> <li>\"Обход в ширину\" и \"обход в глубину\" - это две стратегии обхода графов и деревьев. Обход в ширину стартует из начального узла и исследует все узлы текущего уровня, прежде чем переходить к следующему. Обход в глубину стартует из начального узла, проходит один путь до конца, затем возвращается назад и пробует другие пути, пока не будет полностью пройдена вся структура данных.</li> </ul> <p>Преимущество полного перебора состоит в его простоте и универсальности, поскольку он не требует предварительной обработки данных и использования дополнительных структур данных.</p> <p>Однако временная сложность таких алгоритмов равна \\(O(n)\\) , где \\(n\\) - число элементов, поэтому при больших объемах данных их производительность невысока.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   Адаптивный поиск","text":"<p>Адаптивный поиск использует специфические свойства данных (например, упорядоченность), чтобы оптимизировать процесс поиска и тем самым эффективнее находить целевой элемент.</p> <ul> <li>\"Двоичный поиск\" использует упорядоченность данных для эффективного поиска и применим только к массивам.</li> <li>\"Хеш-поиск\" использует хеш-таблицу для построения отображения между поисковыми данными и целевыми данными, благодаря чему запросы выполняются эффективно.</li> <li>\"Поиск в дереве\" ведется в конкретной древовидной структуре (например, в двоичном дереве поиска) и позволяет быстро отсекать узлы на основе сравнения значений, чтобы найти цель.</li> </ul> <p>Преимущество этих алгоритмов заключается в высокой эффективности: их временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) .</p> <p>Однако для использования таких алгоритмов обычно требуется предварительная обработка данных. Например, для двоичного поиска нужно заранее отсортировать массив, а хеш-поиск и поиск в дереве требуют дополнительных структур данных, поддержание которых тоже отнимает время и память.</p> <p>Tip</p> <p>Адаптивные алгоритмы поиска часто называют алгоритмами поиска в узком смысле, поскольку они в основном предназначены для быстрого нахождения целевого элемента в конкретной структуре данных.</p>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   Выбор метода поиска","text":"<p>Для поиска целевого элемента в наборе данных размера \\(n\\) можно использовать линейный поиск, двоичный поиск, поиск в дереве, хеш-поиск и другие методы. Принципы работы этих методов показаны на рисунке 10-11.</p> <p></p> <p> Рисунок 10-11   Различные стратегии поиска </p> <p>Эффективность и особенности перечисленных методов приведены в таблице 10-1.</p> <p> Таблица 10-1   Сравнение эффективности алгоритмов поиска </p> Линейный поиск Двоичный поиск Поиск в дереве Хеш-поиск Поиск элемента \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) Вставка элемента \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Удаление элемента \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) Дополнительное пространство \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) Предварительная обработка / Сортировка \\(O(n \\log n)\\) Построение дерева \\(O(n \\log n)\\) Построение хеш-таблицы \\(O(n)\\) Упорядоченность данных Не требуется Требуется Требуется Не требуется <p>Выбор алгоритма поиска также зависит от масштаба данных, требований к производительности поиска, а также частоты запросов и обновлений данных.</p> <p>Линейный поиск</p> <ul> <li>Обладает хорошей универсальностью и не требует никакой предварительной обработки данных. Если нужно выполнить только один запрос, то время предварительной обработки для остальных трех методов окажется больше, чем время линейного поиска.</li> <li>Подходит для небольших объемов данных, потому что в этом случае влияние временной сложности на эффективность невелико.</li> <li>Подходит для сценариев с высокой частотой обновления данных, поскольку этот метод не требует никакого дополнительного обслуживания данных.</li> </ul> <p>Двоичный поиск</p> <ul> <li>Подходит для больших наборов данных и демонстрирует стабильную эффективность; его худшая временная сложность равна \\(O(\\log n)\\) .</li> <li>Объем данных не должен быть слишком большим, потому что массив требует непрерывного участка памяти.</li> <li>Не подходит для сценариев с частыми вставками и удалениями данных, так как поддержание массива в отсортированном виде требует больших затрат.</li> </ul> <p>Хеш-поиск</p> <ul> <li>Подходит для сценариев, в которых требования к скорости запросов очень высоки; средняя временная сложность равна \\(O(1)\\) .</li> <li>Не подходит для сценариев, где требуется упорядоченность данных или поиск по диапазону, потому что хеш-таблица не умеет поддерживать порядок данных.</li> <li>Сильно зависит от хеш-функции и стратегии обработки коллизий, поэтому риск деградации производительности сравнительно велик.</li> <li>Не подходит для слишком больших объемов данных, так как хеш-таблице требуется дополнительное пространство, чтобы максимально снизить число коллизий и обеспечить хорошую производительность поиска.</li> </ul> <p>Поиск в дереве</p> <ul> <li>Подходит для очень больших объемов данных, потому что узлы дерева распределены в памяти и не требуют непрерывного хранения.</li> <li>Подходит для сценариев, где нужно поддерживать упорядоченные данные или выполнять поиск по диапазону.</li> <li>В процессе постоянных вставок и удалений узлов двоичное дерево поиска может перекоситься, и тогда временная сложность деградирует до \\(O(n)\\) .</li> <li>Если использовать AVL-дерево или красно-черное дерево, то все операции могут стабильно выполняться за \\(O(\\log n)\\) , но поддержание баланса дерева увеличивает дополнительные накладные расходы.</li> </ul>","path":["Глава 10. Поиск","10.5 &nbsp; Переосмысление алгоритмов поиска"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   Резюме","text":"","path":["Глава 10. Поиск","10.6 &nbsp; Резюме"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Двоичный поиск опирается на упорядоченность данных и выполняет поиск путем циклического сокращения интервала вдвое. Он требует упорядоченных входных данных и подходит только для массивов или структур данных, реализованных на их основе.</li> <li>Полный перебор находит данные путем обхода структуры данных. Линейный поиск подходит для массивов и списков, а обход в ширину и обход в глубину подходят для графов и деревьев. Эти алгоритмы универсальны и не требуют предварительной обработки данных, но их временная сложность \\(O(n)\\) сравнительно велика.</li> <li>Хеш-поиск, поиск в дереве и двоичный поиск относятся к эффективным методам поиска и позволяют быстро находить целевой элемент в конкретных структурах данных. Такие алгоритмы обладают высокой эффективностью, их временная сложность может достигать \\(O(\\log n)\\) и даже \\(O(1)\\) , но обычно им нужны дополнительные структуры данных.</li> <li>На практике нужно анализировать размер данных, требования к производительности поиска, а также частоту запросов и обновлений данных, чтобы выбрать подходящий метод поиска.</li> <li>Линейный поиск подходит для небольших или часто обновляемых наборов данных; двоичный поиск - для больших отсортированных данных; хеш-поиск - для сценариев с высокими требованиями к скорости запросов и без необходимости поиска по диапазону; поиск в дереве - для больших динамических данных, где нужно поддерживать порядок и выполнять диапазонные запросы.</li> <li>Замена линейного поиска на хеш-поиск - это распространенная стратегия ускорения, которая позволяет снизить временную сложность с \\(O(n)\\) до \\(O(1)\\) .</li> </ul>","path":["Глава 10. Поиск","10.6 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"Глава 11.   Сортировка","text":"<p>Abstract</p> <p>Сортировка упорядочивает хаотичные данные и позволяет быстрее находить закономерности.</p> <p>За кажущейся простотой скрывается целая группа алгоритмов с разными достоинствами и ограничениями.</p>","path":["Глава 11. Сортировка","Глава 11. &nbsp; Сортировка"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>11.1   Алгоритмы сортировки</li> <li>11.2   Сортировка выбором</li> <li>11.3   Сортировка пузырьком</li> <li>11.4   Сортировка вставками</li> <li>11.5   Быстрая сортировка</li> <li>11.6   Сортировка слиянием</li> <li>11.7   Пирамидальная сортировка</li> <li>11.8   Блочная сортировка</li> <li>11.9   Сортировка подсчетом</li> <li>11.10   Поразрядная сортировка</li> <li>11.11   Резюме</li> </ul>","path":["Глава 11. Сортировка","Глава 11. &nbsp; Сортировка"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   Сортировка пузырьком","text":"<p>Сортировка пузырьком (bubble sort) реализует сортировку путем последовательного сравнения и обмена соседних элементов. Этот процесс напоминает всплытие пузырьков снизу вверх, откуда и произошло название алгоритма.</p> <p>Как показано на рисунке 11-4, процесс \"всплытия\" можно смоделировать через операцию обмена элементов: начиная от левого края массива и двигаясь вправо, мы последовательно сравниваем соседние элементы и, если \"левый элемент &gt; правый элемент\", меняем их местами. После завершения прохода максимальный элемент будет перемещен в самый правый конец массива.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-4   Моделирование пузырька через обмен элементов </p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   Алгоритм","text":"<p>Пусть длина массива равна \\(n\\) ; тогда шаги сортировки пузырьком показаны на рисунке 11-5.</p> <ol> <li>Сначала выполнить один проход \"всплытия\" по \\(n\\) элементам, переместив максимальный элемент массива на правильную позицию.</li> <li>Затем выполнить \"всплытие\" по оставшимся \\(n - 1\\) элементам, переместив второй по величине элемент на правильную позицию.</li> <li>Продолжать по аналогии; после \\(n - 1\\) раундов \"всплытия\" первые \\(n - 1\\) по величине элементы окажутся на правильных позициях.</li> <li>Оставшийся единственный элемент обязательно является минимальным, сортировать его уже не нужно, поэтому сортировка завершена.</li> </ol> <p></p> <p> Рисунок 11-5   Процесс сортировки пузырьком </p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"Пузырьковая сортировка\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(n - 1, 0, -1):\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                // Здесь используется функция std::swap()\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Пузырьковая сортировка */\nvoid BubbleSort(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Пузырьковая сортировка */\nfunc bubbleSort(nums []int) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Пузырьковая сортировка */\nfunc bubbleSort(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Пузырьковая сортировка */\nfunction bubbleSort(nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Пузырьковая сортировка */\nfunction bubbleSort(nums: number[]): void {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Пузырьковая сортировка */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Пузырьковая сортировка */\nvoid bubbleSort(int nums[], int size) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Пузырьковая сортировка */\nfun bubbleSort(nums: IntArray) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Пузырьковая сортировка ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   Оптимизация эффективности","text":"<p>Если в каком-либо раунде \"всплытия\" не произошло ни одного обмена, значит, массив уже отсортирован и можно сразу вернуть результат. Поэтому можно добавить флаг <code>flag</code> для отслеживания этой ситуации и немедленного выхода.</p> <p>После такой оптимизации худшая и средняя временные сложности сортировки пузырьком по-прежнему равны \\(O(n^2)\\) ; однако если входной массив уже полностью упорядочен, достигается лучшая временная сложность \\(O(n)\\) .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"Пузырьковая сортировка (оптимизация флагом)\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # Инициализировать флаг\n        # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # Записать обмен элементов\n        if not flag:\n            break  # На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n</code></pre> bubble_sort.cpp<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                // Здесь используется функция std::swap()\n                swap(nums[j], nums[j + 1]);\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag)\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag)\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid BubbleSortWithFlag(int[] nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // Записать обмен элементов\n            }\n        }\n        if (!flag) break;     // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunc bubbleSortWithFlag(nums []int) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // Записать обмен элементов\n            }\n        }\n        if flag == false { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // Инициализировать флаг\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // Записать обмен элементов\n            }\n        }\n        if !flag { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunction bubbleSortWithFlag(nums) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // Внешний цикл: неотсортированный диапазон [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // Инициализировать флаг\n    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // Поменять местами nums[j] и nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // Записать обмен элементов\n      }\n    }\n    if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // Поменять местами nums[j] и nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // Записать обмен элементов\n            }\n        }\n        if !flag {\n            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* Пузырьковая сортировка (оптимизация флагом) */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // Внешний цикл: неотсортированный диапазон [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // Инициализировать флаг\n        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // Поменять местами nums[j] и nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // Записать обмен элементов\n            }\n        }\n        if (!flag) break // На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### Пузырьковая сортировка ###\ndef bubble_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n\n# ## Пузырьковая сортировка (оптимизация флагом) ###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # Инициализировать флаг\n\n    # Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # Поменять местами nums[j] и nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # Записать обмен элементов\n      end\n    end\n\n    break unless flag # На этой итерации «всплытия» не было ни одного обмена, сразу выйти\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), алгоритм адаптивен: длины диапазонов, проходящих \"всплытие\" в разных раундах, последовательно равны \\(n - 1\\), \\(n - 2\\), \\(\\dots\\), \\(2\\), \\(1\\) , а их сумма равна \\((n - 1) n / 2\\) . После добавления оптимизации с <code>flag</code> лучшая временная сложность может достигать \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Стабильная сортировка: поскольку при \"всплытии\" равные элементы не обмениваются местами.</li> </ul>","path":["Глава 11. Сортировка","11.3 &nbsp; Сортировка пузырьком"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   Блочная сортировка","text":"<p>Рассмотренные выше алгоритмы сортировки относятся к \"сортировкам на основе сравнений\": они упорядочивают данные, сравнивая элементы друг с другом. Временная сложность таких алгоритмов не может быть лучше \\(O(n \\log n)\\) . Далее мы рассмотрим несколько \"сортировок без сравнений\", чья временная сложность может достигать линейного порядка.</p> <p>Блочная сортировка (bucket sort) является типичным применением стратегии \"разделяй и властвуй\". Она создает набор упорядоченных по величине блоков, где каждый блок соответствует определенному диапазону данных; затем элементы равномерно распределяются по этим блокам, внутри каждого блока отдельно выполняется сортировка, а в конце результаты объединяются в порядке блоков.</p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   Алгоритм","text":"<p>Рассмотрим массив длины \\(n\\), элементы которого являются числами с плавающей запятой из диапазона \\([0, 1)\\) . Процесс блочной сортировки показан на рисунке 11-13.</p> <ol> <li>Инициализировать \\(k\\) блоков и распределить \\(n\\) элементов по этим \\(k\\) блокам.</li> <li>Отсортировать каждый блок по отдельности (здесь используется встроенная функция сортировки языка программирования).</li> <li>Объединить результаты в порядке следования блоков от меньшего к большему.</li> </ol> <p></p> <p> Рисунок 11-13   Процесс блочной сортировки </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"Сортировка корзинами\"\"\"\n    # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. Распределить элементы массива по корзинам\n    for num in nums:\n        # Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        i = int(num * k)\n        # Добавить num в корзину i\n        buckets[i].append(num)\n    # 2. Выполнить сортировку внутри каждой корзины\n    for bucket in buckets:\n        # Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort()\n    # 3. Обойти корзины и объединить результаты\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* Сортировка корзинами */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. Распределить элементы массива по корзинам\n    for (float num : nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = num * k;\n        // Добавить num в корзину bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. Обойти корзины и объединить результаты\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* Сортировка корзинами */\nvoid bucketSort(float[] nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (float num : nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = (int) (num * k);\n        // Добавить num в корзину i\n        buckets.get(i).add(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (List&lt;Float&gt; bucket : buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        Collections.sort(bucket);\n    }\n    // 3. Обойти корзины и объединить результаты\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* Сортировка корзинами */\nvoid BucketSort(float[] nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    foreach (float num in nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        int i = (int)(num * k);\n        // Добавить num в корзину i\n        buckets[i].Add(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.Sort();\n    }\n    // 3. Обойти корзины и объединить результаты\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* Сортировка корзинами */\nfunc bucketSort(nums []float64) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. Распределить элементы массива по корзинам\n    for _, num := range nums {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        i := int(num * float64(k))\n        // Добавить num в корзину i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for i := 0; i &lt; k; i++ {\n        // Использовать встроенную функцию сортировки среза; ее также можно заменить другим алгоритмом сортировки\n        sort.Float64s(buckets[i])\n    }\n    // 3. Обойти корзины и объединить результаты\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* Сортировка корзинами */\nfunc bucketSort(nums: inout [Double]) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. Распределить элементы массива по корзинам\n    for num in nums {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        let i = Int(num * Double(k))\n        // Добавить num в корзину i\n        buckets[i].append(num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for i in buckets.indices {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        buckets[i].sort()\n    }\n    // 3. Обойти корзины и объединить результаты\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* Сортировка корзинами */\nfunction bucketSort(nums) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (const num of nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        const i = Math.floor(num * k);\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (const bucket of buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Обойти корзины и объединить результаты\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* Сортировка корзинами */\nfunction bucketSort(nums: number[]): void {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (const num of nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        const i = Math.floor(num * k);\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (const bucket of buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. Обойти корзины и объединить результаты\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* Сортировка корзинами */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. Распределить элементы массива по корзинам\n  for (double _num in nums) {\n    // Входные данные находятся в диапазоне [0, 1), используем _num * k для отображения в диапазон индексов [0, k-1]\n    int i = (_num * k).toInt();\n    // Добавить _num в корзину bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. Выполнить сортировку внутри каждой корзины\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. Обойти корзины и объединить результаты\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* Сортировка корзинами */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. Распределить элементы массива по корзинам\n    for &amp;num in nums.iter() {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        let i = (num * k as f64) as usize;\n        // Добавить num в корзину i\n        buckets[i].push(num);\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for bucket in &amp;mut buckets {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. Обойти корзины и объединить результаты\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* Сортировка корзинами */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // Инициализировать k = n/2 корзин\n    int *sizes = malloc(k * sizeof(int));          // Записать размер каждой корзины\n    float **buckets = malloc(k * sizeof(float *)); // Массив динамических массивов (корзины)\n    // Предварительно выделить достаточно места для каждой корзины\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. Объединить отсортированные корзины\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // Освободить память\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* Сортировка корзинами */\nfun bucketSort(nums: FloatArray) {\n    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. Распределить элементы массива по корзинам\n    for (num in nums) {\n        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n        val i = (num * k).toInt()\n        // Добавить num в корзину i\n        buckets[i].add(num)\n    }\n    // 2. Выполнить сортировку внутри каждой корзины\n    for (bucket in buckets) {\n        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n        bucket.sort()\n    }\n    // 3. Обойти корзины и объединить результаты\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### Сортировка корзинами ###\ndef bucket_sort(nums)\n  # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. Распределить элементы массива по корзинам\n  nums.each do |num|\n    # Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]\n    i = (num * k).to_i\n    # Добавить num в корзину i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. Выполнить сортировку внутри каждой корзины\n  buckets.each do |bucket|\n    # Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки\n    bucket.sort!\n  end\n\n  # 3. Обойти корзины и объединить результаты\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   Характеристики алгоритма","text":"<p>Блочная сортировка подходит для обработки очень больших объемов данных. Например, если вход содержит 1 миллион элементов и из-за ограничений памяти система не может загрузить их все сразу, можно разбить данные на 1000 блоков, отсортировать каждый блок отдельно, а затем объединить результаты.</p> <ul> <li>Временная сложность равна \\(O(n + k)\\) : если элементы распределены по блокам равномерно, то в каждом блоке будет \\(\\frac{n}{k}\\) элементов. Если сортировка одного блока требует \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) времени, то сортировка всех блоков потребует \\(O(n \\log\\frac{n}{k})\\) времени. Когда число блоков \\(k\\) достаточно велико, временная сложность приближается к \\(O(n)\\) . На объединение результатов требуется \\(O(n + k)\\) времени, потому что нужно пройти по всем блокам и элементам. В худшем случае все данные попадут в один блок, и если сортировка этого блока использует \\(O(n^2)\\) времени, общая сложность также станет \\(O(n^2)\\) .</li> <li>Пространственная сложность равна \\(O(n + k)\\), сортировка не выполняется на месте: требуются дополнительные блоки в количестве \\(k\\) и место для всех \\(n\\) элементов внутри них.</li> <li>Является ли блочная сортировка стабильной, зависит от того, стабилен ли алгоритм сортировки внутри каждого блока.</li> </ul>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   Как добиться равномерного распределения","text":"<p>Теоретически временная сложность блочной сортировки может достигать \\(O(n)\\) ; ключ к этому - как можно более равномерно распределить элементы по блокам. На практике данные часто распределены неравномерно. Например, если нужно распределить все товары на маркетплейсе по 10 ценовым блокам, количество товаров дешевле 100 рублей может быть очень большим, а товаров дороже 1000 рублей - очень маленьким. Если просто разбить диапазон цен на 10 равных частей, число товаров в каждом блоке будет сильно различаться.</p> <p>Чтобы добиться более равномерного распределения, можно сначала задать грубую линию раздела и приблизительно распределить данные по 3 блокам. После этого блоки с большим числом товаров можно снова делить на 3 блока и продолжать процесс до тех пор, пока число элементов в каждом блоке не станет примерно одинаковым.</p> <p>Как показано на рисунке 11-14, по сути этот метод строит рекурсивное дерево, цель которого - сделать значения в листьях как можно более равномерными. Конечно, совсем не обязательно каждый раз делить данные именно на 3 блока; конкретную схему разбиения можно выбирать в зависимости от свойств данных.</p> <p></p> <p> Рисунок 11-14   Рекурсивное разбиение по блокам </p> <p>Если нам заранее известна вероятностная модель распределения цен товаров, то границы цен для каждого блока можно задавать в соответствии с этим распределением. Важно отметить, что фактическое распределение данных не обязательно специально измерять - его можно приблизить некоторой вероятностной моделью исходя из свойств данных.</p> <p>Как показано на рисунке 11-15, если предположить, что цены товаров подчиняются нормальному распределению, то можно разумно задать интервалы цен и тем самым распределить товары по блокам достаточно равномерно.</p> <p></p> <p> Рисунок 11-15   Разбиение блоков по вероятностному распределению </p>","path":["Глава 11. Сортировка","11.8 &nbsp; Блочная сортировка"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   Сортировка подсчетом","text":"<p>Сортировка подсчетом (counting sort) реализует сортировку за счет подсчета количества вхождений элементов и обычно используется для массивов целых чисел.</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   Простая реализация","text":"<p>Сначала рассмотрим простой пример. Дан массив <code>nums</code> длины \\(n\\) , элементы которого являются \"неотрицательными целыми числами\". Общий процесс сортировки подсчетом показан на рисунке 11-16.</p> <ol> <li>Пройти по массиву, найти в нем максимальное число, обозначить его как \\(m\\) , а затем создать вспомогательный массив <code>counter</code> длины \\(m + 1\\) .</li> <li>С помощью <code>counter</code> подсчитать, сколько раз каждое число встречается в <code>nums</code>; при этом <code>counter[num]</code> хранит число вхождений значения <code>num</code> . Делается это просто: достаточно пройти по <code>nums</code> (пусть текущее число равно <code>num</code> ) и на каждом шаге увеличить <code>counter[num]</code> на \\(1\\) .</li> <li>Поскольку индексы массива <code>counter</code> изначально упорядочены, можно считать, что все числа уже отсортированы. Далее остается пройти по <code>counter</code> и в соответствии с числом вхождений записать значения обратно в <code>nums</code> в порядке возрастания.</li> </ol> <p></p> <p> Рисунок 11-16   Процесс сортировки подсчетом </p> <p>Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"Сортировка подсчетом\"\"\"\n    # Простая реализация, не подходит для сортировки объектов\n    # 1. Найти максимальный элемент массива m\n    m = max(nums)\n    # 2. Подсчитать число появлений каждой цифры\n    # counter[num] обозначает число появлений num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Обойти counter и заполнить исходный массив nums элементами\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid CountingSortNaive(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunc countingSortNaive(nums []int) {\n    // 1. Найти максимальный элемент массива m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. Найти максимальный элемент массива m\n    let m = nums.max()!\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunction countingSortNaive(nums) {\n    // 1. Найти максимальный элемент массива m\n    let m = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfunction countingSortNaive(nums: number[]): void {\n    // 1. Найти максимальный элемент массива m\n    let m: number = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. Найти максимальный элемент массива m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Подсчитать число появлений каждой цифры\n  // counter[_num] обозначает число появлений _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Обойти counter и заполнить исходный массив nums элементами\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. Найти максимальный элемент массива m\n    let m = *nums.iter().max().unwrap();\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nvoid countingSortNaive(int nums[], int size) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. Освободить память\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Сортировка подсчетом */\n// Простая реализация, не подходит для сортировки объектов\nfun countingSortNaive(nums: IntArray) {\n    // 1. Найти максимальный элемент массива m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Обойти counter и заполнить исходный массив nums элементами\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Сортировка подсчетом ###\ndef counting_sort_naive(nums)\n  # Простая реализация, не подходит для сортировки объектов\n  # 1. Найти максимальный элемент массива m\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. Подсчитать число появлений каждой цифры\n  # counter[num] обозначает число появлений num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Обойти counter и заполнить исходный массив nums элементами\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Связь между сортировкой подсчетом и блочной сортировкой</p> <p>Если посмотреть на сортировку подсчетом с точки зрения блочной сортировки, то каждый индекс массива <code>counter</code> можно рассматривать как отдельный блок, а процесс подсчета - как распределение элементов по соответствующим блокам. Иными словами, сортировка подсчетом является частным случаем блочной сортировки для целочисленных данных.</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   Полная реализация","text":"<p>Внимательный читатель мог заметить, что если входные данные представлены объектами, то описанный выше шаг <code>3.</code> перестает работать. Например, если входными данными являются объекты товаров и мы хотим отсортировать их по цене (полю класса), то описанный алгоритм сможет выдать только отсортированный ряд цен, но не исходные объекты в нужном порядке.</p> <p>Как же получить корректный порядок исходных данных? Сначала вычислим \"префиксную сумму\" массива <code>counter</code> . Как следует из названия, префиксная сумма в индексе <code>i</code> , обозначаемая как <code>prefix[i]</code> , равна сумме первых <code>i</code> элементов массива:</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>Префиксная сумма имеет четкий смысл: <code>prefix[num] - 1</code> обозначает индекс последнего вхождения элемента <code>num</code> в результирующем массиве <code>res</code>. Это очень важная информация, потому что она указывает, в какую позицию результирующего массива должен попасть каждый элемент. Далее мы проходим исходный массив <code>nums</code> в обратном порядке и на каждой итерации для очередного элемента <code>num</code> выполняем два действия.</p> <ol> <li>Записать <code>num</code> в массив <code>res</code> по индексу <code>prefix[num] - 1</code> .</li> <li>Уменьшить префиксную сумму <code>prefix[num]</code> на \\(1\\) , чтобы получить индекс следующего размещения элемента <code>num</code> .</li> </ol> <p>После завершения прохода массив <code>res</code> будет содержать отсортированный результат; остается только переписать <code>res</code> обратно в <code>nums</code> . Полный процесс сортировки подсчетом показан на рисунке 11-17.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-17   Шаги сортировки подсчетом </p> <p>Код реализации сортировки подсчетом приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"Сортировка подсчетом\"\"\"\n    # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\n    # 1. Найти максимальный элемент массива m\n    m = max(nums)\n    # 2. Подсчитать число появлений каждой цифры\n    # counter[num] обозначает число появлений num\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    # То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    # Инициализировать массив res для хранения результата\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # Поместить num по соответствующему индексу\n        counter[num] -= 1  # Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    # Перезаписать исходный массив nums массивом результата res\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--;              // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid CountingSort(int[] nums) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunc countingSort(nums []int) {\n    // 1. Найти максимальный элемент массива m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // Поместить num по соответствующему индексу\n        res[counter[num]-1] = num\n        // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n        counter[num]--\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunc countingSort(nums: inout [Int]) {\n    // 1. Найти максимальный элемент массива m\n    let m = nums.max()!\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // Поместить num по соответствующему индексу\n        counter[num] -= 1 // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunction countingSort(nums) {\n    // 1. Найти максимальный элемент массива m\n    let m = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfunction countingSort(nums: number[]): void {\n    // 1. Найти максимальный элемент массива m\n    let m: number = Math.max(...nums);\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. Найти максимальный элемент массива m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. Подсчитать число появлений каждой цифры\n  // counter[_num] обозначает число появлений _num\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n  // То есть counter[_num]-1 — это индекс последнего появления _num в res\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n  // Инициализировать массив res для хранения результата\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // Поместить _num по соответствующему индексу\n    counter[_num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения _num\n  }\n  // Перезаписать исходный массив nums массивом результата res\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. Найти максимальный элемент массива m\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num as usize] -= 1; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nvoid countingSort(int nums[], int size) {\n    // 1. Найти максимальный элемент массива m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу\n        counter[num]--;              // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    memcpy(nums, res, size * sizeof(int));\n    // 5. Освободить память\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* Сортировка подсчетом */\n// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\nfun countingSort(nums: IntArray) {\n    // 1. Найти максимальный элемент массива m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. Подсчитать число появлений каждой цифры\n    // counter[num] обозначает число появлений num\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n    // То есть counter[num]-1 — это индекс последнего появления num в res\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n    // Инициализировать массив res для хранения результата\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // Поместить num по соответствующему индексу\n        counter[num]-- // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n    }\n    // Перезаписать исходный массив nums массивом результата res\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### Сортировка подсчетом ###\ndef counting_sort(nums)\n  # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой\n  # 1. Найти максимальный элемент массива m\n  m = nums.max\n  # 2. Подсчитать число появлений каждой цифры\n  # counter[num] обозначает число появлений num\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»\n  # То есть counter[num]-1 — это индекс последнего появления num в res\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res\n  # Инициализировать массив res для хранения результата\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # Поместить num по соответствующему индексу\n    counter[num] -= 1 # Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num\n  end\n  # Перезаписать исходный массив nums массивом результата res\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n + m)\\), алгоритм не является адаптивным : необходимо пройти по <code>nums</code> и по <code>counter</code> , а оба этих прохода занимают линейное время. Обычно выполняется \\(n \\gg m\\) , поэтому временная сложность стремится к \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(n + m)\\), сортировка не выполняется на месте: используются массивы <code>res</code> и <code>counter</code> длины \\(n\\) и \\(m\\) соответственно.</li> <li>Стабильная сортировка: порядок заполнения <code>res</code> идет \"справа налево\", поэтому обратный проход по <code>nums</code> позволяет сохранить относительный порядок равных элементов и тем самым реализовать стабильную сортировку. Вообще говоря, прямой проход по <code>nums</code> тоже даст правильный результат сортировки, но он будет нестабильным.</li> </ul>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   Ограничения","text":"<p>На этом этапе сортировка подсчетом может показаться очень изящной: она позволяет эффективно сортировать данные, опираясь только на подсчет числа вхождений. Однако условия ее применения довольно строгие.</p> <p>Сортировка подсчетом применима только к неотрицательным целым числам. Чтобы использовать ее для других типов данных, нужно убедиться, что эти данные можно преобразовать в неотрицательные целые числа и что при преобразовании относительный порядок элементов не изменится. Например, для массива целых чисел с отрицательными значениями можно сначала прибавить ко всем числам константу, превратив их в положительные, затем выполнить сортировку и после этого преобразовать значения обратно.</p> <p>Сортировка подсчетом подходит для случаев, когда объем данных велик, но диапазон значений невелик. Например, в приведенном выше примере \\(m\\) не должно быть слишком большим, иначе будет занято слишком много памяти. А когда \\(n \\ll m\\) , сортировка подсчетом использует \\(O(m)\\) времени и может оказаться медленнее, чем алгоритмы сортировки с \\(O(n \\log n)\\) .</p>","path":["Глава 11. Сортировка","11.9 &nbsp; Сортировка подсчетом"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   Пирамидальная сортировка","text":"<p>Tip</p> <p>Перед чтением этого раздела убедитесь, что вы уже изучили главу \"Куча\".</p> <p>Пирамидальная сортировка (heap sort) - это эффективный алгоритм сортировки, основанный на структуре данных \"куча\". Для его реализации можно использовать уже изученные нами \"построение кучи\" и \"извлечение элементов из кучи\".</p> <ol> <li>Подать на вход массив и построить из него мин-кучу; в этот момент минимальный элемент будет находиться в вершине кучи.</li> <li>Непрерывно выполнять извлечение из кучи и по порядку записывать извлеченные элементы - так получится последовательность, отсортированная по возрастанию.</li> </ol> <p>Хотя этот метод и работоспособен, он требует дополнительного массива для хранения извлеченных элементов и потому расходует лишнюю память. На практике обычно используют более изящную реализацию.</p>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   Алгоритм","text":"<p>Пусть длина массива равна \\(n\\) ; тогда процесс пирамидальной сортировки показан на рисунке 11-12.</p> <ol> <li>Подать на вход массив и построить из него макс-кучу. После этого максимальный элемент окажется в вершине кучи.</li> <li>Обменять элемент в вершине кучи (первый элемент) с элементом внизу кучи (последний элемент). После обмена длина кучи уменьшается на \\(1\\) , а число уже отсортированных элементов увеличивается на \\(1\\) .</li> <li>Начиная с вершины, выполнить операцию просеивания сверху вниз. После этого свойство кучи будет восстановлено.</li> <li>Циклически повторять шаг <code>2.</code> и шаг <code>3.</code> . После \\(n - 1\\) раундов массив будет полностью отсортирован.</li> </ol> <p>Tip</p> <p>На самом деле операция извлечения из кучи тоже включает шаг <code>2.</code> и шаг <code>3.</code> , только дополнительно содержит действие по удалению элемента.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-12   Шаги пирамидальной сортировки </p> <p>В коде используется та же функция просеивания сверху вниз <code>sift_down()</code>, что и в главе \"Куча\". Важно помнить, что длина кучи уменьшается по мере извлечения максимального элемента, поэтому функции <code>sift_down()</code> нужно передавать параметр длины \\(n\\) , чтобы указать текущую действительную длину кучи. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз\"\"\"\n    while True:\n        # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i:\n            break\n        # Поменять два узла местами\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # Циклическое просеивание вниз\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"Сортировка кучей\"\"\"\n    # Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in range(len(nums) - 1, 0, -1):\n        # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums[0], nums[i] = nums[i], nums[0]\n        # Начиная с корневого узла, выполнить просеивание сверху вниз\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) {\n            break;\n        }\n        // Поменять два узла местами\n        swap(nums[i], nums[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        swap(nums[0], nums[i]);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(int[] nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i)\n            break;\n        // Поменять два узла местами\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid HeapSort(int[] nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfunc heapSort(nums *[]int) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break\n        }\n        // Поменять два узла местами\n        nums.swapAt(i, ma)\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfunc heapSort(nums: inout [Int]) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in nums.indices.dropFirst().reversed() {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums.swapAt(0, i)\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) {\n            break;\n        }\n        // Поменять два узла местами\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfunction heapSort(nums) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma === i) {\n            break;\n        }\n        // Поменять два узла местами\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfunction heapSort(nums: number[]): void {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    if (ma == i) break;\n    // Поменять два узла местами\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // Циклическое просеивание вниз\n    i = ma;\n  }\n}\n\n/* Сортировка кучей */\nvoid heapSort(List&lt;int&gt; nums) {\n  // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // Извлекать максимальный элемент из кучи в течение n-1 итераций\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // Начиная с корневого узла, выполнить просеивание сверху вниз\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if ma == i {\n            break;\n        }\n        // Поменять два узла местами\n        nums.swap(i, ma);\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for i in (1..nums.len()).rev() {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        nums.swap(0, i);\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) {\n            break;\n        }\n        // Поменять два узла местами\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // Циклическое просеивание вниз\n        i = ma;\n    }\n}\n\n/* Сортировка кучей */\nvoid heapSort(int nums[], int n) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (int i = n - 1; i &gt; 0; --i) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n        if (ma == i) \n            break\n        // Поменять два узла местами\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // Циклическое просеивание вниз\n        i = ma\n    }\n}\n\n/* Сортировка кучей */\nfun heapSort(nums: IntArray) {\n    // Построение кучи: выполнить heapify для всех узлов, кроме листовых\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // Извлекать максимальный элемент из кучи в течение n-1 итераций\n    for (i in nums.size - 1 downTo 1) {\n        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // Начиная с корневого узла, выполнить просеивание сверху вниз\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###\ndef sift_down(nums, n, i)\n  while true\n    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти\n    break if ma == i\n    # Поменять два узла местами\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # Циклическое просеивание вниз\n    i = ma\n  end\nend\n\n### Сортировка кучей ###\ndef heap_sort(nums)\n  # Построение кучи: выполнить heapify для всех узлов, кроме листовых\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # Извлекать максимальный элемент из кучи в течение n-1 итераций\n  (nums.length - 1).downto(1) do |i|\n    # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)\n    nums[0], nums[i] = nums[i], nums[0]\n    # Начиная с корневого узла, выполнить просеивание сверху вниз\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: построение кучи занимает \\(O(n)\\) времени. Извлечение максимального элемента из кучи имеет временную сложность \\(O(\\log n)\\) и выполняется \\(n - 1\\) раз.</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: несколько переменных-указателей используют \\(O(1)\\) памяти. Обмен элементов и операции просеивания выполняются прямо в исходном массиве.</li> <li>Нестабильная сортировка: при обмене вершины кучи и нижнего элемента относительный порядок равных элементов может измениться.</li> </ul>","path":["Глава 11. Сортировка","11.7 &nbsp; Пирамидальная сортировка"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   Сортировка вставками","text":"<p>Сортировка вставками (insertion sort) - это простой алгоритм сортировки, принцип которого очень похож на ручную сортировку карт в колоде.</p> <p>Точнее говоря, в неотсортированном диапазоне выбирается опорный элемент, после чего он сравнивается с элементами слева в уже отсортированном диапазоне и вставляется в правильную позицию.</p> <p>На рисунке 11-6 показан процесс вставки элемента в массив. Пусть опорный элемент обозначен как <code>base</code> ; нам нужно сдвинуть все элементы от целевого индекса до <code>base</code> на одну позицию вправо, а затем записать <code>base</code> в целевой индекс.</p> <p></p> <p> Рисунок 11-6   Одна операция вставки </p>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   Алгоритм","text":"<p>Общий процесс сортировки вставками показан на рисунке 11-7.</p> <ol> <li>В начальном состоянии отсортирован только первый элемент массива.</li> <li>Выбрать второй элемент массива как <code>base</code> ; после вставки в правильную позицию первые два элемента массива окажутся отсортированными.</li> <li>Выбрать третий элемент как <code>base</code> ; после вставки в правильную позицию первые три элемента массива окажутся отсортированными.</li> <li>Продолжать по аналогии; в последнем раунде в качестве <code>base</code> берется последний элемент, и после его вставки все элементы массива будут отсортированы.</li> </ol> <p></p> <p> Рисунок 11-7   Процесс сортировки вставками </p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"Сортировка вставками\"\"\"\n    # Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # Сдвинуть nums[j] на одну позицию вправо\n            j -= 1\n        nums[j + 1] = base  # Поместить base в правильную позицию\n</code></pre> insertion_sort.cpp<pre><code>/* Сортировка вставками */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* Сортировка вставками */\nvoid insertionSort(int[] nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base;        // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* Сортировка вставками */\nvoid InsertionSort(int[] nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = bas;         // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* Сортировка вставками */\nfunc insertionSort(nums []int) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j--\n        }\n        nums[j+1] = base // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* Сортировка вставками */\nfunc insertionSort(nums: inout [Int]) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j -= 1\n        }\n        nums[j + 1] = base // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* Сортировка вставками */\nfunction insertionSort(nums) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* Сортировка вставками */\nfunction insertionSort(nums: number[]): void {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n            j--;\n        }\n        nums[j + 1] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* Сортировка вставками */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // Внешний цикл: отсортированный диапазон [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо\n      j--;\n    }\n    nums[j + 1] = base; // Поместить base в правильную позицию\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* Сортировка вставками */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // Сдвинуть nums[j] на одну позицию вправо\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* Сортировка вставками */\nvoid insertionSort(int nums[], int size) {\n    // Внешний цикл: отсортированный диапазон [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // Сдвинуть nums[j] на одну позицию вправо\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // Поместить base в правильную позицию\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* Сортировка вставками */\nfun insertionSort(nums: IntArray) {\n    // Внешний цикл: отсортированные элементы равны 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо\n            j--\n        }\n        nums[j + 1] = base        // Поместить base в правильную позицию\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### Сортировка вставками ###\ndef insertion_sort(nums)\n  n = nums.length\n  # Внешний цикл: отсортированный диапазон [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # Сдвинуть nums[j] на одну позицию вправо\n      j -= 1\n    end\n    nums[j + 1] = base # Поместить base в правильную позицию\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), алгоритм адаптивен: в худшем случае каждой операции вставки требуется соответственно \\(n - 1\\), \\(n-2\\), \\(\\dots\\), \\(2\\), \\(1\\) итераций, а их сумма равна \\((n - 1) n / 2\\) , поэтому временная сложность равна \\(O(n^2)\\) . Если входные данные уже упорядочены, операция вставки завершается раньше. Когда входной массив полностью отсортирован, сортировка вставками достигает лучшей временной сложности \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Стабильная сортировка: в процессе вставки элементы помещаются справа от равных им элементов, поэтому их относительный порядок не меняется.</li> </ul>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   Преимущества сортировки вставками","text":"<p>Временная сложность сортировки вставками равна \\(O(n^2)\\) , а у быстрой сортировки, которую мы скоро изучим, временная сложность равна \\(O(n \\log n)\\) . Несмотря на более высокую асимптотическую сложность, на малых объемах данных сортировка вставками обычно работает быстрее.</p> <p>Этот вывод похож на сравнение линейного и двоичного поиска. Алгоритмы уровня \\(O(n \\log n)\\) , такие как быстрая сортировка, относятся к алгоритмам на основе стратегии \"разделяй и властвуй\" и обычно включают больше элементарных вычислений. Когда объем данных мал, значения \\(n^2\\) и \\(n \\log n\\) близки друг к другу, поэтому асимптотика не доминирует, а решающим становится число элементарных операций в каждом раунде.</p> <p>На практике встроенные функции сортировки во многих языках программирования (например, в Java) используют сортировку вставками. Общая идея такова: для длинных массивов применять алгоритмы сортировки на основе стратегии \"разделяй и властвуй\", например быструю сортировку; для коротких массивов сразу использовать сортировку вставками.</p> <p>Хотя сортировка пузырьком, выбором и вставками имеют одинаковую временную сложность \\(O(n^2)\\) , в реальных задачах сортировка вставками используется заметно чаще, чем сортировка пузырьком и сортировка выбором. Основные причины таковы.</p> <ul> <li>Сортировка пузырьком основана на обмене элементов, для чего нужна временная переменная и суммарно выполняются 3 элементарные операции; сортировка вставками основана на присваивании элементов и требует всего 1 элементарной операции. Поэтому вычислительные затраты сортировки пузырьком обычно выше, чем у сортировки вставками.</li> <li>Временная сложность сортировки выбором в любом случае равна \\(O(n^2)\\) . Если входные данные уже частично упорядочены, сортировка вставками обычно эффективнее сортировки выбором.</li> <li>Сортировка выбором нестабильна, поэтому ее нельзя использовать для многоуровневой сортировки.</li> </ul>","path":["Глава 11. Сортировка","11.4 &nbsp; Сортировка вставками"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   Сортировка слиянием","text":"<p>Сортировка слиянием (merge sort) - это алгоритм сортировки, основанный на стратегии \"разделяй и властвуй\", который включает этапы \"разделения\" и \"слияния\", показанные на рисунке 11-10.</p> <ol> <li>Этап разделения: массив рекурсивно делится пополам, и задача сортировки длинного массива превращается в задачи сортировки более коротких массивов.</li> <li>Этап слияния: когда длина подмассива становится равной 1, разделение завершается и начинается слияние; два коротких упорядоченных массива непрерывно объединяются в один более длинный упорядоченный массив, пока процесс не завершится.</li> </ol> <p></p> <p> Рисунок 11-10   Этапы разделения и слияния в сортировке слиянием </p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   Алгоритм","text":"<p>Как показано на рисунке 11-11, на этапе \"разделения\" массив рекурсивно разбивается сверху вниз по середине на два подмассива.</p> <ol> <li>Вычислить середину массива <code>mid</code> и рекурсивно разделить левый подмассив (интервал <code>[left, mid]</code> ) и правый подмассив (интервал <code>[mid + 1, right]</code> ).</li> <li>Рекурсивно повторять шаг <code>1.</code> , пока длина подмассива не станет равной 1.</li> </ol> <p>Этап \"слияния\" снизу вверх объединяет левый и правый подмассивы в один упорядоченный массив. Следует заметить, что начиная с подмассивов длины 1, каждый подмассив в фазе слияния уже является упорядоченным.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-11   Шаги сортировки слиянием </p> <p>Нетрудно заметить, что порядок рекурсии в сортировке слиянием совпадает с порядком обхода в глубину двоичного дерева.</p> <ul> <li>Обход в глубину: сначала рекурсивно обходится левое поддерево, затем правое поддерево, а в конце обрабатывается корневой узел.</li> <li>Сортировка слиянием: сначала рекурсивно разделяется левый подмассив, затем правый подмассив, а в конце выполняется слияние.</li> </ul> <p>Реализация сортировки слиянием показана в коде ниже. Обратите внимание: в <code>nums</code> объединяемый интервал равен <code>[left, right]</code> , а соответствующий интервал в <code>tmp</code> равен <code>[0, right - left]</code> .</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"Объединить левый и правый подмассивы\"\"\"\n    # Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    # Создать временный массив tmp для хранения результата слияния\n    tmp = [0] * (right - left + 1)\n    # Инициализировать начальные индексы левого и правого подмассивов\n    i, j, k = left, mid + 1, 0\n    # Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"Сортировка слиянием\"\"\"\n    # Условие завершения\n    if left &gt;= right:\n        return  # Завершить рекурсию, когда длина подмассива равна 1\n    # Этап разбиения\n    mid = (left + right) // 2 # Вычислить середину\n    merge_sort(nums, left, mid)  # Рекурсивно обработать левый подмассив\n    merge_sort(nums, mid + 1, right)  # Рекурсивно обработать правый подмассив\n    # Этап слияния\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    vector&lt;int&gt; tmp(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    mergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int[] tmp = new int[right - left + 1];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(int[] nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2; // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* Объединить левый и правый подмассивы */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int[] tmp = new int[right - left + 1];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nvoid MergeSort(int[] nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right) return;       // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    MergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    MergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* Объединить левый и правый подмассивы */\nfunc merge(nums []int, left, mid, right int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    tmp := make([]int, right-left+1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    i, j, k := left, mid+1, 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* Сортировка слиянием */\nfunc mergeSort(nums []int, left, right int) {\n    // Условие завершения\n    if left &gt;= right {\n        return\n    }\n    // Этап разбиения\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // Этап слияния\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* Объединить левый и правый подмассивы */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    var i = left, j = mid + 1, k = 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* Сортировка слиянием */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // Условие завершения\n    if left &gt;= right { // Завершить рекурсию, когда длина подмассива равна 1\n        return\n    }\n    // Этап разбиения\n    let mid = left + (right - left) / 2 // Вычислить середину\n    mergeSort(nums: &amp;nums, left: left, right: mid) // Рекурсивно обработать левый подмассив\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* Объединить левый и правый подмассивы */\nfunction merge(nums, left, mid, right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    const tmp = new Array(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfunction mergeSort(nums, left, right) {\n    // Условие завершения\n    if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    let mid = Math.floor(left + (right - left) / 2); // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* Объединить левый и правый подмассивы */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    const tmp = new Array(right - left + 1);\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // Условие завершения\n    if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    let mid = Math.floor(left + (right - left) / 2); // Вычислить середину\n    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n  // Создать временный массив tmp для хранения результата слияния\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // Инициализировать начальные индексы левого и правого подмассивов\n  int i = left, j = mid + 1, k = 0;\n  // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // Условие завершения\n  if (left &gt;= right) return; // Завершить рекурсию, когда длина подмассива равна 1\n  // Этап разбиения\n  int mid = left + (right - left) ~/ 2; // Вычислить середину\n  mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив\n  mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n  // Этап слияния\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* Объединить левый и правый подмассивы */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // Инициализировать начальные индексы левого и правого подмассивов\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* Сортировка слиянием */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // Условие завершения\n    if left &gt;= right {\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    }\n\n    // Этап разбиения\n    let mid = left + (right - left) / 2; // Вычислить середину\n    merge_sort(nums, left, mid); // Рекурсивно обработать левый подмассив\n    merge_sort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* Объединить левый и правый подмассивы */\nvoid merge(int *nums, int left, int mid, int right) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // Инициализировать начальные индексы левого и правого подмассивов\n    int i = left, j = mid + 1, k = 0;\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // Освободить память\n    free(tmp);\n}\n\n/* Сортировка слиянием */\nvoid mergeSort(int *nums, int left, int right) {\n    // Условие завершения\n    if (left &gt;= right)\n        return; // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    int mid = left + (right - left) / 2;    // Вычислить середину\n    mergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* Объединить левый и правый подмассивы */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]\n    // Создать временный массив tmp для хранения результата слияния\n    val tmp = IntArray(right - left + 1)\n    // Инициализировать начальные индексы левого и правого подмассивов\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* Сортировка слиянием */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // Условие завершения\n    if (left &gt;= right) return  // Завершить рекурсию, когда длина подмассива равна 1\n    // Этап разбиения\n    val mid = left + (right - left) / 2 // Вычислить середину\n    mergeSort(nums, left, mid) // Рекурсивно обработать левый подмассив\n    mergeSort(nums, mid + 1, right) // Рекурсивно обработать правый подмассив\n    // Этап слияния\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### Слияние левого и правого подмассивов ###\ndef merge(nums, left, mid, right)\n  # Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]\n  # Создать временный массив tmp для хранения результата слияния\n  tmp = Array.new(right - left + 1, 0)\n  # Инициализировать начальные индексы левого и правого подмассивов\n  i, j, k = left, mid + 1, 0\n  # Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # Скопировать оставшиеся элементы левого и правого подмассивов во временный массив\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### Сортировка слиянием ###\ndef merge_sort(nums, left, right)\n  # Условие завершения\n  # Когда длина подмассива равна 1, рекурсия завершается\n  return if left &gt;= right\n  # Этап разбиения\n  mid = left + (right - left) / 2 # Вычислить середину\n  merge_sort(nums, left, mid) # Рекурсивно обработать левый подмассив\n  merge_sort(nums, mid + 1, right) # Рекурсивно обработать правый подмассив\n  # Этап слияния\n  merge(nums, left, mid, right)\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: этап разделения создает дерево рекурсии высоты \\(\\log n\\) , а суммарное число операций слияния на каждом уровне равно \\(n\\) , поэтому общая временная сложность составляет \\(O(n \\log n)\\) .</li> <li>Пространственная сложность равна \\(O(n)\\), сортировка не выполняется на месте: глубина рекурсии равна \\(\\log n\\) , из-за чего требуется \\(O(\\log n)\\) памяти под стек вызовов. Для этапа слияния нужен вспомогательный массив, поэтому дополнительно используется \\(O(n)\\) памяти.</li> <li>Стабильная сортировка: в процессе слияния относительный порядок равных элементов не меняется.</li> </ul>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   Сортировка связного списка","text":"<p>Для связных списков сортировка слиянием имеет заметное преимущество перед другими алгоритмами сортировки: пространственную сложность задачи сортировки списка можно оптимизировать до \\(O(1)\\).</p> <ul> <li>Этап разделения: работу по разбиению списка можно реализовать с помощью \"итерации\" вместо \"рекурсии\", тем самым устранив расход памяти на стек вызовов.</li> <li>Этап слияния: в связном списке добавление и удаление узлов требует только изменения ссылок (указателей), поэтому при слиянии двух коротких упорядоченных списков в один длинный упорядоченный список не нужно создавать дополнительный список.</li> </ul> <p>Детали реализации достаточно сложны; заинтересованные читатели могут обратиться к соответствующим материалам самостоятельно.</p>","path":["Глава 11. Сортировка","11.6 &nbsp; Сортировка слиянием"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   Быстрая сортировка","text":"<p>Быстрая сортировка (quick sort) - это алгоритм сортировки, основанный на стратегии \"разделяй и властвуй\"; он работает эффективно и применяется очень широко.</p> <p>Ключевая операция быстрой сортировки - это \"разделение с опорным элементом\". Ее цель такова: выбрать некоторый элемент массива в качестве \"опорного\" и переместить все элементы меньше опорного влево от него, а все элементы больше опорного - вправо. Конкретный процесс показан на рисунке 11-8.</p> <ol> <li>Выбрать самый левый элемент массива как опорный и инициализировать два указателя <code>i</code> и <code>j</code> , направленные на левую и правую границы массива.</li> <li>Запустить цикл, в котором <code>i</code> и <code>j</code> ищут соответственно первый элемент, больший опорного, и первый элемент, меньший опорного, после чего эти два элемента меняются местами.</li> <li>Повторять шаг <code>2.</code> , пока указатели <code>i</code> и <code>j</code> не встретятся, а затем обменять опорный элемент с элементом на границе двух подмассивов.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-8   Шаги разделения с опорным элементом </p> <p>После завершения разделения исходный массив разбивается на три части: левый подмассив, опорный элемент и правый подмассив; при этом выполняется условие \"любой элемент левого подмассива \\(\\leq\\) опорный элемент \\(\\leq\\) любой элемент правого подмассива\". Следовательно, далее нам нужно лишь отсортировать эти два подмассива.</p> <p>Стратегия разделяй и властвуй в быстрой сортировке</p> <p>Иными словами, разделение с опорным элементом сводит задачу сортировки длинного массива к двум задачам сортировки более коротких массивов.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Разбиение с опорными указателями\"\"\"\n    # Взять nums[left] в качестве опорного элемента\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Идти справа налево в поисках первого элемента меньше опорного\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Идти слева направо в поисках первого элемента больше опорного\n        # Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    # Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Вернуть индекс опорного элемента\n</code></pre> quick_sort.cpp<pre><code>/* Разбиение с опорными указателями */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums[i], nums[j]); // Поменять эти два элемента местами\n    }\n    swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов\n    return i;                   // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.java<pre><code>/* Обмен элементов */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint partition(int[] nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.cs<pre><code>/* Обмен элементов */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* Разбиение с опорными указателями */\nint Partition(int[] nums, int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        Swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.go<pre><code>/* Разбиение с опорными указателями */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // Взять nums[left] в качестве опорного элемента\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.swift<pre><code>/* Разбиение с опорными указателями */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swapAt(i, j) // Поменять эти два элемента местами\n    }\n    nums.swapAt(i, left) // Переместить опорный элемент на границу двух подмассивов\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.js<pre><code>/* Обмен элементов */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\npartition(nums, left, right) {\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.ts<pre><code>/* Обмен элементов */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\npartition(nums: number[], left: number, right: number): number {\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.dart<pre><code>/* Обмен элементов */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Взять nums[left] в качестве опорного элемента\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n    _swap(nums, i, j); // Поменять эти два элемента местами\n  }\n  _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n  return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rs<pre><code>/* Разбиение с опорными указателями */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Взять nums[left] в качестве опорного элемента\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swap(i, j); // Поменять эти два элемента местами\n    }\n    nums.swap(i, left); // Переместить опорный элемент на границу двух подмассивов\n    i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.c<pre><code>/* Обмен элементов */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* Разбиение с опорными указателями */\nint partition(int nums[], int left, int right) {\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Поменять эти два элемента местами\n        swap(nums, i, j);\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    swap(nums, i, left);\n    // Вернуть индекс опорного элемента\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* Обмен элементов */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* Разбиение с опорными указателями */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j)  // Поменять эти два элемента местами\n    }\n    swap(nums, i, left)   // Переместить опорный элемент на границу двух подмассивов\n    return i              // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rb<pre><code>### Разбиение с опорными указателями ###\ndef partition(nums, left, right)\n  # Взять nums[left] в качестве опорного элемента\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   Алгоритм","text":"<p>Общий процесс быстрой сортировки показан на рисунке 11-9.</p> <ol> <li>Сначала выполнить \"разделение с опорным элементом\" для исходного массива и получить неотсортированные левый и правый подмассивы.</li> <li>Затем рекурсивно выполнить \"разделение с опорным элементом\" для левого и правого подмассивов.</li> <li>Продолжать рекурсию до тех пор, пока длина подмассива не станет равной 1; после этого сортировка всего массива будет завершена.</li> </ol> <p></p> <p> Рисунок 11-9   Процесс быстрой сортировки </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Быстрая сортировка\"\"\"\n    # Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right:\n        return\n    # Разбиение с опорными указателями\n    pivot = self.partition(nums, left, right)\n    # Рекурсивно обработать левый и правый подмассивы\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* Быстрая сортировка */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* Быстрая сортировка */\nvoid quickSort(int[] nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* Быстрая сортировка */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right)\n        return;\n    // Разбиение с опорными указателями\n    int pivot = Partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* Быстрая сортировка */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return\n    }\n    // Разбиение с опорными указателями\n    pivot := q.partition(nums, left, right)\n    // Рекурсивно обработать левый и правый подмассивы\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* Быстрая сортировка */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return\n    }\n    // Разбиение с опорными указателями\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Быстрая сортировка */\nquickSort(nums, left, right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) return;\n    // Разбиение с опорными указателями\n    const pivot = this.partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* Быстрая сортировка */\nquickSort(nums: number[], left: number, right: number): void {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Разбиение с опорными указателями\n    const pivot = this.partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* Быстрая сортировка */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Завершить рекурсию, когда длина подмассива равна 1\n  if (left &gt;= right) return;\n  // Разбиение с опорными указателями\n  int pivot = _partition(nums, left, right);\n  // Рекурсивно обработать левый и правый подмассивы\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* Быстрая сортировка */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if left &gt;= right {\n        return;\n    }\n    // Разбиение с опорными указателями\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // Рекурсивно обработать левый и правый подмассивы\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* Быстрая сортировка */\nvoid quickSort(int nums[], int left, int right) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) {\n        return;\n    }\n    // Разбиение с опорными указателями\n    int pivot = partition(nums, left, right);\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* Быстрая сортировка */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // Завершить рекурсию, когда длина подмассива равна 1\n    if (left &gt;= right) return\n    // Разбиение с опорными указателями\n    val pivot = partition(nums, left, right)\n    // Рекурсивно обработать левый и правый подмассивы\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### Класс быстрой сортировки ###\ndef quick_sort(nums, left, right)\n  # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1\n  if left &lt; right\n    # Разбиение с опорными указателями\n    pivot = partition(nums, left, right)\n    # Рекурсивно обработать левый и правый подмассивы\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n \\log n)\\), алгоритм не является адаптивным: в среднем глубина рекурсии при разделении равна \\(\\log n\\) , а суммарное число циклов на каждом уровне равно \\(n\\) , поэтому общая сложность составляет \\(O(n \\log n)\\) . В худшем случае каждое разделение делит массив длины \\(n\\) на подмассивы длины \\(0\\) и \\(n - 1\\) ; тогда глубина рекурсии достигает \\(n\\) , на каждом уровне выполняется \\(n\\) операций, и общая временная сложность вырождается в \\(O(n^2)\\) .</li> <li>Пространственная сложность равна \\(O(n)\\), сортировка выполняется на месте: если входной массив полностью отсортирован в обратном порядке, глубина рекурсии достигает худшего случая \\(n\\) , что требует \\(O(n)\\) памяти под стек вызовов. При этом сама сортировка выполняется в исходном массиве без дополнительного массива.</li> <li>Нестабильная сортировка: на последнем шаге разделения опорный элемент может быть обменян вправо от равного ему элемента.</li> </ul>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   Почему быстрая сортировка быстрая","text":"<p>Уже по названию понятно, что быстрая сортировка должна иметь преимущества по эффективности. Хотя ее средняя временная сложность совпадает со сложностью \"сортировки слиянием\" и \"пирамидальной сортировки\", на практике быстрая сортировка обычно работает быстрее. Основные причины таковы.</p> <ul> <li>Вероятность худшего случая очень мала: хотя худшая временная сложность быстрой сортировки равна \\(O(n^2)\\) и она не так стабильна, как сортировка слиянием, в подавляющем большинстве случаев она работает за \\(O(n \\log n)\\) .</li> <li>Высокая эффективность использования кэша: при выполнении разделения система может загрузить весь подмассив в кэш, поэтому доступ к элементам оказывается быстрым. Алгоритмы вроде \"пирамидальной сортировки\" требуют скачкообразного доступа к элементам и таким свойством не обладают.</li> <li>Небольшой константный множитель в сложности: среди трех перечисленных алгоритмов у быстрой сортировки обычно меньше всего сравнений, присваиваний и обменов. Это похоже на причину, по которой \"сортировка вставками\" часто быстрее \"сортировки пузырьком\".</li> </ul>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   Оптимизация выбора опорного элемента","text":"<p>На некоторых входных данных временная эффективность быстрой сортировки может ухудшаться. Рассмотрим крайний случай: входной массив полностью отсортирован в обратном порядке. Поскольку в качестве опорного мы выбираем самый левый элемент, после разделения он будет обменян в самый правый конец массива, из-за чего длина левого подмассива станет \\(n - 1\\) , а длина правого - \\(0\\) . Если рекурсия будет продолжаться таким образом, то после каждого разделения один из подмассивов будет иметь длину \\(0\\) , стратегия \"разделяй и властвуй\" потеряет смысл, а быстрая сортировка выродится в нечто близкое к \"сортировке пузырьком\".</p> <p>Чтобы по возможности избежать такого сценария, можно улучшить стратегию выбора опорного элемента в процедуре разделения. Например, можно выбирать случайный элемент массива как опорный. Однако если не повезет и каждый раз будет выбираться неудачный опорный элемент, производительность все равно останется неудовлетворительной.</p> <p>Стоит учитывать, что языки программирования обычно генерируют псевдослучайные числа. Если специально построить тестовый пример под такую последовательность, эффективность быстрой сортировки все равно может деградировать.</p> <p>Чтобы улучшить ситуацию, можно взять три кандидата (обычно первый, последний и средний элементы массива) и использовать медиану этих трех значений как опорный элемент. Благодаря этому вероятность того, что опорный элемент окажется \"не слишком маленьким и не слишком большим\", заметно возрастает. Конечно, можно брать и большее число кандидатов, чтобы еще сильнее повысить устойчивость алгоритма. После этого вероятность деградации временной сложности до \\(O(n^2)\\) существенно уменьшается.</p> <p>Пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"Выбрать медиану из трех кандидатов\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m находится между l и r\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l находится между m и r\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"Разбиение с опорными указателями (медиана трех)\"\"\"\n    # Взять nums[left] в качестве опорного элемента\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # Переместить медиану в крайний левый элемент массива\n    nums[left], nums[med] = nums[med], nums[left]\n    # Взять nums[left] в качестве опорного элемента\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # Идти справа налево в поисках первого элемента меньше опорного\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # Идти слева направо в поисках первого элемента больше опорного\n        # Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    # Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # Вернуть индекс опорного элемента\n</code></pre> quick_sort.cpp<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums[left], nums[med]);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums[i], nums[j]); // Поменять эти два элемента местами\n    }\n    swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов\n    return i;                   // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.java<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partition(int[] nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.cs<pre><code>/* Выбрать медиану из трех кандидатов */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint Partition(int[] nums, int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    Swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        Swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов\n    return i;             // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.go<pre><code>/* Выбрать медиану из трех кандидатов */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l находится между m и r\n    }\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // Взять nums[left] в качестве опорного элемента\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // Переместить медиану в крайний левый элемент массива\n    nums[left], nums[med] = nums[med], nums[left]\n    // Взять nums[left] в качестве опорного элемента\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // Идти слева направо в поисках первого элемента больше опорного\n        }\n        // Обмен элементов\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // Переместить опорный элемент на границу двух подмассивов\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.swift<pre><code>/* Выбрать медиану из трех кандидатов */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l находится между m и r\n    }\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // Выбрать медиану из трех кандидатов\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // Переместить медиану в крайний левый элемент массива\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* Выбрать медиану из трех кандидатов */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m находится между l и r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l находится между m и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\npartition(nums, left, right) {\n    // Выбрать медиану из трех кандидатов\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Переместить медиану в крайний левый элемент массива\n    this.swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.ts<pre><code>/* Выбрать медиану из трех кандидатов */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m находится между l и r\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l находится между m и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\npartition(nums: number[], left: number, right: number): number {\n    // Выбрать медиану из трех кандидатов\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // Переместить медиану в крайний левый элемент массива\n    this.swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        this.swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.dart<pre><code>/* Выбрать медиану из трех кандидатов */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m находится между l и r\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l находится между m и r\n  return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // Выбрать медиану из трех кандидатов\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // Переместить медиану в крайний левый элемент массива\n  _swap(nums, left, med);\n  // Взять nums[left] в качестве опорного элемента\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного\n    _swap(nums, i, j); // Поменять эти два элемента местами\n  }\n  _swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n  return i; // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rs<pre><code>/* Выбрать медиану из трех кандидатов */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m находится между l и r\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l находится между m и r\n    }\n    right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // Выбрать медиану из трех кандидатов\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    nums.swap(left, med);\n    // Взять nums[left] в качестве опорного элемента\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // Идти справа налево в поисках первого элемента меньше опорного\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // Идти слева направо в поисках первого элемента больше опорного\n        }\n        nums.swap(i, j); // Поменять эти два элемента местами\n    }\n    nums.swap(i, left); // Переместить опорный элемент на границу двух подмассивов\n    i // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.c<pre><code>/* Выбрать медиану из трех кандидатов */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m находится между l и r\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l находится между m и r\n    return right;\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nint partitionMedian(int nums[], int left, int right) {\n    // Выбрать медиану из трех кандидатов\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med);\n    // Взять nums[left] в качестве опорного элемента\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j); // Поменять эти два элемента местами\n    }\n    swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов\n    return i;            // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.kt<pre><code>/* Выбрать медиану из трех кандидатов */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m находится между l и r\n    if ((l in m..r) || (l in r..m))\n        return left // l находится между m и r\n    return right\n}\n\n/* Разбиение с опорными указателями (медиана трех) */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // Выбрать медиану из трех кандидатов\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // Переместить медиану в крайний левый элемент массива\n    swap(nums, left, med)\n    // Взять nums[left] в качестве опорного элемента\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // Идти справа налево в поисках первого элемента меньше опорного\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // Идти слева направо в поисках первого элемента больше опорного\n        swap(nums, i, j)             // Поменять эти два элемента местами\n    }\n    swap(nums, i, left)              // Переместить опорный элемент на границу двух подмассивов\n    return i                         // Вернуть индекс опорного элемента\n}\n</code></pre> quick_sort.rb<pre><code>### Выбрать медиану из трех кандидатов ###\ndef median_three(nums, left, mid, right)\n  # Выбрать медиану из трех кандидатов\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m находится между l и r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l находится между m и r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### Выбрать медиану из трех кандидатов ###\ndef median_three(nums, left, mid, right)\n  # Выбрать медиану из трех кандидатов\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m находится между l и r\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l находится между m и r\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n# ## Разбиение с опорными указателями (медиана трех) ###\ndef partition(nums, left, right)\n  # ## Использовать nums[left] как опорный элемент\n  med = median_three(nums, left, (left + right) / 2, right)\n  # Переместить медиану в крайний левый элемент массива\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   Оптимизация глубины рекурсии","text":"<p>На некоторых входных данных быстрая сортировка может занимать слишком много памяти. Рассмотрим полностью отсортированный входной массив. Пусть длина текущего подмассива в рекурсии равна \\(m\\) ; тогда после каждого разделения будут получаться левый подмассив длины \\(0\\) и правый подмассив длины \\(m - 1\\) . Это означает, что на каждом уровне размер задачи уменьшается совсем немного (лишь на один элемент), а высота дерева рекурсии достигает \\(n - 1\\) , поэтому требуется \\(O(n)\\) памяти под стек вызовов.</p> <p>Чтобы избежать накопления стековых кадров, после каждого разделения можно сравнивать длины двух подмассивов и рекурсивно обрабатывать только более короткий из них. Поскольку длина короткого подмассива не превысит \\(n / 2\\) , такой подход гарантирует, что глубина рекурсии не превысит \\(\\log n\\) , а худшая пространственная сложность будет оптимизирована до \\(O(\\log n)\\) . Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"Быстрая сортировка (оптимизация глубины рекурсии)\"\"\"\n    # Завершить, когда длина подмассива равна 1\n    while left &lt; right:\n        # Операция разбиения с опорными указателями\n        pivot = self.partition(nums, left, right)\n        # Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # Рекурсивно отсортировать левый подмассив\n            left = pivot + 1  # Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # Рекурсивно отсортировать правый подмассив\n            right = pivot - 1  # Оставшийся неотсортированный диапазон: [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1;                 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1;                 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(int[] nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid QuickSort(int[] nums, int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = Partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1;  // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // Завершить, когда длина подмассива равна 1\n    for left &lt; right {\n        // Операция разбиения с опорными указателями\n        pivot := q.partition(nums, left, right)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1                 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1                 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // Завершить, когда длина подмассива равна 1\n    while left &lt; right {\n        // Операция разбиения с опорными указателями\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nquickSort(nums, left, right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        let pivot = this.partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nquickSort(nums: number[], left: number, right: number): void {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        let pivot = this.partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // Завершить, когда длина подмассива равна 1\n  while (left &lt; right) {\n    // Операция разбиения с опорными указателями\n    int pivot = _partition(nums, left, right);\n    // Выполнить быструю сортировку для более короткого из двух подмассивов\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив\n      left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив\n      right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // Завершить, когда длина подмассива равна 1\n    while left &lt; right {\n        // Операция разбиения с опорными указателями\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // Рекурсивно отсортировать левый подмассив\n            left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // Рекурсивно отсортировать правый подмассив\n            right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // Завершить, когда длина подмассива равна 1\n    while (left &lt; right) {\n        // Операция разбиения с опорными указателями\n        int pivot = partition(nums, left, right);\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - left &lt; right - pivot) {\n            // Рекурсивно отсортировать левый подмассив\n            quickSortTailCall(nums, left, pivot - 1);\n            // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // Рекурсивно отсортировать правый подмассив\n            quickSortTailCall(nums, pivot + 1, right);\n            // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* Быстрая сортировка (оптимизация глубины рекурсии) */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // Завершить, когда длина подмассива равна 1\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // Операция разбиения с опорными указателями\n        val pivot = partition(nums, l, r)\n        // Выполнить быструю сортировку для более короткого из двух подмассивов\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // Рекурсивно отсортировать левый подмассив\n            l = pivot + 1 // Оставшийся неотсортированный диапазон: [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // Рекурсивно отсортировать правый подмассив\n            r = pivot - 1 // Оставшийся неотсортированный диапазон: [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### Разбиение с опорными указателями ###\ndef partition(nums, left, right)\n  # Использовать nums[left] как опорный элемент\n  i = left\n  j = right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # Идти справа налево в поисках первого элемента меньше опорного\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # Идти слева направо в поисках первого элемента больше опорного\n    end\n    # Обмен элементов\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # Переместить опорный элемент на границу двух подмассивов\n  nums[i], nums[left] = nums[left], nums[i]\n  i # Вернуть индекс опорного элемента\nend\n\n# ## Быстрая сортировка (оптимизация глубины рекурсии) ###\ndef quick_sort(nums, left, right)\n  # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1\n  while left &lt; right\n    # Разбиение с опорными указателями\n    pivot = partition(nums, left, right)\n    # Выполнить быструю сортировку для более короткого из двух подмассивов\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # Оставшийся неотсортированный диапазон: [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # Оставшийся неотсортированный диапазон: [left, pivot - 1]\n    end\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.5 &nbsp; Быстрая сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   Поразрядная сортировка","text":"<p>В предыдущем разделе была рассмотрена сортировка подсчетом: она хорошо подходит для случаев, когда объем данных \\(n\\) велик, а диапазон значений \\(m\\) сравнительно мал. Предположим теперь, что нужно отсортировать \\(n = 10^6\\) номеров студентов, причем каждый номер представляет собой \\(8\\)-значное число. Тогда диапазон данных \\(m = 10^8\\) оказывается очень большим; сортировка подсчетом потребует огромного объема памяти, а поразрядная сортировка позволяет этого избежать.</p> <p>Поразрядная сортировка (radix sort) по своей основной идее совпадает с сортировкой подсчетом и тоже реализует сортировку через подсчет количества. При этом поразрядная сортировка использует соотношение между разрядами числа и последовательно сортирует данные по каждому разряду, получая итоговый упорядоченный результат.</p>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   Алгоритм","text":"<p>Рассмотрим пример со студенческими номерами: будем считать, что младший разряд имеет номер \\(1\\) , а старший - номер \\(8\\) . Тогда процесс поразрядной сортировки показан на рисунке 11-18.</p> <ol> <li>Инициализировать номер разряда \\(k = 1\\) .</li> <li>Выполнить \"сортировку подсчетом\" по \\(k\\)-му разряду студенческого номера. После этого данные будут упорядочены по \\(k\\)-му разряду по возрастанию.</li> <li>Увеличить \\(k\\) на \\(1\\) и вернуться к шагу <code>2.</code> , продолжая процесс, пока сортировка не будет выполнена для всех разрядов.</li> </ol> <p></p> <p> Рисунок 11-18   Процесс поразрядной сортировки </p> <p>Ниже разберем реализацию кода. Для числа \\(x\\) в системе счисления с основанием \\(d\\) получить его \\(k\\)-й разряд \\(x_k\\) можно по формуле:</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>где \\(\\lfloor a \\rfloor\\) обозначает округление числа \\(a\\) вниз, а \\(\\bmod \\: d\\) означает взятие остатка по модулю \\(d\\) . Для студенческих номеров выполняется \\(d = 10\\) и \\(k \\in [1, 8]\\) .</p> <p>Кроме того, нам нужно слегка изменить код сортировки подсчетом, чтобы он мог сортировать числа по их \\(k\\)-му разряду:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"Получить k-й разряд элемента num, где exp = 10^(k-1)\"\"\"\n    # Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"Сортировка подсчетом (сортировка по k-му разряду nums)\"\"\"\n    # Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    counter = [0] * 10\n    n = len(nums)\n    # Подсчитать число появлений каждой цифры от 0 до 9\n    for i in range(n):\n        d = digit(nums[i], exp)  # Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1  # Подсчитать число появлений цифры d\n    # Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # Получить индекс j цифры d в массиве\n        res[j] = nums[i]  # Поместить текущий элемент по индексу j\n        counter[d] -= 1  # Уменьшить количество d на 1\n    # Перезаписать исходный массив nums результатом\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"Поразрядная сортировка\"\"\"\n    # Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    m = max(nums)\n    # Проходить разряды от младшего к старшему\n    exp = 1\n    while exp &lt;= m:\n        # Выполнить сортировку подсчетом по k-му разряду элементов массива\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # то есть exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = *max_element(nums.begin(), nums.end());\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(int[] nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int[] counter = new int[10];\n    int n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(int[] nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++;                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nvoid RadixSort(int[] nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunc countingSortDigit(nums []int, exp int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    counter := make([]int, 10)\n    n := len(nums)\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++             // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i]    // Поместить текущий элемент по индексу j\n        counter[d]--        // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* Поразрядная сортировка */\nfunc radixSort(nums []int) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    var counter = Array(repeating: 0, count: 10)\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1 // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i] // Поместить текущий элемент по индексу j\n        counter[d] -= 1 // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* Поразрядная сортировка */\nfunc radixSort(nums: inout [Int]) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return Math.floor(num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunction countingSortDigit(nums, exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d]--; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nfunction radixSort(nums) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m = Math.max(... nums);\n    // Проходить разряды от младшего к старшему\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return Math.floor(num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d]--; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* Поразрядная сортировка */\nfunction radixSort(nums: number[]): void {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m: number = Math.max(... nums);\n    // Проходить разряды от младшего к старшему\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* Получить k-й разряд элемента _num, где exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n  return (_num ~/ exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // Подсчитать число появлений каждой цифры от 0 до 9\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n    counter[d]++; // Подсчитать число появлений цифры d\n  }\n  // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n    res[j] = nums[i]; // Поместить текущий элемент по индексу j\n    counter[d]--; // Уменьшить количество d на 1\n  }\n  // Перезаписать исходный массив nums результатом\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(List&lt;int&gt; nums) {\n  // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n  // В dart длина int составляет 64 бита\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // Проходить разряды от младшего к старшему\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // Выполнить сортировку подсчетом по k-му разряду элементов массива\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // то есть exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return ((num / exp) % 10) as usize;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for i in 0..n {\n        let d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d\n        counter[d] += 1; // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i]; // Поместить текущий элемент по индексу j\n        counter[d] -= 1; // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    nums.copy_from_slice(&amp;res);\n}\n\n/* Поразрядная сортировка */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    let m = *nums.into_iter().max().unwrap();\n    // Проходить разряды от младшего к старшему\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10;\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // Инициализировать нулем для последующего освобождения памяти\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (int i = 0; i &lt; size; i++) {\n        // Получить k-й разряд nums[i], обозначив его как d\n        int d = digit(nums[i], exp);\n        // Подсчитать число появлений цифры d\n        counter[d]++;\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // Получить индекс j цифры d в массиве\n        res[j] = nums[i];       // Поместить текущий элемент по индексу j\n        counter[d]--;           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // Освободить память\n    free(res);\n    free(counter);\n}\n\n/* Поразрядная сортировка */\nvoid radixSort(int nums[], int size) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // Проходить разряды от младшего к старшему\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* Получить k-й разряд элемента num, где exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени\n    return (num / exp) % 10\n}\n\n/* Сортировка подсчетом (сортировка по k-му разряду nums) */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n    val counter = IntArray(10)\n    val n = nums.size\n    // Подсчитать число появлений каждой цифры от 0 до 9\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d\n        counter[d]++                // Подсчитать число появлений цифры d\n    }\n    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // Получить индекс j цифры d в массиве\n        res[j] = nums[i]       // Поместить текущий элемент по индексу j\n        counter[d]--           // Уменьшить количество d на 1\n    }\n    // Перезаписать исходный массив nums результатом\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* Поразрядная сортировка */\nfun radixSort(nums: IntArray) {\n    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // Проходить разряды от младшего к старшему\n    while (exp &lt;= m) {\n        // Выполнить сортировку подсчетом по k-му разряду элементов массива\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // то есть exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### Получить k-й разряд элемента num, где exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени\n  (num / exp) % 10\nend\n\n### Получить k-й разряд элемента num, где exp = 10^(k-1) ###\ndef digit(num, exp)\n  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени\n  (num / exp) % 10\nend\n\n# ## Сортировка подсчетом (сортировка по k-му разряду nums) ###\ndef counting_sort_digit(nums, exp)\n  # Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10\n  counter = Array.new(10, 0)\n  n = nums.length\n  # Подсчитать число появлений каждой цифры от 0 до 9\n  for i in 0...n\n    d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d\n    counter[d] += 1 # Подсчитать число появлений цифры d\n  end\n  # Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # Выполняя обратный проход, заполнить res элементами по статистике в корзинах\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # Получить индекс j цифры d в массиве\n    res[j] = nums[i] # Поместить текущий элемент по индексу j\n    counter[d] -= 1 # Уменьшить количество d на 1\n  end\n  # Перезаписать исходный массив nums результатом\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### Поразрядная сортировка ###\ndef radix_sort(nums)\n  # Получить максимальный элемент массива, чтобы определить максимальное число разрядов\n  m = nums.max\n  # Проходить разряды от младшего к старшему\n  exp = 1\n  while exp &lt;= m\n    # Выполнить сортировку подсчетом по k-му разряду элементов массива\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # то есть exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Почему сортировка выполняется от младшего разряда к старшему?</p> <p>В последовательных раундах сортировки результаты более позднего раунда перекрывают результаты предыдущего. Например, если после первого раунда получилось \\(a &lt; b\\) , а после второго - \\(a &gt; b\\) , то именно результат второго раунда станет окончательным. Поскольку старшие разряды имеют более высокий приоритет, сначала нужно сортировать по младшим разрядам, а затем по старшим.</p>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   Характеристики алгоритма","text":"<p>По сравнению с сортировкой подсчетом поразрядная сортировка подходит для случаев с большим диапазоном чисел, но только при условии, что данные можно представить в виде чисел фиксированной длины и число разрядов не слишком велико. Например, числа с плавающей запятой плохо подходят для поразрядной сортировки, потому что число разрядов \\(k\\) слишком велико и может привести к ситуации \\(O(nk) \\gg O(n^2)\\) .</p> <ul> <li>Временная сложность равна \\(O(nk)\\), алгоритм не является адаптивным: пусть объем данных равен \\(n\\) , числа записаны в системе счисления с основанием \\(d\\) , а максимальное число разрядов равно \\(k\\) . Тогда выполнение сортировки подсчетом для одного разряда требует \\(O(n + d)\\) времени, а сортировка по всем \\(k\\) разрядам требует \\(O((n + d)k)\\) времени. Обычно \\(d\\) и \\(k\\) сравнительно малы, поэтому временная сложность стремится к \\(O(n)\\) .</li> <li>Пространственная сложность равна \\(O(n + d)\\), сортировка не выполняется на месте: как и в сортировке подсчетом, здесь требуются массивы <code>res</code> и <code>counter</code> длины \\(n\\) и \\(d\\) .</li> <li>Стабильная сортировка: если сортировка подсчетом стабильна, то и поразрядная сортировка стабильна; если же сортировка подсчетом нестабильна, поразрядная сортировка не может гарантировать корректный результат.</li> </ul>","path":["Глава 11. Сортировка","11.10 &nbsp; Поразрядная сортировка"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   Сортировка выбором","text":"<p>Сортировка выбором (selection sort) работает очень просто: запускается цикл, и на каждом шаге из неотсортированного диапазона выбирается минимальный элемент, после чего он переносится в конец уже отсортированного диапазона.</p> <p>Пусть длина массива равна \\(n\\) ; тогда процесс сортировки выбором выглядит так, как показано на рисунке 11-2.</p> <ol> <li>В начальном состоянии все элементы не отсортированы, то есть неотсортированный диапазон индексов равен \\([0, n-1]\\) .</li> <li>Выбрать минимальный элемент из диапазона \\([0, n-1]\\) и поменять его местами с элементом в позиции \\(0\\) . После этого первый элемент массива отсортирован.</li> <li>Выбрать минимальный элемент из диапазона \\([1, n-1]\\) и поменять его местами с элементом в позиции \\(1\\) . После этого первые два элемента массива отсортированы.</li> <li>Продолжать по аналогии. После \\(n - 1\\) раундов выбора и обмена первые \\(n - 1\\) элементов массива будут отсортированы.</li> <li>Оставшийся элемент обязательно является максимальным, сортировать его не нужно, поэтому массив считается отсортированным.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 11-2   Шаги сортировки выбором </p> <p>В коде мы используем \\(k\\) для записи минимального элемента в пределах неотсортированного диапазона:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"Сортировка выбором\"\"\"\n    n = len(nums)\n    # Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in range(n - 1):\n        # Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # Записать индекс минимального элемента\n        # Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* Сортировка выбором */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* Сортировка выбором */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* Сортировка выбором */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* Сортировка выбором */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // Записать индекс минимального элемента\n                k = j\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* Сортировка выбором */\nfunc selectionSort(nums: inout [Int]) {\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in nums.indices.dropLast() {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* Сортировка выбором */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* Сортировка выбором */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* Сортировка выбором */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // Внешний цикл: неотсортированный диапазон [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // Записать индекс минимального элемента\n    }\n    // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* Сортировка выбором */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for i in 0..n - 1 {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // Записать индекс минимального элемента\n            }\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* Сортировка выбором */\nvoid selectionSort(int nums[], int n) {\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* Сортировка выбором */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // Внешний цикл: неотсортированный диапазон [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // Записать индекс минимального элемента\n        }\n        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### Сортировка выбором ###\ndef selection_sort(nums)\n  n = nums.length\n  # Внешний цикл: неотсортированный диапазон [i, n-1]\n  for i in 0...(n - 1)\n    # Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # Записать индекс минимального элемента\n      end\n    end\n    # Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 11. Сортировка","11.2 &nbsp; Сортировка выбором"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   Характеристики алгоритма","text":"<ul> <li>Временная сложность равна \\(O(n^2)\\), сортировка не является адаптивной: внешний цикл выполняется \\(n - 1\\) раз; в первом раунде длина неотсортированного диапазона равна \\(n\\) , а в последнем - \\(2\\) , то есть отдельные раунды содержат \\(n\\), \\(n - 1\\), \\(\\dots\\), \\(3\\), \\(2\\) проходов внутреннего цикла, их сумма равна \\(\\frac{(n - 1)(n + 2)}{2}\\) .</li> <li>Пространственная сложность равна \\(O(1)\\), сортировка выполняется на месте: указатели \\(i\\) и \\(j\\) используют константный объем дополнительной памяти.</li> <li>Нестабильная сортировка: как показано на рисунке 11-3, элемент <code>nums[i]</code> может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.</li> </ul> <p> Рисунок 11-3   Пример нестабильности сортировки выбором </p>","path":["Глава 11. Сортировка","11.2 &nbsp; Сортировка выбором"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   Алгоритмы сортировки","text":"<p>Алгоритмы сортировки (sorting algorithm) используются для упорядочивания набора данных по определенному правилу. Они применяются очень широко, потому что упорядоченные данные обычно проще анализировать, обрабатывать и искать в них нужные элементы.</p> <p>Как показано на рисунке 11-1, данными в алгоритмах сортировки могут быть целые числа, числа с плавающей запятой, символы, строки и другие типы. Критерий сравнения тоже можно задать по-разному, например по величине чисел, по порядку ASCII-кодов символов или по пользовательскому правилу.</p> <p></p> <p> Рисунок 11-1   Примеры типов данных и правил сравнения </p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   Критерии оценки","text":"<p>Скорость выполнения: мы ожидаем, что временная сложность алгоритма сортировки будет как можно ниже, а общее число операций будет как можно меньше (то есть константа во временной сложности будет небольшой). Для больших объемов данных этот критерий особенно важен.</p> <p>Сортировка на месте: как следует из названия, сортировка на месте выполняется прямо в исходном массиве и не требует дополнительного вспомогательного массива, что позволяет экономить память. Обычно при сортировке на месте переносов данных меньше, а скорость работы выше.</p> <p>Стабильность: стабильная сортировка после завершения не меняет относительный порядок одинаковых элементов в массиве.</p> <p>Стабильность является необходимым условием для многоуровневой сортировки. Предположим, у нас есть таблица со сведениями о студентах, где в первом и втором столбцах записаны имя и возраст. В этом случае нестабильная сортировка может разрушить уже существующий порядок входных данных:</p> <pre><code># Входные данные уже отсортированы по имени\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# Если затем нестабильным алгоритмом отсортировать список по возрасту,\n# относительный порядок ('D', 19) и ('A', 19) изменится,\n# и свойство упорядоченности по имени будет потеряно\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>Адаптивность: адаптивная сортировка умеет использовать уже существующий порядок входных данных, чтобы сократить вычисления и добиться лучшей эффективности. Лучшая временная сложность адаптивных алгоритмов обычно лучше их средней временной сложности.</p> <p>Основанность на сравнении: сортировка на основе сравнений использует операторы сравнения (\\(&lt;\\), \\(=\\), \\(&gt;\\)), чтобы определить относительный порядок элементов и отсортировать массив; ее теоретически лучшая временная сложность равна \\(O(n \\log n)\\) . А вот сортировка без сравнений не опирается на операторы сравнения, поэтому может достигать \\(O(n)\\) , но универсальность у нее ниже.</p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   Идеальный алгоритм сортировки","text":"<p>Быстрый, выполняющийся на месте, стабильный, адаптивный и универсальный. Очевидно, что на сегодняшний день не существует алгоритма сортировки, который одновременно обладал бы всеми этими свойствами. Поэтому при выборе алгоритма сортировки нужно исходить из конкретных особенностей данных и требований задачи.</p> <p>Далее мы последовательно изучим разные алгоритмы сортировки и на основании приведенных выше критериев разберем их преимущества и недостатки.</p>","path":["Глава 11. Сортировка","11.1 &nbsp; Алгоритмы сортировки"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   Резюме","text":"","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   Ключевые выводы","text":"<ul> <li>Сортировка пузырьком выполняет сортировку за счет обмена соседних элементов. Если добавить флаг для досрочного выхода, лучшую временную сложность пузырьковой сортировки можно оптимизировать до \\(O(n)\\) .</li> <li>Сортировка вставками на каждом раунде вставляет элемент из неотсортированного диапазона в правильную позицию внутри отсортированного диапазона. Хотя ее временная сложность равна \\(O(n^2)\\) , она очень популярна для задач сортировки небольших массивов, поскольку число элементарных операций у нее сравнительно невелико.</li> <li>Быстрая сортировка основана на операции разделения с опорным элементом. При неудачном выборе опорного элемента на каждом раунде ее временная сложность может деградировать до \\(O(n^2)\\) . Использование медианы трех элементов или случайного опорного элемента уменьшает вероятность этой деградации. Если всегда рекурсивно обрабатывать более короткий поддиапазон первым, можно эффективно уменьшить глубину рекурсии и оптимизировать пространственную сложность до \\(O(\\log n)\\) .</li> <li>Сортировка слиянием включает этапы разделения и слияния и служит типичным проявлением стратегии \"разделяй и властвуй\". Для сортировки массива ей требуется вспомогательный массив, поэтому пространственная сложность равна \\(O(n)\\) ; однако при сортировке связного списка пространственную сложность можно оптимизировать до \\(O(1)\\) .</li> <li>Блочная сортировка включает три этапа: распределение данных по блокам, сортировку внутри блоков и объединение результатов. Она тоже отражает стратегию \"разделяй и властвуй\" и подходит для очень больших объемов данных. Ключ к эффективности блочной сортировки - равномерное распределение данных.</li> <li>Сортировка подсчетом является частным случаем блочной сортировки; она реализует сортировку через подсчет числа вхождений данных. Сортировка подсчетом подходит для случаев, когда объем данных велик, но диапазон значений ограничен, и при этом данные можно преобразовать в положительные целые числа.</li> <li>Поразрядная сортировка выполняет сортировку данных путем последовательной сортировки по каждому разряду и требует, чтобы данные можно было представить в виде чисел фиксированной разрядности.</li> <li>В общем случае нам хотелось бы найти алгоритм сортировки, который одновременно обладал бы высокой эффективностью, стабильностью, выполнением на месте и адаптивностью. Но, как и в других разделах алгоритмов и структур данных, не существует одного алгоритма сортировки, способного удовлетворить всем этим требованиям одновременно. На практике приходится выбирать подходящий алгоритм в зависимости от свойств данных.</li> <li>На рисунке 11-19 сравниваются эффективность, стабильность, выполнение на месте и адаптивность основных алгоритмов сортировки.</li> </ul> <p> Рисунок 11-19   Сравнение алгоритмов сортировки </p>","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_sorting/summary/#2","level":3,"title":"2.   Вопросы и ответы","text":"<p>В: В каких случаях стабильность алгоритма сортировки является обязательной?</p> <p>В реальных задачах нам может понадобиться сортировать объекты по некоторому атрибуту. Например, у студентов есть два атрибута: имя и рост. Мы хотим выполнить многоуровневую сортировку: сначала отсортировать по имени и получить <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> , а затем отсортировать по росту. Если используемый алгоритм сортировки нестабилен, то мы можем получить <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> .</p> <p>Нетрудно увидеть, что в этом случае студенты D и C поменялись местами, порядок по имени разрушился, а именно этого мы и не хотим.</p> <p>В: Можно ли поменять местами порядок \"поиска справа налево\" и \"поиска слева направо\" в разделении с опорным элементом?</p> <p>Нет. Если в качестве опорного элемента выбирается самый левый элемент, необходимо сначала выполнять \"поиск справа налево\", а уже затем - \"поиск слева направо\". Этот вывод кажется немного неочевидным, поэтому разберем его подробнее.</p> <p>Последний шаг <code>partition()</code> - это обмен <code>nums[left]</code> и <code>nums[i]</code> . После обмена все элементы слева от опорного должны быть <code>&lt;=</code> опорного, а значит, перед этим обменом должно выполняться условие <code>nums[left] &gt;= nums[i]</code>. Если сначала выполнять \"поиск слева направо\", то в случае, когда не удается найти элемент больше опорного, цикл завершится в состоянии <code>i == j</code> , и при этом может оказаться, что <code>nums[j] == nums[i] &gt; nums[left]</code>. Иными словами, на последнем шаге обмена элемент, больший опорного, будет помещен в начало массива, из-за чего разделение завершится неверно.</p> <p>Например, для массива <code>[0, 0, 0, 0, 1]</code> , если сначала выполнять \"поиск слева направо\", после разделения получится <code>[1, 0, 0, 0, 0]</code> , а это неправильный результат.</p> <p>Если же выбрать <code>nums[right]</code> в качестве опорного элемента, то ситуация станет противоположной, и тогда сначала нужно выполнять \"поиск слева направо\".</p> <p>В: Почему при оптимизации глубины рекурсии в быстрой сортировке выбор короткого массива гарантирует, что глубина рекурсии не превысит \\(\\log n\\) ?</p> <p>Глубина рекурсии - это число текущих рекурсивных вызовов, которые еще не завершились. На каждом раунде разделения исходный массив разбивается на два подмассива. После оптимизации глубины рекурсии длина подмассива, в который мы продолжаем рекурсивный спуск, не превышает половины длины исходного массива. Если рассматривать худший случай, когда длина каждый раз становится ровно вдвое меньше, итоговая глубина рекурсии и будет равна \\(\\log n\\) .</p> <p>В исходной версии быстрой сортировки может происходить последовательный рекурсивный вызов для более длинных массивов; в худшем случае это будут длины \\(n\\) , \\(n - 1\\) , \\(\\dots\\) , \\(2\\) , \\(1\\) , а глубина рекурсии окажется равной \\(n\\) . Оптимизация глубины рекурсии как раз и позволяет избежать такого сценария.</p> <p>В: Если все элементы массива равны, будет ли временная сложность быстрой сортировки равна \\(O(n^2)\\) ? Как справиться с таким вырождением?</p> <p>Да. Для этого случая можно рассмотреть разделение массива на три части: элементы меньше опорного, равные опорному и большие опорного. Рекурсию нужно продолжать только для частей меньше и больше опорного. При таком подходе массив, целиком состоящий из одинаковых элементов, будет отсортирован всего за один раунд разделения.</p> <p>В: Почему худшая временная сложность блочной сортировки равна \\(O(n^2)\\) ?</p> <p>В худшем случае все элементы попадут в один и тот же блок. Если затем сортировать этот блок алгоритмом со сложностью \\(O(n^2)\\) , то общая временная сложность тоже станет \\(O(n^2)\\) .</p>","path":["Глава 11. Сортировка","11.11 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"Глава 5.   Стек и очередь","text":"<p>Abstract</p> <p>Стек и очередь - две базовые линейные структуры данных.</p> <p>Они соответственно воплощают принципы \"последним пришел - первым вышел\" и \"первым пришел - первым вышел\".</p>","path":["Глава 5. Стек и очередь","Глава 5. &nbsp; Стек и очередь"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>5.1   Стек</li> <li>5.2   Очередь</li> <li>5.3   Двусторонняя очередь</li> <li>5.4   Резюме</li> </ul>","path":["Глава 5. Стек и очередь","Глава 5. &nbsp; Стек и очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   Двусторонняя очередь","text":"<p>В обычной очереди мы можем удалять элементы только из головы и добавлять их только в хвост. Как показано на рисунке 5-7, двусторонняя очередь (double-ended queue) обеспечивает большую гибкость и позволяет выполнять добавление и удаление элементов как с головы, так и с хвоста.</p> <p></p> <p> Рисунок 5-7   Операции двусторонней очереди </p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   Основные операции с двусторонней очередью","text":"<p>Распространенные операции двусторонней очереди приведены в таблице 5-3. Конкретные названия методов зависят от используемого языка программирования.</p> <p> Таблица 5-3   Эффективность операций двусторонней очереди </p> Имя метода Описание Временная сложность <code>push_first()</code> Добавить элемент в голову очереди \\(O(1)\\) <code>push_last()</code> Добавить элемент в хвост очереди \\(O(1)\\) <code>pop_first()</code> Удалить элемент из головы очереди \\(O(1)\\) <code>pop_last()</code> Удалить элемент из хвоста очереди \\(O(1)\\) <code>peek_first()</code> Просмотреть элемент в голове очереди \\(O(1)\\) <code>peek_last()</code> Просмотреть элемент в хвосте очереди \\(O(1)\\) <p>Точно так же мы можем напрямую использовать уже реализованные в языках программирования классы двусторонней очереди:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# Инициализация двусторонней очереди\ndeq: deque[int] = deque()\n\n# Поместить элементы в очередь\ndeq.append(2)      # Добавить в хвост\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # Добавить в голову\ndeq.appendleft(1)\n\n# Просмотреть элементы\nfront: int = deq[0]  # Элемент в голове\nrear: int = deq[-1]  # Элемент в хвосте\n\n# Извлечь элементы из очереди\npop_front: int = deq.popleft()  # Извлечь элемент из головы\npop_rear: int = deq.pop()       # Извлечь элемент из хвоста\n\n# Получить длину двусторонней очереди\nsize: int = len(deq)\n\n# Проверить, пуста ли двусторонняя очередь\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* Инициализация двусторонней очереди */\ndeque&lt;int&gt; deque;\n\n/* Поместить элементы в очередь */\ndeque.push_back(2);   // Добавить в хвост\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Добавить в голову\ndeque.push_front(1);\n\n/* Просмотреть элементы */\nint front = deque.front(); // Элемент в голове\nint back = deque.back();   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.pop_front();  // Извлечь элемент из головы\ndeque.pop_back();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.size();\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* Инициализация двусторонней очереди */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* Поместить элементы в очередь */\ndeque.offerLast(2);   // Добавить в хвост\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Добавить в голову\ndeque.offerFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.peekFirst();  // Элемент в голове\nint peekLast = deque.peekLast();    // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nint popFirst = deque.pollFirst();  // Извлечь элемент из головы\nint popLast = deque.pollLast();    // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.size();\n\n/* Проверить, пуста ли двусторонняя очередь */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* Инициализация двусторонней очереди */\n// В C# двустороннюю очередь обычно моделируют через связный список LinkedList\nLinkedList&lt;int&gt; deque = new();\n\n/* Поместить элементы в очередь */\ndeque.AddLast(2);   // Добавить в хвост\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Добавить в голову\ndeque.AddFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.First.Value;  // Элемент в голове\nint peekLast = deque.Last.Value;    // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.RemoveFirst();  // Извлечь элемент из головы\ndeque.RemoveLast();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.Count;\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* Инициализация двусторонней очереди */\n// В Go list обычно используется как двусторонняя очередь\ndeque := list.New()\n\n/* Поместить элементы в очередь */\ndeque.PushBack(2)      // Добавить в хвост\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Добавить в голову\ndeque.PushFront(1)\n\n/* Просмотреть элементы */\nfront := deque.Front() // Элемент в голове\nrear := deque.Back()   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\ndeque.Remove(front)    // Извлечь элемент из головы\ndeque.Remove(rear)     // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nsize := deque.Len()\n\n/* Проверить, пуста ли двусторонняя очередь */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* Инициализация двусторонней очереди */\n// В Swift нет встроенного класса двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nvar deque: [Int] = []\n\n/* Поместить элементы в очередь */\ndeque.append(2) // Добавить в хвост\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Добавить в голову\ndeque.insert(1, at: 0)\n\n/* Просмотреть элементы */\nlet peekFirst = deque.first! // Элемент в голове\nlet peekLast = deque.last! // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\n// При моделировании через Array сложность popFirst равна O(n)\nlet popFirst = deque.removeFirst() // Извлечь элемент из головы\nlet popLast = deque.removeLast() // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nlet size = deque.count\n\n/* Проверить, пуста ли двусторонняя очередь */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* Инициализация двусторонней очереди */\n// В JavaScript нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nconst deque = [];\n\n/* Поместить элементы в очередь */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Обрати внимание: поскольку это массив, метод unshift() имеет сложность O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Просмотреть элементы */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* Извлечь элементы из очереди */\n// Обрати внимание: поскольку это массив, метод shift() имеет сложность O(n)\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* Получить длину двусторонней очереди */\nconst size = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* Инициализация двусторонней очереди */\n// В TypeScript нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\nconst deque: number[] = [];\n\n/* Поместить элементы в очередь */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Обрати внимание: поскольку это массив, метод unshift() имеет сложность O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Просмотреть элементы */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* Извлечь элементы из очереди */\n// Обрати внимание: поскольку это массив, метод shift() имеет сложность O(n)\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* Получить длину двусторонней очереди */\nconst size: number = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* Инициализация двусторонней очереди */\n// В Dart Queue определена как двусторонняя очередь\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* Поместить элементы в очередь */\ndeque.addLast(2);  // Добавить в хвост\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Добавить в голову\ndeque.addFirst(1);\n\n/* Просмотреть элементы */\nint peekFirst = deque.first; // Элемент в голове\nint peekLast = deque.last;   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nint popFirst = deque.removeFirst(); // Извлечь элемент из головы\nint popLast = deque.removeLast();   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nint size = deque.length;\n\n/* Проверить, пуста ли двусторонняя очередь */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* Инициализация двусторонней очереди */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Поместить элементы в очередь */\ndeque.push_back(2);  // Добавить в хвост\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Добавить в голову\ndeque.push_front(1);\n\n/* Просмотреть элементы */\nif let Some(front) = deque.front() { // Элемент в голове\n}\nif let Some(rear) = deque.back() {   // Элемент в хвосте\n}\n\n/* Извлечь элементы из очереди */\nif let Some(pop_front) = deque.pop_front() { // Извлечь элемент из головы\n}\nif let Some(pop_rear) = deque.pop_back() {   // Извлечь элемент из хвоста\n}\n\n/* Получить длину двусторонней очереди */\nlet size = deque.len();\n\n/* Проверить, пуста ли двусторонняя очередь */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// В C нет встроенной двусторонней очереди\n</code></pre> deque.kt<pre><code>/* Инициализация двусторонней очереди */\nval deque = LinkedList&lt;Int&gt;()\n\n/* Поместить элементы в очередь */\ndeque.offerLast(2)  // Добавить в хвост\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // Добавить в голову\ndeque.offerFirst(1)\n\n/* Просмотреть элементы */\nval peekFirst = deque.peekFirst() // Элемент в голове\nval peekLast = deque.peekLast()   // Элемент в хвосте\n\n/* Извлечь элементы из очереди */\nval popFirst = deque.pollFirst() // Извлечь элемент из головы\nval popLast = deque.pollLast()   // Извлечь элемент из хвоста\n\n/* Получить длину двусторонней очереди */\nval size = deque.size\n\n/* Проверить, пуста ли двусторонняя очередь */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># Инициализация двусторонней очереди\n# В Ruby нет встроенной двусторонней очереди, поэтому можно использовать Array как двустороннюю очередь\ndeque = []\n\n# Поместить элементы в очередь\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# Обрати внимание: поскольку это массив, метод Array#unshift имеет сложность O(n)\ndeque.unshift(3)\ndeque.unshift(1)\n\n# Просмотреть элементы\npeek_first = deque.first\npeek_last = deque.last\n\n# Извлечь элементы из очереди\n# Обрати внимание: поскольку это массив, метод Array#shift имеет сложность O(n)\npop_front = deque.shift\npop_back = deque.pop\n\n# Получить длину двусторонней очереди\nsize = deque.length\n\n# Проверить, пуста ли двусторонняя очередь\nis_empty = size.zero?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8E%D1%8E%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20deq.append%282%29%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D0%B2%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%83%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20deque%20%3D%22%2C%20deq%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%20%D0%BA%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%83%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20front%20%3D%22%2C%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20rear%20%3D%22%2C%20rear%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%8B%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20pop_front%20%3D%22%2C%20pop_front%29%0A%20%20%20%20print%28%22deque%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B8%D0%B7%20%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D1%8B%20%3D%22%2C%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20pop_rear%20%3D%22%2C%20pop_rear%29%0A%20%20%20%20print%28%22deque%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B8%D0%B7%20%D1%85%D0%B2%D0%BE%D1%81%D1%82%D0%B0%20%3D%22%2C%20deq%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%D0%B9%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D0%B5%D0%B9%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8F%D1%8F%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   Реализация двусторонней очереди *","text":"<p>Реализация двусторонней очереди похожа на реализацию обычной очереди: в качестве базовой структуры данных можно выбрать связный список или массив.</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   Реализация на основе двусвязного списка","text":"<p>Вспомним предыдущий раздел: там мы использовали обычный односвязный список для реализации очереди, потому что он позволяет удобно удалять головной узел, что соответствует операции <code>dequeue</code> , и добавлять новый узел после хвостового узла, что соответствует операции <code>enqueue</code> .</p> <p>Для двусторонней очереди и голова, и хвост допускают операции добавления и удаления элементов. Иначе говоря, двусторонняя очередь требует реализации еще одного симметричного направления операций. Поэтому в качестве базовой структуры данных двусторонней очереди удобно использовать двусвязный список.</p> <p>Как показано на рисунках ниже, мы рассматриваем головной и хвостовой узлы двусвязного списка как голову и хвост двусторонней очереди и одновременно реализуем функции добавления и удаления узлов с обеих сторон.</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 5-8   Операции enqueue и dequeue для двусторонней очереди на связном списке </p> <p>Код реализации приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"Узел двусвязного списка\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"Конструктор\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # Ссылка на узел-преемник\n        self.prev: ListNode | None = None  # Ссылка на узел-предшественник\n\nclass LinkedListDeque:\n    \"\"\"Двусторонняя очередь на основе двусвязного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._front: ListNode | None = None  # Головной узел front\n        self._rear: ListNode | None = None  # Хвостовой узел rear\n        self._size: int = 0  # Длина двусторонней очереди\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины двусторонней очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли двусторонняя очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"Операция добавления в очередь\"\"\"\n        node = ListNode(num)\n        # Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if self.is_empty():\n            self._front = self._rear = node\n        # Операция добавления в голову очереди\n        elif is_front:\n            # Добавить node в голову списка\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # Обновить головной узел\n        # Операция добавления в хвост очереди\n        else:\n            # Добавить node в хвост списка\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # Обновить хвостовой узел\n        self._size += 1  # Обновить длину очереди\n\n    def push_first(self, num: int):\n        \"\"\"Добавление в голову очереди\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"Добавление в хвост очереди\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"Операция извлечения из очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        # Операция извлечения из головы очереди\n        if is_front:\n            val: int = self._front.val  # Временно сохранить значение головного узла\n            # Удалить головной узел\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # Обновить головной узел\n        # Операция извлечения из хвоста очереди\n        else:\n            val: int = self._rear.val  # Временно сохранить значение хвостового узла\n            # Удалить хвостовой узел\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # Обновить хвостовой узел\n        self._size -= 1  # Обновить длину очереди\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Извлечение из головы очереди\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Извлечение из хвоста очереди\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Доступ к элементу в конце очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть массив для вывода\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* Узел двусвязного списка */\nstruct DoublyListNode {\n    int val;              // Значение узла\n    DoublyListNode *next; // Указатель на узел-преемник\n    DoublyListNode *prev; // Указатель на узел-предшественник\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize = 0;              // Длина двусторонней очереди\n\n  public:\n    /* Конструктор */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* Метод-деструктор */\n    ~LinkedListDeque() {\n        // Обходить связный список, удалять узлы и освобождать память\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* Получение длины двусторонней очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty())\n            front = rear = node;\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // Обновить головной узел\n        // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // Обновить хвостовой узел\n        }\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"очередь пуста\");\n        int val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front-&gt;val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // Обновить головной узел\n        // Операция извлечения из хвоста очереди\n        } else {\n            val = rear-&gt;val; // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // Обновить хвостовой узел\n        }\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return front-&gt;val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return rear-&gt;val;\n    }\n\n    /* Вернуть массив для вывода */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    int val; // Значение узла\n    ListNode next; // Ссылка на узел-преемник\n    ListNode prev; // Ссылка на узел-предшественник\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private ListNode front, rear; // Головной узел front, хвостовой узел rear\n    private int queSize = 0; // Длина двусторонней очереди\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty())\n            front = rear = node;\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front.prev = node;\n            node.next = front;\n            front = node; // Обновить головной узел\n        // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // Обновить хвостовой узел\n        }\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front.val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // Обновить головной узел\n        // Операция извлечения из хвоста очереди\n        } else {\n            val = rear.val; // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // Обновить хвостовой узел\n        }\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* Узел двусвязного списка */\nclass ListNode(int val) {\n    public int val = val;       // Значение узла\n    public ListNode? next = null; // Ссылка на узел-преемник\n    public ListNode? prev = null; // Ссылка на узел-предшественник\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    ListNode? front, rear; // Головной узел front, хвостовой узел rear\n    int queSize = 0;      // Длина двусторонней очереди\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Операция добавления в очередь */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // Операция добавления в голову очереди\n        else if (isFront) {\n            // Добавить node в голову списка\n            front!.prev = node;\n            node.next = front;\n            front = node; // Обновить головной узел\n        }\n        // Операция добавления в хвост очереди\n        else {\n            // Добавить node в хвост списка\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // Обновить хвостовой узел\n        }\n\n        queSize++; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            val = front?.val; // Временно сохранить значение головного узла\n            // Удалить головной узел\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // Обновить головной узел\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            val = rear?.val;  // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // Обновить хвостовой узел\n        }\n\n        queSize--; // Обновить длину очереди\n        return val;\n    }\n\n    /* Извлечение из головы очереди */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* Вернуть массив для вывода */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* Двусторонняя очередь на основе двусвязного списка */\ntype linkedListDeque struct {\n    // Использовать встроенный пакет list\n    data *list.List\n}\n\n/* Инициализировать двустороннюю очередь */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* Поместить элемент в голову очереди */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* Поместить элемент в хвост очереди */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь элемент из головы очереди */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Извлечь элемент из хвоста очереди */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Доступ к элементу в конце очереди */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Получение длины очереди */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуста ли очередь */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    var val: Int // Значение узла\n    var next: ListNode? // Ссылка на узел-преемник\n    weak var prev: ListNode? // Ссылка на узел-предшественник\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private var front: ListNode? // Головной узел front\n    private var rear: ListNode? // Хвостовой узел rear\n    private var _size: Int // Длина двусторонней очереди\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины двусторонней очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Операция добавления в очередь */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // Операция добавления в голову очереди\n        else if isFront {\n            // Добавить node в голову списка\n            front?.prev = node\n            node.next = front\n            front = node // Обновить головной узел\n        }\n        // Операция добавления в хвост очереди\n        else {\n            // Добавить node в хвост списка\n            rear?.next = node\n            node.prev = rear\n            rear = node // Обновить хвостовой узел\n        }\n        _size += 1 // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* Добавление в хвост очереди */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* Операция извлечения из очереди */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        let val: Int\n        // Операция извлечения из головы очереди\n        if isFront {\n            val = front!.val // Временно сохранить значение головного узла\n            // Удалить головной узел\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // Обновить головной узел\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            val = rear!.val // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // Обновить хвостовой узел\n        }\n        _size -= 1 // Обновить длину очереди\n        return val\n    }\n\n    /* Извлечение из головы очереди */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* Извлечение из хвоста очереди */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return front!.val\n    }\n\n    /* Доступ к элементу в конце очереди */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return rear!.val\n    }\n\n    /* Вернуть массив для вывода */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    prev; // Ссылка на узел-предшественник (указатель)\n    next; // Ссылка на узел-преемник (указатель)\n    val; // Значение узла\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    #front; // Головной узел front\n    #rear; // Хвостовой узел rear\n    #queSize; // Длина двусторонней очереди\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* Операция добавления в хвост очереди */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Добавить node в хвост списка\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // Обновить хвостовой узел\n        }\n        this.#queSize++;\n    }\n\n    /* Операция добавления в голову очереди */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // Добавить node в голову списка\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // Обновить головной узел\n        }\n        this.#queSize++;\n    }\n\n    /* Операция извлечения из хвоста очереди */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // Сохранить значение хвостового узла\n        // Удалить хвостовой узел\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // Обновить хвостовой узел\n        this.#queSize--;\n        return value;\n    }\n\n    /* Операция извлечения из головы очереди */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // Сохранить значение хвостового узла\n        // Удалить головной узел\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // Обновить головной узел\n        this.#queSize--;\n        return value;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Вывести двустороннюю очередь */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n    prev: ListNode; // Ссылка на узел-предшественник (указатель)\n    next: ListNode; // Ссылка на узел-преемник (указатель)\n    val: number; // Значение узла\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private front: ListNode; // Головной узел front\n    private rear: ListNode; // Хвостовой узел rear\n    private queSize: number; // Длина двусторонней очереди\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* Операция добавления в хвост очереди */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Добавить node в хвост списка\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // Обновить хвостовой узел\n        }\n        this.queSize++;\n    }\n\n    /* Операция добавления в голову очереди */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // Добавить node в голову списка\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // Обновить головной узел\n        }\n        this.queSize++;\n    }\n\n    /* Операция извлечения из хвоста очереди */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // Сохранить значение хвостового узла\n        // Удалить хвостовой узел\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // Обновить хвостовой узел\n        this.queSize--;\n        return value;\n    }\n\n    /* Операция извлечения из головы очереди */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // Сохранить значение хвостового узла\n        // Удалить головной узел\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // Обновить головной узел\n        this.queSize--;\n        return value;\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Вывести двустороннюю очередь */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* Узел двусвязного списка */\nclass ListNode {\n  int val; // Значение узла\n  ListNode? next; // Ссылка на узел-преемник\n  ListNode? prev; // Ссылка на узел-предшественник\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n  late ListNode? _front; // Головной узел _front\n  late ListNode? _rear; // Хвостовой узел _rear\n  int _queSize = 0; // Длина двусторонней очереди\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* Получить длину двусторонней очереди */\n  int size() {\n    return this._queSize;\n  }\n\n  /* Проверка, пуста ли двусторонняя очередь */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* Операция добавления в очередь */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // Если связный список пуст, пусть _front и _rear оба указывают на node\n      _front = _rear = node;\n    } else if (isFront) {\n      // Операция добавления в голову очереди\n      // Добавить node в начало связного списка\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // Обновить головной узел\n    } else {\n      // Операция добавления в хвост очереди\n      // Добавить node в конец связного списка\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // Обновить хвостовой узел\n    }\n    _queSize++; // Обновить длину очереди\n  }\n\n  /* Добавление в голову очереди */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* Добавление в хвост очереди */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* Операция извлечения из очереди */\n  int? pop(bool isFront) {\n    // Если очередь пуста, сразу вернуть null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // Операция извлечения из головы очереди\n      val = _front!.val; // Временно сохранить значение головного узла\n      // Удалить головной узел\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // Обновить головной узел\n    } else {\n      // Операция извлечения из хвоста очереди\n      val = _rear!.val; // Временно сохранить значение хвостового узла\n      // Удалить хвостовой узел\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // Обновить хвостовой узел\n    }\n    _queSize--; // Обновить длину очереди\n    return val;\n  }\n\n  /* Извлечение из головы очереди */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* Извлечение из хвоста очереди */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* Доступ к элементу в конце очереди */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* Вернуть массив для вывода */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* Узел двусвязного списка */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // Значение узла\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Указатель на узел-преемник\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Указатель на узел-предшественник\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Головной узел front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Хвостовой узел rear\n    que_size: usize,                         // Длина двусторонней очереди\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Получение длины двусторонней очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Операция добавления в очередь */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // Операция добавления в голову очереди\n        if is_front {\n            match self.front.take() {\n                // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // Добавить node в голову списка\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // Обновить головной узел\n                }\n            }\n        }\n        // Операция добавления в хвост очереди\n        else {\n            match self.rear.take() {\n                // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // Добавить node в хвост списка\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // Обновить хвостовой узел\n                }\n            }\n        }\n        self.que_size += 1; // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* Добавление в хвост очереди */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* Операция извлечения из очереди */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // Если очередь пуста, сразу вернуть None\n        if self.is_empty() {\n            return None;\n        };\n        // Операция извлечения из головы очереди\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // Обновить головной узел\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // Обновить длину очереди\n                old_front.borrow().val\n            })\n        }\n        // Операция извлечения из хвоста очереди\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // Обновить хвостовой узел\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // Обновить длину очереди\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* Извлечение из головы очереди */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* Извлечение из хвоста очереди */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* Доступ к элементу в начале очереди */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Доступ к элементу в конце очереди */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* Вернуть массив для вывода */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* Узел двусвязного списка */\ntypedef struct DoublyListNode {\n    int val;                     // Значение узла\n    struct DoublyListNode *next; // Узел-преемник\n    struct DoublyListNode *prev; // Узел-предшественник\n} DoublyListNode;\n\n/* Конструктор */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* Деструктор */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\ntypedef struct {\n    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize;                  // Длина двусторонней очереди\n} LinkedListDeque;\n\n/* Конструктор */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Деструктор */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // Освободить все узлы\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Освободить структуру deque\n    free(deque);\n}\n\n/* Получение длины очереди */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* Поместить в очередь */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // Если связный список пуст, пусть front и rear оба указывают на node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // Операция добавления в голову очереди\n    else if (isFront) {\n        // Добавить node в голову списка\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // Обновить головной узел\n    }\n    // Операция добавления в хвост очереди\n    else {\n        // Добавить node в хвост списка\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // Обновить длину очереди\n}\n\n/* Добавление в голову очереди */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* Добавление в хвост очереди */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* Доступ к элементу в начале очереди */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* Доступ к элементу в конце очереди */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* Извлечь из очереди */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // Операция извлечения из головы очереди\n    if (isFront) {\n        val = peekFirst(deque); // Временно сохранить значение головного узла\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // Обновить головной узел\n    }\n    // Операция извлечения из хвоста очереди\n    else {\n        val = peekLast(deque); // Временно сохранить значение хвостового узла\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // Обновить хвостовой узел\n    }\n    deque-&gt;queSize--; // Обновить длину очереди\n    return val;\n}\n\n/* Извлечение из головы очереди */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* Извлечение из хвоста очереди */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* Вывести очередь */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // Скопировать данные связного списка в массив\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* Узел двусвязного списка */\nclass ListNode(var _val: Int) {\n    // Значение узла\n    var next: ListNode? = null // Ссылка на узел-преемник\n    var prev: ListNode? = null // Ссылка на узел-предшественник\n}\n\n/* Двусторонняя очередь на основе двусвязного списка */\nclass LinkedListDeque {\n    private var front: ListNode? = null // Головной узел front\n    private var rear: ListNode? = null // Хвостовой узел rear\n    private var queSize: Int = 0 // Длина двусторонней очереди\n\n    /* Получение длины двусторонней очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Операция добавления в очередь */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // Операция добавления в голову очереди\n        } else if (isFront) {\n            // Добавить node в голову списка\n            front?.prev = node\n            node.next = front\n            front = node // Обновить головной узел\n            // Операция добавления в хвост очереди\n        } else {\n            // Добавить node в хвост списка\n            rear?.next = node\n            node.prev = rear\n            rear = node // Обновить хвостовой узел\n        }\n        queSize++ // Обновить длину очереди\n    }\n\n    /* Добавление в голову очереди */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* Добавление в хвост очереди */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* Операция извлечения из очереди */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // Операция извлечения из головы очереди\n        if (isFront) {\n            _val = front!!._val // Временно сохранить значение головного узла\n            // Удалить головной узел\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // Обновить головной узел\n            // Операция извлечения из хвоста очереди\n        } else {\n            _val = rear!!._val // Временно сохранить значение хвостового узла\n            // Удалить хвостовой узел\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // Обновить хвостовой узел\n        }\n        queSize-- // Обновить длину очереди\n        return _val\n    }\n\n    /* Извлечение из головы очереди */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* Извлечение из хвоста очереди */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* Вернуть массив для вывода */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n# ## Узел двусвязного списка\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # Ссылка на узел-преемник\n  attr_accessor :prev # Ссылка на узел-предшественник\n\n  ### Конструктор ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### Двусторонняя очередь на основе двусвязного списка ###\nclass LinkedListDeque\n  ### Получение длины двусторонней очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @front = nil  # Головной узел front\n    @rear = nil   # Хвостовой узел rear\n    @size = 0     # Длина двусторонней очереди\n  end\n\n  ### Проверка, пуста ли двусторонняя очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Операция добавления в очередь ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # Если связный список пуст, пусть front и rear оба указывают на node\n    if is_empty?\n      @front = @rear = node\n    # Операция добавления в голову очереди\n    elsif is_front\n      # Добавить node в голову списка\n      @front.prev = node\n      node.next = @front\n      @front = node # Обновить головной узел\n    # Операция добавления в хвост очереди\n    else\n      # Добавить node в хвост списка\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # Обновить хвостовой узел\n    end\n    @size += 1 # Обновить длину очереди\n  end\n\n  ### Добавление в голову очереди ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### Добавление в хвост очереди ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### Операция извлечения из очереди ###\n  def pop(is_front)\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    # Операция извлечения из головы очереди\n    if is_front\n      val = @front.val # Временно сохранить значение головного узла\n      # Удалить головной узел\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # Обновить головной узел\n    # Операция извлечения из хвоста очереди\n    else\n      val = @rear.val # Временно сохранить значение хвостового узла\n      # Удалить хвостовой узел\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # Обновить хвостовой узел\n    end\n    @size -= 1 # Обновить длину очереди\n\n    val\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_first\n    pop(true)\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_last\n    pop(false)\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek_first\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @front.val\n  end\n\n  ### Доступ к элементу в хвосте очереди ###\n  def peek_last\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @rear.val\n  end\n\n  ### Вернуть массив для вывода ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Как показано на рисунках ниже, аналогично реализации обычной очереди на массиве мы также можем использовать кольцевой массив для реализации двусторонней очереди.</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 5-9   Операции enqueue и dequeue для двусторонней очереди на массиве </p> <p>На основе реализации обычной очереди нужно лишь добавить методы добавления в голову очереди и удаления из хвоста:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"Двусторонняя очередь на основе кольцевого массива\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"Конструктор\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость двусторонней очереди\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины двусторонней очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли двусторонняя очередь\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"Вычислить индекс в кольцевом массиве\"\"\"\n        # С помощью операции взятия по модулю соединить начало и конец массива\n        # Когда i выходит за конец массива, он возвращается в начало\n        # Когда i выходит за начало массива, он возвращается в конец\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"Добавление в голову очереди\"\"\"\n        if self._size == self.capacity():\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        # Указатель головы сдвигается на одну позицию влево\n        # С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        self._front = self.index(self._front - 1)\n        # Добавить num в голову очереди\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"Добавление в хвост очереди\"\"\"\n        if self._size == self.capacity():\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        rear = self.index(self._front + self._size)\n        # Добавить num в хвост очереди\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"Извлечение из головы очереди\"\"\"\n        num = self.peek_first()\n        # Указатель головы сдвигается на одну позицию назад\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"Извлечение из хвоста очереди\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"Доступ к элементу в конце очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"двусторонняя очередь пуста\")\n        # Вычислить индекс хвостового элемента\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"Вернуть массив для вывода\"\"\"\n        # Преобразовывать только элементы списка в пределах фактической длины\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // Массив для хранения элементов двусторонней очереди\n    int front;        // Указатель head, указывающий на первый элемент очереди\n    int queSize;      // Длина двусторонней очереди\n\n  public:\n    /* Конструктор */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* Получение длины двусторонней очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    int index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity();\n    }\n\n    /* Добавление в голову очереди */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Двусторонняя очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"Двусторонняя очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    int popFirst() {\n        int num = peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"двусторонняя очередь пуста\");\n        // Вычислить индекс хвостового элемента\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private int[] nums; // Массив для хранения элементов двусторонней очереди\n    private int front; // Указатель head, указывающий на первый элемент очереди\n    private int queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private int index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity();\n    }\n\n    /* Добавление в голову очереди */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    public int popFirst() {\n        int num = peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // Вычислить индекс хвостового элемента\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    int[] nums;  // Массив для хранения элементов двусторонней очереди\n    int front;   // Указатель head, указывающий на первый элемент очереди\n    int queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    int Index(int i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* Добавление в голову очереди */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = Index(front - 1);\n        // Добавить num в голову очереди\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        int rear = Index(front + queSize);\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // Вычислить индекс хвостового элемента\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\ntype arrayDeque struct {\n    nums        []int // Массив для хранения элементов двусторонней очереди\n    front       int   // Указатель head, указывающий на первый элемент очереди\n    queSize     int   // Длина двусторонней очереди\n    queCapacity int   // Вместимость очереди (то есть максимальное число элементов)\n}\n\n/* Инициализация очереди */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Получение длины двусторонней очереди */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* Проверка, пуста ли двусторонняя очередь */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Вычислить индекс в кольцевом массиве */\nfunc (q *arrayDeque) index(i int) int {\n    // С помощью операции взятия по модулю соединить начало и конец массива\n    // Когда i выходит за конец массива, он возвращается в начало\n    // Когда i выходит за начало массива, он возвращается в конец\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* Добавление в голову очереди */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Двусторонняя очередь заполнена\")\n        return\n    }\n    // Указатель головы сдвигается на одну позицию влево\n    // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n    q.front = q.index(q.front - 1)\n    // Добавить num в голову очереди\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* Добавление в хвост очереди */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"Двусторонняя очередь заполнена\")\n        return\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    rear := q.index(q.front + q.queSize)\n    // Добавить num в хвост очереди\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Извлечение из головы очереди */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // Указатель головы сдвигается на одну позицию назад\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* Извлечение из хвоста очереди */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Доступ к элементу в конце очереди */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // Вычислить индекс хвостового элемента\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* Получить Slice для вывода */\nfunc (q *arrayDeque) toSlice() []int {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private var nums: [Int] // Массив для хранения элементов двусторонней очереди\n    private var front: Int // Указатель head, указывающий на первый элемент очереди\n    private var _size: Int // Длина двусторонней очереди\n\n    /* Конструктор */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Получение длины двусторонней очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private func index(i: Int) -&gt; Int {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        (i + capacity()) % capacity()\n    }\n\n    /* Добавление в голову очереди */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(i: front - 1)\n        // Добавить num в голову очереди\n        nums[front] = num\n        _size += 1\n    }\n\n    /* Добавление в хвост очереди */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        let rear = index(i: front + size())\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Извлечение из головы очереди */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* Извлечение из хвоста очереди */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        return nums[front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"двусторонняя очередь пуста\")\n        }\n        // Вычислить индекс хвостового элемента\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    func toArray() -&gt; [Int] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    #nums; // Массив для хранения элементов двусторонней очереди\n    #front; // Указатель head, указывающий на первый элемент очереди\n    #queSize; // Длина двусторонней очереди\n\n    /* Конструктор */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    index(i) {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Добавление в голову очереди */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        this.#front = this.index(this.#front - 1);\n        // Добавить num в голову очереди\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // Добавить num в хвост очереди\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    popFirst() {\n        const num = this.peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Вычислить индекс хвостового элемента\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n    private nums: number[]; // Массив для хранения элементов двусторонней очереди\n    private front: number; // Указатель head, указывающий на первый элемент очереди\n    private queSize: number; // Длина двусторонней очереди\n\n    /* Конструктор */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Получение длины двусторонней очереди */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    index(i: number): number {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* Добавление в голову очереди */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        this.front = this.index(this.front - 1);\n        // Добавить num в голову очереди\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* Добавление в хвост очереди */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('Двусторонняя очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // Добавить num в хвост очереди\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Извлечение из головы очереди */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // Указатель головы сдвигается на одну позицию назад\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* Извлечение из хвоста очереди */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* Доступ к элементу в конце очереди */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // Вычислить индекс хвостового элемента\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* Вернуть массив для вывода */\n    toArray(): number[] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // Массив для хранения элементов двусторонней очереди\n  late int _front; // Указатель head, указывающий на первый элемент очереди\n  late int _queSize; // Длина двусторонней очереди\n\n  /* Конструктор */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* Получить вместимость двусторонней очереди */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* Получение длины двусторонней очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли двусторонняя очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Вычислить индекс в кольцевом массиве */\n  int index(int i) {\n    // С помощью операции взятия по модулю соединить начало и конец массива\n    // Когда i выходит за конец массива, он возвращается в начало\n    // Когда i выходит за начало массива, он возвращается в конец\n    return (i + capacity()) % capacity();\n  }\n\n  /* Добавление в голову очереди */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Двусторонняя очередь заполнена\");\n    }\n    // Указатель головы сместить влево на одну позицию\n    // С помощью операции взятия остатка реализовать возврат _front к хвосту после выхода за начало массива\n    _front = index(_front - 1);\n    // Добавить _num в голову очереди\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* Добавление в хвост очереди */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"Двусторонняя очередь заполнена\");\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    int rear = index(_front + _queSize);\n    // Добавить _num в хвост очереди\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Извлечение из головы очереди */\n  int popFirst() {\n    int _num = peekFirst();\n    // Указатель головы сместить вправо на одну позицию\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* Извлечение из хвоста очереди */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"двусторонняя очередь пуста\");\n    }\n    return _nums[_front];\n  }\n\n  /* Доступ к элементу в конце очереди */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"двусторонняя очередь пуста\");\n    }\n    // Вычислить индекс хвостового элемента\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* Вернуть массив для вывода */\n  List&lt;int&gt; toArray() {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // Массив для хранения элементов двусторонней очереди\n    front: usize,    // Указатель head, указывающий на первый элемент очереди\n    que_size: usize, // Длина двусторонней очереди\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* Конструктор */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* Получить вместимость двусторонней очереди */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* Получение длины двусторонней очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* Добавление в голову очереди */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        self.front = self.index(self.front as i32 - 1);\n        // Добавить num в голову очереди\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* Добавление в хвост очереди */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Двусторонняя очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // Добавить num в хвост очереди\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* Извлечение из головы очереди */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // Указатель головы сдвигается на одну позицию назад\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* Извлечение из хвоста очереди */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"двусторонняя очередь пуста\")\n        };\n        self.nums[self.front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"двусторонняя очередь пуста\")\n        };\n        // Вычислить индекс хвостового элемента\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* Двусторонняя очередь на основе кольцевого массива */\ntypedef struct {\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Указатель хвоста, указывающий на позицию после хвоста\n    int queCapacity; // Вместимость очереди\n} ArrayDeque;\n\n/* Конструктор */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // Инициализация массива\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* Деструктор */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* Получить вместимость двусторонней очереди */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* Получение длины двусторонней очереди */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* Проверка, пуста ли двусторонняя очередь */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* Вычислить индекс в кольцевом массиве */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // С помощью операции взятия остатка соединить начало и конец массива\n    // Когда i выходит за хвост массива, вернуться к началу\n    // Когда i выходит за голову массива, вернуться к концу\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* Добавление в голову очереди */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Дек заполнен\\r\\n\");\n        return;\n    }\n    // Указатель головы сместить влево на одну позицию\n    // С помощью операции взятия остатка реализовать возврат front к хвосту после выхода за начало массива\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // Добавить num в голову очереди\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* Добавление в хвост очереди */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"Дек заполнен\\r\\n\");\n        return;\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // Добавить num в хвост очереди\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* Доступ к элементу в начале очереди */\nint peekFirst(ArrayDeque *deque) {\n    // Ошибка доступа: двусторонняя очередь пуста\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* Доступ к элементу в конце очереди */\nint peekLast(ArrayDeque *deque) {\n    // Ошибка доступа: двусторонняя очередь пуста\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* Извлечение из головы очереди */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // Указатель головы сдвигается на одну позицию назад\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Извлечение из хвоста очереди */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* Вернуть массив для вывода */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* Конструктор */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // Массив для хранения элементов двусторонней очереди\n    private var front: Int = 0 // Указатель head, указывающий на первый элемент очереди\n    private var queSize: Int = 0 // Длина двусторонней очереди\n\n    /* Получить вместимость двусторонней очереди */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Получение длины двусторонней очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли двусторонняя очередь */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Вычислить индекс в кольцевом массиве */\n    private fun index(i: Int): Int {\n        // С помощью операции взятия по модулю соединить начало и конец массива\n        // Когда i выходит за конец массива, он возвращается в начало\n        // Когда i выходит за начало массива, он возвращается в конец\n        return (i + capacity()) % capacity()\n    }\n\n    /* Добавление в голову очереди */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Указатель головы сдвигается на одну позицию влево\n        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n        front = index(front - 1)\n        // Добавить num в голову очереди\n        nums[front] = num\n        queSize++\n    }\n\n    /* Добавление в хвост очереди */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Двусторонняя очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        val rear = index(front + queSize)\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Извлечение из головы очереди */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // Указатель головы сдвигается на одну позицию назад\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* Извлечение из хвоста очереди */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Доступ к элементу в конце очереди */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // Вычислить индекс хвостового элемента\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* Вернуть массив для вывода */\n    fun toArray(): IntArray {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### Двусторонняя очередь на основе кольцевого массива ###\nclass ArrayDeque\n  ### Получение длины двусторонней очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### Получить вместимость двусторонней очереди ###\n  def capacity\n    @nums.length\n  end\n\n  ### Проверка, пуста ли двусторонняя очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Добавление в голову очереди ###\n  def push_first(num)\n    if size == capacity\n      puts 'Двусторонняя очередь заполнена'\n      return\n    end\n\n    # Указатель головы сдвигается на одну позицию влево\n    # С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост\n    @front = index(@front - 1)\n    # Добавить num в голову очереди\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### Добавление в хвост очереди ###\n  def push_last(num)\n    if size == capacity\n      puts 'Двусторонняя очередь заполнена'\n      return\n    end\n\n    # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    rear = index(@front + size)\n    # Добавить num в хвост очереди\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Извлечение из головы очереди ###\n  def pop_first\n    num = peek_first\n    # Указатель головы сдвигается на одну позицию назад\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### Извлечение из хвоста очереди ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek_first\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Доступ к элементу в хвосте очереди ###\n  def peek_last\n    raise IndexError, 'двусторонняя очередь пуста' if is_empty?\n\n    # Вычислить индекс хвостового элемента\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### Вернуть массив для вывода ###\n  def to_array\n    # Преобразовывать только элементы списка в пределах фактической длины\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### Вычислить индекс в кольцевом массиве ###\n  def index(i)\n    # С помощью операции взятия по модулю соединить начало и конец массива\n    # Когда i выходит за конец массива, он возвращается в начало\n    # Когда i выходит за начало массива, он возвращается в конец\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   Применение двусторонней очереди","text":"<p>Двусторонняя очередь сочетает в себе логику стека и очереди, поэтому она может покрыть все сценарии применения обеих структур и при этом предоставляет более высокую степень свободы.</p> <p>Мы знаем, что функция \"undo\" в программном обеспечении обычно реализуется с помощью стека: система помещает каждое изменение в стек с помощью <code>push</code> , а затем использует <code>pop</code> для отмены. Однако, учитывая ограниченность системных ресурсов, программы обычно ограничивают число шагов отмены, например разрешают хранить только \\(50\\) шагов. Когда длина стека превышает этот предел, программе нужно удалить элемент с дна стека, то есть с головы очереди. Но стек не может реализовать такую операцию, и в этом случае его приходится заменять двусторонней очередью. Обрати внимание: основная логика \"undo\" по-прежнему следует стековому правилу LIFO, просто двусторонняя очередь позволяет более гибко реализовать некоторые дополнительные механизмы.</p>","path":["Глава 5. Стек и очередь","5.3 &nbsp; Двусторонняя очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   Очередь","text":"<p>Очередь (queue) - это линейная структура данных, подчиняющаяся правилу \"первым пришел - первым вышел\". Как видно из названия, очередь моделирует обычную ситуацию ожидания: новые люди непрерывно присоединяются к хвосту очереди, а стоящие в начале по одному уходят.</p> <p>Как показано на рисунке 5-4, начало очереди называется головой очереди, а конец - хвостом очереди; операцию добавления элемента в хвост называют <code>enqueue</code>, а операцию удаления элемента из головы - <code>dequeue</code>.</p> <p></p> <p> Рисунок 5-4   Правило FIFO для очереди </p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   Основные операции с очередью","text":"<p>Распространенные операции с очередью показаны в таблице 5-2. Следует учитывать, что названия методов в разных языках могут различаться. Здесь мы используем те же названия, что и для стека.</p> <p> Таблица 5-2   Эффективность операций с очередью </p> Имя метода Описание Временная сложность <code>push()</code> Поместить элемент в очередь, то есть добавить его в хвост \\(O(1)\\) <code>pop()</code> Извлечь элемент из головы очереди \\(O(1)\\) <code>peek()</code> Просмотреть элемент в голове очереди \\(O(1)\\) <p>Обычно достаточно использовать готовые классы очереди, предоставляемые языками программирования:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# Инициализация очереди\n# В Python обычно используют двустороннюю очередь deque как обычную очередь\n# Хотя queue.Queue() является \"чистой\" очередью, она не слишком удобна, поэтому ее не рекомендуют\nque: deque[int] = deque()\n\n# Поместить элементы в очередь\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Просмотреть элемент в голове очереди\nfront: int = que[0]\n\n# Извлечь элемент из очереди\npop: int = que.popleft()\n\n# Получить длину очереди\nsize: int = len(que)\n\n# Проверить, пуста ли очередь\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* Инициализация очереди */\nqueue&lt;int&gt; queue;\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nint front = queue.front();\n\n/* Извлечь элемент из очереди */\nqueue.pop();\n\n/* Получить длину очереди */\nint size = queue.size();\n\n/* Проверить, пуста ли очередь */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* Инициализация очереди */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* Поместить элементы в очередь */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.peek();\n\n/* Извлечь элемент из очереди */\nint pop = queue.poll();\n\n/* Получить длину очереди */\nint size = queue.size();\n\n/* Проверить, пуста ли очередь */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* Инициализация очереди */\nQueue&lt;int&gt; queue = new();\n\n/* Поместить элементы в очередь */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.Peek();\n\n/* Извлечь элемент из очереди */\nint pop = queue.Dequeue();\n\n/* Получить длину очереди */\nint size = queue.Count;\n\n/* Проверить, пуста ли очередь */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* Инициализация очереди */\n// В Go очередь обычно реализуют через list\nqueue := list.New()\n\n/* Поместить элементы в очередь */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Просмотреть элемент в голове очереди */\npeek := queue.Front()\n\n/* Извлечь элемент из очереди */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Получить длину очереди */\nsize := queue.Len()\n\n/* Проверить, пуста ли очередь */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* Инициализация очереди */\n// В Swift нет встроенного класса очереди, поэтому можно использовать Array как очередь\nvar queue: [Int] = []\n\n/* Поместить элементы в очередь */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Просмотреть элемент в голове очереди */\nlet peek = queue.first!\n\n/* Извлечь элемент из очереди */\n// Поскольку в основе лежит массив, removeFirst имеет сложность O(n)\nlet pool = queue.removeFirst()\n\n/* Получить длину очереди */\nlet size = queue.count\n\n/* Проверить, пуста ли очередь */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* Инициализация очереди */\n// В JavaScript нет встроенной очереди, поэтому можно использовать Array как очередь\nconst queue = [];\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nconst peek = queue[0];\n\n/* Извлечь элемент из очереди */\n// В основе лежит массив, поэтому shift() имеет сложность O(n)\nconst pop = queue.shift();\n\n/* Получить длину очереди */\nconst size = queue.length;\n\n/* Проверить, пуста ли очередь */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* Инициализация очереди */\n// В TypeScript нет встроенной очереди, поэтому можно использовать Array как очередь\nconst queue: number[] = [];\n\n/* Поместить элементы в очередь */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Просмотреть элемент в голове очереди */\nconst peek = queue[0];\n\n/* Извлечь элемент из очереди */\n// В основе лежит массив, поэтому shift() имеет сложность O(n)\nconst pop = queue.shift();\n\n/* Получить длину очереди */\nconst size = queue.length;\n\n/* Проверить, пуста ли очередь */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* Инициализация очереди */\n// В Dart класс Queue является двусторонней очередью и может использоваться как обычная очередь\nQueue&lt;int&gt; queue = Queue();\n\n/* Поместить элементы в очередь */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Просмотреть элемент в голове очереди */\nint peek = queue.first;\n\n/* Извлечь элемент из очереди */\nint pop = queue.removeFirst();\n\n/* Получить длину очереди */\nint size = queue.length;\n\n/* Проверить, пуста ли очередь */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* Инициализация двусторонней очереди */\n// В Rust двусторонняя очередь может использоваться как обычная очередь\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* Поместить элементы в очередь */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Просмотреть элемент в голове очереди */\nif let Some(front) = deque.front() {\n}\n\n/* Извлечь элемент из очереди */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Получить длину очереди */\nlet size = deque.len();\n\n/* Проверить, пуста ли очередь */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// В C нет встроенной очереди\n</code></pre> queue.kt<pre><code>/* Инициализация очереди */\nval queue = LinkedList&lt;Int&gt;()\n\n/* Поместить элементы в очередь */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* Просмотреть элемент в голове очереди */\nval peek = queue.peek()\n\n/* Извлечь элемент из очереди */\nval pop = queue.poll()\n\n/* Получить длину очереди */\nval size = queue.size\n\n/* Проверить, пуста ли очередь */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># Инициализация очереди\n# Встроенная очередь в Ruby (Thread::Queue) не имеет методов peek и traverse, поэтому можно использовать Array как очередь\nqueue = []\n\n# Поместить элементы в очередь\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# Просмотреть элемент очереди\npeek = queue.first\n\n# Извлечь элемент из очереди\n# Обрати внимание: поскольку это массив, метод Array#shift имеет сложность O(n)\npop = queue.shift\n\n# Получить длину очереди\nsize = queue.length\n\n# Проверить, пуста ли очередь\nis_empty = queue.empty?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20%23%20%D0%92%20Python%20%D0%B4%D0%B2%D1%83%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%BD%D1%8E%D1%8E%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20deque%20%D0%BE%D0%B1%D1%8B%D1%87%D0%BD%D0%BE%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D1%8E%D1%82%20%D0%BA%D0%B0%D0%BA%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20%23%20%D0%A5%D0%BE%D1%82%D1%8F%20queue.Queue%28%29%20%D1%8F%D0%B2%D0%BB%D1%8F%D0%B5%D1%82%D1%81%D1%8F%20%D0%BD%D0%B0%D1%81%D1%82%D0%BE%D1%8F%D1%89%D0%B8%D0%BC%20%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%BC%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%2C%20%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%D1%81%D1%8F%20%D0%B8%D0%BC%20%D0%BD%D0%B5%20%D1%81%D0%BB%D0%B8%D1%88%D0%BA%D0%BE%D0%BC%20%D1%83%D0%B4%D0%BE%D0%B1%D0%BD%D0%BE%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20que%20%3D%22%2C%20que%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20front%20%3D%22%2C%20front%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20pop%20%3D%22%2C%20pop%29%0A%20%20%20%20print%28%22que%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20%3D%22%2C%20que%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   Реализация очереди","text":"<p>Чтобы реализовать очередь, нам нужна такая структура данных, которая позволяет добавлять элементы с одного конца и удалять их с другого; и связный список, и массив этим требованиям удовлетворяют.</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   Реализация на основе связного списка","text":"<p>Как показано на рисунке 5-5, мы можем рассматривать головной узел и хвостовой узел связного списка как голову очереди и хвост очереди соответственно, договорившись, что добавлять узлы можно только в хвост, а удалять - только из головы.</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-5   Операции enqueue и dequeue в реализации очереди на связном списке </p> <p>Ниже приведен код реализации очереди на связном списке:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"Очередь на основе связного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._front: ListNode | None = None  # Головной узел front\n        self._rear: ListNode | None = None  # Хвостовой узел rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Поместить в очередь\"\"\"\n        # Добавить num после хвостового узла\n        node = ListNode(num)\n        # Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # Если очередь не пуста, добавить этот узел после хвостового узла\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из очереди\"\"\"\n        num = self.peek()\n        # Удалить головной узел\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"очередь пуста\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Преобразовать в список для вывода\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // Головной узел front, хвостовой узел rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // Обходить связный список, удалять узлы и освобождать память\n        freeMemoryLinkedList(front);\n    }\n\n    /* Получение длины очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    void push(int num) {\n        // Добавить num после хвостового узла\n        ListNode *node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    int pop() {\n        int num = peek();\n        // Удалить головной узел\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // Освободить память\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"очередь пуста\");\n        return front-&gt;val;\n    }\n\n    /* Преобразовать связный список в Vector и вернуть */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private ListNode front, rear; // Головной узел front, хвостовой узел rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в очередь */\n    public void push(int num) {\n        // Добавить num после хвостового узла\n        ListNode node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node;\n            rear = node;\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int pop() {\n        int num = peek();\n        // Удалить головной узел\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    ListNode? front, rear;  // Головной узел front, хвостовой узел rear\n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* Получение длины очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в очередь */\n    public void Push(int num) {\n        // Добавить num после хвостового узла\n        ListNode node = new(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node;\n            rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int Pop() {\n        int num = Peek();\n        // Удалить головной узел\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* Очередь на основе связного списка */\ntype linkedListQueue struct {\n    // Использовать встроенный пакет list для реализации очереди\n    data *list.List\n}\n\n/* Инициализация очереди */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* Поместить в очередь */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь из очереди */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* Получение длины очереди */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуста ли очередь */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private var front: ListNode? // Головной узел\n    private var rear: ListNode? // Хвостовой узел\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в очередь */\n    func push(num: Int) {\n        // Добавить num после хвостового узла\n        let node = ListNode(x: num)\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // Если очередь не пуста, добавить этот узел после хвостового узла\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* Извлечь из очереди */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Удалить головной узел\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"очередь пуста\")\n        }\n        return front!.val\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    #front; // Головной узел #front\n    #rear; // Хвостовой узел #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* Получение длины очереди */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num) {\n        // Добавить num после хвостового узла\n        const node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop() {\n        const num = this.peek();\n        // Удалить головной узел\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek() {\n        if (this.size === 0) throw new Error('очередь пуста');\n        return this.#front.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n    private front: ListNode | null; // Головной узел front\n    private rear: ListNode | null; // Хвостовой узел rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* Получение длины очереди */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num: number): void {\n        // Добавить num после хвостового узла\n        const node = new ListNode(num);\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('очередь пуста');\n        // Удалить головной узел\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek(): number {\n        if (this.size === 0) throw new Error('очередь пуста');\n        return this.front!.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue {\n  ListNode? _front; // Головной узел _front\n  ListNode? _rear; // Хвостовой узел _rear\n  int _queSize = 0; // Длина очереди\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* Получение длины очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Поместить в очередь */\n  void push(int _num) {\n    // Добавить _num после хвостового узла\n    final node = ListNode(_num);\n    // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // Если очередь не пуста, добавить этот узел после хвостового узла\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* Извлечь из очереди */\n  int pop() {\n    final int _num = peek();\n    // Удалить головной узел\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('очередь пуста');\n    }\n    return _front!.val;\n  }\n\n  /* Преобразовать связный список в Array и вернуть */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* Очередь на основе связного списка */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Головной узел front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // Хвостовой узел rear\n    que_size: usize,                         // Длина очереди\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* Получение длины очереди */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* Проверка, пуста ли очередь */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* Поместить в очередь */\n    pub fn push(&amp;mut self, num: T) {\n        // Добавить num после хвостового узла\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* Извлечь из очереди */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* Доступ к элементу в начале очереди */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* Очередь на основе связного списка */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* Конструктор */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Деструктор */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // Освободить все узлы\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // Освободить структуру queue\n    free(queue);\n}\n\n/* Получение длины очереди */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* Поместить в очередь */\nvoid push(LinkedListQueue *queue, int num) {\n    // Добавить node в хвост\n    ListNode *node = newListNode(num);\n    // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // Если очередь не пуста, добавить этот узел после хвостового узла\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* Доступ к элементу в начале очереди */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* Извлечь из очереди */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Вывести очередь */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // Скопировать данные связного списка в массив\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* Очередь на основе связного списка */\nclass LinkedListQueue(\n    // Головной узел front, хвостовой узел rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* Получение длины очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли очередь */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в очередь */\n    fun push(num: Int) {\n        // Добавить num после хвостового узла\n        val node = ListNode(num)\n        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n        if (front == null) {\n            front = node\n            rear = node\n            // Если очередь не пуста, добавить этот узел после хвостового узла\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* Извлечь из очереди */\n    fun pop(): Int {\n        val num = peek()\n        // Удалить головной узел\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### Очередь на основе связного списка ###\nclass LinkedListQueue\n  ### Получение длины очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @front = nil  # Головной узел front\n    @rear = nil   # Хвостовой узел rear\n    @size = 0\n  end\n\n  ### Проверка, пуста ли очередь ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### Добавление в очередь ###\n  def push(num)\n    # Добавить num после хвостового узла\n    node = ListNode.new(num)\n\n    # Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел\n    if @front.nil?\n      @front = node\n      @rear = node\n    # Если очередь не пуста, добавить этот узел после хвостового узла\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### Извлечение из очереди ###\n  def pop\n    num = peek\n    # Удалить головной узел\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek\n    raise IndexError, 'очередь пуста' if is_empty?\n\n    @front.val\n  end\n\n  ### Преобразовать связный список в Array и вернуть ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Удаление первого элемента из массива имеет временную сложность \\(O(n)\\) , из-за чего операция <code>dequeue</code> оказывается неэффективной. Однако этого можно избежать с помощью следующего приема.</p> <p>Мы можем использовать переменную <code>front</code> , указывающую на индекс элемента в голове очереди, и поддерживать переменную <code>size</code> , которая хранит длину очереди. Определим <code>rear = front + size</code> ; эта формула дает позицию <code>rear</code>, указывающую на ячейку сразу после хвоста очереди.</p> <p>Исходя из этого, эффективный диапазон элементов массива равен <code>[front, rear - 1]</code>, а различные операции реализуются, как показано на рисунке 5-6.</p> <ul> <li>Операция <code>enqueue</code>: записать входной элемент по индексу <code>rear</code> и увеличить <code>size</code> на 1.</li> <li>Операция <code>dequeue</code>: просто увеличить <code>front</code> на 1 и уменьшить <code>size</code> на 1.</li> </ul> <p>Можно увидеть, что и <code>enqueue</code> , и <code>dequeue</code> требуют всего одной операции, а значит обе имеют временную сложность \\(O(1)\\) .</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-6   Операции enqueue и dequeue в реализации очереди на массиве </p> <p>Ты можешь заметить еще одну проблему: при непрерывных операциях <code>enqueue</code> и <code>dequeue</code> значения <code>front</code> и <code>rear</code> оба движутся вправо, и когда они доходят до конца массива, дальше сдвигаться уже нельзя. Чтобы решить эту проблему, можно рассматривать массив как кольцевой массив, у которого начало и конец соединены.</p> <p>Для кольцевого массива нужно сделать так, чтобы <code>front</code> или <code>rear</code>, перешагнув конец массива, сразу возвращались к его началу и продолжали движение. Такую периодичность удобно реализовать с помощью операции взятия остатка, как показано в коде ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"Очередь на основе кольцевого массива\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"Конструктор\"\"\"\n        self._nums: list[int] = [0] * size  # Массив для хранения элементов очереди\n        self._front: int = 0  # Указатель head, указывающий на первый элемент очереди\n        self._size: int = 0  # Длина очереди\n\n    def capacity(self) -&gt; int:\n        \"\"\"Получить вместимость очереди\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины очереди\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуста ли очередь\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"Поместить в очередь\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"очередь заполнена\")\n        # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        # С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        rear: int = (self._front + self._size) % self.capacity()\n        # Добавить num в хвост очереди\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из очереди\"\"\"\n        num: int = self.peek()\n        # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к элементу в начале очереди\"\"\"\n        if self.is_empty():\n            raise IndexError(\"очередь пуста\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Вернуть список для вывода\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n  private:\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Длина очереди\n    int queCapacity; // Вместимость очереди\n\n  public:\n    ArrayQueue(int capacity) {\n        // Инициализация массива\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* Получить вместимость очереди */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* Получение длины очереди */\n    int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в очередь */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"Очередь заполнена\" &lt;&lt; endl;\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % queCapacity;\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    int pop() {\n        int num = peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"очередь пуста\");\n        return nums[front];\n    }\n\n    /* Преобразовать массив в Vector и вернуть */\n    vector&lt;int&gt; toVector() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private int[] nums; // Массив для хранения элементов очереди\n    private int front; // Указатель head, указывающий на первый элемент очереди\n    private int queSize; // Длина очереди\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* Получение длины очереди */\n    public int size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % capacity();\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int pop() {\n        int num = peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* Вернуть массив */\n    public int[] toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    int[] nums;  // Массив для хранения элементов очереди\n    int front;   // Указатель head, указывающий на первый элемент очереди\n    int queSize; // Длина очереди\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* Получение длины очереди */\n    public int Size() {\n        return queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* Поместить в очередь */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        int rear = (front + queSize) % Capacity();\n        // Добавить num в хвост очереди\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* Извлечь из очереди */\n    public int Pop() {\n        int num = Peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* Вернуть массив */\n    public int[] ToArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* Очередь на основе кольцевого массива */\ntype arrayQueue struct {\n    nums        []int // Массив для хранения элементов очереди\n    front       int   // Указатель head, указывающий на первый элемент очереди\n    queSize     int   // Длина очереди\n    queCapacity int   // Вместимость очереди (то есть максимальное число элементов)\n}\n\n/* Инициализация очереди */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* Получение длины очереди */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* Проверка, пуста ли очередь */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* Поместить в очередь */\nfunc (q *arrayQueue) push(num int) {\n    // Когда rear == queCapacity, очередь заполнена\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    rear := (q.front + q.queSize) % q.queCapacity\n    // Добавить num в хвост очереди\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* Извлечь из очереди */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* Доступ к элементу в начале очереди */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* Получить Slice для вывода */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private var nums: [Int] // Массив для хранения элементов очереди\n    private var front: Int // Указатель head, указывающий на первый элемент очереди\n    private var _size: Int // Длина очереди\n\n    init(capacity: Int) {\n        // Инициализация массива\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* Получить вместимость очереди */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* Получение длины очереди */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуста ли очередь */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в очередь */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"Очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        let rear = (front + size()) % capacity()\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* Извлечь из очереди */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"очередь пуста\")\n        }\n        return nums[front]\n    }\n\n    /* Вернуть массив */\n    func toArray() -&gt; [Int] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    #nums; // Массив для хранения элементов очереди\n    #front = 0; // Указатель head, указывающий на первый элемент очереди\n    #queSize = 0; // Длина очереди\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* Получить вместимость очереди */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* Получение длины очереди */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('Очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        const rear = (this.#front + this.size) % this.capacity;\n        // Добавить num в хвост очереди\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop() {\n        const num = this.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek() {\n        if (this.isEmpty()) throw new Error('очередь пуста');\n        return this.#nums[this.#front];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n    private nums: number[]; // Массив для хранения элементов очереди\n    private front: number; // Указатель head, указывающий на первый элемент очереди\n    private queSize: number; // Длина очереди\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* Получить вместимость очереди */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* Получение длины очереди */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* Проверка, пуста ли очередь */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* Поместить в очередь */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('Очередь заполнена');\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        const rear = (this.front + this.queSize) % this.capacity;\n        // Добавить num в хвост очереди\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* Извлечь из очереди */\n    pop(): number {\n        const num = this.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* Доступ к элементу в начале очереди */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('очередь пуста');\n        return this.nums[this.front];\n    }\n\n    /* Вернуть Array */\n    toArray(): number[] {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // Массив для хранения элементов очереди\n  late int _front; // Указатель head, указывающий на первый элемент очереди\n  late int _queSize; // Длина очереди\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* Получить вместимость очереди */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* Получение длины очереди */\n  int size() {\n    return _queSize;\n  }\n\n  /* Проверка, пуста ли очередь */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* Поместить в очередь */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"Очередь заполнена\");\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    int rear = (_front + _queSize) % capaCity();\n    // Добавить _num в хвост очереди\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* Извлечь из очереди */\n  int pop() {\n    int _num = peek();\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* Доступ к элементу в начале очереди */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"очередь пуста\");\n    }\n    return _nums[_front];\n  }\n\n  /* Вернуть Array */\n  List&lt;int&gt; toArray() {\n    // Преобразовывать только элементы списка в пределах фактической длины\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* Очередь на основе кольцевого массива */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // Массив для хранения элементов очереди\n    front: i32,        // Указатель head, указывающий на первый элемент очереди\n    que_size: i32,     // Длина очереди\n    que_capacity: i32, // Вместимость очереди\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* Конструктор */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* Получить вместимость очереди */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* Получение длины очереди */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* Проверка, пуста ли очередь */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* Поместить в очередь */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"Очередь заполнена\");\n            return;\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // Добавить num в хвост очереди\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* Извлечь из очереди */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* Вернуть массив */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* Очередь на основе кольцевого массива */\ntypedef struct {\n    int *nums;       // Массив для хранения элементов очереди\n    int front;       // Указатель head, указывающий на первый элемент очереди\n    int queSize;     // Текущее количество элементов в очереди\n    int queCapacity; // Вместимость очереди\n} ArrayQueue;\n\n/* Конструктор */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // Инициализация массива\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* Деструктор */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* Получить вместимость очереди */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* Получение длины очереди */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* Проверка, пуста ли очередь */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* Доступ к элементу в начале очереди */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* Поместить в очередь */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"Очередь заполнена\\r\\n\");\n        return;\n    }\n    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // Добавить num в хвост очереди\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* Извлечь из очереди */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* Вернуть массив для вывода */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* Очередь на основе кольцевого массива */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // Массив для хранения элементов очереди\n    private var front: Int = 0 // Указатель head, указывающий на первый элемент очереди\n    private var queSize: Int = 0 // Длина очереди\n\n    /* Получить вместимость очереди */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* Получение длины очереди */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* Проверка, пуста ли очередь */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* Поместить в очередь */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"Очередь заполнена\")\n            return\n        }\n        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n        val rear = (front + queSize) % capacity()\n        // Добавить num в хвост очереди\n        nums[rear] = num\n        queSize++\n    }\n\n    /* Извлечь из очереди */\n    fun pop(): Int {\n        val num = peek()\n        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* Доступ к элементу в начале очереди */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* Вернуть массив */\n    fun toArray(): IntArray {\n        // Преобразовывать только элементы списка в пределах фактической длины\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### Очередь на основе кольцевого массива ###\nclass ArrayQueue\n  ### Получение длины очереди ###\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # Массив для хранения элементов очереди\n    @front = 0 # Указатель head, указывающий на первый элемент очереди\n    @size = 0 # Длина очереди\n  end\n\n  ### Получить вместимость очереди ###\n  def capacity\n    @nums.length\n  end\n\n  ### Проверка, пуста ли очередь ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### Добавление в очередь ###\n  def push(num)\n    raise IndexError, 'очередь заполнена' if size == capacity\n\n    # Вычислить указатель хвоста, указывающий на индекс хвоста + 1\n    # С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива\n    rear = (@front + size) % capacity\n    # Добавить num в хвост очереди\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### Извлечение из очереди ###\n  def pop\n    num = peek\n    # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### Доступ к элементу в начале очереди ###\n  def peek\n    raise IndexError, 'очередь пуста' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### Вернуть список для вывода ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Даже такая реализация очереди остается ограниченной: ее длина неизменяема. Однако это несложно исправить, заменив массив на динамический массив и тем самым введя механизм расширения. Заинтересованные читатели могут попробовать реализовать это самостоятельно.</p> <p>Выводы сравнения двух реализаций в целом такие же, как и для стека, поэтому здесь мы не будем повторяться.</p>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   Типичные применения очереди","text":"<ul> <li>Очереди заказов. После оформления заказа покупателем заказ попадает в очередь, а затем система обрабатывает заказы по порядку. Во время крупных распродаж за короткое время возникает огромный поток заказов, и высокая конкурентная нагрузка становится ключевой инженерной проблемой.</li> <li>Различные отложенные задачи. Любой сценарий, где нужно реализовать принцип \"кто раньше пришел, тот раньше обслуживается\", например очередь заданий принтера или очередь блюд на кухне ресторана, хорошо моделируется очередью, которая эффективно поддерживает нужный порядок обработки.</li> </ul>","path":["Глава 5. Стек и очередь","5.2 &nbsp; Очередь"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   Стек","text":"<p>Стек (stack) - это линейная структура данных, подчиняющаяся логике \"последним пришел - первым вышел\".</p> <p>Стек можно сравнить со стопкой тарелок на столе. Если разрешено перемещать только одну тарелку за раз, то, чтобы достать тарелку снизу, сначала придется по одной убрать все тарелки сверху. Если заменить тарелки различными элементами, например целыми числами, символами, объектами и т.д., получится структура данных \"стек\".</p> <p>Как показано на рисунке 5-1, верхнюю часть стопки элементов мы называем вершиной стека, а нижнюю - основанием стека. Операция добавления элемента на вершину называется <code>push</code>, а операция удаления верхнего элемента - <code>pop</code>.</p> <p></p> <p> Рисунок 5-1   Правило LIFO для стека </p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   Основные операции со стеком","text":"<p>Основные операции со стеком показаны в таблице 5-1. Конкретные имена методов зависят от используемого языка программирования. Здесь в качестве примера используются распространенные названия <code>push()</code> , <code>pop()</code> и <code>peek()</code> .</p> <p> Таблица 5-1   Эффективность операций со стеком </p> Метод Описание Временная сложность <code>push()</code> Поместить элемент в стек (на вершину) \\(O(1)\\) <code>pop()</code> Извлечь верхний элемент стека \\(O(1)\\) <code>peek()</code> Просмотреть верхний элемент \\(O(1)\\) <p>Обычно достаточно использовать встроенный стек, предоставляемый языком программирования. Однако в некоторых языках специальный класс стека может отсутствовать. В таком случае можно использовать массив или связный список как стек и в логике программы игнорировать операции, не относящиеся к стеку.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># Инициализация стека\n# В Python нет встроенного класса стека, поэтому можно использовать list как стек\nstack: list[int] = []\n\n# Поместить элементы в стек\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Просмотреть верхний элемент\npeek: int = stack[-1]\n\n# Извлечь элемент\npop: int = stack.pop()\n\n# Получить длину стека\nsize: int = len(stack)\n\n# Проверить, пуст ли стек\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* Инициализация стека */\nstack&lt;int&gt; stack;\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nint top = stack.top();\n\n/* Извлечь элемент */\nstack.pop(); // Без возвращаемого значения\n\n/* Получить длину стека */\nint size = stack.size();\n\n/* Проверить, пуст ли стек */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* Инициализация стека */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.peek();\n\n/* Извлечь элемент */\nint pop = stack.pop();\n\n/* Получить длину стека */\nint size = stack.size();\n\n/* Проверить, пуст ли стек */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* Инициализация стека */\nStack&lt;int&gt; stack = new();\n\n/* Поместить элементы в стек */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.Peek();\n\n/* Извлечь элемент */\nint pop = stack.Pop();\n\n/* Получить длину стека */\nint size = stack.Count;\n\n/* Проверить, пуст ли стек */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* Инициализация стека */\n// В Go рекомендуется использовать Slice как стек\nvar stack []int\n\n/* Поместить элементы в стек */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Просмотреть верхний элемент */\npeek := stack[len(stack)-1]\n\n/* Извлечь элемент */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Получить длину стека */\nsize := len(stack)\n\n/* Проверить, пуст ли стек */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* Инициализация стека */\n// В Swift нет встроенного класса стека, поэтому можно использовать Array как стек\nvar stack: [Int] = []\n\n/* Поместить элементы в стек */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Просмотреть верхний элемент */\nlet peek = stack.last!\n\n/* Извлечь элемент */\nlet pop = stack.removeLast()\n\n/* Получить длину стека */\nlet size = stack.count\n\n/* Проверить, пуст ли стек */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* Инициализация стека */\n// В JavaScript нет встроенного класса стека, поэтому можно использовать Array как стек\nconst stack = [];\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nconst peek = stack[stack.length-1];\n\n/* Извлечь элемент */\nconst pop = stack.pop();\n\n/* Получить длину стека */\nconst size = stack.length;\n\n/* Проверить, пуст ли стек */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* Инициализация стека */\n// В TypeScript нет встроенного класса стека, поэтому можно использовать Array как стек\nconst stack: number[] = [];\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nconst peek = stack[stack.length - 1];\n\n/* Извлечь элемент */\nconst pop = stack.pop();\n\n/* Получить длину стека */\nconst size = stack.length;\n\n/* Проверить, пуст ли стек */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* Инициализация стека */\n// В Dart нет встроенного класса стека, поэтому можно использовать List как стек\nList&lt;int&gt; stack = [];\n\n/* Поместить элементы в стек */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Просмотреть верхний элемент */\nint peek = stack.last;\n\n/* Извлечь элемент */\nint pop = stack.removeLast();\n\n/* Получить длину стека */\nint size = stack.length;\n\n/* Проверить, пуст ли стек */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* Инициализация стека */\n// Используем Vec как стек\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* Поместить элементы в стек */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Просмотреть верхний элемент */\nlet top = stack.last().unwrap();\n\n/* Извлечь элемент */\nlet pop = stack.pop().unwrap();\n\n/* Получить длину стека */\nlet size = stack.len();\n\n/* Проверить, пуст ли стек */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// В C нет встроенного стека\n</code></pre> stack.kt<pre><code>/* Инициализация стека */\nval stack = Stack&lt;Int&gt;()\n\n/* Поместить элементы в стек */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* Просмотреть верхний элемент */\nval peek = stack.peek()\n\n/* Извлечь элемент */\nval pop = stack.pop()\n\n/* Получить длину стека */\nval size = stack.size\n\n/* Проверить, пуст ли стек */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># Инициализация стека\n# В Ruby нет встроенного класса стека, поэтому можно использовать Array как стек\nstack = []\n\n# Поместить элементы в стек\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# Просмотреть верхний элемент\npeek = stack.last\n\n# Извлечь элемент\npop = stack.pop\n\n# Получить длину стека\nsize = stack.length\n\n# Проверить, пуст ли стек\nis_empty = stack.empty?\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20%23%20%D0%92%20Python%20%D0%BD%D0%B5%D1%82%20%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%2C%20%D0%BF%D0%BE%D1%8D%D1%82%D0%BE%D0%BC%D1%83%20list%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BA%D0%B0%D0%BA%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D1%81%D1%82%D0%B5%D0%BA%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%D1%81%D1%82%D0%B5%D0%BA%20stack%20%3D%22%2C%20stack%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%D0%92%D0%B5%D1%80%D1%85%D0%BD%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20peek%20%3D%22%2C%20peek%29%0A%0A%20%20%20%20%23%20%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B8%D0%B7%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%D0%98%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B8%D0%B7%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20pop%20%3D%22%2C%20pop%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%20stack%20%3D%22%2C%20stack%29%0A%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B8%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%D0%94%D0%BB%D0%B8%D0%BD%D0%B0%20%D1%81%D1%82%D0%B5%D0%BA%D0%B0%20size%20%3D%22%2C%20size%29%0A%0A%20%20%20%20%23%20%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%B8%D1%82%D1%8C%2C%20%D0%BF%D1%83%D1%81%D1%82%D0%B0%20%D0%BB%D0%B8%20%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%D0%9F%D1%83%D1%81%D1%82%20%D0%BB%D0%B8%20%D1%81%D1%82%D0%B5%D0%BA%20%3D%22%2C%20is_empty%29&amp;cumulative=false&amp;curInstr=2&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   Реализация стека","text":"<p>Чтобы глубже понять механизм работы стека, попробуем самостоятельно реализовать класс стека.</p> <p>Стек подчиняется принципу LIFO, поэтому мы можем добавлять и удалять элементы только на вершине. Однако и массив, и связный список позволяют добавлять и удалять элементы в произвольном месте. Следовательно, стек можно рассматривать как ограниченный массив или связный список. Иными словами, мы можем скрыть часть нерелевантных операций массива или списка, так чтобы внешняя логика соответствовала свойствам стека.</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   Реализация на основе связного списка","text":"<p>Если реализовывать стек на основе связного списка, то головной узел списка можно рассматривать как вершину стека, а хвостовой - как основание.</p> <p>Как показано на рисунке 5-2, для операции <code>push</code> достаточно вставить элемент в голову связного списка. Такой способ вставки называется вставкой в голову. Для операции <code>pop</code> достаточно удалить головной узел из списка.</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-2   Операции push и pop в реализации стека на связном списке </p> <p>Ниже приведен пример кода реализации стека на основе связного списка:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"Стек на основе связного списка\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины стека\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуст ли стек\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"Поместить в стек\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из стека\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к верхнему элементу стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Преобразовать в список для вывода\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // Использовать головной узел как вершину стека\n    int stkSize;        // Длина стека\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // Обходить связный список, удалять узлы и освобождать память\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* Получение длины стека */\n    int size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // Освободить память\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"стек пуст\");\n        return stackTop-&gt;val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private ListNode stackPeek; // Использовать головной узел как вершину стека\n    private int stkSize = 0; // Длина стека\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    public int size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    ListNode? stackPeek;  // Использовать головной узел как вершину стека\n    int stkSize = 0;   // Длина стека\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* Извлечь из стека */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* Стек на основе связного списка */\ntype linkedListStack struct {\n    // Использовать встроенный пакет list для реализации стека\n    data *list.List\n}\n\n/* Инициализация стека */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* Поместить в стек */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* Извлечь из стека */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* Доступ к верхнему элементу стека */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* Получение длины стека */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* Проверка, пуст ли стек */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* Получить List для вывода */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private var _peek: ListNode? // Использовать головной узел как вершину стека\n    private var _size: Int // Длина стека\n\n    init() {\n        _size = 0\n    }\n\n    /* Получение длины стека */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* Проверка, пуст ли стек */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* Поместить в стек */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* Извлечь из стека */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* Доступ к верхнему элементу стека */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return _peek!.val\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    #stackPeek; // Использовать головной узел как вершину стека\n    #stkSize = 0; // Длина стека\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* Поместить в стек */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* Извлечь из стека */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    peek() {\n        if (!this.#stackPeek) throw new Error('стек пуст');\n        return this.#stackPeek.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // Использовать головной узел как вершину стека\n    private stkSize: number = 0; // Длина стека\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* Получение длины стека */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* Поместить в стек */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* Извлечь из стека */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('стек пуст');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('стек пуст');\n        return this.stackPeek.val;\n    }\n\n    /* Преобразовать связный список в Array и вернуть */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* Стек на основе класса связного списка */\nclass LinkedListStack {\n  ListNode? _stackPeek; // Использовать головной узел как вершину стека\n  int _stkSize = 0; // Длина стека\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* Получение длины стека */\n  int size() {\n    return _stkSize;\n  }\n\n  /* Проверка, пуст ли стек */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* Поместить в стек */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* Извлечь из стека */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* Доступ к верхнему элементу стека */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* Преобразовать связный список в List и вернуть */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* Стек на основе связного списка */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // Использовать головной узел как вершину стека\n    stk_size: usize,                              // Длина стека\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* Получение длины стека */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* Проверка, пуст ли стек */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* Поместить в стек */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* Извлечь из стека */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* Доступ к верхнему элементу стека */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* Стек на основе связного списка */\ntypedef struct {\n    ListNode *top; // Использовать головной узел как вершину стека\n    int size;      // Длина стека\n} LinkedListStack;\n\n/* Конструктор */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* Деструктор */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* Получение длины стека */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* Проверка, пуст ли стек */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* Поместить в стек */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // Обновить поле указателя нового узла\n    node-&gt;val = num;     // Обновить поле данных нового узла\n    s-&gt;top = node;       // Обновить вершину стека\n    s-&gt;size++;           // Обновить размер стека\n}\n\n/* Доступ к верхнему элементу стека */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"стек пуст\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* Извлечь из стека */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // Освободить память\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* Стек на основе связного списка */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // Использовать головной узел как вершину стека\n    private var stkSize: Int = 0 // Длина стека\n) {\n\n    /* Получение длины стека */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* Проверка, пуст ли стек */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в стек */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* Извлечь из стека */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### Стек на основе связного списка ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### Конструктор ###\n  def initialize\n    @size = 0\n  end\n\n  ### Проверка, пуст ли стек ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### Помещение в стек ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### Извлечение из стека ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### Доступ к верхнему элементу стека ###\n  def peek\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @peek.val\n  end\n\n  ### Преобразовать связный список в Array и вернуть ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   Реализация на основе массива","text":"<p>Если реализовывать стек на основе массива, то хвост массива можно рассматривать как вершину стека. Как показано на рисунке 5-3, операции <code>push</code> и <code>pop</code> соответствуют добавлению элемента в конец массива и удалению элемента из конца, обе имеют временную сложность \\(O(1)\\) .</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> Рисунок 5-3   Операции push и pop в реализации стека на массиве </p> <p>Поскольку количество элементов, помещаемых в стек, может непрерывно расти, мы можем использовать динамический массив и тем самым не заниматься расширением массива вручную. Ниже приведен пример кода:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"Стек на основе массива\"\"\"\n\n    def __init__(self):\n        \"\"\"Конструктор\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"Получение длины стека\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Проверка, пуст ли стек\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"Поместить в стек\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"Извлечь из стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"Доступ к верхнему элементу стека\"\"\"\n        if self.is_empty():\n            raise IndexError(\"стек пуст\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"Вернуть список для вывода\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* Получение длины стека */\n    int size() {\n        return stack.size();\n    }\n\n    /* Проверка, пуст ли стек */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* Поместить в стек */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* Извлечь из стека */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"стек пуст\");\n        return stack.back();\n    }\n\n    /* Вернуть Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // Инициализация списка (динамического массива)\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* Получение длины стека */\n    public int size() {\n        return stack.size();\n    }\n\n    /* Проверка, пуст ли стек */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* Извлечь из стека */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // Инициализация списка (динамического массива)\n        stack = [];\n    }\n\n    /* Получение длины стека */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* Проверка, пуст ли стек */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* Поместить в стек */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* Извлечь из стека */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* Доступ к верхнему элементу стека */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* Стек на основе массива */\ntype arrayStack struct {\n    data []int // Данные\n}\n\n/* Инициализация стека */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // Установить длину стека равной 0, а емкость равной 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* Длина стека */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* Пуст ли стек */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* Поместить в стек */\nfunc (s *arrayStack) push(v int) {\n    // Срез автоматически расширяется\n    s.data = append(s.data, v)\n}\n\n/* Извлечь из стека */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* Получить элемент на вершине стека */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* Получить Slice для вывода */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // Инициализация списка (динамического массива)\n        stack = []\n    }\n\n    /* Получение длины стека */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* Проверка, пуст ли стек */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* Поместить в стек */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* Извлечь из стека */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return stack.removeLast()\n    }\n\n    /* Доступ к верхнему элементу стека */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"стек пуст\")\n        }\n        return stack.last!\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* Получение длины стека */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* Поместить в стек */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    pop() {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.#stack.pop();\n    }\n\n    /* Доступ к верхнему элементу стека */\n    top() {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* Получение длины стека */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* Проверка, пуст ли стек */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* Поместить в стек */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.stack.pop();\n    }\n\n    /* Доступ к верхнему элементу стека */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('стек пуст');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* Вернуть Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* Получение длины стека */\n  int size() {\n    return _stack.length;\n  }\n\n  /* Проверка, пуст ли стек */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* Поместить в стек */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* Извлечь из стека */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* Доступ к верхнему элементу стека */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"стек пуст\");\n    }\n    return _stack.last;\n  }\n\n  /* Преобразовать стек в Array и вернуть */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* Стек на основе массива */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* Инициализация стека */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* Получение длины стека */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* Проверка, пуст ли стек */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* Поместить в стек */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* Извлечь из стека */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"стек пуст\")\n        };\n        self.stack.last()\n    }\n\n    /* Вернуть &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* Стек на основе массива */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* Конструктор */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // Инициализировать большую вместимость, чтобы избежать расширения\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* Деструктор */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* Получение длины стека */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* Проверка, пуст ли стек */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* Поместить в стек */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"Стек заполнен\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* Доступ к верхнему элементу стека */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"стек пуст\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* Извлечь из стека */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* Стек на основе массива */\nclass ArrayStack {\n    // Инициализация списка (динамического массива)\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* Получение длины стека */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* Проверка, пуст ли стек */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* Поместить в стек */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* Извлечь из стека */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* Доступ к верхнему элементу стека */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* Преобразовать List в Array и вернуть */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### Стек на основе массива ###\nclass ArrayStack\n  ### Конструктор ###\n  def initialize\n    @stack = []\n  end\n\n  ### Получить длину стека ###\n  def size\n    @stack.length\n  end\n\n  ### Проверка, пуст ли стек ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### Помещение в стек ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### Извлечение из стека ###\n  def pop\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @stack.pop\n  end\n\n  ### Доступ к верхнему элементу стека ###\n  def peek\n    raise IndexError, 'стек пуст' if is_empty?\n\n    @stack.last\n  end\n\n  ### Вернуть список для вывода ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513","level":2,"title":"5.1.3   Сравнение двух реализаций","text":"<p>Поддерживаемые операции</p> <p>Обе реализации поддерживают все операции, определенные для стека. Реализация на массиве дополнительно позволяет выполнять произвольный доступ, но это уже выходит за рамки определения стека и обычно не используется.</p> <p>Временная эффективность</p> <p>В реализации на массиве и <code>push</code> , и <code>pop</code> выполняются в заранее выделенной непрерывной памяти, которая хорошо использует локальность кэша, поэтому такие операции обычно эффективнее. Однако если при <code>push</code> емкость массива оказывается превышена, включается механизм расширения, и временная сложность именно этой операции становится \\(O(n)\\) .</p> <p>В реализации на связном списке расширение выполняется очень гибко, и проблемы падения эффективности из-за расширения массива здесь нет. Но сама операция <code>push</code> требует инициализации объекта-узла и изменения указателей, поэтому в среднем она немного менее эффективна. Впрочем, если помещаемые в стек элементы уже сами являются объектами-узлами, шаг инициализации можно пропустить и тем самым повысить эффективность.</p> <p>Итак, когда элементами, помещаемыми и извлекаемыми из стека, являются базовые типы данных, например <code>int</code> или <code>double</code> , можно сделать следующие выводы.</p> <ul> <li>Стек на основе массива теряет в эффективности в моменты расширения, но поскольку расширение происходит редко, его средняя эффективность выше.</li> <li>Стек на основе связного списка может обеспечивать более стабильную производительность.</li> </ul> <p>Пространственная эффективность</p> <p>При инициализации массива система выделяет начальную емкость, которая может превышать реальную потребность. Кроме того, механизм расширения обычно увеличивает емкость по некоторому коэффициенту, например в 2 раза, и расширенная емкость тоже может оказаться больше фактически необходимой. Поэтому реализация стека на основе массива может приводить к некоторым потерям памяти.</p> <p>Однако, поскольку узлы связного списка должны дополнительно хранить указатели, узлы списка сами по себе занимают больше пространства.</p> <p>В итоге нельзя просто сказать, какая из реализаций более экономна по памяти; это нужно анализировать в контексте конкретной задачи.</p>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   Типичные применения стека","text":"<ul> <li>Кнопки \"назад\" и \"вперед\" в браузере, undo и redo в программах. Каждый раз, когда мы открываем новую страницу, браузер помещает предыдущую страницу в стек, чтобы по операции \"назад\" можно было вернуться к ней. Операция \"назад\" по сути является <code>pop</code> . Если нужно одновременно поддерживать и \"назад\", и \"вперед\", то обычно используются два стека.</li> <li>Управление памятью программы. Каждый раз при вызове функции система помещает на вершину стека стековый кадр, в котором хранится контекст функции. В рекурсивной функции на этапе углубления рекурсии непрерывно выполняются операции <code>push</code> , а на этапе возврата - операции <code>pop</code> .</li> </ul>","path":["Глава 5. Стек и очередь","5.1 &nbsp; Стек"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   Резюме","text":"","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   Основные выводы","text":"<ul> <li>Стек - это структура данных, следующая правилу \"последним пришел - первым вышел\", и его можно реализовать с помощью массива или связного списка.</li> <li>С точки зрения временной эффективности реализация стека на массиве обычно работает быстрее в среднем, но во время расширения емкости временная сложность отдельной операции <code>push</code> может ухудшаться до \\(O(n)\\) . Напротив, реализация стека на связном списке дает более стабильные характеристики.</li> <li>С точки зрения использования памяти реализация стека на массиве может приводить к некоторой потере пространства. Однако следует учитывать, что узлы связного списка занимают больше памяти, чем элементы массива.</li> <li>Очередь - это структура данных, следующая правилу \"первым пришел - первым вышел\", и ее также можно реализовать с помощью массива или связного списка. Сравнение временной и пространственной эффективности для очереди в целом приводит к тем же выводам, что и для стека.</li> <li>Двусторонняя очередь - это очередь с более высокой степенью свободы, которая позволяет добавлять и удалять элементы с обоих концов.</li> </ul>","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Реализованы ли кнопки \"вперед\" и \"назад\" в браузере с помощью двусвязного списка?</p> <p>По сути, функция переходов \"вперед/назад\" в браузере отражает логику стека. Когда пользователь открывает новую страницу, она помещается на вершину стека; когда пользователь нажимает кнопку \"назад\", эта страница снимается с вершины стека. Двусторонняя очередь позволяет удобно реализовать некоторые дополнительные операции, об этом уже упоминалось в разделе \"Двусторонняя очередь\".</p> <p>Q: Нужно ли освобождать память узла после извлечения его из стека?</p> <p>Если извлеченный узел еще понадобится, память освобождать не нужно. Если он больше не нужен, то в языках <code>Java</code> и <code>Python</code> есть автоматический сборщик мусора, поэтому ручное освобождение памяти не требуется; в <code>C</code> и <code>C++</code> память нужно освобождать вручную.</p> <p>Q: Двусторонняя очередь выглядит как два соединенных стека. Для чего она нужна?</p> <p>Двусторонняя очередь похожа на комбинацию стека и очереди или на два соединенных стека. Она объединяет логику обеих структур, поэтому может покрыть все их применения и при этом остается более гибкой.</p> <p>Q: Как именно реализуются отмена (undo) и повтор (redo)?</p> <p>Используются два стека: стек <code>A</code> для отмены и стек <code>B</code> для повтора.</p> <ol> <li>Каждый раз, когда пользователь выполняет действие, это действие помещается в стек <code>A</code> , а стек <code>B</code> очищается.</li> <li>Когда пользователь выполняет \"undo\", последнее действие извлекается из стека <code>A</code> и помещается в стек <code>B</code> .</li> <li>Когда пользователь выполняет \"redo\", последнее действие извлекается из стека <code>B</code> и помещается обратно в стек <code>A</code> .</li> </ol>","path":["Глава 5. Стек и очередь","5.4 &nbsp; Резюме"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"Глава 7.   Деревья","text":"<p>Abstract</p> <p>Высокое дерево полно жизни: мощные корни, густая листва и раскидистые ветви.</p> <p>Оно наглядно показывает нам живую форму данных, построенную на принципе \"разделяй и властвуй\".</p>","path":["Глава 7. Деревья","Глава 7. &nbsp; Деревья"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"Содержание главы","text":"<ul> <li>7.1   Двоичное дерево</li> <li>7.2   Обход двоичного дерева</li> <li>7.3   Представление двоичного дерева массивом</li> <li>7.4   Двоичное дерево поиска</li> <li>7.5   AVL-дерево *</li> <li>7.6   Краткие итоги</li> </ul>","path":["Глава 7. Деревья","Глава 7. &nbsp; Деревья"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   Представление двоичного дерева массивом","text":"<p>В представлении через связную структуру единицей хранения двоичного дерева является узел <code>TreeNode</code> , а между узлами существуют связи через указатели. В предыдущем разделе были рассмотрены основные операции двоичного дерева в таком представлении.</p> <p>Возникает вопрос: можно ли представить двоичное дерево с помощью массива? Ответ: да.</p>","path":["Глава 7. Деревья","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   Представление идеального двоичного дерева","text":"<p>Сначала разберем простой случай. Если дана идеальная двоичная структура и все ее узлы хранятся в массиве в порядке обхода по уровням, то каждому узлу будет соответствовать единственный индекс массива.</p> <p>Из свойств обхода по уровням можно вывести формулу соответствия между индексом родителя и индексами дочерних узлов: если индекс некоторого узла равен \\(i\\) , то индекс его левого дочернего узла равен \\(2i + 1\\) , а правого - \\(2i + 2\\) . На рисунке 7-12 показано соответствие между индексами разных узлов.</p> <p></p> <p> Рисунок 7-12   Представление идеального двоичного дерева массивом </p> <p>Эта формула соответствия играет ту же роль, что и ссылки на узлы в связной структуре . Имея любой узел в массиве, мы можем с ее помощью получить доступ к его левому и правому дочерним узлам.</p>","path":["Глава 7. Деревья","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   Представление произвольного двоичного дерева","text":"<p>Идеальное двоичное дерево - лишь частный случай; в обычной двоичной структуре на промежуточных уровнях часто существует множество <code>None</code> . Поскольку последовательность обхода по уровням не содержит этих <code>None</code> , мы не можем по одной лишь этой последовательности определить их количество и расположение. Это означает, что одному и тому же обходу по уровням может соответствовать сразу несколько различных структур двоичного дерева.</p> <p>Как показано на рисунке 7-13, для неполной двоичной структуры описанный выше способ представления массивом уже перестает работать.</p> <p></p> <p> Рисунок 7-13   Одной последовательности обхода по уровням соответствуют разные двоичные структуры </p> <p>Чтобы решить эту проблему, мы можем явно записывать все <code>None</code> в последовательности обхода по уровням . Как показано на рисунке 7-14, после такой обработки последовательность обхода по уровням уже сможет однозначно задавать двоичное дерево. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># Представление двоичного дерева массивом\n# Используем None для обозначения пустых позиций\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем максимальное значение int, INT_MAX, для обозначения пустых позиций\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя обертку Integer для int, можно применять null для обозначения пустых позиций\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип int? , можно применять null для обозначения пустых позиций\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем срез типа any, чтобы можно было применять nil для обозначения пустых позиций\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип Int? , можно применять nil для обозначения пустых позиций\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используя nullable-тип int? , можно применять null для обозначения пустых позиций\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем None для обозначения пустых позиций\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем максимальное значение int для обозначения пустых позиций, поэтому узлы не должны принимать значение INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* Представление двоичного дерева массивом */\n// Используем null для обозначения пустых позиций\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### Представление двоичного дерева массивом ###\n# Используем nil для обозначения пустых позиций\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> Рисунок 7-14   Представление произвольного двоичного дерева массивом </p> <p>Стоит отметить, что полное двоичное дерево очень удобно представлять массивом . Если вспомнить определение полного двоичного дерева, то <code>None</code> появляются только на самом нижнем уровне и справа, а значит, все <code>None</code> обязательно находятся в конце последовательности обхода по уровням.</p> <p>Это означает, что при представлении полного двоичного дерева массивом можно не хранить все <code>None</code> , что очень удобно. На рисунке 7-15 приведен пример.</p> <p></p> <p> Рисунок 7-15   Представление полного двоичного дерева массивом </p> <p>Ниже приведен код реализации двоичного дерева, представленного массивом. Он включает следующие операции.</p> <ul> <li>Для заданного узла получить его значение, левого дочернего узла, правого дочернего узла и родительский узел.</li> <li>Получить последовательности прямого, симметричного, обратного обходов и обхода по уровням.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"Класс двоичного дерева в массивном представлении\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"Конструктор\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"Вместимость списка\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"Получить значение узла с индексом i\"\"\"\n        # Если индекс выходит за границы, вернуть None, обозначающий пустую позицию\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс левого дочернего узла узла с индексом i\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс правого дочернего узла узла с индексом i\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"Получить индекс родительского узла узла с индексом i\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"Обход в ширину\"\"\"\n        self.res = []\n        # Непосредственно обходить массив\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"Обход в глубину\"\"\"\n        if self.val(i) is None:\n            return\n        # Предварительный обход\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # Симметричный обход\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # Обратный обход\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"Предварительный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"Симметричный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"Обратный обход\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n  public:\n    /* Конструктор */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* Вместимость списка */\n    int size() {\n        return tree.size();\n    }\n\n    /* Получить значение узла с индексом i */\n    int val(int i) {\n        // Если индекс выходит за границы, вернуть INT_MAX, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* Предварительный обход */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* Обход в глубину */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // Если это пустая позиция, вернуть\n        if (val(i) == INT_MAX)\n            return;\n        // Предварительный обход\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // Симметричный обход\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // Обратный обход\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* Конструктор */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* Вместимость списка */\n    public int size() {\n        return tree.size();\n    }\n\n    /* Получить значение узла с индексом i */\n    public Integer val(int i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // Если это пустая позиция, вернуть\n        if (val(i) == null)\n            return;\n        // Предварительный обход\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // Симметричный обход\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // Обратный обход\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* Предварительный обход */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* Вместимость списка */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* Получить значение узла с индексом i */\n    public int? Val(int i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* Обход в ширину */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // Непосредственно обходить массив\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // Если это пустая позиция, вернуть\n        if (!Val(i).HasValue)\n            return;\n        // Предварительный обход\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // Симметричный обход\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // Обратный обход\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* Предварительный обход */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* Обратный обход */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* Класс двоичного дерева в массивном представлении */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* Конструктор */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* Вместимость списка */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* Получить значение узла с индексом i */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* Получить индекс левого дочернего узла узла с индексом i */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* Получить индекс правого дочернего узла узла с индексом i */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* Получить индекс родительского узла узла с индексом i */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* Обход в ширину */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // Непосредственно обходить массив\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* Обход в глубину */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // Если это пустая позиция, вернуть\n    if abt.val(i) == nil {\n        return\n    }\n    // Предварительный обход\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // Симметричный обход\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // Обратный обход\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* Предварительный обход */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* Симметричный обход */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* Обратный обход */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* Конструктор */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* Вместимость списка */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* Получить значение узла с индексом i */\n    func val(i: Int) -&gt; Int? {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // Непосредственно обходить массив\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* Обход в глубину */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // Если это пустая позиция, вернуть\n        guard let val = val(i: i) else {\n            return\n        }\n        // Предварительный обход\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // Симметричный обход\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // Обратный обход\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* Предварительный обход */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* Симметричный обход */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* Обратный обход */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* Конструктор */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* Вместимость списка */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* Получить значение узла с индексом i */\n    val(i) {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // Округление вниз при делении\n    }\n\n    /* Обход в ширину */\n    levelOrder() {\n        let res = [];\n        // Непосредственно обходить массив\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    #dfs(i, order, res) {\n        // Если это пустая позиция, вернуть\n        if (this.val(i) === null) return;\n        // Предварительный обход\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Симметричный обход\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Обратный обход\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Предварительный обход */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Обратный обход */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* Конструктор */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* Вместимость списка */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* Получить значение узла с индексом i */\n    val(i: number): number | null {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // Округление вниз при делении\n    }\n\n    /* Обход в ширину */\n    levelOrder(): number[] {\n        let res = [];\n        // Непосредственно обходить массив\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* Обход в глубину */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // Если это пустая позиция, вернуть\n        if (this.val(i) === null) return;\n        // Предварительный обход\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // Симметричный обход\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // Обратный обход\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* Предварительный обход */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* Симметричный обход */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* Обратный обход */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* Конструктор */\n  ArrayBinaryTree(this._tree);\n\n  /* Вместимость списка */\n  int size() {\n    return _tree.length;\n  }\n\n  /* Получить значение узла с индексом i */\n  int? val(int i) {\n    // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* Получить индекс левого дочернего узла узла с индексом i */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* Получить индекс правого дочернего узла узла с индексом i */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* Получить индекс родительского узла узла с индексом i */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* Обход в ширину */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* Обход в глубину */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // Если это пустая позиция, вернуть\n    if (val(i) == null) {\n      return;\n    }\n    // Предварительный обход\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // Симметричный обход\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // Обратный обход\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* Предварительный обход */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* Симметричный обход */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* Обратный обход */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* Класс двоичного дерева в массивном представлении */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* Конструктор */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* Вместимость списка */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* Получить значение узла с индексом i */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // Если индекс выходит за границы, вернуть None, обозначающий пустую позицию\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* Обход в глубину */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // Предварительный обход\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // Симметричный обход\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // Обратный обход\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* Предварительный обход */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* Симметричный обход */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* Обратный обход */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* Структура двоичного дерева в представлении массивом */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* Конструктор */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* Деструктор */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* Вместимость списка */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* Получить значение узла с индексом i */\nint val(ArrayBinaryTree *abt, int i) {\n    // Если индекс выходит за границы, вернуть INT_MAX, обозначающий пустую позицию\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* Обход в ширину */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // Непосредственно обходить массив\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* Обход в глубину */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // Если это пустая позиция, вернуть\n    if (val(abt, i) == INT_MAX)\n        return;\n    // Предварительный обход\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // Симметричный обход\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // Обратный обход\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* Предварительный обход */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Симметричный обход */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* Обратный обход */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* Класс двоичного дерева в массивном представлении */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* Вместимость списка */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* Получить значение узла с индексом i */\n    fun _val(i: Int): Int? {\n        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* Получить индекс левого дочернего узла узла с индексом i */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* Получить индекс правого дочернего узла узла с индексом i */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* Получить индекс родительского узла узла с индексом i */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* Обход в ширину */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // Непосредственно обходить массив\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* Обход в глубину */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // Если это пустая позиция, вернуть\n        if (_val(i) == null)\n            return\n        // Предварительный обход\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // Симметричный обход\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // Обратный обход\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* Предварительный обход */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* Симметричный обход */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* Обратный обход */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### Класс двоичного дерева в массивном представлении ###\nclass ArrayBinaryTree\n  ### Конструктор ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### Вместимость списка ###\n  def size\n    @tree.length\n  end\n\n  ### Получить значение узла с индексом i ###\n  def val(i)\n    # Если индекс выходит за границы, вернуть nil, обозначающий пустую ячейку\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### Получить индекс левого дочернего узла узла с индексом i ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### Получить индекс правого дочернего узла узла с индексом i ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### Получить индекс родительского узла узла с индексом i ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### Обход в ширину ###\n  def level_order\n    @res = []\n\n    # Непосредственно обходить массив\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### Обход в глубину ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # Предварительный обход\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # Симметричный обход\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # Обратный обход\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### Предварительный обход ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### Симметричный обход ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### Обратный обход ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Деревья","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   Преимущества и ограничения","text":"<p>Представление двоичного дерева массивом имеет в основном следующие преимущества.</p> <ul> <li>Массив хранится в непрерывной области памяти, хорошо работает с кешем и обеспечивает высокую скорость доступа и обхода.</li> <li>Не нужно хранить указатели, поэтому память расходуется экономнее.</li> <li>Разрешается произвольный доступ к узлам.</li> </ul> <p>Однако у представления массивом есть и некоторые ограничения.</p> <ul> <li>Для хранения массива требуется непрерывная область памяти, поэтому такой способ не подходит для деревьев с очень большим объемом данных.</li> <li>Добавление и удаление узлов приходится реализовывать через вставку и удаление элементов массива, а это не слишком эффективно.</li> <li>Когда в двоичном дереве имеется большое число <code>None</code> , доля действительно полезных данных в массиве оказывается низкой, и эффективность использования пространства падает.</li> </ul>","path":["Глава 7. Деревья","7.3 &nbsp; Представление двоичного дерева массивом"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL-дерево *","text":"<p>В разделе \"Двоичное дерево поиска\" мы упоминали, что после многократных операций вставки и удаления узлов двоичное дерево поиска может выродиться в связный список. В таком случае временная сложность всех операций ухудшается с \\(O(\\log n)\\) до \\(O(n)\\) .</p> <p>Как показано на рисунке 7-24, после двух операций удаления узлов это двоичное дерево поиска вырождается в связный список.</p> <p></p> <p> Рисунок 7-24   Деградация AVL-дерева после удаления узлов </p> <p>Другой пример: если в идеальное двоичное дерево, показанное на рисунке 7-25, вставить два узла, то дерево сильно наклонится влево, а временная сложность поиска тоже ухудшится.</p> <p></p> <p> Рисунок 7-25   Деградация AVL-дерева после вставки узлов </p> <p>В 1962 году Г. М. Adelson-Velsky и Е. М. Landis в статье \"An algorithm for the organization of information\" предложили AVL-дерево. В статье подробно описан набор операций, гарантирующий, что при непрерывном добавлении и удалении узлов AVL-дерево не вырождается, благодаря чему временная сложность различных операций сохраняется на уровне \\(O(\\log n)\\) . Иначе говоря, в сценариях, где часто выполняются вставка, удаление, поиск и изменение, AVL-дерево всегда поддерживает эффективную работу с данными и потому имеет высокую практическую ценность.</p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl-","level":2,"title":"7.5.1   Распространенные термины AVL-дерева","text":"<p>AVL-дерево одновременно является и двоичным деревом поиска, и сбалансированным двоичным деревом, то есть одновременно удовлетворяет всем свойствам обеих этих структур. Поэтому AVL-дерево является разновидностью сбалансированного двоичного дерева поиска (balanced binary search tree).</p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   Высота узла","text":"<p>Поскольку операции AVL-дерева требуют получать высоту узла, нам нужно добавить в класс узла переменную <code>height</code> :</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Класс узла AVL-дерева\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # Значение узла\n        self.height: int = 0                # Высота узла\n        self.left: TreeNode | None = None   # Ссылка на левого дочернего узла\n        self.right: TreeNode | None = None  # Ссылка на правого дочернего узла\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nstruct TreeNode {\n    int val{};          // Значение узла\n    int height = 0;     // Высота узла\n    TreeNode *left{};   // Левый дочерний узел\n    TreeNode *right{};  // Правый дочерний узел\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    public int val;        // Значение узла\n    public int height;     // Высота узла\n    public TreeNode left;  // Левый дочерний узел\n    public TreeNode right; // Правый дочерний узел\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode(int? x) {\n    public int? val = x;    // Значение узла\n    public int height;      // Высота узла\n    public TreeNode? left;  // Ссылка на левого дочернего узла\n    public TreeNode? right; // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Структура узла AVL-дерева */\ntype TreeNode struct {\n    Val    int       // Значение узла\n    Height int       // Высота узла\n    Left   *TreeNode // Ссылка на левого дочернего узла\n    Right  *TreeNode // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    var val: Int // Значение узла\n    var height: Int // Высота узла\n    var left: TreeNode? // Левый дочерний узел\n    var right: TreeNode? // Правый дочерний узел\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    val; // Значение узла\n    height; // Высота узла\n    left; // Указатель на левого дочернего узла\n    right; // Указатель на правого дочернего узла\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n    val: number;            // Значение узла\n    height: number;         // Высота узла\n    left: TreeNode | null;  // Указатель на левого дочернего узла\n    right: TreeNode | null; // Указатель на правого дочернего узла\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode {\n  int val;         // Значение узла\n  int height;      // Высота узла\n  TreeNode? left;  // Левый дочерний узел\n  TreeNode? right; // Правый дочерний узел\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура узла AVL-дерева */\nstruct TreeNode {\n    val: i32,                               // Значение узла\n    height: i32,                            // Высота узла\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Левый дочерний узел\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Правый дочерний узел\n}\n\nimpl TreeNode {\n    /* Конструктор */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Структура узла AVL-дерева */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* Конструктор */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла AVL-дерева */\nclass TreeNode(val _val: Int) {  // Значение узла\n    val height: Int = 0          // Высота узла\n    val left: TreeNode? = null   // Левый дочерний узел\n    val right: TreeNode? = null  // Правый дочерний узел\n}\n</code></pre> <pre><code>### Класс узла AVL-дерева ###\nclass TreeNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :height # Высота узла\n  attr_accessor :left   # Ссылка на левого дочернего узла\n  attr_accessor :right  # Ссылка на правого дочернего узла\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>\"Высота узла\" означает расстояние от этого узла до самого удаленного листового узла, то есть число пройденных \"ребер\". Особенно важно помнить, что высота листового узла равна \\(0\\) , а высота пустого узла равна \\(-1\\) . Мы создадим две вспомогательные функции: одну для получения высоты узла, другую для ее обновления:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Получить высоту узла\"\"\"\n    # Высота пустого узла равна -1, высота листового узла равна 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"Обновить высоту узла\"\"\"\n    # Высота узла равна высоте более высокого поддерева + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* Получить высоту узла */\nint height(TreeNode *node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode *node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* Получить высоту узла */\nint height(TreeNode node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* Получить высоту узла */\nint Height(TreeNode? node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid UpdateHeight(TreeNode node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* Получить высоту узла */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* Обновить высоту узла */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // Высота узла равна высоте более высокого поддерева + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* Получить высоту узла */\nfunc height(node: TreeNode?) -&gt; Int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    node?.height ?? -1\n}\n\n/* Обновить высоту узла */\nfunc updateHeight(node: TreeNode?) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* Получить высоту узла */\nheight(node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node === null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\n#updateHeight(node) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* Получить высоту узла */\nheight(node: TreeNode): number {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node === null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nupdateHeight(node: TreeNode): void {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* Получить высоту узла */\nint height(TreeNode? node) {\n  // Высота пустого узла равна -1, высота листового узла равна 0\n  return node == null ? -1 : node.height;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode? node) {\n  // Высота узла равна высоте более высокого поддерева + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* Получить высоту узла */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* Обновить высоту узла */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // Высота узла равна высоте более высокого поддерева + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Получить высоту узла */\nint height(TreeNode *node) {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* Обновить высоту узла */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // Высота узла равна высоте более высокого поддерева + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* Получить высоту узла */\nfun height(node: TreeNode?): Int {\n    // Высота пустого узла равна -1, высота листового узла равна 0\n    return node?.height ?: -1\n}\n\n/* Обновить высоту узла */\nfun updateHeight(node: TreeNode?) {\n    // Высота узла равна высоте более высокого поддерева + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### Получить высоту узла ###\ndef height(node)\n  # Высота пустого узла равна -1, высота листового узла равна 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### Обновить высоту узла ###\ndef update_height(node)\n  # Высота узла равна высоте более высокого поддерева + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2-","level":3,"title":"2.   Баланс-фактор узла","text":"<p>Баланс-фактор (balance factor) узла определяется как высота левого поддерева минус высота правого поддерева; при этом баланс-фактор пустого узла считается равным \\(0\\) . Мы также инкапсулируем получение баланс-фактора в отдельную функцию, чтобы потом было удобнее ее использовать:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"Получить коэффициент баланса\"\"\"\n    # Коэффициент баланса пустого узла равен 0\n    if node is None:\n        return 0\n    # Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode *node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == nullptr)\n        return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null)\n        return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* Получить коэффициент баланса */\nint BalanceFactor(TreeNode? node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* Получить коэффициент баланса */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // Коэффициент баланса пустого узла равен 0\n    if node == nil {\n        return 0\n    }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* Получить коэффициент баланса */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // Коэффициент баланса пустого узла равен 0\n    guard let node = node else { return 0 }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* Получить коэффициент баланса */\nbalanceFactor(node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node === null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* Получить коэффициент баланса */\nbalanceFactor(node: TreeNode): number {\n    // Коэффициент баланса пустого узла равен 0\n    if (node === null) return 0;\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode? node) {\n  // Коэффициент баланса пустого узла равен 0\n  if (node == null) return 0;\n  // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* Получить коэффициент баланса */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // Коэффициент баланса пустого узла равен 0\n        None =&gt; 0,\n        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Получить коэффициент баланса */\nint balanceFactor(TreeNode *node) {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == NULL) {\n        return 0;\n    }\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* Получить коэффициент баланса */\nfun balanceFactor(node: TreeNode?): Int {\n    // Коэффициент баланса пустого узла равен 0\n    if (node == null) return 0\n    // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### Получить коэффициент баланса ###\ndef balance_factor(node)\n  # Коэффициент баланса пустого узла равен 0\n  return 0 if node.nil?\n\n  # Коэффициент баланса узла = высота левого поддерева - высота правого поддерева\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>Пусть баланс-фактор равен \\(f\\) ; тогда для любого узла AVL-дерева выполняется \\(-1 \\le f \\le 1\\) .</p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl-","level":2,"title":"7.5.2   Вращения AVL-дерева","text":"<p>Особенность AVL-дерева заключается в операции \"вращения\", которая позволяет заново сбалансировать разбалансированный узел, не нарушая последовательность симметричного обхода двоичного дерева. Иначе говоря, операция вращения одновременно сохраняет свойство \"двоичного дерева поиска\" и возвращает дерево в состояние \"сбалансированного двоичного дерева\".</p> <p>Узлы, для которых абсолютное значение баланс-фактора больше \\(1\\) , мы называем \"разбалансированными узлами\". В зависимости от вида разбаланса вращения делятся на четыре типа: правое вращение, левое вращение, сначала левое затем правое, и сначала правое затем левое. Ниже разберем их подробно.</p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   Правое вращение","text":"<p>Как показано на рисунках ниже, под узлом указан его баланс-фактор. Если двигаться снизу вверх, то первым разбалансированным узлом в двоичном дереве будет \"узел 3\". Рассмотрим поддерево с этим узлом в качестве корня, обозначим данный узел как <code>node</code> , его левого дочернего узла как <code>child</code> и выполним \"правое вращение\". После завершения правого вращения поддерево снова станет сбалансированным и при этом сохранит свойство двоичного дерева поиска.</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-26   Шаги правого вращения </p> <p>Как показано на рисунке 7-27, когда у узла <code>child</code> есть правый дочерний узел, который мы обозначим как <code>grand_child</code> , в правое вращение нужно добавить еще один шаг: сделать <code>grand_child</code> левым дочерним узлом <code>node</code> .</p> <p></p> <p> Рисунок 7-27   Правое вращение при наличии grand_child </p> <p>\"Поворот вправо\" - это лишь образное описание; в реальности он реализуется через изменение указателей узлов. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Операция правого вращения\"\"\"\n    child = node.left\n    grand_child = child.right\n    # Выполнить правое вращение узла node вокруг child\n    child.right = node\n    node.left = grand_child\n    # Обновить высоту узла\n    self.update_height(node)\n    self.update_height(child)\n    # Вернуть корневой узел поддерева после вращения\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Операция правого вращения */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // Выполнить правое вращение узла node вокруг child\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Операция правого вращения */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Операция правого вращения */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Операция правого вращения */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // Выполнить правое вращение узла node вокруг child\n    child.Right = node\n    node.Left = grandChild\n    // Обновить высоту узла\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Операция правого вращения */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // Выполнить правое вращение узла node вокруг child\n    child?.right = node\n    node?.left = grandChild\n    // Обновить высоту узла\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Операция правого вращения */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Операция правого вращения */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node;\n    node.left = grandChild;\n    // Обновить высоту узла\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Операция правого вращения */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // Выполнить правое вращение узла node вокруг child\n  child.right = node;\n  node.left = grandChild;\n  // Обновить высоту узла\n  updateHeight(node);\n  updateHeight(child);\n  // Вернуть корневой узел поддерева после вращения\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Операция правого вращения */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // Выполнить правое вращение узла node вокруг child\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // Обновить высоту узла\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Вернуть корневой узел поддерева после вращения\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Операция правого вращения */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // Выполнить правое вращение узла node вокруг child\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Операция правого вращения */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // Выполнить правое вращение узла node вокруг child\n    child.right = node\n    node.left = grandChild\n    // Обновить высоту узла\n    updateHeight(node)\n    updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Операция правого вращения ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # Выполнить правое вращение узла node вокруг child\n  child.right = node\n  node.left = grand_child\n  # Обновить высоту узла\n  update_height(node)\n  update_height(child)\n  # Вернуть корневой узел поддерева после вращения\n  child\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   Левое вращение","text":"<p>Соответственно, если рассмотреть \"зеркальную\" версию приведенного выше разбалансированного двоичного дерева, то понадобится выполнить \"левое вращение\", показанное на рисунке 7-28.</p> <p></p> <p> Рисунок 7-28   Левое вращение </p> <p>По той же причине, когда у узла <code>child</code> есть левый дочерний узел, который обозначим как <code>grand_child</code> , в левое вращение также требуется добавить шаг: сделать <code>grand_child</code> правым дочерним узлом <code>node</code> .</p> <p></p> <p> Рисунок 7-29   Левое вращение при наличии grand_child </p> <p>Можно заметить, что операции правого и левого вращения логически зеркально симметричны, и два вида разбаланса, которые они исправляют, тоже симметричны. Поэтому, опираясь на эту симметрию, достаточно заменить в коде правого вращения все <code>left</code> на <code>right</code> , а все <code>right</code> на <code>left</code> , чтобы получить реализацию левого вращения:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Операция левого вращения\"\"\"\n    child = node.right\n    grand_child = child.left\n    # Выполнить левое вращение узла node вокруг child\n    child.left = node\n    node.right = grand_child\n    # Обновить высоту узла\n    self.update_height(node)\n    self.update_height(child)\n    # Вернуть корневой узел поддерева после вращения\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* Операция левого вращения */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // Выполнить левое вращение узла node вокруг child\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* Операция левого вращения */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* Операция левого вращения */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* Операция левого вращения */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // Выполнить левое вращение узла node вокруг child\n    child.Left = node\n    node.Right = grandChild\n    // Обновить высоту узла\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* Операция левого вращения */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // Выполнить левое вращение узла node вокруг child\n    child?.left = node\n    node?.right = grandChild\n    // Обновить высоту узла\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* Операция левого вращения */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* Операция левого вращения */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node;\n    node.right = grandChild;\n    // Обновить высоту узла\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* Операция левого вращения */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // Выполнить левое вращение узла node вокруг child\n  child.left = node;\n  node.right = grandChild;\n  // Обновить высоту узла\n  updateHeight(node);\n  updateHeight(child);\n  // Вернуть корневой узел поддерева после вращения\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* Операция левого вращения */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // Выполнить левое вращение узла node вокруг child\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // Обновить высоту узла\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // Вернуть корневой узел поддерева после вращения\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Операция левого вращения */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // Выполнить левое вращение узла node вокруг child\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // Обновить высоту узла\n    updateHeight(node);\n    updateHeight(child);\n    // Вернуть корневой узел поддерева после вращения\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* Операция левого вращения */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // Выполнить левое вращение узла node вокруг child\n    child.left = node\n    node.right = grandChild\n    // Обновить высоту узла\n    updateHeight(node)\n    updateHeight(child)\n    // Вернуть корневой узел поддерева после вращения\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### Операция левого вращения ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # Выполнить левое вращение узла node вокруг child\n  child.left = node\n  node.right = grand_child\n  # Обновить высоту узла\n  update_height(node)\n  update_height(child)\n  # Вернуть корневой узел поддерева после вращения\n  child\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   Сначала левое, затем правое вращение","text":"<p>Для разбалансированного узла 3 на рисунке 7-30 ни одно лишь левое вращение, ни одно лишь правое вращение не способны вернуть поддерево в баланс. В этом случае нужно сначала выполнить \"левое вращение\" для <code>child</code> , а затем выполнить \"правое вращение\" для <code>node</code> .</p> <p></p> <p> Рисунок 7-30   Сначала левое, затем правое вращение </p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   Сначала правое, затем левое вращение","text":"<p>Как показано на рисунке 7-31, для зеркальной ситуации предыдущего разбалансированного двоичного дерева нужно сначала выполнить \"правое вращение\" для <code>child</code> , а затем \"левое вращение\" для <code>node</code> .</p> <p></p> <p> Рисунок 7-31   Сначала правое, затем левое вращение </p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   Выбор вращения","text":"<p>Четыре вида разбаланса, показанные на рисунке 7-32, по одному соответствуют рассмотренным выше случаям; для них соответственно требуются правое вращение, сначала левое затем правое, сначала правое затем левое и левое вращение.</p> <p></p> <p> Рисунок 7-32   Четыре случая вращений AVL-дерева </p> <p>Как показано в таблице 7-3, мы определяем, какому из этих четырех случаев соответствует разбалансированный узел, по знаку баланс-фактора самого разбалансированного узла и по знаку баланс-фактора дочернего узла на более высокой стороне.</p> <p> Таблица 7-3   Условия выбора для четырех случаев вращений </p> Баланс-фактор разбалансированного узла Баланс-фактор дочернего узла Какое вращение использовать \\(&gt; 1\\) (левостороннее дерево) \\(\\geq 0\\) Правое вращение \\(&gt; 1\\) (левостороннее дерево) \\(&lt;0\\) Сначала левое, затем правое \\(&lt; -1\\) (правостороннее дерево) \\(\\leq 0\\) Левое вращение \\(&lt; -1\\) (правостороннее дерево) \\(&gt;0\\) Сначала правое, затем левое <p>Для удобства мы инкапсулируем операцию вращения в отдельную функцию. С помощью этой функции можно выполнить корректное вращение для любой ситуации разбаланса и снова привести узел в сбалансированное состояние. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"Выполнить вращение, чтобы снова сбалансировать поддерево\"\"\"\n    # Получить коэффициент баланса узла node\n    balance_factor = self.balance_factor(node)\n    # Левосторонне перекошенное дерево\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # Правое вращение\n            return self.right_rotate(node)\n        else:\n            # Сначала левое вращение, затем правое\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # Правосторонне перекошенное дерево\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # Левое вращение\n            return self.left_rotate(node)\n        else:\n            # Сначала правое вращение, затем левое\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode *rotate(TreeNode *node) {\n    // Получить коэффициент баланса узла node\n    int _balanceFactor = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode rotate(TreeNode node) {\n    // Получить коэффициент баланса узла node\n    int balanceFactor = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode? Rotate(TreeNode? node) {\n    // Получить коэффициент баланса узла node\n    int balanceFactorInt = BalanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // Правое вращение\n            return RightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // Левое вращение\n            return LeftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // Получить коэффициент баланса узла node\n    // В Go рекомендуется использовать короткие имена переменных, здесь bf обозначает t.balanceFactor\n    bf := t.balanceFactor(node)\n    // Левосторонне перекошенное дерево\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // Правое вращение\n            return t.rightRotate(node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // Левое вращение\n            return t.leftRotate(node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // Получить коэффициент баланса узла node\n    let balanceFactor = balanceFactor(node: node)\n    // Левосторонне перекошенное дерево\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // Правое вращение\n            return rightRotate(node: node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // Левое вращение\n            return leftRotate(node: node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\n#rotate(node) {\n    // Получить коэффициент баланса узла node\n    const balanceFactor = this.balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return this.#rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return this.#leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nrotate(node: TreeNode): TreeNode {\n    // Получить коэффициент баланса узла node\n    const balanceFactor = this.balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return this.rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return this.leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode? rotate(TreeNode? node) {\n  // Получить коэффициент баланса узла node\n  int factor = balanceFactor(node);\n  // Левосторонне перекошенное дерево\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // Правое вращение\n      return rightRotate(node);\n    } else {\n      // Сначала левое вращение, затем правое\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // Правосторонне перекошенное дерево\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // Левое вращение\n      return leftRotate(node);\n    } else {\n      // Сначала правое вращение, затем левое\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // Дерево сбалансировано, вращение не требуется, вернуть сразу\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // Получить коэффициент баланса узла node\n    let balance_factor = Self::balance_factor(node.clone());\n    // Левосторонне перекошенное дерево\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // Правое вращение\n            Self::right_rotate(Some(node))\n        } else {\n            // Сначала левое вращение, затем правое\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // Правосторонне перекошенное дерево\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // Левое вращение\n            Self::left_rotate(Some(node))\n        } else {\n            // Сначала правое вращение, затем левое\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // Дерево сбалансировано, вращение не требуется, вернуть сразу\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nTreeNode *rotate(TreeNode *node) {\n    // Получить коэффициент баланса узла node\n    int bf = balanceFactor(node);\n    // Левосторонне перекошенное дерево\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node);\n        } else {\n            // Сначала левое вращение, затем правое\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node);\n        } else {\n            // Сначала правое вращение, затем левое\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Выполнить вращение, чтобы снова сбалансировать поддерево */\nfun rotate(node: TreeNode): TreeNode {\n    // Получить коэффициент баланса узла node\n    val balanceFactor = balanceFactor(node)\n    // Левосторонне перекошенное дерево\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // Правое вращение\n            return rightRotate(node)\n        } else {\n            // Сначала левое вращение, затем правое\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // Правосторонне перекошенное дерево\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // Левое вращение\n            return leftRotate(node)\n        } else {\n            // Сначала правое вращение, затем левое\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // Дерево сбалансировано, вращение не требуется, вернуть сразу\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Выполнить вращение, чтобы снова сбалансировать поддерево ###\ndef rotate(node)\n  # Получить коэффициент баланса узла node\n  balance_factor = balance_factor(node)\n  # Обойти левое поддерево\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # Правое вращение\n      return right_rotate(node)\n    else\n      # Сначала левое вращение, затем правое\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # Правостороннее дерево обхода\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # Левое вращение\n      return left_rotate(node)\n    else\n      # Сначала правое вращение, затем левое\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # Дерево сбалансировано, вращение не требуется, вернуть сразу\n  node\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl-","level":2,"title":"7.5.3   Распространенные операции AVL-дерева","text":"","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   Вставка узла","text":"<p>Операция вставки узла в AVL-дерево по основному процессу похожа на вставку в двоичное дерево поиска. Единственная разница состоит в том, что после вставки в AVL-дерево на пути от вставленного узла к корню может появиться цепочка разбалансированных узлов. Поэтому начиная от этого узла, мы должны выполнять вращения снизу вверх, чтобы вернуть в баланс все разбалансированные узлы. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"Вставка узла\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"Рекурсивная вставка узла (вспомогательный метод)\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. Найти позицию вставки и вставить узел\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # Повторяющийся узел не вставлять, сразу вернуть\n        return node\n    # Обновить высоту узла\n    self.update_height(node)\n    # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Вставка узла */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Вставка узла */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Вставка узла */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // Повторяющийся узел не вставлять, сразу вернуть\n    UpdateHeight(node);  // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = Rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Вставка узла */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* Рекурсивная вставка узла (вспомогательная функция) */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // Повторяющийся узел не вставлять, сразу вернуть\n        return node\n    }\n    // Обновить высоту узла\n    t.updateHeight(node)\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = t.rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Вставка узла */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // Повторяющийся узел не вставлять, сразу вернуть\n    }\n    updateHeight(node: node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node: node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Вставка узла */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // Повторяющийся узел не вставлять, сразу вернуть\n    this.#updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.#rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Вставка узла */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // Повторяющийся узел не вставлять, сразу вернуть\n    }\n    this.updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Вставка узла */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. Найти позицию вставки и вставить узел */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // Повторяющийся узел не вставлять, сразу вернуть\n  updateHeight(node); // Обновить высоту узла\n  /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n  node = rotate(node);\n  // Вернуть корневой узел поддерева\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Вставка узла */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Найти позицию вставки и вставить узел */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // Повторяющийся узел не вставлять, сразу вернуть\n                }\n            }\n            Self::update_height(Some(node.clone())); // Обновить высоту узла\n\n            /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n            node = Self::rotate(Some(node)).unwrap();\n            // Вернуть корневой узел поддерева\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Вставка узла */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* Рекурсивная вставка узла (вспомогательная функция) */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. Найти позицию вставки и вставить узел */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // Повторяющийся узел не вставлять, сразу вернуть\n        return node;\n    }\n    // Обновить высоту узла\n    updateHeight(node);\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Вставка узла */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* Рекурсивная вставка узла (вспомогательный метод) */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. Найти позицию вставки и вставить узел */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // Повторяющийся узел не вставлять, сразу вернуть\n    updateHeight(node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Вставка узла ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### Вставка узла ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n# ## Рекурсивная вставка узла (вспомогательный метод) ###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. Найти позицию вставки и вставить узел\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # Повторяющийся узел не вставлять, сразу вернуть\n    return node\n  end\n  # Обновить высоту узла\n  update_height(node)\n  # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n  rotate(node)\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   Удаление узла","text":"<p>Аналогично, на основе метода удаления узла из двоичного дерева поиска нужно добавить вращения снизу вверх, чтобы восстановить баланс всех разбалансированных узлов. Код приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"Удаление узла\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"Рекурсивное удаление узла (вспомогательный метод)\"\"\"\n    if node is None:\n        return None\n    # 1. Найти узел и удалить его\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # Число дочерних узлов = 0, удалить node и сразу вернуть\n            if child is None:\n                return None\n            # Число дочерних узлов = 1, удалить node напрямую\n            else:\n                node = child\n        else:\n            # Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # Обновить высоту узла\n    self.update_height(node)\n    # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* Удаление узла */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // Число дочерних узлов = 1, удалить node напрямую\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* Удаление узла */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* Удаление узла */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = Rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* Удаление узла */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* Рекурсивное удаление узла (вспомогательная функция) */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. Найти узел и удалить его */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // Число дочерних узлов = 0, удалить node и сразу вернуть\n                return nil\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // Обновить высоту узла\n    t.updateHeight(node)\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = t.rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* Удаление узла */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. Найти узел и удалить его */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if child == nil {\n                return nil\n            }\n            // Число дочерних узлов = 1, удалить node напрямую\n            else {\n                node = child\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node: node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* Удаление узла */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child === null) return null;\n            // Число дочерних узлов = 1, удалить node напрямую\n            else node = child;\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.#rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* Удаление узла */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child === null) {\n                return null;\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = this.rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* Удаление узла */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. Найти узел и удалить его */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // Число дочерних узлов = 0, удалить node и сразу вернуть\n      if (child == null)\n        return null;\n      // Число дочерних узлов = 1, удалить node напрямую\n      else\n        node = child;\n    } else {\n      // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // Обновить высоту узла\n  /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n  node = rotate(node);\n  // Вернуть корневой узел поддерева\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* Удаление узла */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. Найти узел и удалить его */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // Число дочерних узлов = 0, удалить node и сразу вернуть\n                    None =&gt; {\n                        return None;\n                    }\n                    // Число дочерних узлов = 1, удалить node напрямую\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // Обновить высоту узла\n\n            /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n            node = Self::rotate(Some(node)).unwrap();\n            // Вернуть корневой узел поддерева\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* Удаление узла */\n// Из-за подключения stdio.h здесь нельзя использовать ключевое слово remove\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* Рекурсивное удаление узла (вспомогательная функция) */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. Найти узел и удалить его */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // Число дочерних узлов = 1, удалить node напрямую\n                node = child;\n            }\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // Обновить высоту узла\n    updateHeight(node);\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node);\n    // Вернуть корневой узел поддерева\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* Удаление узла */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* Рекурсивное удаление узла (вспомогательный метод) */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. Найти узел и удалить его */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // Число дочерних узлов = 0, удалить node и сразу вернуть\n            if (child == null)\n                return null\n            // Число дочерних узлов = 1, удалить node напрямую\n            else\n                node = child\n        } else {\n            // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // Обновить высоту узла\n    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */\n    node = rotate(node)\n    // Вернуть корневой узел поддерева\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### Удаление узла ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### Удаление узла ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n# ## Рекурсивное удаление узла (вспомогательный метод) ###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. Найти узел и удалить его\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # Число дочерних узлов = 0, удалить node и сразу вернуть\n      return if child.nil?\n      # Число дочерних узлов = 1, удалить node напрямую\n      node = child\n    else\n      # Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # Обновить высоту узла\n  update_height(node)\n  # 2. Выполнить вращение, чтобы снова сбалансировать поддерево\n  rotate(node)\nend\n</code></pre>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   Поиск узла","text":"<p>Операция поиска узла в AVL-дереве совпадает с поиском в двоичном дереве поиска, поэтому здесь она повторно не рассматривается.</p>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl-","level":2,"title":"7.5.4   Типичные применения AVL-дерева","text":"<ul> <li>Организация и хранение больших массивов данных, особенно в сценариях с частым поиском и относительно редкими вставками и удалениями.</li> <li>Использование при построении индексных систем в базах данных.</li> <li>Красно-черное дерево тоже является распространенным видом сбалансированного двоичного дерева поиска. По сравнению с AVL-деревом условия баланса у красно-черного дерева мягче, поэтому при вставке и удалении требуется меньше вращений, а средняя эффективность операций добавления и удаления выше.</li> </ul>","path":["Глава 7. Деревья","7.5 &nbsp; AVL-дерево *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   Двоичное дерево поиска","text":"<p>Как показано на рисунке 7-16, двоичное дерево поиска (binary search tree) удовлетворяет следующим условиям.</p> <ol> <li>Для корневого узла все значения в левом поддереве меньше значения корневого узла, а все значения в правом поддереве больше значения корневого узла.</li> <li>Левое и правое поддеревья любого узла также являются двоичными деревьями поиска, то есть тоже удовлетворяют условию <code>1.</code> .</li> </ol> <p></p> <p> Рисунок 7-16   Двоичное дерево поиска </p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   Операции с двоичным деревом поиска","text":"<p>Мы инкапсулируем двоичное дерево поиска в класс <code>BinarySearchTree</code> и объявляем переменную-член <code>root</code> , которая указывает на корневой узел дерева.</p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   Поиск узла","text":"<p>Для заданного целевого значения узла <code>num</code> можно выполнить поиск, опираясь на свойства двоичного дерева поиска. Как показано на рисунках ниже, мы объявляем узел <code>cur</code> , стартуем от корня дерева <code>root</code> и циклически сравниваем значения <code>cur.val</code> и <code>num</code> .</p> <ul> <li>Если <code>cur.val &lt; num</code> , это означает, что целевой узел находится в правом поддереве <code>cur</code> , поэтому выполняем <code>cur = cur.right</code> .</li> <li>Если <code>cur.val &gt; num</code> , это означает, что целевой узел находится в левом поддереве <code>cur</code> , поэтому выполняем <code>cur = cur.left</code> .</li> <li>Если <code>cur.val = num</code> , это означает, что целевой узел найден, и мы выходим из цикла, возвращая этот узел.</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-17   Пример поиска узла в двоичном дереве поиска </p> <p>Операция поиска в двоичном дереве поиска работает по тому же принципу, что и двоичный поиск: на каждом шаге она отбрасывает половину вариантов. Число итераций не превосходит высоты двоичного дерева, а когда дерево сбалансировано, требуется \\(O(\\log n)\\) времени. Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"Поиск узла\"\"\"\n    cur = self._root\n    # Искать в цикле и выйти после прохода за листовой узел\n    while cur is not None:\n        # Целевой узел находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Целевой узел находится в левом поддереве cur\n        elif cur.val &gt; num:\n            cur = cur.left\n        # Найти целевой узел и выйти из цикла\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* Поиск узла */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Поиск узла */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Поиск узла */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else\n            break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* Поиск узла */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // Искать в цикле и выйти после прохода за листовой узел\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // Целевой узел находится в правом поддереве cur\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // Целевой узел находится в левом поддереве cur\n            node = node.Left\n        } else {\n            // Найти целевой узел и выйти из цикла\n            break\n        }\n    }\n    // Вернуть целевой узел\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Поиск узла */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Целевой узел находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Целевой узел находится в левом поддереве cur\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // Найти целевой узел и выйти из цикла\n        else {\n            break\n        }\n    }\n    // Вернуть целевой узел\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* Поиск узла */\nsearch(num) {\n    let cur = this.root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num) cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Поиск узла */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Целевой узел находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Целевой узел находится в левом поддереве cur\n        else if (cur.val &gt; num) cur = cur.left;\n        // Найти целевой узел и выйти из цикла\n        else break;\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Поиск узла */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Целевой узел находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Целевой узел находится в левом поддереве cur\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // Найти целевой узел и выйти из цикла\n    else\n      break;\n  }\n  // Вернуть целевой узел\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Поиск узла */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Целевой узел находится в правом поддереве cur\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // Целевой узел находится в левом поддереве cur\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // Найти целевой узел и выйти из цикла\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // Вернуть целевой узел\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* Поиск узла */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // Целевой узел находится в правом поддереве cur\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // Целевой узел находится в левом поддереве cur\n            cur = cur-&gt;left;\n        } else {\n            // Найти целевой узел и выйти из цикла\n            break;\n        }\n    }\n    // Вернуть целевой узел\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Поиск узла */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Целевой узел находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Целевой узел находится в левом поддереве cur\n        else if (cur._val &gt; num)\n            cur.left\n        // Найти целевой узел и выйти из цикла\n        else\n            break\n    }\n    // Вернуть целевой узел\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### Поиск узла ###\ndef search(num)\n  cur = @root\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  while !cur.nil?\n    # Целевой узел находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Целевой узел находится в левом поддереве cur\n    elsif cur.val &gt; num\n      cur = cur.left\n    # Найти целевой узел и выйти из цикла\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   Вставка узла","text":"<p>Пусть дан элемент <code>num</code> , который нужно вставить. Чтобы сохранить свойство двоичного дерева поиска \"левое поддерево &lt; корень &lt; правое поддерево\", процесс вставки выглядит следующим образом.</p> <ol> <li>Найти позицию для вставки: как и в операции поиска, начиная от корня, мы циклически спускаемся вниз в зависимости от соотношения между текущим значением узла и <code>num</code> , пока не выйдем за листовой узел (то есть не дойдем до <code>None</code> ).</li> <li>Вставить узел в найденную позицию: инициализировать узел <code>num</code> и поставить его на место этого <code>None</code> .</li> </ol> <p></p> <p> Рисунок 7-18   Вставка узла в двоичное дерево поиска </p> <p>В реализации кода нужно обратить внимание на следующие два момента.</p> <ul> <li>Двоичное дерево поиска не допускает дублирующихся узлов, иначе его определение будет нарушено. Поэтому если вставляемый узел уже существует в дереве, вставка не выполняется и функция сразу возвращается.</li> <li>Чтобы реализовать вставку, нам нужно использовать узел <code>pre</code> для сохранения узла предыдущей итерации цикла. Тогда, когда обход дойдет до <code>None</code> , мы сможем получить его родителя и завершить вставку.</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"Вставка узла\"\"\"\n    # Если дерево пусто, инициализировать корневой узел\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # Искать в цикле и выйти после прохода за листовой узел\n    cur, pre = self._root, None\n    while cur is not None:\n        # Найти повторяющийся узел и сразу вернуть\n        if cur.val == num:\n            return\n        pre = cur\n        # Позиция вставки находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Позиция вставки находится в левом поддереве cur\n        else:\n            cur = cur.left\n    # Вставка узла\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* Вставка узла */\nvoid insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur-&gt;left;\n    }\n    // Вставка узла\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* Вставка узла */\nvoid insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Вставка узла\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Вставка узла */\nvoid Insert(int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n\n    // Вставка узла\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Вставка узла */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // Если дерево пусто, инициализировать корневой узел\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // Позиция узла, предшествующего вставляемому\n    var pre *TreeNode = nil\n    // Искать в цикле и выйти после прохода за листовой узел\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // Вставка узла\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Вставка узла */\nfunc insert(num: Int) {\n    // Если дерево пусто, инициализировать корневой узел\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Найти повторяющийся узел и сразу вернуть\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // Позиция вставки находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Позиция вставки находится в левом поддереве cur\n        else {\n            cur = cur?.left\n        }\n    }\n    // Вставка узла\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Вставка узла */\ninsert(num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val === num) return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Вставка узла\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Вставка узла */\ninsert(num: number): void {\n    // Если дерево пусто, инициализировать корневой узел\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur.val === num) return;\n        pre = cur;\n        // Позиция вставки находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Позиция вставки находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Вставка узла\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Вставка узла */\nvoid insert(int _num) {\n  // Если дерево пусто, инициализировать корневой узел\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Найти повторяющийся узел и сразу вернуть\n    if (cur.val == _num) return;\n    pre = cur;\n    // Позиция вставки находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Позиция вставки находится в левом поддереве cur\n    else\n      cur = cur.left;\n  }\n  // Вставка узла\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Вставка узла */\npub fn insert(&amp;mut self, num: i32) {\n    // Если дерево пусто, инициализировать корневой узел\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Найти повторяющийся узел и сразу вернуть\n            Ordering::Equal =&gt; return,\n            // Позиция вставки находится в правом поддереве cur\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Позиция вставки находится в левом поддереве cur\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Вставка узла\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Вставка узла */\nvoid insert(BinarySearchTree *bst, int num) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Позиция вставки находится в правом поддереве cur\n            cur = cur-&gt;right;\n        } else {\n            // Позиция вставки находится в левом поддереве cur\n            cur = cur-&gt;left;\n        }\n    }\n    // Вставка узла\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Вставка узла */\nfun insert(num: Int) {\n    // Если дерево пусто, инициализировать корневой узел\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти повторяющийся узел и сразу вернуть\n        if (cur._val == num)\n            return\n        pre = cur\n        // Позиция вставки находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Позиция вставки находится в левом поддереве cur\n        else\n            cur.left\n    }\n    // Вставка узла\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### Вставка узла ###\ndef insert(num)\n  # Если дерево пусто, инициализировать корневой узел\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Найти повторяющийся узел и сразу вернуть\n    return if cur.val == num\n\n    pre = cur\n    # Позиция вставки находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Позиция вставки находится в левом поддереве cur\n    else\n      cur = cur.left\n    end\n  end\n\n  # Вставка узла\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Как и поиск узла, вставка узла требует \\(O(\\log n)\\) времени.</p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   Удаление узла","text":"<p>Сначала нужно найти в двоичном дереве целевой узел, а затем удалить его. Как и при вставке, после удаления необходимо сохранить свойство двоичного дерева поиска: \"левое поддерево &lt; корень &lt; правое поддерево\". Поэтому в зависимости от числа дочерних узлов у удаляемого узла, то есть для случаев со степенью 0, 1 и 2, выполняются разные операции удаления.</p> <p>Как показано на рисунке 7-19, когда степень удаляемого узла равна \\(0\\) , это значит, что узел является листом и может быть удален напрямую.</p> <p></p> <p> Рисунок 7-19   Удаление узла в двоичном дереве поиска (степень 0) </p> <p>Как показано на рисунке 7-20, когда степень удаляемого узла равна \\(1\\) , достаточно заменить удаляемый узел его дочерним узлом.</p> <p></p> <p> Рисунок 7-20   Удаление узла в двоичном дереве поиска (степень 1) </p> <p>Когда степень удаляемого узла равна \\(2\\) , мы уже не можем удалить его напрямую и должны использовать для замены другой узел. Чтобы сохранить свойство двоичного дерева поиска \"левое поддерево \\(&lt;\\) корень \\(&lt;\\) правое поддерево\", этим узлом может быть минимальный узел правого поддерева или максимальный узел левого поддерева.</p> <p>Предположим, мы выбираем минимальный узел правого поддерева, то есть следующий узел в симметричном обходе. Тогда процесс удаления выглядит так.</p> <ol> <li>Найти следующий узел в \"последовательности симметричного обхода\" для удаляемого узла и обозначить его как <code>tmp</code> .</li> <li>Значением <code>tmp</code> перезаписать значение удаляемого узла, а затем рекурсивно удалить узел <code>tmp</code> из дерева.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-21   Удаление узла в двоичном дереве поиска (степень 2) </p> <p>Операция удаления узла также требует \\(O(\\log n)\\) времени, где поиск удаляемого узла стоит \\(O(\\log n)\\) , а получение следующего узла симметричного обхода также требует \\(O(\\log n)\\) . Пример кода приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"Удаление узла\"\"\"\n    # Если дерево пусто, сразу вернуть\n    if self._root is None:\n        return\n    # Искать в цикле и выйти после прохода за листовой узел\n    cur, pre = self._root, None\n    while cur is not None:\n        # Найти узел для удаления и выйти из цикла\n        if cur.val == num:\n            break\n        pre = cur\n        # Узел для удаления находится в правом поддереве cur\n        if cur.val &lt; num:\n            cur = cur.right\n        # Узел для удаления находится в левом поддереве cur\n        else:\n            cur = cur.left\n    # Если узел для удаления отсутствует, сразу вернуть\n    if cur is None:\n        return\n\n    # Число дочерних узлов = 0 или 1\n    if cur.left is None or cur.right is None:\n        # Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        child = cur.left or cur.right\n        # Удалить узел cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # Если удаляемый узел является корнем, заново назначить корневой узел\n            self._root = child\n    # Число дочерних узлов = 2\n    else:\n        # Получить следующий узел после cur в симметричном обходе\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # Рекурсивно удалить узел tmp\n        self.remove(tmp.val)\n        # Перезаписать cur значением tmp\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* Удаление узла */\nvoid remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != nullptr) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur-&gt;left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == nullptr)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n        // Освободить память\n        delete cur;\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Рекурсивно удалить узел tmp\n        remove(tmp-&gt;val);\n        // Перезаписать cur значением tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* Удаление узла */\nvoid remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        remove(tmp.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* Удаление узла */\nvoid Remove(int num) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        TreeNode? child = cur.left ?? cur.right;\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        Remove(tmp.val!.Value);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* Удаление узла */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // Если дерево пусто, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Позиция узла, предшествующего удаляемому\n    var pre *TreeNode = nil\n    // Искать в цикле и выйти после прохода за листовой узел\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // Удаляемый узел находится в правом поддереве\n            cur = cur.Right\n        } else {\n            // Удаляемый узел находится в левом поддереве\n            cur = cur.Left\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Число дочерних узлов равно 0 или 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // Извлечь дочерний узел удаляемого узла\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // Удалить узел cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            bst.root = child\n        }\n        // Число дочерних узлов равно 2\n    } else {\n        // Получить следующий после cur узел в симметричном обходе для удаляемого узла\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // Рекурсивно удалить узел tmp\n        bst.remove(tmp.Val.(int))\n        // Перезаписать cur значением tmp\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* Удаление узла */\nfunc remove(num: Int) {\n    // Если дерево пусто, сразу вернуть\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // Искать в цикле и выйти после прохода за листовой узел\n    while cur != nil {\n        // Найти узел для удаления и выйти из цикла\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // Узел для удаления находится в правом поддереве cur\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // Узел для удаления находится в левом поддереве cur\n        else {\n            cur = cur?.left\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur == nil {\n        return\n    }\n    // Число дочерних узлов = 0 или 1\n    if cur?.left == nil || cur?.right == nil {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        let child = cur?.left ?? cur?.right\n        // Удалить узел cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // Рекурсивно удалить узел tmp\n        remove(num: tmp!.val)\n        // Перезаписать cur значением tmp\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* Удаление узла */\nremove(num) {\n    // Если дерево пусто, сразу вернуть\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val === num) break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur === null) return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left === null || cur.right === null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        const child = cur.left !== null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            this.root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // Рекурсивно удалить узел tmp\n        this.remove(tmp.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* Удаление узла */\nremove(num: number): void {\n    // Если дерево пусто, сразу вернуть\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur !== null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur.val === num) break;\n        pre = cur;\n        // Узел для удаления находится в правом поддереве cur\n        if (cur.val &lt; num) cur = cur.right;\n        // Узел для удаления находится в левом поддереве cur\n        else cur = cur.left;\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur === null) return;\n    // Число дочерних узлов = 0 или 1\n    if (cur.left === null || cur.right === null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // Удалить узел cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            this.root = child;\n        }\n    }\n    // Число дочерних узлов = 2\n    else {\n        // Получить следующий узел после cur в симметричном обходе\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // Рекурсивно удалить узел tmp\n        this.remove(tmp!.val);\n        // Перезаписать cur значением tmp\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* Удаление узла */\nvoid remove(int _num) {\n  // Если дерево пусто, сразу вернуть\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // Искать в цикле и выйти после прохода за листовой узел\n  while (cur != null) {\n    // Найти узел для удаления и выйти из цикла\n    if (cur.val == _num) break;\n    pre = cur;\n    // Узел для удаления находится в правом поддереве cur\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // Узел для удаления находится в левом поддереве cur\n    else\n      cur = cur.left;\n  }\n  // Если удаляемого узла нет, сразу вернуть\n  if (cur == null) return;\n  // Число дочерних узлов = 0 или 1\n  if (cur.left == null || cur.right == null) {\n    // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n    TreeNode? child = cur.left ?? cur.right;\n    // Удалить узел cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // Если удаляемый узел является корнем, заново назначить корневой узел\n      _root = child;\n    }\n  } else {\n    // Число дочерних узлов = 2\n    // Получить следующий узел после cur в симметричном обходе\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // Рекурсивно удалить узел tmp\n    remove(tmp.val);\n    // Перезаписать cur значением tmp\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* Удаление узла */\npub fn remove(&amp;mut self, num: i32) {\n    // Если дерево пусто, сразу вернуть\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // Найти узел для удаления и выйти из цикла\n            Ordering::Equal =&gt; break,\n            // Узел для удаления находится в правом поддереве cur\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // Узел для удаления находится в левом поддереве cur\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // Число дочерних узлов = 0 или 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // Удалить узел cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // Если удаляемый узел является корнем, заново назначить корневой узел\n                self.root = child;\n            }\n        }\n        // Число дочерних узлов = 2\n        (Some(_), Some(_)) =&gt; {\n            // Получить следующий узел после cur в симметричном обходе\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // Рекурсивно удалить узел tmp\n            self.remove(tmp_val);\n            // Перезаписать cur значением tmp\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* Удаление узла */\n// Из-за подключения stdio.h здесь нельзя использовать ключевое слово remove\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // Если дерево пусто, сразу вернуть\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != NULL) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // Удаляемый узел находится в правом поддереве root\n            cur = cur-&gt;right;\n        } else {\n            // Удаляемый узел находится в левом поддереве root\n            cur = cur-&gt;left;\n        }\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == NULL)\n        return;\n    // Проверить, есть ли дочерние узлы у удаляемого узла\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* Число дочерних узлов = 0 или 1 */\n        // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // Удалить узел cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // Освободить память\n        free(cur);\n    } else {\n        /* Число дочерних узлов = 2 */\n        // Получить следующий узел после cur в симметричном обходе\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // Рекурсивно удалить узел tmp\n        removeItem(bst, tmp-&gt;val);\n        // Перезаписать cur значением tmp\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* Удаление узла */\nfun remove(num: Int) {\n    // Если дерево пусто, сразу вернуть\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // Искать в цикле и выйти после прохода за листовой узел\n    while (cur != null) {\n        // Найти узел для удаления и выйти из цикла\n        if (cur._val == num)\n            break\n        pre = cur\n        // Узел для удаления находится в правом поддереве cur\n        cur = if (cur._val &lt; num)\n            cur.right\n        // Узел для удаления находится в левом поддереве cur\n        else\n            cur.left\n    }\n    // Если узел для удаления отсутствует, сразу вернуть\n    if (cur == null)\n        return\n    // Число дочерних узлов = 0 или 1\n    if (cur.left == null || cur.right == null) {\n        // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // Удалить узел cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // Если удаляемый узел является корнем, заново назначить корневой узел\n            root = child\n        }\n        // Число дочерних узлов = 2\n    } else {\n        // Получить следующий узел после cur в симметричном обходе\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // Рекурсивно удалить узел tmp\n        remove(tmp._val)\n        // Перезаписать cur значением tmp\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### Удаление узла ###\ndef remove(num)\n  # Если дерево пусто, сразу вернуть\n  return if @root.nil?\n\n  # Искать в цикле и выйти после прохода за листовой узел\n  cur, pre = @root, nil\n  while !cur.nil?\n    # Найти узел для удаления и выйти из цикла\n    break if cur.val == num\n\n    pre = cur\n    # Узел для удаления находится в правом поддереве cur\n    if cur.val &lt; num\n      cur = cur.right\n    # Узел для удаления находится в левом поддереве cur\n    else\n      cur = cur.left\n    end\n  end\n  # Если узел для удаления отсутствует, сразу вернуть\n  return if cur.nil?\n\n  # Число дочерних узлов = 0 или 1\n  if cur.left.nil? || cur.right.nil?\n    # Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел\n    child = cur.left || cur.right\n    # Удалить узел cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # Если удаляемый узел является корнем, заново назначить корневой узел\n      @root = child\n    end\n  # Число дочерних узлов = 2\n  else\n    # Получить следующий узел после cur в симметричном обходе\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # Рекурсивно удалить узел tmp\n    remove(tmp.val)\n    # Перезаписать cur значением tmp\n    cur.val = tmp.val\n  end\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   Упорядоченность симметричного обхода","text":"<p>Как показано на рисунке 7-22, симметричный обход двоичного дерева следует порядку \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\", а двоичное дерево поиска удовлетворяет соотношению \"левый дочерний узел \\(&lt;\\) корень \\(&lt;\\) правый дочерний узел\".</p> <p>Это означает, что при симметричном обходе двоичного дерева поиска мы всегда сначала будем посещать следующий минимальный узел, и отсюда получается важное свойство: последовательность симметричного обхода двоичного дерева поиска является возрастающей.</p> <p>Используя это свойство возрастающей последовательности симметричного обхода, мы можем получить отсортированные данные из двоичного дерева поиска всего за \\(O(n)\\) времени, без дополнительной сортировки, что очень эффективно.</p> <p></p> <p> Рисунок 7-22   Последовательность симметричного обхода двоичного дерева поиска </p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   Эффективность двоичного дерева поиска","text":"<p>Для заданного набора данных можно рассмотреть хранение либо в массиве, либо в двоичном дереве поиска. Из таблицы ниже видно, что временная сложность операций двоичного дерева поиска имеет логарифмический порядок и обеспечивает стабильную высокую производительность. Только в сценариях с очень частыми вставками и редкими поисками и удалениями массив может быть эффективнее, чем двоичное дерево поиска.</p> <p> Таблица 7-2   Сравнение эффективности массива и дерева поиска </p> Неупорядоченный массив Двоичное дерево поиска Поиск элемента \\(O(n)\\) \\(O(\\log n)\\) Вставка элемента \\(O(1)\\) \\(O(\\log n)\\) Удаление элемента \\(O(n)\\) \\(O(\\log n)\\) <p>В идеальном случае двоичное дерево поиска является \"сбалансированным\", и тогда любой узел можно найти за \\(\\log n\\) итераций.</p> <p>Однако если в двоичное дерево поиска непрерывно вставлять и удалять узлы, оно может выродиться в связный список, как показано на рисунке 7-23. Тогда временная сложность различных операций тоже вырождается до \\(O(n)\\) .</p> <p></p> <p> Рисунок 7-23   Деградация двоичного дерева поиска </p>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   Типичные применения двоичного дерева поиска","text":"<ul> <li>Используется как многоуровневый индекс в системах, обеспечивая эффективный поиск, вставку и удаление.</li> <li>Служит базовой структурой данных для некоторых поисковых алгоритмов.</li> <li>Применяется для хранения потока данных в отсортированном состоянии.</li> </ul>","path":["Глава 7. Деревья","7.4 &nbsp; Двоичное дерево поиска"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   Двоичное дерево","text":"<p>Двоичное дерево (binary tree) - это нелинейная структура данных, представляющая отношения между \"предками\" и \"потомками\" и отражающая логику \"разделяй и властвуй\". Подобно связному списку, базовой единицей двоичного дерева является узел; каждый узел содержит значение, ссылку на левого дочернего узла и ссылку на правого дочернего узла.</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"Класс узла двоичного дерева\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Значение узла\n        self.left: TreeNode | None = None  # Ссылка на левого дочернего узла\n        self.right: TreeNode | None = None # Ссылка на правого дочернего узла\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\nstruct TreeNode {\n    int val;          // Значение узла\n    TreeNode *left;   // Указатель на левого дочернего узла\n    TreeNode *right;  // Указатель на правого дочернего узла\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    int val;         // Значение узла\n    TreeNode left;   // Ссылка на левого дочернего узла\n    TreeNode right;  // Ссылка на правого дочернего узла\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode(int? x) {\n    public int? val = x;    // Значение узла\n    public TreeNode? left;  // Ссылка на левого дочернего узла\n    public TreeNode? right; // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* Конструктор */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // Указатель на левого дочернего узла\n        Right: nil, // Указатель на правого дочернего узла\n        Val:   v,   // Значение узла\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    var val: Int // Значение узла\n    var left: TreeNode? // Ссылка на левого дочернего узла\n    var right: TreeNode? // Ссылка на правого дочернего узла\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    val; // Значение узла\n    left; // Указатель на левого дочернего узла\n    right; // Указатель на правого дочернего узла\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // Значение узла\n        this.left = left === undefined ? null : left; // Ссылка на левого дочернего узла\n        this.right = right === undefined ? null : right; // Ссылка на правого дочернего узла\n    }\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode {\n  int val;         // Значение узла\n  TreeNode? left;  // Ссылка на левого дочернего узла\n  TreeNode? right; // Ссылка на правого дочернего узла\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Структура узла двоичного дерева */\nstruct TreeNode {\n    val: i32,                               // Значение узла\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // Ссылка на левого дочернего узла\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // Ссылка на правого дочернего узла\n}\n\nimpl TreeNode {\n    /* Конструктор */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* Структура узла двоичного дерева */\ntypedef struct TreeNode {\n    int val;                // Значение узла\n    int height;             // Высота узла\n    struct TreeNode *left;  // Указатель на левого дочернего узла\n    struct TreeNode *right; // Указатель на правого дочернего узла\n} TreeNode;\n\n/* Конструктор */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* Класс узла двоичного дерева */\nclass TreeNode(val _val: Int) {  // Значение узла\n    val left: TreeNode? = null   // Ссылка на левого дочернего узла\n    val right: TreeNode? = null  // Ссылка на правого дочернего узла\n}\n</code></pre> <pre><code>### Класс узла двоичного дерева ###\nclass TreeNode\n  attr_accessor :val    # Значение узла\n  attr_accessor :left   # Ссылка на левого дочернего узла\n  attr_accessor :right  # Ссылка на правого дочернего узла\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>Каждый узел имеет две ссылки (указателя), которые соответственно указывают на левого дочернего узла (left-child node) и правого дочернего узла (right-child node); данный узел называется родительским узлом (parent node) для этих двух дочерних узлов. Если задан некоторый узел двоичного дерева, то дерево, образованное его левым дочерним узлом и всеми узлами ниже него, называется левым поддеревом (left subtree) этого узла; аналогично определяется правое поддерево (right subtree).</p> <p>Узлы, не имеющие дочерних узлов, называют листьями, а все остальные узлы содержат дочерние узлы и непустые поддеревья. Как показано на рисунке 7-1, если рассматривать \"узел 2\" как родительский, то его левым и правым дочерними узлами будут \"узел 4\" и \"узел 5\"; левое поддерево - это \"узел 4 и дерево ниже него\", а правое поддерево - это \"узел 5 и дерево ниже него\".</p> <p></p> <p> Рисунок 7-1   Родительский узел, дочерние узлы и поддеревья </p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   Распространенные термины двоичного дерева","text":"<p>Распространенные термины двоичного дерева показаны на рисунке 7-2.</p> <ul> <li>Корневой узел (root node): узел, расположенный на верхнем уровне двоичного дерева и не имеющий родительского узла.</li> <li>Листовой узел (leaf node): узел без дочерних узлов; оба его указателя направлены на <code>None</code> .</li> <li>Ребро (edge): отрезок, соединяющий два узла, то есть ссылка (указатель) между узлами.</li> <li>Уровень (level) узла: увеличивается сверху вниз; уровень корневого узла равен 1 .</li> <li>Степень (degree) узла: число дочерних узлов данного узла. В двоичном дереве возможны степени 0, 1, 2 .</li> <li>Высота (height) двоичного дерева: число ребер от корневого узла до самого удаленного листового узла.</li> <li>Глубина (depth) узла: число ребер от корневого узла до данного узла.</li> <li>Высота (height) узла: число ребер от самого удаленного листового узла до данного узла.</li> </ul> <p></p> <p> Рисунок 7-2   Распространенные термины двоичного дерева </p> <p>Tip</p> <p>Обычно под \"высотой\" и \"глубиной\" понимают \"число пройденных ребер\", но в некоторых задачах или учебниках их могут определять как \"число пройденных узлов\". В таком случае и высоту, и глубину нужно увеличить на 1 .</p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   Базовые операции двоичного дерева","text":"","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   Инициализация двоичного дерева","text":"<p>Как и в связном списке, сначала инициализируются узлы, а затем между ними строятся ссылки (указатели).</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Инициализация двоичного дерева\n# Инициализация узлов\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// Инициализация узлов\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// Построение ссылок (указателей) между узлами\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// Инициализация узлов\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// Инициализация узлов\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// Построение ссылок (указателей) между узлами\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* Инициализация двоичного дерева */\n// Инициализация узлов\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// Построение ссылок (указателей) между узлами\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// Инициализация узлов\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># Инициализация двоичного дерева\n# Инициализация узлов\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# Построение ссылок (указателей) между узлами\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%D0%9A%D0%BB%D0%B0%D1%81%D1%81%20%D1%83%D0%B7%D0%BB%D0%B0%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BB%D0%B5%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%20%28%D1%83%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8%29%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&amp;cumulative=false&amp;curInstr=3&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   Вставка и удаление узлов","text":"<p>Как и в связном списке, вставка и удаление узлов в двоичном дереве могут выполняться через изменение указателей. На рисунке 7-3 приведен пример.</p> <p></p> <p> Рисунок 7-3   Вставка и удаление узлов в двоичном дереве </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># Вставка и удаление узлов\np = TreeNode(0)\n# Вставить узел P между n1 -&gt; n2\nn1.left = p\np.left = n2\n# Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* Вставка и удаление узлов */\nTreeNode* P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Удалить узел P\nn1-&gt;left = n2;\n// Освободить память\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* Вставка и удаление узлов */\nTreeNode P = new(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* Вставка и удаление узлов */\n// Вставить узел P между n1 -&gt; n2\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// Удалить узел P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// Вставить узел P между n1 -&gt; n2\nn1.left = P\nP.left = n2\n// Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* Вставка и удаление узлов */\nlet P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* Вставка и удаление узлов */\nconst P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* Вставка и удаление узлов */\nTreeNode P = new TreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1.left = P;\nP.left = n2;\n// Удалить узел P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// Вставить узел P между n1 -&gt; n2\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// Удалить узел p\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* Вставка и удаление узлов */\nTreeNode *P = newTreeNode(0);\n// Вставить узел P между n1 -&gt; n2\nn1-&gt;left = P;\nP-&gt;left = n2;\n// Удалить узел P\nn1-&gt;left = n2;\n// Освободить память\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// Вставить узел P между n1 -&gt; n2\nn1.left = P\nP.left = n2\n// Удалить узел P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># Вставка и удаление узлов\n_p = TreeNode.new(0)\n# Вставить узел _p между n1 -&gt; n2\nn1.left = _p\n_p.left = n2\n# Удалить узел\nn1.left = n2\n</code></pre> Визуализация выполнения <p>https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%D0%9A%D0%BB%D0%B0%D1%81%D1%81%20%D1%83%D0%B7%D0%BB%D0%B0%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0%22%22%22%0A%20%20%20%20def%20__init__%28self%2C%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%B0%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BB%D0%B5%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%B4%D0%BE%D1%87%D0%B5%D1%80%D0%BD%D0%B8%D0%B9%20%D1%83%D0%B7%D0%B5%D0%BB%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5%20%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B8%D1%82%D1%8C%20%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D1%83%D0%B7%D0%BB%D0%B0%D0%BC%D0%B8%20%28%D1%83%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D0%B8%29%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%20%D0%B8%20%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%83%D0%B7%D0%BB%D0%BE%D0%B2%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%D0%92%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%20P%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20n1%20-%3E%20n2%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%D0%A3%D0%B4%D0%B0%D0%BB%D0%B8%D1%82%D1%8C%20%D1%83%D0%B7%D0%B5%D0%BB%20P%0A%20%20%20%20n1.left%20%3D%20n2&amp;cumulative=false&amp;curInstr=37&amp;heapPrimitives=nevernest&amp;mode=display&amp;origin=opt-frontend.js&amp;py=311&amp;rawInputLstJSON=%5B%5D&amp;textReferences=false</p> <p>Tip</p> <p>Стоит помнить, что вставка узла может изменить исходную логическую структуру двоичного дерева, а удаление узла обычно означает удаление этого узла вместе со всеми его поддеревьями. Поэтому в двоичном дереве операции вставки и удаления обычно являются частью более крупного набора операций, который и реализует осмысленное действие.</p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   Распространенные типы двоичных деревьев","text":"","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   Идеальное двоичное дерево","text":"<p>Как показано на рисунке 7-4, идеальное двоичное дерево (perfect binary tree) полностью заполнено на всех уровнях. В идеальном двоичном дереве степень листовых узлов равна \\(0\\) , а у всех остальных узлов степень равна \\(2\\) ; если высота дерева равна \\(h\\) , то общее число узлов равно \\(2^{h+1} - 1\\) , что образует стандартную экспоненциальную зависимость и отражает часто встречающееся в природе явление клеточного деления.</p> <p>Tip</p> <p>В китайскоязычном сообществе идеальное двоичное дерево часто называют полностью заполненным двоичным деревом.</p> <p></p> <p> Рисунок 7-4   Идеальное двоичное дерево </p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   Полное двоичное дерево","text":"<p>Как показано на рисунке 7-5, полное двоичное дерево (complete binary tree) допускает неполное заполнение только на самом нижнем уровне, причем узлы этого уровня должны непрерывно заполняться слева направо. Стоит отметить, что идеальное двоичное дерево тоже является полным двоичным деревом.</p> <p></p> <p> Рисунок 7-5   Полное двоичное дерево </p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   Строгое двоичное дерево","text":"<p>Как показано на рисунке 7-6, строгое двоичное дерево (full binary tree) имеет у всех нелистовых узлов ровно двух дочерних узлов.</p> <p></p> <p> Рисунок 7-6   Строгое двоичное дерево </p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   Сбалансированное двоичное дерево","text":"<p>Как показано на рисунке 7-7, в сбалансированном двоичном дереве (balanced binary tree) для любого узла абсолютное значение разности высот левого и правого поддеревьев не превышает 1 .</p> <p></p> <p> Рисунок 7-7   Сбалансированное двоичное дерево </p>","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   Вырождение двоичного дерева","text":"<p>На рисунке 7-8 показаны идеальная структура двоичного дерева и вырожденная структура. Когда каждый уровень двоичного дерева полностью заполнен узлами, мы получаем \"идеальное двоичное дерево\"; когда же все узлы смещаются к одной стороне, двоичное дерево вырождается в \"связный список\".</p> <ul> <li>Идеальное двоичное дерево соответствует лучшему случаю и позволяет в полной мере раскрыть преимущества подхода \"разделяй и властвуй\".</li> <li>Связный список представляет противоположную крайность: все операции становятся линейными, а временная сложность деградирует до \\(O(n)\\) .</li> </ul> <p></p> <p> Рисунок 7-8   Лучший и худший случаи структуры двоичного дерева </p> <p>Как показано в таблице 7-1, в лучшем и худшем случаях число листовых узлов, общее число узлов, высота и другие характеристики двоичного дерева достигают максимума или минимума.</p> <p> Таблица 7-1   Лучший и худший случаи структуры двоичного дерева </p> Идеальное двоичное дерево Связный список Число узлов на уровне \\(i\\) \\(2^{i-1}\\) \\(1\\) Число листьев у дерева высоты \\(h\\) \\(2^h\\) \\(1\\) Общее число узлов у дерева высоты \\(h\\) \\(2^{h+1} - 1\\) \\(h + 1\\) Высота дерева с \\(n\\) узлами \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["Глава 7. Деревья","7.1 &nbsp; Двоичное дерево"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   Обход двоичного дерева","text":"<p>С точки зрения физической структуры дерево представляет собой разновидность структуры данных на основе связей, поэтому его обход выполняется через последовательный доступ к узлам по указателям. Однако дерево является нелинейной структурой данных, а значит, его обход сложнее, чем обход связного списка, и для него требуется использовать поисковые алгоритмы.</p> <p>К распространенным способам обхода двоичного дерева относятся обход по уровням, прямой обход, симметричный обход и обратный обход.</p>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   Обход по уровням","text":"<p>Как показано на рисунке 7-9, обход по уровням (level-order traversal) проходит двоичное дерево сверху вниз по уровням и на каждом уровне посещает узлы слева направо.</p> <p>По своей сути обход по уровням относится к обходу в ширину (breadth-first traversal), также называемому поиском в ширину (breadth-first search, BFS); он отражает идею \"расширяться от центра к периферии слой за слоем\".</p> <p></p> <p> Рисунок 7-9   Обход двоичного дерева по уровням </p>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   Код реализации","text":"<p>Обход в ширину обычно реализуется с помощью \"очереди\". Очередь подчиняется правилу \"первым пришел - первым вышел\", а обход в ширину подчиняется правилу \"продвигаться по уровням\", поэтому стоящая за ними идея согласована. Код реализации приведен ниже:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"Обход в ширину\"\"\"\n    # Инициализировать очередь и добавить корневой узел\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # Инициализировать список для хранения последовательности обхода\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # Извлечение из очереди\n        res.append(node.val)  # Сохранить значение узла\n        if node.left is not None:\n            queue.append(node.left)  # Поместить левый дочерний узел в очередь\n        if node.right is not None:\n            queue.append(node.right)  # Поместить правый дочерний узел в очередь\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* Обход в ширину */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // Инициализировать очередь и добавить корневой узел\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // Инициализировать список для хранения последовательности обхода\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // Извлечение из очереди\n        vec.push_back(node-&gt;val); // Сохранить значение узла\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // Поместить левый дочерний узел в очередь\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // Поместить правый дочерний узел в очередь\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* Обход в ширину */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // Инициализировать очередь и добавить корневой узел\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // Инициализировать список для хранения последовательности обхода\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // Извлечение из очереди\n        list.add(node.val);           // Сохранить значение узла\n        if (node.left != null)\n            queue.offer(node.left);   // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.offer(node.right);  // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* Обход в ширину */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // Инициализировать очередь и добавить корневой узел\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // Инициализировать список для хранения последовательности обхода\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // Извлечение из очереди\n        list.Add(node.val!.Value);       // Сохранить значение узла\n        if (node.left != null)\n            queue.Enqueue(node.left);    // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.Enqueue(node.right);   // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* Обход в ширину */\nfunc levelOrder(root *TreeNode) []any {\n    // Инициализировать очередь и добавить корневой узел\n    queue := list.New()\n    queue.PushBack(root)\n    // Инициализировать срез для хранения последовательности обхода\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // Извлечение из очереди\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // Сохранить значение узла\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // Поместить левый дочерний узел в очередь\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // Поместить правый дочерний узел в очередь\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* Обход в ширину */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // Инициализировать очередь и добавить корневой узел\n    var queue: [TreeNode] = [root]\n    // Инициализировать список для хранения последовательности обхода\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // Извлечение из очереди\n        list.append(node.val) // Сохранить значение узла\n        if let left = node.left {\n            queue.append(left) // Поместить левый дочерний узел в очередь\n        }\n        if let right = node.right {\n            queue.append(right) // Поместить правый дочерний узел в очередь\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* Обход в ширину */\nfunction levelOrder(root) {\n    // Инициализировать очередь и добавить корневой узел\n    const queue = [root];\n    // Инициализировать список для хранения последовательности обхода\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // Извлечение из очереди\n        list.push(node.val); // Сохранить значение узла\n        if (node.left) queue.push(node.left); // Поместить левый дочерний узел в очередь\n        if (node.right) queue.push(node.right); // Поместить правый дочерний узел в очередь\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* Обход в ширину */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // Инициализировать очередь и добавить корневой узел\n    const queue = [root];\n    // Инициализировать список для хранения последовательности обхода\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // Извлечение из очереди\n        list.push(node.val); // Сохранить значение узла\n        if (node.left) {\n            queue.push(node.left); // Поместить левый дочерний узел в очередь\n        }\n        if (node.right) {\n            queue.push(node.right); // Поместить правый дочерний узел в очередь\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* Обход в ширину */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // Инициализировать очередь и добавить корневой узел\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // Инициализировать список для хранения последовательности обхода\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // Извлечение из очереди\n    res.add(node!.val); // Сохранить значение узла\n    if (node.left != null) queue.add(node.left); // Поместить левый дочерний узел в очередь\n    if (node.right != null) queue.add(node.right); // Поместить правый дочерний узел в очередь\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* Обход в ширину */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // Инициализировать очередь и добавить корневой узел\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // Инициализировать список для хранения последовательности обхода\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // Извлечение из очереди\n        vec.push(node.borrow().val); // Сохранить значение узла\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // Поместить левый дочерний узел в очередь\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // Поместить правый дочерний узел в очередь\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* Обход в ширину */\nint *levelOrder(TreeNode *root, int *size) {\n    /* Вспомогательная очередь */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* Вспомогательная очередь */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // Указатель очереди\n    front = 0, rear = 0;\n    // Добавить корневой узел\n    queue[rear++] = root;\n    // Инициализировать список для хранения последовательности обхода\n    /* Вспомогательный массив */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // Указатель на массив\n    index = 0;\n    while (front &lt; rear) {\n        // Извлечение из очереди\n        node = queue[front++];\n        // Сохранить значение узла\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // Поместить левый дочерний узел в очередь\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // Поместить правый дочерний узел в очередь\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // Обновить значение длины массива\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // Освободить память вспомогательного массива\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* Обход в ширину */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // Инициализировать очередь и добавить корневой узел\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // Инициализировать список для хранения последовательности обхода\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // Извлечение из очереди\n        list.add(node?._val!!)       // Сохранить значение узла\n        if (node.left != null)\n            queue.offer(node.left)   // Поместить левый дочерний узел в очередь\n        if (node.right != null)\n            queue.offer(node.right)  // Поместить правый дочерний узел в очередь\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### Обход в ширину ###\ndef level_order(root)\n  # Инициализировать очередь и добавить корневой узел\n  queue = [root]\n  # Инициализировать список для хранения последовательности обхода\n  res = []\n  while !queue.empty?\n    node = queue.shift # Извлечение из очереди\n    res &lt;&lt; node.val # Сохранить значение узла\n    queue &lt;&lt; node.left unless node.left.nil? # Поместить левый дочерний узел в очередь\n    queue &lt;&lt; node.right unless node.right.nil? # Поместить правый дочерний узел в очередь\n  end\n  res\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   Анализ сложности","text":"<ul> <li>Временная сложность равна \\(O(n)\\) : все узлы посещаются по одному разу, поэтому требуется \\(O(n)\\) времени, где \\(n\\) - число узлов.</li> <li>Пространственная сложность равна \\(O(n)\\) : в худшем случае, то есть для полной двоичной деревообразной структуры, до достижения самого нижнего уровня в очереди одновременно может находиться до \\((n + 1) / 2\\) узлов, что требует \\(O(n)\\) памяти.</li> </ul>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   Прямой, симметричный и обратный обходы","text":"<p>Соответственно, прямой, симметричный и обратный обходы относятся к обходу в глубину (depth-first traversal), также называемому поиском в глубину (depth-first search, DFS); он отражает идею \"сначала идти до конца, затем возвращаться и продолжать\".</p> <p>На рисунке 7-10 показан принцип работы обхода двоичного дерева в глубину. Обход в глубину можно представить как обход всей двоичной структуры по внешнему контуру , и у каждого узла встречаются три позиции, соответствующие прямому, симметричному и обратному обходам.</p> <p></p> <p> Рисунок 7-10   Прямой, симметричный и обратный обходы двоичного дерева поиска </p>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   Код реализации","text":"<p>Поиск в глубину обычно реализуется через рекурсию:</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"Предварительный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"Симметричный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"Обратный обход\"\"\"\n    if root is None:\n        return\n    # Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* Предварительный обход */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* Симметричный обход */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* Обратный обход */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* Предварительный обход */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* Симметричный обход */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* Обратный обход */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* Предварительный обход */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* Симметричный обход */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* Обратный обход */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* Предварительный обход */\nfunction preOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nfunction inOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nfunction postOrder(root) {\n    if (root === null) return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* Предварительный обход */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* Симметричный обход */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* Обратный обход */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* Предварительный обход */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Симметричный обход */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* Обратный обход */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* Предварительный обход */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* Симметричный обход */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* Обратный обход */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* Предварительный обход */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* Симметричный обход */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* Обратный обход */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### Предварительный обход ###\ndef pre_order(root)\n  return if root.nil?\n\n  # Порядок обхода: корень -&gt; левое поддерево -&gt; правое поддерево\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### Симметричный обход ###\ndef in_order(root)\n  return if root.nil?\n\n  # Порядок обхода: левое поддерево -&gt; корень -&gt; правое поддерево\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### Обратный обход ###\ndef post_order(root)\n  return if root.nil?\n\n  # Порядок обхода: левое поддерево -&gt; правое поддерево -&gt; корень\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> Визуализация кода <p> Во весь экран &gt;</p> <p>Tip</p> <p>Поиск в глубину можно реализовать и итеративно; заинтересованные читатели могут изучить это самостоятельно.</p> <p>На рисунках ниже показан рекурсивный процесс прямого обхода двоичного дерева. Его можно разделить на две противоположные части: \"вход в рекурсию\" и \"возврат\".</p> <ol> <li>\"Вход в рекурсию\" означает запуск нового вызова функции; в этом процессе программа переходит к следующему узлу.</li> <li>\"Возврат\" означает завершение вызова функции и возврат назад, то есть текущий узел уже полностью обработан.</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> Рисунок 7-11   Рекурсивный процесс прямого обхода </p>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   Анализ сложности","text":"<ul> <li>Временная сложность равна \\(O(n)\\) : все узлы посещаются по одному разу, поэтому требуется \\(O(n)\\) времени.</li> <li>Пространственная сложность равна \\(O(n)\\) : в худшем случае, когда дерево вырождается в связный список, глубина рекурсии достигает \\(n\\) , и система тратит \\(O(n)\\) памяти на стек вызовов.</li> </ul>","path":["Глава 7. Деревья","7.2 &nbsp; Обход двоичного дерева"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   Краткие итоги","text":"","path":["Глава 7. Деревья","7.6 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   Основные моменты","text":"<ul> <li>Двоичное дерево - это нелинейная структура данных, отражающая логику \"разделяй и властвуй\". Каждый узел двоичного дерева содержит значение и два указателя, которые соответственно ведут к левому и правому дочерним узлам.</li> <li>Для любого узла двоичного дерева дерево, образованное его левым (правым) дочерним узлом и всеми нижележащими узлами, называется левым (правым) поддеревом этого узла.</li> <li>К связанным с двоичным деревом терминам относятся корневой узел, листовой узел, уровень, степень, ребро, высота, глубина и так далее.</li> <li>Инициализация двоичного дерева, вставка узлов и удаление узлов аналогичны операциям со связным списком.</li> <li>К распространенным видам двоичного дерева относятся идеальное двоичное дерево, полное двоичное дерево, строгое двоичное дерево и сбалансированное двоичное дерево. Идеальное двоичное дерево - наиболее желательное состояние, а связный список - худший случай после вырождения.</li> <li>Двоичное дерево можно представить массивом: значения узлов и пустые позиции располагаются в порядке обхода по уровням, а связи между родителем и детьми реализуются через индексацию.</li> <li>Обход двоичного дерева по уровням является методом поиска в ширину; он отражает идею \"расширяться от центра к периферии слой за слоем\" и обычно реализуется через очередь.</li> <li>Прямой, симметричный и обратный обходы относятся к поиску в глубину; они отражают идею \"сначала дойти до конца, затем вернуться и продолжить\" и обычно реализуются рекурсивно.</li> <li>Двоичное дерево поиска - это эффективная структура данных для поиска элементов; его поиск, вставка и удаление имеют временную сложность \\(O(\\log n)\\) . Когда двоичное дерево поиска вырождается в связный список, все эти сложности деградируют до \\(O(n)\\) .</li> <li>AVL-дерево, также называемое сбалансированным двоичным деревом поиска, с помощью вращений гарантирует, что после постоянных вставок и удалений узлов дерево остается сбалансированным.</li> <li>Вращения AVL-дерева включают правое вращение, левое вращение, сначала правое затем левое и сначала левое затем правое. После вставки или удаления узла AVL-дерево выполняет вращения снизу вверх, чтобы снова восстановить баланс.</li> </ul>","path":["Глава 7. Деревья","7.6 &nbsp; Краткие итоги"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q: Для двоичного дерева, состоящего из одного узла, высота дерева и глубина корня обе равны \\(0\\) ?</p> <p>Да, потому что высота и глубина обычно определяются как \"число пройденных ребер\".</p> <p>Q: Вставка и удаление в двоичном дереве обычно выполняются в составе набора операций. Что именно означает этот \"набор операций\"? Можно ли понимать это как освобождение ресурсов у дочерних узлов ресурса?</p> <p>Возьмем в качестве примера двоичное дерево поиска: операция удаления узла делится на три случая, и каждый из этих случаев требует нескольких последовательных шагов работы с узлами.</p> <p>Q: Почему у DFS для двоичного дерева есть три порядка: прямой, симметричный и обратный? Для чего они нужны?</p> <p>Подобно прямому и обратному обходу массива, прямой, симметричный и обратный обходы - это три способа обхода двоичного дерева, с помощью которых можно получить результаты в определенном порядке. Например, в двоичном дереве поиска, где соблюдается отношение <code>значение левого дочернего узла &lt; значение корня &lt; значение правого дочернего узла</code> , если обходить дерево с приоритетом \"лево \\(\\rightarrow\\) корень \\(\\rightarrow\\) право\", то получится упорядоченная последовательность узлов.</p> <p>Q: Правое вращение работает с отношениями между <code>node</code> , <code>child</code> и <code>grand_child</code> . А связь между <code>node</code> и его исходным родителем разве не нужно поддерживать? После правого вращения она ведь не оборвется?</p> <p>На это нужно смотреть с точки зрения рекурсии. В правое вращение <code>right_rotate(root)</code> передается корень поддерева, а затем через <code>return child</code> возвращается корень этого поддерева уже после вращения. Соединение между новым корнем поддерева и его родителем восстанавливается после возврата функции и не входит в обязанности самой операции правого вращения.</p> <p>Q: В C++ функции делятся на <code>private</code> и <code>public</code> . Какая логика стоит за этим? Почему <code>height()</code> и <code>updateHeight()</code> помещают в разные области видимости?</p> <p>Главный критерий - область использования метода. Если метод нужен только внутри класса, его следует проектировать как <code>private</code> . Например, самостоятельный вызов <code>updateHeight()</code> пользователем не имеет смысла: это лишь один из шагов внутри вставки или удаления. А <code>height()</code> используется для чтения высоты узла, подобно <code>vector.size()</code> , поэтому его разумно делать <code>public</code> .</p> <p>Q: Как построить двоичное дерево поиска из набора входных данных? Важен ли выбор корневого узла?</p> <p>Да, важен. Способ построения дерева уже показан в методе <code>build_tree()</code> в коде двоичного дерева поиска. Что касается выбора корня, обычно входные данные сортируют, берут средний элемент как корень, а затем рекурсивно строят левое и правое поддеревья. Это позволяет в наибольшей степени сохранить баланс дерева.</p> <p>Q: Нужно ли в Java всегда использовать <code>equals()</code> для сравнения строк?</p> <p>В Java для базовых типов <code>==</code> используется, чтобы сравнивать, равны ли значения двух переменных. Для ссылочных типов логика у этих двух способов уже разная.</p> <ul> <li><code>==</code> : сравнивает, ссылаются ли две переменные на один и тот же объект, то есть совпадает ли их адрес в памяти.</li> <li><code>equals()</code>: сравнивает, равны ли значения двух объектов.</li> </ul> <p>Поэтому если нужно сравнить значения, то следует использовать <code>equals()</code> . Но строки, инициализированные как <code>String a = \"hi\"; String b = \"hi\";</code> , хранятся в строковом пуле констант и указывают на один и тот же объект, поэтому в таком случае <code>a == b</code> тоже может дать истинный результат при сравнении содержимого.</p> <p>Q: До достижения самого нижнего уровня при обходе в ширину число узлов в очереди равно \\(2^h\\) ?</p> <p>Да. Например, для полного двоичного дерева высоты \\(h = 2\\) общее число узлов равно \\(n = 7\\) , а число узлов на нижнем уровне равно \\(4 = 2^h = (n + 1) / 2\\) .</p>","path":["Глава 7. Деревья","7.6 &nbsp; Краткие итоги"],"tags":[]}]}
\ No newline at end of file
diff --git a/ru/stylesheets/extra.css b/ru/stylesheets/extra.css
index 711698907..47b0b941e 100644
--- a/ru/stylesheets/extra.css
+++ b/ru/stylesheets/extra.css
@@ -1,4 +1,4 @@
-/* Color Settings */
+/* Theme tokens */
 /* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
 /* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
 :root>* {
@@ -14,21 +14,23 @@
   --md-code-fg-color: #1d1d20;
   --md-code-bg-color: #f5f5f5;
 
-  --md-accent-fg-color: #999;
-
   --md-typeset-color: #1d1d20;
   --md-typeset-a-color: #349890;
 
+  --md-accent-fg-color: var(--md-typeset-a-color);
+
   --md-typeset-btn-color: #55aea6;
   --md-typeset-btn-hover-color: #52bbb1;
 
   --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
-  --md-admonition-pythontutor-color: #eee;
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+
+  --hello-algo-sidebar-width: 13rem;
 }
 
 [data-md-color-scheme="slate"] {
-  --theme-dark-base: #1E1E1E;
-  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-base: #1e1e1e;
+  --theme-dark-mantle: #1a1a1a;
   --theme-dark-crust: #171717;
   --hero-starfield-bg-color: var(--theme-dark-base);
 
@@ -37,25 +39,25 @@
 
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: var(--theme-dark-base);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
 
-  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-body-bg-color: var(--md-default-bg-color);
   --md-header-bg-color: rgba(26, 26, 26, 0.8);
 
   --md-code-fg-color: #adbac7;
   --md-code-bg-color: var(--theme-dark-crust);
 
-  --md-accent-fg-color: #aaa;
-
-  --md-footer-fg-color: #adbac7;
-  --md-footer-bg-color: var(--theme-dark-mantle);
-
   --md-typeset-color: #adbac7;
   --md-typeset-a-color: #52bbb1;
+  --md-accent-fg-color: var(--md-typeset-a-color);
 
   --md-typeset-btn-color: #52bbb1;
   --md-typeset-btn-hover-color: #55aea6;
 
-  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
 }
 
 [data-md-color-scheme="slate"][data-md-color-primary="black"],
@@ -63,24 +65,82 @@
   --md-typeset-a-color: #52bbb1;
 }
 
+/* Base layout */
+body {
+  background-color: var(--md-default-bg-color);
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Banner and footer */
+.md-banner {
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
 [data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner {
-  background-color: var(--theme-dark-mantle);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer-meta {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer__link {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
 [data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--theme-dark-base);
+  color: var(--md-footer-fg-color);
 }
 
 [data-md-color-scheme="slate"] .md-footer__title,
@@ -93,40 +153,31 @@
   color: var(--md-footer-fg-color);
 }
 
-/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
-.md-nav__link[for] {
-  color: var(--md-default-fg-color) !important;
-}
-
-/* Figure class */
+/* Shared content elements */
 .animation-figure {
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Cover image class */
 .cover-image {
   width: 28rem;
   height: auto;
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Center Markdown Tables (requires md_in_html extension) */
 .center-table {
   text-align: center;
 }
 
-/* Reset alignment for table cells */
 .md-typeset .center-table :is(td, th):not([align]) {
   text-align: initial;
 }
 
-/* Font size */
 .md-typeset {
   font-size: 0.75rem;
   line-height: 1.5;
@@ -136,7 +187,6 @@
   font-size: 0.95em;
 }
 
-/* Markdown Header */
 /* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
 .md-typeset h1 {
   font-weight: 400;
@@ -155,11 +205,6 @@
   text-transform: none;
 }
 
-.md-typeset a:hover {
-  color: var(--md-typeset-a-color);
-  text-decoration: underline;
-}
-
 .md-typeset code {
   border-radius: 0.2rem;
 }
@@ -168,21 +213,11 @@
   font-weight: normal;
 }
 
-/* font-family setting for Win10 */
-body {
-  --md-text-font-family: -apple-system, BlinkMacSystemFont,
-    var(--md-text-font, _), Helvetica, Arial, sans-serif;
-  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
-    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
-}
-
-/* max height of code block */
 /* https://github.com/squidfunk/mkdocs-material/issues/3444 */
 .md-typeset pre>code {
   max-height: 25rem;
 }
 
-/* Keep code block scrollbar hover neutral instead of accent-colored */
 .md-typeset pre>code:hover {
   scrollbar-color: var(--md-default-fg-color--lighter) transparent;
 }
@@ -191,29 +226,48 @@ body {
   background-color: var(--md-default-fg-color--lighter);
 }
 
-/* Make the picture not glare in dark theme */
 [data-md-color-scheme="slate"] .md-typeset img,
 [data-md-color-scheme="slate"] .md-typeset svg,
 [data-md-color-scheme="slate"] .md-typeset video {
   filter: brightness(0.85) invert(0.05);
 }
 
-/* landing page */
-.header-img-div {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0 auto;
-  width: 100%;
-  /* Default to full width */
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+/* Admonitions and tabs */
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
 }
 
-/* Admonition for python tutor */
 .md-typeset .admonition.pythontutor,
 .md-typeset details.pythontutor {
   border-color: var(--md-default-fg-color--lightest);
   margin-top: 0;
   margin-bottom: 1.5625em;
+  background-color: var(--md-code-bg-color);
 }
 
 .md-typeset .pythontutor>.admonition-title,
@@ -228,26 +282,18 @@ body {
   mask-image: var(--md-admonition-icon--pythontutor);
 }
 
-/* code block tabs */
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
 .md-typeset .tabbed-labels>label {
   font-size: 0.61rem;
 }
 
 .md-typeset .tabbed-labels--linked>label>a {
-  padding: .78125em 1.0em .625em;
-}
-
-/* header banner */
-.md-banner {
-  background-color: var(--md-code-bg-color);
-  color: var(--md-default-fg-color);
-  font-size: 0.75rem;
-}
-
-.md-banner .banner-svg svg {
-  margin-right: 0.3rem;
-  height: 0.63rem;
-  fill: var(--md-default-fg-color);
+  padding: 0.78125em 1em 0.625em;
 }
 
 .pythontutor-iframe {
@@ -260,115 +306,55 @@ body {
   border: none;
 }
 
-/* landing page container */
+/* Landing page layout */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+}
+
 .home-div {
   width: 100%;
   height: auto;
   display: flex;
   justify-content: center;
   align-items: center;
+  padding: 3em 2em;
   background-color: var(--md-default-bg-color);
   color: var(--md-default-fg-color);
   font-size: 0.9rem;
-  padding: 3em 2em;
   text-align: center;
 }
 
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6,
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
 .section-content {
   width: 100%;
   height: auto;
   max-width: 70vw;
 }
 
-/* rounded button */
-.rounded-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 10em;
-  margin: 0 0.1em;
-  padding: 0.6em 1.3em;
-  border: none;
-  background-color: var(--md-typeset-btn-color);
-  color: var(--md-primary-fg-color) !important;
-  text-align: center;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.rounded-button:hover {
-  background-color: var(--md-typeset-btn-hover-color);
-}
-
-.rounded-button span {
-  margin: 0;
-  margin-bottom: 0.07em;
-  white-space: nowrap;
-}
-
-.rounded-button svg {
-  fill: var(--md-primary-fg-color);
-  width: auto;
-  height: 1.2em;
-  margin-right: 0.5em;
-}
-
-/* device image */
-.device-on-hover {
-  width: auto;
-  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
-}
-
-a:hover .device-on-hover {
-  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
-  transform: scale(1.01);
-}
-
-/* text button */
-.reading-media {
-  display: flex;
-  justify-content: center;
-  align-items: flex-end;
-  height: 32vw;
-}
-
-.media-block {
-  height: 100%;
-  margin: 0 0.2em;
-}
-
-.text-button {
-  width: auto;
-  color: var(--md-typeset-btn-color);
-  text-decoration: none;
-  text-align: center;
-  margin: 2.7em auto;
-}
-
-.text-button span {
-  white-space: nowrap;
-}
-
-.text-button svg {
-  display: inline-block;
-  fill: var(--md-typeset-btn-color);
-  width: auto;
-  height: 0.9em;
-  background-size: cover;
-  padding-top: 0.17em;
-  margin-left: 0.15em;
-}
-
-a:hover .text-button span {
-  text-decoration: underline;
-}
-
-/* hero image */
 .hero-div {
   height: min(84vh, 75vw);
   width: min(112vh, 100vw);
-  margin: 0 auto;
-  margin-top: -2.4rem;
+  margin: -2.4rem auto 0;
   padding: 0;
   position: relative;
   font-size: min(1.8vh, 2.5vw);
@@ -384,13 +370,12 @@ a:hover .text-button span {
 }
 
 .hero-bg {
-  height: 100%;
   width: 100%;
+  height: 100%;
   object-fit: cover;
   position: absolute;
 }
 
-/* hover on the planets */
 .hero-div>a>img {
   width: auto;
   position: absolute;
@@ -402,7 +387,6 @@ a:hover .text-button span {
   position: absolute;
   transform: translateX(-50%) translateY(-50%);
   white-space: nowrap;
-  /* prevent line breaks */
   color: white;
 }
 
@@ -412,21 +396,105 @@ a:hover .text-button span {
 }
 
 .hero-div>a:hover>span {
-  text-decoration: underline;
   color: var(--md-typeset-btn-color);
+  text-decoration: underline;
 }
 
 .heading-div {
   width: 100%;
   position: absolute;
-  transform: translateX(-50%);
   left: 50%;
   bottom: min(2vh, 3vw);
+  transform: translateX(-50%);
   pointer-events: none;
   color: #fff;
 }
 
-/* code badge */
+/* Landing page CTAs */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  border-radius: 10em;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0 0 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+  fill: var(--md-primary-fg-color);
+}
+
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  margin: 2.7em auto;
+  color: var(--md-typeset-btn-color);
+  text-align: center;
+  text-decoration: none;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  width: auto;
+  height: 0.9em;
+  margin-left: 0.15em;
+  padding-top: 0.17em;
+  fill: var(--md-typeset-btn-color);
+  background-size: cover;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* Landing page content blocks */
 .code-badge {
   width: 100%;
   height: auto;
@@ -434,11 +502,10 @@ a:hover .text-button span {
 }
 
 .code-badge img {
-  height: 1.07em;
   width: auto;
+  height: 1.07em;
 }
 
-/* brief intro */
 .intro-container {
   display: flex;
   align-items: center;
@@ -455,14 +522,13 @@ a:hover .text-button span {
 
 .intro-text {
   flex-grow: 1;
-  /* fill the space */
   display: flex;
   flex-direction: column;
   justify-content: center;
-  text-align: left;
   align-items: flex-start;
   width: fit-content;
   margin: 2em;
+  text-align: left;
 }
 
 .intro-text>div {
@@ -471,6 +537,10 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
+.intro-text svg path {
+  fill: #3b3b3b;
+}
+
 .endor-text {
   width: 50%;
 }
@@ -480,7 +550,10 @@ a:hover .text-button span {
   font-weight: bold;
 }
 
-/* contributors table */
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
 .profile-div {
   display: flex;
   flex-wrap: wrap;
@@ -495,6 +568,11 @@ a:hover .text-button span {
   text-align: center;
 }
 
+.profile-cell a:hover b,
+.profile-cell a:focus-visible b {
+  text-decoration: underline;
+}
+
 .profile-img {
   width: 5em;
   border-radius: 50%;
@@ -517,7 +595,37 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
-/* Hide navigation */
+/* Embedded media */
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Responsive adjustments */
 @media screen and (max-width: 76.25em) {
   .section-content {
     max-width: 95vw;
@@ -532,7 +640,6 @@ a:hover .text-button span {
   }
 }
 
-/* mobile devices */
 @media screen and (max-width: 60em) {
   .home-div {
     font-size: 0.75rem;
@@ -571,209 +678,4 @@ a:hover .text-button span {
     flex: 1 1 30%;
   }
 }
-
-.video-container {
-  position: relative;
-  padding-bottom: 56.25%;
-  /* 16:9 */
-  height: 0;
-}
-
-.video-container iframe {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-/* starfield */
-.starfield {
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  z-index: 0;
-  background-color: var(--hero-starfield-bg-color, transparent);
-}
-
-.starfield-origin {
-  position: absolute;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-}
-
-/* Zensical-specific adjustments merged into the main stylesheet. */
-:root>* {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --hello-algo-sidebar-width: 13rem;
-}
-
-[data-md-color-scheme="slate"] {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --md-body-bg-color: var(--md-default-bg-color);
-  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
-}
-
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
-  background-color: #f5f5f5;
-  color: #1d1d20;
-}
-
-body {
-  background-color: var(--md-default-bg-color);
-}
-
-html:has(body[data-md-color-scheme="slate"]) {
-  background-color: #1e1e1e;
-}
-
-html:has(body[data-md-color-scheme="default"]) {
-  background-color: #ffffff;
-}
-
-.home-div[data-md-color-scheme="default"],
-.home-div[data-md-color-scheme="default"] h1,
-.home-div[data-md-color-scheme="default"] h2,
-.home-div[data-md-color-scheme="default"] h3,
-.home-div[data-md-color-scheme="default"] h4,
-.home-div[data-md-color-scheme="default"] h5,
-.home-div[data-md-color-scheme="default"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div[data-md-color-scheme="slate"],
-.home-div[data-md-color-scheme="slate"] h1,
-.home-div[data-md-color-scheme="slate"] h2,
-.home-div[data-md-color-scheme="slate"] h3,
-.home-div[data-md-color-scheme="slate"] h4,
-.home-div[data-md-color-scheme="slate"] h5,
-.home-div[data-md-color-scheme="slate"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div .intro-quote {
-  color: var(--md-default-fg-color--light) !important;
-}
-
-.reading-media+p {
-  margin-top: 1em !important;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before,
-.md-typeset summary:after {
-  top: 50%;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before {
-  transform: translateY(-50%);
-}
-
-.md-typeset summary:after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open]>summary:after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-nav__link[for] {
-  color: inherit !important;
-}
-
-.md-nav__link[for].md-nav__link--active {
-  color: var(--md-accent-fg-color) !important;
-}
-
-@media screen and (min-width: 76.25em) {
-  .md-grid {
-    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
-  }
-
-  .md-sidebar--primary,
-  .md-sidebar--secondary {
-    width: var(--hello-algo-sidebar-width);
-  }
-
-  [dir="ltr"] .md-sidebar__inner {
-    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-
-  [dir="rtl"] .md-sidebar__inner {
-    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap {
-  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
-  background-color: var(--md-default-fg-color--lighter);
-}
-
-.md-footer,
-.md-footer__inner,
-.md-footer-meta,
-.md-footer__link,
-.md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-footer {
-  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
-}
-
-[data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner,
-[data-md-color-scheme="slate"] .md-footer-meta,
-[data-md-color-scheme="slate"] .md-footer__link,
-[data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-banner {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .admonition.pythontutor,
-.md-typeset details.pythontutor,
-.md-typeset .pythontutor>.admonition-title,
-.md-typeset .pythontutor>summary {
-  background-color: var(--md-code-bg-color);
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before,
-.md-typeset .pythontutor>summary::after {
-  top: 50%;
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before {
-  transform: translateY(-50%);
-}
-
-.md-typeset .pythontutor>summary::after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open].pythontutor>summary::after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-typeset a:not(.md-button) {
-  text-decoration: none;
-}
-
-.md-typeset a:not(.md-button):hover,
-.md-typeset a:not(.md-button):focus-visible {
-  text-decoration: underline;
-}
-/*! update cache: 20260331044536 */
+/*! update cache: 20260331053229 */
diff --git a/stylesheets/extra.css b/stylesheets/extra.css
index b5093f588..854da1257 100644
--- a/stylesheets/extra.css
+++ b/stylesheets/extra.css
@@ -1,4 +1,4 @@
-/* Color Settings */
+/* Theme tokens */
 /* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
 /* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
 :root>* {
@@ -14,21 +14,23 @@
   --md-code-fg-color: #1d1d20;
   --md-code-bg-color: #f5f5f5;
 
-  --md-accent-fg-color: #999;
-
   --md-typeset-color: #1d1d20;
   --md-typeset-a-color: #349890;
 
+  --md-accent-fg-color: var(--md-typeset-a-color);
+
   --md-typeset-btn-color: #55aea6;
   --md-typeset-btn-hover-color: #52bbb1;
 
   --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
-  --md-admonition-pythontutor-color: #eee;
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+
+  --hello-algo-sidebar-width: 13rem;
 }
 
 [data-md-color-scheme="slate"] {
-  --theme-dark-base: #1E1E1E;
-  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-base: #1e1e1e;
+  --theme-dark-mantle: #1a1a1a;
   --theme-dark-crust: #171717;
   --hero-starfield-bg-color: var(--theme-dark-base);
 
@@ -37,25 +39,25 @@
 
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: var(--theme-dark-base);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
 
-  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-body-bg-color: var(--md-default-bg-color);
   --md-header-bg-color: rgba(26, 26, 26, 0.8);
 
   --md-code-fg-color: #adbac7;
   --md-code-bg-color: var(--theme-dark-crust);
 
-  --md-accent-fg-color: #aaa;
-
-  --md-footer-fg-color: #adbac7;
-  --md-footer-bg-color: var(--theme-dark-mantle);
-
   --md-typeset-color: #adbac7;
   --md-typeset-a-color: #52bbb1;
+  --md-accent-fg-color: var(--md-typeset-a-color);
 
   --md-typeset-btn-color: #52bbb1;
   --md-typeset-btn-hover-color: #55aea6;
 
-  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
 }
 
 [data-md-color-scheme="slate"][data-md-color-primary="black"],
@@ -63,24 +65,82 @@
   --md-typeset-a-color: #52bbb1;
 }
 
+/* Base layout */
+body {
+  background-color: var(--md-default-bg-color);
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Banner and footer */
+.md-banner {
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
 [data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner {
-  background-color: var(--theme-dark-mantle);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer-meta {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer__link {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
 [data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--theme-dark-base);
+  color: var(--md-footer-fg-color);
 }
 
 [data-md-color-scheme="slate"] .md-footer__title,
@@ -93,40 +153,31 @@
   color: var(--md-footer-fg-color);
 }
 
-/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
-.md-nav__link[for] {
-  color: var(--md-default-fg-color) !important;
-}
-
-/* Figure class */
+/* Shared content elements */
 .animation-figure {
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Cover image class */
 .cover-image {
   width: 28rem;
   height: auto;
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Center Markdown Tables (requires md_in_html extension) */
 .center-table {
   text-align: center;
 }
 
-/* Reset alignment for table cells */
 .md-typeset .center-table :is(td, th):not([align]) {
   text-align: initial;
 }
 
-/* Font size */
 .md-typeset {
   font-size: 0.75rem;
   line-height: 1.5;
@@ -136,7 +187,6 @@
   font-size: 0.95em;
 }
 
-/* Markdown Header */
 /* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
 .md-typeset h1 {
   font-weight: 400;
@@ -155,11 +205,6 @@
   text-transform: none;
 }
 
-.md-typeset a:hover {
-  color: var(--md-typeset-a-color);
-  text-decoration: underline;
-}
-
 .md-typeset code {
   border-radius: 0.2rem;
 }
@@ -168,21 +213,11 @@
   font-weight: normal;
 }
 
-/* font-family setting for Win10 */
-body {
-  --md-text-font-family: -apple-system, BlinkMacSystemFont,
-    var(--md-text-font, _), Helvetica, Arial, sans-serif;
-  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
-    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
-}
-
-/* max height of code block */
 /* https://github.com/squidfunk/mkdocs-material/issues/3444 */
 .md-typeset pre>code {
   max-height: 25rem;
 }
 
-/* Keep code block scrollbar hover neutral instead of accent-colored */
 .md-typeset pre>code:hover {
   scrollbar-color: var(--md-default-fg-color--lighter) transparent;
 }
@@ -191,29 +226,48 @@ body {
   background-color: var(--md-default-fg-color--lighter);
 }
 
-/* Make the picture not glare in dark theme */
 [data-md-color-scheme="slate"] .md-typeset img,
 [data-md-color-scheme="slate"] .md-typeset svg,
 [data-md-color-scheme="slate"] .md-typeset video {
   filter: brightness(0.85) invert(0.05);
 }
 
-/* landing page */
-.header-img-div {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0 auto;
-  width: 100%;
-  /* Default to full width */
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+/* Admonitions and tabs */
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
 }
 
-/* Admonition for python tutor */
 .md-typeset .admonition.pythontutor,
 .md-typeset details.pythontutor {
   border-color: var(--md-default-fg-color--lightest);
   margin-top: 0;
   margin-bottom: 1.5625em;
+  background-color: var(--md-code-bg-color);
 }
 
 .md-typeset .pythontutor>.admonition-title,
@@ -228,26 +282,18 @@ body {
   mask-image: var(--md-admonition-icon--pythontutor);
 }
 
-/* code block tabs */
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
 .md-typeset .tabbed-labels>label {
   font-size: 0.61rem;
 }
 
 .md-typeset .tabbed-labels--linked>label>a {
-  padding: .78125em 1.0em .625em;
-}
-
-/* header banner */
-.md-banner {
-  background-color: var(--md-code-bg-color);
-  color: var(--md-default-fg-color);
-  font-size: 0.75rem;
-}
-
-.md-banner .banner-svg svg {
-  margin-right: 0.3rem;
-  height: 0.63rem;
-  fill: var(--md-default-fg-color);
+  padding: 0.78125em 1em 0.625em;
 }
 
 .pythontutor-iframe {
@@ -260,115 +306,55 @@ body {
   border: none;
 }
 
-/* landing page container */
+/* Landing page layout */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+}
+
 .home-div {
   width: 100%;
   height: auto;
   display: flex;
   justify-content: center;
   align-items: center;
+  padding: 3em 2em;
   background-color: var(--md-default-bg-color);
   color: var(--md-default-fg-color);
   font-size: 0.9rem;
-  padding: 3em 2em;
   text-align: center;
 }
 
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6,
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
 .section-content {
   width: 100%;
   height: auto;
   max-width: 70vw;
 }
 
-/* rounded button */
-.rounded-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 10em;
-  margin: 0 0.1em;
-  padding: 0.6em 1.3em;
-  border: none;
-  background-color: var(--md-typeset-btn-color);
-  color: var(--md-primary-fg-color) !important;
-  text-align: center;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.rounded-button:hover {
-  background-color: var(--md-typeset-btn-hover-color);
-}
-
-.rounded-button span {
-  margin: 0;
-  margin-bottom: 0.07em;
-  white-space: nowrap;
-}
-
-.rounded-button svg {
-  fill: var(--md-primary-fg-color);
-  width: auto;
-  height: 1.2em;
-  margin-right: 0.5em;
-}
-
-/* device image */
-.device-on-hover {
-  width: auto;
-  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
-}
-
-a:hover .device-on-hover {
-  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
-  transform: scale(1.01);
-}
-
-/* text button */
-.reading-media {
-  display: flex;
-  justify-content: center;
-  align-items: flex-end;
-  height: 32vw;
-}
-
-.media-block {
-  height: 100%;
-  margin: 0 0.2em;
-}
-
-.text-button {
-  width: auto;
-  color: var(--md-typeset-btn-color);
-  text-decoration: none;
-  text-align: center;
-  margin: 2.7em auto;
-}
-
-.text-button span {
-  white-space: nowrap;
-}
-
-.text-button svg {
-  display: inline-block;
-  fill: var(--md-typeset-btn-color);
-  width: auto;
-  height: 0.9em;
-  background-size: cover;
-  padding-top: 0.17em;
-  margin-left: 0.15em;
-}
-
-a:hover .text-button span {
-  text-decoration: underline;
-}
-
-/* hero image */
 .hero-div {
   height: min(84vh, 75vw);
   width: min(112vh, 100vw);
-  margin: 0 auto;
-  margin-top: -2.4rem;
+  margin: -2.4rem auto 0;
   padding: 0;
   position: relative;
   font-size: min(1.8vh, 2.5vw);
@@ -384,13 +370,12 @@ a:hover .text-button span {
 }
 
 .hero-bg {
-  height: 100%;
   width: 100%;
+  height: 100%;
   object-fit: cover;
   position: absolute;
 }
 
-/* hover on the planets */
 .hero-div>a>img {
   width: auto;
   position: absolute;
@@ -402,7 +387,6 @@ a:hover .text-button span {
   position: absolute;
   transform: translateX(-50%) translateY(-50%);
   white-space: nowrap;
-  /* prevent line breaks */
   color: white;
 }
 
@@ -412,21 +396,105 @@ a:hover .text-button span {
 }
 
 .hero-div>a:hover>span {
-  text-decoration: underline;
   color: var(--md-typeset-btn-color);
+  text-decoration: underline;
 }
 
 .heading-div {
   width: 100%;
   position: absolute;
-  transform: translateX(-50%);
   left: 50%;
   bottom: min(2vh, 3vw);
+  transform: translateX(-50%);
   pointer-events: none;
   color: #fff;
 }
 
-/* code badge */
+/* Landing page CTAs */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  border-radius: 10em;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0 0 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+  fill: var(--md-primary-fg-color);
+}
+
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  margin: 2.7em auto;
+  color: var(--md-typeset-btn-color);
+  text-align: center;
+  text-decoration: none;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  width: auto;
+  height: 0.9em;
+  margin-left: 0.15em;
+  padding-top: 0.17em;
+  fill: var(--md-typeset-btn-color);
+  background-size: cover;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* Landing page content blocks */
 .code-badge {
   width: 100%;
   height: auto;
@@ -434,11 +502,10 @@ a:hover .text-button span {
 }
 
 .code-badge img {
-  height: 1.07em;
   width: auto;
+  height: 1.07em;
 }
 
-/* brief intro */
 .intro-container {
   display: flex;
   align-items: center;
@@ -455,14 +522,13 @@ a:hover .text-button span {
 
 .intro-text {
   flex-grow: 1;
-  /* fill the space */
   display: flex;
   flex-direction: column;
   justify-content: center;
-  text-align: left;
   align-items: flex-start;
   width: fit-content;
   margin: 2em;
+  text-align: left;
 }
 
 .intro-text>div {
@@ -471,6 +537,10 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
+.intro-text svg path {
+  fill: #3b3b3b;
+}
+
 .endor-text {
   width: 50%;
 }
@@ -480,7 +550,10 @@ a:hover .text-button span {
   font-weight: bold;
 }
 
-/* contributors table */
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
 .profile-div {
   display: flex;
   flex-wrap: wrap;
@@ -495,6 +568,11 @@ a:hover .text-button span {
   text-align: center;
 }
 
+.profile-cell a:hover b,
+.profile-cell a:focus-visible b {
+  text-decoration: underline;
+}
+
 .profile-img {
   width: 5em;
   border-radius: 50%;
@@ -517,7 +595,37 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
-/* Hide navigation */
+/* Embedded media */
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Responsive adjustments */
 @media screen and (max-width: 76.25em) {
   .section-content {
     max-width: 95vw;
@@ -532,7 +640,6 @@ a:hover .text-button span {
   }
 }
 
-/* mobile devices */
 @media screen and (max-width: 60em) {
   .home-div {
     font-size: 0.75rem;
@@ -571,209 +678,4 @@ a:hover .text-button span {
     flex: 1 1 30%;
   }
 }
-
-.video-container {
-  position: relative;
-  padding-bottom: 56.25%;
-  /* 16:9 */
-  height: 0;
-}
-
-.video-container iframe {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-/* starfield */
-.starfield {
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  z-index: 0;
-  background-color: var(--hero-starfield-bg-color, transparent);
-}
-
-.starfield-origin {
-  position: absolute;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-}
-
-/* Zensical-specific adjustments merged into the main stylesheet. */
-:root>* {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --hello-algo-sidebar-width: 13rem;
-}
-
-[data-md-color-scheme="slate"] {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --md-body-bg-color: var(--md-default-bg-color);
-  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
-}
-
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
-  background-color: #f5f5f5;
-  color: #1d1d20;
-}
-
-body {
-  background-color: var(--md-default-bg-color);
-}
-
-html:has(body[data-md-color-scheme="slate"]) {
-  background-color: #1e1e1e;
-}
-
-html:has(body[data-md-color-scheme="default"]) {
-  background-color: #ffffff;
-}
-
-.home-div[data-md-color-scheme="default"],
-.home-div[data-md-color-scheme="default"] h1,
-.home-div[data-md-color-scheme="default"] h2,
-.home-div[data-md-color-scheme="default"] h3,
-.home-div[data-md-color-scheme="default"] h4,
-.home-div[data-md-color-scheme="default"] h5,
-.home-div[data-md-color-scheme="default"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div[data-md-color-scheme="slate"],
-.home-div[data-md-color-scheme="slate"] h1,
-.home-div[data-md-color-scheme="slate"] h2,
-.home-div[data-md-color-scheme="slate"] h3,
-.home-div[data-md-color-scheme="slate"] h4,
-.home-div[data-md-color-scheme="slate"] h5,
-.home-div[data-md-color-scheme="slate"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div .intro-quote {
-  color: var(--md-default-fg-color--light) !important;
-}
-
-.reading-media+p {
-  margin-top: 1em !important;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before,
-.md-typeset summary:after {
-  top: 50%;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before {
-  transform: translateY(-50%);
-}
-
-.md-typeset summary:after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open]>summary:after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-nav__link[for] {
-  color: inherit !important;
-}
-
-.md-nav__link[for].md-nav__link--active {
-  color: var(--md-accent-fg-color) !important;
-}
-
-@media screen and (min-width: 76.25em) {
-  .md-grid {
-    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
-  }
-
-  .md-sidebar--primary,
-  .md-sidebar--secondary {
-    width: var(--hello-algo-sidebar-width);
-  }
-
-  [dir="ltr"] .md-sidebar__inner {
-    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-
-  [dir="rtl"] .md-sidebar__inner {
-    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap {
-  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
-  background-color: var(--md-default-fg-color--lighter);
-}
-
-.md-footer,
-.md-footer__inner,
-.md-footer-meta,
-.md-footer__link,
-.md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-footer {
-  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
-}
-
-[data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner,
-[data-md-color-scheme="slate"] .md-footer-meta,
-[data-md-color-scheme="slate"] .md-footer__link,
-[data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-banner {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .admonition.pythontutor,
-.md-typeset details.pythontutor,
-.md-typeset .pythontutor>.admonition-title,
-.md-typeset .pythontutor>summary {
-  background-color: var(--md-code-bg-color);
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before,
-.md-typeset .pythontutor>summary::after {
-  top: 50%;
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before {
-  transform: translateY(-50%);
-}
-
-.md-typeset .pythontutor>summary::after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open].pythontutor>summary::after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-typeset a:not(.md-button) {
-  text-decoration: none;
-}
-
-.md-typeset a:not(.md-button):hover,
-.md-typeset a:not(.md-button):focus-visible {
-  text-decoration: underline;
-}
-/*! update cache: 20260331044451 */
+/*! update cache: 20260331053143 */
diff --git a/zh-hant/assets/javascripts/bundle.c2b142ea.min.js b/zh-hant/assets/javascripts/bundle.c2b142ea.min.js
index 75c694074..69e45286f 100644
--- a/zh-hant/assets/javascripts/bundle.c2b142ea.min.js
+++ b/zh-hant/assets/javascripts/bundle.c2b142ea.min.js
@@ -1,4 +1,4 @@
 "use strict";(()=>{var xc=Object.create;var kn=Object.defineProperty,wc=Object.defineProperties,Ec=Object.getOwnPropertyDescriptor,Tc=Object.getOwnPropertyDescriptors,Sc=Object.getOwnPropertyNames,Dr=Object.getOwnPropertySymbols,Oc=Object.getPrototypeOf,An=Object.prototype.hasOwnProperty,Fo=Object.prototype.propertyIsEnumerable;var jo=(e,t,r)=>t in e?kn(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,H=(e,t)=>{for(var r in t||(t={}))An.call(t,r)&&jo(e,r,t[r]);if(Dr)for(var r of Dr(t))Fo.call(t,r)&&jo(e,r,t[r]);return e},He=(e,t)=>wc(e,Tc(t));var gr=(e,t)=>{var r={};for(var n in e)An.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&Dr)for(var n of Dr(e))t.indexOf(n)<0&&Fo.call(e,n)&&(r[n]=e[n]);return r};var Cn=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var Lc=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Sc(t))!An.call(e,o)&&o!==r&&kn(e,o,{get:()=>t[o],enumerable:!(n=Ec(t,o))||n.enumerable});return e};var _r=(e,t,r)=>(r=e!=null?xc(Oc(e)):{},Lc(t||!e||!e.__esModule?kn(r,"default",{value:e,enumerable:!0}):r,e));var Uo=(e,t,r)=>new Promise((n,o)=>{var i=c=>{try{s(r.next(c))}catch(l){o(l)}},a=c=>{try{s(r.throw(c))}catch(l){o(l)}},s=c=>c.done?n(c.value):Promise.resolve(c.value).then(i,a);s((r=r.apply(e,t)).next())});var Do=Cn((Hn,No)=>{(function(e,t){typeof Hn=="object"&&typeof No!="undefined"?t():typeof define=="function"&&define.amd?define(t):t()})(Hn,(function(){"use strict";function e(r){var n=!0,o=!1,i=null,a={text:!0,search:!0,url:!0,tel:!0,email:!0,password:!0,number:!0,date:!0,month:!0,week:!0,time:!0,datetime:!0,"datetime-local":!0};function s(_){return!!(_&&_!==document&&_.nodeName!=="HTML"&&_.nodeName!=="BODY"&&"classList"in _&&"contains"in _.classList)}function c(_){var de=_.type,be=_.tagName;return!!(be==="INPUT"&&a[de]&&!_.readOnly||be==="TEXTAREA"&&!_.readOnly||_.isContentEditable)}function l(_){_.classList.contains("focus-visible")||(_.classList.add("focus-visible"),_.setAttribute("data-focus-visible-added",""))}function u(_){_.hasAttribute("data-focus-visible-added")&&(_.classList.remove("focus-visible"),_.removeAttribute("data-focus-visible-added"))}function p(_){_.metaKey||_.altKey||_.ctrlKey||(s(r.activeElement)&&l(r.activeElement),n=!0)}function d(_){n=!1}function m(_){s(_.target)&&(n||c(_.target))&&l(_.target)}function h(_){s(_.target)&&(_.target.classList.contains("focus-visible")||_.target.hasAttribute("data-focus-visible-added"))&&(o=!0,window.clearTimeout(i),i=window.setTimeout(function(){o=!1},100),u(_.target))}function v(_){document.visibilityState==="hidden"&&(o&&(n=!0),x())}function x(){document.addEventListener("mousemove",E),document.addEventListener("mousedown",E),document.addEventListener("mouseup",E),document.addEventListener("pointermove",E),document.addEventListener("pointerdown",E),document.addEventListener("pointerup",E),document.addEventListener("touchmove",E),document.addEventListener("touchstart",E),document.addEventListener("touchend",E)}function w(){document.removeEventListener("mousemove",E),document.removeEventListener("mousedown",E),document.removeEventListener("mouseup",E),document.removeEventListener("pointermove",E),document.removeEventListener("pointerdown",E),document.removeEventListener("pointerup",E),document.removeEventListener("touchmove",E),document.removeEventListener("touchstart",E),document.removeEventListener("touchend",E)}function E(_){_.target.nodeName&&_.target.nodeName.toLowerCase()==="html"||(n=!1,w())}document.addEventListener("keydown",p,!0),document.addEventListener("mousedown",d,!0),document.addEventListener("pointerdown",d,!0),document.addEventListener("touchstart",d,!0),document.addEventListener("visibilitychange",v,!0),x(),r.addEventListener("focus",m,!0),r.addEventListener("blur",h,!0),r.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&r.host?r.host.setAttribute("data-js-focus-visible",""):r.nodeType===Node.DOCUMENT_NODE&&(document.documentElement.classList.add("js-focus-visible"),document.documentElement.setAttribute("data-js-focus-visible",""))}if(typeof window!="undefined"&&typeof document!="undefined"){window.applyFocusVisiblePolyfill=e;var t;try{t=new CustomEvent("focus-visible-polyfill-ready")}catch(r){t=document.createEvent("CustomEvent"),t.initCustomEvent("focus-visible-polyfill-ready",!1,!1,{})}window.dispatchEvent(t)}typeof document!="undefined"&&e(document)}))});var So=Cn((M0,vs)=>{"use strict";var Gu=/["'&<>]/;vs.exports=Ju;function Ju(e){var t=""+e,r=Gu.exec(t);if(!r)return t;var n,o="",i=0,a=0;for(i=r.index;i<t.length;i++){switch(t.charCodeAt(i)){case 34:n="&quot;";break;case 38:n="&amp;";break;case 39:n="&#39;";break;case 60:n="&lt;";break;case 62:n="&gt;";break;default:continue}a!==i&&(o+=t.substring(a,i)),a=i+1,o+=n}return a!==i?o+t.substring(a,i):o}});var Mo=Cn((jr,Lo)=>{(function(t,r){typeof jr=="object"&&typeof Lo=="object"?Lo.exports=r():typeof define=="function"&&define.amd?define([],r):typeof jr=="object"?jr.ClipboardJS=r():t.ClipboardJS=r()})(jr,function(){return(function(){var e={686:(function(n,o,i){"use strict";i.d(o,{default:function(){return vr}});var a=i(279),s=i.n(a),c=i(370),l=i.n(c),u=i(817),p=i.n(u);function d(B){try{return document.execCommand(B)}catch(C){return!1}}var m=function(C){var k=p()(C);return d("cut"),k},h=m;function v(B){var C=document.documentElement.getAttribute("dir")==="rtl",k=document.createElement("textarea");k.style.fontSize="12pt",k.style.border="0",k.style.padding="0",k.style.margin="0",k.style.position="absolute",k.style[C?"right":"left"]="-9999px";var D=window.pageYOffset||document.documentElement.scrollTop;return k.style.top="".concat(D,"px"),k.setAttribute("readonly",""),k.value=B,k}var x=function(C,k){var D=v(C);k.container.appendChild(D);var W=p()(D);return d("copy"),D.remove(),W},w=function(C){var k=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body},D="";return typeof C=="string"?D=x(C,k):C instanceof HTMLInputElement&&!["text","search","url","tel","password"].includes(C==null?void 0:C.type)?D=x(C.value,k):(D=p()(C),d("copy")),D},E=w;function _(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?_=function(k){return typeof k}:_=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},_(B)}var de=function(){var C=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},k=C.action,D=k===void 0?"copy":k,W=C.container,Z=C.target,We=C.text;if(D!=="copy"&&D!=="cut")throw new Error('Invalid "action" value, use either "copy" or "cut"');if(Z!==void 0)if(Z&&_(Z)==="object"&&Z.nodeType===1){if(D==="copy"&&Z.hasAttribute("disabled"))throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');if(D==="cut"&&(Z.hasAttribute("readonly")||Z.hasAttribute("disabled")))throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`)}else throw new Error('Invalid "target" value, use a valid Element');if(We)return E(We,{container:W});if(Z)return D==="cut"?h(Z):E(Z,{container:W})},be=de;function M(B){"@babel/helpers - typeof";return typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?M=function(k){return typeof k}:M=function(k){return k&&typeof Symbol=="function"&&k.constructor===Symbol&&k!==Symbol.prototype?"symbol":typeof k},M(B)}function O(B,C){if(!(B instanceof C))throw new TypeError("Cannot call a class as a function")}function N(B,C){for(var k=0;k<C.length;k++){var D=C[k];D.enumerable=D.enumerable||!1,D.configurable=!0,"value"in D&&(D.writable=!0),Object.defineProperty(B,D.key,D)}}function ee(B,C,k){return C&&N(B.prototype,C),k&&N(B,k),B}function le(B,C){if(typeof C!="function"&&C!==null)throw new TypeError("Super expression must either be null or a function");B.prototype=Object.create(C&&C.prototype,{constructor:{value:B,writable:!0,configurable:!0}}),C&&ce(B,C)}function ce(B,C){return ce=Object.setPrototypeOf||function(D,W){return D.__proto__=W,D},ce(B,C)}function Ne(B){var C=st();return function(){var D=tt(B),W;if(C){var Z=tt(this).constructor;W=Reflect.construct(D,arguments,Z)}else W=D.apply(this,arguments);return bt(this,W)}}function bt(B,C){return C&&(M(C)==="object"||typeof C=="function")?C:De(B)}function De(B){if(B===void 0)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return B}function st(){if(typeof Reflect=="undefined"||!Reflect.construct||Reflect.construct.sham)return!1;if(typeof Proxy=="function")return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(B){return!1}}function tt(B){return tt=Object.setPrototypeOf?Object.getPrototypeOf:function(k){return k.__proto__||Object.getPrototypeOf(k)},tt(B)}function Yt(B,C){var k="data-clipboard-".concat(B);if(C.hasAttribute(k))return C.getAttribute(k)}var Mt=(function(B){le(k,B);var C=Ne(k);function k(D,W){var Z;return O(this,k),Z=C.call(this),Z.resolveOptions(W),Z.listenClick(D),Z}return ee(k,[{key:"resolveOptions",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};this.action=typeof W.action=="function"?W.action:this.defaultAction,this.target=typeof W.target=="function"?W.target:this.defaultTarget,this.text=typeof W.text=="function"?W.text:this.defaultText,this.container=M(W.container)==="object"?W.container:document.body}},{key:"listenClick",value:function(W){var Z=this;this.listener=l()(W,"click",function(We){return Z.onClick(We)})}},{key:"onClick",value:function(W){var Z=W.delegateTarget||W.currentTarget,We=this.action(Z)||"copy",Gt=be({action:We,container:this.container,target:this.target(Z),text:this.text(Z)});this.emit(Gt?"success":"error",{action:We,text:Gt,trigger:Z,clearSelection:function(){Z&&Z.focus(),window.getSelection().removeAllRanges()}})}},{key:"defaultAction",value:function(W){return Yt("action",W)}},{key:"defaultTarget",value:function(W){var Z=Yt("target",W);if(Z)return document.querySelector(Z)}},{key:"defaultText",value:function(W){return Yt("text",W)}},{key:"destroy",value:function(){this.listener.destroy()}}],[{key:"copy",value:function(W){var Z=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{container:document.body};return E(W,Z)}},{key:"cut",value:function(W){return h(W)}},{key:"isSupported",value:function(){var W=arguments.length>0&&arguments[0]!==void 0?arguments[0]:["copy","cut"],Z=typeof W=="string"?[W]:W,We=!!document.queryCommandSupported;return Z.forEach(function(Gt){We=We&&!!document.queryCommandSupported(Gt)}),We}}]),k})(s()),vr=Mt}),828:(function(n){var o=9;if(typeof Element!="undefined"&&!Element.prototype.matches){var i=Element.prototype;i.matches=i.matchesSelector||i.mozMatchesSelector||i.msMatchesSelector||i.oMatchesSelector||i.webkitMatchesSelector}function a(s,c){for(;s&&s.nodeType!==o;){if(typeof s.matches=="function"&&s.matches(c))return s;s=s.parentNode}}n.exports=a}),438:(function(n,o,i){var a=i(828);function s(u,p,d,m,h){var v=l.apply(this,arguments);return u.addEventListener(d,v,h),{destroy:function(){u.removeEventListener(d,v,h)}}}function c(u,p,d,m,h){return typeof u.addEventListener=="function"?s.apply(null,arguments):typeof d=="function"?s.bind(null,document).apply(null,arguments):(typeof u=="string"&&(u=document.querySelectorAll(u)),Array.prototype.map.call(u,function(v){return s(v,p,d,m,h)}))}function l(u,p,d,m){return function(h){h.delegateTarget=a(h.target,p),h.delegateTarget&&m.call(u,h)}}n.exports=c}),879:(function(n,o){o.node=function(i){return i!==void 0&&i instanceof HTMLElement&&i.nodeType===1},o.nodeList=function(i){var a=Object.prototype.toString.call(i);return i!==void 0&&(a==="[object NodeList]"||a==="[object HTMLCollection]")&&"length"in i&&(i.length===0||o.node(i[0]))},o.string=function(i){return typeof i=="string"||i instanceof String},o.fn=function(i){var a=Object.prototype.toString.call(i);return a==="[object Function]"}}),370:(function(n,o,i){var a=i(879),s=i(438);function c(d,m,h){if(!d&&!m&&!h)throw new Error("Missing required arguments");if(!a.string(m))throw new TypeError("Second argument must be a String");if(!a.fn(h))throw new TypeError("Third argument must be a Function");if(a.node(d))return l(d,m,h);if(a.nodeList(d))return u(d,m,h);if(a.string(d))return p(d,m,h);throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList")}function l(d,m,h){return d.addEventListener(m,h),{destroy:function(){d.removeEventListener(m,h)}}}function u(d,m,h){return Array.prototype.forEach.call(d,function(v){v.addEventListener(m,h)}),{destroy:function(){Array.prototype.forEach.call(d,function(v){v.removeEventListener(m,h)})}}}function p(d,m,h){return s(document.body,d,m,h)}n.exports=c}),817:(function(n){function o(i){var a;if(i.nodeName==="SELECT")i.focus(),a=i.value;else if(i.nodeName==="INPUT"||i.nodeName==="TEXTAREA"){var s=i.hasAttribute("readonly");s||i.setAttribute("readonly",""),i.select(),i.setSelectionRange(0,i.value.length),s||i.removeAttribute("readonly"),a=i.value}else{i.hasAttribute("contenteditable")&&i.focus();var c=window.getSelection(),l=document.createRange();l.selectNodeContents(i),c.removeAllRanges(),c.addRange(l),a=c.toString()}return a}n.exports=o}),279:(function(n){function o(){}o.prototype={on:function(i,a,s){var c=this.e||(this.e={});return(c[i]||(c[i]=[])).push({fn:a,ctx:s}),this},once:function(i,a,s){var c=this;function l(){c.off(i,l),a.apply(s,arguments)}return l._=a,this.on(i,l,s)},emit:function(i){var a=[].slice.call(arguments,1),s=((this.e||(this.e={}))[i]||[]).slice(),c=0,l=s.length;for(c;c<l;c++)s[c].fn.apply(s[c].ctx,a);return this},off:function(i,a){var s=this.e||(this.e={}),c=s[i],l=[];if(c&&a)for(var u=0,p=c.length;u<p;u++)c[u].fn!==a&&c[u].fn._!==a&&l.push(c[u]);return l.length?s[i]=l:delete s[i],this}},n.exports=o,n.exports.TinyEmitter=o})},t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={exports:{}};return e[n](o,o.exports,r),o.exports}return(function(){r.n=function(n){var o=n&&n.__esModule?function(){return n.default}:function(){return n};return r.d(o,{a:o}),o}})(),(function(){r.d=function(n,o){for(var i in o)r.o(o,i)&&!r.o(n,i)&&Object.defineProperty(n,i,{enumerable:!0,get:o[i]})}})(),(function(){r.o=function(n,o){return Object.prototype.hasOwnProperty.call(n,o)}})(),r(686)})().default})});var LM=_r(Do());var $n=function(e,t){return $n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(r,n){r.__proto__=n}||function(r,n){for(var o in n)Object.prototype.hasOwnProperty.call(n,o)&&(r[o]=n[o])},$n(e,t)};function ue(e,t){if(typeof t!="function"&&t!==null)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");$n(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function Wo(e,t,r,n){function o(i){return i instanceof r?i:new r(function(a){a(i)})}return new(r||(r=Promise))(function(i,a){function s(u){try{l(n.next(u))}catch(p){a(p)}}function c(u){try{l(n.throw(u))}catch(p){a(p)}}function l(u){u.done?i(u.value):o(u.value).then(s,c)}l((n=n.apply(e,t||[])).next())})}function Wr(e,t){var r={label:0,sent:function(){if(i[0]&1)throw i[1];return i[1]},trys:[],ops:[]},n,o,i,a=Object.create((typeof Iterator=="function"?Iterator:Object).prototype);return a.next=s(0),a.throw=s(1),a.return=s(2),typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(l){return function(u){return c([l,u])}}function c(l){if(n)throw new TypeError("Generator is already executing.");for(;a&&(a=0,l[0]&&(r=0)),r;)try{if(n=1,o&&(i=l[0]&2?o.return:l[0]?o.throw||((i=o.return)&&i.call(o),0):o.next)&&!(i=i.call(o,l[1])).done)return i;switch(o=0,i&&(l=[l[0]&2,i.value]),l[0]){case 0:case 1:i=l;break;case 4:return r.label++,{value:l[1],done:!1};case 5:r.label++,o=l[1],l=[0];continue;case 7:l=r.ops.pop(),r.trys.pop();continue;default:if(i=r.trys,!(i=i.length>0&&i[i.length-1])&&(l[0]===6||l[0]===2)){r=0;continue}if(l[0]===3&&(!i||l[1]>i[0]&&l[1]<i[3])){r.label=l[1];break}if(l[0]===6&&r.label<i[1]){r.label=i[1],i=l;break}if(i&&r.label<i[2]){r.label=i[2],r.ops.push(l);break}i[2]&&r.ops.pop(),r.trys.pop();continue}l=t.call(e,r)}catch(u){l=[6,u],o=0}finally{n=i=0}if(l[0]&5)throw l[1];return{value:l[0]?l[1]:void 0,done:!0}}}function $e(e){var t=typeof Symbol=="function"&&Symbol.iterator,r=t&&e[t],n=0;if(r)return r.call(e);if(e&&typeof e.length=="number")return{next:function(){return e&&n>=e.length&&(e=void 0),{value:e&&e[n++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function te(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),o,i=[],a;try{for(;(t===void 0||t-- >0)&&!(o=n.next()).done;)i.push(o.value)}catch(s){a={error:s}}finally{try{o&&!o.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return i}function ne(e,t,r){if(r||arguments.length===2)for(var n=0,o=t.length,i;n<o;n++)(i||!(n in t))&&(i||(i=Array.prototype.slice.call(t,0,n)),i[n]=t[n]);return e.concat(i||Array.prototype.slice.call(t))}function kt(e){return this instanceof kt?(this.v=e,this):new kt(e)}function Vo(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),o,i=[];return o=Object.create((typeof AsyncIterator=="function"?AsyncIterator:Object).prototype),s("next"),s("throw"),s("return",a),o[Symbol.asyncIterator]=function(){return this},o;function a(m){return function(h){return Promise.resolve(h).then(m,p)}}function s(m,h){n[m]&&(o[m]=function(v){return new Promise(function(x,w){i.push([m,v,x,w])>1||c(m,v)})},h&&(o[m]=h(o[m])))}function c(m,h){try{l(n[m](h))}catch(v){d(i[0][3],v)}}function l(m){m.value instanceof kt?Promise.resolve(m.value.v).then(u,p):d(i[0][2],m)}function u(m){c("next",m)}function p(m){c("throw",m)}function d(m,h){m(h),i.shift(),i.length&&c(i[0][0],i[0][1])}}function zo(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator],r;return t?t.call(e):(e=typeof $e=="function"?$e(e):e[Symbol.iterator](),r={},n("next"),n("throw"),n("return"),r[Symbol.asyncIterator]=function(){return this},r);function n(i){r[i]=e[i]&&function(a){return new Promise(function(s,c){a=e[i](a),o(s,c,a.done,a.value)})}}function o(i,a,s,c){Promise.resolve(c).then(function(l){i({value:l,done:s})},a)}}function F(e){return typeof e=="function"}function Jt(e){var t=function(n){Error.call(n),n.stack=new Error().stack},r=e(t);return r.prototype=Object.create(Error.prototype),r.prototype.constructor=r,r}var Vr=Jt(function(e){return function(r){e(this),this.message=r?r.length+` errors occurred during unsubscription:
 `+r.map(function(n,o){return o+1+") "+n.toString()}).join(`
   `):"",this.name="UnsubscriptionError",this.errors=r}});function ct(e,t){if(e){var r=e.indexOf(t);0<=r&&e.splice(r,1)}}var rt=(function(){function e(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}return e.prototype.unsubscribe=function(){var t,r,n,o,i;if(!this.closed){this.closed=!0;var a=this._parentage;if(a)if(this._parentage=null,Array.isArray(a))try{for(var s=$e(a),c=s.next();!c.done;c=s.next()){var l=c.value;l.remove(this)}}catch(v){t={error:v}}finally{try{c&&!c.done&&(r=s.return)&&r.call(s)}finally{if(t)throw t.error}}else a.remove(this);var u=this.initialTeardown;if(F(u))try{u()}catch(v){i=v instanceof Vr?v.errors:[v]}var p=this._finalizers;if(p){this._finalizers=null;try{for(var d=$e(p),m=d.next();!m.done;m=d.next()){var h=m.value;try{qo(h)}catch(v){i=i!=null?i:[],v instanceof Vr?i=ne(ne([],te(i)),te(v.errors)):i.push(v)}}}catch(v){n={error:v}}finally{try{m&&!m.done&&(o=d.return)&&o.call(d)}finally{if(n)throw n.error}}}if(i)throw new Vr(i)}},e.prototype.add=function(t){var r;if(t&&t!==this)if(this.closed)qo(t);else{if(t instanceof e){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=(r=this._finalizers)!==null&&r!==void 0?r:[]).push(t)}},e.prototype._hasParent=function(t){var r=this._parentage;return r===t||Array.isArray(r)&&r.includes(t)},e.prototype._addParent=function(t){var r=this._parentage;this._parentage=Array.isArray(r)?(r.push(t),r):r?[r,t]:t},e.prototype._removeParent=function(t){var r=this._parentage;r===t?this._parentage=null:Array.isArray(r)&&ct(r,t)},e.prototype.remove=function(t){var r=this._finalizers;r&&ct(r,t),t instanceof e&&t._removeParent(this)},e.EMPTY=(function(){var t=new e;return t.closed=!0,t})(),e})();var Pn=rt.EMPTY;function zr(e){return e instanceof rt||e&&"closed"in e&&F(e.remove)&&F(e.add)&&F(e.unsubscribe)}function qo(e){F(e)?e():e.unsubscribe()}var Je={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1};var Xt={setTimeout:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Xt.delegate;return o!=null&&o.setTimeout?o.setTimeout.apply(o,ne([e,t],te(r))):setTimeout.apply(void 0,ne([e,t],te(r)))},clearTimeout:function(e){var t=Xt.delegate;return((t==null?void 0:t.clearTimeout)||clearTimeout)(e)},delegate:void 0};function qr(e){Xt.setTimeout(function(){var t=Je.onUnhandledError;if(t)t(e);else throw e})}function Pe(){}var Ko=(function(){return In("C",void 0,void 0)})();function Bo(e){return In("E",void 0,e)}function Yo(e){return In("N",e,void 0)}function In(e,t,r){return{kind:e,value:t,error:r}}var At=null;function Zt(e){if(Je.useDeprecatedSynchronousErrorHandling){var t=!At;if(t&&(At={errorThrown:!1,error:null}),e(),t){var r=At,n=r.errorThrown,o=r.error;if(At=null,n)throw o}}else e()}function Go(e){Je.useDeprecatedSynchronousErrorHandling&&At&&(At.errorThrown=!0,At.error=e)}var yr=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n.isStopped=!1,r?(n.destination=r,zr(r)&&r.add(n)):n.destination=Cc,n}return t.create=function(r,n,o){return new Ct(r,n,o)},t.prototype.next=function(r){this.isStopped?jn(Yo(r),this):this._next(r)},t.prototype.error=function(r){this.isStopped?jn(Bo(r),this):(this.isStopped=!0,this._error(r))},t.prototype.complete=function(){this.isStopped?jn(Ko,this):(this.isStopped=!0,this._complete())},t.prototype.unsubscribe=function(){this.closed||(this.isStopped=!0,e.prototype.unsubscribe.call(this),this.destination=null)},t.prototype._next=function(r){this.destination.next(r)},t.prototype._error=function(r){try{this.destination.error(r)}finally{this.unsubscribe()}},t.prototype._complete=function(){try{this.destination.complete()}finally{this.unsubscribe()}},t})(rt);var Mc=Function.prototype.bind;function Rn(e,t){return Mc.call(e,t)}var kc=(function(){function e(t){this.partialObserver=t}return e.prototype.next=function(t){var r=this.partialObserver;if(r.next)try{r.next(t)}catch(n){Kr(n)}},e.prototype.error=function(t){var r=this.partialObserver;if(r.error)try{r.error(t)}catch(n){Kr(n)}else Kr(t)},e.prototype.complete=function(){var t=this.partialObserver;if(t.complete)try{t.complete()}catch(r){Kr(r)}},e})(),Ct=(function(e){ue(t,e);function t(r,n,o){var i=e.call(this)||this,a;if(F(r)||!r)a={next:r!=null?r:void 0,error:n!=null?n:void 0,complete:o!=null?o:void 0};else{var s;i&&Je.useDeprecatedNextContext?(s=Object.create(r),s.unsubscribe=function(){return i.unsubscribe()},a={next:r.next&&Rn(r.next,s),error:r.error&&Rn(r.error,s),complete:r.complete&&Rn(r.complete,s)}):a=r}return i.destination=new kc(a),i}return t})(yr);function Kr(e){Je.useDeprecatedSynchronousErrorHandling?Go(e):qr(e)}function Ac(e){throw e}function jn(e,t){var r=Je.onStoppedNotification;r&&Xt.setTimeout(function(){return r(e,t)})}var Cc={closed:!0,next:Pe,error:Ac,complete:Pe};var Qt=(function(){return typeof Symbol=="function"&&Symbol.observable||"@@observable"})();function Oe(e){return e}function Jo(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Fn(e)}function Fn(e){return e.length===0?Oe:e.length===1?e[0]:function(r){return e.reduce(function(n,o){return o(n)},r)}}var U=(function(){function e(t){t&&(this._subscribe=t)}return e.prototype.lift=function(t){var r=new e;return r.source=this,r.operator=t,r},e.prototype.subscribe=function(t,r,n){var o=this,i=$c(t)?t:new Ct(t,r,n);return Zt(function(){var a=o,s=a.operator,c=a.source;i.add(s?s.call(i,c):c?o._subscribe(i):o._trySubscribe(i))}),i},e.prototype._trySubscribe=function(t){try{return this._subscribe(t)}catch(r){t.error(r)}},e.prototype.forEach=function(t,r){var n=this;return r=Xo(r),new r(function(o,i){var a=new Ct({next:function(s){try{t(s)}catch(c){i(c),a.unsubscribe()}},error:i,complete:o});n.subscribe(a)})},e.prototype._subscribe=function(t){var r;return(r=this.source)===null||r===void 0?void 0:r.subscribe(t)},e.prototype[Qt]=function(){return this},e.prototype.pipe=function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];return Fn(t)(this)},e.prototype.toPromise=function(t){var r=this;return t=Xo(t),new t(function(n,o){var i;r.subscribe(function(a){return i=a},function(a){return o(a)},function(){return n(i)})})},e.create=function(t){return new e(t)},e})();function Xo(e){var t;return(t=e!=null?e:Je.Promise)!==null&&t!==void 0?t:Promise}function Hc(e){return e&&F(e.next)&&F(e.error)&&F(e.complete)}function $c(e){return e&&e instanceof yr||Hc(e)&&zr(e)}function Pc(e){return F(e==null?void 0:e.lift)}function S(e){return function(t){if(Pc(t))return t.lift(function(r){try{return e(r,this)}catch(n){this.error(n)}});throw new TypeError("Unable to lift unknown Observable type")}}function T(e,t,r,n,o){return new Ic(e,t,r,n,o)}var Ic=(function(e){ue(t,e);function t(r,n,o,i,a,s){var c=e.call(this,r)||this;return c.onFinalize=a,c.shouldUnsubscribe=s,c._next=n?function(l){try{n(l)}catch(u){r.error(u)}}:e.prototype._next,c._error=i?function(l){try{i(l)}catch(u){r.error(u)}finally{this.unsubscribe()}}:e.prototype._error,c._complete=o?function(){try{o()}catch(l){r.error(l)}finally{this.unsubscribe()}}:e.prototype._complete,c}return t.prototype.unsubscribe=function(){var r;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){var n=this.closed;e.prototype.unsubscribe.call(this),!n&&((r=this.onFinalize)===null||r===void 0||r.call(this))}},t})(yr);var er={schedule:function(e){var t=requestAnimationFrame,r=cancelAnimationFrame,n=er.delegate;n&&(t=n.requestAnimationFrame,r=n.cancelAnimationFrame);var o=t(function(i){r=void 0,e(i)});return new rt(function(){return r==null?void 0:r(o)})},requestAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.requestAnimationFrame)||requestAnimationFrame).apply(void 0,ne([],te(e)))},cancelAnimationFrame:function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=er.delegate;return((r==null?void 0:r.cancelAnimationFrame)||cancelAnimationFrame).apply(void 0,ne([],te(e)))},delegate:void 0};var Zo=Jt(function(e){return function(){e(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}});var I=(function(e){ue(t,e);function t(){var r=e.call(this)||this;return r.closed=!1,r.currentObservers=null,r.observers=[],r.isStopped=!1,r.hasError=!1,r.thrownError=null,r}return t.prototype.lift=function(r){var n=new Qo(this,this);return n.operator=r,n},t.prototype._throwIfClosed=function(){if(this.closed)throw new Zo},t.prototype.next=function(r){var n=this;Zt(function(){var o,i;if(n._throwIfClosed(),!n.isStopped){n.currentObservers||(n.currentObservers=Array.from(n.observers));try{for(var a=$e(n.currentObservers),s=a.next();!s.done;s=a.next()){var c=s.value;c.next(r)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}}})},t.prototype.error=function(r){var n=this;Zt(function(){if(n._throwIfClosed(),!n.isStopped){n.hasError=n.isStopped=!0,n.thrownError=r;for(var o=n.observers;o.length;)o.shift().error(r)}})},t.prototype.complete=function(){var r=this;Zt(function(){if(r._throwIfClosed(),!r.isStopped){r.isStopped=!0;for(var n=r.observers;n.length;)n.shift().complete()}})},t.prototype.unsubscribe=function(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null},Object.defineProperty(t.prototype,"observed",{get:function(){var r;return((r=this.observers)===null||r===void 0?void 0:r.length)>0},enumerable:!1,configurable:!0}),t.prototype._trySubscribe=function(r){return this._throwIfClosed(),e.prototype._trySubscribe.call(this,r)},t.prototype._subscribe=function(r){return this._throwIfClosed(),this._checkFinalizedStatuses(r),this._innerSubscribe(r)},t.prototype._innerSubscribe=function(r){var n=this,o=this,i=o.hasError,a=o.isStopped,s=o.observers;return i||a?Pn:(this.currentObservers=null,s.push(r),new rt(function(){n.currentObservers=null,ct(s,r)}))},t.prototype._checkFinalizedStatuses=function(r){var n=this,o=n.hasError,i=n.thrownError,a=n.isStopped;o?r.error(i):a&&r.complete()},t.prototype.asObservable=function(){var r=new U;return r.source=this,r},t.create=function(r,n){return new Qo(r,n)},t})(U);var Qo=(function(e){ue(t,e);function t(r,n){var o=e.call(this)||this;return o.destination=r,o.source=n,o}return t.prototype.next=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.next)===null||o===void 0||o.call(n,r)},t.prototype.error=function(r){var n,o;(o=(n=this.destination)===null||n===void 0?void 0:n.error)===null||o===void 0||o.call(n,r)},t.prototype.complete=function(){var r,n;(n=(r=this.destination)===null||r===void 0?void 0:r.complete)===null||n===void 0||n.call(r)},t.prototype._subscribe=function(r){var n,o;return(o=(n=this.source)===null||n===void 0?void 0:n.subscribe(r))!==null&&o!==void 0?o:Pn},t})(I);var Un=(function(e){ue(t,e);function t(r){var n=e.call(this)||this;return n._value=r,n}return Object.defineProperty(t.prototype,"value",{get:function(){return this.getValue()},enumerable:!1,configurable:!0}),t.prototype._subscribe=function(r){var n=e.prototype._subscribe.call(this,r);return!n.closed&&r.next(this._value),n},t.prototype.getValue=function(){var r=this,n=r.hasError,o=r.thrownError,i=r._value;if(n)throw o;return this._throwIfClosed(),i},t.prototype.next=function(r){e.prototype.next.call(this,this._value=r)},t})(I);var xr={now:function(){return(xr.delegate||Date).now()},delegate:void 0};var wr=(function(e){ue(t,e);function t(r,n,o){r===void 0&&(r=1/0),n===void 0&&(n=1/0),o===void 0&&(o=xr);var i=e.call(this)||this;return i._bufferSize=r,i._windowTime=n,i._timestampProvider=o,i._buffer=[],i._infiniteTimeWindow=!0,i._infiniteTimeWindow=n===1/0,i._bufferSize=Math.max(1,r),i._windowTime=Math.max(1,n),i}return t.prototype.next=function(r){var n=this,o=n.isStopped,i=n._buffer,a=n._infiniteTimeWindow,s=n._timestampProvider,c=n._windowTime;o||(i.push(r),!a&&i.push(s.now()+c)),this._trimBuffer(),e.prototype.next.call(this,r)},t.prototype._subscribe=function(r){this._throwIfClosed(),this._trimBuffer();for(var n=this._innerSubscribe(r),o=this,i=o._infiniteTimeWindow,a=o._buffer,s=a.slice(),c=0;c<s.length&&!r.closed;c+=i?1:2)r.next(s[c]);return this._checkFinalizedStatuses(r),n},t.prototype._trimBuffer=function(){var r=this,n=r._bufferSize,o=r._timestampProvider,i=r._buffer,a=r._infiniteTimeWindow,s=(a?1:2)*n;if(n<1/0&&s<i.length&&i.splice(0,i.length-s),!a){for(var c=o.now(),l=0,u=1;u<i.length&&i[u]<=c;u+=2)l=u;l&&i.splice(0,l+1)}},t})(I);var ei=(function(e){ue(t,e);function t(r,n){return e.call(this)||this}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),this},t})(rt);var Er={setInterval:function(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];var o=Er.delegate;return o!=null&&o.setInterval?o.setInterval.apply(o,ne([e,t],te(r))):setInterval.apply(void 0,ne([e,t],te(r)))},clearInterval:function(e){var t=Er.delegate;return((t==null?void 0:t.clearInterval)||clearInterval)(e)},delegate:void 0};var tr=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o.pending=!1,o}return t.prototype.schedule=function(r,n){var o;if(n===void 0&&(n=0),this.closed)return this;this.state=r;var i=this.id,a=this.scheduler;return i!=null&&(this.id=this.recycleAsyncId(a,i,n)),this.pending=!0,this.delay=n,this.id=(o=this.id)!==null&&o!==void 0?o:this.requestAsyncId(a,this.id,n),this},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),Er.setInterval(r.flush.bind(r,this),o)},t.prototype.recycleAsyncId=function(r,n,o){if(o===void 0&&(o=0),o!=null&&this.delay===o&&this.pending===!1)return n;n!=null&&Er.clearInterval(n)},t.prototype.execute=function(r,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;var o=this._execute(r,n);if(o)return o;this.pending===!1&&this.id!=null&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))},t.prototype._execute=function(r,n){var o=!1,i;try{this.work(r)}catch(a){o=!0,i=a||new Error("Scheduled action threw falsy error")}if(o)return this.unsubscribe(),i},t.prototype.unsubscribe=function(){if(!this.closed){var r=this,n=r.id,o=r.scheduler,i=o.actions;this.work=this.state=this.scheduler=null,this.pending=!1,ct(i,this),n!=null&&(this.id=this.recycleAsyncId(o,n,null)),this.delay=null,e.prototype.unsubscribe.call(this)}},t})(ei);var Nn=(function(){function e(t,r){r===void 0&&(r=e.now),this.schedulerActionCtor=t,this.now=r}return e.prototype.schedule=function(t,r,n){return r===void 0&&(r=0),new this.schedulerActionCtor(this,t).schedule(n,r)},e.now=xr.now,e})();var rr=(function(e){ue(t,e);function t(r,n){n===void 0&&(n=Nn.now);var o=e.call(this,r,n)||this;return o.actions=[],o._active=!1,o}return t.prototype.flush=function(r){var n=this.actions;if(this._active){n.push(r);return}var o;this._active=!0;do if(o=r.execute(r.state,r.delay))break;while(r=n.shift());if(this._active=!1,o){for(;r=n.shift();)r.unsubscribe();throw o}},t})(Nn);var ge=new rr(tr),Dn=ge;var ti=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.schedule=function(r,n){return n===void 0&&(n=0),n>0?e.prototype.schedule.call(this,r,n):(this.delay=n,this.state=r,this.scheduler.flush(this),this)},t.prototype.execute=function(r,n){return n>0||this.closed?e.prototype.execute.call(this,r,n):this._execute(r,n)},t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!=null&&o>0||o==null&&this.delay>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.flush(this),0)},t})(tr);var ri=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t})(rr);var Wn=new ri(ti);var ni=(function(e){ue(t,e);function t(r,n){var o=e.call(this,r,n)||this;return o.scheduler=r,o.work=n,o}return t.prototype.requestAsyncId=function(r,n,o){return o===void 0&&(o=0),o!==null&&o>0?e.prototype.requestAsyncId.call(this,r,n,o):(r.actions.push(this),r._scheduled||(r._scheduled=er.requestAnimationFrame(function(){return r.flush(void 0)})))},t.prototype.recycleAsyncId=function(r,n,o){var i;if(o===void 0&&(o=0),o!=null?o>0:this.delay>0)return e.prototype.recycleAsyncId.call(this,r,n,o);var a=r.actions;n!=null&&n===r._scheduled&&((i=a[a.length-1])===null||i===void 0?void 0:i.id)!==n&&(er.cancelAnimationFrame(n),r._scheduled=void 0)},t})(tr);var oi=(function(e){ue(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.flush=function(r){this._active=!0;var n;r?n=r.id:(n=this._scheduled,this._scheduled=void 0);var o=this.actions,i;r=r||o.shift();do if(i=r.execute(r.state,r.delay))break;while((r=o[0])&&r.id===n&&o.shift());if(this._active=!1,i){for(;(r=o[0])&&r.id===n&&o.shift();)r.unsubscribe();throw i}},t})(rr);var je=new oi(ni);var y=new U(function(e){return e.complete()});function Br(e){return e&&F(e.schedule)}function Vn(e){return e[e.length-1]}function _t(e){return F(Vn(e))?e.pop():void 0}function qe(e){return Br(Vn(e))?e.pop():void 0}function Yr(e,t){return typeof Vn(e)=="number"?e.pop():t}var nr=(function(e){return e&&typeof e.length=="number"&&typeof e!="function"});function Gr(e){return F(e==null?void 0:e.then)}function Jr(e){return F(e[Qt])}function Xr(e){return Symbol.asyncIterator&&F(e==null?void 0:e[Symbol.asyncIterator])}function Zr(e){return new TypeError("You provided "+(e!==null&&typeof e=="object"?"an invalid object":"'"+e+"'")+" where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")}function Rc(){return typeof Symbol!="function"||!Symbol.iterator?"@@iterator":Symbol.iterator}var Qr=Rc();function en(e){return F(e==null?void 0:e[Qr])}function tn(e){return Vo(this,arguments,function(){var r,n,o,i;return Wr(this,function(a){switch(a.label){case 0:r=e.getReader(),a.label=1;case 1:a.trys.push([1,,9,10]),a.label=2;case 2:return[4,kt(r.read())];case 3:return n=a.sent(),o=n.value,i=n.done,i?[4,kt(void 0)]:[3,5];case 4:return[2,a.sent()];case 5:return[4,kt(o)];case 6:return[4,a.sent()];case 7:return a.sent(),[3,2];case 8:return[3,10];case 9:return r.releaseLock(),[7];case 10:return[2]}})})}function rn(e){return F(e==null?void 0:e.getReader)}function q(e){if(e instanceof U)return e;if(e!=null){if(Jr(e))return jc(e);if(nr(e))return Fc(e);if(Gr(e))return Uc(e);if(Xr(e))return ii(e);if(en(e))return Nc(e);if(rn(e))return Dc(e)}throw Zr(e)}function jc(e){return new U(function(t){var r=e[Qt]();if(F(r.subscribe))return r.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}function Fc(e){return new U(function(t){for(var r=0;r<e.length&&!t.closed;r++)t.next(e[r]);t.complete()})}function Uc(e){return new U(function(t){e.then(function(r){t.closed||(t.next(r),t.complete())},function(r){return t.error(r)}).then(null,qr)})}function Nc(e){return new U(function(t){var r,n;try{for(var o=$e(e),i=o.next();!i.done;i=o.next()){var a=i.value;if(t.next(a),t.closed)return}}catch(s){r={error:s}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}t.complete()})}function ii(e){return new U(function(t){Wc(e,t).catch(function(r){return t.error(r)})})}function Dc(e){return ii(tn(e))}function Wc(e,t){var r,n,o,i;return Wo(this,void 0,void 0,function(){var a,s;return Wr(this,function(c){switch(c.label){case 0:c.trys.push([0,5,6,11]),r=zo(e),c.label=1;case 1:return[4,r.next()];case 2:if(n=c.sent(),!!n.done)return[3,4];if(a=n.value,t.next(a),t.closed)return[2];c.label=3;case 3:return[3,1];case 4:return[3,11];case 5:return s=c.sent(),o={error:s},[3,11];case 6:return c.trys.push([6,,9,10]),n&&!n.done&&(i=r.return)?[4,i.call(r)]:[3,8];case 7:c.sent(),c.label=8;case 8:return[3,10];case 9:if(o)throw o.error;return[7];case 10:return[7];case 11:return t.complete(),[2]}})})}function Fe(e,t,r,n,o){n===void 0&&(n=0),o===void 0&&(o=!1);var i=t.schedule(function(){r(),o?e.add(this.schedule(null,n)):this.unsubscribe()},n);if(e.add(i),!o)return i}function Ie(e,t){return t===void 0&&(t=0),S(function(r,n){r.subscribe(T(n,function(o){return Fe(n,e,function(){return n.next(o)},t)},function(){return Fe(n,e,function(){return n.complete()},t)},function(o){return Fe(n,e,function(){return n.error(o)},t)}))})}function Ht(e,t){return t===void 0&&(t=0),S(function(r,n){n.add(e.schedule(function(){return r.subscribe(n)},t))})}function ai(e,t){return q(e).pipe(Ht(t),Ie(t))}function si(e,t){return q(e).pipe(Ht(t),Ie(t))}function ci(e,t){return new U(function(r){var n=0;return t.schedule(function(){n===e.length?r.complete():(r.next(e[n++]),r.closed||this.schedule())})})}function li(e,t){return new U(function(r){var n;return Fe(r,t,function(){n=e[Qr](),Fe(r,t,function(){var o,i,a;try{o=n.next(),i=o.value,a=o.done}catch(s){r.error(s);return}a?r.complete():r.next(i)},0,!0)}),function(){return F(n==null?void 0:n.return)&&n.return()}})}function nn(e,t){if(!e)throw new Error("Iterable cannot be null");return new U(function(r){Fe(r,t,function(){var n=e[Symbol.asyncIterator]();Fe(r,t,function(){n.next().then(function(o){o.done?r.complete():r.next(o.value)})},0,!0)})})}function ui(e,t){return nn(tn(e),t)}function pi(e,t){if(e!=null){if(Jr(e))return ai(e,t);if(nr(e))return ci(e,t);if(Gr(e))return si(e,t);if(Xr(e))return nn(e,t);if(en(e))return li(e,t);if(rn(e))return ui(e,t)}throw Zr(e)}function me(e,t){return t?pi(e,t):q(e)}function Y(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return me(e,r)}function zn(e,t){var r=F(e)?e:function(){return e},n=function(o){return o.error(r())};return new U(t?function(o){return t.schedule(n,0,o)}:n)}var on=Jt(function(e){return function(){e(this),this.name="EmptyError",this.message="no elements in sequence"}});function fi(e){return e instanceof Date&&!isNaN(e)}function f(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){n.next(e.call(t,i,o++))}))})}var Vc=Array.isArray;function zc(e,t){return Vc(t)?e.apply(void 0,ne([],te(t))):e(t)}function yt(e){return f(function(t){return zc(e,t)})}var qc=Array.isArray,Kc=Object.getPrototypeOf,Bc=Object.prototype,Yc=Object.keys;function mi(e){if(e.length===1){var t=e[0];if(qc(t))return{args:t,keys:null};if(Gc(t)){var r=Yc(t);return{args:r.map(function(n){return t[n]}),keys:r}}}return{args:e,keys:null}}function Gc(e){return e&&typeof e=="object"&&Kc(e)===Bc}function di(e,t){return e.reduce(function(r,n,o){return r[n]=t[o],r},{})}function re(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=_t(e),o=mi(e),i=o.args,a=o.keys;if(i.length===0)return me([],r);var s=new U(qn(i,r,a?function(c){return di(a,c)}:Oe));return n?s.pipe(yt(n)):s}function qn(e,t,r){return r===void 0&&(r=Oe),function(n){hi(t,function(){for(var o=e.length,i=new Array(o),a=o,s=o,c=function(u){hi(t,function(){var p=me(e[u],t),d=!1;p.subscribe(T(n,function(m){i[u]=m,d||(d=!0,s--),s||n.next(r(i.slice()))},function(){--a||n.complete()}))},n)},l=0;l<o;l++)c(l)},n)}}function hi(e,t,r){e?Fe(r,e,t):t()}function vi(e,t,r,n,o,i,a,s){var c=[],l=0,u=0,p=!1,d=function(){p&&!c.length&&!l&&t.complete()},m=function(v){return l<n?h(v):c.push(v)},h=function(v){i&&t.next(v),l++;var x=!1;q(r(v,u++)).subscribe(T(t,function(w){o==null||o(w),i?m(w):t.next(w)},function(){x=!0},void 0,function(){if(x)try{l--;for(var w=function(){var E=c.shift();a?Fe(t,a,function(){return h(E)}):h(E)};c.length&&l<n;)w();d()}catch(E){t.error(E)}}))};return e.subscribe(T(t,m,function(){p=!0,d()})),function(){s==null||s()}}function oe(e,t,r){return r===void 0&&(r=1/0),F(t)?oe(function(n,o){return f(function(i,a){return t(n,i,o,a)})(q(e(n,o)))},r):(typeof t=="number"&&(r=t),S(function(n,o){return vi(n,o,e,r)}))}function or(e){return e===void 0&&(e=1/0),oe(Oe,e)}function bi(){return or(1)}function nt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return bi()(me(e,qe(e)))}function j(e){return new U(function(t){q(e()).subscribe(t)})}var Jc=["addListener","removeListener"],Xc=["addEventListener","removeEventListener"],Zc=["on","off"];function b(e,t,r,n){if(F(r)&&(n=r,r=void 0),n)return b(e,t,r).pipe(yt(n));var o=te(tl(e)?Xc.map(function(s){return function(c){return e[s](t,c,r)}}):Qc(e)?Jc.map(gi(e,t)):el(e)?Zc.map(gi(e,t)):[],2),i=o[0],a=o[1];if(!i&&nr(e))return oe(function(s){return b(s,t,r)})(q(e));if(!i)throw new TypeError("Invalid event target");return new U(function(s){var c=function(){for(var l=[],u=0;u<arguments.length;u++)l[u]=arguments[u];return s.next(1<l.length?l:l[0])};return i(c),function(){return a(c)}})}function gi(e,t){return function(r){return function(n){return e[r](t,n)}}}function Qc(e){return F(e.addListener)&&F(e.removeListener)}function el(e){return F(e.on)&&F(e.off)}function tl(e){return F(e.addEventListener)&&F(e.removeEventListener)}function an(e,t,r){return r?an(e,t).pipe(yt(r)):new U(function(n){var o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];return n.next(a.length===1?a[0]:a)},i=e(o);return F(t)?function(){return t(o,i)}:void 0})}function Ve(e,t,r){e===void 0&&(e=0),r===void 0&&(r=Dn);var n=-1;return t!=null&&(Br(t)?r=t:n=t),new U(function(o){var i=fi(e)?+e-r.now():e;i<0&&(i=0);var a=0;return r.schedule(function(){o.closed||(o.next(a++),0<=n?this.schedule(void 0,n):o.complete())},i)})}function R(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0),o=e;return o.length?o.length===1?q(o[0]):or(n)(me(o,r)):y}var Ke=new U(Pe);var rl=Array.isArray;function sn(e){return e.length===1&&rl(e[0])?e[0]:e}function L(e,t){return S(function(r,n){var o=0;r.subscribe(T(n,function(i){return e.call(t,i,o++)&&n.next(i)}))})}function $t(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e),n=sn(e);return n.length?new U(function(o){var i=n.map(function(){return[]}),a=n.map(function(){return!1});o.add(function(){i=a=null});for(var s=function(l){q(n[l]).subscribe(T(o,function(u){if(i[l].push(u),i.every(function(d){return d.length})){var p=i.map(function(d){return d.shift()});o.next(r?r.apply(void 0,ne([],te(p))):p),i.some(function(d,m){return!d.length&&a[m]})&&o.complete()}},function(){a[l]=!0,!i[l].length&&o.complete()}))},c=0;!o.closed&&c<n.length;c++)s(c);return function(){i=a=null}}):y}function _i(e){return S(function(t,r){var n=!1,o=null,i=null,a=!1,s=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var l=o;o=null,r.next(l)}a&&r.complete()},c=function(){i=null,a&&r.complete()};t.subscribe(T(r,function(l){n=!0,o=l,i||q(e(l)).subscribe(i=T(r,s,c))},function(){a=!0,(!n||!i||i.closed)&&r.complete()}))})}function Xe(e,t){return t===void 0&&(t=ge),_i(function(){return Ve(e,t)})}function Pt(e,t){return t===void 0&&(t=null),t=t!=null?t:e,S(function(r,n){var o=[],i=0;r.subscribe(T(n,function(a){var s,c,l,u,p=null;i++%t===0&&o.push([]);try{for(var d=$e(o),m=d.next();!m.done;m=d.next()){var h=m.value;h.push(a),e<=h.length&&(p=p!=null?p:[],p.push(h))}}catch(w){s={error:w}}finally{try{m&&!m.done&&(c=d.return)&&c.call(d)}finally{if(s)throw s.error}}if(p)try{for(var v=$e(p),x=v.next();!x.done;x=v.next()){var h=x.value;ct(o,h),n.next(h)}}catch(w){l={error:w}}finally{try{x&&!x.done&&(u=v.return)&&u.call(v)}finally{if(l)throw l.error}}},function(){var a,s;try{for(var c=$e(o),l=c.next();!l.done;l=c.next()){var u=l.value;n.next(u)}}catch(p){a={error:p}}finally{try{l&&!l.done&&(s=c.return)&&s.call(c)}finally{if(a)throw a.error}}n.complete()},void 0,function(){o=null}))})}function _e(e){return S(function(t,r){var n=null,o=!1,i;n=t.subscribe(T(r,void 0,void 0,function(a){i=q(e(a,_e(e)(t))),n?(n.unsubscribe(),n=null,i.subscribe(r)):o=!0})),o&&(n.unsubscribe(),n=null,i.subscribe(r))})}function yi(e,t,r,n,o){return function(i,a){var s=r,c=t,l=0;i.subscribe(T(a,function(u){var p=l++;c=s?e(c,u,p):(s=!0,u),n&&a.next(c)},o&&(function(){s&&a.next(c),a.complete()})))}}function Kn(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return r?Jo(Kn.apply(void 0,ne([],te(e))),yt(r)):S(function(n,o){qn(ne([n],te(sn(e))))(o)})}function Ze(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Kn.apply(void 0,ne([],te(e)))}function Tr(e){return S(function(t,r){var n=!1,o=null,i=null,a=function(){if(i==null||i.unsubscribe(),i=null,n){n=!1;var s=o;o=null,r.next(s)}};t.subscribe(T(r,function(s){i==null||i.unsubscribe(),n=!0,o=s,i=T(r,a,Pe),q(e(s)).subscribe(i)},function(){a(),r.complete()},void 0,function(){o=i=null}))})}function Be(e,t){return t===void 0&&(t=ge),S(function(r,n){var o=null,i=null,a=null,s=function(){if(o){o.unsubscribe(),o=null;var l=i;i=null,n.next(l)}};function c(){var l=a+e,u=t.now();if(u<l){o=this.schedule(void 0,l-u),n.add(o);return}s()}r.subscribe(T(n,function(l){i=l,a=t.now(),o||(o=t.schedule(c,e),n.add(o))},function(){s(),n.complete()},void 0,function(){i=o=null}))})}function ot(e){return S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){n||r.next(e),r.complete()}))})}function Me(e){return e<=0?function(){return y}:S(function(t,r){var n=0;t.subscribe(T(r,function(o){++n<=e&&(r.next(o),e<=n&&r.complete())}))})}function he(){return S(function(e,t){e.subscribe(T(t,Pe))})}function xi(e){return f(function(){return e})}function Bn(e,t){return t?function(r){return nt(t.pipe(Me(1),he()),r.pipe(Bn(e)))}:oe(function(r,n){return q(e(r,n)).pipe(Me(1),xi(r))})}function It(e,t){t===void 0&&(t=ge);var r=Ve(e,t);return Bn(function(){return r})}function Yn(e,t){return S(function(r,n){var o=new Set;r.subscribe(T(n,function(i){var a=e?e(i):i;o.has(a)||(o.add(a),n.next(i))})),t&&q(t).subscribe(T(n,function(){return o.clear()},Pe))})}function ie(e,t){return t===void 0&&(t=Oe),e=e!=null?e:nl,S(function(r,n){var o,i=!0;r.subscribe(T(n,function(a){var s=t(a);(i||!e(o,s))&&(i=!1,o=s,n.next(a))}))})}function nl(e,t){return e===t}function fe(e,t){return ie(function(r,n){return t?t(r[e],n[e]):r[e]===n[e]})}function wi(e){return e===void 0&&(e=ol),S(function(t,r){var n=!1;t.subscribe(T(r,function(o){n=!0,r.next(o)},function(){return n?r.complete():r.error(e())}))})}function ol(){return new on}function ye(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return function(r){return nt(r,Y.apply(void 0,ne([],te(e))))}}function cn(e,t){return t?function(r){return r.pipe(cn(function(n,o){return q(e(n,o)).pipe(f(function(i,a){return t(n,i,o,a)}))}))}:S(function(r,n){var o=0,i=null,a=!1;r.subscribe(T(n,function(s){i||(i=T(n,void 0,function(){i=null,a&&n.complete()}),q(e(s,o++)).subscribe(i))},function(){a=!0,!i&&n.complete()}))})}function V(e){return S(function(t,r){try{t.subscribe(r)}finally{r.add(e)}})}function Sr(e,t){var r=arguments.length>=2;return function(n){return n.pipe(e?L(function(o,i){return e(o,i,n)}):Oe,Me(1),r?ot(t):wi(function(){return new on}))}}function Gn(e){return e<=0?function(){return y}:S(function(t,r){var n=[];t.subscribe(T(r,function(o){n.push(o),e<n.length&&n.shift()},function(){var o,i;try{for(var a=$e(n),s=a.next();!s.done;s=a.next()){var c=s.value;r.next(c)}}catch(l){o={error:l}}finally{try{s&&!s.done&&(i=a.return)&&i.call(a)}finally{if(o)throw o.error}}r.complete()},void 0,function(){n=null}))})}function Ei(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e),n=Yr(e,1/0);return S(function(o,i){or(n)(me(ne([o],te(e)),r)).subscribe(i)})}function Rt(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return Ei.apply(void 0,ne([],te(e)))}function jt(e){var t,r=1/0,n;return e!=null&&(typeof e=="object"?(t=e.count,r=t===void 0?1/0:t,n=e.delay):r=e),r<=0?function(){return y}:S(function(o,i){var a=0,s,c=function(){if(s==null||s.unsubscribe(),s=null,n!=null){var u=typeof n=="number"?Ve(n):q(n(a)),p=T(i,function(){p.unsubscribe(),l()});u.subscribe(p)}else l()},l=function(){var u=!1;s=o.subscribe(T(i,void 0,function(){++a<r?s?c():u=!0:i.complete()})),u&&c()};l()})}function Or(e,t){return S(yi(e,t,arguments.length>=2,!0))}function xe(e){e===void 0&&(e={});var t=e.connector,r=t===void 0?function(){return new I}:t,n=e.resetOnError,o=n===void 0?!0:n,i=e.resetOnComplete,a=i===void 0?!0:i,s=e.resetOnRefCountZero,c=s===void 0?!0:s;return function(l){var u,p,d,m=0,h=!1,v=!1,x=function(){p==null||p.unsubscribe(),p=void 0},w=function(){x(),u=d=void 0,h=v=!1},E=function(){var _=u;w(),_==null||_.unsubscribe()};return S(function(_,de){m++,!v&&!h&&x();var be=d=d!=null?d:r();de.add(function(){m--,m===0&&!v&&!h&&(p=Jn(E,c))}),be.subscribe(de),!u&&m>0&&(u=new Ct({next:function(M){return be.next(M)},error:function(M){v=!0,x(),p=Jn(w,o,M),be.error(M)},complete:function(){h=!0,x(),p=Jn(w,a),be.complete()}}),q(_).subscribe(u))})(l)}}function Jn(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];if(t===!0){e();return}if(t!==!1){var o=new Ct({next:function(){o.unsubscribe(),e()}});return q(t.apply(void 0,ne([],te(r)))).subscribe(o)}}function se(e,t,r){var n,o,i,a,s=!1;return e&&typeof e=="object"?(n=e.bufferSize,a=n===void 0?1/0:n,o=e.windowTime,t=o===void 0?1/0:o,i=e.refCount,s=i===void 0?!1:i,r=e.scheduler):a=e!=null?e:1/0,xe({connector:function(){return new wr(a,t,r)},resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:s})}function ke(e){return L(function(t,r){return e<=r})}function J(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=qe(e);return S(function(n,o){(r?nt(e,n,r):nt(e,n)).subscribe(o)})}function g(e,t){return S(function(r,n){var o=null,i=0,a=!1,s=function(){return a&&!o&&n.complete()};r.subscribe(T(n,function(c){o==null||o.unsubscribe();var l=0,u=i++;q(e(c,u)).subscribe(o=T(n,function(p){return n.next(t?t(c,p,u,l++):p)},function(){o=null,s()}))},function(){a=!0,s()}))})}function Q(e){return S(function(t,r){q(e).subscribe(T(r,function(){return r.complete()},Pe)),!r.closed&&t.subscribe(r)})}function Xn(e,t){return t===void 0&&(t=!1),S(function(r,n){var o=0;r.subscribe(T(n,function(i){var a=e(i,o++);(a||t)&&n.next(i),!a&&n.complete()}))})}function $(e,t,r){var n=F(e)||t||r?{next:e,error:t,complete:r}:e;return n?S(function(o,i){var a;(a=n.subscribe)===null||a===void 0||a.call(n);var s=!0;o.subscribe(T(i,function(c){var l;(l=n.next)===null||l===void 0||l.call(n,c),i.next(c)},function(){var c;s=!1,(c=n.complete)===null||c===void 0||c.call(n),i.complete()},function(c){var l;s=!1,(l=n.error)===null||l===void 0||l.call(n,c),i.error(c)},function(){var c,l;s&&((c=n.unsubscribe)===null||c===void 0||c.call(n)),(l=n.finalize)===null||l===void 0||l.call(n)}))}):Oe}function Ti(e,t){return S(function(r,n){var o=t!=null?t:{},i=o.leading,a=i===void 0?!0:i,s=o.trailing,c=s===void 0?!1:s,l=!1,u=null,p=null,d=!1,m=function(){p==null||p.unsubscribe(),p=null,c&&(x(),d&&n.complete())},h=function(){p=null,d&&n.complete()},v=function(w){return p=q(e(w)).subscribe(T(n,m,h))},x=function(){if(l){l=!1;var w=u;u=null,n.next(w),!d&&v(w)}};r.subscribe(T(n,function(w){l=!0,u=w,!(p&&!p.closed)&&(a?x():v(w))},function(){d=!0,!(c&&l&&p&&!p.closed)&&n.complete()}))})}function Lr(e,t,r){t===void 0&&(t=ge);var n=Ve(e,t);return Ti(function(){return n},r)}function pe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=_t(e);return S(function(n,o){for(var i=e.length,a=new Array(i),s=e.map(function(){return!1}),c=!1,l=function(p){q(e[p]).subscribe(T(o,function(d){a[p]=d,!c&&!s[p]&&(s[p]=!0,(c=s.every(Oe))&&(s=null))},Pe))},u=0;u<i;u++)l(u);n.subscribe(T(o,function(p){if(c){var d=ne([p],te(a));o.next(r?r.apply(void 0,ne([],te(d))):d)}}))})}function Si(){let e=new wr(1);return b(document,"DOMContentLoaded",{once:!0}).subscribe(()=>e.next(document)),e}function P(e,t=document){return Array.from(t.querySelectorAll(e))}function G(e,t=document){let r=Le(e,t);if(typeof r=="undefined")throw new ReferenceError(`Missing element: expected "${e}" to be present`);return r}function Le(e,t=document){return t.querySelector(e)||void 0}function xt(){var e,t,r,n;return(n=(r=(t=(e=document.activeElement)==null?void 0:e.shadowRoot)==null?void 0:t.activeElement)!=null?r:document.activeElement)!=null?n:void 0}var il=R(b(document.body,"focusin"),b(document.body,"focusout")).pipe(Be(1),J(void 0),f(()=>xt()||document.body),se(1));function ir(e){return il.pipe(f(t=>e.contains(t)),ie())}function Ft(e,t){let{matches:r}=matchMedia("(hover)");return j(()=>(r?R(b(e,"mouseenter").pipe(f(()=>!0)),b(e,"mouseleave").pipe(f(()=>!1))):R(b(e,"touchstart").pipe(f(()=>!0)),b(e,"touchend").pipe(f(()=>!1)),b(e,"touchcancel").pipe(f(()=>!1)))).pipe(t?Tr(o=>Ve(+!o*t)):Oe,J(!0,e.matches(":hover"))))}function Oi(e,t){if(typeof t=="string"||typeof t=="number")e.innerHTML+=t.toString();else if(t instanceof Node)e.appendChild(t);else if(Array.isArray(t))for(let r of t)Oi(e,r)}function A(e,t,...r){let n=document.createElement(e);if(t)for(let o of Object.keys(t))typeof t[o]!="undefined"&&(typeof t[o]!="boolean"?n.setAttribute(o,t[o]):n.setAttribute(o,""));for(let o of r)Oi(n,o);return n}function Li(e){if(e>999){let t=+((e-950)%1e3>99);return`${((e+1e-6)/1e3).toFixed(t)}k`}else return e.toString()}function ar(e){let t=A("script",{src:e});return j(()=>(document.head.appendChild(t),R(b(t,"load"),b(t,"error").pipe(g(()=>zn(()=>new ReferenceError(`Invalid script: ${e}`))))).pipe(f(()=>{}),V(()=>document.head.removeChild(t)),Me(1))))}var Mi=new I,al=j(()=>typeof ResizeObserver=="undefined"?ar("https://unpkg.com/resize-observer-polyfill"):Y(void 0)).pipe(f(()=>new ResizeObserver(e=>e.forEach(t=>Mi.next(t)))),g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Ae(e){return{width:e.offsetWidth,height:e.offsetHeight}}function Re(e){let t=e;for(;t.clientWidth===0&&t.parentElement;)t=t.parentElement;return al.pipe($(r=>r.observe(t)),g(r=>Mi.pipe(L(n=>n.target===t),V(()=>r.unobserve(t)))),f(()=>Ae(e)),J(Ae(e)))}function Mr(e){return{width:e.scrollWidth,height:e.scrollHeight}}function ki(e){let t=e.parentElement;for(;t&&(e.scrollWidth<=t.scrollWidth&&e.scrollHeight<=t.scrollHeight);)t=(e=t).parentElement;return t?e:void 0}function Ai(e){let t=[],r=e.parentElement;for(;r;)(e.clientWidth>r.clientWidth||e.clientHeight>r.clientHeight)&&t.push(r),r=(e=r).parentElement;return t.length===0&&t.push(document.documentElement),t}function wt(e){return{x:e.offsetLeft,y:e.offsetTop}}function Ci(e){let t=e.getBoundingClientRect();return{x:t.x+window.scrollX,y:t.y+window.scrollY}}function Hi(e){return R(b(window,"load"),b(window,"resize")).pipe(Xe(0,je),f(()=>wt(e)),J(wt(e)))}function ln(e){return{x:e.scrollLeft,y:e.scrollTop}}function Ut(e){return R(b(e,"scroll"),b(window,"scroll"),b(window,"resize")).pipe(Xe(0,je),f(()=>ln(e)),J(ln(e)))}var $i=new I,sl=j(()=>Y(new IntersectionObserver(e=>{for(let t of e)$i.next(t)},{threshold:0}))).pipe(g(e=>R(Ke,Y(e)).pipe(V(()=>e.disconnect()))),se(1));function Et(e){return sl.pipe($(t=>t.observe(e)),g(t=>$i.pipe(L(({target:r})=>r===e),V(()=>t.unobserve(e)),f(({isIntersecting:r})=>r))))}var cl=Object.create,la=Object.defineProperty,ll=Object.getOwnPropertyDescriptor,ul=Object.getOwnPropertyNames,pl=Object.getPrototypeOf,fl=Object.prototype.hasOwnProperty,ml=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),dl=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of ul(t))!fl.call(e,o)&&o!==r&&la(e,o,{get:()=>t[o],enumerable:!(n=ll(t,o))||n.enumerable});return e},hl=(e,t,r)=>(r=e!=null?cl(pl(e)):{},dl(t||!e||!e.__esModule?la(r,"default",{value:e,enumerable:!0}):r,e)),vl=ml((e,t)=>{var r="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,s=/^0b[01]+$/i,c=/^0o[0-7]+$/i,l=parseInt,u=typeof global=="object"&&global&&global.Object===Object&&global,p=typeof self=="object"&&self&&self.Object===Object&&self,d=u||p||Function("return this")(),m=Object.prototype,h=m.toString,v=Math.max,x=Math.min,w=function(){return d.Date.now()};function E(O,N,ee){var le,ce,Ne,bt,De,st,tt=0,Yt=!1,Mt=!1,vr=!0;if(typeof O!="function")throw new TypeError(r);N=M(N)||0,_(ee)&&(Yt=!!ee.leading,Mt="maxWait"in ee,Ne=Mt?v(M(ee.maxWait)||0,N):Ne,vr="trailing"in ee?!!ee.trailing:vr);function B(Te){var gt=le,br=ce;return le=ce=void 0,tt=Te,bt=O.apply(br,gt),bt}function C(Te){return tt=Te,De=setTimeout(W,N),Yt?B(Te):bt}function k(Te){var gt=Te-st,br=Te-tt,Ro=N-gt;return Mt?x(Ro,Ne-br):Ro}function D(Te){var gt=Te-st,br=Te-tt;return st===void 0||gt>=N||gt<0||Mt&&br>=Ne}function W(){var Te=w();if(D(Te))return Z(Te);De=setTimeout(W,k(Te))}function Z(Te){return De=void 0,vr&&le?B(Te):(le=ce=void 0,bt)}function We(){De!==void 0&&clearTimeout(De),tt=0,le=st=ce=De=void 0}function Gt(){return De===void 0?bt:Z(w())}function Nr(){var Te=w(),gt=D(Te);if(le=arguments,ce=this,st=Te,gt){if(De===void 0)return C(st);if(Mt)return De=setTimeout(W,N),B(st)}return De===void 0&&(De=setTimeout(W,N)),bt}return Nr.cancel=We,Nr.flush=Gt,Nr}function _(O){var N=typeof O;return!!O&&(N=="object"||N=="function")}function de(O){return!!O&&typeof O=="object"}function be(O){return typeof O=="symbol"||de(O)&&h.call(O)==o}function M(O){if(typeof O=="number")return O;if(be(O))return n;if(_(O)){var N=typeof O.valueOf=="function"?O.valueOf():O;O=_(N)?N+"":N}if(typeof O!="string")return O===0?O:+O;O=O.replace(i,"");var ee=s.test(O);return ee||c.test(O)?l(O.slice(2),ee?2:8):a.test(O)?n:+O}t.exports=E}),yn,K,ua,pa,Nt,Pi,fa,ma,da,lo,to,ro,bl,Ar={},ha=[],gl=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,Pr=Array.isArray;function pt(e,t){for(var r in t)e[r]=t[r];return e}function uo(e){e&&e.parentNode&&e.parentNode.removeChild(e)}function Wt(e,t,r){var n,o,i,a={};for(i in t)i=="key"?n=t[i]:i=="ref"?o=t[i]:a[i]=t[i];if(arguments.length>2&&(a.children=arguments.length>3?yn.call(arguments,2):r),typeof e=="function"&&e.defaultProps!=null)for(i in e.defaultProps)a[i]===void 0&&(a[i]=e.defaultProps[i]);return fn(e,a,n,o,null)}function fn(e,t,r,n,o){var i={type:e,props:t,key:r,ref:n,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:o!=null?o:++ua,__i:-1,__u:0};return o==null&&K.vnode!=null&&K.vnode(i),i}function ft(e){return e.children}function at(e,t){this.props=e,this.context=t}function cr(e,t){if(t==null)return e.__?cr(e.__,e.__i+1):null;for(var r;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null)return r.__e;return typeof e.type=="function"?cr(e):null}function va(e){var t,r;if((e=e.__)!=null&&e.__c!=null){for(e.__e=e.__c.base=null,t=0;t<e.__k.length;t++)if((r=e.__k[t])!=null&&r.__e!=null){e.__e=e.__c.base=r.__e;break}return va(e)}}function Ii(e){(!e.__d&&(e.__d=!0)&&Nt.push(e)&&!vn.__r++||Pi!=K.debounceRendering)&&((Pi=K.debounceRendering)||fa)(vn)}function vn(){for(var e,t,r,n,o,i,a,s=1;Nt.length;)Nt.length>s&&Nt.sort(ma),e=Nt.shift(),s=Nt.length,e.__d&&(r=void 0,n=void 0,o=(n=(t=e).__v).__e,i=[],a=[],t.__P&&((r=pt({},n)).__v=n.__v+1,K.vnode&&K.vnode(r),po(t.__P,r,n,t.__n,t.__P.namespaceURI,32&n.__u?[o]:null,i,o!=null?o:cr(n),!!(32&n.__u),a),r.__v=n.__v,r.__.__k[r.__i]=r,_a(i,r,a),n.__e=n.__=null,r.__e!=o&&va(r)));vn.__r=0}function ba(e,t,r,n,o,i,a,s,c,l,u){var p,d,m,h,v,x,w,E=n&&n.__k||ha,_=t.length;for(c=_l(r,t,E,c,_),p=0;p<_;p++)(m=r.__k[p])!=null&&(d=m.__i==-1?Ar:E[m.__i]||Ar,m.__i=p,x=po(e,m,d,o,i,a,s,c,l,u),h=m.__e,m.ref&&d.ref!=m.ref&&(d.ref&&fo(d.ref,null,m),u.push(m.ref,m.__c||h,m)),v==null&&h!=null&&(v=h),(w=!!(4&m.__u))||d.__k===m.__k?c=ga(m,c,e,w):typeof m.type=="function"&&x!==void 0?c=x:h&&(c=h.nextSibling),m.__u&=-7);return r.__e=v,c}function _l(e,t,r,n,o){var i,a,s,c,l,u=r.length,p=u,d=0;for(e.__k=new Array(o),i=0;i<o;i++)(a=t[i])!=null&&typeof a!="boolean"&&typeof a!="function"?(c=i+d,(a=e.__k[i]=typeof a=="string"||typeof a=="number"||typeof a=="bigint"||a.constructor==String?fn(null,a,null,null,null):Pr(a)?fn(ft,{children:a},null,null,null):a.constructor==null&&a.__b>0?fn(a.type,a.props,a.key,a.ref?a.ref:null,a.__v):a).__=e,a.__b=e.__b+1,s=null,(l=a.__i=yl(a,r,c,p))!=-1&&(p--,(s=r[l])&&(s.__u|=2)),s==null||s.__v==null?(l==-1&&(o>u?d--:o<u&&d++),typeof a.type!="function"&&(a.__u|=4)):l!=c&&(l==c-1?d--:l==c+1?d++:(l>c?d--:d++,a.__u|=4))):e.__k[i]=null;if(p)for(i=0;i<u;i++)(s=r[i])!=null&&!(2&s.__u)&&(s.__e==n&&(n=cr(s)),xa(s,s));return n}function ga(e,t,r,n){var o,i;if(typeof e.type=="function"){for(o=e.__k,i=0;o&&i<o.length;i++)o[i]&&(o[i].__=e,t=ga(o[i],t,r,n));return t}e.__e!=t&&(n&&(t&&e.type&&!t.parentNode&&(t=cr(e)),r.insertBefore(e.__e,t||null)),t=e.__e);do t=t&&t.nextSibling;while(t!=null&&t.nodeType==8);return t}function Cr(e,t){return t=t||[],e==null||typeof e=="boolean"||(Pr(e)?e.some(function(r){Cr(r,t)}):t.push(e)),t}function yl(e,t,r,n){var o,i,a,s=e.key,c=e.type,l=t[r],u=l!=null&&(2&l.__u)==0;if(l===null&&e.key==null||u&&s==l.key&&c==l.type)return r;if(n>(u?1:0)){for(o=r-1,i=r+1;o>=0||i<t.length;)if((l=t[a=o>=0?o--:i++])!=null&&!(2&l.__u)&&s==l.key&&c==l.type)return a}return-1}function Ri(e,t,r){t[0]=="-"?e.setProperty(t,r!=null?r:""):e[t]=r==null?"":typeof r!="number"||gl.test(t)?r:r+"px"}function un(e,t,r,n,o){var i,a;e:if(t=="style")if(typeof r=="string")e.style.cssText=r;else{if(typeof n=="string"&&(e.style.cssText=n=""),n)for(t in n)r&&t in r||Ri(e.style,t,"");if(r)for(t in r)n&&r[t]==n[t]||Ri(e.style,t,r[t])}else if(t[0]=="o"&&t[1]=="n")i=t!=(t=t.replace(da,"$1")),a=t.toLowerCase(),t=a in e||t=="onFocusOut"||t=="onFocusIn"?a.slice(2):t.slice(2),e.l||(e.l={}),e.l[t+i]=r,r?n?r.u=n.u:(r.u=lo,e.addEventListener(t,i?ro:to,i)):e.removeEventListener(t,i?ro:to,i);else{if(o=="http://www.w3.org/2000/svg")t=t.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if(t!="width"&&t!="height"&&t!="href"&&t!="list"&&t!="form"&&t!="tabIndex"&&t!="download"&&t!="rowSpan"&&t!="colSpan"&&t!="role"&&t!="popover"&&t in e)try{e[t]=r!=null?r:"";break e}catch(s){}typeof r=="function"||(r==null||r===!1&&t[4]!="-"?e.removeAttribute(t):e.setAttribute(t,t=="popover"&&r==1?"":r))}}function ji(e){return function(t){if(this.l){var r=this.l[t.type+e];if(t.t==null)t.t=lo++;else if(t.t<r.u)return;return r(K.event?K.event(t):t)}}}function po(e,t,r,n,o,i,a,s,c,l){var u,p,d,m,h,v,x,w,E,_,de,be,M,O,N,ee,le,ce=t.type;if(t.constructor!=null)return null;128&r.__u&&(c=!!(32&r.__u),i=[s=t.__e=r.__e]),(u=K.__b)&&u(t);e:if(typeof ce=="function")try{if(w=t.props,E="prototype"in ce&&ce.prototype.render,_=(u=ce.contextType)&&n[u.__c],de=u?_?_.props.value:u.__:n,r.__c?x=(p=t.__c=r.__c).__=p.__E:(E?t.__c=p=new ce(w,de):(t.__c=p=new at(w,de),p.constructor=ce,p.render=wl),_&&_.sub(p),p.props=w,p.state||(p.state={}),p.context=de,p.__n=n,d=p.__d=!0,p.__h=[],p._sb=[]),E&&p.__s==null&&(p.__s=p.state),E&&ce.getDerivedStateFromProps!=null&&(p.__s==p.state&&(p.__s=pt({},p.__s)),pt(p.__s,ce.getDerivedStateFromProps(w,p.__s))),m=p.props,h=p.state,p.__v=t,d)E&&ce.getDerivedStateFromProps==null&&p.componentWillMount!=null&&p.componentWillMount(),E&&p.componentDidMount!=null&&p.__h.push(p.componentDidMount);else{if(E&&ce.getDerivedStateFromProps==null&&w!==m&&p.componentWillReceiveProps!=null&&p.componentWillReceiveProps(w,de),!p.__e&&p.shouldComponentUpdate!=null&&p.shouldComponentUpdate(w,p.__s,de)===!1||t.__v==r.__v){for(t.__v!=r.__v&&(p.props=w,p.state=p.__s,p.__d=!1),t.__e=r.__e,t.__k=r.__k,t.__k.some(function(Ne){Ne&&(Ne.__=t)}),be=0;be<p._sb.length;be++)p.__h.push(p._sb[be]);p._sb=[],p.__h.length&&a.push(p);break e}p.componentWillUpdate!=null&&p.componentWillUpdate(w,p.__s,de),E&&p.componentDidUpdate!=null&&p.__h.push(function(){p.componentDidUpdate(m,h,v)})}if(p.context=de,p.props=w,p.__P=e,p.__e=!1,M=K.__r,O=0,E){for(p.state=p.__s,p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),N=0;N<p._sb.length;N++)p.__h.push(p._sb[N]);p._sb=[]}else do p.__d=!1,M&&M(t),u=p.render(p.props,p.state,p.context),p.state=p.__s;while(p.__d&&++O<25);p.state=p.__s,p.getChildContext!=null&&(n=pt(pt({},n),p.getChildContext())),E&&!d&&p.getSnapshotBeforeUpdate!=null&&(v=p.getSnapshotBeforeUpdate(m,h)),ee=u,u!=null&&u.type===ft&&u.key==null&&(ee=ya(u.props.children)),s=ba(e,Pr(ee)?ee:[ee],t,r,n,o,i,a,s,c,l),p.base=t.__e,t.__u&=-161,p.__h.length&&a.push(p),x&&(p.__E=p.__=null)}catch(Ne){if(t.__v=null,c||i!=null)if(Ne.then){for(t.__u|=c?160:128;s&&s.nodeType==8&&s.nextSibling;)s=s.nextSibling;i[i.indexOf(s)]=null,t.__e=s}else{for(le=i.length;le--;)uo(i[le]);no(t)}else t.__e=r.__e,t.__k=r.__k,Ne.then||no(t);K.__e(Ne,t,r)}else i==null&&t.__v==r.__v?(t.__k=r.__k,t.__e=r.__e):s=t.__e=xl(r.__e,t,r,n,o,i,a,c,l);return(u=K.diffed)&&u(t),128&t.__u?void 0:s}function no(e){e&&e.__c&&(e.__c.__e=!0),e&&e.__k&&e.__k.forEach(no)}function _a(e,t,r){for(var n=0;n<r.length;n++)fo(r[n],r[++n],r[++n]);K.__c&&K.__c(t,e),e.some(function(o){try{e=o.__h,o.__h=[],e.some(function(i){i.call(o)})}catch(i){K.__e(i,o.__v)}})}function ya(e){return typeof e!="object"||e==null||e.__b&&e.__b>0?e:Pr(e)?e.map(ya):pt({},e)}function xl(e,t,r,n,o,i,a,s,c){var l,u,p,d,m,h,v,x=r.props,w=t.props,E=t.type;if(E=="svg"?o="http://www.w3.org/2000/svg":E=="math"?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),i!=null){for(l=0;l<i.length;l++)if((m=i[l])&&"setAttribute"in m==!!E&&(E?m.localName==E:m.nodeType==3)){e=m,i[l]=null;break}}if(e==null){if(E==null)return document.createTextNode(w);e=document.createElementNS(o,E,w.is&&w),s&&(K.__m&&K.__m(t,i),s=!1),i=null}if(E==null)x===w||s&&e.data==w||(e.data=w);else{if(i=i&&yn.call(e.childNodes),x=r.props||Ar,!s&&i!=null)for(x={},l=0;l<e.attributes.length;l++)x[(m=e.attributes[l]).name]=m.value;for(l in x)if(m=x[l],l!="children"){if(l=="dangerouslySetInnerHTML")p=m;else if(!(l in w)){if(l=="value"&&"defaultValue"in w||l=="checked"&&"defaultChecked"in w)continue;un(e,l,null,m,o)}}for(l in w)m=w[l],l=="children"?d=m:l=="dangerouslySetInnerHTML"?u=m:l=="value"?h=m:l=="checked"?v=m:s&&typeof m!="function"||x[l]===m||un(e,l,m,x[l],o);if(u)s||p&&(u.__html==p.__html||u.__html==e.innerHTML)||(e.innerHTML=u.__html),t.__k=[];else if(p&&(e.innerHTML=""),ba(t.type=="template"?e.content:e,Pr(d)?d:[d],t,r,n,E=="foreignObject"?"http://www.w3.org/1999/xhtml":o,i,a,i?i[0]:r.__k&&cr(r,0),s,c),i!=null)for(l=i.length;l--;)uo(i[l]);s||(l="value",E=="progress"&&h==null?e.removeAttribute("value"):h!=null&&(h!==e[l]||E=="progress"&&!h||E=="option"&&h!=x[l])&&un(e,l,h,x[l],o),l="checked",v!=null&&v!=e[l]&&un(e,l,v,x[l],o))}return e}function fo(e,t,r){try{if(typeof e=="function"){var n=typeof e.__u=="function";n&&e.__u(),n&&t==null||(e.__u=e(t))}else e.current=t}catch(o){K.__e(o,r)}}function xa(e,t,r){var n,o;if(K.unmount&&K.unmount(e),(n=e.ref)&&(n.current&&n.current!=e.__e||fo(n,null,t)),(n=e.__c)!=null){if(n.componentWillUnmount)try{n.componentWillUnmount()}catch(i){K.__e(i,t)}n.base=n.__P=null}if(n=e.__k)for(o=0;o<n.length;o++)n[o]&&xa(n[o],t,r||typeof e.type!="function");r||uo(e.__e),e.__c=e.__=e.__e=void 0}function wl(e,t,r){return this.constructor(e,r)}function El(e,t,r){var n,o,i,a;t==document&&(t=document.documentElement),K.__&&K.__(e,t),o=(n=typeof r=="function")?null:r&&r.__k||t.__k,i=[],a=[],po(t,e=(!n&&r||t).__k=Wt(ft,null,[e]),o||Ar,Ar,t.namespaceURI,!n&&r?[r]:o?null:t.firstChild?yn.call(t.childNodes):null,i,!n&&r?r:o?o.__e:t.firstChild,n,a),_a(i,e,a)}yn=ha.slice,K={__e:function(e,t,r,n){for(var o,i,a;t=t.__;)if((o=t.__c)&&!o.__)try{if((i=o.constructor)&&i.getDerivedStateFromError!=null&&(o.setState(i.getDerivedStateFromError(e)),a=o.__d),o.componentDidCatch!=null&&(o.componentDidCatch(e,n||{}),a=o.__d),a)return o.__E=o}catch(s){e=s}throw e}},ua=0,pa=function(e){return e!=null&&e.constructor==null},at.prototype.setState=function(e,t){var r;r=this.__s!=null&&this.__s!=this.state?this.__s:this.__s=pt({},this.state),typeof e=="function"&&(e=e(pt({},r),this.props)),e&&pt(r,e),e!=null&&this.__v&&(t&&this._sb.push(t),Ii(this))},at.prototype.forceUpdate=function(e){this.__v&&(this.__e=!0,e&&this.__h.push(e),Ii(this))},at.prototype.render=ft,Nt=[],fa=typeof Promise=="function"?Promise.prototype.then.bind(Promise.resolve()):setTimeout,ma=function(e,t){return e.__v.__b-t.__v.__b},vn.__r=0,da=/(PointerCapture)$|Capture$/i,lo=0,to=ji(!1),ro=ji(!0),bl=0;var Hr,ve,Zn,Fi,$r=0,wa=[],we=K,Ui=we.__b,Ni=we.__r,Di=we.diffed,Wi=we.__c,Vi=we.unmount,zi=we.__;function mo(e,t){we.__h&&we.__h(ve,e,$r||t),$r=0;var r=ve.__H||(ve.__H={__:[],__h:[]});return e>=r.__.length&&r.__.push({}),r.__[e]}function bn(e){return $r=1,Tl(Ta,e)}function Tl(e,t,r){var n=mo(Hr++,2);if(n.t=e,!n.__c&&(n.__=[r?r(t):Ta(void 0,t),function(s){var c=n.__N?n.__N[0]:n.__[0],l=n.t(c,s);c!==l&&(n.__N=[l,n.__[1]],n.__c.setState({}))}],n.__c=ve,!ve.__f)){var o=function(s,c,l){if(!n.__c.__H)return!0;var u=n.__c.__H.__.filter(function(d){return!!d.__c});if(u.every(function(d){return!d.__N}))return!i||i.call(this,s,c,l);var p=n.__c.props!==s;return u.forEach(function(d){if(d.__N){var m=d.__[0];d.__=d.__N,d.__N=void 0,m!==d.__[0]&&(p=!0)}}),i&&i.call(this,s,c,l)||p};ve.__f=!0;var i=ve.shouldComponentUpdate,a=ve.componentWillUpdate;ve.componentWillUpdate=function(s,c,l){if(this.__e){var u=i;i=void 0,o(s,c,l),i=u}a&&a.call(this,s,c,l)},ve.shouldComponentUpdate=o}return n.__N||n.__}function mt(e,t){var r=mo(Hr++,3);!we.__s&&Ea(r.__H,t)&&(r.__=e,r.u=t,ve.__H.__h.push(r))}function Vt(e){return $r=5,ur(function(){return{current:e}},[])}function ur(e,t){var r=mo(Hr++,7);return Ea(r.__H,t)&&(r.__=e(),r.__H=t,r.__h=e),r.__}function Sl(e,t){return $r=8,ur(function(){return e},t)}function Ol(){for(var e;e=wa.shift();)if(e.__P&&e.__H)try{e.__H.__h.forEach(mn),e.__H.__h.forEach(oo),e.__H.__h=[]}catch(t){e.__H.__h=[],we.__e(t,e.__v)}}we.__b=function(e){ve=null,Ui&&Ui(e)},we.__=function(e,t){e&&t.__k&&t.__k.__m&&(e.__m=t.__k.__m),zi&&zi(e,t)},we.__r=function(e){Ni&&Ni(e),Hr=0;var t=(ve=e.__c).__H;t&&(Zn===ve?(t.__h=[],ve.__h=[],t.__.forEach(function(r){r.__N&&(r.__=r.__N),r.u=r.__N=void 0})):(t.__h.forEach(mn),t.__h.forEach(oo),t.__h=[],Hr=0)),Zn=ve},we.diffed=function(e){Di&&Di(e);var t=e.__c;t&&t.__H&&(t.__H.__h.length&&(wa.push(t)!==1&&Fi===we.requestAnimationFrame||((Fi=we.requestAnimationFrame)||Ll)(Ol)),t.__H.__.forEach(function(r){r.u&&(r.__H=r.u),r.u=void 0})),Zn=ve=null},we.__c=function(e,t){t.some(function(r){try{r.__h.forEach(mn),r.__h=r.__h.filter(function(n){return!n.__||oo(n)})}catch(n){t.some(function(o){o.__h&&(o.__h=[])}),t=[],we.__e(n,r.__v)}}),Wi&&Wi(e,t)},we.unmount=function(e){Vi&&Vi(e);var t,r=e.__c;r&&r.__H&&(r.__H.__.forEach(function(n){try{mn(n)}catch(o){t=o}}),r.__H=void 0,t&&we.__e(t,r.__v))};var qi=typeof requestAnimationFrame=="function";function Ll(e){var t,r=function(){clearTimeout(n),qi&&cancelAnimationFrame(t),setTimeout(e)},n=setTimeout(r,35);qi&&(t=requestAnimationFrame(r))}function mn(e){var t=ve,r=e.__c;typeof r=="function"&&(e.__c=void 0,r()),ve=t}function oo(e){var t=ve;e.__c=e.__(),ve=t}function Ea(e,t){return!e||e.length!==t.length||t.some(function(r,n){return r!==e[n]})}function Ta(e,t){return typeof t=="function"?t(e):t}function Ml(e,t){for(var r in t)e[r]=t[r];return e}function Ki(e,t){for(var r in e)if(r!=="__source"&&!(r in t))return!0;for(var n in t)if(n!=="__source"&&e[n]!==t[n])return!0;return!1}function Bi(e,t){this.props=e,this.context=t}(Bi.prototype=new at).isPureReactComponent=!0,Bi.prototype.shouldComponentUpdate=function(e,t){return Ki(this.props,e)||Ki(this.state,t)};var Yi=K.__b;K.__b=function(e){e.type&&e.type.__f&&e.ref&&(e.props.ref=e.ref,e.ref=null),Yi&&Yi(e)};var Yx=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.forward_ref")||3911,kl=K.__e;K.__e=function(e,t,r,n){if(e.then){for(var o,i=t;i=i.__;)if((o=i.__c)&&o.__c)return t.__e==null&&(t.__e=r.__e,t.__k=r.__k),o.__c(e,t)}kl(e,t,r,n)};var Gi=K.unmount;function Sa(e,t,r){return e&&(e.__c&&e.__c.__H&&(e.__c.__H.__.forEach(function(n){typeof n.__c=="function"&&n.__c()}),e.__c.__H=null),(e=Ml({},e)).__c!=null&&(e.__c.__P===r&&(e.__c.__P=t),e.__c.__e=!0,e.__c=null),e.__k=e.__k&&e.__k.map(function(n){return Sa(n,t,r)})),e}function Oa(e,t,r){return e&&r&&(e.__v=null,e.__k=e.__k&&e.__k.map(function(n){return Oa(n,t,r)}),e.__c&&e.__c.__P===t&&(e.__e&&r.appendChild(e.__e),e.__c.__e=!0,e.__c.__P=r)),e}function Qn(){this.__u=0,this.o=null,this.__b=null}function La(e){var t=e.__.__c;return t&&t.__a&&t.__a(e)}function pn(){this.i=null,this.l=null}K.unmount=function(e){var t=e.__c;t&&t.__R&&t.__R(),t&&32&e.__u&&(e.type=null),Gi&&Gi(e)},(Qn.prototype=new at).__c=function(e,t){var r=t.__c,n=this;n.o==null&&(n.o=[]),n.o.push(r);var o=La(n.__v),i=!1,a=function(){i||(i=!0,r.__R=null,o?o(s):s())};r.__R=a;var s=function(){if(!--n.__u){if(n.state.__a){var c=n.state.__a;n.__v.__k[0]=Oa(c,c.__c.__P,c.__c.__O)}var l;for(n.setState({__a:n.__b=null});l=n.o.pop();)l.forceUpdate()}};n.__u++||32&t.__u||n.setState({__a:n.__b=n.__v.__k[0]}),e.then(a,a)},Qn.prototype.componentWillUnmount=function(){this.o=[]},Qn.prototype.render=function(e,t){if(this.__b){if(this.__v.__k){var r=document.createElement("div"),n=this.__v.__k[0].__c;this.__v.__k[0]=Sa(this.__b,r,n.__O=n.__P)}this.__b=null}var o=t.__a&&Wt(ft,null,e.fallback);return o&&(o.__u&=-33),[Wt(ft,null,t.__a?null:e.children),o]};var Ji=function(e,t,r){if(++r[1]===r[0]&&e.l.delete(t),e.props.revealOrder&&(e.props.revealOrder[0]!=="t"||!e.l.size))for(r=e.i;r;){for(;r.length>3;)r.pop()();if(r[1]<r[0])break;e.i=r=r[2]}};(pn.prototype=new at).__a=function(e){var t=this,r=La(t.__v),n=t.l.get(e);return n[0]++,function(o){var i=function(){t.props.revealOrder?(n.push(o),Ji(t,e,n)):o()};r?r(i):i()}},pn.prototype.render=function(e){this.i=null,this.l=new Map;var t=Cr(e.children);e.revealOrder&&e.revealOrder[0]==="b"&&t.reverse();for(var r=t.length;r--;)this.l.set(t[r],this.i=[1,0,this.i]);return e.children},pn.prototype.componentDidUpdate=pn.prototype.componentDidMount=function(){var e=this;this.l.forEach(function(t,r){Ji(e,r,t)})};var Al=typeof Symbol<"u"&&Symbol.for&&Symbol.for("react.element")||60103,Cl=/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/,Hl=/^on(Ani|Tra|Tou|BeforeInp|Compo)/,$l=/[A-Z0-9]/g,Pl=typeof document<"u",Il=function(e){return(typeof Symbol<"u"&&typeof Symbol()=="symbol"?/fil|che|rad/:/fil|che|ra/).test(e)};at.prototype.isReactComponent={},["componentWillMount","componentWillReceiveProps","componentWillUpdate"].forEach(function(e){Object.defineProperty(at.prototype,e,{configurable:!0,get:function(){return this["UNSAFE_"+e]},set:function(t){Object.defineProperty(this,e,{configurable:!0,writable:!0,value:t})}})});var Xi=K.event;function Rl(){}function jl(){return this.cancelBubble}function Fl(){return this.defaultPrevented}K.event=function(e){return Xi&&(e=Xi(e)),e.persist=Rl,e.isPropagationStopped=jl,e.isDefaultPrevented=Fl,e.nativeEvent=e};var Ma,Ul={enumerable:!1,configurable:!0,get:function(){return this.class}},Zi=K.vnode;K.vnode=function(e){typeof e.type=="string"&&(function(t){var r=t.props,n=t.type,o={},i=n.indexOf("-")===-1;for(var a in r){var s=r[a];if(!(a==="value"&&"defaultValue"in r&&s==null||Pl&&a==="children"&&n==="noscript"||a==="class"||a==="className")){var c=a.toLowerCase();a==="defaultValue"&&"value"in r&&r.value==null?a="value":a==="download"&&s===!0?s="":c==="translate"&&s==="no"?s=!1:c[0]==="o"&&c[1]==="n"?c==="ondoubleclick"?a="ondblclick":c!=="onchange"||n!=="input"&&n!=="textarea"||Il(r.type)?c==="onfocus"?a="onfocusin":c==="onblur"?a="onfocusout":Hl.test(a)&&(a=c):c=a="oninput":i&&Cl.test(a)?a=a.replace($l,"-$&").toLowerCase():s===null&&(s=void 0),c==="oninput"&&o[a=c]&&(a="oninputCapture"),o[a]=s}}n=="select"&&o.multiple&&Array.isArray(o.value)&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.value.indexOf(l.props.value)!=-1})),n=="select"&&o.defaultValue!=null&&(o.value=Cr(r.children).forEach(function(l){l.props.selected=o.multiple?o.defaultValue.indexOf(l.props.value)!=-1:o.defaultValue==l.props.value})),r.class&&!r.className?(o.class=r.class,Object.defineProperty(o,"className",Ul)):(r.className&&!r.class||r.class&&r.className)&&(o.class=o.className=r.className),t.props=o})(e),e.$$typeof=Al,Zi&&Zi(e)};var Qi=K.__r;K.__r=function(e){Qi&&Qi(e),Ma=e.__c};var ea=K.diffed;K.diffed=function(e){ea&&ea(e);var t=e.props,r=e.__e;r!=null&&e.type==="textarea"&&"value"in t&&t.value!==r.value&&(r.value=t.value==null?"":t.value),Ma=null};function ka(e){let t=Vt(e);return t.current=e,ur(()=>Object.freeze({get current(){return t.current}}),[])}var Nl=typeof globalThis<"u"&&typeof navigator<"u"&&typeof document<"u";function Dl(e,...t){var r;(r=e==null?void 0:e.addEventListener)==null||r.call(e,...t)}function Wl(e,...t){var r;(r=e==null?void 0:e.removeEventListener)==null||r.call(e,...t)}var Vl=(e,t)=>Object.hasOwn(e,t),zl=()=>!0,ql=()=>!1;function Kl(e=!1){let t=Vt(e),r=Sl(()=>t.current,[]);return mt(()=>(t.current=!0,()=>{t.current=!1}),[]),r}function Bl(e,...t){let r=Kl(),n=ka(t[1]),o=ur(()=>function(...i){r()&&(typeof n.current=="function"?n.current.apply(this,i):typeof n.current.handleEvent=="function"&&n.current.handleEvent.apply(this,i))},[]);mt(()=>{let i=Yl(e)?e.current:e;if(!i)return;let a=t.slice(2);return Dl(i,t[0],o,...a),()=>{Wl(i,t[0],o,...a)}},[e,t[0]])}function Yl(e){return e!==null&&typeof e=="object"&&Vl(e,"current")}var Gl=e=>typeof e=="function"?e:typeof e=="string"?t=>t.key===e:e?zl:ql,Jl=Nl?globalThis:null;function Aa(e,t,r=[],n={}){let{event:o="keydown",target:i=Jl,eventOptions:a}=n,s=ka(t),c=ur(()=>{let l=Gl(e);return function(u){l(u)&&s.current.call(this,u)}},r);Bl(i,o,c,a)}function Ca(e){var t,r,n="";if(typeof e=="string"||typeof e=="number")n+=e;else if(typeof e=="object")if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(r=Ca(e[t]))&&(n&&(n+=" "),n+=r)}else for(r in e)e[r]&&(n&&(n+=" "),n+=r);return n}function Xl(){for(var e,t,r=0,n="",o=arguments.length;r<o;r++)(e=arguments[r])&&(t=Ca(e))&&(n&&(n+=" "),n+=t);return n}var zt=Xl,Zl=Symbol.for("preact-signals");function xn(){if(St>1)St--;else{for(var e,t=!1;kr!==void 0;){var r=kr;for(kr=void 0,io++;r!==void 0;){var n=r.o;if(r.o=void 0,r.f&=-3,!(8&r.f)&&Pa(r))try{r.c()}catch(o){t||(e=o,t=!0)}r=n}}if(io=0,St--,t)throw e}}function Ql(e){if(St>0)return e();St++;try{return e()}finally{xn()}}var ae=void 0;function Ha(e){var t=ae;ae=void 0;try{return e()}finally{ae=t}}var kr=void 0,St=0,io=0,gn=0;function $a(e){if(ae!==void 0){var t=e.n;if(t===void 0||t.t!==ae)return t={i:0,S:e,p:ae.s,n:void 0,t:ae,e:void 0,x:void 0,r:t},ae.s!==void 0&&(ae.s.n=t),ae.s=t,e.n=t,32&ae.f&&e.S(t),t;if(t.i===-1)return t.i=0,t.n!==void 0&&(t.n.p=t.p,t.p!==void 0&&(t.p.n=t.n),t.p=ae.s,t.n=void 0,ae.s.n=t,ae.s=t),t}}function Ce(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Ce.prototype.brand=Zl;Ce.prototype.h=function(){return!0};Ce.prototype.S=function(e){var t=this,r=this.t;r!==e&&e.e===void 0&&(e.x=r,this.t=e,r!==void 0?r.e=e:Ha(function(){var n;(n=t.W)==null||n.call(t)}))};Ce.prototype.U=function(e){var t=this;if(this.t!==void 0){var r=e.e,n=e.x;r!==void 0&&(r.x=n,e.e=void 0),n!==void 0&&(n.e=r,e.x=void 0),e===this.t&&(this.t=n,n===void 0&&Ha(function(){var o;(o=t.Z)==null||o.call(t)}))}};Ce.prototype.subscribe=function(e){var t=this;return qt(function(){var r=t.value,n=ae;ae=void 0;try{e(r)}finally{ae=n}},{name:"sub"})};Ce.prototype.valueOf=function(){return this.value};Ce.prototype.toString=function(){return this.value+""};Ce.prototype.toJSON=function(){return this.value};Ce.prototype.peek=function(){var e=ae;ae=void 0;try{return this.value}finally{ae=e}};Object.defineProperty(Ce.prototype,"value",{get:function(){var e=$a(this);return e!==void 0&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(io>100)throw new Error("Cycle detected");this.v=e,this.i++,gn++,St++;try{for(var t=this.t;t!==void 0;t=t.x)t.t.N()}finally{xn()}}}});function Ot(e,t){return new Ce(e,t)}function Pa(e){for(var t=e.s;t!==void 0;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function Ia(e){for(var t=e.s;t!==void 0;t=t.n){var r=t.S.n;if(r!==void 0&&(t.r=r),t.S.n=t,t.i=-1,t.n===void 0){e.s=t;break}}}function Ra(e){for(var t=e.s,r=void 0;t!==void 0;){var n=t.p;t.i===-1?(t.S.U(t),n!==void 0&&(n.n=t.n),t.n!==void 0&&(t.n.p=n)):r=t,t.S.n=t.r,t.r!==void 0&&(t.r=void 0),t=n}e.s=r}function Kt(e,t){Ce.call(this,void 0),this.x=e,this.s=void 0,this.g=gn-1,this.f=4,this.W=t==null?void 0:t.watched,this.Z=t==null?void 0:t.unwatched,this.name=t==null?void 0:t.name}Kt.prototype=new Ce;Kt.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if((36&this.f)==32||(this.f&=-5,this.g===gn))return!0;if(this.g=gn,this.f|=1,this.i>0&&!Pa(this))return this.f&=-2,!0;var e=ae;try{Ia(this),ae=this;var t=this.x();(16&this.f||this.v!==t||this.i===0)&&(this.v=t,this.f&=-17,this.i++)}catch(r){this.v=r,this.f|=16,this.i++}return ae=e,Ra(this),this.f&=-2,!0};Kt.prototype.S=function(e){if(this.t===void 0){this.f|=36;for(var t=this.s;t!==void 0;t=t.n)t.S.S(t)}Ce.prototype.S.call(this,e)};Kt.prototype.U=function(e){if(this.t!==void 0&&(Ce.prototype.U.call(this,e),this.t===void 0)){this.f&=-33;for(var t=this.s;t!==void 0;t=t.n)t.S.U(t)}};Kt.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;e!==void 0;e=e.x)e.t.N()}};Object.defineProperty(Kt.prototype,"value",{get:function(){if(1&this.f)throw new Error("Cycle detected");var e=$a(this);if(this.h(),e!==void 0&&(e.i=this.i),16&this.f)throw this.v;return this.v}});function ta(e,t){return new Kt(e,t)}function ja(e){var t=e.u;if(e.u=void 0,typeof t=="function"){St++;var r=ae;ae=void 0;try{t()}catch(n){throw e.f&=-2,e.f|=8,ho(e),n}finally{ae=r,xn()}}}function ho(e){for(var t=e.s;t!==void 0;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,ja(e)}function eu(e){if(ae!==this)throw new Error("Out-of-order effect");Ra(this),ae=e,this.f&=-2,8&this.f&&ho(this),xn()}function pr(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=t==null?void 0:t.name}pr.prototype.c=function(){var e=this.S();try{if(8&this.f||this.x===void 0)return;var t=this.x();typeof t=="function"&&(this.u=t)}finally{e()}};pr.prototype.S=function(){if(1&this.f)throw new Error("Cycle detected");this.f|=1,this.f&=-9,ja(this),Ia(this),St++;var e=ae;return ae=this,eu.bind(this,e)};pr.prototype.N=function(){2&this.f||(this.f|=2,this.o=kr,kr=this)};pr.prototype.d=function(){this.f|=8,1&this.f||ho(this)};pr.prototype.dispose=function(){this.d()};function qt(e,t){var r=new pr(e,t);try{r.c()}catch(o){throw r.d(),o}var n=r.d.bind(r);return n[Symbol.dispose]=n,n}var Fa,vo,eo,Ua=[];qt(function(){Fa=this.N})();function fr(e,t){K[e]=t.bind(null,K[e]||function(){})}function _n(e){eo&&eo(),eo=e&&e.S()}function Na(e){var t=this,r=e.data,n=ru(r);n.value=r;var o=ur(function(){for(var s=t,c=t.__v;c=c.__;)if(c.__c){c.__c.__$f|=4;break}var l=ta(function(){var m=n.value.value;return m===0?0:m===!0?"":m||""}),u=ta(function(){return!Array.isArray(l.value)&&!pa(l.value)}),p=qt(function(){if(this.N=Da,u.value){var m=l.value;s.__v&&s.__v.__e&&s.__v.__e.nodeType===3&&(s.__v.__e.data=m)}}),d=t.__$u.d;return t.__$u.d=function(){p(),d.call(this)},[u,l]},[]),i=o[0],a=o[1];return i.value?a.peek():a.value}Na.displayName="ReactiveTextNode";Object.defineProperties(Ce.prototype,{constructor:{configurable:!0,value:void 0},type:{configurable:!0,value:Na},props:{configurable:!0,get:function(){return{data:this}}},__b:{configurable:!0,value:1}});fr("__b",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),typeof t.type=="string"){var r,n=t.props;for(var o in n)if(o!=="children"){var i=n[o];i instanceof Ce&&(r||(t.__np=r={}),r[o]=i,n[o]=i.peek())}}e(t)});fr("__r",function(e,t){if(typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.enterComponent(t),t.type!==ft){_n();var r,n=t.__c;n&&(n.__$f&=-2,(r=n.__$u)===void 0&&(n.__$u=r=(function(o){var i;return qt(function(){i=this}),i.c=function(){n.__$f|=1,n.setState({})},i})())),vo=n,_n(r)}e(t)});fr("__e",function(e,t,r,n){typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0,e(t,r,n)});fr("diffed",function(e,t){typeof t.type=="function"&&typeof window<"u"&&window.__PREACT_SIGNALS_DEVTOOLS__&&window.__PREACT_SIGNALS_DEVTOOLS__.exitComponent(),_n(),vo=void 0;var r;if(typeof t.type=="string"&&(r=t.__e)){var n=t.__np,o=t.props;if(n){var i=r.U;if(i)for(var a in i){var s=i[a];s!==void 0&&!(a in n)&&(s.d(),i[a]=void 0)}else i={},r.U=i;for(var c in n){var l=i[c],u=n[c];l===void 0?(l=tu(r,c,u,o),i[c]=l):l.o(u,o)}}}e(t)});function tu(e,t,r,n){var o=t in e&&e.ownerSVGElement===void 0,i=Ot(r);return{o:function(a,s){i.value=a,n=s},d:qt(function(){this.N=Da;var a=i.value.value;n[t]!==a&&(n[t]=a,o?e[t]=a:a?e.setAttribute(t,a):e.removeAttribute(t))})}}fr("unmount",function(e,t){if(typeof t.type=="string"){var r=t.__e;if(r){var n=r.U;if(n){r.U=void 0;for(var o in n){var i=n[o];i&&i.d()}}}}else{var a=t.__c;if(a){var s=a.__$u;s&&(a.__$u=void 0,s.d())}}e(t)});fr("__h",function(e,t,r,n){(n<3||n===9)&&(t.__$f|=2),e(t,r,n)});at.prototype.shouldComponentUpdate=function(e,t){var r=this.__$u,n=r&&r.s!==void 0;for(var o in t)return!0;if(this.__f||typeof this.u=="boolean"&&this.u===!0){var i=2&this.__$f;if(!(n||i||4&this.__$f)||1&this.__$f)return!0}else if(!(n||4&this.__$f)||3&this.__$f)return!0;for(var a in e)if(a!=="__source"&&e[a]!==this.props[a])return!0;for(var s in this.props)if(!(s in e))return!0;return!1};function ru(e,t){return bn(function(){return Ot(e,t)})[0]}var nu=function(e){queueMicrotask(function(){queueMicrotask(e)})};function ou(){Ql(function(){for(var e;e=Ua.shift();)Fa.call(e)})}function Da(){Ua.push(this)===1&&(K.requestAnimationFrame||nu)(ou)}var ao=[0];for(let e=0;e<32;e++)ao.push(ao[e]|1<<e);function iu(e){return new Uint32Array(e)}var ra=class{constructor(e,t=iu(Math.ceil(e/32))){this.size=e,this.data=t}get(e){return this.data[e>>>5]>>>e&1}set(e){this.data[e>>>5]|=1<<(e&31)}forEach(e){let t=this.size&31;for(let r=0;r<this.data.length;r++){if(this.data[r]===0)continue;let n=this.data[r];t&&r===this.data.length-1&&(n=n&ao[t]);for(let o=0,i=32-Math.clz32(n);o<i;o++)n&1<<o&&e((r<<5)+o)}}};function au(e){lr.value=e,e.items.find(t=>{var r;return(r=t.tags)==null?void 0:r.length})&&(matchMedia("(max-width: 768px)").matches||Wa())}function Dt(){Qe.value=He(H({},Qe.value),{hideSearch:!Qe.value.hideSearch})}function Wa(){Qe.value=He(H({},Qe.value),{hideFilters:!Qe.value.hideFilters})}function dn(){return Qe.value.selectedItem}function so(e){Qe.value=He(H({},Qe.value),{selectedItem:e})}function su(){var e,t;return(t=(e=lr.value)==null?void 0:e.items)!=null?t:[]}function wn(){return typeof Se.value.input=="string"?Se.value.input:""}function Va(e){let t=za();e.length&&!t.length?Se.value=He(H({},Se.value),{page:void 0,input:e}):!e.length&&t.length?Se.value=He(H({},Se.value),{page:void 0,input:{type:"operator",data:{operator:"not",operands:[]}}}):Se.value=He(H({},Se.value),{page:void 0,input:e})}function cu(){typeof it.value.pagination.next<"u"&&(Se.value=He(H({},Se.value),{page:it.value.pagination.next}))}function lu(e){let t=Se.value.filter.input;if("type"in t&&t.type==="operator"){for(let r of t.data.operands)if("type"in r&&r.type==="value"&&typeof r.data.value=="string"&&r.data.value===e)return!0}return!1}function za(){let e=Se.value.filter.input,t=[];if("type"in e&&e.type==="operator")for(let r of e.data.operands)"type"in r&&r.type==="value"&&typeof r.data.value=="string"&&t.push(r.data.value);return t}function uu(e){let t=Se.value.filter.input,r=[];if("type"in t&&t.type==="operator")for(let n of t.data.operands)"type"in n&&n.type==="value"&&typeof n.data.value=="string"&&r.push(n.data.value);if(r.includes(e)){let n=r.indexOf(e);n>-1&&r.splice(n,1)}else r.push(e);Se.value=He(H({},Se.value),{page:void 0,filter:He(H({},Se.value.filter),{input:{type:"operator",data:{operator:"and",operands:r.map(n=>({type:"value",data:{field:"tags",value:n}}))}}})}),Va(wn())}function pu(){return it.value.items}function fu(){return it.value.total}function mu(){var e;for(let t of(e=it.value.aggregations)!=null?e:[])if(t.type==="term")return t.data.value;return[]}function sr(){return Qe.value.hideSearch}function du(){return Qe.value.hideFilters}function qa(){var e;return(e=Ka.value.highlight)!=null?e:!1}var Qe=Ot({hideSearch:!0,hideFilters:!0,selectedItem:0}),Ka=Ot({}),lr=Ot(),na=Ot(),Se=Ot({input:"",filter:{input:{type:"operator",data:{operator:"and",operands:[]}},aggregation:{input:[{type:"term",data:{field:"tags"}}]}}}),it=Ot({items:[],query:{select:{documents:new ra(0),terms:new ra(0)},values:[]},pagination:{total:0}});function hu(e,t,r){for(let n=0;t<r;){switch(n=n<<8^32|e.charCodeAt(++t),n){case 97:case 98:case 99:case 101:case 104:case 105:case 108:case 109:case 112:case 115:case 116:case 119:case 24946:case 25185:case 25455:case 25965:case 26989:case 26990:case 27753:case 28005:case 28769:case 29551:case 29810:case 30562:case 6386277:case 6447475:case 6647138:case 6909552:case 7104878:case 7169396:case 7364978:case 7565173:case 7631457:case 1701667429:case 1768845429:case 1869967971:case 1885434465:case 1936684402:case 1953653091:continue;case 25202:case 26738:case 6516588:case 6909287:case 7823986:case 1634885997:case 1634887009:case 1650553701:case 1818848875:case 1835165028:case 1835365473:case 1852863860:case 1918985067:case 1970430821:switch(e.charCodeAt(++t)){case 9:case 10:case 32:case 47:case 62:return!0}}break}return!1}function vu(e,t,r=0,n=e.length){let o=0,i=r;for(let a=0;i<n;i++)switch(a=e.charCodeAt(i),a){case 60:i>r&&t(0,o,r,r=i);continue;case 62:e.charCodeAt(r+1)===47?t(2,--o,r,r=i+1):hu(e,r,n)?t(3,o,r,r=i+1):t(1,o++,r,r=i+1)}i>r&&t(0,o,r,i)}function bu(e,t=0,r=e.length){let n=++t;e:for(let l=0;n<r;n++)switch(l=e.charCodeAt(n),l){case 9:case 10:case 32:case 62:break e}let o=e.slice(t,t=n),i=[],a=0,s=0,c=0;for(let l=0;n<r;n++){let u=e.charCodeAt(n);switch(a){case 0:switch(u){case 9:case 10:case 32:t===n?t++:(s=1,a=1);break;case 61:s=1,a=2;break;case 47:t++;case 62:t<n&&(s=1);break}break;case 1:switch(u){case 9:case 10:case 32:continue;case 61:a=2,t=n+1;continue;default:a=0,t=n,l++}continue;case 2:switch(u){case 9:case 10:case 32:t===n?t++:c===0&&(s=2,a=0);break;case 34:case 39:switch(c){case 0:c=u,t=n+1;continue;case u:s=2,a=0,c=0}break;case 62:t<n&&(s=2);break}}switch(s){case 1:i[l]=[e.slice(t,n),""],s=0,t=n+1;break;case 2:i[l++][1]=e.slice(t,n),s=0,t=n+1;break}}return{tag:o,attrs:i.length?Object.fromEntries(i):null}}function gu(e,t,r){return e.slice(t,r)}function _u(e){return(t,r,n,o)=>{let i=[],a=[],{onElement:s,onText:c=gu}=typeof r=="function"?{onElement:r}:r,l=0,u=0;return e(t,(p,d,m,h)=>{if(p===0)i[l++]=c(t,m,h),a[u++]={value:null,depth:d};else if(p&1&&(a[u++]={value:bu(t,m,h),depth:d}),p&2)for(let v=0;u>=0;v++){let{value:x,depth:w}=a[--u];if(w>d)continue;let E=i.slice(l-=v,l+v);i[l++]=s(x,E),u++;break}},n,o),i.slice(0,l)}}function yu(e){return e.replace(/[&<>]/g,t=>{switch(t.charCodeAt(0)){case 38:return"&amp;";case 60:return"&lt;";case 62:return"&gt;"}})}function hn(e){return e.replace(/&(amp|[lg]t);/g,t=>{switch(t.charCodeAt(1)){case 97:return"&";case 108:return"<";case 103:return">"}})}function xu(e,t){return{start:e.start+t,end:e.end+t,value:e.value}}function wu(e,t,r){return e.slice(t,r)}function Eu(e){let{onHighlight:t,onText:r=wu}=typeof e=="function"?{onHighlight:e}:e;return(n,o,i=0,a=n.length)=>{var l;let s=[],c=(l=o==null?void 0:o.ranges)!=null?l:[];for(let u=0,p=i;u<c.length;u++){let d=c[u].start;if(d>a)break;let m=c[u].end;if(m<p)continue;d=Math.max(d,i),m=Math.min(m,a),d>i&&s.push(r(n,i,d));let{value:h}=c[u];s.push(t(n,{start:d,end:i=m,value:h}))}return i<a&&s.push(r(n,i,a)),s}}var Tu={fuzzy:"v"},Su=0;function z(e,t,r,n,o,i){t||(t={});var a,s,c=t;if("ref"in c)for(s in c={},t)s=="ref"?a=t[s]:c[s]=t[s];var l={type:e,props:c,key:r,ref:a,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:--Su,__i:-1,__u:0,__source:o,__self:i};if(typeof e=="function"&&(a=e.defaultProps))for(s in a)c[s]===void 0&&(c[s]=a[s]);return K.vnode&&K.vnode(l),l}var Ou=_u(vu),Lu=Eu({onText(e,t,r){return hn(e.slice(t,r))},onHighlight(e,{start:t,end:r,value:n}){let o=Math.min(r,t+n);return t===r?null:(n===-1&&(o=r),z("mark",{className:zt({[Tu.fuzzy]:n===-1}),children:[z("u",{children:hn(e.slice(t,o))}),hn(e.slice(o,r))]}))}});function Ba(e,t){let r=Ou(e,{onElement(n,o){return Wt(n.tag,n.attrs,...o)},onText(n,o,i){return Lu(n,t==null?void 0:t.value.highlight,o,i)}});return z(ft,{children:r})}function Mu(e,t){var n;let r=[];for(let o=0,i=0;o<e.length;o++){let a=[];if((n=t==null?void 0:t.value.highlight)!=null&&n.ranges)for(let s of t.value.highlight.ranges)a.push(xu(s,-i));r.push(Ba(e[o],He(H({},t),{value:He(H({},t==null?void 0:t.value),{highlight:{ranges:a}})}))),i+=e[o].length}return r}function Ya(e,t={highlight:!0}){Ka.value=t;let r=new Worker(e);r.onmessage=n=>{let o=n.data;switch(o.type){case 1:na.value=!0;break;case 3:typeof o.data.pagination.prev<"u"?it.value=He(H({},it.value),{pagination:o.data.pagination,items:[...it.value.items,...o.data.items]}):(it.value=o.data,so(0));break}},qt(()=>{lr.value&&r.postMessage({type:0,data:lr.value})}),qt(()=>{na.value&&r.postMessage({type:2,data:Se.value})})}var oa={container:"p",hidden:"m"};function ku(e){return z("div",{class:zt(oa.container,{[oa.hidden]:e.hidden}),onClick:()=>Dt()})}var ia={container:"r",disabled:"c"};function co(e){return z("button",{class:zt(ia.container,{[ia.disabled]:!e.onClick}),onClick:e.onClick,children:e.children})}var aa=e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").toLowerCase(),Au=e=>e.replace(/^([A-Z])|[\s-_]+(\w)/g,(t,r,n)=>n?n.toUpperCase():r.toLowerCase()),sa=e=>{let t=Au(e);return t.charAt(0).toUpperCase()+t.slice(1)},Cu=(...e)=>e.filter((t,r,n)=>!!t&&t.trim()!==""&&n.indexOf(t)===r).join(" ").trim(),Hu={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":"2","stroke-linecap":"round","stroke-linejoin":"round"},$u=c=>{var l=c,{color:e="currentColor",size:t=24,strokeWidth:r=2,absoluteStrokeWidth:n,children:o,iconNode:i,class:a=""}=l,s=gr(l,["color","size","strokeWidth","absoluteStrokeWidth","children","iconNode","class"]);return Wt("svg",H(He(H({},Hu),{width:String(t),height:t,stroke:e,"stroke-width":n?Number(r)*24/Number(t):r,class:["lucide",a].join(" ")}),s),[...i.map(([u,p])=>Wt(u,p)),...Cr(o)])},bo=(e,t)=>{let r=a=>{var s=a,{class:n="",children:o}=s,i=gr(s,["class","children"]);return Wt($u,He(H({},i),{iconNode:t,class:Cu(`lucide-${aa(sa(e))}`,`lucide-${aa(e)}`,n)}),o)};return r.displayName=sa(e),r},Pu=bo("corner-down-left",[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4",key:"6o5b7l"}],["path",{d:"m9 10-5 5 5 5",key:"1kshq7"}]]),Iu=bo("list-filter",[["path",{d:"M2 5h20",key:"1fs1ex"}],["path",{d:"M6 12h12",key:"8npq4p"}],["path",{d:"M9 19h6",key:"456am0"}]]),Ru=bo("search",[["path",{d:"m21 21-4.34-4.34",key:"14j7rj"}],["circle",{cx:"11",cy:"11",r:"8",key:"4ej97u"}]]),Gx=hl(vl(),1);function ju({threshold:e=0,root:t=null,rootMargin:r="0%",freezeOnceVisible:n=!1,initialIsIntersecting:o=!1,onChange:i}={}){var a;let[s,c]=bn(null),[l,u]=bn(()=>({isIntersecting:o,entry:void 0})),p=Vt();p.current=i;let d=((a=l.entry)==null?void 0:a.isIntersecting)&&n;mt(()=>{if(!s||!("IntersectionObserver"in window)||d)return;let v,x=new IntersectionObserver(w=>{let E=Array.isArray(x.thresholds)?x.thresholds:[x.thresholds];w.forEach(_=>{let de=_.isIntersecting&&E.some(be=>_.intersectionRatio>=be);u({isIntersecting:de,entry:_}),p.current&&p.current(de,_),de&&n&&v&&(v(),v=void 0)})},{threshold:e,root:t,rootMargin:r});return x.observe(s),()=>{x.disconnect()}},[s,JSON.stringify(e),t,r,d,n]);let m=Vt(null);mt(()=>{var v;!s&&(v=l.entry)!=null&&v.target&&!n&&!d&&m.current!==l.entry.target&&(m.current=l.entry.target,u({isIntersecting:o,entry:void 0}))},[s,l.entry,n,d,o]);let h=[c,!!l.isIntersecting,l.entry];return h.ref=h[0],h.isIntersecting=h[1],h.entry=h[2],h}var lt={container:"n",hidden:"l",content:"u",pop:"d",badge:"y",sidebar:"i",controls:"w",results:"k",loadmore:"z"};function Fu(e){let{isIntersecting:t,ref:r}=ju({threshold:0});mt(()=>{t&&cu()},[t]);let n=Vt(null);mt(()=>{n.current&&typeof Se.value.page>"u"&&n.current.scrollTo({top:0,behavior:"smooth"})},[Se.value]);let o=za();return z("div",{class:zt(lt.container,{[lt.hidden]:e.hidden}),children:[z("div",{class:lt.content,children:[z("div",{class:lt.controls,children:[z(co,{onClick:Dt,children:z(Ru,{})}),z(Nu,{focus:!e.hidden}),z(co,{onClick:Wa,children:[z(Iu,{}),o.length>0&&z("span",{class:lt.badge,children:o.length})]})]}),z("div",{class:lt.results,ref:n,children:[z(Du,{keyboard:!e.hidden}),z("div",{class:lt.loadmore,ref:r})]})]}),z("div",{class:zt(lt.sidebar,{[lt.hidden]:du()}),children:z(Uu,{})})]})}var Tt={container:"X",list:"j",heading:"F",title:"I",item:"o",active:"g",value:"R",count:"q"};function Uu(e){let t=mu();return t.sort((r,n)=>n.node.count-r.node.count),z("div",{class:Tt.container,children:[z("h3",{class:Tt.heading,children:"Filters"}),z("h4",{class:Tt.title,children:"Tags"}),z("ol",{class:Tt.list,children:t.map(r=>z("li",{class:zt(Tt.item,{[Tt.active]:lu(r.node.value)}),onClick:()=>uu(r.node.value),children:[z("span",{class:Tt.value,children:r.node.value}),z("span",{class:Tt.count,children:r.node.count})]}))})]})}var ca={container:"f"};function Nu(e){let t=Vt(null);return mt(()=>{var r,n;e.focus?(r=t.current)==null||r.focus():(n=t.current)==null||n.blur()},[e.focus]),z("div",{class:ca.container,children:z("input",{ref:t,type:"text",class:ca.content,value:hn(wn()),onInput:r=>Va(yu(r.currentTarget.value)),autocapitalize:"off",autocomplete:"off",autocorrect:"off",placeholder:"Search",spellcheck:!1,role:"combobox"})})}var ut={container:"b",heading:"A",item:"a",active:"h",wrapper:"B",actions:"s",title:"x",path:"t"};function Ga(){let[e,t]=bn(!1);return mt(()=>{let r=()=>t(!0),n=()=>t(!1);return document.addEventListener("compositionstart",r),document.addEventListener("compositionend",n),()=>{document.removeEventListener("compositionstart",r),document.removeEventListener("compositionend",n)}},[]),e}function Du(e){var s;let t=su(),r=pu(),n=dn(),o=Vt([]),i=Ga();mt(()=>{let c=o.current[n];c&&c.scrollIntoView({block:"center",behavior:"smooth"})},[n]),Aa(e.keyboard,c=>{if(i)return;let l=dn();c.key==="ArrowDown"?(c.preventDefault(),so(Math.min(l+1,r.length-1))):c.key==="ArrowUp"&&(c.preventDefault(),so(Math.max(l-1,0)))},[e.keyboard,i]);let a=(s=fu())!=null?s:0;return z(ft,{children:[r.length>0&&z("h3",{class:ut.heading,children:[z("span",{class:ut.bubble,children:new Intl.NumberFormat("en-US").format(a)})," ","results"]}),z("ol",{class:ut.container,children:r.map((c,l)=>{var m;let u=Ba(t[c.id].title,c.matches.find(({field:h})=>h==="title")),p=Mu((m=t[c.id].path)!=null?m:[],c.matches.find(({field:h})=>h==="path")),d=t[c.id].location;if(qa()){let h=encodeURIComponent(wn()),[v,x]=d.split("#",2);d=`${v}?h=${h.replace(/%20/g,"+")}`,typeof x<"u"&&(d+=`#${x}`)}return z("li",{children:z("a",{ref:h=>{o.current[l]=h},href:d,onClick:()=>Dt(),class:zt(ut.item,{[ut.active]:l===dn()}),children:[z("div",{class:ut.wrapper,children:[z("h2",{class:ut.title,children:u}),z("menu",{class:ut.path,children:p.map(h=>z("li",{children:h}))})]}),z("nav",{class:ut.actions,children:z(co,{children:z(Pu,{})})})]})})})})]})}var Wu={container:"e"};function Vu(e){let t=Ga();return Aa(!0,r=>{var n,o,i,a,s;if(!t)if((r.metaKey||r.ctrlKey)&&r.key==="k")r.preventDefault(),Dt();else if((r.metaKey||r.ctrlKey)&&r.key==="j")document.body.classList.toggle("dark");else if(r.key==="Enter"&&!sr()){r.preventDefault();let c=dn(),l=(o=(n=it.value)==null?void 0:n.items[c])==null?void 0:o.id;if((a=(i=lr.value)==null?void 0:i.items[l])!=null&&a.location){Dt();let u=(s=lr.value)==null?void 0:s.items[l].location;if(qa()){let p=encodeURIComponent(wn()),[d,m]=u.split("#",2);u=`${d}?h=${p.replace(/%20/g,"+")}`,typeof m<"u"&&(u+=`#${m}`)}window.location.href=u}}else r.key==="Escape"&&!sr()&&(r.preventDefault(),Dt())},[t]),z("div",{class:Wu.container,children:[z(ku,{hidden:sr()}),z(Fu,{hidden:sr()})]})}function Ja(e,t){au(e),El(z(Vu,{}),t)}function go(){Dt()}function zu(e,t){switch(e.constructor){case HTMLInputElement:return e.type==="radio"?/^Arrow/.test(t):!0;case HTMLSelectElement:case HTMLTextAreaElement:return!0;default:return e.isContentEditable}}function qu(){return R(b(window,"compositionstart").pipe(f(()=>!0)),b(window,"compositionend").pipe(f(()=>!1))).pipe(J(!1))}function Xa(){let e=b(window,"keydown").pipe(f(t=>({mode:sr()?"global":"search",type:t.key,meta:t.ctrlKey||t.metaKey,claim(){t.preventDefault(),t.stopPropagation()}})),L(({mode:t,type:r})=>{if(t==="global"){let n=xt();if(typeof n!="undefined")return!zu(n,r)}return!0}),xe());return qu().pipe(g(t=>t?y:e))}function Ye(){return new URL(location.href)}function dt(e,t=!1){if(X("navigation.instant")&&!t){let r=A("a",{href:e.href});document.body.appendChild(r),r.click(),r.remove()}else location.href=e.href}function Za(){return new I}function Qa(){return location.hash.slice(1)}function es(e){let t=A("a",{href:e});t.addEventListener("click",r=>r.stopPropagation()),t.click()}function _o(e){return R(b(window,"hashchange"),e).pipe(f(Qa),J(Qa()),L(t=>t.length>0),se(1))}function ts(e){return _o(e).pipe(f(t=>Le(`[id="${t}"]`)),L(t=>typeof t!="undefined"))}function Ir(e){let t=matchMedia(e);return an(r=>t.addListener(()=>r(t.matches))).pipe(J(t.matches))}function rs(){let e=matchMedia("print");return R(b(window,"beforeprint").pipe(f(()=>!0)),b(window,"afterprint").pipe(f(()=>!1))).pipe(J(e.matches))}function yo(e,t){return e.pipe(g(r=>r?t():y))}function xo(e,t){return new U(r=>{let n=new XMLHttpRequest;return n.open("GET",`${e}`),n.responseType="blob",n.addEventListener("load",()=>{n.status>=200&&n.status<300?(r.next(n.response),r.complete()):r.error(new Error(n.statusText))}),n.addEventListener("error",()=>{r.error(new Error("Network error"))}),n.addEventListener("abort",()=>{r.complete()}),typeof(t==null?void 0:t.progress$)!="undefined"&&(n.addEventListener("progress",o=>{var i;if(o.lengthComputable)t.progress$.next(o.loaded/o.total*100);else{let a=(i=n.getResponseHeader("Content-Length"))!=null?i:0;t.progress$.next(o.loaded/+a*100)}}),t.progress$.next(5)),n.send(),()=>n.abort()})}function et(e,t){return xo(e,t).pipe(g(r=>r.text()),f(r=>JSON.parse(r)),se(1))}function En(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/html")),se(1))}function ns(e,t){let r=new DOMParser;return xo(e,t).pipe(g(n=>n.text()),f(n=>r.parseFromString(n,"text/xml")),se(1))}var wo={drawer:G("[data-md-toggle=drawer]"),search:G("[data-md-toggle=search]")};function Eo(e,t){wo[e].checked!==t&&wo[e].click()}function Tn(e){let t=wo[e];return b(t,"change").pipe(f(()=>t.checked),J(t.checked))}function os(){return{x:Math.max(0,scrollX),y:Math.max(0,scrollY)}}function is(){return R(b(window,"scroll",{passive:!0}),b(window,"resize",{passive:!0})).pipe(f(os),J(os()))}function as(){return{width:innerWidth,height:innerHeight}}function ss(){return b(window,"resize",{passive:!0}).pipe(f(as),J(as()))}function cs(){return re([is(),ss()]).pipe(f(([e,t])=>({offset:e,size:t})),se(1))}function Sn(e,{viewport$:t,header$:r}){let n=t.pipe(fe("size")),o=re([n,r]).pipe(f(()=>wt(e)));return re([r,t,o]).pipe(f(([{height:i},{offset:a,size:s},{x:c,y:l}])=>({offset:{x:a.x-c,y:a.y-l+i},size:s})))}var Ku=G("#__config"),mr=JSON.parse(Ku.textContent);mr.base=`${new URL(mr.base,Ye())}`;function Ue(){return mr}function X(e){return mr.features.includes(e)}function Bt(e,t){return typeof t!="undefined"?mr.translations[e].replace("#",t.toString()):mr.translations[e]}function ht(e,t=document){return G(`[data-md-component=${e}]`,t)}function Ee(e,t=document){return P(`[data-md-component=${e}]`,t)}function Bu(e){let t=G(".md-typeset > :first-child",e);return b(t,"click",{once:!0}).pipe(f(()=>G(".md-typeset",e)),f(r=>({hash:__md_hash(r.innerHTML)})))}function ls(e){if(!X("announce.dismiss")||!e.childElementCount)return y;if(!e.hidden){let t=G(".md-typeset",e);__md_hash(t.innerHTML)===__md_get("__announce")&&(e.hidden=!0)}return j(()=>{let t=new I;return t.subscribe(({hash:r})=>{e.hidden=!0,__md_set("__announce",r)}),Bu(e).pipe($(r=>t.next(r)),V(()=>t.complete()),f(r=>H({ref:e},r)))})}function Yu(e,{target$:t}){return t.pipe(f(r=>({hidden:r!==e})))}function us(e,t){let r=new I;return r.subscribe(({hidden:n})=>{e.hidden=n}),Yu(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))}function To(e,t){return t==="inline"?A("div",{class:"md-tooltip md-tooltip--inline",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"})):A("div",{class:"md-tooltip",id:e,role:"tooltip"},A("div",{class:"md-tooltip__inner md-typeset"}))}function On(...e){return A("div",{class:"md-tooltip2",role:"dialog"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function ps(...e){return A("div",{class:"md-tooltip2",role:"tooltip"},A("div",{class:"md-tooltip2__inner md-typeset"},e))}function fs(e,t){if(t=t?`${t}_annotation_${e}`:void 0,t){let r=t?`#${t}`:void 0;return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("a",{href:r,class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}else return A("aside",{class:"md-annotation",tabIndex:0},To(t),A("span",{class:"md-annotation__index",tabIndex:-1},A("span",{"data-md-annotation-id":e})))}function ms(e){return A("button",{class:"md-code__button",title:Bt("clipboard.copy"),"data-clipboard-target":`#${e} > code`,"data-md-type":"copy"})}function ds(){return A("button",{class:"md-code__button",title:"Toggle line selection","data-md-type":"select"})}function hs(){return A("nav",{class:"md-code__nav"})}var Xu=_r(So());function bs(e){return A("ul",{class:"md-source__facts"},Object.entries(e).map(([t,r])=>A("li",{class:`md-source__fact md-source__fact--${t}`},typeof r=="number"?Li(r):r)))}function Oo(e){let t=`tabbed-control tabbed-control--${e}`;return A("div",{class:t,hidden:!0},A("button",{class:"tabbed-button",tabIndex:-1,"aria-hidden":"true"}))}function gs(e){return A("div",{class:"md-typeset__scrollwrap"},A("div",{class:"md-typeset__table"},e))}function Zu(e){var n;let t=Ue(),r=new URL(`../${e.version}/`,t.base);return A("li",{class:"md-version__item"},A("a",{href:`${r}`,class:"md-version__link"},e.title,((n=t.version)==null?void 0:n.alias)&&e.aliases.length>0&&A("span",{class:"md-version__alias"},e.aliases[0])))}function _s(e,t){var n;let r=Ue();return e=e.filter(o=>{var i;return!((i=o.properties)!=null&&i.hidden)}),A("div",{class:"md-version"},A("button",{class:"md-version__current","aria-label":Bt("select.version")},t.title,((n=r.version)==null?void 0:n.alias)&&t.aliases.length>0&&A("span",{class:"md-version__alias"},t.aliases[0])),A("ul",{class:"md-version__list"},e.map(Zu)))}var Qu=0;function ep(e,t=250){let r=re([ir(e),Ft(e,t)]).pipe(f(([o,i])=>o||i),ie()),n=j(()=>Ai(e)).pipe(oe(Ut),Lr(1),Ze(r),f(()=>Ci(e)));return r.pipe(Sr(o=>o),g(()=>re([r,n])),f(([o,i])=>({active:o,offset:i})),xe())}function Rr(e,t,r=250){let{content$:n,viewport$:o}=t,i=`__tooltip2_${Qu++}`;return j(()=>{let a=new I,s=new Un(!1);a.pipe(he(),ye(!1)).subscribe(s);let c=s.pipe(Tr(u=>Ve(+!u*250,Wn)),ie(),g(u=>u?n:y),$(u=>u.id=i),xe());re([a.pipe(f(({active:u})=>u)),c.pipe(g(u=>Ft(u,250)),J(!1))]).pipe(f(u=>u.some(p=>p))).subscribe(s);let l=s.pipe(L(u=>u),pe(c,o),f(([u,p,{size:d}])=>{let m=e.getBoundingClientRect(),h=m.width/2;if(p.role==="tooltip")return{x:h,y:8+m.height};if(m.y>=d.height/2){let{height:v}=Ae(p);return{x:h,y:-16-v}}else return{x:h,y:16+m.height}}));return re([c,a,l]).subscribe(([u,{offset:p},d])=>{u.style.setProperty("--md-tooltip-host-x",`${p.x}px`),u.style.setProperty("--md-tooltip-host-y",`${p.y}px`),u.style.setProperty("--md-tooltip-x",`${d.x}px`),u.style.setProperty("--md-tooltip-y",`${d.y}px`),u.classList.toggle("md-tooltip2--top",d.y<0),u.classList.toggle("md-tooltip2--bottom",d.y>=0)}),s.pipe(L(u=>u),pe(c,(u,p)=>p),L(u=>u.role==="tooltip")).subscribe(u=>{let p=Ae(G(":scope > *",u));u.style.setProperty("--md-tooltip-width",`${p.width}px`),u.style.setProperty("--md-tooltip-tail","0px")}),s.pipe(ie(),Ie(je),pe(c)).subscribe(([u,p])=>{p.classList.toggle("md-tooltip2--active",u)}),re([s.pipe(L(u=>u)),c]).subscribe(([u,p])=>{p.role==="dialog"?(e.setAttribute("aria-controls",i),e.setAttribute("aria-haspopup","dialog")):e.setAttribute("aria-describedby",i)}),s.pipe(L(u=>!u)).subscribe(()=>{e.removeAttribute("aria-controls"),e.removeAttribute("aria-describedby"),e.removeAttribute("aria-haspopup")}),ep(e,r).pipe($(u=>a.next(u)),V(()=>a.complete()),f(u=>H({ref:e},u)))})}function Ge(e,{viewport$:t},r=document.body){return Rr(e,{content$:new U(n=>{let o=e.title,i=ps(o);return n.next(i),e.removeAttribute("title"),r.append(i),()=>{i.remove(),e.setAttribute("title",o)}}),viewport$:t},0)}function tp(e,t){let r=j(()=>re([Hi(e),Ut(t)])).pipe(f(([{x:n,y:o},i])=>{let{width:a,height:s}=Ae(e);return{x:n-i.x+a/2,y:o-i.y+s/2}}));return ir(e).pipe(g(n=>r.pipe(f(o=>({active:n,offset:o})),Me(+!n||1/0))))}function ys(e,t,{target$:r}){let[n,o]=Array.from(e.children);return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({offset:s}){e.style.setProperty("--md-tooltip-x",`${s.x}px`),e.style.setProperty("--md-tooltip-y",`${s.y}px`)},complete(){e.style.removeProperty("--md-tooltip-x"),e.style.removeProperty("--md-tooltip-y")}}),Et(e).pipe(Q(a)).subscribe(s=>{e.toggleAttribute("data-md-visible",s)}),R(i.pipe(L(({active:s})=>s)),i.pipe(Be(250),L(({active:s})=>!s))).subscribe({next({active:s}){s?e.prepend(n):n.remove()},complete(){e.prepend(n)}}),i.pipe(Xe(16,je)).subscribe(({active:s})=>{n.classList.toggle("md-tooltip--active",s)}),i.pipe(Lr(125,je),L(()=>!!e.offsetParent),f(()=>e.offsetParent.getBoundingClientRect()),f(({x:s})=>s)).subscribe({next(s){s?e.style.setProperty("--md-tooltip-0",`${-s}px`):e.style.removeProperty("--md-tooltip-0")},complete(){e.style.removeProperty("--md-tooltip-0")}}),b(o,"click").pipe(Q(a),L(s=>!(s.metaKey||s.ctrlKey))).subscribe(s=>{s.stopPropagation(),s.preventDefault()}),b(o,"mousedown").pipe(Q(a),pe(i)).subscribe(([s,{active:c}])=>{var l;if(s.button!==0||s.metaKey||s.ctrlKey)s.preventDefault();else if(c){s.preventDefault();let u=e.parentElement.closest(".md-annotation");u instanceof HTMLElement?u.focus():(l=xt())==null||l.blur()}}),r.pipe(Q(a),L(s=>s===n),It(125)).subscribe(()=>e.focus()),tp(e,t).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function rp(e){let t=Ue();if(e.tagName!=="CODE")return[e];let r=[".c",".c1",".cm"];if(t.annotate){let n=e.closest("[class|=language]");if(n)for(let o of Array.from(n.classList)){if(!o.startsWith("language-"))continue;let[,i]=o.split("-");i in t.annotate&&r.push(...t.annotate[i])}}return P(r.join(", "),e)}function np(e){let t=[];for(let r of rp(e)){let n=[],o=document.createNodeIterator(r,NodeFilter.SHOW_TEXT);for(let i=o.nextNode();i;i=o.nextNode())n.push(i);for(let i of n){let a;for(;a=/(\(\d+\))(!)?/.exec(i.textContent);){let[,s,c]=a;if(typeof c=="undefined"){let l=i.splitText(a.index);i=l.splitText(s.length),t.push(l)}else{i.textContent=s,t.push(i);break}}}}return t}function xs(e,t){t.append(...Array.from(e.childNodes))}function Ln(e,t,{target$:r,print$:n}){let o=t.closest("[id]"),i=o==null?void 0:o.id,a=new Map;for(let s of np(t)){let[,c]=s.textContent.match(/\((\d+)\)/);Le(`:scope > li:nth-child(${c})`,e)&&(a.set(c,fs(c,i)),s.replaceWith(a.get(c)))}return a.size===0?y:j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=[];for(let[u,p]of a)l.push([G(".md-typeset",p),G(`:scope > li:nth-child(${u})`,e)]);return n.pipe(Q(c)).subscribe(u=>{e.hidden=!u,e.classList.toggle("md-annotation-list",u);for(let[p,d]of l)u?xs(p,d):xs(d,p)}),R(...[...a].map(([,u])=>ys(u,t,{target$:r}))).pipe(V(()=>s.complete()),xe())})}function ws(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return ws(t)}}function Es(e,t){return j(()=>{let r=ws(e);return typeof r!="undefined"?Ln(r,e,t):y})}var Ss=_r(Mo());var op=0,Ts=R(b(window,"keydown").pipe(f(()=>!0)),R(b(window,"keyup"),b(window,"contextmenu")).pipe(f(()=>!1))).pipe(J(!1),se(1));function Os(e){if(e.nextElementSibling){let t=e.nextElementSibling;if(t.tagName==="OL")return t;if(t.tagName==="P"&&!t.children.length)return Os(t)}}function ip(e){return Re(e).pipe(f(({width:t})=>({scrollable:Mr(e).width>t})),fe("scrollable"))}function Ls(e,t){let{matches:r}=matchMedia("(hover)"),n=j(()=>{let o=new I,i=o.pipe(Gn(1));o.subscribe(({scrollable:m})=>{m&&r?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")});let a=[],s=e.closest("pre"),c=s.closest("[id]"),l=c?c.id:op++;s.id=`__code_${l}`;let u=[],p=e.closest(".highlight");if(p instanceof HTMLElement){let m=Os(p);if(typeof m!="undefined"&&(p.classList.contains("annotate")||X("content.code.annotate"))){let h=Ln(m,e,t);u.push(Re(p).pipe(Q(i),f(({width:v,height:x})=>v&&x),ie(),g(v=>v?h:y)))}}let d=P(":scope > span[id]",e);if(d.length&&(e.classList.add("md-code__content"),e.closest(".select")||X("content.code.select")&&!e.closest(".no-select"))){let m=+d[0].id.split("-").pop(),h=ds();a.push(h),X("content.tooltips")&&u.push(Ge(h,{viewport$}));let v=b(h,"click").pipe(Or(M=>!M,!1),$(()=>h.blur()),xe());v.subscribe(M=>{h.classList.toggle("md-code__button--active",M)});let x=me(d).pipe(oe(M=>Ft(M).pipe(f(O=>[M,O]))));v.pipe(g(M=>M?x:y)).subscribe(([M,O])=>{let N=Le(".hll.select",M);if(N&&!O)N.replaceWith(...Array.from(N.childNodes));else if(!N&&O){let ee=document.createElement("span");ee.className="hll select",ee.append(...Array.from(M.childNodes).slice(1)),M.append(ee)}});let w=me(d).pipe(oe(M=>b(M,"mousedown").pipe($(O=>O.preventDefault()),f(()=>M)))),E=v.pipe(g(M=>M?w:y),pe(Ts),f(([M,O])=>{var ee;let N=d.indexOf(M)+m;if(O===!1)return[N,N];{let le=P(".hll",e).map(ce=>d.indexOf(ce.parentElement)+m);return(ee=window.getSelection())==null||ee.removeAllRanges(),[Math.min(N,...le),Math.max(N,...le)]}})),_=_o(y).pipe(L(M=>M.startsWith(`__codelineno-${l}-`)));_.subscribe(M=>{let[,,O]=M.split("-"),N=O.split(":").map(le=>+le-m+1);N.length===1&&N.push(N[0]);for(let le of P(".hll:not(.select)",e))le.replaceWith(...Array.from(le.childNodes));let ee=d.slice(N[0]-1,N[1]);for(let le of ee){let ce=document.createElement("span");ce.className="hll",ce.append(...Array.from(le.childNodes).slice(1)),le.append(ce)}}),_.pipe(Me(1),Ie(ge)).subscribe(M=>{if(M.includes(":")){let O=document.getElementById(M.split(":")[0]);O&&setTimeout(()=>{let N=O,ee=-64;for(;N!==document.body;)ee+=N.offsetTop,N=N.offsetParent;window.scrollTo({top:ee})},1)}});let be=me(P('a[href^="#__codelineno"]',p)).pipe(oe(M=>b(M,"click").pipe($(O=>O.preventDefault()),f(()=>M)))).pipe(Q(i),pe(Ts),f(([M,O])=>{let ee=+G(`[id="${M.hash.slice(1)}"]`).parentElement.id.split("-").pop();if(O===!1)return[ee,ee];{let le=P(".hll",e).map(ce=>+ce.parentElement.id.split("-").pop());return[Math.min(ee,...le),Math.max(ee,...le)]}}));R(E,be).subscribe(M=>{let O=`#__codelineno-${l}-`;M[0]===M[1]?O+=M[0]:O+=`${M[0]}:${M[1]}`,history.replaceState({},"",O),window.dispatchEvent(new HashChangeEvent("hashchange",{newURL:window.location.origin+window.location.pathname+O,oldURL:window.location.href}))})}if(Ss.default.isSupported()&&(e.closest(".copy")||X("content.code.copy")&&!e.closest(".no-copy"))){let m=ms(s.id);a.push(m),X("content.tooltips")&&u.push(Ge(m,{viewport$}))}if(a.length){let m=hs();m.append(...a),s.insertBefore(m,e)}return ip(e).pipe($(m=>o.next(m)),V(()=>o.complete()),f(m=>H({ref:e},m)),Rt(R(...u).pipe(Q(i))))});return X("content.lazy")?Et(e).pipe(L(o=>o),Me(1),g(()=>n)):n}function ap(e,{target$:t,print$:r}){let n=!0;return R(t.pipe(f(o=>o.closest("details:not([open])")),L(o=>e===o),f(()=>({action:"open",reveal:!0}))),r.pipe(L(o=>o||!n),$(()=>n=e.open),f(o=>({action:o?"open":"close"}))))}function Ms(e,t){return j(()=>{let r=new I;return r.subscribe(({action:n,reveal:o})=>{e.toggleAttribute("open",n==="open"),o&&e.scrollIntoView()}),ap(e,t).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}var ks=0,As=new Map;function sp(e){let t=document.createElement("h3");t.innerHTML=e.innerHTML;let r=[t],n=e.nextElementSibling;for(;n&&!(n instanceof HTMLHeadingElement);)r.push(n.cloneNode(!0)),n=n.nextElementSibling;return r}function cp(e,t){for(let r of P("[href], [src]",e))for(let n of["href","src"]){let o=r.getAttribute(n);if(o&&!/^(?:[a-z]+:)?\/\//i.test(o)){r[n]=new URL(r.getAttribute(n),t).toString();break}}for(let r of P("[name^=__], [for]",e))for(let n of["id","for","name"]){let o=r.getAttribute(n);o&&r.setAttribute(n,`${o}$preview_${ks}`)}return ks++,Y(e)}function lp(e){let t=As.get(e.toString());return t?Y(t):En(e).pipe(g(r=>cp(r,e)),f(r=>(As.set(e.toString(),r),r)))}function Cs(e,t){let{sitemap$:r}=t;if(!(e instanceof HTMLAnchorElement))return y;if(!(X("navigation.instant.preview")||e.hasAttribute("data-preview")))return y;e.removeAttribute("title");let n=re([ir(e),Ft(e).pipe(ke(1))]).pipe(f(([i,a])=>i||a),ie(),L(i=>i));return $t([r,n]).pipe(g(([i])=>{let a=new URL(e.href);return a.search=a.hash="",i.has(`${a}`)?Y(a):y}),g(i=>lp(i)),g(i=>{let a=e.hash?`article [id="${decodeURIComponent(e.hash.slice(1))}"]`:"article h1",s=Le(a,i);return typeof s=="undefined"?y:Y(sp(s))})).pipe(g(i=>{let a=new U(s=>{let c=On(...i);return s.next(c),document.body.append(c),()=>c.remove()});return Rr(e,H({content$:a},t))}))}var Hs=".node circle,.node ellipse,.node path,.node polygon,.node rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}marker{fill:var(--md-mermaid-edge-color)!important}.edgeLabel .label rect{fill:#0000}.flowchartTitleText{fill:var(--md-mermaid-label-fg-color)}.label{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.label foreignObject{line-height:normal;overflow:visible}.label div .edgeLabel{color:var(--md-mermaid-label-fg-color)}.edgeLabel,.edgeLabel p,.label div .edgeLabel{background-color:var(--md-mermaid-label-bg-color)}.edgeLabel,.edgeLabel p{fill:var(--md-mermaid-label-bg-color);color:var(--md-mermaid-edge-color)}.edgePath .path,.flowchart-link{stroke:var(--md-mermaid-edge-color)}.edgePath .arrowheadPath{fill:var(--md-mermaid-edge-color);stroke:none}.cluster rect{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}.cluster span{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}g #flowchart-circleEnd,g #flowchart-circleStart,g #flowchart-crossEnd,g #flowchart-crossStart,g #flowchart-pointEnd,g #flowchart-pointStart{stroke:none}.classDiagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.classGroup line,g.classGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.classGroup text{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.classLabel .box{fill:var(--md-mermaid-label-bg-color);background-color:var(--md-mermaid-label-bg-color);opacity:1}.classLabel .label{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.node .divider{stroke:var(--md-mermaid-node-fg-color)}.relation{stroke:var(--md-mermaid-edge-color)}.cardinality{fill:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}.cardinality text{fill:inherit!important}defs marker.marker.composition.class path,defs marker.marker.dependency.class path,defs marker.marker.extension.class path{fill:var(--md-mermaid-edge-color)!important;stroke:var(--md-mermaid-edge-color)!important}defs marker.marker.aggregation.class path{fill:var(--md-mermaid-label-bg-color)!important;stroke:var(--md-mermaid-edge-color)!important}.statediagramTitleText{fill:var(--md-mermaid-label-fg-color)}g.stateGroup rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}g.stateGroup .state-title{fill:var(--md-mermaid-label-fg-color)!important;font-family:var(--md-mermaid-font-family)}g.stateGroup .composit{fill:var(--md-mermaid-label-bg-color)}.nodeLabel,.nodeLabel p{color:var(--md-mermaid-label-fg-color);font-family:var(--md-mermaid-font-family)}a .nodeLabel{text-decoration:underline}.node circle.state-end,.node circle.state-start,.start-state{fill:var(--md-mermaid-edge-color);stroke:none}.end-state-inner,.end-state-outer{fill:var(--md-mermaid-edge-color)}.end-state-inner,.node circle.state-end{stroke:var(--md-mermaid-label-bg-color)}.transition{stroke:var(--md-mermaid-edge-color)}[id^=state-fork] rect,[id^=state-join] rect{fill:var(--md-mermaid-edge-color)!important;stroke:none!important}.statediagram-cluster.statediagram-cluster .inner{fill:var(--md-default-bg-color)}.statediagram-cluster rect{fill:var(--md-mermaid-node-bg-color);stroke:var(--md-mermaid-node-fg-color)}.statediagram-state rect.divider{fill:var(--md-default-fg-color--lightest);stroke:var(--md-default-fg-color--lighter)}defs #statediagram-barbEnd{stroke:var(--md-mermaid-edge-color)}[id^=entity] path,[id^=entity] rect{fill:var(--md-default-bg-color)}.relationshipLine{stroke:var(--md-mermaid-edge-color)}defs .marker.oneOrMore.er *,defs .marker.onlyOne.er *,defs .marker.zeroOrMore.er *,defs .marker.zeroOrOne.er *{stroke:var(--md-mermaid-edge-color)!important}text:not([class]):last-child{fill:var(--md-mermaid-label-fg-color)}.actor{fill:var(--md-mermaid-sequence-actor-bg-color);stroke:var(--md-mermaid-sequence-actor-border-color)}text.actor>tspan{fill:var(--md-mermaid-sequence-actor-fg-color);font-family:var(--md-mermaid-font-family)}line{stroke:var(--md-mermaid-sequence-actor-line-color)}.actor-man circle,.actor-man line{fill:var(--md-mermaid-sequence-actorman-bg-color);stroke:var(--md-mermaid-sequence-actorman-line-color)}.messageLine0,.messageLine1{stroke:var(--md-mermaid-sequence-message-line-color)}.note{fill:var(--md-mermaid-sequence-note-bg-color);stroke:var(--md-mermaid-sequence-note-border-color)}.loopText,.loopText>tspan,.messageText,.noteText>tspan{stroke:none;font-family:var(--md-mermaid-font-family)!important}.messageText{fill:var(--md-mermaid-sequence-message-fg-color)}.loopText,.loopText>tspan{fill:var(--md-mermaid-sequence-loop-fg-color)}.noteText>tspan{fill:var(--md-mermaid-sequence-note-fg-color)}#arrowhead path{fill:var(--md-mermaid-sequence-message-line-color);stroke:none}.loopLine{fill:var(--md-mermaid-sequence-loop-bg-color);stroke:var(--md-mermaid-sequence-loop-border-color)}.labelBox{fill:var(--md-mermaid-sequence-label-bg-color);stroke:none}.labelText,.labelText>span{fill:var(--md-mermaid-sequence-label-fg-color);font-family:var(--md-mermaid-font-family)}.sequenceNumber{fill:var(--md-mermaid-sequence-number-fg-color)}rect.rect{fill:var(--md-mermaid-sequence-box-bg-color);stroke:none}rect.rect+text.text{fill:var(--md-mermaid-sequence-box-fg-color)}defs #sequencenumber{fill:var(--md-mermaid-sequence-number-bg-color)!important}";var ko,pp=0;function fp(){return typeof mermaid=="undefined"||mermaid instanceof Element?ar("https://unpkg.com/mermaid@11/dist/mermaid.min.js"):Y(void 0)}function $s(e){return e.classList.remove("mermaid"),ko||(ko=fp().pipe($(()=>mermaid.initialize({startOnLoad:!1,themeCSS:Hs,sequence:{actorFontSize:"16px",messageFontSize:"16px",noteFontSize:"16px"}})),f(()=>{}),se(1))),ko.subscribe(()=>Uo(null,null,function*(){e.classList.add("mermaid");let t=`__mermaid_${pp++}`,r=A("div",{class:"mermaid"}),n=e.textContent,{svg:o,fn:i}=yield mermaid.render(t,n),a=r.attachShadow({mode:"closed"});a.innerHTML=o,e.replaceWith(r),i==null||i(a)})),ko.pipe(f(()=>({ref:e})))}var Ps=A("table");function Is(e){return e.replaceWith(Ps),Ps.replaceWith(gs(e)),Y({ref:e})}function mp(e){let t=e.find(r=>r.checked)||e[0];return R(...e.map(r=>b(r,"change").pipe(f(()=>G(`label[for="${r.id}"]`))))).pipe(J(G(`label[for="${t.id}"]`)),f(r=>({active:r})))}function Rs(e,{viewport$:t,target$:r}){let n=G(".tabbed-labels",e),o=P(":scope > input",e),i=Oo("prev");e.append(i);let a=Oo("next");return e.append(a),j(()=>{let s=new I,c=s.pipe(he(),ye(!0));re([s,Re(e),Et(e)]).pipe(Q(c),Xe(1,je)).subscribe({next([{active:l},u]){let p=wt(l),{width:d}=Ae(l);e.style.setProperty("--md-indicator-x",`${p.x}px`),e.style.setProperty("--md-indicator-width",`${d}px`);let m=ln(n);(p.x<m.x||p.x+d>m.x+u.width)&&n.scrollTo({left:Math.max(0,p.x-16),behavior:"smooth"})},complete(){e.style.removeProperty("--md-indicator-x"),e.style.removeProperty("--md-indicator-width")}}),re([Ut(n),Re(n)]).pipe(Q(c)).subscribe(([l,u])=>{let p=Mr(n);i.hidden=l.x<16,a.hidden=l.x>p.width-u.width-16}),R(b(i,"click").pipe(f(()=>-1)),b(a,"click").pipe(f(()=>1))).pipe(Q(c)).subscribe(l=>{let{width:u}=Ae(n);n.scrollBy({left:u*l,behavior:"smooth"})}),r.pipe(Q(c),L(l=>o.includes(l))).subscribe(l=>l.click()),n.classList.add("tabbed-labels--linked");for(let l of o){let u=G(`label[for="${l.id}"]`);u.replaceChildren(A("a",{href:`#${u.htmlFor}`,tabIndex:-1},...Array.from(u.childNodes))),b(u.firstElementChild,"click").pipe(Q(c),L(p=>!(p.metaKey||p.ctrlKey)),$(p=>{p.preventDefault(),p.stopPropagation()})).subscribe(()=>{history.replaceState({},"",`#${u.htmlFor}`),u.click()})}return X("content.tabs.link")&&s.pipe(ke(1),pe(t)).subscribe(([{active:l},{offset:u}])=>{let p=l.innerText.trim();if(l.hasAttribute("data-md-switching"))l.removeAttribute("data-md-switching");else{let d=e.offsetTop-u.y;for(let h of P("[data-tabs]"))for(let v of P(":scope > input",h)){let x=G(`label[for="${v.id}"]`);if(x!==l&&x.innerText.trim()===p){x.setAttribute("data-md-switching",""),v.click();break}}window.scrollTo({top:e.offsetTop-d});let m=__md_get("__tabs")||[];__md_set("__tabs",[...new Set([p,...m])])}}),s.pipe(Q(c)).subscribe(()=>{for(let l of P("audio, video",e))l.offsetWidth&&l.autoplay?l.play().catch(()=>{}):l.pause()}),mp(o).pipe($(l=>s.next(l)),V(()=>s.complete()),f(l=>H({ref:e},l)))}).pipe(Ht(ge))}function js(e,t){let{viewport$:r,target$:n,print$:o}=t;return R(...P(".annotate:not(.highlight)",e).map(i=>Es(i,{target$:n,print$:o})),...P("pre:not(.mermaid) > code",e).map(i=>Ls(i,{target$:n,print$:o})),...P("a",e).map(i=>Cs(i,t)),...P("pre.mermaid",e).map(i=>$s(i)),...P("table:not([class])",e).map(i=>Is(i)),...P("details",e).map(i=>Ms(i,{target$:n,print$:o})),...P("[data-tabs]",e).map(i=>Rs(i,{viewport$:r,target$:n})),...P("[title]:not([data-preview])",e).filter(()=>X("content.tooltips")).map(i=>Ge(i,{viewport$:r})),...P(".footnote-ref",e).filter(()=>X("content.footnote.tooltips")).map(i=>Rr(i,{content$:new U(a=>{let s=new URL(i.href).hash.slice(1),c=Array.from(document.getElementById(s).cloneNode(!0).children),l=On(...c);return a.next(l),document.body.append(l),()=>l.remove()}),viewport$:r})))}function dp(e,{alert$:t}){return t.pipe(g(r=>R(Y(!0),Y(!1).pipe(It(2e3))).pipe(f(n=>({message:r,active:n})))))}function Fs(e,t){let r=G(".md-typeset",e);return j(()=>{let n=new I;return n.subscribe(({message:o,active:i})=>{e.classList.toggle("md-dialog--active",i),r.textContent=o}),dp(e,t).pipe($(o=>n.next(o)),V(()=>n.complete()),f(o=>H({ref:e},o)))})}function hp({viewport$:e}){if(!X("header.autohide"))return Y(!1);let t=e.pipe(f(({offset:{y:o}})=>o),Pt(2,1),f(([o,i])=>[o<i,i]),fe(0)),r=re([e,t]).pipe(L(([{offset:o},[,i]])=>Math.abs(i-o.y)>100),f(([,[o]])=>o),ie()),n=Tn("search");return re([e,n]).pipe(f(([{offset:o},i])=>o.y>400&&!i),ie(),g(o=>o?r:Y(!1)),J(!1))}function Us(e,t){return j(()=>re([Re(e),hp(t)])).pipe(f(([{height:r},n])=>({height:r,hidden:n})),ie((r,n)=>r.height===n.height&&r.hidden===n.hidden),se(1))}function Ns(e,{viewport$:t,header$:r,main$:n}){return j(()=>{let o=new I,i=o.pipe(he(),ye(!0));o.pipe(fe("active"),Ze(r)).subscribe(([{active:s},{hidden:c}])=>{e.classList.toggle("md-header--shadow",s&&!c),e.hidden=c});let a=me(P("[title]",e)).pipe(L(()=>X("content.tooltips")),oe(s=>Ge(s,{viewport$:t})));return n.subscribe(o),r.pipe(Q(i),f(s=>H({ref:e},s)),Rt(a.pipe(Q(i))))})}function vp(e,{viewport$:t,header$:r}){return Sn(e,{viewport$:t,header$:r}).pipe(f(({offset:{y:n}})=>{let{height:o}=Ae(e);return{active:o>0&&n>=o}}),fe("active"))}function Ds(e,t){return j(()=>{let r=new I;r.subscribe({next({active:o}){e.classList.toggle("md-header__title--active",o)},complete(){e.classList.remove("md-header__title--active")}});let n=Le(".md-content h1");return typeof n=="undefined"?y:vp(n,t).pipe($(o=>r.next(o)),V(()=>r.complete()),f(o=>H({ref:e},o)))})}function Ws(e,{viewport$:t,header$:r}){let n=r.pipe(f(({height:i})=>i),ie()),o=n.pipe(g(()=>Re(e).pipe(f(({height:i})=>({top:e.offsetTop,bottom:e.offsetTop+i})),fe("bottom"))));return re([n,o,t]).pipe(f(([i,{top:a,bottom:s},{offset:{y:c},size:{height:l}}])=>(l=Math.max(0,l-Math.max(0,a-c,i)-Math.max(0,l+c-s)),{offset:a-i,height:l,active:a-i<=c})),ie((i,a)=>i.offset===a.offset&&i.height===a.height&&i.active===a.active))}function bp(e){let t=__md_get("__palette")||{index:e.findIndex(n=>matchMedia(n.getAttribute("data-md-color-media")).matches)},r=Math.max(0,Math.min(t.index,e.length-1));return Y(...e).pipe(oe(n=>b(n,"change").pipe(f(()=>n))),J(e[r]),f(n=>({index:e.indexOf(n),color:{media:n.getAttribute("data-md-color-media"),scheme:n.getAttribute("data-md-color-scheme"),primary:n.getAttribute("data-md-color-primary"),accent:n.getAttribute("data-md-color-accent")}})),se(1))}function Vs(e){let t=P("input",e),r=A("meta",{name:"theme-color"});document.head.appendChild(r);let n=A("meta",{name:"color-scheme"});document.head.appendChild(n);let o=Ir("(prefers-color-scheme: light)");return j(()=>{let i=new I;return i.subscribe(a=>{if(document.body.setAttribute("data-md-color-switching",""),a.color.media==="(prefers-color-scheme)"){let s=matchMedia("(prefers-color-scheme: light)"),c=document.querySelector(s.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");a.color.scheme=c.getAttribute("data-md-color-scheme"),a.color.primary=c.getAttribute("data-md-color-primary"),a.color.accent=c.getAttribute("data-md-color-accent")}for(let[s,c]of Object.entries(a.color))document.body.setAttribute(`data-md-color-${s}`,c);for(let s=0;s<t.length;s++){let c=t[s].nextElementSibling;c instanceof HTMLElement&&(c.hidden=a.index!==s)}__md_set("__palette",a)}),b(e,"keydown").pipe(L(a=>a.key==="Enter"),pe(i,(a,s)=>s)).subscribe(({index:a})=>{a=(a+1)%t.length,t[a].click(),t[a].focus()}),i.pipe(f(()=>{let a=ht("header"),s=window.getComputedStyle(a);return n.content=s.colorScheme,s.backgroundColor.match(/\d+/g).map(c=>(+c).toString(16).padStart(2,"0")).join("")})).subscribe(a=>r.content=`#${a}`),i.pipe(Ie(ge)).subscribe(()=>{document.body.removeAttribute("data-md-color-switching")}),bp(t).pipe(Q(o.pipe(ke(1))),jt(),$(a=>i.next(a)),V(()=>i.complete()),f(a=>H({ref:e},a)))})}function zs(e,{progress$:t}){return j(()=>{let r=new I;return r.subscribe(({value:n})=>{e.style.setProperty("--md-progress-value",`${n}`)}),t.pipe($(n=>r.next({value:n})),V(()=>r.complete()),f(n=>({ref:e,value:n})))})}var qs='.v u{text-decoration:underline!important;text-decoration-style:wavy!important;text-decoration-thickness:1px!important}.p{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-backdrop)/var(--alpha-lighter));cursor:pointer;height:100%;pointer-events:auto;position:absolute;transition:opacity .25s;width:100%}.p.m{opacity:0;pointer-events:none;transition:opacity .35s}.r{align-items:center;background-color:initial;border:none;border-radius:var(--space-2);cursor:pointer;display:flex;flex-shrink:0;font-family:var(--font-family);height:36px;justify-content:center;outline:none;padding:0;position:relative;transition:background-color .25s,color .25s;width:36px;z-index:1}.r svg{stroke:rgb(var(--color-foreground));height:18px;opacity:.5;width:18px}.r:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.r:hover:before{opacity:1;transform:scale(1)}.r.c{cursor:auto}.r.c:before{display:none}.n{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background)/var(--alpha-light));border-radius:var(--space-3);box-shadow:0 0 60px #0000000d;display:flex;height:480px;overflow:hidden;pointer-events:auto;position:absolute;transition:transform .25s cubic-bezier(.16,1,.3,1),opacity .25s;width:640px}.n.l{opacity:0;pointer-events:none;transform:scale(1.1);transition:transform .25s .15s,opacity .15s}@media (max-width:680px){.n{border-radius:0;height:100%;width:100%}}.u{display:flex;flex-basis:min-content;flex-direction:column;flex-grow:1;flex-shrink:0}@keyframes d{0%{transform:scale(0)}50%{transform:scale(1.2)}to{transform:scale(1)}}.y{animation:d .25s ease-in-out;background:var(--color-highlight);border-radius:100%;color:#fff;font-size:8px;font-weight:700;height:12px;padding-top:1px;position:absolute;right:4px;top:4px;width:12px}.i{background-color:rgb(var(--color-background-subtle)/var(--alpha-lighter));flex-shrink:0;overflow:scroll;position:relative;transition:width .35s cubic-bezier(.16,1,.3,1),opacity .25s;width:200px}.i>*{transform:translate(0);transition:transform .25s cubic-bezier(.16,1,.3,1)}.i.l{opacity:0;width:0}.i.l>*{transform:translate(-48px)}@media (max-width:680px){.i{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background-color:rgba(var(--color-background-subtle)/var(--alpha-light));box-shadow:0 0 60px #00000026;height:100%;position:absolute;right:0;top:0}}.w{border-bottom:1px solid rgb(var(--color-foreground)/var(--alpha-lightest));display:flex;gap:var(--space-1);padding:var(--space-2)}.k{-webkit-overflow-scrolling:touch;overflow:auto;overscroll-behavior:contain}.z{padding:8px 10px}.X{color:rgb(var(--color-foreground)/var(--alpha-light));padding:var(--space-2);position:absolute;width:200px}.X,.j{display:flex;flex-direction:column}.j{gap:2px;list-style:none;padding:0}.F,.j{margin:0}.F{font-size:16px;font-weight:400}.F,.I{padding:8px}.I{font-size:14px;margin:4px 0 0;opacity:.5}.I,.o{font-size:12px}.o{cursor:pointer;display:flex;padding:4px 8px;position:relative}.o:before{background-color:var(--color-highlight-transparent);border-radius:var(--space-1);content:"";inset:0;opacity:0;position:absolute;transform:scale(.75);transition:transform 125ms,opacity 125ms;z-index:0}.o.g:before,.o:hover:before{opacity:1;transform:scale(1)}.o.g,.o:hover{color:var(--color-highlight)}.R{flex-grow:1}.R,.q{position:relative}.q{font-weight:700}.f{flex-grow:1}.f input{background:#0000;border:none;color:rgb(var(--color-foreground));font-family:var(--font-family);font-size:16px;height:100%;letter-spacing:-.25px;outline:none;width:100%}.b{color:rgb(var(--color-foreground)/var(--alpha-light));display:flex;flex-direction:column;gap:2px;line-height:1.3;list-style:none;margin:var(--space-2);margin-top:0;padding:0}.A,.b li{margin:0}.A{color:rgb(var(--color-foreground)/var(--alpha-lighter));font-size:12px;margin-top:var(--space-2);padding:0 18px}.a{border-radius:var(--space-2);color:inherit;cursor:pointer;display:flex;flex-direction:row;flex-grow:1;padding:8px 10px;position:relative;text-decoration:none}.a:before{background-color:rgb(var(--color-background-subtle));border-radius:var(--border-radius-2);content:"";display:block;inset:0;opacity:0;position:absolute;transform:scale(.9);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.a.h:before,.a:hover:before{opacity:1;transform:scale(1)}}.a mark{background:#0000;color:var(--color-highlight)}.a u{background-color:var(--color-highlight-transparent);border-radius:2px;box-shadow:0 0 0 1px var(--color-highlight-transparent);text-decoration:none}.B{flex-grow:1}.s{margin-right:-8px;opacity:0;position:relative;transform:translate(-2px);transition:transform 125ms,opacity 125ms;z-index:0}@media (pointer:fine){.h>.s,:hover>.s{opacity:1;transform:none}}.x{font-size:14px;margin:0;position:relative}.x code{background:rgb(var(--color-background-subtle));border-radius:var(--space-1);font-size:13px;padding:2px 4px}.t{color:rgb(var(--color-foreground)/var(--alpha-lighter));display:inline-flex;flex-wrap:wrap;font-size:12px;gap:var(--space-1);list-style:none;margin:0;padding:0;position:relative}.t li{white-space:nowrap}.t li:after{content:"/";display:inline;margin-left:var(--space-1)}.t li:last-child:after{content:"";display:none}.e{--space-1:4px;--space-2:calc(var(--space-1)*2);--space-3:calc(var(--space-2)*2);--space-4:calc(var(--space-3)*2);--space-5:calc(var(--space-4)*2);--alpha-light:.7;--alpha-lighter:.54;--alpha-lightest:.1;--color-highlight:var(--md-accent-fg-color,#526cfe);--color-highlight-transparent:var(--md-accent-fg-color--transparent,#526cfe1a);--border-radius-1:var(--space-1);--border-radius-2:var(--space-2);--border-radius-3:calc(var(--space-1) + var(--space-2));--font-family:var(--md-text-font-family,Inter,Roboto Flex,system-ui,sans-serif);--font-size:16px;--line-height:1.5;--letter-spacing:-.5px;-webkit-font-smoothing:antialiased;align-items:center;display:flex;font-family:var(--font-family);font-size:var(--font-size);height:100vh;justify-content:center;letter-spacing:var(--letter-spacing);line-height:var(--line-height);pointer-events:none;position:absolute;width:100vw}@media (pointer:coarse){.e{height:-webkit-fill-available}}.e *,.e :after,.e :before{box-sizing:border-box}';function Ks(e,{index$:t}){let r=Ue(),n=document.createElement("div");document.body.appendChild(n),n.style.position="fixed",n.style.height="100%",n.style.top="0",n.style.zIndex="4";let o=n.attachShadow({mode:"open"});o.appendChild(A("style",{},qs.toString()));try{Ya(r.search,{highlight:r.features.includes("search.highlight")}),me(t).subscribe(i=>{for(let a of i.items)a.location=new URL(a.location,r.base).toString();Ja(i,o)}),b(e,"click").subscribe(()=>{go()}),Tn("search").pipe(ke(1)).subscribe(()=>go())}catch(i){e.hidden=!0;let a=G("label[for=__search]");a.hidden=!0}return Ke}var Bs=_r(So());function Ys(e,{index$:t,location$:r}){return re([t,r.pipe(J(Ye()),L(n=>!!n.searchParams.get("h")))]).pipe(f(([n,o])=>_p(n.config)(o.searchParams.get("h"))),f(n=>{var a;let o=new Map,i=document.createNodeIterator(e,NodeFilter.SHOW_TEXT);for(let s=i.nextNode();s;s=i.nextNode())if((a=s.parentElement)!=null&&a.offsetHeight){let c=s.textContent,l=n(c);l.length>c.length&&o.set(s,l)}for(let[s,c]of o){let{childNodes:l}=A("span",null,c);s.replaceWith(...Array.from(l))}return{ref:e,nodes:o}}))}function _p(e){let t=e.separator.split("|").map(o=>o.replace(/(\(\?[!=<][^)]+\))/g,"").length===0?"\uFFFD":o).join("|"),r=new RegExp(t,"img"),n=(o,i,a)=>`${i}<mark data-md-highlight>${a}</mark>`;return o=>{o=o.replace(/\s+/g," ").replace(/&/g,"&amp;").trim();let i=new RegExp(`(^|${e.separator}|)(${o.split(r).map(a=>a.replace(/[|\\{}()[\]^$+*?.-]/g,"\\$&")).filter(a=>a.length>0).join("|")})`,"img");return a=>(0,Bs.default)(a).replace(i,n).replace(/<\/mark>(\s+)<mark[^>]*>/img,"$1")}}function yp(e,{viewport$:t,main$:r}){let n=e.closest(".md-grid"),o=n.offsetTop-n.parentElement.offsetTop;return re([r,t]).pipe(f(([{offset:i,height:a},{offset:{y:s}}])=>(a=a+Math.min(o,Math.max(0,s-i))-o,{height:a,locked:s>=i+o})),ie((i,a)=>i.height===a.height&&i.locked===a.locked))}function Ao(e,n){var o=n,{header$:t}=o,r=gr(o,["header$"]);let i=G(".md-sidebar__scrollwrap",e),{y:a}=wt(i);return j(()=>{let s=new I,c=s.pipe(he(),ye(!0)),l=s.pipe(Xe(0,je));return l.pipe(pe(t)).subscribe({next([{height:u},{height:p}]){i.style.height=`${u-2*a}px`,e.style.top=`${p}px`},complete(){i.style.height="",e.style.top=""}}),l.pipe(Sr()).subscribe(()=>{for(let u of P(".md-nav__link--active[href]",e)){if(!u.clientHeight)continue;let p=u.closest(".md-sidebar__scrollwrap");if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2})}}}),me(P("label[tabindex]",e)).pipe(oe(u=>b(u,"click").pipe(Ie(ge),f(()=>u),Q(c)))).subscribe(u=>{let p=G(`[id="${u.htmlFor}"]`);G(`[aria-labelledby="${u.id}"]`).setAttribute("aria-expanded",`${p.checked}`)}),X("content.tooltips")&&me(P("abbr[title]",e)).pipe(oe(u=>Ge(u,{viewport$})),Q(c)).subscribe(),yp(e,r).pipe($(u=>s.next(u)),V(()=>s.complete()),f(u=>H({ref:e},u)))})}function Gs(e,t){if(typeof t!="undefined"){let r=`https://api.github.com/repos/${e}/${t}`;return $t(et(`${r}/releases/latest`).pipe(_e(()=>y),f(n=>({version:n.tag_name})),ot({})),et(r).pipe(_e(()=>y),f(n=>({stars:n.stargazers_count,forks:n.forks_count})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}else{let r=`https://api.github.com/users/${e}`;return et(r).pipe(f(n=>({repositories:n.public_repos})),ot({}))}}function Js(e,t){let r=`https://${e}/api/v4/projects/${encodeURIComponent(t)}`;return $t(et(`${r}/releases/permalink/latest`).pipe(_e(()=>y),f(({tag_name:n})=>({version:n})),ot({})),et(r).pipe(_e(()=>y),f(({star_count:n,forks_count:o})=>({stars:n,forks:o})),ot({}))).pipe(f(([n,o])=>H(H({},n),o)))}function Xs(e){let t=e.match(/^.+github\.com\/([^/]+)\/?([^/]+)?/i);if(t){let[,r,n]=t;return Gs(r,n)}if(t=e.match(/^.+?([^/]*gitlab[^/]+)\/(.+?)\/?$/i),t){let[,r,n]=t;return Js(r,n)}return y}var xp;function wp(e){return xp||(xp=j(()=>{let t=__md_get("__source",sessionStorage);if(t)return Y(t);if(Ee("consent").length){let n=__md_get("__consent");if(!(n&&n.github))return y}return Xs(e.href).pipe($(n=>__md_set("__source",n,sessionStorage)))}).pipe(_e(()=>y),L(t=>Object.keys(t).length>0),f(t=>({facts:t})),se(1)))}function Zs(e){let t=G(":scope > :last-child",e);return j(()=>{let r=new I;return r.subscribe(({facts:n})=>{t.appendChild(bs(n)),t.classList.add("md-source__repository--active")}),wp(e).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Ep(e,{viewport$:t,header$:r}){return Re(document.body).pipe(g(()=>Sn(e,{header$:r,viewport$:t})),f(({offset:{y:n}})=>({hidden:n>=10})),fe("hidden"))}function Qs(e,t){return j(()=>{let r=new I;return r.subscribe({next({hidden:n}){e.hidden=n},complete(){e.hidden=!1}}),(X("navigation.tabs.sticky")?Y({hidden:!1}):Ep(e,t)).pipe($(n=>r.next(n)),V(()=>r.complete()),f(n=>H({ref:e},n)))})}function Tp(e,{viewport$:t,header$:r}){let n=new Map,o=P(".md-nav__link",e);for(let s of o){let c=decodeURIComponent(s.hash.substring(1)),l=Le(`[id="${c}"]`);typeof l!="undefined"&&n.set(s,l)}let i=r.pipe(fe("height"),f(({height:s})=>{let c=ht("main"),l=G(":scope > :first-child",c);return s+.9*(l.offsetTop-c.offsetTop)}),xe());return Re(document.body).pipe(fe("height"),g(s=>j(()=>{let c=[];return Y([...n].reduce((l,[u,p])=>{for(;c.length&&n.get(c[c.length-1]).tagName>=p.tagName;)c.pop();let d=p.offsetTop;for(;!d&&p.parentElement;)p=p.parentElement,d=p.offsetTop;let m=p.offsetParent;for(;m;m=m.offsetParent)d+=m.offsetTop;return l.set([...c=[...c,u]].reverse(),d)},new Map))}).pipe(f(c=>new Map([...c].sort(([,l],[,u])=>l-u))),Ze(i),g(([c,l])=>t.pipe(Or(([u,p],{offset:{y:d},size:m})=>{let h=d+m.height>=Math.floor(s.height);for(;p.length;){let[,v]=p[0];if(v-l<d||h)u=[...u,p.shift()];else break}for(;u.length;){let[,v]=u[u.length-1];if(v-l>=d&&!h)p=[u.pop(),...p];else break}return[u,p]},[[],[...c]]),ie((u,p)=>u[0]===p[0]&&u[1]===p[1])))))).pipe(f(([s,c])=>({prev:s.map(([l])=>l),next:c.map(([l])=>l)})),J({prev:[],next:[]}),Pt(2,1),f(([s,c])=>s.prev.length<c.prev.length?{prev:c.prev.slice(Math.max(0,s.prev.length-1),c.prev.length),next:[]}:{prev:c.prev.slice(-1),next:c.next.slice(0,c.next.length-s.next.length)}))}function ec(e,{viewport$:t,header$:r,main$:n,target$:o}){return j(()=>{let i=new I,a=i.pipe(he(),ye(!0));if(i.subscribe(({prev:s,next:c})=>{for(let[l]of c)l.classList.remove("md-nav__link--passed"),l.classList.remove("md-nav__link--active");for(let[l,[u]]of s.entries())u.classList.add("md-nav__link--passed"),u.classList.toggle("md-nav__link--active",l===s.length-1)}),X("toc.follow")){let s=R(t.pipe(Be(1),f(()=>{})),t.pipe(Be(250),f(()=>"smooth")));i.pipe(L(({prev:c})=>c.length>0),Ze(n.pipe(Ie(ge))),pe(s)).subscribe(([[{prev:c}],l])=>{let[u]=c[c.length-1];if(u.offsetHeight){let p=ki(u);if(typeof p!="undefined"){let d=u.offsetTop-p.offsetTop,{height:m}=Ae(p);p.scrollTo({top:d-m/2,behavior:l})}}})}return X("navigation.tracking")&&t.pipe(Q(a),fe("offset"),Be(250),ke(1),Q(o.pipe(ke(1))),jt({delay:250}),pe(i)).subscribe(([,{prev:s}])=>{let c=Ye(),l=s[s.length-1];if(l&&l.length){let[u]=l,{hash:p}=new URL(u.href);c.hash!==p&&(c.hash=p,history.replaceState({},"",`${c}`))}else c.hash="",history.replaceState({},"",`${c}`)}),Tp(e,{viewport$:t,header$:r}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))})}function Sp(e,{viewport$:t,main$:r,target$:n}){let o=t.pipe(f(({offset:{y:a}})=>a),Pt(2,1),f(([a,s])=>a>s&&s>0),ie()),i=r.pipe(f(({active:a})=>a));return re([i,o]).pipe(f(([a,s])=>!(a&&s)),ie(),Q(n.pipe(ke(1))),ye(!0),jt({delay:250}),f(a=>({hidden:a})))}function tc(e,{viewport$:t,header$:r,main$:n,target$:o}){let i=new I,a=i.pipe(he(),ye(!0));return i.subscribe({next({hidden:s}){e.hidden=s,s?(e.setAttribute("tabindex","-1"),e.blur()):e.removeAttribute("tabindex")},complete(){e.style.top="",e.hidden=!0,e.removeAttribute("tabindex")}}),r.pipe(Q(a),fe("height")).subscribe(({height:s})=>{e.style.top=`${s+16}px`}),b(e,"click").subscribe(s=>{s.preventDefault(),window.scrollTo({top:0})}),Sp(e,{viewport$:t,main$:n,target$:o}).pipe($(s=>i.next(s)),V(()=>i.complete()),f(s=>H({ref:e},s)))}function rc(e,t){return e.protocol=t.protocol,e.hostname=t.hostname,t.port&&(e.port=t.port),e}function Op(e,t){let r=new Map;for(let n of P("url",e)){let o=G("loc",n),i=[rc(new URL(o.textContent),t)];r.set(`${i[0]}`,i);for(let a of P("[rel=alternate]",n)){let s=a.getAttribute("href");s!=null&&i.push(rc(new URL(s),t))}}return r}function dr(e){return ns(new URL("sitemap.xml",e)).pipe(f(t=>Op(t,new URL(e))),_e(()=>Y(new Map)),xe())}function nc({document$:e}){let t=new Map;e.pipe(g(()=>P("link[rel=alternate]")),f(r=>new URL(r.href)),L(r=>!t.has(r.toString())),oe(r=>dr(r).pipe(f(n=>[r,n]),_e(()=>y)))).subscribe(([r,n])=>{t.set(r.toString().replace(/\/$/,""),n)}),b(document.body,"click").pipe(L(r=>!r.metaKey&&!r.ctrlKey),g(r=>{if(r.target instanceof Element){let n=r.target.closest("a");if(n&&!n.target){let o=[...t].find(([p])=>n.href.startsWith(`${p}/`));if(typeof o=="undefined")return y;let[i,a]=o,s=Ye();if(s.href.startsWith(i))return y;let c=Ue(),l=s.href.replace(c.base,"");l=`${i}/${l}`;let u=a.has(l.split("#")[0])?new URL(l,c.base):new URL(i);return r.preventDefault(),Y(u)}}return y})).subscribe(r=>dt(r,!0))}var Co=_r(Mo());function Lp(e){e.setAttribute("data-md-copying","");let t=e.closest("[data-copy]"),r=t?t.getAttribute("data-copy"):e.innerText;return e.removeAttribute("data-md-copying"),r.trimEnd()}function oc({alert$:e}){Co.default.isSupported()&&new U(t=>{new Co.default("[data-clipboard-target], [data-clipboard-text]",{text:r=>r.getAttribute("data-clipboard-text")||Lp(G(r.getAttribute("data-clipboard-target")))}).on("success",r=>t.next(r))}).pipe($(t=>{t.trigger.focus()}),f(()=>Bt("clipboard.copied"))).subscribe(e)}function ic(e,t){if(!(e.target instanceof Element))return y;let r=e.target.closest("a");if(r===null)return y;if(r.target||e.metaKey||e.ctrlKey)return y;let n=new URL(r.href);return n.search=n.hash="",t.has(`${n}`)?(e.preventDefault(),Y(r)):y}function ac(e){let t=new Map;for(let r of P(":scope > *",e.head))t.set(r.outerHTML,r);return t}function sc(e){for(let t of P("[href], [src]",e))for(let r of["href","src"]){let n=t.getAttribute(r);if(n&&!/^(?:[a-z]+:)?\/\//i.test(n)){t[r]=t[r];break}}return Y(e)}function Mp(e){for(let n of["[data-md-component=announce]","[data-md-component=container]","[data-md-component=header-topic]","[data-md-component=outdated]","[data-md-component=logo]","[data-md-component=skip]",...X("navigation.tabs.sticky")?["[data-md-component=tabs]"]:[]]){let o=Le(n),i=Le(n,e);typeof o!="undefined"&&typeof i!="undefined"&&o.replaceWith(i)}let t=ac(document);for(let[n,o]of ac(e))t.has(n)?t.delete(n):document.head.appendChild(o);for(let n of t.values()){let o=n.getAttribute("name");o!=="theme-color"&&o!=="color-scheme"&&n.remove()}let r=ht("container");return nt(P("script",r)).pipe(g(n=>{let o=e.createElement("script");if(n.src){for(let i of n.getAttributeNames())o.setAttribute(i,n.getAttribute(i));return n.replaceWith(o),new U(i=>{o.onload=()=>i.complete()})}else return o.textContent=n.textContent,n.replaceWith(o),y}),he(),ye(document))}function cc({sitemap$:e,location$:t,viewport$:r,progress$:n}){if(location.protocol==="file:")return Ke;Y(document).subscribe(sc);let o=b(document.body,"click").pipe(Ze(e),g(([s,c])=>ic(s,c)),f(({href:s})=>new URL(s)),xe()),i=b(window,"popstate").pipe(f(Ye),xe());o.pipe(pe(r)).subscribe(([s,{offset:c}])=>{history.replaceState(c,""),history.pushState(null,"",s)}),R(o,i).subscribe(t);let a=t.pipe(fe("pathname"),g(s=>En(s,{progress$:n}).pipe(_e(()=>(dt(s,!0),y)))),g(sc),g(Mp),xe());return R(a.pipe(pe(t,(s,c)=>c)),a.pipe(g(()=>t),fe("hash")),t.pipe(ie((s,c)=>s.pathname===c.pathname&&s.hash===c.hash),g(()=>o),$(()=>history.back()))).subscribe(s=>{var c,l;history.state!==null||!s.hash?window.scrollTo(0,(l=(c=history.state)==null?void 0:c.y)!=null?l:0):(history.scrollRestoration="auto",es(s.hash),history.scrollRestoration="manual")}),t.subscribe(()=>{history.scrollRestoration="manual"}),b(window,"beforeunload").subscribe(()=>{history.scrollRestoration="auto"}),r.pipe(fe("offset"),Be(100)).subscribe(({offset:s})=>{history.replaceState(s,"")}),X("navigation.instant.prefetch")&&R(b(document.body,"mousemove"),b(document.body,"focusin")).pipe(Ze(e),g(([s,c])=>ic(s,c)),Be(25),Yn(({href:s})=>s),cn(s=>{let c=document.createElement("link");return c.rel="prefetch",c.href=s.toString(),document.head.appendChild(c),b(c,"load").pipe(f(()=>c),Me(1))})).subscribe(s=>s.remove()),a}function lc(e){var u;let{selectedVersionSitemap:t,selectedVersionBaseURL:r,currentLocation:n,currentBaseURL:o}=e,i=(u=Ho(o))==null?void 0:u.pathname;if(i===void 0)return;let a=kp(n.pathname,i);if(a===void 0)return;let s=Cp(t.keys());if(!t.has(s))return;let c=Ho(a,s);if(!c||!t.has(c.href))return;let l=Ho(a,r);if(l)return l.hash=n.hash,l.search=n.search,l}function Ho(e,t){try{return new URL(e,t)}catch(r){return}}function kp(e,t){if(e.startsWith(t))return e.slice(t.length)}function Ap(e,t){let r=Math.min(e.length,t.length),n;for(n=0;n<r&&e[n]===t[n];++n);return n}function Cp(e){let t;for(let r of e)t===void 0?t=r:t=t.slice(0,Ap(t,r));return t!=null?t:""}function uc({document$:e}){let t=Ue(),r=et(new URL("../versions.json",t.base)).pipe(_e(()=>y)),n=r.pipe(f(o=>{let[,i]=t.base.match(/([^/]+)\/?$/);return o.find(({version:a,aliases:s})=>a===i||s.includes(i))||o[0]}));r.pipe(f(o=>new Map(o.map(i=>[`${new URL(`../${i.version}/`,t.base)}`,i]))),g(o=>b(document.body,"click").pipe(L(i=>!i.metaKey&&!i.ctrlKey),pe(n),g(([i,a])=>{if(i.target instanceof Element){let s=i.target.closest("a");if(s&&!s.target&&o.has(s.href)){let c=s.href;return!i.target.closest(".md-version")&&o.get(c)===a?y:(i.preventDefault(),Y(new URL(c)))}}return y}),g(i=>dr(i).pipe(f(a=>{var s;return(s=lc({selectedVersionSitemap:a,selectedVersionBaseURL:i,currentLocation:Ye(),currentBaseURL:t.base}))!=null?s:i})))))).subscribe(o=>dt(o,!0)),re([r,n]).subscribe(([o,i])=>{G(".md-header__topic").appendChild(_s(o,i))}),e.pipe(g(()=>n)).subscribe(o=>{var s;let i=new URL(t.base),a=__md_get("__outdated",sessionStorage,i);if(a===null){a=!0;let c=((s=t.version)==null?void 0:s.default)||"latest";Array.isArray(c)||(c=[c]);e:for(let l of c)for(let u of o.aliases.concat(o.version))if(new RegExp(l,"i").test(u)){a=!1;break e}__md_set("__outdated",a,sessionStorage,i)}if(a)for(let c of Ee("outdated"))c.hidden=!1})}function pc({document$:e,viewport$:t}){e.pipe(g(()=>P(".md-ellipsis")),oe(r=>Et(r).pipe(Q(e.pipe(ke(1))),L(n=>n),f(()=>r),Me(1))),L(r=>r.offsetWidth<r.scrollWidth),oe(r=>{let n=r.innerText,o=r.closest("a")||r;return o.title=n,X("content.tooltips")?Ge(o,{viewport$:t}).pipe(Q(e.pipe(ke(1))),V(()=>o.removeAttribute("title"))):y})).subscribe(),X("content.tooltips")&&e.pipe(g(()=>P(".md-status")),oe(r=>Ge(r,{viewport$:t}))).subscribe()}function fc({document$:e,tablet$:t}){e.pipe(g(()=>P(".md-toggle--indeterminate")),$(r=>{r.indeterminate=!0,r.checked=!1}),oe(r=>b(r,"change").pipe(Xn(()=>r.classList.contains("md-toggle--indeterminate")),f(()=>r))),pe(t)).subscribe(([r,n])=>{r.classList.remove("md-toggle--indeterminate"),n&&(r.checked=!1)})}function Hp(){return/(iPad|iPhone|iPod)/.test(navigator.userAgent)}function mc({document$:e}){e.pipe(g(()=>P("[data-md-scrollfix]")),$(t=>t.removeAttribute("data-md-scrollfix")),L(Hp),oe(t=>b(t,"touchstart").pipe(f(()=>t)))).subscribe(t=>{let r=t.scrollTop;r===0?t.scrollTop=1:r+t.offsetHeight===t.scrollHeight&&(t.scrollTop=r-1)})}Object.entries||(Object.entries=function(e){let t=[];for(let r of Object.keys(e))t.push([r,e[r]]);return t});Object.values||(Object.values=function(e){let t=[];for(let r of Object.keys(e))t.push(e[r]);return t});typeof Element!="undefined"&&(Element.prototype.scrollTo||(Element.prototype.scrollTo=function(e,t){typeof e=="object"?(this.scrollLeft=e.left,this.scrollTop=e.top):(this.scrollLeft=e,this.scrollTop=t)}),Element.prototype.replaceWith||(Element.prototype.replaceWith=function(...e){let t=this.parentNode;if(t){e.length===0&&t.removeChild(this);for(let r=e.length-1;r>=0;r--){let n=e[r];typeof n=="string"?n=document.createTextNode(n):n.parentNode&&n.parentNode.removeChild(n),r?t.insertBefore(this.previousSibling,n):t.replaceChild(n,this)}}}));function $p(){return location.protocol==="file:"?ar(`${new URL("search.js",Mn.base)}`).pipe(f(()=>__index),_e(()=>Ke),se(1)):et(new URL("search.json",Mn.base))}document.documentElement.classList.remove("no-js");document.documentElement.classList.add("js");var vt=Si(),Ur=Za(),hr=ts(Ur),hc=Xa(),ze=cs(),$o=Ir("(min-width: 60em)"),vc=Ir("(min-width: 76.25em)"),bc=rs(),Mn=Ue(),gc=Le(".md-search")?$p():Ke,Po=new I;oc({alert$:Po});nc({document$:vt});var Io=new I,_c=dr(Mn.base);X("navigation.instant")&&cc({sitemap$:_c,location$:Ur,viewport$:ze,progress$:Io}).subscribe(vt);var dc;((dc=Mn.version)==null?void 0:dc.provider)==="mike"&&uc({document$:vt});R(Ur,hr).pipe(It(125)).subscribe(()=>{Eo("drawer",!1),Eo("search",!1)});hc.pipe(L(({mode:e,meta:t})=>e==="global"&&!t)).subscribe(e=>{switch(e.type){case",":case"p":let t=document.querySelector("link[rel=prev]");t instanceof HTMLLinkElement&&dt(t);break;case".":case"n":let r=document.querySelector("link[rel=next]");r instanceof HTMLLinkElement&&dt(r);break;case"/":let n=document.querySelector("[data-md-component=search] button");n instanceof HTMLButtonElement&&n.click();break;case"Enter":let o=xt();o instanceof HTMLLabelElement&&o.click()}});pc({viewport$:ze,document$:vt});fc({document$:vt,tablet$:$o});mc({document$:vt});var Lt=Us(ht("header"),{viewport$:ze}),Fr=vt.pipe(f(()=>ht("main")),g(e=>Ws(e,{viewport$:ze,header$:Lt})),se(1)),Pp=R(...Ee("consent").map(e=>us(e,{target$:hr})),...Ee("dialog").map(e=>Fs(e,{alert$:Po})),...Ee("palette").map(e=>Vs(e)),...Ee("progress").map(e=>zs(e,{progress$:Io})),...Ee("search").map(e=>Ks(e,{index$:gc})),...Ee("source").map(e=>Zs(e))),Ip=j(()=>R(...Ee("announce").map(e=>ls(e)),...Ee("content").map(e=>js(e,{sitemap$:_c,viewport$:ze,target$:hr,print$:bc})),...Ee("content").map(e=>X("search.highlight")?Ys(e,{index$:gc,location$:Ur}):y),...Ee("header").map(e=>Ns(e,{viewport$:ze,header$:Lt,main$:Fr})),...Ee("header-title").map(e=>Ds(e,{viewport$:ze,header$:Lt})),...Ee("sidebar").map(e=>e.getAttribute("data-md-type")==="navigation"?yo(vc,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr})):yo($o,()=>Ao(e,{viewport$:ze,header$:Lt,main$:Fr}))),...Ee("tabs").map(e=>Qs(e,{viewport$:ze,header$:Lt})),...Ee("toc").map(e=>ec(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})),...Ee("top").map(e=>tc(e,{viewport$:ze,header$:Lt,main$:Fr,target$:hr})))),yc=vt.pipe(g(()=>Ip),Rt(Pp),se(1));yc.subscribe();window.document$=vt;window.location$=Ur;window.target$=hr;window.keyboard$=hc;window.viewport$=ze;window.tablet$=$o;window.screen$=vc;window.print$=bc;window.alert$=Po;window.progress$=Io;window.component$=yc;})();
-/*! update cache: 20260331044502 */
+/*! update cache: 20260331053155 */
diff --git a/zh-hant/chapter_stack_and_queue/queue/index.html b/zh-hant/chapter_stack_and_queue/queue/index.html
index d50b1b659..a8efec54a 100644
--- a/zh-hant/chapter_stack_and_queue/queue/index.html
+++ b/zh-hant/chapter_stack_and_queue/queue/index.html
@@ -6454,7 +6454,7 @@
 <a id="__codelineno-36-2" name="__codelineno-36-2" href="#__codelineno-36-2"></a><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-36-3" name="__codelineno-36-3" href="#__codelineno-36-3"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">nums</span><span class="p">;</span><span class="w">       </span><span class="c1">// 用於儲存佇列元素的陣列</span>
 <a id="__codelineno-36-4" name="__codelineno-36-4" href="#__codelineno-36-4"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">front</span><span class="p">;</span><span class="w">       </span><span class="c1">// 佇列首指標，指向佇列首元素</span>
-<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// 尾指標，指向佇列尾 + 1</span>
+<a id="__codelineno-36-5" name="__codelineno-36-5" href="#__codelineno-36-5"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queSize</span><span class="p">;</span><span class="w">     </span><span class="c1">// 當前佇列的元素數量</span>
 <a id="__codelineno-36-6" name="__codelineno-36-6" href="#__codelineno-36-6"></a><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">queCapacity</span><span class="p">;</span><span class="w"> </span><span class="c1">// 佇列容量</span>
 <a id="__codelineno-36-7" name="__codelineno-36-7" href="#__codelineno-36-7"></a><span class="p">}</span><span class="w"> </span><span class="n">ArrayQueue</span><span class="p">;</span>
 <a id="__codelineno-36-8" name="__codelineno-36-8" href="#__codelineno-36-8"></a>
diff --git a/zh-hant/javascripts/katex.js b/zh-hant/javascripts/katex.js
index 1e9c55dbf..f080d1565 100644
--- a/zh-hant/javascripts/katex.js
+++ b/zh-hant/javascripts/katex.js
@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260331044502 */
+/*! update cache: 20260331053155 */
diff --git a/zh-hant/javascripts/mathjax.js b/zh-hant/javascripts/mathjax.js
index 61456f400..4bd85bedf 100644
--- a/zh-hant/javascripts/mathjax.js
+++ b/zh-hant/javascripts/mathjax.js
@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260331044502 */
+/*! update cache: 20260331053155 */
diff --git a/zh-hant/javascripts/starfield.js b/zh-hant/javascripts/starfield.js
index 9d6a209cd..9b2b85222 100644
--- a/zh-hant/javascripts/starfield.js
+++ b/zh-hant/javascripts/starfield.js
@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260331044502 */
+/*! update cache: 20260331053155 */
diff --git a/zh-hant/search.json b/zh-hant/search.json
index b77e4e8b3..ced605d8a 100644
--- a/zh-hant/search.json
+++ b/zh-hant/search.json
@@ -1 +1 @@
-{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"第 16 章   附錄","text":"","path":["第 16 章 &nbsp; 附錄"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"本章內容","text":"<ul> <li>16.1   程式設計環境安裝</li> <li>16.2   一起參與創作</li> <li>16.3   術語表</li> </ul>","path":["第 16 章 &nbsp; 附錄"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   一起參與創作","text":"<p>由於筆者能力有限，書中難免存在一些遺漏和錯誤，請您諒解。如果您發現了筆誤、連結失效、內容缺失、文字歧義、解釋不清晰或行文結構不合理等問題，請協助我們進行修正，以給讀者提供更優質的學習資源。</p> <p>所有撰稿人的 GitHub ID 將在本書倉庫、網頁版和 PDF 版的主頁上進行展示，以感謝他們對開源社群的無私奉獻。</p> <p>開源的魅力</p> <p>紙質圖書的兩次印刷的間隔時間往往較久，內容更新非常不方便。</p> <p>而在本開源書中，內容更迭的時間被縮短至數日甚至幾個小時。</p>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   內容微調","text":"<p>如圖 16-3 所示，每個頁面的右上角都有“編輯圖示”。您可以按照以下步驟修改文字或程式碼。</p> <ol> <li>點選“編輯圖示”，如果遇到“需要 Fork 此倉庫”的提示，請同意該操作。</li> <li>修改 Markdown 源檔案內容，檢查內容的正確性，並儘量保持排版格式的統一。</li> <li>在頁面底部填寫修改說明，然後點選“Propose file change”按鈕。頁面跳轉後，點選“Create pull request”按鈕即可發起拉取請求。</li> </ol> <p></p> <p> 圖 16-3   頁面編輯按鍵 </p> <p>圖片無法直接修改，需要透過新建 Issue 或評論留言來描述問題，我們會盡快重新繪製並替換圖片。</p>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   內容創作","text":"<p>如果您有興趣參與此開源專案，包括將程式碼翻譯成其他程式語言、擴展文章內容等，那麼需要實施以下 Pull Request 工作流程。</p> <ol> <li>登入 GitHub ，將本書的程式碼倉庫 Fork 到個人帳號下。</li> <li>進入您的 Fork 倉庫網頁，使用 <code>git clone</code> 命令將倉庫克隆至本地。</li> <li>在本地進行內容創作，並進行完整測試，驗證程式碼的正確性。</li> <li>將本地所做更改 Commit ，然後 Push 至遠端倉庫。</li> <li>重新整理倉庫網頁，點選“Create pull request”按鈕即可發起拉取請求。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Docker 部署","text":"<p>在 <code>hello-algo</code> 根目錄下，執行以下 Docker 指令碼，即可在 <code>http://localhost:8000</code> 訪問本專案：</p> <pre><code>docker-compose up -d\n</code></pre> <p>使用以下命令即可刪除部署：</p> <pre><code>docker-compose down\n</code></pre>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   程式設計環境安裝","text":"","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   安裝 IDE","text":"<p>推薦使用開源、輕量的 VS Code 作為本地整合開發環境（IDE）。訪問 VS Code 官網，根據作業系統選擇相應版本的 VS Code 進行下載和安裝。</p> <p></p> <p> 圖 16-1   從官網下載 VS Code </p> <p>VS Code 擁有強大的擴展包生態系統，支持大多數程式語言的執行和除錯。以 Python 為例，安裝“Python Extension Pack”擴展包之後，即可進行 Python 程式碼除錯。安裝步驟如圖 16-2 所示。</p> <p></p> <p> 圖 16-2   安裝 VS Code 擴展包 </p>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   安裝語言環境","text":"","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Python 環境","text":"<ol> <li>下載並安裝 Miniconda3 ，需要 Python 3.10 或更新版本。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>python</code> ，安裝 Python Extension Pack 。</li> <li>（可選）在命令列輸入 <code>pip install black</code> ，安裝程式碼格式化工具。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   C/C++ 環境","text":"<ol> <li>Windows 系統需要安裝 MinGW（配置教程）；MacOS 自帶 Clang ，無須安裝。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>c++</code> ，安裝 C/C++ Extension Pack 。</li> <li>（可選）開啟 Settings 頁面，搜尋 <code>Clang_format_fallback Style</code> 程式碼格式化選項，設定為 <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code> 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Java 環境","text":"<ol> <li>下載並安裝 OpenJDK（版本需滿足 &gt; JDK 9）。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>java</code> ，安裝 Extension Pack for Java 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   C# 環境","text":"<ol> <li>下載並安裝 .Net 8.0 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>C# Dev Kit</code> ，安裝 C# Dev Kit （配置教程）。</li> <li>也可使用 Visual Studio（安裝教程）。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Go 環境","text":"<ol> <li>下載並安裝 go 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>go</code> ，安裝 Go 。</li> <li>按快捷鍵 <code>Ctrl + Shift + P</code> 撥出命令欄，輸入 go ，選擇 <code>Go: Install/Update Tools</code> ，全部勾選並安裝即可。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Swift 環境","text":"<ol> <li>下載並安裝 Swift 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>swift</code> ，安裝 Swift for Visual Studio Code 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   JavaScript 環境","text":"<ol> <li>下載並安裝 Node.js 。</li> <li>（可選）在 VS Code 的擴充功能市場中搜索 <code>Prettier</code> ，安裝程式碼格式化工具。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   TypeScript 環境","text":"<ol> <li>同 JavaScript 環境安裝步驟。</li> <li>安裝 TypeScript Execute (tsx) 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>typescript</code> ，安裝 Pretty TypeScript Errors 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Dart 環境","text":"<ol> <li>下載並安裝 Dart 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>dart</code> ，安裝 Dart 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Rust 環境","text":"<ol> <li>下載並安裝 Rust 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>rust</code> ，安裝 rust-analyzer 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   術語表","text":"<p>表 16-1 列出了書中出現的重要術語，值得注意以下幾點。</p> <ul> <li>建議記住名詞的英文叫法，以便閱讀英文文獻。</li> <li>部分名詞在簡體中文和繁體中文下的叫法不同。</li> </ul> <p> 表 16-1   資料結構與演算法的重要名詞 </p> English 簡體中文 繁體中文 algorithm 算法 演算法 data structure 数据结构 資料結構 code 代码 程式碼 file 文件 檔案 function 函数 函式 method 方法 方法 variable 变量 變數 asymptotic complexity analysis 渐近复杂度分析 漸近複雜度分析 time complexity 时间复杂度 時間複雜度 space complexity 空间复杂度 空間複雜度 loop 循环 迴圈 iteration 迭代 迭代 recursion 递归 遞迴 tail recursion 尾递归 尾遞迴 recursion tree 递归树 遞迴樹 big-\\(O\\) notation 大 \\(O\\) 记号 大 \\(O\\) 記號 asymptotic upper bound 渐近上界 漸近上界 sign-magnitude 原码 原碼 1’s complement 反码 一補數 2’s complement 补码 二補數 array 数组 陣列 index 索引 索引 linked list 链表 鏈結串列 linked list node, list node 链表节点 鏈結串列節點 head node 头节点 頭節點 tail node 尾节点 尾節點 list 列表 串列 dynamic array 动态数组 動態陣列 hard disk 硬盘 硬碟 random-access memory (RAM) 内存 記憶體 cache memory 缓存 快取 cache miss 缓存未命中 快取未命中 cache hit rate 缓存命中率 快取命中率 stack 栈 堆疊 top of the stack 栈顶 堆疊頂 bottom of the stack 栈底 堆疊底 queue 队列 佇列 double-ended queue 双向队列 雙向佇列 front of the queue 队首 佇列首 rear of the queue 队尾 佇列尾 hash table 哈希表 雜湊表 hash set 哈希集合 雜湊集合 bucket 桶 桶 hash function 哈希函数 雜湊函式 hash collision 哈希冲突 雜湊衝突 load factor 负载因子 負載因子 separate chaining 链式地址 鏈結位址 open addressing 开放寻址 開放定址 linear probing 线性探测 線性探查 lazy deletion 懒删除 懶刪除 binary tree 二叉树 二元樹 tree node 树节点 樹節點 left-child node 左子节点 左子節點 right-child node 右子节点 右子節點 parent node 父节点 父節點 left subtree 左子树 左子樹 right subtree 右子树 右子樹 root node 根节点 根節點 leaf node 叶节点 葉節點 edge 边 邊 level 层 層 degree 度 度 height 高度 高度 depth 深度 深度 perfect binary tree 完美二叉树 完美二元樹 complete binary tree 完全二叉树 完全二元樹 full binary tree 完满二叉树 完滿二元樹 balanced binary tree 平衡二叉树 平衡二元樹 binary search tree 二叉搜索树 二元搜尋樹 AVL tree AVL 树 AVL 樹 red-black tree 红黑树 紅黑樹 level-order traversal 层序遍历 層序走訪 breadth-first traversal 广度优先遍历 廣度優先走訪 depth-first traversal 深度优先遍历 深度優先走訪 binary search tree 二叉搜索树 二元搜尋樹 balanced binary search tree 平衡二叉搜索树 平衡二元搜尋樹 balance factor 平衡因子 平衡因子 heap 堆 堆積 max heap 大顶堆 大頂堆積 min heap 小顶堆 小頂堆積 priority queue 优先队列 優先佇列 heapify 堆化 堆積化 top-\\(k\\) problem Top-\\(k\\) 问题 Top-\\(k\\) 問題 graph 图 圖 vertex 顶点 頂點 undirected graph 无向图 無向圖 directed graph 有向图 有向圖 connected graph 连通图 連通圖 disconnected graph 非连通图 非連通圖 weighted graph 有权图 有權圖 adjacency 邻接 鄰接 path 路径 路徑 in-degree 入度 入度 out-degree 出度 出度 adjacency matrix 邻接矩阵 鄰接矩陣 adjacency list 邻接表 鄰接表 breadth-first search 广度优先搜索 廣度優先搜尋 depth-first search 深度优先搜索 深度優先搜尋 binary search 二分查找 二分搜尋 searching algorithm 搜索算法 搜尋演算法 sorting algorithm 排序算法 排序演算法 selection sort 选择排序 選擇排序 bubble sort 冒泡排序 泡沫排序 insertion sort 插入排序 插入排序 quick sort 快速排序 快速排序 merge sort 归并排序 合併排序 heap sort 堆排序 堆積排序 bucket sort 桶排序 桶排序 counting sort 计数排序 計數排序 radix sort 基数排序 基數排序 divide and conquer 分治 分治 hanota problem 汉诺塔问题 河內塔問題 backtracking algorithm 回溯算法 回溯演算法 constraint 约束 約束 solution 解 解 state 状态 狀態 pruning 剪枝 剪枝 permutations problem 全排列问题 全排列問題 subset-sum problem 子集和问题 子集合問題 \\(n\\)-queens problem \\(n\\) 皇后问题 \\(n\\) 皇后問題 dynamic programming 动态规划 動態規劃 initial state 初始状态 初始狀態 state-transition equation 状态转移方程 狀態轉移方程 knapsack problem 背包问题 背包問題 edit distance problem 编辑距离问题 編輯距離問題 greedy algorithm 贪心算法 貪婪演算法","path":["第 16 章 &nbsp; 附錄","16.3 &nbsp; 術語表"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"第 4 章   陣列與鏈結串列","text":"<p>Abstract</p> <p>資料結構的世界如同一堵厚實的磚牆。</p> <p>陣列的磚塊整齊排列，逐個緊貼。鏈結串列的磚塊分散各處，連線的藤蔓自由地穿梭於磚縫之間。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"本章內容","text":"<ul> <li>4.1   陣列</li> <li>4.2   鏈結串列</li> <li>4.3   串列</li> <li>4.4   記憶體與快取 *</li> <li>4.5   小結</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   陣列","text":"<p>陣列（array）是一種線性資料結構，其將相同型別的元素儲存在連續的記憶體空間中。我們將元素在陣列中的位置稱為該元素的索引（index）。圖 4-1 展示了陣列的主要概念和儲存方式。</p> <p></p> <p> 圖 4-1   陣列定義與儲存方式 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   陣列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   初始化陣列","text":"<p>我們可以根據需求選用陣列的兩種初始化方式：無初始值、給定初始值。在未指定初始值的情況下，大多數程式語言會將陣列元素初始化為 \\(0\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># 初始化陣列\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* 初始化陣列 */\n// 儲存在堆疊上\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// 儲存在堆積上（需要手動釋放空間）\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* 初始化陣列 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* 初始化陣列 */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* 初始化陣列 */\nvar arr [5]int\n// 在 Go 中，指定長度時（[5]int）為陣列，不指定長度時（[]int）為切片\n// 由於 Go 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度\n// 為了方便實現擴容 extend() 方法，以下將切片（Slice）看作陣列（Array）\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* 初始化陣列 */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* 初始化陣列 */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* 初始化陣列 */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* 初始化陣列 */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* 初始化陣列 */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// 在 Rust 中，指定長度時（[i32; 5]）為陣列，不指定長度時（&amp;[i32]）為切片\n// 由於 Rust 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度\n// Vector 是 Rust 一般情況下用作動態陣列的型別\n// 為了方便實現擴容 extend() 方法，以下將 vector 看作陣列（array）\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* 初始化陣列 */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* 初始化陣列 */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># 初始化陣列\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   訪問元素","text":"<p>陣列元素被儲存在連續的記憶體空間中，這意味著計算陣列元素的記憶體位址非常容易。給定陣列記憶體位址（首元素記憶體位址）和某個元素的索引，我們可以使用圖 4-2 所示的公式計算得到該元素的記憶體位址，從而直接訪問該元素。</p> <p></p> <p> 圖 4-2   陣列元素的記憶體位址計算 </p> <p>觀察圖 4-2 ，我們發現陣列首個元素的索引為 \\(0\\) ，這似乎有些反直覺，因為從 \\(1\\) 開始計數會更自然。但從位址計算公式的角度看，索引本質上是記憶體位址的偏移量。首個元素的位址偏移量是 \\(0\\) ，因此它的索引為 \\(0\\) 是合理的。</p> <p>在陣列中訪問元素非常高效，我們可以在 \\(O(1)\\) 時間內隨機訪問陣列中的任意一個元素。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"隨機訪問元素\"\"\"\n    # 在區間 [0, len(nums)-1] 中隨機抽取一個數字\n    random_index = random.randint(0, len(nums) - 1)\n    # 獲取並返回隨機元素\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* 隨機訪問元素 */\nint randomAccess(int *nums, int size) {\n    // 在區間 [0, size) 中隨機抽取一個數字\n    int randomIndex = rand() % size;\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* 隨機訪問元素 */\nint randomAccess(int[] nums) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* 隨機訪問元素 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // 在區間 [0, nums.Length) 中隨機抽取一個數字\n    int randomIndex = random.Next(nums.Length);\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* 隨機訪問元素 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    randomIndex := rand.Intn(len(nums))\n    // 獲取並返回隨機元素\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* 隨機訪問元素 */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // 在區間 [0, nums.count) 中隨機抽取一個數字\n    let randomIndex = nums.indices.randomElement()!\n    // 獲取並返回隨機元素\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* 隨機訪問元素 */\nfunction randomAccess(nums) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    const random_index = Math.floor(Math.random() * nums.length);\n    // 獲取並返回隨機元素\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* 隨機訪問元素 */\nfunction randomAccess(nums: number[]): number {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    const random_index = Math.floor(Math.random() * nums.length);\n    // 獲取並返回隨機元素\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* 隨機訪問元素 */\nint randomAccess(List&lt;int&gt; nums) {\n  // 在區間 [0, nums.length) 中隨機抽取一個數字\n  int randomIndex = Random().nextInt(nums.length);\n  // 獲取並返回隨機元素\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* 隨機訪問元素 */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // 在區間 [0, nums.len()) 中隨機抽取一個數字\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // 獲取並返回隨機元素\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* 隨機訪問元素 */\nint randomAccess(int *nums, int size) {\n    // 在區間 [0, size) 中隨機抽取一個數字\n    int randomIndex = rand() % size;\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* 隨機訪問元素 */\nfun randomAccess(nums: IntArray): Int {\n    // 在區間 [0, nums.size) 中隨機抽取一個數字\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // 獲取並返回隨機元素\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### 隨機訪問元素 ###\ndef random_access(nums)\n  # 在區間 [0, nums.length) 中隨機抽取一個數字\n  random_index = Random.rand(0...nums.length)\n\n  # 獲取並返回隨機元素\n  nums[random_index]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   插入元素","text":"<p>陣列元素在記憶體中是“緊挨著的”，它們之間沒有空間再存放任何資料。如圖 4-3 所示，如果想在陣列中間插入一個元素，則需要將該元素之後的所有元素都向後移動一位，之後再把元素賦值給該索引。</p> <p></p> <p> 圖 4-3   陣列插入元素示例 </p> <p>值得注意的是，由於陣列的長度是固定的，因此插入一個元素必定會導致陣列尾部元素“丟失”。我們將這個問題的解決方案留在“串列”章節中討論。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"在陣列的索引 index 處插入元素 num\"\"\"\n    # 把索引 index 以及之後的所有元素向後移動一位\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # 將 num 賦給 index 處的元素\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int *nums, int size, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int[] nums, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid Insert(int[] nums, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunc insert(nums []int, num int, index int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunction insert(nums, num, index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunction insert(nums: number[], num: number, index: number): void {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* 在陣列的索引 index 處插入元素 _num */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // 把索引 index 以及之後的所有元素向後移動一位\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // 將 _num 賦給 index 處元素\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int *nums, int size, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### 在陣列的索引 index 處插入元素 num ###\ndef insert(nums, num, index)\n  # 把索引 index 以及之後的所有元素向後移動一位\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # 將 num 賦給 index 處的元素\n  nums[index] = num\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   刪除元素","text":"<p>同理，如圖 4-4 所示，若想刪除索引 \\(i\\) 處的元素，則需要把索引 \\(i\\) 之後的元素都向前移動一位。</p> <p></p> <p> 圖 4-4   陣列刪除元素示例 </p> <p>請注意，刪除元素完成後，原先末尾的元素變得“無意義”了，所以我們無須特意去修改它。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"刪除索引 index 處的元素\"\"\"\n    # 把索引 index 之後的所有元素向前移動一位\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(int *nums, int size, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(int[] nums, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* 刪除索引 index 處的元素 */\nvoid Remove(int[] nums, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* 刪除索引 index 處的元素 */\nfunc remove(nums []int, index int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* 刪除索引 index 處的元素 */\nfunc remove(nums: inout [Int], index: Int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* 刪除索引 index 處的元素 */\nfunction remove(nums, index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* 刪除索引 index 處的元素 */\nfunction remove(nums: number[], index: number): void {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // 把索引 index 之後的所有元素向前移動一位\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* 刪除索引 index 處的元素 */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* 刪除索引 index 處的元素 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nvoid removeItem(int *nums, int size, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* 刪除索引 index 處的元素 */\nfun remove(nums: IntArray, index: Int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### 刪除索引 index 處的元素 ###\ndef remove(nums, index)\n  # 把索引 index 之後的所有元素向前移動一位\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總的來看，陣列的插入與刪除操作有以下缺點。</p> <ul> <li>時間複雜度高：陣列的插入和刪除的平均時間複雜度均為 \\(O(n)\\) ，其中 \\(n\\) 為陣列長度。</li> <li>丟失元素：由於陣列的長度不可變，因此在插入元素後，超出陣列長度範圍的元素會丟失。</li> <li>記憶體浪費：我們可以初始化一個比較長的陣列，只用前面一部分，這樣在插入資料時，丟失的末尾元素都是“無意義”的，但這樣做會造成部分記憶體空間浪費。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   走訪陣列","text":"<p>在大多數程式語言中，我們既可以透過索引走訪陣列，也可以直接走訪獲取陣列中的每個元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"走訪陣列\"\"\"\n    count = 0\n    # 透過索引走訪陣列\n    for i in range(len(nums)):\n        count += nums[i]\n    # 直接走訪陣列元素\n    for num in nums:\n        count += num\n    # 同時走訪資料索引和元素\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* 走訪陣列 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* 走訪陣列 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* 走訪陣列 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* 走訪陣列 */\nfunc traverse(nums []int) {\n    count := 0\n    // 透過索引走訪陣列\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // 直接走訪陣列元素\n    for _, num := range nums {\n        count += num\n    }\n    // 同時走訪資料索引和元素\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* 走訪陣列 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // 透過索引走訪陣列\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // 直接走訪陣列元素\n    for num in nums {\n        count += num\n    }\n    // 同時走訪資料索引和元素\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* 走訪陣列 */\nfunction traverse(nums) {\n    let count = 0;\n    // 透過索引走訪陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* 走訪陣列 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // 透過索引走訪陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* 走訪陣列元素 */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // 透過索引走訪陣列\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // 直接走訪陣列元素\n  for (int _num in nums) {\n    count += _num;\n  }\n  // 透過 forEach 方法走訪陣列\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* 走訪陣列 */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // 透過索引走訪陣列\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // 直接走訪陣列元素\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* 走訪陣列 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* 走訪陣列 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // 透過索引走訪陣列\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // 直接走訪陣列元素\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### 走訪陣列 ###\ndef traverse(nums)\n  count = 0\n\n  # 透過索引走訪陣列\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # 直接走訪陣列元素\n  for num in nums\n    count += num\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   查詢元素","text":"<p>在陣列中查詢指定元素需要走訪陣列，每輪判斷元素值是否匹配，若匹配則輸出對應索引。</p> <p>因為陣列是線性資料結構，所以上述查詢操作被稱為“線性查詢”。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"在陣列中查詢指定元素\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* 在陣列中查詢指定元素 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* 在陣列中查詢指定元素 */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* 在陣列中查詢指定元素 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* 在陣列中查詢指定元素 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* 在陣列中查詢指定元素 */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* 在陣列中查詢指定元素 */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* 在陣列中查詢指定元素 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* 在陣列中查詢指定元素 */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* 在陣列中查詢指定元素 */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* 在陣列中查詢指定元素 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* 在陣列中查詢指定元素 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### 在陣列中查詢指定元素 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   擴容陣列","text":"<p>在複雜的系統環境中，程式難以保證陣列之後的記憶體空間是可用的，從而無法安全地擴展陣列容量。因此在大多數程式語言中，陣列的長度是不可變的。</p> <p>如果我們希望擴容陣列，則需重新建立一個更大的陣列，然後把原陣列元素依次複製到新陣列。這是一個 \\(O(n)\\) 的操作，在陣列很大的情況下非常耗時。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"擴展陣列長度\"\"\"\n    # 初始化一個擴展長度後的陣列\n    res = [0] * (len(nums) + enlarge)\n    # 將原陣列中的所有元素複製到新陣列\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # 返回擴展後的新陣列\n    return res\n</code></pre> array.cpp<pre><code>/* 擴展陣列長度 */\nint *extend(int *nums, int size, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int *res = new int[size + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 釋放記憶體\n    delete[] nums;\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.java<pre><code>/* 擴展陣列長度 */\nint[] extend(int[] nums, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int[] res = new int[nums.length + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.cs<pre><code>/* 擴展陣列長度 */\nint[] Extend(int[] nums, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int[] res = new int[nums.Length + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.go<pre><code>/* 擴展陣列長度 */\nfunc extend(nums []int, enlarge int) []int {\n    // 初始化一個擴展長度後的陣列\n    res := make([]int, len(nums)+enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for i, num := range nums {\n        res[i] = num\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.swift<pre><code>/* 擴展陣列長度 */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // 初始化一個擴展長度後的陣列\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.js<pre><code>/* 擴展陣列長度 */\n// 請注意，JavaScript 的 Array 是動態陣列，可以直接擴展\n// 為了方便學習，本函式將 Array 看作長度不可變的陣列\nfunction extend(nums, enlarge) {\n    // 初始化一個擴展長度後的陣列\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 將原陣列中的所有元素複製到新陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.ts<pre><code>/* 擴展陣列長度 */\n// 請注意，TypeScript 的 Array 是動態陣列，可以直接擴展\n// 為了方便學習，本函式將 Array 看作長度不可變的陣列\nfunction extend(nums: number[], enlarge: number): number[] {\n    // 初始化一個擴展長度後的陣列\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 將原陣列中的所有元素複製到新陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.dart<pre><code>/* 擴展陣列長度 */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // 初始化一個擴展長度後的陣列\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // 將原陣列中的所有元素複製到新陣列\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // 返回擴展後的新陣列\n  return res;\n}\n</code></pre> array.rs<pre><code>/* 擴展陣列長度 */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // 初始化一個擴展長度後的陣列\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // 將原陣列中的所有元素複製到新\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // 返回擴展後的新陣列\n    res\n}\n</code></pre> array.c<pre><code>/* 擴展陣列長度 */\nint *extend(int *nums, int size, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 初始化擴展後的空間\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.kt<pre><code>/* 擴展陣列長度 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // 初始化一個擴展長度後的陣列\n    val res = IntArray(nums.size + enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.rb<pre><code>### 擴展陣列長度 ###\n# 請注意，Ruby 的 Array 是動態陣列，可以直接擴展\n# 為了方便學習，本函式將 Array 看作長度不可變的陣列\ndef extend(nums, enlarge)\n  # 初始化一個擴展長度後的陣列\n  res = Array.new(nums.length + enlarge, 0)\n\n  # 將原陣列中的所有元素複製到新陣列\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # 返回擴展後的新陣列\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   陣列的優點與侷限性","text":"<p>陣列儲存在連續的記憶體空間內，且元素型別相同。這種做法包含豐富的先驗資訊，系統可以利用這些資訊來最佳化資料結構的操作效率。</p> <ul> <li>空間效率高：陣列為資料分配了連續的記憶體塊，無須額外的結構開銷。</li> <li>支持隨機訪問：陣列允許在 \\(O(1)\\) 時間內訪問任何元素。</li> <li>快取區域性：當訪問陣列元素時，計算機不僅會載入它，還會快取其周圍的其他資料，從而藉助高速快取來提升後續操作的執行速度。</li> </ul> <p>連續空間儲存是一把雙刃劍，其存在以下侷限性。</p> <ul> <li>插入與刪除效率低：當陣列中元素較多時，插入與刪除操作需要移動大量的元素。</li> <li>長度不可變：陣列在初始化後長度就固定了，擴容陣列需要將所有資料複製到新陣列，開銷很大。</li> <li>空間浪費：如果陣列分配的大小超過實際所需，那麼多餘的空間就被浪費了。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   陣列典型應用","text":"<p>陣列是一種基礎且常見的資料結構，既頻繁應用在各類演算法之中，也可用於實現各種複雜資料結構。</p> <ul> <li>隨機訪問：如果我們想隨機抽取一些樣本，那麼可以用陣列儲存，並生成一個隨機序列，根據索引實現隨機抽樣。</li> <li>排序和搜尋：陣列是排序和搜尋演算法最常用的資料結構。快速排序、合併排序、二分搜尋等都主要在陣列上進行。</li> <li>查詢表：當需要快速查詢一個元素或其對應關係時，可以使用陣列作為查詢表。假如我們想實現字元到 ASCII 碼的對映，則可以將字元的 ASCII 碼值作為索引，對應的元素存放在陣列中的對應位置。</li> <li>機器學習：神經網路中大量使用了向量、矩陣、張量之間的線性代數運算，這些資料都是以陣列的形式構建的。陣列是神經網路程式設計中最常使用的資料結構。</li> <li>資料結構實現：陣列可以用於實現堆疊、佇列、雜湊表、堆積、圖等資料結構。例如，圖的鄰接矩陣表示實際上是一個二維陣列。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   鏈結串列","text":"<p>記憶體空間是所有程式的公共資源，在一個複雜的系統執行環境下，空閒的記憶體空間可能散落在記憶體各處。我們知道，儲存陣列的記憶體空間必須是連續的，而當陣列非常大時，記憶體可能無法提供如此大的連續空間。此時鏈結串列的靈活性優勢就體現出來了。</p> <p>鏈結串列（linked list）是一種線性資料結構，其中的每個元素都是一個節點物件，各個節點透過“引用”相連線。引用記錄了下一個節點的記憶體位址，透過它可以從當前節點訪問到下一個節點。</p> <p>鏈結串列的設計使得各個節點可以分散儲存在記憶體各處，它們的記憶體位址無須連續。</p> <p></p> <p> 圖 4-5   鏈結串列定義與儲存方式 </p> <p>觀察圖 4-5 ，鏈結串列的組成單位是節點（node）物件。每個節點都包含兩項資料：節點的“值”和指向下一節點的“引用”。</p> <ul> <li>鏈結串列的首個節點被稱為“頭節點”，最後一個節點被稱為“尾節點”。</li> <li>尾節點指向的是“空”，它在 Java、C++ 和 Python 中分別被記為 <code>null</code>、<code>nullptr</code> 和 <code>None</code> 。</li> <li>在 C、C++、Go 和 Rust 等支持指標的語言中，上述“引用”應被替換為“指標”。</li> </ul> <p>如以下程式碼所示，鏈結串列節點 <code>ListNode</code> 除了包含值，還需額外儲存一個引用（指標）。因此在相同資料量下，鏈結串列比陣列佔用更多的記憶體空間。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"鏈結串列節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # 節點值\n        self.next: ListNode | None = None # 指向下一節點的引用\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\nstruct ListNode {\n    int val;         // 節點值\n    ListNode *next;  // 指向下一節點的指標\n    ListNode(int x) : val(x), next(nullptr) {}  // 建構子\n};\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode next;  // 指向下一節點的引用\n    ListNode(int x) { val = x; }  // 建構子\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode(int x) {  //建構子\n    int val = x;         // 節點值\n    ListNode? next;      // 指向下一節點的引用\n}\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\ntype ListNode struct {\n    Val  int       // 節點值\n    Next *ListNode // 指向下一節點的指標\n}\n\n// NewListNode 建構子，建立一個新的鏈結串列\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 指向下一節點的引用\n\n    init(x: Int) { // 建構子\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // 節點值\n        this.next = (next === undefined ? null : next); // 指向下一節點的引用\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // 節點值\n        this.next = next === undefined ? null : next;  // 指向下一節點的引用\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n  int val; // 節點值\n  ListNode? next; // 指向下一節點的引用\n  ListNode(this.val, [this.next]); // 建構子\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* 鏈結串列節點類別 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // 節點值\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向下一節點的指標\n}\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\ntypedef struct ListNode {\n    int val;               // 節點值\n    struct ListNode *next; // 指向下一節點的指標\n} ListNode;\n\n/* 建構子 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\n// 建構子\nclass ListNode(x: Int) {\n    val _val: Int = x          // 節點值\n    val next: ListNode? = null // 指向下一個節點的引用\n}\n</code></pre> <pre><code># 鏈結串列節點類別\nclass ListNode\n  attr_accessor :val  # 節點值\n  attr_accessor :next # 指向下一節點的引用\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   鏈結串列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   初始化鏈結串列","text":"<p>建立鏈結串列分為兩步，第一步是初始化各個節點物件，第二步是構建節點之間的引用關係。初始化完成後，我們就可以從鏈結串列的頭節點出發，透過引用指向 <code>next</code> 依次訪問所有節點。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# 初始化各個節點\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// 構建節點之間的引用\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// 構建節點之間的引用\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// 初始化各個節點\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// 構建節點之間的引用\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// 構建節點之間的引用\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# 初始化各個節點\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>陣列整體是一個變數，比如陣列 <code>nums</code> 包含元素 <code>nums[0]</code> 和 <code>nums[1]</code> 等，而鏈結串列是由多個獨立的節點物件組成的。我們通常將頭節點當作鏈結串列的代稱，比如以上程式碼中的鏈結串列可記作鏈結串列 <code>n0</code> 。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   插入節點","text":"<p>在鏈結串列中插入節點非常容易。如圖 4-6 所示，假設我們想在相鄰的兩個節點 <code>n0</code> 和 <code>n1</code> 之間插入一個新節點 <code>P</code> ，則只需改變兩個節點引用（指標）即可，時間複雜度為 \\(O(1)\\) 。</p> <p>相比之下，在陣列中插入元素的時間複雜度為 \\(O(n)\\) ，在大資料量下的效率較低。</p> <p></p> <p> 圖 4-6   鏈結串列插入節點示例 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"在鏈結串列的節點 n0 之後插入節點 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### 在鏈結串列的節點 n0 之後插入節點 _p ###\n# Ruby 的 `p` 是一個內建函式， `P` 是一個常數，所以可以使用 `_p` 代替\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   刪除節點","text":"<p>如圖 4-7 所示，在鏈結串列中刪除節點也非常方便，只需改變一個節點的引用（指標）即可。</p> <p>請注意，儘管在刪除操作完成後節點 <code>P</code> 仍然指向 <code>n1</code> ，但實際上走訪此鏈結串列已經無法訪問到 <code>P</code> ，這意味著 <code>P</code> 已經不再屬於該鏈結串列了。</p> <p></p> <p> 圖 4-7   鏈結串列刪除節點 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"刪除鏈結串列的節點 n0 之後的首個節點\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // 釋放記憶體\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // 釋放記憶體\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### 刪除鏈結串列的節點 n0 之後的首個節點 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   訪問節點","text":"<p>在鏈結串列中訪問節點的效率較低。如上一節所述，我們可以在 \\(O(1)\\) 時間下訪問陣列中的任意元素。鏈結串列則不然，程式需要從頭節點出發，逐個向後走訪，直至找到目標節點。也就是說，訪問鏈結串列的第 \\(i\\) 個節點需要迴圈 \\(i - 1\\) 輪，時間複雜度為 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"訪問鏈結串列中索引為 index 的節點\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### 訪問鏈結串列中索引為 index 的節點 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   查詢節點","text":"<p>走訪鏈結串列，查詢其中值為 <code>target</code> 的節點，輸出該節點在鏈結串列中的索引。此過程也屬於線性查詢。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"在鏈結串列中查詢值為 target 的首個節點\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### 在鏈結串列中查詢值為 target 的首個節點 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","level":2,"title":"4.2.2   陣列 vs. 鏈結串列","text":"<p>表 4-1 總結了陣列和鏈結串列的各項特點並對比了操作效率。由於它們採用兩種相反的儲存策略，因此各種性質和操作效率也呈現對立的特點。</p> <p> 表 4-1   陣列與鏈結串列的效率對比 </p> 陣列 鏈結串列 儲存方式 連續記憶體空間 分散記憶體空間 容量擴展 長度不可變 可靈活擴展 記憶體效率 元素佔用記憶體少、但可能浪費空間 元素佔用記憶體多 訪問元素 \\(O(1)\\) \\(O(n)\\) 新增元素 \\(O(n)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(1)\\)","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   常見鏈結串列型別","text":"<p>如圖 4-8 所示，常見的鏈結串列型別包括三種。</p> <ul> <li>單向鏈結串列：即前面介紹的普通鏈結串列。單向鏈結串列的節點包含值和指向下一節點的引用兩項資料。我們將首個節點稱為頭節點，將最後一個節點稱為尾節點，尾節點指向空 <code>None</code> 。</li> <li>環形鏈結串列：如果我們令單向鏈結串列的尾節點指向頭節點（首尾相接），則得到一個環形鏈結串列。在環形鏈結串列中，任意節點都可以視作頭節點。</li> <li>雙向鏈結串列：與單向鏈結串列相比，雙向鏈結串列記錄了兩個方向的引用。雙向鏈結串列的節點定義同時包含指向後繼節點（下一個節點）和前驅節點（上一個節點）的引用（指標）。相較於單向鏈結串列，雙向鏈結串列更具靈活性，可以朝兩個方向走訪鏈結串列，但相應地也需要佔用更多的記憶體空間。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"雙向鏈結串列節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # 節點值\n        self.next: ListNode | None = None  # 指向後繼節點的引用\n        self.prev: ListNode | None = None  # 指向前驅節點的引用\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\nstruct ListNode {\n    int val;         // 節點值\n    ListNode *next;  // 指向後繼節點的指標\n    ListNode *prev;  // 指向前驅節點的指標\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 建構子\n};\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode next;  // 指向後繼節點的引用\n    ListNode prev;  // 指向前驅節點的引用\n    ListNode(int x) { val = x; }  // 建構子\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode(int x) {  // 建構子\n    int val = x;    // 節點值\n    ListNode next;  // 指向後繼節點的引用\n    ListNode prev;  // 指向前驅節點的引用\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\ntype DoublyListNode struct {\n    Val  int             // 節點值\n    Next *DoublyListNode // 指向後繼節點的指標\n    Prev *DoublyListNode // 指向前驅節點的指標\n}\n\n// NewDoublyListNode 初始化\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 指向後繼節點的引用\n    var prev: ListNode? // 指向前驅節點的引用\n\n    init(x: Int) { // 建構子\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // 節點值\n        this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用\n        this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // 節點值\n        this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用\n        this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode? next;  // 指向後繼節點的引用\n    ListNode? prev;  // 指向前驅節點的引用\n    ListNode(this.val, [this.next, this.prev]);  // 建構子\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 雙向鏈結串列節點型別 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // 節點值\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向後繼節點的指標\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向前驅節點的指標\n}\n\n/* 建構子 */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\ntypedef struct ListNode {\n    int val;               // 節點值\n    struct ListNode *next; // 指向後繼節點的指標\n    struct ListNode *prev; // 指向前驅節點的指標\n} ListNode;\n\n/* 建構子 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\n// 建構子\nclass ListNode(x: Int) {\n    val _val: Int = x           // 節點值\n    val next: ListNode? = null  // 指向後繼節點的引用\n    val prev: ListNode? = null  // 指向前驅節點的引用\n}\n</code></pre> <pre><code># 雙向鏈結串列節點類別\nclass ListNode\n  attr_accessor :val    # 節點值\n  attr_accessor :next   # 指向後繼節點的引用\n  attr_accessor :prev   # 指向前驅節點的引用\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> 圖 4-8   常見鏈結串列種類 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   鏈結串列典型應用","text":"<p>單向鏈結串列通常用於實現堆疊、佇列、雜湊表和圖等資料結構。</p> <ul> <li>堆疊與佇列：當插入和刪除操作都在鏈結串列的一端進行時，它表現的特性為先進後出，對應堆疊；當插入操作在鏈結串列的一端進行，刪除操作在鏈結串列的另一端進行，它表現的特性為先進先出，對應佇列。</li> <li>雜湊表：鏈式位址是解決雜湊衝突的主流方案之一，在該方案中，所有衝突的元素都會被放到一個鏈結串列中。</li> <li>圖：鄰接表是表示圖的一種常用方式，其中圖的每個頂點都與一個鏈結串列相關聯，鏈結串列中的每個元素都代表與該頂點相連的其他頂點。</li> </ul> <p>雙向鏈結串列常用於需要快速查詢前一個和後一個元素的場景。</p> <ul> <li>高階資料結構：比如在紅黑樹、B 樹中，我們需要訪問節點的父節點，這可以透過在節點中儲存一個指向父節點的引用來實現，類似於雙向鏈結串列。</li> <li>瀏覽器歷史：在網頁瀏覽器中，當用戶點選前進或後退按鈕時，瀏覽器需要知道使用者訪問過的前一個和後一個網頁。雙向鏈結串列的特性使得這種操作變得簡單。</li> <li>LRU 演算法：在快取淘汰（LRU）演算法中，我們需要快速找到最近最少使用的資料，以及支持快速新增和刪除節點。這時候使用雙向鏈結串列就非常合適。</li> </ul> <p>環形鏈結串列常用於需要週期性操作的場景，比如作業系統的資源排程。</p> <ul> <li>時間片輪轉排程演算法：在作業系統中，時間片輪轉排程演算法是一種常見的 CPU 排程演算法，它需要對一組程序進行迴圈。每個程序被賦予一個時間片，當時間片用完時，CPU 將切換到下一個程序。這種迴圈操作可以透過環形鏈結串列來實現。</li> <li>資料緩衝區：在某些資料緩衝區的實現中，也可能會使用環形鏈結串列。比如在音訊、影片播放器中，資料流可能會被分成多個緩衝塊並放入一個環形鏈結串列，以便實現無縫播放。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   串列","text":"<p>串列（list）是一個抽象的資料結構概念，它表示元素的有序集合，支持元素訪問、修改、新增、刪除和走訪等操作，無須使用者考慮容量限制的問題。串列可以基於鏈結串列或陣列實現。</p> <ul> <li>鏈結串列天然可以看作一個串列，其支持元素增刪查改操作，並且可以靈活動態擴容。</li> <li>陣列也支持元素增刪查改，但由於其長度不可變，因此只能看作一個具有長度限制的串列。</li> </ul> <p>當使用陣列實現串列時，長度不可變的性質會導致串列的實用性降低。這是因為我們通常無法事先確定需要儲存多少資料，從而難以選擇合適的串列長度。若長度過小，則很可能無法滿足使用需求；若長度過大，則會造成記憶體空間浪費。</p> <p>為解決此問題，我們可以使用動態陣列（dynamic array）來實現串列。它繼承了陣列的各項優點，並且可以在程式執行過程中進行動態擴容。</p> <p>實際上，許多程式語言中的標準庫提供的串列是基於動態陣列實現的，例如 Python 中的 <code>list</code> 、Java 中的 <code>ArrayList</code> 、C++ 中的 <code>vector</code> 和 C# 中的 <code>List</code> 等。在接下來的討論中，我們將把“串列”和“動態陣列”視為等同的概念。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   串列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   初始化串列","text":"<p>我們通常使用“無初始值”和“有初始值”這兩種初始化方法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 初始化串列\n# 無初始值\nnums1: list[int] = []\n# 有初始值\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* 初始化串列 */\n// 需注意，C++ 中 vector 即是本文描述的 nums\n// 無初始值\nvector&lt;int&gt; nums1;\n// 有初始值\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// 有初始值（注意陣列的元素型別需為 int[] 的包裝類別 Integer[]）\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;int&gt; nums1 = [];\n// 有初始值\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* 初始化串列 */\n// 無初始值\nnums1 := []int{}\n// 有初始值\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* 初始化串列 */\n// 無初始值\nlet nums1: [Int] = []\n// 有初始值\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* 初始化串列 */\n// 無初始值\nconst nums1 = [];\n// 有初始值\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* 初始化串列 */\n// 無初始值\nconst nums1: number[] = [];\n// 有初始值\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;int&gt; nums1 = [];\n// 有初始值\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* 初始化串列 */\n// 無初始值\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// 有初始值\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 初始化串列 */\n// 無初始值\nvar nums1 = listOf&lt;Int&gt;()\n// 有初始值\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># 初始化串列\n# 無初始值\nnums1 = []\n# 有初始值\nnums = [1, 3, 2, 5, 4]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   訪問元素","text":"<p>串列本質上是陣列，因此可以在 \\(O(1)\\) 時間內訪問和更新元素，效率很高。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 訪問元素\nnum: int = nums[1]  # 訪問索引 1 處的元素\n\n# 更新元素\nnums[1] = 0    # 將索引 1 處的元素更新為 0\n</code></pre> list.cpp<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.java<pre><code>/* 訪問元素 */\nint num = nums.get(1);  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums.set(1, 0);  // 將索引 1 處的元素更新為 0\n</code></pre> list.cs<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list_test.go<pre><code>/* 訪問元素 */\nnum := nums[1]  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0     // 將索引 1 處的元素更新為 0\n</code></pre> list.swift<pre><code>/* 訪問元素 */\nlet num = nums[1] // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0 // 將索引 1 處的元素更新為 0\n</code></pre> list.js<pre><code>/* 訪問元素 */\nconst num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.ts<pre><code>/* 訪問元素 */\nconst num: number = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.dart<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.rs<pre><code>/* 訪問元素 */\nlet num: i32 = nums[1];  // 訪問索引 1 處的元素\n/* 更新元素 */\nnums[1] = 0;             // 將索引 1 處的元素更新為 0\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 訪問元素 */\nval num = nums[1]       // 訪問索引 1 處的元素\n/* 更新元素 */\nnums[1] = 0             // 將索引 1 處的元素更新為 0\n</code></pre> list.rb<pre><code># 訪問元素\nnum = nums[1] # 訪問索引 1 處的元素\n# 更新元素\nnums[1] = 0 # 將索引 1 處的元素更新為 0\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   插入與刪除元素","text":"<p>相較於陣列，串列可以自由地新增與刪除元素。在串列尾部新增元素的時間複雜度為 \\(O(1)\\) ，但插入和刪除元素的效率仍與陣列相同，時間複雜度為 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 清空串列\nnums.clear()\n\n# 在尾部新增元素\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# 在中間插入元素\nnums.insert(3, 6)  # 在索引 3 處插入數字 6\n\n# 刪除元素\nnums.pop(3)        # 刪除索引 3 處的元素\n</code></pre> list.cpp<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* 在中間插入元素 */\nnums.insert(nums.begin() + 3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.erase(nums.begin() + 3);      // 刪除索引 3 處的元素\n</code></pre> list.java<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.add(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);  // 刪除索引 3 處的元素\n</code></pre> list.cs<pre><code>/* 清空串列 */\nnums.Clear();\n\n/* 在尾部新增元素 */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* 在中間插入元素 */\nnums.Insert(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.RemoveAt(3);  // 刪除索引 3 處的元素\n</code></pre> list_test.go<pre><code>/* 清空串列 */\nnums = nil\n\n/* 在尾部新增元素 */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* 在中間插入元素 */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums = append(nums[:3], nums[4:]...) // 刪除索引 3 處的元素\n</code></pre> list.swift<pre><code>/* 清空串列 */\nnums.removeAll()\n\n/* 在尾部新增元素 */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* 在中間插入元素 */\nnums.insert(6, at: 3) // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(at: 3) // 刪除索引 3 處的元素\n</code></pre> list.js<pre><code>/* 清空串列 */\nnums.length = 0;\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.splice(3, 0, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.splice(3, 1);  // 刪除索引 3 處的元素\n</code></pre> list.ts<pre><code>/* 清空串列 */\nnums.length = 0;\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.splice(3, 0, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.splice(3, 1);  // 刪除索引 3 處的元素\n</code></pre> list.dart<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.insert(3, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.removeAt(3); // 刪除索引 3 處的元素\n</code></pre> list.rs<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.insert(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);    // 刪除索引 3 處的元素\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.add(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);  // 刪除索引 3 處的元素\n</code></pre> list.rb<pre><code># 清空串列\nnums.clear\n\n# 在尾部新增元素\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# 在中間插入元素\nnums.insert(3, 6) # 在索引 3 處插入數字 6\n\n# 刪除元素\nnums.delete_at(3) # 刪除索引 3 處的元素\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   走訪串列","text":"<p>與陣列一樣，串列可以根據索引走訪，也可以直接走訪各元素。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 透過索引走訪串列\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# 直接走訪串列元素\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* 直接走訪串列元素 */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* 透過索引走訪串列 */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* 透過索引走訪串列 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* 透過索引走訪串列 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* 透過索引走訪串列 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// 透過索引走訪串列\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// 直接走訪串列元素\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 透過索引走訪串列 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># 透過索引走訪串列\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# 直接走訪串列元素\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   拼接串列","text":"<p>給定一個新串列 <code>nums1</code> ，我們可以將其拼接到原串列的尾部。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 拼接兩個串列\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # 將串列 nums1 拼接到 nums 之後\n</code></pre> list.cpp<pre><code>/* 拼接兩個串列 */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// 將串列 nums1 拼接到 nums 之後\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* 拼接兩個串列 */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.cs<pre><code>/* 拼接兩個串列 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list_test.go<pre><code>/* 拼接兩個串列 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.swift<pre><code>/* 拼接兩個串列 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.js<pre><code>/* 拼接兩個串列 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.ts<pre><code>/* 拼接兩個串列 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.dart<pre><code>/* 拼接兩個串列 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.rs<pre><code>/* 拼接兩個串列 */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 拼接兩個串列 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.rb<pre><code># 拼接兩個串列\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   排序串列","text":"<p>完成串列排序後，我們便可以使用在陣列類別演算法題中經常考查的“二分搜尋”和“雙指標”演算法。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 排序串列\nnums.sort()  # 排序後，串列元素從小到大排列\n</code></pre> list.cpp<pre><code>/* 排序串列 */\nsort(nums.begin(), nums.end());  // 排序後，串列元素從小到大排列\n</code></pre> list.java<pre><code>/* 排序串列 */\nCollections.sort(nums);  // 排序後，串列元素從小到大排列\n</code></pre> list.cs<pre><code>/* 排序串列 */\nnums.Sort(); // 排序後，串列元素從小到大排列\n</code></pre> list_test.go<pre><code>/* 排序串列 */\nsort.Ints(nums)  // 排序後，串列元素從小到大排列\n</code></pre> list.swift<pre><code>/* 排序串列 */\nnums.sort() // 排序後，串列元素從小到大排列\n</code></pre> list.js<pre><code>/* 排序串列 */\nnums.sort((a, b) =&gt; a - b);  // 排序後，串列元素從小到大排列\n</code></pre> list.ts<pre><code>/* 排序串列 */\nnums.sort((a, b) =&gt; a - b);  // 排序後，串列元素從小到大排列\n</code></pre> list.dart<pre><code>/* 排序串列 */\nnums.sort(); // 排序後，串列元素從小到大排列\n</code></pre> list.rs<pre><code>/* 排序串列 */\nnums.sort(); // 排序後，串列元素從小到大排列\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 排序串列 */\nnums.sort() // 排序後，串列元素從小到大排列\n</code></pre> list.rb<pre><code># 排序串列\nnums = nums.sort { |a, b| a &lt;=&gt; b } # 排序後，串列元素從小到大排列\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   串列實現","text":"<p>許多程式語言內建了串列，例如 Java、C++、Python 等。它們的實現比較複雜，各個參數的設定也非常考究，例如初始容量、擴容倍數等。感興趣的讀者可以查閱原始碼進行學習。</p> <p>為了加深對串列工作原理的理解，我們嘗試實現一個簡易版串列，包括以下三個重點設計。</p> <ul> <li>初始容量：選取一個合理的陣列初始容量。在本示例中，我們選擇 10 作為初始容量。</li> <li>數量記錄：宣告一個變數 <code>size</code> ，用於記錄串列當前元素數量，並隨著元素插入和刪除即時更新。根據此變數，我們可以定位串列尾部，以及判斷是否需要擴容。</li> <li>擴容機制：若插入元素時串列容量已滿，則需要進行擴容。先根據擴容倍數建立一個更大的陣列，再將當前陣列的所有元素依次移動至新陣列。在本示例中，我們規定每次將陣列擴容至之前的 2 倍。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"串列類別\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._capacity: int = 10  # 串列容量\n        self._arr: list[int] = [0] * self._capacity  # 陣列（儲存串列元素）\n        self._size: int = 0  # 串列長度（當前元素數量）\n        self._extend_ratio: int = 2  # 每次串列擴容的倍數\n\n    def size(self) -&gt; int:\n        \"\"\"獲取串列長度（當前元素數量）\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取串列容量\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"訪問元素\"\"\"\n        # 索引如果越界，則丟擲異常，下同\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"更新元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"在尾部新增元素\"\"\"\n        # 元素數量超出容量時，觸發擴容機制\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"在中間插入元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        # 元素數量超出容量時，觸發擴容機制\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # 將索引 index 以及之後的元素都向後移動一位\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # 更新元素數量\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"刪除元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        num = self._arr[index]\n        # 將索引 index 之後的元素都向前移動一位\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # 更新元素數量\n        self._size -= 1\n        # 返回被刪除的元素\n        return num\n\n    def extend_capacity(self):\n        \"\"\"串列擴容\"\"\"\n        # 新建一個長度為原陣列 _extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # 更新串列容量\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回有效長度的串列\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* 串列類別 */\nclass MyList {\n  private:\n    int *arr;             // 陣列（儲存串列元素）\n    int arrCapacity = 10; // 串列容量\n    int arrSize = 0;      // 串列長度（當前元素數量）\n    int extendRatio = 2;   // 每次串列擴容的倍數\n\n  public:\n    /* 建構子 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* 析構方法 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    int size() {\n        return arrSize;\n    }\n\n    /* 獲取串列容量 */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* 訪問元素 */\n    int get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    void add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 在中間插入元素 */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (size() == capacity())\n            extendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 刪除元素 */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        int num = arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        arrSize--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    void extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // 將原陣列中的所有元素複製到新陣列\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // 釋放記憶體\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* 將串列轉換為 Vector 用於列印 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* 串列類別 */\nclass MyList {\n    private int[] arr; // 陣列（儲存串列元素）\n    private int capacity = 10; // 串列容量\n    private int size = 0; // 串列長度（當前元素數量）\n    private int extendRatio = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* 獲取串列長度（當前元素數量） */\n    public int size() {\n        return size;\n    }\n\n    /* 獲取串列容量 */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* 訪問元素 */\n    public int get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public void add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // 更新元素數量\n        size++;\n    }\n\n    /* 在中間插入元素 */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        size++;\n    }\n\n    /* 刪除元素 */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        int num = arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public void extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // 更新串列容量\n        capacity = arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public int[] toArray() {\n        int size = size();\n        // 僅轉換有效長度範圍內的串列元素\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* 串列類別 */\nclass MyList {\n    private int[] arr;           // 陣列（儲存串列元素）\n    private int arrCapacity = 10;    // 串列容量\n    private int arrSize = 0;         // 串列長度（當前元素數量）\n    private readonly int extendRatio = 2;  // 每次串列擴容的倍數\n\n    /* 建構子 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* 獲取串列容量 */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* 訪問元素 */\n    public int Get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public void Add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 在中間插入元素 */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 刪除元素 */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        int num = arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        arrSize--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public void ExtendCapacity() {\n        // 新建一個長度為 arrCapacity * extendRatio 的陣列，並將原陣列複製到新陣列\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // 更新串列容量\n        arrCapacity = arr.Length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* 串列類別 */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* 建構子 */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // 串列容量\n        arr:         make([]int, 10), // 陣列（儲存串列元素）\n        arrSize:     0,               // 串列長度（當前元素數量）\n        extendRatio: 2,               // 每次串列擴容的倍數\n    }\n}\n\n/* 獲取串列長度（當前元素數量） */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  獲取串列容量 */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* 訪問元素 */\nfunc (l *myList) get(index int) int {\n    // 索引如果越界，則丟擲異常，下同\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    return l.arr[index]\n}\n\n/* 更新元素 */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    l.arr[index] = num\n}\n\n/* 在尾部新增元素 */\nfunc (l *myList) add(num int) {\n    // 元素數量超出容量時，觸發擴容機制\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // 更新元素數量\n    l.arrSize++\n}\n\n/* 在中間插入元素 */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    // 元素數量超出容量時，觸發擴容機制\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // 將索引 index 以及之後的元素都向後移動一位\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // 更新元素數量\n    l.arrSize++\n}\n\n/* 刪除元素 */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    num := l.arr[index]\n    // 將索引 index 之後的元素都向前移動一位\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // 更新元素數量\n    l.arrSize--\n    // 返回被刪除的元素\n    return num\n}\n\n/* 串列擴容 */\nfunc (l *myList) extendCapacity() {\n    // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // 更新串列容量\n    l.arrCapacity = len(l.arr)\n}\n\n/* 返回有效長度的串列 */\nfunc (l *myList) toArray() []int {\n    // 僅轉換有效長度範圍內的串列元素\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* 串列類別 */\nclass MyList {\n    private var arr: [Int] // 陣列（儲存串列元素）\n    private var _capacity: Int // 串列容量\n    private var _size: Int // 串列長度（當前元素數量）\n    private let extendRatio: Int // 每次串列擴容的倍數\n\n    /* 建構子 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 獲取串列容量 */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* 訪問元素 */\n    func get(index: Int) -&gt; Int {\n        // 索引如果越界則丟擲錯誤，下同\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        return arr[index]\n    }\n\n    /* 更新元素 */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        arr[index] = num\n    }\n\n    /* 在尾部新增元素 */\n    func add(num: Int) {\n        // 元素數量超出容量時，觸發擴容機制\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // 更新元素數量\n        _size += 1\n    }\n\n    /* 在中間插入元素 */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        // 元素數量超出容量時，觸發擴容機制\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // 更新元素數量\n        _size += 1\n    }\n\n    /* 刪除元素 */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        let num = arr[index]\n        // 將將索引 index 之後的元素都向前移動一位\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // 更新元素數量\n        _size -= 1\n        // 返回被刪除的元素\n        return num\n    }\n\n    /* 串列擴容 */\n    func extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // 更新串列容量\n        _capacity = arr.count\n    }\n\n    /* 將串列轉換為陣列 */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* 串列類別 */\nclass MyList {\n    #arr = new Array(); // 陣列（儲存串列元素）\n    #capacity = 10; // 串列容量\n    #size = 0; // 串列長度（當前元素數量）\n    #extendRatio = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    size() {\n        return this.#size;\n    }\n\n    /* 獲取串列容量 */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* 訪問元素 */\n    get(index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        return this.#arr[index];\n    }\n\n    /* 更新元素 */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        this.#arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    add(num) {\n        // 如果長度等於容量，則需要擴容\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 將新元素新增到串列尾部\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* 在中間插入元素 */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        // 元素數量超出容量時，觸發擴容機制\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // 更新元素數量\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* 刪除元素 */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        let num = this.#arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // 更新元素數量\n        this.#size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // 更新串列容量\n        this.#capacity = this.#arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    toArray() {\n        let size = this.size();\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* 串列類別 */\nclass MyList {\n    private arr: Array&lt;number&gt;; // 陣列（儲存串列元素）\n    private _capacity: number = 10; // 串列容量\n    private _size: number = 0; // 串列長度（當前元素數量）\n    private extendRatio: number = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* 獲取串列容量 */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* 訪問元素 */\n    public get(index: number): number {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        return this.arr[index];\n    }\n\n    /* 更新元素 */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        this.arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public add(num: number): void {\n        // 如果長度等於容量，則需要擴容\n        if (this._size === this._capacity) this.extendCapacity();\n        // 將新元素新增到串列尾部\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* 在中間插入元素 */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        // 元素數量超出容量時，觸發擴容機制\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // 更新元素數量\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* 刪除元素 */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        let num = this.arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // 更新元素數量\n        this._size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public extendCapacity(): void {\n        // 新建一個長度為 size 的陣列，並將原陣列複製到新陣列\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // 更新串列容量\n        this._capacity = this.arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public toArray(): number[] {\n        let size = this.size();\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* 串列類別 */\nclass MyList {\n  late List&lt;int&gt; _arr; // 陣列（儲存串列元素）\n  int _capacity = 10; // 串列容量\n  int _size = 0; // 串列長度（當前元素數量）\n  int _extendRatio = 2; // 每次串列擴容的倍數\n\n  /* 建構子 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* 獲取串列長度（當前元素數量）*/\n  int size() =&gt; _size;\n\n  /* 獲取串列容量 */\n  int capacity() =&gt; _capacity;\n\n  /* 訪問元素 */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    return _arr[index];\n  }\n\n  /* 更新元素 */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    _arr[index] = _num;\n  }\n\n  /* 在尾部新增元素 */\n  void add(int _num) {\n    // 元素數量超出容量時，觸發擴容機制\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // 更新元素數量\n    _size++;\n  }\n\n  /* 在中間插入元素 */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    // 元素數量超出容量時，觸發擴容機制\n    if (_size == _capacity) extendCapacity();\n    // 將索引 index 以及之後的元素都向後移動一位\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // 更新元素數量\n    _size++;\n  }\n\n  /* 刪除元素 */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    int _num = _arr[index];\n    // 將將索引 index 之後的元素都向前移動一位\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // 更新元素數量\n    _size--;\n    // 返回被刪除的元素\n    return _num;\n  }\n\n  /* 串列擴容 */\n  void extendCapacity() {\n    // 新建一個長度為原陣列 _extendRatio 倍的新陣列\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // 將原陣列複製到新陣列\n    List.copyRange(_newNums, 0, _arr);\n    // 更新 _arr 的引用\n    _arr = _newNums;\n    // 更新串列容量\n    _capacity = _arr.length;\n  }\n\n  /* 將串列轉換為陣列 */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* 串列類別 */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // 陣列（儲存串列元素）\n    capacity: usize,     // 串列容量\n    size: usize,         // 串列長度（當前元素數量）\n    extend_ratio: usize, // 每次串列擴容的倍數\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* 建構子 */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* 獲取串列容量 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* 訪問元素 */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // 索引如果越界，則丟擲異常，下同\n        if index &gt;= self.size {\n            panic!(\"索引越界\")\n        };\n        return self.arr[index];\n    }\n\n    /* 更新元素 */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"索引越界\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    pub fn add(&amp;mut self, num: i32) {\n        // 元素數量超出容量時，觸發擴容機制\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // 更新元素數量\n        self.size += 1;\n    }\n\n    /* 在中間插入元素 */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"索引越界\")\n        };\n        // 元素數量超出容量時，觸發擴容機制\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // 更新元素數量\n        self.size += 1;\n    }\n\n    /* 刪除元素 */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"索引越界\")\n        };\n        let num = self.arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // 更新元素數量\n        self.size -= 1;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    pub fn extend_capacity(&amp;mut self) {\n        // 新建一個長度為原陣列 extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // 更新串列容量\n        self.capacity = new_capacity;\n    }\n\n    /* 將串列轉換為陣列 */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // 僅轉換有效長度範圍內的串列元素\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* 串列類別 */\ntypedef struct {\n    int *arr;        // 陣列（儲存串列元素）\n    int capacity;    // 串列容量\n    int size;        // 串列大小\n    int extendRatio; // 串列每次擴容的倍數\n} MyList;\n\n/* 建構子 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* 析構函式 */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* 獲取串列長度 */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* 獲取串列容量 */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* 訪問元素 */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* 更新元素 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* 在尾部新增元素 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 擴容\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* 在中間插入元素 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // 元素數量超出容量時，觸發擴容機制\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 擴容\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* 刪除元素 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* 串列擴容 */\nvoid extendCapacity(MyList *nums) {\n    // 先分配空間\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // 複製舊資料到新資料\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // 釋放舊資料\n    free(temp);\n\n    // 更新新資料\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* 將串列轉換為 Array 用於列印 */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* 串列類別 */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // 陣列（儲存串列元素）\n    private var capacity: Int = 10 // 串列容量\n    private var size: Int = 0 // 串列長度（當前元素數量）\n    private var extendRatio: Int = 2 // 每次串列擴容的倍數\n\n    /* 建構子 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* 獲取串列長度（當前元素數量） */\n    fun size(): Int {\n        return size\n    }\n\n    /* 獲取串列容量 */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* 訪問元素 */\n    fun get(index: Int): Int {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        return arr[index]\n    }\n\n    /* 更新元素 */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        arr[index] = num\n    }\n\n    /* 在尾部新增元素 */\n    fun add(num: Int) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // 更新元素數量\n        size++\n    }\n\n    /* 在中間插入元素 */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity()\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // 更新元素數量\n        size++\n    }\n\n    /* 刪除元素 */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        val num = arr[index]\n        // 將將索引 index 之後的元素都向前移動一位\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // 更新元素數量\n        size--\n        // 返回被刪除的元素\n        return num\n    }\n\n    /* 串列擴容 */\n    fun extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = arr.copyOf(capacity() * extendRatio)\n        // 更新串列容量\n        capacity = arr.size\n    }\n\n    /* 將串列轉換為陣列 */\n    fun toArray(): IntArray {\n        val size = size()\n        // 僅轉換有效長度範圍內的串列元素\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### 串列類別 ###\nclass MyList\n  attr_reader :size       # 獲取串列長度（當前元素數量）\n  attr_reader :capacity   # 獲取串列容量\n\n  ### 建構子 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### 訪問元素 ###\n  def get(index)\n    # 索引如果越界，則丟擲異常，下同\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### 訪問元素 ###\n  def set(index, num)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### 在尾部新增元素 ###\n  def add(num)\n    # 元素數量超出容量時，觸發擴容機制\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # 更新元素數量\n    @size += 1\n  end\n\n  ### 在中間插入元素 ###\n  def insert(index, num)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n\n    # 元素數量超出容量時，觸發擴容機制\n    extend_capacity if size == capacity\n\n    # 將索引 index 以及之後的元素都向後移動一位\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # 更新元素數量\n    @size += 1\n  end\n\n  ### 刪除元素 ###\n  def remove(index)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # 將將索引 index 之後的元素都向前移動一位\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # 更新元素數量\n    @size -= 1\n\n    # 返回被刪除的元素\n    num\n  end\n\n  ### 串列擴容 ###\n  def extend_capacity\n    # 新建一個長度為原陣列 extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # 更新串列容量\n    @capacity = arr.length\n  end\n\n  ### 將串列轉換為陣列 ###\n  def to_array\n    sz = size\n    # 僅轉換有效長度範圍內的串列元素\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   記憶體與快取 *","text":"<p>在本章的前兩節中，我們探討了陣列和鏈結串列這兩種基礎且重要的資料結構，它們分別代表了“連續儲存”和“分散儲存”兩種物理結構。</p> <p>實際上，物理結構在很大程度上決定了程式對記憶體和快取的使用效率，進而影響演算法程式的整體效能。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   計算機儲存裝置","text":"<p>計算機中包括三種類型的儲存裝置：硬碟（hard disk）、記憶體（random-access memory, RAM）、快取（cache memory）。表 4-2 展示了它們在計算機系統中的不同角色和效能特點。</p> <p> 表 4-2   計算機的儲存裝置 </p> 硬碟 記憶體 快取 用途 長期儲存資料，包括作業系統、程式、檔案等 臨時儲存當前執行的程式和正在處理的資料 儲存經常訪問的資料和指令，減少 CPU 訪問記憶體的次數 易失性 斷電後資料不會丟失 斷電後資料會丟失 斷電後資料會丟失 容量 較大，TB 級別 較小，GB 級別 非常小，MB 級別 速度 較慢，幾百到幾千 MB/s 較快，幾十 GB/s 非常快，幾十到幾百 GB/s 價格（人民幣） 較便宜，幾毛到幾元 / GB 較貴，幾十到幾百元 / GB 非常貴，隨 CPU 打包計價 <p>我們可以將計算機儲存系統想象為圖 4-9 所示的金字塔結構。越靠近金字塔頂端的儲存裝置的速度越快、容量越小、成本越高。這種多層級的設計並非偶然，而是計算機科學家和工程師們經過深思熟慮的結果。</p> <ul> <li>硬碟難以被記憶體取代。首先，記憶體中的資料在斷電後會丟失，因此它不適合長期儲存資料；其次，記憶體的成本是硬碟的幾十倍，這使得它難以在消費者市場普及。</li> <li>快取的大容量和高速度難以兼得。隨著 L1、L2、L3 快取的容量逐步增大，其物理尺寸會變大，與 CPU 核心之間的物理距離會變遠，從而導致資料傳輸時間增加，元素訪問延遲變高。在當前技術下，多層級的快取結構是容量、速度和成本之間的最佳平衡點。</li> </ul> <p></p> <p> 圖 4-9   計算機儲存系統 </p> <p>Tip</p> <p>計算機的儲存層次結構體現了速度、容量和成本三者之間的精妙平衡。實際上，這種權衡普遍存在於所有工業領域，它要求我們在不同的優勢和限制之間找到最佳平衡點。</p> <p>總的來說，硬碟用於長期儲存大量資料，記憶體用於臨時儲存程式執行中正在處理的資料，而快取則用於儲存經常訪問的資料和指令，以提高程式執行效率。三者共同協作，確保計算機系統高效執行。</p> <p>如圖 4-10 所示，在程式執行時，資料會從硬碟中被讀取到記憶體中，供 CPU 計算使用。快取可以看作 CPU 的一部分，它透過智慧地從記憶體載入資料，給 CPU 提供高速的資料讀取，從而顯著提升程式的執行效率，減少對較慢的記憶體的依賴。</p> <p></p> <p> 圖 4-10   硬碟、記憶體和快取之間的資料流通 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   資料結構的記憶體效率","text":"<p>在記憶體空間利用方面，陣列和鏈結串列各自具有優勢和侷限性。</p> <p>一方面，記憶體是有限的，且同一塊記憶體不能被多個程式共享，因此我們希望資料結構能夠儘可能高效地利用空間。陣列的元素緊密排列，不需要額外的空間來儲存鏈結串列節點間的引用（指標），因此空間效率更高。然而，陣列需要一次性分配足夠的連續記憶體空間，這可能導致記憶體浪費，陣列擴容也需要額外的時間和空間成本。相比之下，鏈結串列以“節點”為單位進行動態記憶體分配和回收，提供了更大的靈活性。</p> <p>另一方面，在程式執行時，隨著反覆申請與釋放記憶體，空閒記憶體的碎片化程度會越來越高，從而導致記憶體的利用效率降低。陣列由於其連續的儲存方式，相對不容易導致記憶體碎片化。相反，鏈結串列的元素是分散儲存的，在頻繁的插入與刪除操作中，更容易導致記憶體碎片化。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   資料結構的快取效率","text":"<p>快取雖然在空間容量上遠小於記憶體，但它比記憶體快得多，在程式執行速度上起著至關重要的作用。由於快取的容量有限，只能儲存一小部分頻繁訪問的資料，因此當 CPU 嘗試訪問的資料不在快取中時，就會發生快取未命中（cache miss），此時 CPU 不得不從速度較慢的記憶體中載入所需資料。</p> <p>顯然，“快取未命中”越少，CPU 讀寫資料的效率就越高，程式效能也就越好。我們將 CPU 從快取中成功獲取資料的比例稱為快取命中率（cache hit rate），這個指標通常用來衡量快取效率。</p> <p>為了儘可能達到更高的效率，快取會採取以下資料載入機制。</p> <ul> <li>快取行：快取不是單個位元組地儲存與載入資料，而是以快取行為單位。相比於單個位元組的傳輸，快取行的傳輸形式更加高效。</li> <li>預取機制：處理器會嘗試預測資料訪問模式（例如順序訪問、固定步長跳躍訪問等），並根據特定模式將資料載入至快取之中，從而提升命中率。</li> <li>空間區域性：如果一個數據被訪問，那麼它附近的資料可能近期也會被訪問。因此，快取在載入某一資料時，也會載入其附近的資料，以提高命中率。</li> <li>時間區域性：如果一個數據被訪問，那麼它在不久的將來很可能再次被訪問。快取利用這一原理，透過保留最近訪問過的資料來提高命中率。</li> </ul> <p>實際上，陣列和鏈結串列對快取的利用效率是不同的，主要體現在以下幾個方面。</p> <ul> <li>佔用空間：鏈結串列元素比陣列元素佔用空間更多，導致快取中容納的有效資料量更少。</li> <li>快取行：鏈結串列資料分散在記憶體各處，而快取是“按行載入”的，因此載入到無效資料的比例更高。</li> <li>預取機制：陣列比鏈結串列的資料訪問模式更具“可預測性”，即系統更容易猜出即將被載入的資料。</li> <li>空間區域性：陣列被儲存在集中的記憶體空間中，因此被載入資料附近的資料更有可能即將被訪問。</li> </ul> <p>總體而言，陣列具有更高的快取命中率，因此它在操作效率上通常優於鏈結串列。這使得在解決演算法問題時，基於陣列實現的資料結構往往更受歡迎。</p> <p>需要注意的是，高快取效率並不意味著陣列在所有情況下都優於鏈結串列。實際應用中選擇哪種資料結構，應根據具體需求來決定。例如，陣列和鏈結串列都可以實現“堆疊”資料結構（下一章會詳細介紹），但它們適用於不同場景。</p> <ul> <li>在做演算法題時，我們會傾向於選擇基於陣列實現的堆疊，因為它提供了更高的操作效率和隨機訪問的能力，代價僅是需要預先為陣列分配一定的記憶體空間。</li> <li>如果資料量非常大、動態性很高、堆疊的預期大小難以估計，那麼基於鏈結串列實現的堆疊更加合適。鏈結串列能夠將大量資料分散儲存於記憶體的不同部分，並且避免了陣列擴容產生的額外開銷。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   小結","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>陣列和鏈結串列是兩種基本的資料結構，分別代表資料在計算機記憶體中的兩種儲存方式：連續空間儲存和分散空間儲存。兩者的特點呈現出互補的特性。</li> <li>陣列支持隨機訪問、佔用記憶體較少；但插入和刪除元素效率低，且初始化後長度不可變。</li> <li>鏈結串列透過更改引用（指標）實現高效的節點插入與刪除，且可以靈活調整長度；但節點訪問效率低、佔用記憶體較多。常見的鏈結串列型別包括單向鏈結串列、環形鏈結串列、雙向鏈結串列。</li> <li>串列是一種支持增刪查改的元素有序集合，通常基於動態陣列實現。它保留了陣列的優勢，同時可以靈活調整長度。</li> <li>串列的出現大幅提高了陣列的實用性，但可能導致部分記憶體空間浪費。</li> <li>程式執行時，資料主要儲存在記憶體中。陣列可提供更高的記憶體空間效率，而鏈結串列則在記憶體使用上更加靈活。</li> <li>快取透過快取行、預取機制以及空間區域性和時間區域性等資料載入機制，為 CPU 提供快速資料訪問，顯著提升程式的執行效率。</li> <li>由於陣列具有更高的快取命中率，因此它通常比鏈結串列更高效。在選擇資料結構時，應根據具體需求和場景做出恰當選擇。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：陣列儲存在堆疊上和儲存在堆積上，對時間效率和空間效率是否有影響？</p> <p>儲存在堆疊上和堆積上的陣列都被儲存在連續記憶體空間內，資料操作效率基本一致。然而，堆疊和堆積具有各自的特點，從而導致以下不同點。</p> <ol> <li>分配和釋放效率：堆疊是一塊較小的記憶體，分配由編譯器自動完成；而堆積記憶體相對更大，可以在程式碼中動態分配，更容易碎片化。因此，堆積上的分配和釋放操作通常比堆疊上的慢。</li> <li>大小限制：堆疊記憶體相對較小，堆積的大小一般受限於可用記憶體。因此堆積更加適合儲存大型陣列。</li> <li>靈活性：堆疊上的陣列的大小需要在編譯時確定，而堆積上的陣列的大小可以在執行時動態確定。</li> </ol> <p>Q：為什麼陣列要求相同型別的元素，而在鏈結串列中卻沒有強調相同型別呢？</p> <p>鏈結串列由節點組成，節點之間透過引用（指標）連線，各個節點可以儲存不同型別的資料，例如 <code>int</code>、<code>double</code>、<code>string</code>、<code>object</code> 等。</p> <p>相對地，陣列元素則必須是相同型別的，這樣才能透過計算偏移量來獲取對應元素位置。例如，陣列同時包含 <code>int</code> 和 <code>long</code> 兩種型別，單個元素分別佔用 4 位元組和 8 位元組 ，此時就不能用以下公式計算偏移量了，因為陣列中包含了兩種“元素長度”。</p> <pre><code># 元素記憶體位址 = 陣列記憶體位址（首元素記憶體位址） + 元素長度 * 元素索引\n</code></pre> <p>Q：刪除節點 <code>P</code> 後，是否需要把 <code>P.next</code> 設為 <code>None</code> 呢？</p> <p>不修改 <code>P.next</code> 也可以。從該鏈結串列的角度看，從頭節點走訪到尾節點已經不會遇到 <code>P</code> 了。這意味著節點 <code>P</code> 已經從鏈結串列中刪除了，此時節點 <code>P</code> 指向哪裡都不會對該鏈結串列產生影響。</p> <p>從資料結構與演算法（做題）的角度看，不斷開沒有關係，只要保證程式的邏輯是正確的就行。從標準庫的角度看，斷開更加安全、邏輯更加清晰。如果不斷開，假設被刪除節點未被正常回收，那麼它會影響後繼節點的記憶體回收。</p> <p>Q：在鏈結串列中插入和刪除操作的時間複雜度是 \\(O(1)\\) 。但是增刪之前都需要 \\(O(n)\\) 的時間查詢元素，那為什麼時間複雜度不是 \\(O(n)\\) 呢？</p> <p>如果是先查詢元素、再刪除元素，時間複雜度確實是 \\(O(n)\\) 。然而，鏈結串列的 \\(O(1)\\) 增刪的優勢可以在其他應用上得到體現。例如，雙向佇列適合使用鏈結串列實現，我們維護一個指標變數始終指向頭節點、尾節點，每次插入與刪除操作都是 \\(O(1)\\) 。</p> <p>Q：圖“鏈結串列定義與儲存方式”中，淺藍色的儲存節點指標是佔用一塊記憶體位址嗎？還是和節點值各佔一半呢？</p> <p>該示意圖只是定性表示，定量表示需要根據具體情況進行分析。</p> <ul> <li>不同型別的節點值佔用的空間是不同的，比如 <code>int</code>、<code>long</code>、<code>double</code> 和例項物件等。</li> <li>指標變數佔用的記憶體空間大小根據所使用的作業系統及編譯環境而定，大多為 8 位元組或 4 位元組。</li> </ul> <p>Q：在串列末尾新增元素是否時時刻刻都為 \\(O(1)\\) ？</p> <p>如果新增元素時超出串列長度，則需要先擴容串列再新增。系統會申請一塊新的記憶體，並將原串列的所有元素搬運過去，這時候時間複雜度就會是 \\(O(n)\\) 。</p> <p>Q：“串列的出現極大地提高了陣列的實用性，但可能導致部分記憶體空間浪費”，這裡的空間浪費是指額外增加的變數如容量、長度、擴容倍數所佔的記憶體嗎？</p> <p>這裡的空間浪費主要有兩方面含義：一方面，串列都會設定一個初始長度，我們不一定需要用這麼多；另一方面，為了防止頻繁擴容，擴容一般會乘以一個係數，比如 \\(\\times 1.5\\) 。這樣一來，也會出現很多空位，我們通常不能完全填滿它們。</p> <p>Q：在 Python 中初始化 <code>n = [1, 2, 3]</code> 後，這 3 個元素的位址是相連的，但是初始化 <code>m = [2, 1, 3]</code> 會發現它們每個元素的 id 並不是連續的，而是分別跟 <code>n</code> 中的相同。這些元素的位址不連續，那麼 <code>m</code> 還是陣列嗎？</p> <p>假如把串列元素換成鏈結串列節點 <code>n = [n1, n2, n3, n4, n5]</code> ，通常情況下這 5 個節點物件也分散儲存在記憶體各處。然而，給定一個串列索引，我們仍然可以在 \\(O(1)\\) 時間內獲取節點記憶體位址，從而訪問到對應的節點。這是因為陣列中儲存的是節點的引用，而非節點本身。</p> <p>與許多語言不同，Python 中的數字也被包裝為物件，串列中儲存的不是數字本身，而是對數字的引用。因此，我們會發現兩個陣列中的相同數字擁有同一個 id ，並且這些數字的記憶體位址無須連續。</p> <p>Q：C++ STL 裡面的 <code>std::list</code> 已經實現了雙向鏈結串列，但好像一些演算法書上不怎麼直接使用它，是不是因為有什麼侷限性呢？</p> <p>一方面，我們往往更青睞使用陣列實現演算法，而只在必要時才使用鏈結串列，主要有兩個原因。</p> <ul> <li>空間開銷：由於每個元素需要兩個額外的指標（一個用於前一個元素，一個用於後一個元素），所以 <code>std::list</code> 通常比 <code>std::vector</code> 更佔用空間。</li> <li>快取不友好：由於資料不是連續存放的，因此 <code>std::list</code> 對快取的利用率較低。一般情況下，<code>std::vector</code> 的效能會更好。</li> </ul> <p>另一方面，必要使用鏈結串列的情況主要是二元樹和圖。堆疊和佇列往往會使用程式語言提供的 <code>stack</code> 和 <code>queue</code> ，而非鏈結串列。</p> <p>Q：操作 <code>res = [[0]] * n</code> 生成了一個二維串列，其中每一個 <code>[0]</code> 都是獨立的嗎？</p> <p>不是獨立的。此二維串列中，所有的 <code>[0]</code> 實際上是同一個物件的引用。如果我們修改其中一個元素，會發現所有的對應元素都會隨之改變。</p> <p>如果希望二維串列中的每個 <code>[0]</code> 都是獨立的，可以使用 <code>res = [[0] for _ in range(n)]</code> 來實現。這種方式的原理是初始化了 \\(n\\) 個獨立的 <code>[0]</code> 串列物件。</p> <p>Q：操作 <code>res = [0] * n</code> 生成了一個串列，其中每一個整數 0 都是獨立的嗎？</p> <p>在該串列中，所有整數 0 都是同一個物件的引用。這是因為 Python 對小整數（通常是 -5 到 256）採用了快取池機制，以便最大化物件複用，從而提升效能。</p> <p>雖然它們指向同一個物件，但我們仍然可以獨立修改串列中的每個元素，這是因為 Python 的整數是“不可變物件”。當我們修改某個元素時，實際上是切換為另一個物件的引用，而不是改變原有物件本身。</p> <p>然而，當串列元素是“可變物件”時（例如串列、字典或類別例項等），修改某個元素會直接改變該物件本身，所有引用該物件的元素都會產生相同變化。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"第 13 章   回溯","text":"<p>Abstract</p> <p>我們如同迷宮中的探索者，在前進的道路上可能會遇到困難。</p> <p>回溯的力量讓我們能夠重新開始，不斷嘗試，最終找到通往光明的出口。</p>","path":["第 13 章 &nbsp; 回溯"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"本章內容","text":"<ul> <li>13.1   回溯演算法</li> <li>13.2   全排列問題</li> <li>13.3   子集和問題</li> <li>13.4   N 皇后問題</li> <li>13.5   小結</li> </ul>","path":["第 13 章 &nbsp; 回溯"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   回溯演算法","text":"<p>回溯演算法（backtracking algorithm）是一種透過窮舉來解決問題的方法，它的核心思想是從一個初始狀態出發，暴力搜尋所有可能的解決方案，當遇到正確的解則將其記錄，直到找到解或者嘗試了所有可能的選擇都無法找到解為止。</p> <p>回溯演算法通常採用“深度優先搜尋”來走訪解空間。在“二元樹”章節中，我們提到前序、中序和後序走訪都屬於深度優先搜尋。接下來，我們利用前序走訪構造一個回溯問題，逐步瞭解回溯演算法的工作原理。</p> <p>例題一</p> <p>給定一棵二元樹，搜尋並記錄所有值為 \\(7\\) 的節點，請返回節點串列。</p> <p>對於此題，我們前序走訪這棵樹，並判斷當前節點的值是否為 \\(7\\) ，若是，則將該節點的值加入結果串列 <code>res</code> 之中。相關過程實現如圖 13-1 和以下程式碼所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題一\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # 記錄解\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 記錄解\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* 前序走訪：例題一 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* 前序走訪：例題一 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // 記錄解\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* 前序走訪：例題一 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // 記錄解\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* 前序走訪：例題一 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 記錄解\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* 前序走訪：例題一 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 記錄解\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // 記錄解\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* 前序走訪：例題一 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* 前序走訪：例題一 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### 前序走訪：例題一 ###\ndef pre_order(root)\n  return unless root\n\n  # 記錄解\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 13-1   在前序走訪中搜索節點 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   嘗試與回退","text":"<p>之所以稱之為回溯演算法，是因為該演算法在搜尋解空間時會採用“嘗試”與“回退”的策略。當演算法在搜尋過程中遇到某個狀態無法繼續前進或無法得到滿足條件的解時，它會撤銷上一步的選擇，退回到之前的狀態，並嘗試其他可能的選擇。</p> <p>對於例題一，訪問每個節點都代表一次“嘗試”，而越過葉節點或返回父節點的 <code>return</code> 則表示“回退”。</p> <p>值得說明的是，回退並不僅僅包括函式返回。為解釋這一點，我們對例題一稍作拓展。</p> <p>例題二</p> <p>在二元樹中搜索所有值為 \\(7\\) 的節點，請返回根節點到這些節點的路徑。</p> <p>在例題一程式碼的基礎上，我們需要藉助一個串列 <code>path</code> 記錄訪問過的節點路徑。當訪問到值為 \\(7\\) 的節點時，則複製 <code>path</code> 並新增進結果串列 <code>res</code> 。走訪完成後，<code>res</code> 中儲存的就是所有的解。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題二\"\"\"\n    if root is None:\n        return\n    # 嘗試\n    path.append(root)\n    if root.val == 7:\n        # 記錄解\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # 回退\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // 嘗試\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // 嘗試\n    path.add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // 回退\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* 前序走訪：例題二 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // 嘗試\n    path.Add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // 回退\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* 前序走訪：例題二 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // 嘗試\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 記錄解\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // 回退\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* 前序走訪：例題二 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 嘗試\n    path.append(root)\n    if root.val == 7 {\n        // 記錄解\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // 回退\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* 前序走訪：例題二 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* 前序走訪：例題二 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // 嘗試\n  path.add(root);\n  if (root.val == 7) {\n    // 記錄解\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // 回退\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* 前序走訪：例題二 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // 嘗試\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // 回退\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // 嘗試\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 記錄解\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* 前序走訪：例題二 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // 嘗試\n    path!!.add(root)\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // 回退\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### 前序走訪：例題二 ###\ndef pre_order(root)\n  return unless root\n\n  # 嘗試\n  $path &lt;&lt; root\n\n  # 記錄解\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # 回退\n  $path.pop\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在每次“嘗試”中，我們透過將當前節點新增進 <code>path</code> 來記錄路徑；而在“回退”前，我們需要將該節點從 <code>path</code> 中彈出，以恢復本次嘗試之前的狀態。</p> <p>觀察圖 13-2 所示的過程，我們可以將嘗試和回退理解為“前進”與“撤銷”，兩個操作互為逆向。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 13-2   嘗試與回退 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   剪枝","text":"<p>複雜的回溯問題通常包含一個或多個約束條件，約束條件通常可用於“剪枝”。</p> <p>例題三</p> <p>在二元樹中搜索所有值為 \\(7\\) 的節點，請返回根節點到這些節點的路徑，並要求路徑中不包含值為 \\(3\\) 的節點。</p> <p>為了滿足以上約束條件，我們需要新增剪枝操作：在搜尋過程中，若遇到值為 \\(3\\) 的節點，則提前返回，不再繼續搜尋。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題三\"\"\"\n    # 剪枝\n    if root is None or root.val == 3:\n        return\n    # 嘗試\n    path.append(root)\n    if root.val == 7:\n        # 記錄解\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # 回退\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode *root) {\n    // 剪枝\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // 嘗試\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode root) {\n    // 剪枝\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 嘗試\n    path.add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // 回退\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* 前序走訪：例題三 */\nvoid PreOrder(TreeNode? root) {\n    // 剪枝\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 嘗試\n    path.Add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // 回退\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* 前序走訪：例題三 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // 剪枝\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // 嘗試\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 記錄解\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // 回退\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* 前序走訪：例題三 */\nfunc preOrder(root: TreeNode?) {\n    // 剪枝\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // 嘗試\n    path.append(root)\n    if root.val == 7 {\n        // 記錄解\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // 回退\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* 前序走訪：例題三 */\nfunction preOrder(root, path, res) {\n    // 剪枝\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* 前序走訪：例題三 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 剪枝\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // 嘗試\n  path.add(root);\n  if (root.val == 7) {\n    // 記錄解\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // 回退\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* 前序走訪：例題三 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // 剪枝\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // 嘗試\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // 回退\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode *root) {\n    // 剪枝\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // 嘗試\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 記錄解\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* 前序走訪：例題三 */\nfun preOrder(root: TreeNode?) {\n    // 剪枝\n    if (root == null || root._val == 3) {\n        return\n    }\n    // 嘗試\n    path!!.add(root)\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // 回退\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### 前序走訪：例題三 ###\ndef pre_order(root)\n  # 剪枝\n  return if !root || root.val == 3\n\n  # 嘗試\n  $path.append(root)\n\n  # 記錄解\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # 回退\n  $path.pop\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>“剪枝”是一個非常形象的名詞。如圖 13-3 所示，在搜尋過程中，我們“剪掉”了不滿足約束條件的搜尋分支，避免許多無意義的嘗試，從而提高了搜尋效率。</p> <p></p> <p> 圖 13-3   根據約束條件剪枝 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   框架程式碼","text":"<p>接下來，我們嘗試將回溯的“嘗試、回退、剪枝”的主體框架提煉出來，提升程式碼的通用性。</p> <p>在以下框架程式碼中，<code>state</code> 表示問題的當前狀態，<code>choices</code> 表示當前狀態下可以做出的選擇：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"回溯演算法框架\"\"\"\n    # 判斷是否為解\n    if is_solution(state):\n        # 記錄解\n        record_solution(state, res)\n        # 不再繼續搜尋\n        return\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：判斷選擇是否合法\n        if is_valid(state, choice):\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (Choice choice : choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (Choice choice : choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 判斷是否為解\n    if (IsSolution(state)) {\n        // 記錄解\n        RecordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    foreach (Choice choice in choices) {\n        // 剪枝：判斷選擇是否合法\n        if (IsValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // 判斷是否為解\n    if isSolution(state) {\n        // 記錄解\n        recordSolution(state, res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for _, choice := range choices {\n        // 剪枝：判斷選擇是否合法\n        if isValid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // 判斷是否為解\n    if isSolution(state: state) {\n        // 記錄解\n        recordSolution(state: state, res: &amp;res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：判斷選擇是否合法\n        if isValid(state: state, choice: choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunction backtrack(state, choices, res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (let choice of choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (let choice of choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // 判斷是否為解\n  if (isSolution(state)) {\n    // 記錄解\n    recordSolution(state, res);\n    // 不再繼續搜尋\n    return;\n  }\n  // 走訪所有選擇\n  for (Choice choice in choices) {\n    // 剪枝：判斷選擇是否合法\n    if (isValid(state, choice)) {\n      // 嘗試：做出選擇，更新狀態\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // 判斷是否為解\n    if is_solution(state) {\n        // 記錄解\n        record_solution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：判斷選擇是否合法\n        if is_valid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res, numRes);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; numChoices; i++) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, &amp;choices[i])) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### 回溯演算法框架 ###\ndef backtrack(state, choices, res)\n    # 判斷是否為解\n    if is_solution?(state)\n        # 記錄解\n        record_solution(state, res)\n        return\n    end\n\n    # 走訪所有選擇\n    for choice in choices\n        # 剪枝：判斷選擇是否合法\n        if is_valid?(state, choice)\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>接下來，我們基於框架程式碼來解決例題三。狀態 <code>state</code> 為節點走訪路徑，選擇 <code>choices</code> 為當前節點的左子節點和右子節點，結果 <code>res</code> 是路徑串列：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"判斷當前狀態是否為解\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"記錄解\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"判斷在當前狀態下，該選擇是否合法\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"更新狀態\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"恢復狀態\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"回溯演算法：例題三\"\"\"\n    # 檢查是否為解\n    if is_solution(state):\n        # 記錄解\n        record_solution(state, res)\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：檢查選擇是否合法\n        if is_valid(state, choice):\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            # 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (TreeNode *choice : choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* 判斷當前狀態是否為解 */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (TreeNode choice : choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* 判斷當前狀態是否為解 */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* 記錄解 */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* 恢復狀態 */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* 回溯演算法：例題三 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 檢查是否為解\n    if (IsSolution(state)) {\n        // 記錄解\n        RecordSolution(state, res);\n    }\n    // 走訪所有選擇\n    foreach (TreeNode choice in choices) {\n        // 剪枝：檢查選擇是否合法\n        if (IsValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            MakeChoice(state, choice);\n            // 進行下一輪選擇\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* 判斷當前狀態是否為解 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* 記錄解 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* 更新狀態 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* 恢復狀態 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* 回溯演算法：例題三 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // 檢查是否為解\n    if isSolution(state) {\n        // 記錄解\n        recordSolution(state, res)\n    }\n    // 走訪所有選擇\n    for _, choice := range *choices {\n        // 剪枝：檢查選擇是否合法\n        if isValid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            // 進行下一輪選擇\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* 判斷當前狀態是否為解 */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* 記錄解 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* 更新狀態 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* 恢復狀態 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* 回溯演算法：例題三 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // 檢查是否為解\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：檢查選擇是否合法\n        if isValid(state: state, choice: choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state: &amp;state, choice: choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* 判斷當前狀態是否為解 */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 記錄解 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 更新狀態 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfunction backtrack(state, choices, res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* 判斷當前狀態是否為解 */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 記錄解 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 更新狀態 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // 檢查是否為解\n  if (isSolution(state)) {\n    // 記錄解\n    recordSolution(state, res);\n  }\n  // 走訪所有選擇\n  for (TreeNode? choice in choices) {\n    // 剪枝：檢查選擇是否合法\n    if (isValid(state, choice)) {\n      // 嘗試：做出選擇，更新狀態\n      makeChoice(state, choice);\n      // 進行下一輪選擇\n      backtrack(state, [choice!.left, choice.right], res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* 判斷當前狀態是否為解 */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* 記錄解 */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* 更新狀態 */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // 檢查是否為解\n    if is_solution(state) {\n        // 記錄解\n        record_solution(state, res);\n    }\n    // 走訪所有選擇\n    for &amp;choice in choices.iter() {\n        // 剪枝：檢查選擇是否合法\n        if is_valid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            make_choice(state, choice.unwrap().clone());\n            // 進行下一輪選擇\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* 恢復狀態 */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(TreeNode *choices[2]) {\n    // 檢查是否為解\n    if (isSolution()) {\n        // 記錄解\n        recordSolution();\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // 剪枝：檢查選擇是否合法\n        if (isValid(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(choice);\n            // 進行下一輪選擇\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* 判斷當前狀態是否為解 */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* 記錄解 */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* 更新狀態 */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* 恢復狀態 */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* 回溯演算法：例題三 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res)\n    }\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            // 進行下一輪選擇\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### 判斷當前狀態是否為解 ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### 記錄解 ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### 判斷在當前狀態下，該選擇是否合法 ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### 更新狀態 ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### 恢復狀態 ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### 回溯演算法：例題三 ###\ndef backtrack(state, choices, res)\n  # 檢查是否為解\n  record_solution(state, res) if is_solution?(state)\n\n  # 走訪所有選擇\n  for choice in choices\n    # 剪枝：檢查選擇是否合法\n    if is_valid?(state, choice)\n      # 嘗試：做出選擇，更新狀態\n      make_choice(state, choice)\n      # 進行下一輪選擇\n      backtrack(state, [choice.left, choice.right], res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>根據題意，我們在找到值為 \\(7\\) 的節點後應該繼續搜尋，因此需要將記錄解之後的 <code>return</code> 語句刪除。圖 13-4 對比了保留或刪除 <code>return</code> 語句的搜尋過程。</p> <p></p> <p> 圖 13-4   保留與刪除 return 的搜尋過程對比 </p> <p>相比基於前序走訪的程式碼實現，基於回溯演算法框架的程式碼實現雖然顯得囉唆，但通用性更好。實際上，許多回溯問題可以在該框架下解決。我們只需根據具體問題來定義 <code>state</code> 和 <code>choices</code> ，並實現框架中的各個方法即可。</p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   常用術語","text":"<p>為了更清晰地分析演算法問題，我們總結一下回溯演算法中常用術語的含義，並對照例題三給出對應示例，如表 13-1 所示。</p> <p> 表 13-1   常見的回溯演算法術語 </p> 名詞 定義 例題三 解（solution） 解是滿足問題特定條件的答案，可能有一個或多個 根節點到節點 \\(7\\) 的滿足約束條件的所有路徑 約束條件（constraint） 約束條件是問題中限制解的可行性的條件，通常用於剪枝 路徑中不包含節點 \\(3\\) 狀態（state） 狀態表示問題在某一時刻的情況，包括已經做出的選擇 當前已訪問的節點路徑，即 <code>path</code> 節點串列 嘗試（attempt） 嘗試是根據可用選擇來探索解空間的過程，包括做出選擇，更新狀態，檢查是否為解 遞迴訪問左（右）子節點，將節點新增進 <code>path</code> ，判斷節點的值是否為 \\(7\\) 回退（backtracking） 回退指遇到不滿足約束條件的狀態時，撤銷前面做出的選擇，回到上一個狀態 當越過葉節點、結束節點訪問、遇到值為 \\(3\\) 的節點時終止搜尋，函式返回 剪枝（pruning） 剪枝是根據問題特性和約束條件避免無意義的搜尋路徑的方法，可提高搜尋效率 當遇到值為 \\(3\\) 的節點時，則不再繼續搜尋 <p>Tip</p> <p>問題、解、狀態等概念是通用的，在分治、回溯、動態規劃、貪婪等演算法中都有涉及。</p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   優點與侷限性","text":"<p>回溯演算法本質上是一種深度優先搜尋演算法，它嘗試所有可能的解決方案直到找到滿足條件的解。這種方法的優點在於能夠找到所有可能的解決方案，而且在合理的剪枝操作下，具有很高的效率。</p> <p>然而，在處理大規模或者複雜問題時，回溯演算法的執行效率可能難以接受。</p> <ul> <li>時間：回溯演算法通常需要走訪狀態空間的所有可能，時間複雜度可以達到指數階或階乘階。</li> <li>空間：在遞迴呼叫中需要儲存當前的狀態（例如路徑、用於剪枝的輔助變數等），當深度很大時，空間需求可能會變得很大。</li> </ul> <p>即便如此，回溯演算法仍然是某些搜尋問題和約束滿足問題的最佳解決方案。對於這些問題，由於無法預測哪些選擇可生成有效的解，因此我們必須對所有可能的選擇進行走訪。在這種情況下，關鍵是如何最佳化效率，常見的效率最佳化方法有兩種。</p> <ul> <li>剪枝：避免搜尋那些肯定不會產生解的路徑，從而節省時間和空間。</li> <li>啟發式搜尋：在搜尋過程中引入一些策略或者估計值，從而優先搜尋最有可能產生有效解的路徑。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   回溯典型例題","text":"<p>回溯演算法可用於解決許多搜尋問題、約束滿足問題和組合最佳化問題。</p> <p>搜尋問題：這類問題的目標是找到滿足特定條件的解決方案。</p> <ul> <li>全排列問題：給定一個集合，求出其所有可能的排列組合。</li> <li>子集和問題：給定一個集合和一個目標和，找到集合中所有和為目標和的子集。</li> <li>河內塔問題：給定三根柱子和一系列大小不同的圓盤，要求將所有圓盤從一根柱子移動到另一根柱子，每次只能移動一個圓盤，且不能將大圓盤放在小圓盤上。</li> </ul> <p>約束滿足問題：這類問題的目標是找到滿足所有約束條件的解。</p> <ul> <li>\\(n\\) 皇后：在 \\(n \\times n\\) 的棋盤上放置 \\(n\\) 個皇后，使得它們互不攻擊。</li> <li>數獨：在 \\(9 \\times 9\\) 的網格中填入數字 \\(1\\) ~ \\(9\\) ，使得每行、每列和每個 \\(3 \\times 3\\) 子網格中的數字不重複。</li> <li>圖著色問題：給定一個無向圖，用最少的顏色給圖的每個頂點著色，使得相鄰頂點顏色不同。</li> </ul> <p>組合最佳化問題：這類問題的目標是在一個組合空間中找到滿足某些條件的最優解。</p> <ul> <li>0-1 背包問題：給定一組物品和一個背包，每個物品有一定的價值和重量，要求在背包容量限制內，選擇物品使得總價值最大。</li> <li>旅行商問題：在一個圖中，從一個點出發，訪問所有其他點恰好一次後返回起點，求最短路徑。</li> <li>最大團問題：給定一個無向圖，找到最大的完全子圖，即子圖中的任意兩個頂點之間都有邊相連。</li> </ul> <p>請注意，對於許多組合最佳化問題，回溯不是最優解決方案。</p> <ul> <li>0-1 背包問題通常使用動態規劃解決，以達到更高的時間效率。</li> <li>旅行商是一個著名的 NP-Hard 問題，常用解法有遺傳演算法和蟻群演算法等。</li> <li>最大團問題是圖論中的一個經典問題，可用貪婪演算法等啟發式演算法來解決。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   n 皇后問題","text":"<p>Question</p> <p>根據國際象棋的規則，皇后可以攻擊與同處一行、一列或一條斜線上的棋子。給定 \\(n\\) 個皇后和一個 \\(n \\times n\\) 大小的棋盤，尋找使得所有皇后之間無法相互攻擊的擺放方案。</p> <p>如圖 13-15 所示，當 \\(n = 4\\) 時，共可以找到兩個解。從回溯演算法的角度看，\\(n \\times n\\) 大小的棋盤共有 \\(n^2\\) 個格子，給出了所有的選擇 <code>choices</code> 。在逐個放置皇后的過程中，棋盤狀態在不斷地變化，每個時刻的棋盤就是狀態 <code>state</code> 。</p> <p></p> <p> 圖 13-15   4 皇后問題的解 </p> <p>圖 13-16 展示了本題的三個約束條件：多個皇后不能在同一行、同一列、同一條對角線上。值得注意的是，對角線分為主對角線 <code>\\</code> 和次對角線 <code>/</code> 兩種。</p> <p></p> <p> 圖 13-16   n 皇后問題的約束條件 </p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   逐行放置策略","text":"<p>皇后的數量和棋盤的行數都為 \\(n\\) ，因此我們容易得到一個推論：棋盤每行都允許且只允許放置一個皇后。</p> <p>也就是說，我們可以採取逐行放置策略：從第一行開始，在每行放置一個皇后，直至最後一行結束。</p> <p>圖 13-17 所示為 4 皇后問題的逐行放置過程。受畫幅限制，圖 13-17 僅展開了第一行的其中一個搜尋分支，並且將不滿足列約束和對角線約束的方案都進行了剪枝。</p> <p></p> <p> 圖 13-17   逐行放置策略 </p> <p>從本質上看，逐行放置策略起到了剪枝的作用，它避免了同一行出現多個皇后的所有搜尋分支。</p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   列與對角線剪枝","text":"<p>為了滿足列約束，我們可以利用一個長度為 \\(n\\) 的布林型陣列 <code>cols</code> 記錄每一列是否有皇后。在每次決定放置前，我們透過 <code>cols</code> 將已有皇后的列進行剪枝，並在回溯中動態更新 <code>cols</code> 的狀態。</p> <p>Tip</p> <p>請注意，矩陣的起點位於左上角，其中行索引從上到下增加，列索引從左到右增加。</p> <p>那麼，如何處理對角線約束呢？設棋盤中某個格子的行列索引為 \\((row, col)\\) ，選定矩陣中的某條主對角線，我們發現該對角線上所有格子的行索引減列索引都相等，即主對角線上所有格子的 \\(row - col\\) 為恆定值。</p> <p>也就是說，如果兩個格子滿足 \\(row_1 - col_1 = row_2 - col_2\\) ，則它們一定處在同一條主對角線上。利用該規律，我們可以藉助圖 13-18 所示的陣列 <code>diags1</code> 記錄每條主對角線上是否有皇后。</p> <p>同理，次對角線上的所有格子的 \\(row + col\\) 是恆定值。我們同樣也可以藉助陣列 <code>diags2</code> 來處理次對角線約束。</p> <p></p> <p> 圖 13-18   處理列約束和對角線約束 </p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>請注意，\\(n\\) 維方陣中 \\(row - col\\) 的範圍是 \\([-n + 1, n - 1]\\) ，\\(row + col\\) 的範圍是 \\([0, 2n - 2]\\) ，所以主對角線和次對角線的數量都為 \\(2n - 1\\) ，即陣列 <code>diags1</code> 和 <code>diags2</code> 的長度都為 \\(2n - 1\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"回溯演算法：n 皇后\"\"\"\n    # 當放置完所有行時，記錄解\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # 走訪所有列\n    for col in range(n):\n        # 計算該格子對應的主對角線和次對角線\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"求解 n 皇后\"\"\"\n    # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # 記錄列是否有皇后\n    diags1 = [False] * (2 * n - 1)  # 記錄主對角線上是否有皇后\n    diags2 = [False] * (2 * n - 1)  # 記錄次對角線上是否有皇后\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // 記錄列是否有皇后\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // 記錄主對角線上是否有皇后\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // 記錄次對角線上是否有皇后\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // 記錄列是否有皇后\n    boolean[] diags1 = new boolean[2 * n - 1]; // 記錄主對角線上是否有皇后\n    boolean[] diags2 = new boolean[2 * n - 1]; // 記錄次對角線上是否有皇后\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* 回溯演算法：n 皇后 */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // 記錄列是否有皇后\n    bool[] diags1 = new bool[2 * n - 1]; // 記錄主對角線上是否有皇后\n    bool[] diags2 = new bool[2 * n - 1]; // 記錄次對角線上是否有皇后\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* 回溯演算法：n 皇后 */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有列\n    for col := 0; col &lt; n; col++ {\n        // 計算該格子對應的主對角線和次對角線\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // 嘗試：將皇后放置在該格子\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // 放置下一行\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // 回退：將該格子恢復為空位\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunc nQueens(n int) [][][]string {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // 記錄列是否有皇后\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* 回溯演算法：n 皇后 */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        res.append(state)\n        return\n    }\n    // 走訪所有列\n    for col in 0 ..&lt; n {\n        // 計算該格子對應的主對角線和次對角線\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // 放置下一行\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // 記錄列是否有皇后\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // 記錄主對角線上是否有皇后\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // 記錄次對角線上是否有皇后\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* 回溯演算法：n 皇后 */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // 當放置完所有行時，記錄解\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // 走訪所有列\n    for (let col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunction nQueens(n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 記錄列是否有皇后\n    const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后\n    const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* 回溯演算法：n 皇后 */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // 當放置完所有行時，記錄解\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // 走訪所有列\n    for (let col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunction nQueens(n: number): string[][][] {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 記錄列是否有皇后\n    const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后\n    const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // 當放置完所有行時，記錄解\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // 走訪所有列\n  for (int col = 0; col &lt; n; col++) {\n    // 計算該格子對應的主對角線和次對角線\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // 嘗試：將皇后放置在該格子\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // 放置下一行\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // 回退：將該格子恢復為空位\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // 記錄列是否有皇后\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // 記錄主對角線上是否有皇后\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // 記錄次對角線上是否有皇后\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* 回溯演算法：n 皇后 */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有列\n    for col in 0..n {\n        // 計算該格子對應的主對角線和次對角線\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // 記錄列是否有皇后\n    let mut diags1 = vec![false; 2 * n - 1]; // 記錄主對角線上是否有皇后\n    let mut diags2 = vec![false; 2 * n - 1]; // 記錄次對角線上是否有皇后\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // 記錄列是否有皇后\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // 記錄主對角線上是否有皇后\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // 記錄次對角線上是否有皇后\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* 回溯演算法：n 皇后 */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // 走訪所有列\n    for (col in 0..&lt;n) {\n        // 計算該格子對應的主對角線和次對角線\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // 記錄列是否有皇后\n    val diags1 = BooleanArray(2 * n - 1) // 記錄主對角線上是否有皇后\n    val diags2 = BooleanArray(2 * n - 1) // 記錄次對角線上是否有皇后\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### 回溯演算法：n 皇后 ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # 當放置完所有行時，記錄解\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # 走訪所有列\n  for col in 0...n\n    # 計算該格子對應的主對角線和次對角線\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # 嘗試：將皇后放置在該格子\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # 放置下一行\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # 回退：將該格子恢復為空位\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### 求解 n 皇后 ###\ndef n_queens(n)\n  # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # 記錄列是否有皇后\n  diags1 = Array.new(2 * n - 1, false) # 記錄主對角線上是否有皇后\n  diags2 = Array.new(2 * n - 1, false) # 記錄次對角線上是否有皇后\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>逐行放置 \\(n\\) 次，考慮列約束，則從第一行到最後一行分別有 \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 個選擇，使用 \\(O(n!)\\) 時間。當記錄解時，需要複製矩陣 <code>state</code> 並新增進 <code>res</code> ，複製操作使用 \\(O(n^2)\\) 時間。因此，總體時間複雜度為 \\(O(n! \\cdot n^2)\\) 。實際上，根據對角線約束的剪枝也能夠大幅縮小搜尋空間，因而搜尋效率往往優於以上時間複雜度。</p> <p>陣列 <code>state</code> 使用 \\(O(n^2)\\) 空間，陣列 <code>cols</code>、<code>diags1</code> 和 <code>diags2</code> 皆使用 \\(O(n)\\) 空間。最大遞迴深度為 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。因此，空間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   全排列問題","text":"<p>全排列問題是回溯演算法的一個典型應用。它的定義是在給定一個集合（如一個陣列或字串）的情況下，找出其中元素的所有可能的排列。</p> <p>表 13-2 列舉了幾個示例資料，包括輸入陣列和對應的所有排列。</p> <p> 表 13-2   全排列示例 </p> 輸入陣列 所有排列 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   無相等元素的情況","text":"<p>Question</p> <p>輸入一個整數陣列，其中不包含重複元素，返回所有可能的排列。</p> <p>從回溯演算法的角度看，我們可以把生成排列的過程想象成一系列選擇的結果。假設輸入陣列為 \\([1, 2, 3]\\) ，如果我們先選擇 \\(1\\) ，再選擇 \\(3\\) ，最後選擇 \\(2\\) ，則獲得排列 \\([1, 3, 2]\\) 。回退表示撤銷一個選擇，之後繼續嘗試其他選擇。</p> <p>從回溯程式碼的角度看，候選集合 <code>choices</code> 是輸入陣列中的所有元素，狀態 <code>state</code> 是直至目前已被選擇的元素。請注意，每個元素只允許被選擇一次，因此 <code>state</code> 中的所有元素都應該是唯一的。</p> <p>如圖 13-5 所示，我們可以將搜尋過程展開成一棵遞迴樹，樹中的每個節點代表當前狀態 <code>state</code> 。從根節點開始，經過三輪選擇後到達葉節點，每個葉節點都對應一個排列。</p> <p></p> <p> 圖 13-5   全排列的遞迴樹 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   重複選擇剪枝","text":"<p>為了實現每個元素只被選擇一次，我們考慮引入一個布林型陣列 <code>selected</code> ，其中 <code>selected[i]</code> 表示 <code>choices[i]</code> 是否已被選擇，並基於它實現以下剪枝操作。</p> <ul> <li>在做出選擇 <code>choice[i]</code> 後，我們就將 <code>selected[i]</code> 賦值為 \\(\\text{True}\\) ，代表它已被選擇。</li> <li>走訪選擇串列 <code>choices</code> 時，跳過所有已被選擇的節點，即剪枝。</li> </ul> <p>如圖 13-6 所示，假設我們第一輪選擇 1 ，第二輪選擇 3 ，第三輪選擇 2 ，則需要在第二輪剪掉元素 1 的分支，在第三輪剪掉元素 1 和元素 3 的分支。</p> <p></p> <p> 圖 13-6   全排列剪枝示例 </p> <p>觀察圖 13-6 發現，該剪枝操作將搜尋空間大小從 \\(O(n^n)\\) 減小至 \\(O(n!)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>想清楚以上資訊之後，我們就可以在框架程式碼中做“完形填空”了。為了縮短整體程式碼，我們不單獨實現框架程式碼中的各個函式，而是將它們展開在 <code>backtrack()</code> 函式中：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"回溯演算法：全排列 I\"\"\"\n    # 當狀態長度等於元素數量時，記錄解\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    for i, choice in enumerate(choices):\n        # 剪枝：不允許重複選擇元素\n        if not selected[i]:\n            # 嘗試：做出選擇，更新狀態\n            selected[i] = True\n            state.append(choice)\n            # 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全排列 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push_back(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全排列 I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.add(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全排列 I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* 回溯演算法：全排列 I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.Add(choice);\n            // 進行下一輪選擇\n            Backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全排列 I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* 回溯演算法：全排列 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 當狀態長度等於元素數量時，記錄解\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // 走訪所有選擇\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 剪枝：不允許重複選擇元素\n        if !(*selected)[i] {\n            // 嘗試：做出選擇，更新狀態\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 進行下一輪選擇\n            backtrackI(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全排列 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* 回溯演算法：全排列 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    for (i, choice) in choices.enumerated() {\n        // 剪枝：不允許重複選擇元素\n        if !selected[i] {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true\n            state.append(choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全排列 I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* 回溯演算法：全排列 I */\nfunction backtrack(state, choices, selected, res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* 回溯演算法：全排列 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 當狀態長度等於元素數量時，記錄解\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 剪枝：不允許重複選擇元素\n    if (!selected[i]) {\n      // 嘗試：做出選擇，更新狀態\n      selected[i] = true;\n      state.add(choice);\n      // 進行下一輪選擇\n      backtrack(state, choices, selected, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全排列 I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* 回溯演算法：全排列 I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // 走訪所有選擇\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if !selected[i] {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state.clone(), choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全排列 I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // 狀態（子集）\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 進行下一輪選擇\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全排列 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* 回溯演算法：全排列 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true\n            state.add(choice)\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全排列 I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### 回溯演算法：全排列 I ###\ndef backtrack(state, choices, selected, res)\n  # 當狀態長度等於元素數量時，記錄解\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  choices.each_with_index do |choice, i|\n    # 剪枝：不允許重複選擇元素\n    unless selected[i]\n      # 嘗試：做出選擇，更新狀態\n      selected[i] = true\n      state &lt;&lt; choice\n      # 進行下一輪選擇\n      backtrack(state, choices, selected, res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全排列 I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   考慮相等元素的情況","text":"<p>Question</p> <p>輸入一個整數陣列，陣列中可能包含重複元素，返回所有不重複的排列。</p> <p>假設輸入陣列為 \\([1, 1, 2]\\) 。為了方便區分兩個重複元素 \\(1\\) ，我們將第二個 \\(1\\) 記為 \\(\\hat{1}\\) 。</p> <p>如圖 13-7 所示，上述方法生成的排列有一半是重複的。</p> <p></p> <p> 圖 13-7   重複排列 </p> <p>那麼如何去除重複的排列呢？最直接地，考慮藉助一個雜湊集合，直接對排列結果進行去重。然而這樣做不夠優雅，因為生成重複排列的搜尋分支沒有必要，應當提前識別並剪枝，這樣可以進一步提升演算法效率。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   相等元素剪枝","text":"<p>觀察圖 13-8 ，在第一輪中，選擇 \\(1\\) 或選擇 \\(\\hat{1}\\) 是等價的，在這兩個選擇之下生成的所有排列都是重複的。因此應該把 \\(\\hat{1}\\) 剪枝。</p> <p>同理，在第一輪選擇 \\(2\\) 之後，第二輪選擇中的 \\(1\\) 和 \\(\\hat{1}\\) 也會產生重複分支，因此也應將第二輪的 \\(\\hat{1}\\) 剪枝。</p> <p>從本質上看，我們的目標是在某一輪選擇中，保證多個相等的元素僅被選擇一次。</p> <p></p> <p> 圖 13-8   重複排列剪枝 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"<p>在上一題的程式碼的基礎上，我們考慮在每一輪選擇中開啟一個雜湊集合 <code>duplicated</code> ，用於記錄該輪中已經嘗試過的元素，並將重複元素剪枝：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"回溯演算法：全排列 II\"\"\"\n    # 當狀態長度等於元素數量時，記錄解\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if not selected[i] and choice not in duplicated:\n            # 嘗試：做出選擇，更新狀態\n            duplicated.add(choice)  # 記錄選擇過的元素值\n            selected[i] = True\n            state.append(choice)\n            # 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全排列 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.emplace(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push_back(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全排列 II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.add(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全排列 II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* 回溯演算法：全排列 II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.Add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.Add(choice);\n            // 進行下一輪選擇\n            Backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全排列 II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* 回溯演算法：全排列 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 當狀態長度等於元素數量時，記錄解\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // 走訪所有選擇\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // 嘗試：做出選擇，更新狀態\n            // 記錄選擇過的元素值\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 進行下一輪選擇\n            backtrackII(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全排列 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* 回溯演算法：全排列 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if !selected[i], !duplicated.contains(choice) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.insert(choice) // 記錄選擇過的元素值\n            selected[i] = true\n            state.append(choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全排列 II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* 回溯演算法：全排列 II */\nfunction backtrack(state, choices, selected, res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* 回溯演算法：全排列 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 當狀態長度等於元素數量時，記錄解\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // 嘗試：做出選擇，更新狀態\n      duplicated.add(choice); // 記錄選擇過的元素值\n      selected[i] = true;\n      state.add(choice);\n      // 進行下一輪選擇\n      backtrack(state, choices, selected, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全排列 II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* 回溯演算法：全排列 II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // 走訪所有選擇\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.insert(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state.clone(), choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全排列 II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有選擇\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated[choice] = true; // 記錄選擇過的元素值\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 進行下一輪選擇\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全排列 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* 回溯演算法：全排列 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice) // 記錄選擇過的元素值\n            selected[i] = true\n            state.add(choice)\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全排列 II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### 回溯演算法：全排列 II ###\ndef backtrack(state, choices, selected, res)\n  # 當狀態長度等於元素數量時，記錄解\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # 嘗試：做出選擇，更新狀態\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # 進行下一輪選擇\n      backtrack(state, choices, selected, res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全排列 II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>假設元素兩兩之間互不相同，則 \\(n\\) 個元素共有 \\(n!\\)  種排列（階乘）；在記錄結果時，需要複製長度為 \\(n\\) 的串列，使用 \\(O(n)\\) 時間。因此時間複雜度為 \\(O(n!n)\\) 。</p> <p>最大遞迴深度為 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。<code>selected</code> 使用 \\(O(n)\\) 空間。同一時刻最多共有 \\(n\\) 個 <code>duplicated</code> ，使用 \\(O(n^2)\\) 空間。因此空間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3","level":3,"title":"3.   兩種剪枝對比","text":"<p>請注意，雖然 <code>selected</code> 和 <code>duplicated</code> 都用於剪枝，但兩者的目標不同。</p> <ul> <li>重複選擇剪枝：整個搜尋過程中只有一個 <code>selected</code> 。它記錄的是當前狀態中包含哪些元素，其作用是避免某個元素在 <code>state</code> 中重複出現。</li> <li>相等元素剪枝：每輪選擇（每個呼叫的 <code>backtrack</code> 函式）都包含一個 <code>duplicated</code> 。它記錄的是在本輪走訪（<code>for</code> 迴圈）中哪些元素已被選擇過，其作用是保證相等元素只被選擇一次。</li> </ul> <p>圖 13-9 展示了兩個剪枝條件的生效範圍。注意，樹中的每個節點代表一個選擇，從根節點到葉節點的路徑上的各個節點構成一個排列。</p> <p></p> <p> 圖 13-9   兩種剪枝條件的作用範圍 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   子集和問題","text":"","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   無重複元素的情況","text":"<p>Question</p> <p>給定一個正整數陣列 <code>nums</code> 和一個目標正整數 <code>target</code> ，請找出所有可能的組合，使得組合中的元素和等於 <code>target</code> 。給定陣列無重複元素，每個元素可以被選取多次。請以串列形式返回這些組合，串列中不應包含重複組合。</p> <p>例如，輸入集合 \\(\\{3, 4, 5\\}\\) 和目標整數 \\(9\\) ，解為 \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) 。需要注意以下兩點。</p> <ul> <li>輸入集合中的元素可以被無限次重複選取。</li> <li>子集不區分元素順序，比如 \\(\\{4, 5\\}\\) 和 \\(\\{5, 4\\}\\) 是同一個子集。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   參考全排列解法","text":"<p>類似於全排列問題，我們可以把子集的生成過程想象成一系列選擇的結果，並在選擇過程中即時更新“元素和”，當元素和等於 <code>target</code> 時，就將子集記錄至結果串列。</p> <p>而與全排列問題不同的是，本題集合中的元素可以被無限次選取，因此無須藉助 <code>selected</code> 布林串列來記錄元素是否已被選擇。我們可以對全排列程式碼進行小幅修改，初步得到解題程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"回溯演算法：子集和 I\"\"\"\n    # 子集和等於 target 時，記錄解\n    if total == target:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    for i in range(len(choices)):\n        # 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target:\n            continue\n        # 嘗試：做出選擇，更新元素和 total\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 I（包含重複子集）\"\"\"\n    state = []  # 狀態（子集）\n    total = 0  # 子集和\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // 狀態（子集）\n    int total = 0;           // 子集和\n    vector&lt;vector&lt;int&gt;&gt; res; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    int total = 0; // 子集和\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* 回溯演算法：子集和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    int total = 0; // 子集和\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    for i := 0; i &lt; len(*choices); i++ {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    total := 0              // 子集和\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if total == target {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    for i in choices.indices {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let total = 0 // 子集和\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(state, target, total, choices, res) {\n    // 子集和等於 target 時，記錄解\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // 狀態（子集）\n    const total = 0; // 子集和\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    const total = 0; // 子集和\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  for (int i = 0; i &lt; choices.length; i++) {\n    // 剪枝：若子集和超過 target ，則跳過該選擇\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // 嘗試：做出選擇，更新元素和 total\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target, total + choices[i], choices, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  int total = 0; // 元素和\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* 回溯演算法：子集和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    for i in 0..choices.len() {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    let total = 0; // 子集和\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state[stateSize++] = choices[i];\n        // 進行下一輪選擇\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // 初始化解的數量為0\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* 回溯演算法：子集和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    for (i in choices.indices) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    val total = 0 // 子集和\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### 回溯演算法：子集和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 子集和等於 target 時，記錄解\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  for i in 0...choices.length\n    # 剪枝：若子集和超過 target ，則跳過該選擇\n    next if total + choices[i] &gt; target\n    # 嘗試：做出選擇，更新元素和 total\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target, total + choices[i], choices, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 I（包含重複子集）###\ndef subset_sum_i_naive(nums, target)\n  state = [] # 狀態（子集）\n  total = 0 # 子集和\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>向以上程式碼輸入陣列 \\([3, 4, 5]\\) 和目標元素 \\(9\\) ，輸出結果為 \\([3, 3, 3], [4, 5], [5, 4]\\) 。雖然成功找出了所有和為 \\(9\\) 的子集，但其中存在重複的子集 \\([4, 5]\\) 和 \\([5, 4]\\) 。</p> <p>這是因為搜尋過程是區分選擇順序的，然而子集不區分選擇順序。如圖 13-10 所示，先選 \\(4\\) 後選 \\(5\\) 與先選 \\(5\\) 後選 \\(4\\) 是不同的分支，但對應同一個子集。</p> <p></p> <p> 圖 13-10   子集搜尋與越界剪枝 </p> <p>為了去除重複子集，一種直接的思路是對結果串列進行去重。但這個方法效率很低，有兩方面原因。</p> <ul> <li>當陣列元素較多，尤其是當 <code>target</code> 較大時，搜尋過程會產生大量的重複子集。</li> <li>比較子集（陣列）的異同非常耗時，需要先排序陣列，再比較陣列中每個元素的異同。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   重複子集剪枝","text":"<p>我們考慮在搜尋過程中透過剪枝進行去重。觀察圖 13-11 ，重複子集是在以不同順序選擇陣列元素時產生的，例如以下情況。</p> <ol> <li>當第一輪和第二輪分別選擇 \\(3\\) 和 \\(4\\) 時，會生成包含這兩個元素的所有子集，記為 \\([3, 4, \\dots]\\) 。</li> <li>之後，當第一輪選擇 \\(4\\) 時，則第二輪應該跳過 \\(3\\) ，因為該選擇產生的子集 \\([4, 3, \\dots]\\) 和第 <code>1.</code> 步中生成的子集完全重複。</li> </ol> <p>在搜尋過程中，每一層的選擇都是從左到右被逐個嘗試的，因此越靠右的分支被剪掉的越多。</p> <ol> <li>前兩輪選擇 \\(3\\) 和 \\(5\\) ，生成子集 \\([3, 5, \\dots]\\) 。</li> <li>前兩輪選擇 \\(4\\) 和 \\(5\\) ，生成子集 \\([4, 5, \\dots]\\) 。</li> <li>若第一輪選擇 \\(5\\) ，則第二輪應該跳過 \\(3\\) 和 \\(4\\) ，因為子集 \\([5, 3, \\dots]\\) 和 \\([5, 4, \\dots]\\) 與第 <code>1.</code> 步和第 <code>2.</code> 步中描述的子集完全重複。</li> </ol> <p></p> <p> 圖 13-11   不同選擇順序導致的重複子集 </p> <p>總結來看，給定輸入陣列 \\([x_1, x_2, \\dots, x_n]\\) ，設搜尋過程中的選擇序列為 \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) ，則該選擇序列需要滿足 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ，不滿足該條件的選擇序列都會造成重複，應當剪枝。</p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>為實現該剪枝，我們初始化變數 <code>start</code> ，用於指示走訪起始點。當做出選擇 \\(x_{i}\\) 後，設定下一輪從索引 \\(i\\) 開始走訪。這樣做就可以讓選擇序列滿足 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ，從而保證子集唯一。</p> <p>除此之外，我們還對程式碼進行了以下兩項最佳化。</p> <ul> <li>在開啟搜尋前，先將陣列 <code>nums</code> 排序。在走訪所有選擇時，當子集和超過 <code>target</code> 時直接結束迴圈，因為後邊的元素更大，其子集和一定超過 <code>target</code> 。</li> <li>省去元素和變數 <code>total</code> ，透過在 <code>target</code> 上執行減法來統計元素和，當 <code>target</code> 等於 \\(0\\) 時記錄解。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"回溯演算法：子集和 I\"\"\"\n    # 子集和等於 target 時，記錄解\n    if target == 0:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    # 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in range(start, len(choices)):\n        # 剪枝一：若子集和超過 target ，則直接結束迴圈\n        # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0:\n            break\n        # 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 I\"\"\"\n    state = []  # 狀態（子集）\n    nums.sort()  # 對 nums 進行排序\n    start = 0  # 走訪起始點\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 狀態（子集）\n    sort(nums.begin(), nums.end()); // 對 nums 進行排序\n    int start = 0;                  // 走訪起始點\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    Arrays.sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* 回溯演算法：子集和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    Array.Sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i := start; i &lt; len(*choices); i++ {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    sort.Ints(nums)         // 對 nums 進行排序\n    start := 0              // 走訪起始點\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in choices.indices.dropFirst(start) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let nums = nums.sorted() // 對 nums 進行排序\n    let start = 0 // 走訪起始點\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(state, target, choices, start, res) {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfunction subsetSumI(nums, target) {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  // 剪枝二：從 start 開始走訪，避免生成重複子集\n  for (int i = start; i &lt; choices.length; i++) {\n    // 剪枝一：若子集和超過 target ，則直接結束迴圈\n    // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 嘗試：做出選擇，更新 target, start\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  nums.sort(); // 對 nums 進行排序\n  int start = 0; // 走訪起始點\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* 回溯演算法：子集和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in start..choices.len() {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    nums.sort(); // 對 nums 進行排序\n    let start = 0; // 走訪起始點\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 進行下一輪選擇\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // 對 nums 進行排序\n    int start = 0;                           // 走訪起始點\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* 回溯演算法：子集和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (i in start..&lt;choices.size) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    nums.sort() // 對 nums 進行排序\n    val start = 0 // 走訪起始點\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### 回溯演算法：子集和 I ###\ndef backtrack(state, target, choices, start, res)\n  # 子集和等於 target 時，記錄解\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # 走訪所有選擇\n  # 剪枝二：從 start 開始走訪，避免生成重複子集\n  for i in start...choices.length\n    # 剪枝一：若子集和超過 target ，則直接結束迴圈\n    # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    break if target - choices[i] &lt; 0\n    # 嘗試：做出選擇，更新 target, start\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 I ###\ndef subset_sum_i(nums, target)\n  state = [] # 狀態（子集）\n  nums.sort! # 對 nums 進行排序\n  start = 0 # 走訪起始點\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 13-12 所示為將陣列 \\([3, 4, 5]\\) 和目標元素 \\(9\\) 輸入以上程式碼後的整體回溯過程。</p> <p></p> <p> 圖 13-12   子集和 I 回溯過程 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   考慮重複元素的情況","text":"<p>Question</p> <p>給定一個正整數陣列 <code>nums</code> 和一個目標正整數 <code>target</code> ，請找出所有可能的組合，使得組合中的元素和等於 <code>target</code> 。給定陣列可能包含重複元素，每個元素只可被選擇一次。請以串列形式返回這些組合，串列中不應包含重複組合。</p> <p>相比於上題，本題的輸入陣列可能包含重複元素，這引入了新的問題。例如，給定陣列 \\([4, \\hat{4}, 5]\\) 和目標元素 \\(9\\) ，則現有程式碼的輸出結果為 \\([4, 5], [\\hat{4}, 5]\\) ，出現了重複子集。</p> <p>造成這種重複的原因是相等元素在某輪中被多次選擇。在圖 13-13 中，第一輪共有三個選擇，其中兩個都為 \\(4\\) ，會產生兩個重複的搜尋分支，從而輸出重複子集；同理，第二輪的兩個 \\(4\\) 也會產生重複子集。</p> <p></p> <p> 圖 13-13   相等元素導致的重複子集 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   相等元素剪枝","text":"<p>為解決此問題，我們需要限制相等元素在每一輪中只能被選擇一次。實現方式比較巧妙：由於陣列是已排序的，因此相等元素都是相鄰的。這意味著在某輪選擇中，若當前元素與其左邊元素相等，則說明它已經被選擇過，因此直接跳過當前元素。</p> <p>與此同時，本題規定每個陣列元素只能被選擇一次。幸運的是，我們也可以利用變數 <code>start</code> 來滿足該約束：當做出選擇 \\(x_{i}\\) 後，設定下一輪從索引 \\(i + 1\\) 開始向後走訪。這樣既能去除重複子集，也能避免重複選擇元素。</p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"回溯演算法：子集和 II\"\"\"\n    # 子集和等於 target 時，記錄解\n    if target == 0:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    # 剪枝二：從 start 開始走訪，避免生成重複子集\n    # 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in range(start, len(choices)):\n        # 剪枝一：若子集和超過 target ，則直接結束迴圈\n        # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0:\n            break\n        # 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 II\"\"\"\n    state = []  # 狀態（子集）\n    nums.sort()  # 對 nums 進行排序\n    start = 0  # 走訪起始點\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 狀態（子集）\n    sort(nums.begin(), nums.end()); // 對 nums 進行排序\n    int start = 0;                  // 走訪起始點\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    Arrays.sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* 回溯演算法：子集和 II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    Array.Sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* 回溯演算法：子集和 II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i := start; i &lt; len(*choices); i++ {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    sort.Ints(nums)         // 對 nums 進行排序\n    start := 0              // 走訪起始點\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* 回溯演算法：子集和 II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in choices.indices.dropFirst(start) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let nums = nums.sorted() // 對 nums 進行排序\n    let start = 0 // 走訪起始點\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* 回溯演算法：子集和 II */\nfunction backtrack(state, target, choices, start, res) {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfunction subsetSumII(nums, target) {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* 回溯演算法：子集和 II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  // 剪枝二：從 start 開始走訪，避免生成重複子集\n  // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n  for (int i = start; i &lt; choices.length; i++) {\n    // 剪枝一：若子集和超過 target ，則直接結束迴圈\n    // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // 嘗試：做出選擇，更新 target, start\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  nums.sort(); // 對 nums 進行排序\n  int start = 0; // 走訪起始點\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* 回溯演算法：子集和 II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in start..choices.len() {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    nums.sort(); // 對 nums 進行排序\n    let start = 0; // 走訪起始點\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 剪枝一：若子集和超過 target ，則直接跳過\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 進行下一輪選擇\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // 對 nums 進行排序\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // 開始回溯\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* 回溯演算法：子集和 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (i in start..&lt;choices.size) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    nums.sort() // 對 nums 進行排序\n    val start = 0 // 走訪起始點\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### 回溯演算法：子集和 II ###\ndef backtrack(state, target, choices, start, res)\n  # 子集和等於 target 時，記錄解\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  # 剪枝二：從 start 開始走訪，避免生成重複子集\n  # 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n  for i in start...choices.length\n    # 剪枝一：若子集和超過 target ，則直接結束迴圈\n    # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    break if target - choices[i] &lt; 0\n    # 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # 嘗試：做出選擇，更新 target, start\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 II ###\ndef subset_sum_ii(nums, target)\n  state = [] # 狀態（子集）\n  nums.sort! # 對 nums 進行排序\n  start = 0 # 走訪起始點\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 13-14 展示了陣列 \\([4, 4, 5]\\) 和目標元素 \\(9\\) 的回溯過程，共包含四種剪枝操作。請你將圖示與程式碼註釋相結合，理解整個搜尋過程，以及每種剪枝操作是如何工作的。</p> <p></p> <p> 圖 13-14   子集和 II 回溯過程 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   小結","text":"","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>回溯演算法本質是窮舉法，透過對解空間進行深度優先走訪來尋找符合條件的解。在搜尋過程中，遇到滿足條件的解則記錄，直至找到所有解或走訪完成後結束。</li> <li>回溯演算法的搜尋過程包括嘗試與回退兩個部分。它透過深度優先搜尋來嘗試各種選擇，當遇到不滿足約束條件的情況時，則撤銷上一步的選擇，退回到之前的狀態，並繼續嘗試其他選擇。嘗試與回退是兩個方向相反的操作。</li> <li>回溯問題通常包含多個約束條件，它們可用於實現剪枝操作。剪枝可以提前結束不必要的搜尋分支，大幅提升搜尋效率。</li> <li>回溯演算法主要可用於解決搜尋問題和約束滿足問題。組合最佳化問題雖然可以用回溯演算法解決，但往往存在效率更高或效果更好的解法。</li> <li>全排列問題旨在搜尋給定集合元素的所有可能的排列。我們藉助一個陣列來記錄每個元素是否被選擇，剪掉重複選擇同一元素的搜尋分支，確保每個元素只被選擇一次。</li> <li>在全排列問題中，如果集合中存在重複元素，則最終結果會出現重複排列。我們需要約束相等元素在每輪中只能被選擇一次，這通常藉助一個雜湊集合來實現。</li> <li>子集和問題的目標是在給定集合中找到和為目標值的所有子集。集合不區分元素順序，而搜尋過程會輸出所有順序的結果，產生重複子集。我們在回溯前將資料進行排序，並設定一個變數來指示每一輪的走訪起始點，從而將生成重複子集的搜尋分支進行剪枝。</li> <li>對於子集和問題，陣列中的相等元素會產生重複集合。我們利用陣列已排序的前置條件，透過判斷相鄰元素是否相等實現剪枝，從而確保相等元素在每輪中只能被選中一次。</li> <li>\\(n\\) 皇后問題旨在尋找將 \\(n\\) 個皇后放置到 \\(n \\times n\\) 尺寸棋盤上的方案，要求所有皇后兩兩之間無法攻擊對方。該問題的約束條件有行約束、列約束、主對角線和次對角線約束。為滿足行約束，我們採用按行放置的策略，保證每一行放置一個皇后。</li> <li>列約束和對角線約束的處理方式類似。對於列約束，我們利用一個陣列來記錄每一列是否有皇后，從而指示選中的格子是否合法。對於對角線約束，我們藉助兩個陣列來分別記錄該主、次對角線上是否存在皇后；難點在於找出處在同一主（副）對角線上的格子所滿足的行列索引規律。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：怎麼理解回溯和遞迴的關係？</p> <p>總的來看，回溯是一種“演算法策略”，而遞迴更像是一個“工具”。</p> <ul> <li>回溯演算法通常基於遞迴實現。然而，回溯是遞迴的應用場景之一，是遞迴在搜尋問題中的應用。</li> <li>遞迴的結構體現了“子問題分解”的解題範式，常用於解決分治、回溯、動態規劃（記憶化遞迴）等問題。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"第 2 章   複雜度分析","text":"<p>Abstract</p> <p>複雜度分析猶如浩瀚的演算法宇宙中的時空嚮導。</p> <p>它帶領我們在時間與空間這兩個維度上深入探索，尋找更優雅的解決方案。</p>","path":["第 2 章 &nbsp; 複雜度分析"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"本章內容","text":"<ul> <li>2.1   演算法效率評估</li> <li>2.2   迭代與遞迴</li> <li>2.3   時間複雜度</li> <li>2.4   空間複雜度</li> <li>2.5   小結</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   迭代與遞迴","text":"<p>在演算法中，重複執行某個任務是很常見的，它與複雜度分析息息相關。因此，在介紹時間複雜度和空間複雜度之前，我們先來了解如何在程式中實現重複執行任務，即兩種基本的程式控制結構：迭代、遞迴。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   迭代","text":"<p>迭代（iteration）是一種重複執行某個任務的控制結構。在迭代中，程式會在滿足一定的條件下重複執行某段程式碼，直到這個條件不再滿足。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   for 迴圈","text":"<p><code>for</code> 迴圈是最常見的迭代形式之一，適合在預先知道迭代次數時使用。</p> <p>以下函式基於 <code>for</code> 迴圈實現了求和 \\(1 + 2 + \\dots + n\\) ，求和結果使用變數 <code>res</code> 記錄。需要注意的是，Python 中 <code>range(a, b)</code> 對應的區間是“左閉右開”的，對應的走訪範圍為 \\(a, a + 1, \\dots, b-1\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for 迴圈\"\"\"\n    res = 0\n    # 迴圈求和 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for 迴圈 */\nint ForLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for 迴圈 */\nfunc forLoop(n int) int {\n    res := 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for 迴圈 */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for 迴圈 */\nfunction forLoop(n) {\n    let res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for 迴圈 */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n  int res = 0;\n  // 迴圈求和 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for 迴圈 */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for 迴圈 */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for 迴圈 ###\ndef for_loop(n)\n  res = 0\n\n  # 迴圈求和 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-1 是該求和函式的流程框圖。</p> <p></p> <p> 圖 2-1   求和函式的流程框圖 </p> <p>此求和函式的操作數量與輸入資料大小 \\(n\\) 成正比，或者說成“線性關係”。實際上，時間複雜度描述的就是這個“線性關係”。相關內容將會在下一節中詳細介紹。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   while 迴圈","text":"<p>與 <code>for</code> 迴圈類似，<code>while</code> 迴圈也是一種實現迭代的方法。在 <code>while</code> 迴圈中，程式每輪都會先檢查條件，如果條件為真，則繼續執行，否則就結束迴圈。</p> <p>下面我們用 <code>while</code> 迴圈來實現求和 \\(1 + 2 + \\dots + n\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while 迴圈\"\"\"\n    res = 0\n    i = 1  # 初始化條件變數\n    # 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # 更新條件變數\n    return res\n</code></pre> iteration.cpp<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while 迴圈 */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while 迴圈 */\nfunc whileLoop(n int) int {\n    res := 0\n    // 初始化條件變數\n    i := 1\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // 更新條件變數\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while 迴圈 */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // 更新條件變數\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while 迴圈 */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while 迴圈 */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // 初始化條件變數\n  // 迴圈求和 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // 更新條件變數\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while 迴圈 */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 初始化條件變數\n\n    // 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // 更新條件變數\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while 迴圈 */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // 更新條件變數\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while 迴圈 ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 初始化條件變數\n\n  # 迴圈求和 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # 更新條件變數\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p><code>while</code> 迴圈比 <code>for</code> 迴圈的自由度更高。在 <code>while</code> 迴圈中，我們可以自由地設計條件變數的初始化和更新步驟。</p> <p>例如在以下程式碼中，條件變數 \\(i\\) 每輪進行兩次更新，這種情況就不太方便用 <code>for</code> 迴圈實現：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while 迴圈（兩次更新）\"\"\"\n    res = 0\n    i = 1  # 初始化條件變數\n    # 迴圈求和 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # 更新條件變數\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while 迴圈（兩次更新） */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while 迴圈（兩次更新） */\nfunc whileLoopII(n int) int {\n    res := 0\n    // 初始化條件變數\n    i := 1\n    // 迴圈求和 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // 更新條件變數\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while 迴圈（兩次更新） */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // 更新條件變數\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while 迴圈（兩次更新） */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while 迴圈（兩次更新） */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // 初始化條件變數\n  // 迴圈求和 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // 更新條件變數\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while 迴圈（兩次更新） */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 初始化條件變數\n\n    // 迴圈求和 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // 更新條件變數\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while 迴圈（兩次更新） */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // 更新條件變數\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while 迴圈（兩次更新）###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # 初始化條件變數\n\n  # 迴圈求和 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # 更新條件變數\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總的來說，<code>for</code> 迴圈的程式碼更加緊湊，<code>while</code> 迴圈更加靈活，兩者都可以實現迭代結構。選擇使用哪一個應該根據特定問題的需求來決定。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   巢狀迴圈","text":"<p>我們可以在一個迴圈結構內巢狀另一個迴圈結構，下面以 <code>for</code> 迴圈為例：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"雙層 for 迴圈\"\"\"\n    res = \"\"\n    # 迴圈 i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # 迴圈 j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* 雙層 for 迴圈 */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* 雙層 for 迴圈 */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* 雙層 for 迴圈 */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* 雙層 for 迴圈 */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // 迴圈 j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* 雙層 for 迴圈 */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* 雙層 for 迴圈 */\nfunction nestedForLoop(n) {\n    let res = '';\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* 雙層 for 迴圈 */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* 雙層 for 迴圈 */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // 迴圈 i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // 迴圈 j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* 雙層 for 迴圈 */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* 雙層 for 迴圈 */\nchar *nestedForLoop(int n) {\n    // n * n 為對應點數量，\"(i, j), \" 對應字串長最大為 6+10*2，加上最後一個空字元 \\0 的額外空間\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* 雙層 for 迴圈 */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### 雙層 for 迴圈 ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # 迴圈 i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # 迴圈 j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-2 是該巢狀迴圈的流程框圖。</p> <p></p> <p> 圖 2-2   巢狀迴圈的流程框圖 </p> <p>在這種情況下，函式的操作數量與 \\(n^2\\) 成正比，或者說演算法執行時間和輸入資料大小 \\(n\\) 成“平方關係”。</p> <p>我們可以繼續新增巢狀迴圈，每一次巢狀都是一次“升維”，將會使時間複雜度提高至“立方關係”“四次方關係”，以此類推。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   遞迴","text":"<p>遞迴（recursion）是一種演算法策略，透過函式呼叫自身來解決問題。它主要包含兩個階段。</p> <ol> <li>遞：程式不斷深入地呼叫自身，通常傳入更小或更簡化的參數，直到達到“終止條件”。</li> <li>迴：觸發“終止條件”後，程式從最深層的遞迴函式開始逐層返回，匯聚每一層的結果。</li> </ol> <p>而從實現的角度看，遞迴程式碼主要包含三個要素。</p> <ol> <li>終止條件：用於決定什麼時候由“遞”轉“迴”。</li> <li>遞迴呼叫：對應“遞”，函式呼叫自身，通常輸入更小或更簡化的參數。</li> <li>返回結果：對應“迴”，將當前遞迴層級的結果返回至上一層。</li> </ol> <p>觀察以下程式碼，我們只需呼叫函式 <code>recur(n)</code>  ，就可以完成 \\(1 + 2 + \\dots + n\\) 的計算：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"遞迴\"\"\"\n    # 終止條件\n    if n == 1:\n        return 1\n    # 遞：遞迴呼叫\n    res = recur(n - 1)\n    # 迴：返回結果\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* 遞迴 */\nint Recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = Recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* 遞迴 */\nfunc recur(n int) int {\n    // 終止條件\n    if n == 1 {\n        return 1\n    }\n    // 遞：遞迴呼叫\n    res := recur(n - 1)\n    // 迴：返回結果\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* 遞迴 */\nfunc recur(n: Int) -&gt; Int {\n    // 終止條件\n    if n == 1 {\n        return 1\n    }\n    // 遞：遞迴呼叫\n    let res = recur(n: n - 1)\n    // 迴：返回結果\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* 遞迴 */\nfunction recur(n) {\n    // 終止條件\n    if (n === 1) return 1;\n    // 遞：遞迴呼叫\n    const res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* 遞迴 */\nfunction recur(n: number): number {\n    // 終止條件\n    if (n === 1) return 1;\n    // 遞：遞迴呼叫\n    const res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* 遞迴 */\nint recur(int n) {\n  // 終止條件\n  if (n == 1) return 1;\n  // 遞：遞迴呼叫\n  int res = recur(n - 1);\n  // 迴：返回結果\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* 遞迴 */\nfn recur(n: i32) -&gt; i32 {\n    // 終止條件\n    if n == 1 {\n        return 1;\n    }\n    // 遞：遞迴呼叫\n    let res = recur(n - 1);\n    // 迴：返回結果\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* 遞迴 */\nfun recur(n: Int): Int {\n    // 終止條件\n    if (n == 1)\n        return 1\n    // 遞: 遞迴呼叫\n    val res = recur(n - 1)\n    // 迴: 返回結果\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### 遞迴 ###\ndef recur(n)\n  # 終止條件\n  return 1 if n == 1\n  # 遞：遞迴呼叫\n  res = recur(n - 1)\n  # 迴：返回結果\n  n + res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-3 展示了該函式的遞迴過程。</p> <p></p> <p> 圖 2-3   求和函式的遞迴過程 </p> <p>雖然從計算角度看，迭代與遞迴可以得到相同的結果，但它們代表了兩種完全不同的思考和解決問題的範式。</p> <ul> <li>迭代：“自下而上”地解決問題。從最基礎的步驟開始，然後不斷重複或累加這些步驟，直到任務完成。</li> <li>遞迴：“自上而下”地解決問題。將原問題分解為更小的子問題，這些子問題和原問題具有相同的形式。接下來將子問題繼續分解為更小的子問題，直到基本情況時停止（基本情況的解是已知的）。</li> </ul> <p>以上述求和函式為例，設問題 \\(f(n) = 1 + 2 + \\dots + n\\) 。</p> <ul> <li>迭代：在迴圈中模擬求和過程，從 \\(1\\) 走訪到 \\(n\\) ，每輪執行求和操作，即可求得 \\(f(n)\\) 。</li> <li>遞迴：將問題分解為子問題 \\(f(n) = n + f(n-1)\\) ，不斷（遞迴地）分解下去，直至基本情況 \\(f(1) = 1\\) 時終止。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   呼叫堆疊","text":"<p>遞迴函式每次呼叫自身時，系統都會為新開啟的函式分配記憶體，以儲存區域性變數、呼叫位址和其他資訊等。這將導致兩方面的結果。</p> <ul> <li>函式的上下文資料都儲存在稱為“堆疊幀空間”的記憶體區域中，直至函式返回後才會被釋放。因此，遞迴通常比迭代更加耗費記憶體空間。</li> <li>遞迴呼叫函式會產生額外的開銷。因此遞迴通常比迴圈的時間效率更低。</li> </ul> <p>如圖 2-4 所示，在觸發終止條件前，同時存在 \\(n\\) 個未返回的遞迴函式，遞迴深度為 \\(n\\) 。</p> <p></p> <p> 圖 2-4   遞迴呼叫深度 </p> <p>在實際中，程式語言允許的遞迴深度通常是有限的，過深的遞迴可能導致堆疊溢位錯誤。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   尾遞迴","text":"<p>有趣的是，如果函式在返回前的最後一步才進行遞迴呼叫，則該函式可以被編譯器或直譯器最佳化，使其在空間效率上與迭代相當。這種情況被稱為尾遞迴（tail recursion）。</p> <ul> <li>普通遞迴：當函式返回到上一層級的函式後，需要繼續執行程式碼，因此系統需要儲存上一層呼叫的上下文。</li> <li>尾遞迴：遞迴呼叫是函式返回前的最後一個操作，這意味著函式返回到上一層級後，無須繼續執行其他操作，因此系統無須儲存上一層函式的上下文。</li> </ul> <p>以計算 \\(1 + 2 + \\dots + n\\) 為例，我們可以將結果變數 <code>res</code> 設為函式參數，從而實現尾遞迴：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"尾遞迴\"\"\"\n    # 終止條件\n    if n == 0:\n        return res\n    # 尾遞迴呼叫\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* 尾遞迴 */\nint TailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* 尾遞迴 */\nfunc tailRecur(n int, res int) int {\n    // 終止條件\n    if n == 0 {\n        return res\n    }\n    // 尾遞迴呼叫\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* 尾遞迴 */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // 終止條件\n    if n == 0 {\n        return res\n    }\n    // 尾遞迴呼叫\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* 尾遞迴 */\nfunction tailRecur(n, res) {\n    // 終止條件\n    if (n === 0) return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* 尾遞迴 */\nfunction tailRecur(n: number, res: number): number {\n    // 終止條件\n    if (n === 0) return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n  // 終止條件\n  if (n == 0) return res;\n  // 尾遞迴呼叫\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* 尾遞迴 */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // 終止條件\n    if n == 0 {\n        return res;\n    }\n    // 尾遞迴呼叫\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* 尾遞迴 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // 新增 tailrec 關鍵詞，以開啟尾遞迴最佳化\n    // 終止條件\n    if (n == 0)\n        return res\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### 尾遞迴 ###\ndef tail_recur(n, res)\n  # 終止條件\n  return res if n == 0\n  # 尾遞迴呼叫\n  tail_recur(n - 1, res + n)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>尾遞迴的執行過程如圖 2-5 所示。對比普通遞迴和尾遞迴，兩者的求和操作的執行點是不同的。</p> <ul> <li>普通遞迴：求和操作是在“迴”的過程中執行的，每層返回後都要再執行一次求和操作。</li> <li>尾遞迴：求和操作是在“遞”的過程中執行的，“迴”的過程只需層層返回。</li> </ul> <p></p> <p> 圖 2-5   尾遞迴過程 </p> <p>Tip</p> <p>請注意，許多編譯器或直譯器並不支持尾遞迴最佳化。例如，Python 預設不支持尾遞迴最佳化，因此即使函式是尾遞迴形式，仍然可能會遇到堆疊溢位問題。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   遞迴樹","text":"<p>當處理與“分治”相關的演算法問題時，遞迴往往比迭代的思路更加直觀、程式碼更加易讀。以“費波那契數列”為例。</p> <p>Question</p> <p>給定一個費波那契數列 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) ，求該數列的第 \\(n\\) 個數字。</p> <p>設費波那契數列的第 \\(n\\) 個數字為 \\(f(n)\\) ，易得兩個結論。</p> <ul> <li>數列的前兩個數字為 \\(f(1) = 0\\) 和 \\(f(2) = 1\\) 。</li> <li>數列中的每個數字是前兩個數字的和，即 \\(f(n) = f(n - 1) + f(n - 2)\\) 。</li> </ul> <p>按照遞推關係進行遞迴呼叫，將前兩個數字作為終止條件，便可寫出遞迴程式碼。呼叫 <code>fib(n)</code> 即可得到費波那契數列的第 \\(n\\) 個數字：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"費波那契數列：遞迴\"\"\"\n    # 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # 返回結果 f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 費波那契數列：遞迴 */\nint Fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 費波那契數列：遞迴 */\nfunc fib(n int) int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 費波那契數列：遞迴 */\nfunc fib(n: Int) -&gt; Int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 費波那契數列：遞迴 */\nfunction fib(n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 費波那契數列：遞迴 */\nfunction fib(n: number): number {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n  // 終止條件 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // 返回結果 f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 費波那契數列：遞迴 */\nfn fib(n: i32) -&gt; i32 {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // 返回結果\n    res\n}\n</code></pre> recursion.c<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 費波那契數列：遞迴 */\nfun fib(n: Int): Int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 費波那契數列：遞迴 ###\ndef fib(n)\n  # 終止條件 f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # 返回結果 f(n)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，我們在函式內遞迴呼叫了兩個函式，這意味著從一個呼叫產生了兩個呼叫分支。如圖 2-6 所示，這樣不斷遞迴呼叫下去，最終將產生一棵層數為 \\(n\\) 的遞迴樹（recursion tree）。</p> <p></p> <p> 圖 2-6   費波那契數列的遞迴樹 </p> <p>從本質上看，遞迴體現了“將問題分解為更小子問題”的思維範式，這種分治策略至關重要。</p> <ul> <li>從演算法角度看，搜尋、排序、回溯、分治、動態規劃等許多重要演算法策略直接或間接地應用了這種思維方式。</li> <li>從資料結構角度看，遞迴天然適合處理鏈結串列、樹和圖的相關問題，因為它們非常適合用分治思想進行分析。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   兩者對比","text":"<p>總結以上內容，如表 2-1 所示，迭代和遞迴在實現、效能和適用性上有所不同。</p> <p> 表 2-1   迭代與遞迴特點對比 </p> 迭代 遞迴 實現方式 迴圈結構 函式呼叫自身 時間效率 效率通常較高，無函式呼叫開銷 每次函式呼叫都會產生開銷 記憶體使用 通常使用固定大小的記憶體空間 累積函式呼叫可能使用大量的堆疊幀空間 適用問題 適用於簡單迴圈任務，程式碼直觀、可讀性好 適用於子問題分解，如樹、圖、分治、回溯等，程式碼結構簡潔、清晰 <p>Tip</p> <p>如果感覺以下內容理解困難，可以在讀完“堆疊”章節後再來複習。</p> <p>那麼，迭代和遞迴具有什麼內在關聯呢？以上述遞迴函式為例，求和操作在遞迴的“迴”階段進行。這意味著最初被呼叫的函式實際上是最後完成其求和操作的，這種工作機制與堆疊的“先入後出”原則異曲同工。</p> <p>事實上，“呼叫堆疊”和“堆疊幀空間”這類遞迴術語已經暗示了遞迴與堆疊之間的密切關係。</p> <ol> <li>遞：當函式被呼叫時，系統會在“呼叫堆疊”上為該函式分配新的堆疊幀，用於儲存函式的區域性變數、參數、返回位址等資料。</li> <li>迴：當函式完成執行並返回時，對應的堆疊幀會被從“呼叫堆疊”上移除，恢復之前函式的執行環境。</li> </ol> <p>因此，我們可以使用一個顯式的堆疊來模擬呼叫堆疊的行為，從而將遞迴轉化為迭代形式：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"使用迭代模擬遞迴\"\"\"\n    # 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack = []\n    res = 0\n    # 遞：遞迴呼叫\n    for i in range(n, 0, -1):\n        # 透過“入堆疊操作”模擬“遞”\n        stack.append(i)\n    # 迴：返回結果\n    while stack:\n        # 透過“出堆疊操作”模擬“迴”\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (!stack.empty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (!stack.isEmpty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 使用迭代模擬遞迴 */\nint ForLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.Push(i);\n    }\n    // 迴：返回結果\n    while (stack.Count &gt; 0) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 使用迭代模擬遞迴 */\nfunc forLoopRecur(n int) int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack := list.New()\n    res := 0\n    // 遞：遞迴呼叫\n    for i := n; i &gt; 0; i-- {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.PushBack(i)\n    }\n    // 迴：返回結果\n    for stack.Len() != 0 {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 使用迭代模擬遞迴 */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    var stack: [Int] = []\n    var res = 0\n    // 遞：遞迴呼叫\n    for i in (1 ... n).reversed() {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.append(i)\n    }\n    // 迴：返回結果\n    while !stack.isEmpty {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 使用迭代模擬遞迴 */\nfunction forLoopRecur(n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    const stack = [];\n    let res = 0;\n    // 遞：遞迴呼叫\n    for (let i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (stack.length) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 使用迭代模擬遞迴 */\nfunction forLoopRecur(n: number): number {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊 \n    const stack: number[] = [];\n    let res: number = 0;\n    // 遞：遞迴呼叫\n    for (let i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (stack.length) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n  // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // 遞：遞迴呼叫\n  for (int i = n; i &gt; 0; i--) {\n    // 透過“入堆疊操作”模擬“遞”\n    stack.add(i);\n  }\n  // 迴：返回結果\n  while (!stack.isEmpty) {\n    // 透過“出堆疊操作”模擬“迴”\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 使用迭代模擬遞迴 */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // 遞：遞迴呼叫\n    for i in (1..=n).rev() {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while !stack.is_empty() {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    int stack[1000]; // 藉助一個大陣列來模擬堆疊\n    int top = -1;    // 堆疊頂索引\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack[1 + top++] = i;\n    }\n    // 迴：返回結果\n    while (top &gt;= 0) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 使用迭代模擬遞迴 */\nfun forLoopRecur(n: Int): Int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // 遞: 遞迴呼叫\n    for (i in n downTo 0) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i)\n    }\n    // 迴: 返回結果\n    while (stack.isNotEmpty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 使用迭代模擬遞迴 ###\ndef for_loop_recur(n)\n  # 使用一個顯式的堆疊來模擬系統呼叫堆疊\n  stack = []\n  res = 0\n\n  # 遞：遞迴呼叫\n  for i in n.downto(0)\n    # 透過“入堆疊操作”模擬“遞”\n    stack &lt;&lt; i\n  end\n  # 迴：返回結果\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，當遞迴轉化為迭代後，程式碼變得更加複雜了。儘管迭代和遞迴在很多情況下可以互相轉化，但不一定值得這樣做，有以下兩點原因。</p> <ul> <li>轉化後的程式碼可能更加難以理解，可讀性更差。</li> <li>對於某些複雜問題，模擬系統呼叫堆疊的行為可能非常困難。</li> </ul> <p>總之，選擇迭代還是遞迴取決於特定問題的性質。在程式設計實踐中，權衡兩者的優劣並根據情境選擇合適的方法至關重要。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   演算法效率評估","text":"<p>在演算法設計中，我們先後追求以下兩個層面的目標。</p> <ol> <li>找到問題解法：演算法需要在規定的輸入範圍內可靠地求得問題的正確解。</li> <li>尋求最優解法：同一個問題可能存在多種解法，我們希望找到儘可能高效的演算法。</li> </ol> <p>也就是說，在能夠解決問題的前提下，演算法效率已成為衡量演算法優劣的主要評價指標，它包括以下兩個維度。</p> <ul> <li>時間效率：演算法執行時間的長短。</li> <li>空間效率：演算法佔用記憶體空間的大小。</li> </ul> <p>簡而言之，我們的目標是設計“既快又省”的資料結構與演算法。而有效地評估演算法效率至關重要，因為只有這樣，我們才能將各種演算法進行對比，進而指導演算法設計與最佳化過程。</p> <p>效率評估方法主要分為兩種：實際測試、理論估算。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   實際測試","text":"<p>假設我們現在有演算法 <code>A</code> 和演算法 <code>B</code> ，它們都能解決同一問題，現在需要對比這兩個演算法的效率。最直接的方法是找一臺計算機，執行這兩個演算法，並監控記錄它們的執行時間和記憶體佔用情況。這種評估方式能夠反映真實情況，但也存在較大的侷限性。</p> <p>一方面，難以排除測試環境的干擾因素。硬體配置會影響演算法的效能表現。比如一個演算法的並行度較高，那麼它就更適合在多核 CPU 上執行，一個演算法的記憶體操作密集，那麼它在高效能記憶體上的表現就會更好。也就是說，演算法在不同的機器上的測試結果可能是不一致的。這意味著我們需要在各種機器上進行測試，統計平均效率，而這是不現實的。</p> <p>另一方面，展開完整測試非常耗費資源。隨著輸入資料量的變化，演算法會表現出不同的效率。例如，在輸入資料量較小時，演算法 <code>A</code> 的執行時間比演算法 <code>B</code> 短；而在輸入資料量較大時，測試結果可能恰恰相反。因此，為了得到有說服力的結論，我們需要測試各種規模的輸入資料，而這需要耗費大量的計算資源。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   理論估算","text":"<p>由於實際測試具有較大的侷限性，我們可以考慮僅透過一些計算來評估演算法的效率。這種估算方法被稱為漸近複雜度分析（asymptotic complexity analysis），簡稱複雜度分析。</p> <p>複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料規模之間的關係。它描述了隨著輸入資料規模的增加，演算法執行所需時間和空間的增長趨勢。這個定義有些拗口，我們可以將其分為三個重點來理解。</p> <ul> <li>“時間和空間資源”分別對應時間複雜度（time complexity）和空間複雜度（space complexity）。</li> <li>“隨著輸入資料規模的增加”意味著複雜度反映了演算法執行效率與輸入資料規模之間的關係。</li> <li>“時間和空間的增長趨勢”表示複雜度分析關注的不是執行時間或佔用空間的具體值，而是時間或空間增長的“快慢”。</li> </ul> <p>複雜度分析克服了實際測試方法的弊端，體現在以下幾個方面。</p> <ul> <li>它無需實際執行程式碼，更加綠色節能。</li> <li>它獨立於測試環境，分析結果適用於所有執行平臺。</li> <li>它可以體現不同資料量下的演算法效率，尤其是在大資料量下的演算法效能。</li> </ul> <p>Tip</p> <p>如果你仍對複雜度的概念感到困惑，無須擔心，我們會在後續章節中詳細介紹。</p> <p>複雜度分析為我們提供了一把評估演算法效率的“標尺”，使我們可以衡量執行某個演算法所需的時間和空間資源，對比不同演算法之間的效率。</p> <p>複雜度是個數學概念，對於初學者可能比較抽象，學習難度相對較高。從這個角度看，複雜度分析可能不太適合作為最先介紹的內容。然而，當我們討論某個資料結構或演算法的特點時，難以避免要分析其執行速度和空間使用情況。</p> <p>綜上所述，建議你在深入學習資料結構與演算法之前，先對複雜度分析建立初步的瞭解，以便能夠完成簡單演算法的複雜度分析。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   空間複雜度","text":"<p>空間複雜度（space complexity）用於衡量演算法佔用記憶體空間隨著資料量變大時的增長趨勢。這個概念與時間複雜度非常類似，只需將“執行時間”替換為“佔用記憶體空間”。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   演算法相關空間","text":"<p>演算法在執行過程中使用的記憶體空間主要包括以下幾種。</p> <ul> <li>輸入空間：用於儲存演算法的輸入資料。</li> <li>暫存空間：用於儲存演算法在執行過程中的變數、物件、函式上下文等資料。</li> <li>輸出空間：用於儲存演算法的輸出資料。</li> </ul> <p>一般情況下，空間複雜度的統計範圍是“暫存空間”加上“輸出空間”。</p> <p>暫存空間可以進一步劃分為三個部分。</p> <ul> <li>暫存資料：用於儲存演算法執行過程中的各種常數、變數、物件等。</li> <li>堆疊幀空間：用於儲存呼叫函式的上下文資料。系統在每次呼叫函式時都會在堆疊頂部建立一個堆疊幀，函式返回後，堆疊幀空間會被釋放。</li> <li>指令空間：用於儲存編譯後的程式指令，在實際統計中通常忽略不計。</li> </ul> <p>在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2-15 所示。</p> <p></p> <p> 圖 2-15   演算法使用的相關空間 </p> <p>相關程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"類別\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # 節點值\n        self.next: Node | None = None  # 指向下一節點的引用\n\ndef function() -&gt; int:\n    \"\"\"函式\"\"\"\n    # 執行某些操作...\n    return 0\n\ndef algorithm(n) -&gt; int:  # 輸入資料\n    A = 0                 # 暫存資料（常數，一般用大寫字母表示）\n    b = 0                 # 暫存資料（變數）\n    node = Node(0)        # 暫存資料（物件）\n    c = function()        # 堆疊幀空間（呼叫函式）\n    return A + b + c      # 輸出資料\n</code></pre> <pre><code>/* 結構體 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* 函式 */\nint func() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) {        // 輸入資料\n    const int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node* node = new Node(0); // 暫存資料（物件）\n    int c = func();           // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* 函式 */\nint function() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) {        // 輸入資料\n    final int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node node = new Node(0);  // 暫存資料（物件）\n    int c = function();       // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* 函式 */\nint Function() {\n    // 執行某些操作...\n    return 0;\n}\n\nint Algorithm(int n) {        // 輸入資料\n    const int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node node = new(0);       // 暫存資料（物件）\n    int c = Function();       // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 結構體 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* 建立 node 結構體  */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* 函式 */\nfunc function() int {\n    // 執行某些操作...\n    return 0\n}\n\nfunc algorithm(n int) int { // 輸入資料\n    const a = 0             // 暫存資料（常數）\n    b := 0                  // 暫存資料（變數）\n    newNode(0)              // 暫存資料（物件）\n    c := function()         // 堆疊幀空間（呼叫函式）\n    return a + b + c        // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* 函式 */\nfunc function() -&gt; Int {\n    // 執行某些操作...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // 輸入資料\n    let a = 0             // 暫存資料（常數）\n    var b = 0             // 暫存資料（變數）\n    let node = Node(x: 0) // 暫存資料（物件）\n    let c = function()    // 堆疊幀空間（呼叫函式）\n    return a + b + c      // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.next = null;                       // 指向下一節點的引用\n    }\n}\n\n/* 函式 */\nfunction constFunc() {\n    // 執行某些操作\n    return 0;\n}\n\nfunction algorithm(n) {       // 輸入資料\n    const a = 0;              // 暫存資料（常數）\n    let b = 0;                // 暫存資料（變數）\n    const node = new Node(0); // 暫存資料（物件）\n    const c = constFunc();    // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.next = null;                       // 指向下一節點的引用\n    }\n}\n\n/* 函式 */\nfunction constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n\nfunction algorithm(n: number): number { // 輸入資料\n    const a = 0;                        // 暫存資料（常數）\n    let b = 0;                          // 暫存資料（變數）\n    const node = new Node(0);           // 暫存資料（物件）\n    const c = constFunc();              // 堆疊幀空間（呼叫函式）\n    return a + b + c;                   // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* 函式 */\nint function() {\n  // 執行某些操作...\n  return 0;\n}\n\nint algorithm(int n) {  // 輸入資料\n  const int a = 0;      // 暫存資料（常數）\n  int b = 0;            // 暫存資料（變數）\n  Node node = Node(0);  // 暫存資料（物件）\n  int c = function();   // 堆疊幀空間（呼叫函式）\n  return a + b + c;     // 輸出資料\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 結構體 */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* 建立 Node 結構體 */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* 函式 */\nfn function() -&gt; i32 {      \n    // 執行某些操作...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // 輸入資料\n    const a: i32 = 0;               // 暫存資料（常數）\n    let mut b = 0;                  // 暫存資料（變數）\n    let node = Node::new(0);        // 暫存資料（物件）\n    let c = function();             // 堆疊幀空間（呼叫函式）\n    return a + b + c;               // 輸出資料\n}\n</code></pre> <pre><code>/* 函式 */\nint func() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) { // 輸入資料\n    const int a = 0;   // 暫存資料（常數）\n    int b = 0;         // 暫存資料（變數）\n    int c = func();    // 堆疊幀空間（呼叫函式）\n    return a + b + c;  // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* 函式 */\nfun function(): Int {\n    // 執行某些操作...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // 輸入資料\n    val a = 0                // 暫存資料（常數）\n    var b = 0                // 暫存資料（變數）\n    val node = Node(0)       // 暫存資料（物件）\n    val c = function()       // 堆疊幀空間（呼叫函式）\n    return a + b + c         // 輸出資料\n}\n</code></pre> <pre><code>### 類別 ###\nclass Node\n    attr_accessor :val      # 節點值\n    attr_accessor :next     # 指向下一節點的引用\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### 函式 ###\ndef function\n    # 執行某些操作...\n    0\nend\n\n### 演算法 ###\ndef algorithm(n)        # 輸入資料\n    a = 0               # 暫存資料（常數）\n    b = 0               # 暫存資料（變數）\n    node = Node.new(0)  # 暫存資料（物件）\n    c = function        # 堆疊幀空間（呼叫函式）\n    a + b + c           # 輸出資料\nend\n</code></pre>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   推算方法","text":"<p>空間複雜度的推算方法與時間複雜度大致相同，只需將統計物件從“操作數量”轉為“使用空間大小”。</p> <p>而與時間複雜度不同的是，我們通常只關注最差空間複雜度。這是因為記憶體空間是一項硬性要求，我們必須確保在所有輸入資料下都有足夠的記憶體空間預留。</p> <p>觀察以下程式碼，最差空間複雜度中的“最差”有兩層含義。</p> <ol> <li>以最差輸入資料為準：當 \\(n &lt; 10\\) 時，空間複雜度為 \\(O(1)\\) ；但當 \\(n &gt; 10\\) 時，初始化的陣列 <code>nums</code> 佔用 \\(O(n)\\) 空間，因此最差空間複雜度為 \\(O(n)\\) 。</li> <li>以演算法執行中的峰值記憶體為準：例如，程式在執行最後一行之前，佔用 \\(O(1)\\) 空間；當初始化陣列 <code>nums</code> 時，程式佔用 \\(O(n)\\) 空間，因此最差空間複雜度為 \\(O(n)\\) 。</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>在遞迴函式中，需要注意統計堆疊幀空間。觀察以下程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # 執行某些操作\n    return 0\n\ndef loop(n: int):\n    \"\"\"迴圈的空間複雜度為 O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"遞迴的空間複雜度為 O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // 執行某些操作\n    return 0\n}\n\n/* 迴圈的空間複雜度為 O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* 遞迴的空間複雜度為 O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 迴圈的空間複雜度為 O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* 遞迴的空間複雜度為 O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // 執行某些操作\n  return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // 執行某些操作\n    return 0\n}\n/* 迴圈的空間複雜度為 O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # 執行某些操作\n    0\nend\n\n### 迴圈的空間複雜度為 O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### 遞迴的空間複雜度為 O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>函式 <code>loop()</code> 和 <code>recur()</code> 的時間複雜度都為 \\(O(n)\\) ，但空間複雜度不同。</p> <ul> <li>函式 <code>loop()</code> 在迴圈中呼叫了 \\(n\\) 次 <code>function()</code> ，每輪中的 <code>function()</code> 都返回並釋放了堆疊幀空間，因此空間複雜度仍為 \\(O(1)\\) 。</li> <li>遞迴函式 <code>recur()</code> 在執行過程中會同時存在 \\(n\\) 個未返回的 <code>recur()</code> ，從而佔用 \\(O(n)\\) 的堆疊幀空間。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   常見型別","text":"<p>設輸入資料大小為 \\(n\\) ，圖 2-16 展示了常見的空間複雜度型別（從低到高排列）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{常數階} &lt; \\text{對數階} &lt; \\text{線性階} &lt; \\text{平方階} &lt; \\text{指數階} \\end{aligned} \\] <p></p> <p> 圖 2-16   常見的空間複雜度型別 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   常數階 \\(O(1)\\)","text":"<p>常數階常見於數量與輸入資料大小 \\(n\\) 無關的常數、變數、物件。</p> <p>需要注意的是，在迴圈中初始化變數或呼叫函式而佔用的記憶體，在進入下一迴圈後就會被釋放，因此不會累積佔用空間，空間複雜度仍為 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"函式\"\"\"\n    # 執行某些操作\n    return 0\n\ndef constant(n: int):\n    \"\"\"常數階\"\"\"\n    # 常數、變數、物件佔用 O(1) 空間\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # 迴圈中的變數佔用 O(1) 空間\n    for _ in range(n):\n        c = 0\n    # 迴圈中的函式佔用 O(1) 空間\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* 函式 */\nint func() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 函式 */\nint function() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 函式 */\nint Function() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid Constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 函式 */\nfunc function() int {\n    // 執行某些操作...\n    return 0\n}\n\n/* 常數階 */\nfunc spaceConstant(n int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // 迴圈中的變數佔用 O(1) 空間\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* 函式 */\n@discardableResult\nfunc function() -&gt; Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 常數階 */\nfunc constant(n: Int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // 迴圈中的變數佔用 O(1) 空間\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* 函式 */\nfunction constFunc() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nfunction constant(n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 函式 */\nfunction constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nfunction constant(n: number): void {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 函式 */\nint function() {\n  // 執行某些操作\n  return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n  // 常數、變數、物件佔用 O(1) 空間\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // 迴圈中的變數佔用 O(1) 空間\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // 迴圈中的函式佔用 O(1) 空間\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 函式 */\nfn function() -&gt; i32 {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for i in 0..n {\n        let c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 函式 */\nint func() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 函式 */\nfun function(): Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 常數階 */\nfun constant(n: Int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // 迴圈中的變數佔用 O(1) 空間\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 函式 ###\ndef function\n  # 執行某些操作\n  0\nend\n\n### 常數階 ###\ndef constant(n)\n  # 常數、變數、物件佔用 O(1) 空間\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # 迴圈中的變數佔用 O(1) 空間\n  (0...n).each { c = 0 }\n  # 迴圈中的函式佔用 O(1) 空間\n  (0...n).each { function }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   線性階 \\(O(n)\\)","text":"<p>線性階常見於元素數量與 \\(n\\) 成正比的陣列、鏈結串列、堆疊、佇列等：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"線性階\"\"\"\n    # 長度為 n 的串列佔用 O(n) 空間\n    nums = [0] * n\n    # 長度為 n 的雜湊表佔用 O(n) 空間\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    vector&lt;int&gt; nums(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int[] nums = new int[n];\n    // 長度為 n 的串列佔用 O(n) 空間\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 線性階 */\nvoid Linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int[] nums = new int[n];\n    // 長度為 n 的串列佔用 O(n) 空間\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 線性階 */\nfunc spaceLinear(n int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    _ = make([]int, n)\n    // 長度為 n 的串列佔用 O(n) 空間\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 線性階 */\nfunc linear(n: Int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    let nums = Array(repeating: 0, count: n)\n    // 長度為 n 的串列佔用 O(n) 空間\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* 線性階 */\nfunction linear(n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    const nums = new Array(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 線性階 */\nfunction linear(n: number): void {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    const nums = new Array(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 線性階 */\nvoid linear(int n) {\n  // 長度為 n 的陣列佔用 O(n) 空間\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // 長度為 n 的串列佔用 O(n) 空間\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // 長度為 n 的雜湊表佔用 O(n) 空間\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 線性階 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    let mut nums = vec![0; n as usize];\n    // 長度為 n 的串列佔用 O(n) 空間\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 雜湊表 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // 基於 uthash.h 實現\n} HashTable;\n\n/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // 長度為 n 的串列佔用 O(n) 空間\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // 記憶體釋放\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // 記憶體釋放\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 線性階 */\nfun linear(n: Int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    val nums = Array(n) { 0 }\n    // 長度為 n 的串列佔用 O(n) 空間\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 線性階 ###\ndef linear(n)\n  # 長度為 n 的串列佔用 O(n) 空間\n  nums = Array.new(n, 0)\n\n  # 長度為 n 的雜湊表佔用 O(n) 空間\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 2-17 所示，此函式的遞迴深度為 \\(n\\) ，即同時存在 \\(n\\) 個未返回的 <code>linear_recur()</code> 函式，使用 \\(O(n)\\) 大小的堆疊幀空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"線性階（遞迴實現）\"\"\"\n    print(\"遞迴 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"遞迴 n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    System.out.println(\"遞迴 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 線性階（遞迴實現） */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"遞迴 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 線性階（遞迴實現） */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"遞迴 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 線性階（遞迴實現） */\nfunc linearRecur(n: Int) {\n    print(\"遞迴 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 線性階（遞迴實現） */\nfunction linearRecur(n) {\n    console.log(`遞迴 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 線性階（遞迴實現） */\nfunction linearRecur(n: number): void {\n    console.log(`遞迴 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n  print('遞迴 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 線性階（遞迴實現） */\nfn linear_recur(n: i32) {\n    println!(\"遞迴 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    printf(\"遞迴 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* 線性階（遞迴實現） */\nfun linearRecur(n: Int) {\n    println(\"遞迴 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 線性階（遞迴實現）###\ndef linear_recur(n)\n  puts \"遞迴 n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-17   遞迴函式產生的線性階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階常見於矩陣和圖，元素數量與 \\(n\\) 成平方關係：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"平方階\"\"\"\n    # 二維串列佔用 O(n^2) 空間\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 二維串列佔用 O(n^2) 空間\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 矩陣佔用 O(n^2) 空間\n    int[][] numMatrix = new int[n][n];\n    // 二維串列佔用 O(n^2) 空間\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 平方階 */\nvoid Quadratic(int n) {\n    // 矩陣佔用 O(n^2) 空間\n    int[,] numMatrix = new int[n, n];\n    // 二維串列佔用 O(n^2) 空間\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 平方階 */\nfunc spaceQuadratic(n int) {\n    // 矩陣佔用 O(n^2) 空間\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 平方階 */\nfunc quadratic(n: Int) {\n    // 二維串列佔用 O(n^2) 空間\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* 平方階 */\nfunction quadratic(n) {\n    // 矩陣佔用 O(n^2) 空間\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二維串列佔用 O(n^2) 空間\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 平方階 */\nfunction quadratic(n: number): void {\n    // 矩陣佔用 O(n^2) 空間\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二維串列佔用 O(n^2) 空間\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n  // 矩陣佔用 O(n^2) 空間\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 二維串列佔用 O(n^2) 空間\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 平方階 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // 矩陣佔用 O(n^2) 空間\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 二維串列佔用 O(n^2) 空間\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 二維串列佔用 O(n^2) 空間\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // 記憶體釋放\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* 平方階 */\nfun quadratic(n: Int) {\n    // 矩陣佔用 O(n^2) 空間\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 二維串列佔用 O(n^2) 空間\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二維串列佔用 O(n^2) 空間\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 2-18 所示，該函式的遞迴深度為 \\(n\\) ，在每個遞迴函式中都初始化了一個陣列，長度分別為 \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，平均長度為 \\(n / 2\\) ，因此總體佔用 \\(O(n^2)\\) 空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"平方階（遞迴實現）\"\"\"\n    if n &lt;= 0:\n        return 0\n    # 陣列 nums 長度為 n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"遞迴 n = \" &lt;&lt; n &lt;&lt; \" 中的 nums 長度 = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"遞迴 n = \" + n + \" 中的 nums 長度 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 平方階（遞迴實現） */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"遞迴 n = \" + n + \" 中的 nums 長度 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 平方階（遞迴實現） */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"遞迴 n = %d 中的 nums 長度 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 平方階（遞迴實現） */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"遞迴 n = \\(n) 中的 nums 長度 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 平方階（遞迴實現） */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`遞迴 n = ${n} 中的 nums 長度 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 平方階（遞迴實現） */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`遞迴 n = ${n} 中的 nums 長度 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('遞迴 n = $n 中的 nums 長度 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 平方階（遞迴實現） */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"遞迴 n = {} 中的 nums 長度 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"遞迴 n = %d 中的 nums 長度 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* 平方階（遞迴實現） */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"遞迴 n = $n 中的 nums 長度 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階（遞迴實現）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 陣列 nums 長度為 n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-18   遞迴函式產生的平方階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   指數階 \\(O(2^n)\\)","text":"<p>指數階常見於二元樹。觀察圖 2-19 ，層數為 \\(n\\) 的“滿二元樹”的節點數量為 \\(2^n - 1\\) ，佔用 \\(O(2^n)\\) 空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"指數階（建立滿二元樹）\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* 指數階（建立滿二元樹） */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* 指數階（建立滿二元樹） */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* 指數階（建立滿二元樹） */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* 指數階（建立滿二元樹） */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* 指數階（建立滿二元樹） */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* 指數階（建立滿二元樹） */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### 指數階（建立滿二元樹）###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-19   滿二元樹產生的指數階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   對數階 \\(O(\\log n)\\)","text":"<p>對數階常見於分治演算法。例如合併排序，輸入長度為 \\(n\\) 的陣列，每輪遞迴將陣列從中點處劃分為兩半，形成高度為 \\(\\log n\\) 的遞迴樹，使用 \\(O(\\log n)\\) 堆疊幀空間。</p> <p>再例如將數字轉化為字串，輸入一個正整數 \\(n\\) ，它的位數為 \\(\\lfloor \\log_{10} n \\rfloor + 1\\) ，即對應字串長度為 \\(\\lfloor \\log_{10} n \\rfloor + 1\\) ，因此空間複雜度為 \\(O(\\log_{10} n + 1) = O(\\log n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   權衡時間與空間","text":"<p>理想情況下，我們希望演算法的時間複雜度和空間複雜度都能達到最優。然而在實際情況中，同時最佳化時間複雜度和空間複雜度通常非常困難。</p> <p>降低時間複雜度通常需要以提升空間複雜度為代價，反之亦然。我們將犧牲記憶體空間來提升演算法執行速度的思路稱為“以空間換時間”；反之，則稱為“以時間換空間”。</p> <p>選擇哪種思路取決於我們更看重哪個方面。在大多數情況下，時間比空間更寶貴，因此“以空間換時間”通常是更常用的策略。當然，在資料量很大的情況下，控制空間複雜度也非常重要。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   小結","text":"","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   重點回顧","text":"<p>演算法效率評估</p> <ul> <li>時間效率和空間效率是衡量演算法優劣的兩個主要評價指標。</li> <li>我們可以透過實際測試來評估演算法效率，但難以消除測試環境的影響，且會耗費大量計算資源。</li> <li>複雜度分析可以消除實際測試的弊端，分析結果適用於所有執行平臺，並且能夠揭示演算法在不同資料規模下的效率。</li> </ul> <p>時間複雜度</p> <ul> <li>時間複雜度用於衡量演算法執行時間隨資料量增長的趨勢，可以有效評估演算法效率，但在某些情況下可能失效，如在輸入的資料量較小或時間複雜度相同時，無法精確對比演算法效率的優劣。</li> <li>最差時間複雜度使用大 \\(O\\) 符號表示，對應函式漸近上界，反映當 \\(n\\) 趨向正無窮時，操作數量 \\(T(n)\\) 的增長級別。</li> <li>推算時間複雜度分為兩步，首先統計操作數量，然後判斷漸近上界。</li> <li>常見時間複雜度從低到高排列有 \\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n \\log n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\) 和 \\(O(n!)\\) 等。</li> <li>某些演算法的時間複雜度非固定，而是與輸入資料的分佈有關。時間複雜度分為最差、最佳、平均時間複雜度，最佳時間複雜度幾乎不用，因為輸入資料一般需要滿足嚴格條件才能達到最佳情況。</li> <li>平均時間複雜度反映演算法在隨機資料輸入下的執行效率，最接近實際應用中的演算法效能。計算平均時間複雜度需要統計輸入資料分佈以及綜合後的數學期望。</li> </ul> <p>空間複雜度</p> <ul> <li>空間複雜度的作用類似於時間複雜度，用於衡量演算法佔用記憶體空間隨資料量增長的趨勢。</li> <li>演算法執行過程中的相關記憶體空間可分為輸入空間、暫存空間、輸出空間。通常情況下，輸入空間不納入空間複雜度計算。暫存空間可分為暫存資料、堆疊幀空間和指令空間，其中堆疊幀空間通常僅在遞迴函式中影響空間複雜度。</li> <li>我們通常只關注最差空間複雜度，即統計演算法在最差輸入資料和最差執行時刻下的空間複雜度。</li> <li>常見空間複雜度從低到高排列有 \\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n^2)\\) 和 \\(O(2^n)\\) 等。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：尾遞迴的空間複雜度是 \\(O(1)\\) 嗎？</p> <p>理論上，尾遞迴函式的空間複雜度可以最佳化至 \\(O(1)\\) 。不過絕大多數程式語言（例如 Java、Python、C++、Go、C# 等）不支持自動最佳化尾遞迴，因此通常認為空間複雜度是 \\(O(n)\\) 。</p> <p>Q：函式和方法這兩個術語的區別是什麼？</p> <p>函式（function）可以被獨立執行，所有參數都以顯式傳遞。方法（method）與一個物件關聯，被隱式傳遞給呼叫它的物件，能夠對類別的例項中包含的資料進行操作。</p> <p>下面以幾種常見的程式語言為例來說明。</p> <ul> <li>C 語言是程序式程式設計語言，沒有物件導向的概念，所以只有函式。但我們可以透過建立結構體（struct）來模擬物件導向程式設計，與結構體相關聯的函式就相當於其他程式語言中的方法。</li> <li>Java 和 C# 是物件導向的程式語言，程式碼塊（方法）通常作為某個類別的一部分。靜態方法的行為類似於函式，因為它被繫結在類別上，不能訪問特定的例項變數。</li> <li>C++ 和 Python 既支持程序式程式設計（函式），也支持物件導向程式設計（方法）。</li> </ul> <p>Q：圖解“常見的空間複雜度型別”反映的是否是佔用空間的絕對大小？</p> <p>不是，該圖展示的是空間複雜度，其反映的是增長趨勢，而不是佔用空間的絕對大小。</p> <p>假設取 \\(n = 8\\) ，你可能會發現每條曲線的值與函式對應不上。這是因為每條曲線都包含一個常數項，用於將取值範圍壓縮到一個視覺舒適的範圍內。</p> <p>在實際中，因為我們通常不知道每個方法的“常數項”複雜度是多少，所以一般無法僅憑複雜度來選擇 \\(n = 8\\) 之下的最優解法。但對於 \\(n = 8^5\\) 就很好選了，這時增長趨勢已經佔主導了。</p> <p>Q 是否存在根據實際使用場景，選擇犧牲時間（或空間）來設計演算法的情況？</p> <p>在實際應用中，大部分情況會選擇犧牲空間換時間。例如資料庫索引，我們通常選擇建立 B+ 樹或雜湊索引，佔用大量記憶體空間，以換取 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 的高效查詢。</p> <p>在空間資源寶貴的場景，也會選擇犧牲時間換空間。例如在嵌入式開發中，裝置記憶體很寶貴，工程師可能會放棄使用雜湊表，選擇使用陣列順序查詢，以節省記憶體佔用，代價是查詢變慢。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   時間複雜度","text":"<p>執行時間可以直觀且準確地反映演算法的效率。如果我們想準確預估一段程式碼的執行時間，應該如何操作呢？</p> <ol> <li>確定執行平臺，包括硬體配置、程式語言、系統環境等，這些因素都會影響程式碼的執行效率。</li> <li>評估各種計算操作所需的執行時間，例如加法操作 <code>+</code> 需要 1 ns ，乘法操作 <code>*</code> 需要 10 ns ，列印操作 <code>print()</code> 需要 5 ns 等。</li> <li>統計程式碼中所有的計算操作，並將所有操作的執行時間求和，從而得到執行時間。</li> </ol> <p>例如在以下程式碼中，輸入資料大小為 \\(n\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 在某執行平臺下\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # 迴圈 n 次\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // 迴圈 n 次\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // 迴圈 n 次\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // 迴圈 n 次\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // 迴圈 n 次\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // 迴圈 n 次\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># 在某執行平臺下\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # 迴圈 n 次\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>根據以上方法，可以得到演算法的執行時間為 \\((6n + 12)\\) ns ：</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>但實際上，統計演算法的執行時間既不合理也不現實。首先，我們不希望將預估時間和執行平臺繫結，因為演算法需要在各種不同的平臺上執行。其次，我們很難獲知每種操作的執行時間，這給預估過程帶來了極大的難度。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   統計時間增長趨勢","text":"<p>時間複雜度分析統計的不是演算法執行時間，而是演算法執行時間隨著資料量變大時的增長趨勢。</p> <p>“時間增長趨勢”這個概念比較抽象，我們透過一個例子來加以理解。假設輸入資料大小為 \\(n\\) ，給定三個演算法 <code>A</code>、<code>B</code> 和 <code>C</code> ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 演算法 A 的時間複雜度：常數階\ndef algorithm_A(n: int):\n    print(0)\n# 演算法 B 的時間複雜度：線性階\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# 演算法 C 的時間複雜度：常數階\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// 演算法 B 的時間複雜度：線性階\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// 演算法 B 的時間複雜度：線性階\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// 演算法 C 的時間複雜度：常數階\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// 演算法 B 的時間複雜度：線性階\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// 演算法 B 的時間複雜度：線性階\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithmA(int n) {\n  print(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// 演算法 B 的時間複雜度：線性階\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// 演算法 B 的時間複雜度：線性階\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># 演算法 A 的時間複雜度：常數階\ndef algorithm_A(n)\n    puts 0\nend\n\n# 演算法 B 的時間複雜度：線性階\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# 演算法 C 的時間複雜度：常數階\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>圖 2-7 展示了以上三個演算法函式的時間複雜度。</p> <ul> <li>演算法 <code>A</code> 只有 \\(1\\) 個列印操作，演算法執行時間不隨著 \\(n\\) 增大而增長。我們稱此演算法的時間複雜度為“常數階”。</li> <li>演算法 <code>B</code> 中的列印操作需要迴圈 \\(n\\) 次，演算法執行時間隨著 \\(n\\) 增大呈線性增長。此演算法的時間複雜度被稱為“線性階”。</li> <li>演算法 <code>C</code> 中的列印操作需要迴圈 \\(1000000\\) 次，雖然執行時間很長，但它與輸入資料大小 \\(n\\) 無關。因此 <code>C</code> 的時間複雜度和 <code>A</code> 相同，仍為“常數階”。</li> </ul> <p></p> <p> 圖 2-7   演算法 A、B 和 C 的時間增長趨勢 </p> <p>相較於直接統計演算法的執行時間，時間複雜度分析有哪些特點呢？</p> <ul> <li>時間複雜度能夠有效評估演算法效率。例如，演算法 <code>B</code> 的執行時間呈線性增長，在 \\(n &gt; 1\\) 時比演算法 <code>A</code> 更慢，在 \\(n &gt; 1000000\\) 時比演算法 <code>C</code> 更慢。事實上，只要輸入資料大小 \\(n\\) 足夠大，複雜度為“常數階”的演算法一定優於“線性階”的演算法，這正是時間增長趨勢的含義。</li> <li>時間複雜度的推算方法更簡便。顯然，執行平臺和計算操作型別都與演算法執行時間的增長趨勢無關。因此在時間複雜度分析中，我們可以簡單地將所有計算操作的執行時間視為相同的“單位時間”，從而將“計算操作執行時間統計”簡化為“計算操作數量統計”，這樣一來估算難度就大大降低了。</li> <li>時間複雜度也存在一定的侷限性。例如，儘管演算法 <code>A</code> 和 <code>C</code> 的時間複雜度相同，但實際執行時間差別很大。同樣，儘管演算法 <code>B</code> 的時間複雜度比 <code>C</code> 高，但在輸入資料大小 \\(n\\) 較小時，演算法 <code>B</code> 明顯優於演算法 <code>C</code> 。對於此類情況，我們時常難以僅憑時間複雜度判斷演算法效率的高低。當然，儘管存在上述問題，複雜度分析仍然是評判演算法效率最有效且常用的方法。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   函式漸近上界","text":"<p>給定一個輸入大小為 \\(n\\) 的函式：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # 迴圈 n 次\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // +1（每輪都執行 i ++）\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // 迴圈 n 次\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // 迴圈 n 次\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++){ // +1（每輪都執行 i ++）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++){ // +1（每輪都執行 i ++）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // 迴圈 n 次\n  for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // 迴圈 n 次\n    for _ in 0..n { // +1（每輪都執行 i ++）\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // +1（每輪都執行 i ++）\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // 迴圈 n 次\n    for (i in 0..&lt;n) { // +1（每輪都執行 i ++）\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # 迴圈 n 次\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>設演算法的操作數量是一個關於輸入資料大小 \\(n\\) 的函式，記為 \\(T(n)\\) ，則以上函式的操作數量為：</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) 是一次函式，說明其執行時間的增長趨勢是線性的，因此它的時間複雜度是線性階。</p> <p>我們將線性階的時間複雜度記為 \\(O(n)\\) ，這個數學符號稱為大 \\(O\\) 記號（big-\\(O\\) notation），表示函式 \\(T(n)\\) 的漸近上界（asymptotic upper bound）。</p> <p>時間複雜度分析本質上是計算“操作數量 \\(T(n)\\)”的漸近上界，它具有明確的數學定義。</p> <p>函式漸近上界</p> <p>若存在正實數 \\(c\\) 和實數 \\(n_0\\) ，使得對於所有的 \\(n &gt; n_0\\) ，均有 \\(T(n) \\leq c \\cdot f(n)\\) ，則可認為 \\(f(n)\\) 給出了 \\(T(n)\\) 的一個漸近上界，記為 \\(T(n) = O(f(n))\\) 。</p> <p>如圖 2-8 所示，計算漸近上界就是尋找一個函式 \\(f(n)\\) ，使得當 \\(n\\) 趨向於無窮大時，\\(T(n)\\) 和 \\(f(n)\\) 處於相同的增長級別，僅相差一個常數係數 \\(c\\)。</p> <p></p> <p> 圖 2-8   函式的漸近上界 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   推算方法","text":"<p>漸近上界的數學味兒有點重，如果你感覺沒有完全理解，也無須擔心。我們可以先掌握推算方法，在不斷的實踐中，就可以逐漸領悟其數學意義。</p> <p>根據定義，確定 \\(f(n)\\) 之後，我們便可得到時間複雜度 \\(O(f(n))\\) 。那麼如何確定漸近上界 \\(f(n)\\) 呢？總體分為兩步：首先統計操作數量，然後判斷漸近上界。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1","level":3,"title":"1.   第一步：統計操作數量","text":"<p>針對程式碼，逐行從上到下計算即可。然而，由於上述 \\(c \\cdot f(n)\\) 中的常數係數 \\(c\\) 可以取任意大小，因此操作數量 \\(T(n)\\) 中的各種係數、常數項都可以忽略。根據此原則，可以總結出以下計數簡化技巧。</p> <ol> <li>忽略 \\(T(n)\\) 中的常數。因為它們都與 \\(n\\) 無關，所以對時間複雜度不產生影響。</li> <li>省略所有係數。例如，迴圈 \\(2n\\) 次、\\(5n + 1\\) 次等，都可以簡化記為 \\(n\\) 次，因為 \\(n\\) 前面的係數對時間複雜度沒有影響。</li> <li>迴圈巢狀時使用乘法。總操作數量等於外層迴圈和內層迴圈操作數量之積，每一層迴圈依然可以分別套用第 <code>1.</code> 點和第 <code>2.</code> 點的技巧。</li> </ol> <p>給定一個函式，我們可以用上述技巧來統計操作數量：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0（技巧 1）\n    a = a + n  # +0（技巧 1）\n    # +n（技巧 2）\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n（技巧 3）\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0（技巧 1）\n    a = a + n  // +0（技巧 1）\n    // +n（技巧 2）\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n（技巧 3）\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0（技巧 1）\n    a = a + n // +0（技巧 1）\n    // +n（技巧 2）\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n（技巧 3）\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（技巧 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（技巧 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0（技巧 1）\n  a = a + n; // +0（技巧 1）\n  // +n（技巧 2）\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n（技巧 3）\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0（技巧 1）\n    a = a + n;        // +0（技巧 1）\n\n    // +n（技巧 2）\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n（技巧 3）\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0（技巧 1）\n    a = a + n   // +0（技巧 1）\n    // +n（技巧 2）\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n（技巧 3）\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0（技巧 1）\n    a = a + n   # +0（技巧 1）\n    # +n（技巧 2）\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n（技巧 3）\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>以下公式展示了使用上述技巧前後的統計結果，兩者推算出的時間複雜度都為 \\(O(n^2)\\) 。</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{完整統計 (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{偷懶統計 (o.O)} \\end{aligned} \\]","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2","level":3,"title":"2.   第二步：判斷漸近上界","text":"<p>時間複雜度由 \\(T(n)\\) 中最高階的項來決定。這是因為在 \\(n\\) 趨於無窮大時，最高階的項將發揮主導作用，其他項的影響都可以忽略。</p> <p>表 2-2 展示了一些例子，其中一些誇張的值是為了強調“係數無法撼動階數”這一結論。當 \\(n\\) 趨於無窮大時，這些常數變得無足輕重。</p> <p> 表 2-2   不同操作數量對應的時間複雜度 </p> 操作數量 \\(T(n)\\) 時間複雜度 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   常見型別","text":"<p>設輸入資料大小為 \\(n\\) ，常見的時間複雜度型別如圖 2-9 所示（按照從低到高的順序排列）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{常數階} &lt; \\text{對數階} &lt; \\text{線性階} &lt; \\text{線性對數階} &lt; \\text{平方階} &lt; \\text{指數階} &lt; \\text{階乘階} \\end{aligned} \\] <p></p> <p> 圖 2-9   常見的時間複雜度型別 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   常數階 \\(O(1)\\)","text":"<p>常數階的操作數量與輸入資料大小 \\(n\\) 無關，即不隨著 \\(n\\) 的變化而變化。</p> <p>在以下函式中，儘管操作數量 <code>size</code> 可能很大，但由於其與輸入資料大小 \\(n\\) 無關，因此時間複雜度仍為 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"常數階\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 常數階 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 常數階 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 常數階 */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 常數階 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 常數階 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 常數階 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 常數階 */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 常數階 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 常數階 ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   線性階 \\(O(n)\\)","text":"<p>線性階的操作數量相對於輸入資料大小 \\(n\\) 以線性級別增長。線性階通常出現在單層迴圈中：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"線性階\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性階 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性階 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性階 */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性階 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性階 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性階 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性階 */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性階 */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>走訪陣列和走訪鏈結串列等操作的時間複雜度均為 \\(O(n)\\) ，其中 \\(n\\) 為陣列或鏈結串列的長度：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"線性階（走訪陣列）\"\"\"\n    count = 0\n    # 迴圈次數與陣列長度成正比\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性階（走訪陣列） */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性階（走訪陣列） */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // 迴圈次數與陣列長度成正比\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性階（走訪陣列） */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // 迴圈次數與陣列長度成正比\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性階（走訪陣列） */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性階（走訪陣列） */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // 迴圈次數與陣列長度成正比\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性階（走訪陣列） */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // 迴圈次數與陣列長度成正比\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性階（走訪陣列） */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // 迴圈次數與陣列長度成正比\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性階（走訪陣列）###\ndef array_traversal(nums)\n  count = 0\n\n  # 迴圈次數與陣列長度成正比\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得注意的是，輸入資料大小 \\(n\\) 需根據輸入資料的型別來具體確定。比如在第一個示例中，變數 \\(n\\) 為輸入資料大小；在第二個示例中，陣列長度 \\(n\\) 為資料大小。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階的操作數量相對於輸入資料大小 \\(n\\) 以平方級別增長。平方階通常出現在巢狀迴圈中，外層迴圈和內層迴圈的時間複雜度都為 \\(O(n)\\) ，因此總體的時間複雜度為 \\(O(n^2)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"平方階\"\"\"\n    count = 0\n    # 迴圈次數與資料大小 n 成平方關係\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 平方階 */\nint Quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 平方階 */\nfunc quadratic(n int) int {\n    count := 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 平方階 */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 平方階 */\nfunction quadratic(n) {\n    let count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 平方階 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 平方階 */\nint quadratic(int n) {\n  int count = 0;\n  // 迴圈次數與資料大小 n 成平方關係\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 平方階 */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 平方階 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # 迴圈次數與資料大小 n 成平方關係\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-10 對比了常數階、線性階和平方階三種時間複雜度。</p> <p></p> <p> 圖 2-10   常數階、線性階和平方階的時間複雜度 </p> <p>以泡沫排序為例，外層迴圈執行 \\(n - 1\\) 次，內層迴圈執行 \\(n-1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 次，平均為 \\(n / 2\\) 次，因此時間複雜度為 \\(O((n - 1) n / 2) = O(n^2)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"平方階（泡沫排序）\"\"\"\n    count = 0  # 計數器\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # 元素交換包含 3 個單元操作\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(int[] nums) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 平方階（泡沫排序） */\nint BubbleSort(int[] nums) {\n    int count = 0;  // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 平方階（泡沫排序） */\nfunc bubbleSort(nums []int) int {\n    count := 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 平方階（泡沫排序） */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 平方階（泡沫排序） */\nfunction bubbleSort(nums) {\n    let count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 平方階（泡沫排序） */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // 計數器\n  // 外迴圈：未排序區間為 [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // 元素交換包含 3 個單元操作\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 平方階（泡沫排序） */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // 計數器\n\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 平方階（泡沫排序） */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階（泡沫排序）###\ndef bubble_sort(nums)\n  count = 0  # 計數器\n\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 元素交換包含 3 個單元操作\n      end\n    end\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   指數階 \\(O(2^n)\\)","text":"<p>生物學的“細胞分裂”是指數階增長的典型例子：初始狀態為 \\(1\\) 個細胞，分裂一輪後變為 \\(2\\) 個，分裂兩輪後變為 \\(4\\) 個，以此類推，分裂 \\(n\\) 輪後有 \\(2^n\\) 個細胞。</p> <p>圖 2-11 和以下程式碼模擬了細胞分裂的過程，時間複雜度為 \\(O(2^n)\\) 。請注意，輸入 \\(n\\) 表示分裂輪數，返回值 <code>count</code> 表示總分裂次數。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"指數階（迴圈實現）\"\"\"\n    count = 0\n    base = 1\n    # 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指數階（迴圈實現） */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 指數階（迴圈實現）*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 指數階（迴圈實現） */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 指數階（迴圈實現） */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指數階（迴圈實現） */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指數階（迴圈實現） */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指數階（迴圈實現） */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 指數階（迴圈實現）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-11   指數階的時間複雜度 </p> <p>在實際演算法中，指數階常出現於遞迴函式中。例如在以下程式碼中，其遞迴地一分為二，經過 \\(n\\) 次分裂後停止：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"指數階（遞迴實現）\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指數階（遞迴實現） */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 指數階（遞迴實現）*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 指數階（遞迴實現） */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 指數階（遞迴實現） */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指數階（遞迴實現） */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指數階（遞迴實現） */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指數階（遞迴實現） */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 指數階（遞迴實現）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>指數階增長非常迅速，在窮舉法（暴力搜尋、回溯等）中比較常見。對於資料規模較大的問題，指數階是不可接受的，通常需要使用動態規劃或貪婪演算法等來解決。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   對數階 \\(O(\\log n)\\)","text":"<p>與指數階相反，對數階反映了“每輪縮減到一半”的情況。設輸入資料大小為 \\(n\\) ，由於每輪縮減到一半，因此迴圈次數是 \\(\\log_2 n\\) ，即 \\(2^n\\) 的反函式。</p> <p>圖 2-12 和以下程式碼模擬了“每輪縮減到一半”的過程，時間複雜度為 \\(O(\\log_2 n)\\) ，簡記為 \\(O(\\log n)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"對數階（迴圈實現）\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 對數階（迴圈實現） */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 對數階（迴圈實現）*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 對數階（迴圈實現） */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 對數階（迴圈實現） */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 對數階（迴圈實現） */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 對數階（迴圈實現） */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 對數階（迴圈實現） */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 對數階（迴圈實現）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-12   對數階的時間複雜度 </p> <p>與指數階類似，對數階也常出現於遞迴函式中。以下程式碼形成了一棵高度為 \\(\\log_2 n\\) 的遞迴樹：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"對數階（遞迴實現）\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 對數階（遞迴實現） */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 對數階（遞迴實現）*/\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 對數階（遞迴實現） */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 對數階（遞迴實現） */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 對數階（遞迴實現） */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 對數階（遞迴實現） */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 對數階（遞迴實現） */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 對數階（遞迴實現）###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>對數階常出現於基於分治策略的演算法中，體現了“一分為多”和“化繁為簡”的演算法思想。它增長緩慢，是僅次於常數階的理想的時間複雜度。</p> <p>\\(O(\\log n)\\) 的底數是多少？</p> <p>準確來說，“一分為 \\(m\\)”對應的時間複雜度是 \\(O(\\log_m n)\\) 。而透過對數換底公式，我們可以得到具有不同底數、相等的時間複雜度：</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>也就是說，底數 \\(m\\) 可以在不影響複雜度的前提下轉換。因此我們通常會省略底數 \\(m\\) ，將對數階直接記為 \\(O(\\log n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   線性對數階 \\(O(n \\log n)\\)","text":"<p>線性對數階常出現於巢狀迴圈中，兩層迴圈的時間複雜度分別為 \\(O(\\log n)\\) 和 \\(O(n)\\) 。相關程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"線性對數階\"\"\"\n    if n &lt;= 1:\n        return 1\n    # 一分為二，子問題的規模減小一半\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # 當前子問題包含 n 個操作\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性對數階 */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性對數階 */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性對數階 */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性對數階 */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性對數階 */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性對數階 */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性對數階 */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性對數階 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-13 展示了線性對數階的生成方式。二元樹的每一層的操作總數都為 \\(n\\) ，樹共有 \\(\\log_2 n + 1\\) 層，因此時間複雜度為 \\(O(n \\log n)\\) 。</p> <p></p> <p> 圖 2-13   線性對數階的時間複雜度 </p> <p>主流排序演算法的時間複雜度通常為 \\(O(n \\log n)\\) ，例如快速排序、合併排序、堆積排序等。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   階乘階 \\(O(n!)\\)","text":"<p>階乘階對應數學上的“全排列”問題。給定 \\(n\\) 個互不重複的元素，求其所有可能的排列方案，方案數量為：</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>階乘通常使用遞迴實現。如圖 2-14 和以下程式碼所示，第一層分裂出 \\(n\\) 個，第二層分裂出 \\(n - 1\\) 個，以此類推，直至第 \\(n\\) 層時停止分裂：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"階乘階（遞迴實現）\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # 從 1 個分裂出 n 個\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 階乘階（遞迴實現） */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 階乘階（遞迴實現） */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // 從 1 個分裂出 n 個\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 階乘階（遞迴實現） */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // 從 1 個分裂出 n 個\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 階乘階（遞迴實現） */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // 從 1 個分裂出 n 個\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 階乘階（遞迴實現） */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // 從 1 個分裂出 n 個\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // 從 1 個分裂出 n 個\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 階乘階（遞迴實現） */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // 從 1 個分裂出 n 個\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 階乘階（遞迴實現） */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // 從 1 個分裂出 n 個\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 階乘階（遞迴實現）###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # 從 1 個分裂出 n 個\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-14   階乘階的時間複雜度 </p> <p>請注意，因為當 \\(n \\geq 4\\) 時恆有 \\(n! &gt; 2^n\\) ，所以階乘階比指數階增長得更快，在 \\(n\\) 較大時也是不可接受的。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   最差、最佳、平均時間複雜度","text":"<p>演算法的時間效率往往不是固定的，而是與輸入資料的分佈有關。假設輸入一個長度為 \\(n\\) 的陣列 <code>nums</code> ，其中 <code>nums</code> 由從 \\(1\\) 至 \\(n\\) 的數字組成，每個數字只出現一次；但元素順序是隨機打亂的，任務目標是返回元素 \\(1\\) 的索引。我們可以得出以下結論。</p> <ul> <li>當 <code>nums = [?, ?, ..., 1]</code> ，即當末尾元素是 \\(1\\) 時，需要完整走訪陣列，達到最差時間複雜度 \\(O(n)\\) 。</li> <li>當 <code>nums = [1, ?, ?, ...]</code> ，即當首個元素為 \\(1\\) 時，無論陣列多長都不需要繼續走訪，達到最佳時間複雜度 \\(\\Omega(1)\\) 。</li> </ul> <p>“最差時間複雜度”對應函式漸近上界，使用大 \\(O\\) 記號表示。相應地，“最佳時間複雜度”對應函式漸近下界，用 \\(\\Omega\\) 記號表示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"生成一個陣列，元素為: 1, 2, ..., n ，順序被打亂\"\"\"\n    # 生成陣列 nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # 隨機打亂陣列元素\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"查詢陣列 nums 中數字 1 所在索引\"\"\"\n    for i in range(len(nums)):\n        # 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        # 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 使用系統時間生成隨機種子\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // 隨機打亂陣列元素\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // 隨機打亂陣列元素\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // 隨機打亂陣列元素\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // 隨機打亂陣列元素\n    nums.shuffle()\n    return nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // 生成陣列 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // 隨機打亂陣列元素\n  nums.shuffle();\n\n  return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n    // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // 隨機打亂陣列元素\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint *randomNumbers(int n) {\n    // 分配堆積區記憶體（建立一維可變長陣列：陣列中元素數量為 n ，元素型別為 int ）\n    int *nums = (int *)malloc(n * sizeof(int));\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // 隨機打亂陣列元素\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### 生成一個陣列，元素為: 1, 2, ..., n ，順序被打亂 ###\ndef random_numbers(n)\n  # 生成陣列 nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # 隨機打亂陣列元素\n  nums.shuffle!\nend\n\n### 查詢陣列 nums 中數字 1 所在索引 ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n    # 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得說明的是，我們在實際中很少使用最佳時間複雜度，因為通常只有在很小機率下才能達到，可能會帶來一定的誤導性。而最差時間複雜度更為實用，因為它給出了一個效率安全值，讓我們可以放心地使用演算法。</p> <p>從上述示例可以看出，最差時間複雜度和最佳時間複雜度只出現於“特殊的資料分佈”，這些情況的出現機率可能很小，並不能真實地反映演算法執行效率。相比之下，平均時間複雜度可以體現演算法在隨機輸入資料下的執行效率，用 \\(\\Theta\\) 記號來表示。</p> <p>對於部分演算法，我們可以簡單地推算出隨機資料分佈下的平均情況。比如上述示例，由於輸入陣列是被打亂的，因此元素 \\(1\\) 出現在任意索引的機率都是相等的，那麼演算法的平均迴圈次數就是陣列長度的一半 \\(n / 2\\) ，平均時間複雜度為 \\(\\Theta(n / 2) = \\Theta(n)\\) 。</p> <p>但對於較為複雜的演算法，計算平均時間複雜度往往比較困難，因為很難分析出在資料分佈下的整體數學期望。在這種情況下，我們通常使用最差時間複雜度作為演算法效率的評判標準。</p> <p>為什麼很少看到 \\(\\Theta\\) 符號？</p> <p>可能由於 \\(O\\) 符號過於朗朗上口，因此我們常常使用它來表示平均時間複雜度。但從嚴格意義上講，這種做法並不規範。在本書和其他資料中，若遇到類似“平均時間複雜度 \\(O(n)\\)”的表述，請將其直接理解為 \\(\\Theta(n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"第 3 章   資料結構","text":"<p>Abstract</p> <p>資料結構如同一副穩固而多樣的框架。</p> <p>它為資料的有序組織提供了藍圖，演算法得以在此基礎上生動起來。</p>","path":["第 3 章 &nbsp; 資料結構"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"本章內容","text":"<ul> <li>3.1   資料結構分類</li> <li>3.2   基本資料型別</li> <li>3.3   數字編碼 *</li> <li>3.4   字元編碼 *</li> <li>3.5   小結</li> </ul>","path":["第 3 章 &nbsp; 資料結構"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   基本資料型別","text":"<p>當談及計算機中的資料時，我們會想到文字、圖片、影片、語音、3D 模型等各種形式。儘管這些資料的組織形式各異，但它們都由各種基本資料型別構成。</p> <p>基本資料型別是 CPU 可以直接進行運算的型別，在演算法中直接被使用，主要包括以下幾種。</p> <ul> <li>整數型別 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> 。</li> <li>浮點數型別 <code>float</code>、<code>double</code> ，用於表示小數。</li> <li>字元型別 <code>char</code> ，用於表示各種語言的字母、標點符號甚至表情符號等。</li> <li>布林型別 <code>bool</code> ，用於表示“是”與“否”判斷。</li> </ul> <p>基本資料型別以二進位制的形式儲存在計算機中。一個二進位制位即為 \\(1\\) 位元。在絕大多數現代作業系統中，\\(1\\) 位元組（byte）由 \\(8\\) 位元（bit）組成。</p> <p>基本資料型別的取值範圍取決於其佔用的空間大小。下面以 Java 為例。</p> <ul> <li>整數型別 <code>byte</code> 佔用 \\(1\\) 位元組 = \\(8\\) 位元 ，可以表示 \\(2^{8}\\) 個數字。</li> <li>整數型別 <code>int</code> 佔用 \\(4\\) 位元組 = \\(32\\) 位元 ，可以表示 \\(2^{32}\\) 個數字。</li> </ul> <p>表 3-1 列舉了 Java 中各種基本資料型別的佔用空間、取值範圍和預設值。此表格無須死記硬背，大致理解即可，需要時可以透過查表來回憶。</p> <p> 表 3-1   基本資料型別的佔用空間和取值範圍 </p> 型別 符號 佔用空間 最小值 最大值 預設值 整數 <code>byte</code> 1 位元組 \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 位元組 \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 位元組 \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 位元組 \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) 浮點數 <code>float</code> 4 位元組 \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 位元組 \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) 字元 <code>char</code> 2 位元組 \\(0\\) \\(2^{16} - 1\\) \\(0\\) 布林 <code>bool</code> 1 位元組 \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>請注意，表 3-1 針對的是 Java 的基本資料型別的情況。每種程式語言都有各自的資料型別定義，它們的佔用空間、取值範圍和預設值可能會有所不同。</p> <ul> <li>在 Python 中，整數型別 <code>int</code> 可以是任意大小，只受限於可用記憶體；浮點數 <code>float</code> 是雙精度 64 位；沒有 <code>char</code> 型別，單個字元實際上是長度為 1 的字串 <code>str</code> 。</li> <li>C 和 C++ 未明確規定基本資料型別的大小，而因實現和平臺各異。表 3-1 遵循 LP64 資料模型，其用於包括 Linux 和 macOS 在內的 Unix 64 位作業系統。</li> <li>字元 <code>char</code> 的大小在 C 和 C++ 中為 1 位元組，在大多數程式語言中取決於特定的字元編碼方法，詳見“字元編碼”章節。</li> <li>即使表示布林量僅需 1 位（\\(0\\) 或 \\(1\\)），它在記憶體中通常也儲存為 1 位元組。這是因為現代計算機 CPU 通常將 1 位元組作為最小定址記憶體單元。</li> </ul> <p>那麼，基本資料型別與資料結構之間有什麼關聯呢？我們知道，資料結構是在計算機中組織與儲存資料的方式。這句話的主語是“結構”而非“資料”。</p> <p>如果想表示“一排數字”，我們自然會想到使用陣列。這是因為陣列的線性結構可以表示數字的相鄰關係和順序關係，但至於儲存的內容是整數 <code>int</code>、小數 <code>float</code> 還是字元 <code>char</code> ，則與“資料結構”無關。</p> <p>換句話說，基本資料型別提供了資料的“內容型別”，而資料結構提供了資料的“組織方式”。例如以下程式碼，我們用相同的資料結構（陣列）來儲存與表示不同的基本資料型別，包括 <code>int</code>、<code>float</code>、<code>char</code>、<code>bool</code> 等。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 使用多種基本資料型別來初始化陣列\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python 的字元實際上是長度為 1 的字串\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python 的串列可以自由儲存各種基本資料型別和物件引用\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript 的陣列可以自由儲存各種基本資料型別和物件\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby 的串列可以自由儲存各種基本資料型別和物件引用\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 3 章 &nbsp; 資料結構","3.2 &nbsp; 基本資料型別"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   字元編碼 *","text":"<p>在計算機中，所有資料都是以二進位制數的形式儲存的，字元 <code>char</code> 也不例外。為了表示字元，我們需要建立一套“字元集”，規定每個字元和二進位制數之間的一一對應關係。有了字元集之後，計算機就可以透過查表完成二進位制數到字元的轉換。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   ASCII 字元集","text":"<p>ASCII 碼是最早出現的字元集，其全稱為 American Standard Code for Information Interchange（美國標準資訊交換程式碼）。它使用 7 位二進位制數（一個位元組的低 7 位）表示一個字元，最多能夠表示 128 個不同的字元。如圖 3-6 所示，ASCII 碼包括英文字母的大小寫、數字 0 ~ 9、一些標點符號，以及一些控制字元（如換行符和製表符）。</p> <p></p> <p> 圖 3-6   ASCII 碼 </p> <p>然而，ASCII 碼僅能夠表示英文。隨著計算機的全球化，誕生了一種能夠表示更多語言的 EASCII 字元集。它在 ASCII 的 7 位基礎上擴展到 8 位，能夠表示 256 個不同的字元。</p> <p>在世界範圍內，陸續出現了一批適用於不同地區的 EASCII 字元集。這些字元集的前 128 個字元統一為 ASCII 碼，後 128 個字元定義不同，以適應不同語言的需求。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   GBK 字元集","text":"<p>後來人們發現，EASCII 碼仍然無法滿足許多語言的字元數量要求。比如漢字有近十萬個，光日常使用的就有幾千個。中國國家標準總局於 1980 年釋出了 GB2312 字元集，其收錄了 6763 個漢字，基本滿足了漢字的計算機處理需要。</p> <p>然而，GB2312 無法處理部分罕見字和繁體字。GBK 字元集是在 GB2312 的基礎上擴展得到的，它共收錄了 21886 個漢字。在 GBK 的編碼方案中，ASCII 字元使用一個位元組表示，漢字使用兩個位元組表示。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Unicode 字元集","text":"<p>隨著計算機技術的蓬勃發展，字元集與編碼標準百花齊放，而這帶來了許多問題。一方面，這些字元集一般只定義了特定語言的字元，無法在多語言環境下正常工作。另一方面，同一種語言存在多種字元集標準，如果兩臺計算機使用的是不同的編碼標準，則在資訊傳遞時就會出現亂碼。</p> <p>那個時代的研究人員就在想：如果推出一個足夠完整的字元集，將世界範圍內的所有語言和符號都收錄其中，不就可以解決跨語言環境和亂碼問題了嗎？在這種想法的驅動下，一個大而全的字元集 Unicode 應運而生。</p> <p>Unicode 的中文名稱為“統一碼”，理論上能容納 100 多萬個字元。它致力於將全球範圍內的字元納入統一的字元集之中，提供一種通用的字元集來處理和顯示各種語言文字，減少因為編碼標準不同而產生的亂碼問題。</p> <p>自 1991 年釋出以來，Unicode 不斷擴充新的語言與字元。截至 2022 年 9 月，Unicode 已經包含 149186 個字元，包括各種語言的字元、符號甚至表情符號等。在龐大的 Unicode 字元集中，常用的字元佔用 2 位元組，有些生僻的字元佔用 3 位元組甚至 4 位元組。</p> <p>Unicode 是一種通用字元集，本質上是給每個字元分配一個編號（稱為“碼點”），但它並沒有規定在計算機中如何儲存這些字元碼點。我們不禁會問：當多種長度的 Unicode 碼點同時出現在一個文字中時，系統如何解析字元？例如給定一個長度為 2 位元組的編碼，系統如何確認它是一個 2 位元組的字元還是兩個 1 位元組的字元？</p> <p>對於以上問題，一種直接的解決方案是將所有字元儲存為等長的編碼。如圖 3-7 所示，“Hello”中的每個字元佔用 1 位元組，“演算法”中的每個字元佔用 2 位元組。我們可以透過高位填 0 將“Hello 演算法”中的所有字元都編碼為 2 位元組長度。這樣系統就可以每隔 2 位元組解析一個字元，恢復這個短語的內容了。</p> <p></p> <p> 圖 3-7   Unicode 編碼示例 </p> <p>然而 ASCII 碼已經向我們證明，編碼英文只需 1 位元組。若採用上述方案，英文文字佔用空間的大小將會是 ASCII 編碼下的兩倍，非常浪費記憶體空間。因此，我們需要一種更加高效的 Unicode 編碼方法。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   UTF-8 編碼","text":"<p>目前，UTF-8 已成為國際上使用最廣泛的 Unicode 編碼方法。它是一種可變長度的編碼，使用 1 到 4 位元組來表示一個字元，根據字元的複雜性而變。ASCII 字元只需 1 位元組，拉丁字母和希臘字母需要 2 位元組，常用的中文字元需要 3 位元組，其他的一些生僻字元需要 4 位元組。</p> <p>UTF-8 的編碼規則並不複雜，分為以下兩種情況。</p> <ul> <li>對於長度為 1 位元組的字元，將最高位設定為 \\(0\\) ，其餘 7 位設定為 Unicode 碼點。值得注意的是，ASCII 字元在 Unicode 字元集中佔據了前 128 個碼點。也就是說，UTF-8 編碼可以向下相容 ASCII 碼。這意味著我們可以使用 UTF-8 來解析年代久遠的 ASCII 碼文字。</li> <li>對於長度為 \\(n\\) 位元組的字元（其中 \\(n &gt; 1\\)），將首個位元組的高 \\(n\\) 位都設定為 \\(1\\) ，第 \\(n + 1\\) 位設定為 \\(0\\) ；從第二個位元組開始，將每個位元組的高 2 位都設定為 \\(10\\) ；其餘所有位用於填充字元的 Unicode 碼點。</li> </ul> <p>圖 3-8 展示了“Hello演算法”對應的 UTF-8 編碼。觀察發現，由於最高 \\(n\\) 位都設定為 \\(1\\) ，因此系統可以透過讀取最高位 \\(1\\) 的個數來解析出字元的長度為 \\(n\\) 。</p> <p>但為什麼要將其餘所有位元組的高 2 位都設定為 \\(10\\) 呢？實際上，這個 \\(10\\) 能夠起到校驗符的作用。假設系統從一個錯誤的位元組開始解析文字，位元組頭部的 \\(10\\) 能夠幫助系統快速判斷出異常。</p> <p>之所以將 \\(10\\) 當作校驗符，是因為在 UTF-8 編碼規則下，不可能有字元的最高兩位是 \\(10\\) 。這個結論可以用反證法來證明：假設一個字元的最高兩位是 \\(10\\) ，說明該字元的長度為 \\(1\\) ，對應 ASCII 碼。而 ASCII 碼的最高位應該是 \\(0\\) ，與假設矛盾。</p> <p></p> <p> 圖 3-8   UTF-8 編碼示例 </p> <p>除了 UTF-8 之外，常見的編碼方式還包括以下兩種。</p> <ul> <li>UTF-16 編碼：使用 2 或 4 位元組來表示一個字元。所有的 ASCII 字元和常用的非英文字元，都用 2 位元組表示；少數字符需要用到 4 位元組表示。對於 2 位元組的字元，UTF-16 編碼與 Unicode 碼點相等。</li> <li>UTF-32 編碼：每個字元都使用 4 位元組。這意味著 UTF-32 比 UTF-8 和 UTF-16 更佔用空間，特別是對於 ASCII 字元佔比較高的文字。</li> </ul> <p>從儲存空間佔用的角度看，使用 UTF-8 表示英文字元非常高效，因為它僅需 1 位元組；使用 UTF-16 編碼某些非英文字元（例如中文）會更加高效，因為它僅需 2 位元組，而 UTF-8 可能需要 3 位元組。</p> <p>從相容性的角度看，UTF-8 的通用性最佳，許多工具和庫優先支持 UTF-8 。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   程式語言的字元編碼","text":"<p>對於以往的大多數程式語言，程式執行中的字串都採用 UTF-16 或 UTF-32 這類等長編碼。在等長編碼下，我們可以將字串看作陣列來處理，這種做法具有以下優點。</p> <ul> <li>隨機訪問：UTF-16 編碼的字串可以很容易地進行隨機訪問。UTF-8 是一種變長編碼，要想找到第 \\(i\\) 個字元，我們需要從字串的開始處走訪到第 \\(i\\) 個字元，這需要 \\(O(n)\\) 的時間。</li> <li>字元計數：與隨機訪問類似，計算 UTF-16 編碼的字串的長度也是 \\(O(1)\\) 的操作。但是，計算 UTF-8 編碼的字串的長度需要走訪整個字串。</li> <li>字串操作：在 UTF-16 編碼的字串上，很多字串操作（如分割、連線、插入、刪除等）更容易進行。在 UTF-8 編碼的字串上，進行這些操作通常需要額外的計算，以確保不會產生無效的 UTF-8 編碼。</li> </ul> <p>實際上，程式語言的字元編碼方案設計是一個很有趣的話題，涉及許多因素。</p> <ul> <li>Java 的 <code>String</code> 型別使用 UTF-16 編碼，每個字元佔用 2 位元組。這是因為 Java 語言設計之初，人們認為 16 位足以表示所有可能的字元。然而，這是一個不正確的判斷。後來 Unicode 規範擴展到了超過 16 位，所以 Java 中的字元現在可能由一對 16 位的值（稱為“代理對”）表示。</li> <li>JavaScript 和 TypeScript 的字串使用 UTF-16 編碼的原因與 Java 類似。當 1995 年 Netscape 公司首次推出 JavaScript 語言時，Unicode 還處於發展早期，那時候使用 16 位的編碼就足以表示所有的 Unicode 字元了。</li> <li>C# 使用 UTF-16 編碼，主要是因為 .NET 平臺是由 Microsoft 設計的，而 Microsoft 的很多技術（包括 Windows 作業系統）都廣泛使用 UTF-16 編碼。</li> </ul> <p>由於以上程式語言對字元數量的低估，它們不得不採取“代理對”的方式來表示超過 16 位長度的 Unicode 字元。這是一個不得已為之的無奈之舉。一方面，包含代理對的字串中，一個字元可能佔用 2 位元組或 4 位元組，從而喪失了等長編碼的優勢。另一方面，處理代理對需要額外增加程式碼，這提高了程式設計的複雜性和除錯難度。</p> <p>出於以上原因，部分程式語言提出了一些不同的編碼方案。</p> <ul> <li>Python 中的 <code>str</code> 使用 Unicode 編碼，並採用一種靈活的字串表示，儲存的字元長度取決於字串中最大的 Unicode 碼點。若字串中全部是 ASCII 字元，則每個字元佔用 1 位元組；如果有字元超出了 ASCII 範圍，但全部在基本多語言平面（BMP）內，則每個字元佔用 2 位元組；如果有超出 BMP 的字元，則每個字元佔用 4 位元組。</li> <li>Go 語言的 <code>string</code> 型別在內部使用 UTF-8 編碼。Go 語言還提供了 <code>rune</code> 型別，它用於表示單個 Unicode 碼點。</li> <li>Rust 語言的 <code>str</code> 和 <code>String</code> 型別在內部使用 UTF-8 編碼。Rust 也提供了 <code>char</code> 型別，用於表示單個 Unicode 碼點。</li> </ul> <p>需要注意的是，以上討論的都是字串在程式語言中的儲存方式，這和字串如何在檔案中儲存或在網路中傳輸是不同的問題。在檔案儲存或網路傳輸中，我們通常會將字串編碼為 UTF-8 格式，以達到最優的相容性和空間效率。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   資料結構分類","text":"<p>常見的資料結構包括陣列、鏈結串列、堆疊、佇列、雜湊表、樹、堆積、圖，它們可以從“邏輯結構”和“物理結構”兩個維度進行分類。</p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   邏輯結構：線性與非線性","text":"<p>邏輯結構揭示了資料元素之間的邏輯關係。在陣列和鏈結串列中，資料按照一定順序排列，體現了資料之間的線性關係；而在樹中，資料從頂部向下按層次排列，表現出“祖先”與“後代”之間的派生關係；圖則由節點和邊構成，反映了複雜的網路關係。</p> <p>如圖 3-1 所示，邏輯結構可分為“線性”和“非線性”兩大類。線性結構比較直觀，指資料在邏輯關係上呈線性排列；非線性結構則相反，呈非線性排列。</p> <ul> <li>線性資料結構：陣列、鏈結串列、堆疊、佇列、雜湊表，元素之間是一對一的順序關係。</li> <li>非線性資料結構：樹、堆積、圖、雜湊表。</li> </ul> <p>非線性資料結構可以進一步劃分為樹形結構和網狀結構。</p> <ul> <li>樹形結構：樹、堆積、雜湊表，元素之間是一對多的關係。</li> <li>網狀結構：圖，元素之間是多對多的關係。</li> </ul> <p></p> <p> 圖 3-1   線性資料結構與非線性資料結構 </p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   物理結構：連續與分散","text":"<p>當演算法程式執行時，正在處理的資料主要儲存在記憶體中。圖 3-2 展示了一個計算機記憶體條，其中每個黑色方塊都包含一塊記憶體空間。我們可以將記憶體想象成一個巨大的 Excel 表格，其中每個單元格都可以儲存一定大小的資料。</p> <p>系統透過記憶體位址來訪問目標位置的資料。如圖 3-2 所示，計算機根據特定規則為表格中的每個單元格分配編號，確保每個記憶體空間都有唯一的記憶體位址。有了這些位址，程式便可以訪問記憶體中的資料。</p> <p></p> <p> 圖 3-2   記憶體條、記憶體空間、記憶體位址 </p> <p>Tip</p> <p>值得說明的是，將記憶體比作 Excel 表格是一個簡化的類比，實際記憶體的工作機制比較複雜，涉及位址空間、記憶體管理、快取機制、虛擬記憶體和物理記憶體等概念。</p> <p>記憶體是所有程式的共享資源，當某塊記憶體被某個程式佔用時，則通常無法被其他程式同時使用了。因此在資料結構與演算法的設計中，記憶體資源是一個重要的考慮因素。比如，演算法所佔用的記憶體峰值不應超過系統剩餘空閒記憶體；如果缺少連續大塊的記憶體空間，那麼所選用的資料結構必須能夠儲存在分散的記憶體空間內。</p> <p>如圖 3-3 所示，物理結構反映了資料在計算機記憶體中的儲存方式，可分為連續空間儲存（陣列）和分散空間儲存（鏈結串列）。物理結構從底層決定了資料的訪問、更新、增刪等操作方法，兩種物理結構在時間效率和空間效率方面呈現出互補的特點。</p> <p></p> <p> 圖 3-3   連續空間儲存與分散空間儲存 </p> <p>值得說明的是，所有資料結構都是基於陣列、鏈結串列或二者的組合實現的。例如，堆疊和佇列既可以使用陣列實現，也可以使用鏈結串列實現；而雜湊表的實現可能同時包含陣列和鏈結串列。</p> <ul> <li>基於陣列可實現：堆疊、佇列、雜湊表、樹、堆積、圖、矩陣、張量（維度 \\(\\geq 3\\) 的陣列）等。</li> <li>基於鏈結串列可實現：堆疊、佇列、雜湊表、樹、堆積、圖等。</li> </ul> <p>鏈結串列在初始化後，仍可以在程式執行過程中對其長度進行調整，因此也稱“動態資料結構”。陣列在初始化後長度不可變，因此也稱“靜態資料結構”。值得注意的是，陣列可透過重新分配記憶體實現長度變化，從而具備一定的“動態性”。</p> <p>Tip</p> <p>如果你感覺物理結構理解起來有困難，建議先閱讀下一章，然後再回顧本節內容。</p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   數字編碼 *","text":"<p>Tip</p> <p>在本書中，標題帶有 * 符號的是選讀章節。如果你時間有限或感到理解困難，可以先跳過，等學完必讀章節後再單獨攻克。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331","level":2,"title":"3.3.1   原碼、一補數和二補數","text":"<p>在上一節的表格中我們發現，所有整數型別能夠表示的負數都比正數多一個，例如 <code>byte</code> 的取值範圍是 \\([-128, 127]\\) 。這個現象比較反直覺，它的內在原因涉及原碼、一補數、二補數的相關知識。</p> <p>首先需要指出，數字是以“二補數”的形式儲存在計算機中的。在分析這樣做的原因之前，首先給出三者的定義。</p> <ul> <li>原碼：我們將數字的二進位制表示的最高位視為符號位，其中 \\(0\\) 表示正數，\\(1\\) 表示負數，其餘位表示數字的值。</li> <li>一補數：正數的一補數與其原碼相同，負數的一補數是對其原碼除符號位外的所有位取反。</li> <li>二補數：正數的二補數與其原碼相同，負數的二補數是在其一補數的基礎上加 \\(1\\) 。</li> </ul> <p>圖 3-4 展示了原碼、一補數和二補數之間的轉換方法。</p> <p></p> <p> 圖 3-4   原碼、一補數與二補數之間的相互轉換 </p> <p>原碼（sign-magnitude）雖然最直觀，但存在一些侷限性。一方面，負數的原碼不能直接用於運算。例如在原碼下計算 \\(1 + (-2)\\) ，得到的結果是 \\(-3\\) ，這顯然是不對的。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>為了解決此問題，計算機引入了一補數（1's complement）。如果我們先將原碼轉換為一補數，並在一補數下計算 \\(1 + (-2)\\) ，最後將結果從一補數轉換回原碼，則可得到正確結果 \\(-1\\) 。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(原碼)} + 1000 \\; 0010 \\; \\text{(原碼)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(一補數)} + 1111  \\; 1101 \\; \\text{(一補數)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(一補數)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(原碼)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>另一方面，數字零的原碼有 \\(+0\\) 和 \\(-0\\) 兩種表示方式。這意味著數字零對應兩個不同的二進位制編碼，這可能會帶來歧義。比如在條件判斷中，如果沒有區分正零和負零，則可能會導致判斷結果出錯。而如果我們想處理正零和負零歧義，則需要引入額外的判斷操作，這可能會降低計算機的運算效率。</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>與原碼一樣，一補數也存在正負零歧義問題，因此計算機進一步引入了二補數（2's complement）。我們先來觀察一下負零的原碼、一補數、二補數的轉換過程：</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(原碼)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(一補數)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(二補數)} \\newline \\end{aligned} \\] <p>在負零的一補數基礎上加 \\(1\\) 會產生進位，但 <code>byte</code> 型別的長度只有 8 位，因此溢位到第 9 位的 \\(1\\) 會被捨棄。也就是說，負零的二補數為 \\(0000 \\; 0000\\) ，與正零的二補數相同。這意味著在二補數表示中只存在一個零，正負零歧義從而得到解決。</p> <p>還剩最後一個疑惑：<code>byte</code> 型別的取值範圍是 \\([-128, 127]\\) ，多出來的一個負數 \\(-128\\) 是如何得到的呢？我們注意到，區間 \\([-127, +127]\\) 內的所有整數都有對應的原碼、一補數和二補數，並且原碼和二補數之間可以互相轉換。</p> <p>然而，二補數 \\(1000 \\; 0000\\) 是一個例外，它並沒有對應的原碼。根據轉換方法，我們得到該二補數的原碼為 \\(0000 \\; 0000\\) 。這顯然是矛盾的，因為該原碼表示數字 \\(0\\) ，它的二補數應該是自身。計算機規定這個特殊的二補數 \\(1000 \\; 0000\\) 代表 \\(-128\\) 。實際上，\\((-1) + (-127)\\) 在二補數下的計算結果就是 \\(-128\\) 。</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(原碼)} + 1000 \\; 0001 \\; \\text{(原碼)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(一補數)} + 1111  \\; 1110 \\; \\text{(一補數)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(二補數)} + 1111  \\; 1111 \\; \\text{(二補數)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(二補數)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>你可能已經發現了，上述所有計算都是加法運算。這暗示著一個重要事實：計算機內部的硬體電路主要是基於加法運算設計的。這是因為加法運算相對於其他運算（比如乘法、除法和減法）來說，硬體實現起來更簡單，更容易進行並行化處理，運算速度更快。</p> <p>請注意，這並不意味著計算機只能做加法。透過將加法與一些基本邏輯運算結合，計算機能夠實現各種其他的數學運算。例如，計算減法 \\(a - b\\) 可以轉換為計算加法 \\(a + (-b)\\) ；計算乘法和除法可以轉換為計算多次加法或減法。</p> <p>現在我們可以總結出計算機使用二補數的原因：基於二補數表示，計算機可以用同樣的電路和操作來處理正數和負數的加法，不需要設計特殊的硬體電路來處理減法，並且無須特別處理正負零的歧義問題。這大大簡化了硬體設計，提高了運算效率。</p> <p>二補數的設計非常精妙，因篇幅關係我們就先介紹到這裡，建議有興趣的讀者進一步深入瞭解。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   浮點數編碼","text":"<p>細心的你可能會發現：<code>int</code> 和 <code>float</code> 長度相同，都是 4 位元組 ，但為什麼 <code>float</code> 的取值範圍遠大於 <code>int</code> ？這非常反直覺，因為按理說 <code>float</code> 需要表示小數，取值範圍應該變小才對。</p> <p>實際上，這是因為浮點數 <code>float</code> 採用了不同的表示方式。記一個 32 位元長度的二進位制數為：</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>根據 IEEE 754 標準，32-bit 長度的 <code>float</code> 由以下三個部分構成。</p> <ul> <li>符號位 \\(\\mathrm{S}\\) ：佔 1 位 ，對應 \\(b_{31}\\) 。</li> <li>指數位 \\(\\mathrm{E}\\) ：佔 8 位 ，對應 \\(b_{30} b_{29} \\ldots b_{23}\\) 。</li> <li>分數位 \\(\\mathrm{N}\\) ：佔 23 位 ，對應 \\(b_{22} b_{21} \\ldots b_0\\) 。</li> </ul> <p>二進位制數 <code>float</code> 對應值的計算方法為：</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>轉化到十進位制下的計算公式為：</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>其中各項的取值範圍為：</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> 圖 3-5   IEEE 754 標準下的 float 的計算示例 </p> <p>觀察圖 3-5 ，給定一個示例資料 \\(\\mathrm{S} = 0\\) ， \\(\\mathrm{E} = 124\\) ，\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) ，則有：</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>現在我們可以回答最初的問題：<code>float</code> 的表示方式包含指數位，導致其取值範圍遠大於 <code>int</code> 。根據以上計算，<code>float</code> 可表示的最大正數為 \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) ，切換符號位便可得到最小負數。</p> <p>儘管浮點數 <code>float</code> 擴展了取值範圍，但其副作用是犧牲了精度。整數型別 <code>int</code> 將全部 32 位元用於表示數字，數字是均勻分佈的；而由於指數位的存在，浮點數 <code>float</code> 的數值越大，相鄰兩個數字之間的差值就會趨向越大。</p> <p>如表 3-2 所示，指數位 \\(\\mathrm{E} = 0\\) 和 \\(\\mathrm{E} = 255\\) 具有特殊含義，用於表示零、無窮大、\\(\\mathrm{NaN}\\) 等。</p> <p> 表 3-2   指數位含義 </p> 指數位 E 分數位 \\(\\mathrm{N} = 0\\) 分數位 \\(\\mathrm{N} \\ne 0\\) 計算公式 \\(0\\) \\(\\pm 0\\) 次正規數 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) 正規數 正規數 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>值得說明的是，次正規數顯著提升了浮點數的精度。最小正正規數為 \\(2^{-126}\\) ，最小正次正規數為 \\(2^{-126} \\times 2^{-23}\\) 。</p> <p>雙精度 <code>double</code> 也採用類似於 <code>float</code> 的表示方法，在此不做贅述。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   小結","text":"","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>資料結構可以從邏輯結構和物理結構兩個角度進行分類。邏輯結構描述了資料元素之間的邏輯關係，而物理結構描述了資料在計算機記憶體中的儲存方式。</li> <li>常見的邏輯結構包括線性、樹狀和網狀等。通常我們根據邏輯結構將資料結構分為線性（陣列、鏈結串列、堆疊、佇列）和非線性（樹、圖、堆積）兩種。雜湊表的實現可能同時包含線性資料結構和非線性資料結構。</li> <li>當程式執行時，資料被儲存在計算機記憶體中。每個記憶體空間都擁有對應的記憶體位址，程式透過這些記憶體位址訪問資料。</li> <li>物理結構主要分為連續空間儲存（陣列）和分散空間儲存（鏈結串列）。所有資料結構都是由陣列、鏈結串列或兩者的組合實現的。</li> <li>計算機中的基本資料型別包括整數 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> ，浮點數 <code>float</code>、<code>double</code> ，字元 <code>char</code> 和布林 <code>bool</code> 。它們的取值範圍取決於佔用空間大小和表示方式。</li> <li>原碼、一補數和二補數是在計算機中編碼數字的三種方法，它們之間可以相互轉換。整數的原碼的最高位是符號位，其餘位是數字的值。</li> <li>整數在計算機中是以二補數的形式儲存的。在二補數表示下，計算機可以對正數和負數的加法一視同仁，不需要為減法操作單獨設計特殊的硬體電路，並且不存在正負零歧義的問題。</li> <li>浮點數的編碼由 1 位符號位、8 位指數位和 23 位分數位構成。由於存在指數位，因此浮點數的取值範圍遠大於整數，代價是犧牲了精度。</li> <li>ASCII 碼是最早出現的英文字元集，長度為 1 位元組，共收錄 127 個字元。GBK 字元集是常用的中文字元集，共收錄兩萬多個漢字。Unicode 致力於提供一個完整的字元集標準，收錄世界上各種語言的字元，從而解決由於字元編碼方法不一致而導致的亂碼問題。</li> <li>UTF-8 是最受歡迎的 Unicode 編碼方法，通用性非常好。它是一種變長的編碼方法，具有很好的擴展性，有效提升了儲存空間的使用效率。UTF-16 和 UTF-32 是等長的編碼方法。在編碼中文時，UTF-16 佔用的空間比 UTF-8 更小。Java 和 C# 等程式語言預設使用 UTF-16 編碼。</li> </ul>","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：為什麼雜湊表同時包含線性資料結構和非線性資料結構？</p> <p>雜湊表底層是陣列，而為了解決雜湊衝突，我們可能會使用“鏈式位址”（後續“雜湊衝突”章節會講）：陣列中每個桶指向一個鏈結串列，當鏈結串列長度超過一定閾值時，又可能被轉化為樹（通常為紅黑樹）。</p> <p>從儲存的角度來看，雜湊表的底層是陣列，其中每一個桶槽位可能包含一個值，也可能包含一個鏈結串列或一棵樹。因此，雜湊表可能同時包含線性資料結構（陣列、鏈結串列）和非線性資料結構（樹）。</p> <p>Q：<code>char</code> 型別的長度是 1 位元組嗎？</p> <p><code>char</code> 型別的長度由程式語言採用的編碼方法決定。例如，Java、JavaScript、TypeScript、C# 都採用 UTF-16 編碼（儲存 Unicode 碼點），因此 <code>char</code> 型別的長度為 2 位元組。</p> <p>Q：基於陣列實現的資料結構也稱“靜態資料結構” 是否有歧義？堆疊也可以進行出堆疊和入堆疊等操作，這些操作都是“動態”的。</p> <p>堆疊確實可以實現動態的資料操作，但資料結構仍然是“靜態”（長度不可變）的。儘管基於陣列的資料結構可以動態地新增或刪除元素，但它們的容量是固定的。如果資料量超出了預分配的大小，就需要建立一個新的更大的陣列，並將舊陣列的內容複製到新陣列中。</p> <p>Q：在構建堆疊（佇列）的時候，未指定它的大小，為什麼它們是“靜態資料結構”呢？</p> <p>在高階程式語言中，我們無須人工指定堆疊（佇列）的初始容量，這個工作由類別內部自動完成。例如，Java 的 <code>ArrayList</code> 的初始容量通常為 10。另外，擴容操作也是自動實現的。詳見後續的“串列”章節。</p> <p>Q：原碼轉二補數的方法是“先取反後加 1”，那麼二補數轉原碼應該是逆運算“先減 1 後取反”，而二補數轉原碼也一樣可以透過“先取反後加 1”得到，這是為什麼呢？</p> <p>這是因為原碼和二補數的相互轉換實際上是計算“補數”的過程。我們先給出補數的定義：假設 \\(a + b = c\\) ，那麼我們稱 \\(a\\) 是 \\(b\\) 到 \\(c\\) 的補數，反之也稱 \\(b\\) 是 \\(a\\) 到 \\(c\\) 的補數。</p> <p>給定一個 \\(n = 4\\) 位長度的二進位制數 \\(0010\\) ，如果將這個數字看作原碼（不考慮符號位），那麼它的二補數需透過“先取反後加 1”得到：</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>我們會發現，原碼和二補數的和是 \\(0010 + 1110 = 10000\\) ，也就是說，二補數 \\(1110\\) 是原碼 \\(0010\\) 到 \\(10000\\) 的“補數”。這意味著上述“先取反後加 1”實際上是計算到 \\(10000\\) 的補數的過程。</p> <p>那麼，二補數 \\(1110\\) 到 \\(10000\\) 的“補數”是多少呢？我們依然可以用“先取反後加 1”得到它：</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>換句話說，原碼和二補數互為對方到 \\(10000\\) 的“補數”，因此“原碼轉二補數”和“二補數轉原碼”可以用相同的操作（先取反後加 1 ）實現。</p> <p>當然，我們也可以用逆運算來求二補數 \\(1110\\) 的原碼，即“先減 1 後取反”：</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>總結來看，“先取反後加 1”和“先減 1 後取反”這兩種運算都是在計算到 \\(10000\\) 的補數，它們是等價的。</p> <p>本質上看，“取反”操作實際上是求到 \\(1111\\) 的補數（因為恆有 <code>原碼 + 一補數 = 1111</code>）；而在一補數基礎上再加 1 得到的二補數，就是到 \\(10000\\) 的補數。</p> <p>上述以 \\(n = 4\\) 為例，其可被推廣至任意位數的二進位制數。</p>","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"第 12 章   分治","text":"<p>Abstract</p> <p>難題被逐層拆解，每一次的拆解都使它變得更為簡單。</p> <p>分而治之揭示了一個重要的事實：從簡單做起，一切都不再複雜。</p>","path":["第 12 章 &nbsp; 分治"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"本章內容","text":"<ul> <li>12.1   分治演算法</li> <li>12.2   分治搜尋策略</li> <li>12.3   構建樹問題</li> <li>12.4   河內塔問題</li> <li>12.5   小結</li> </ul>","path":["第 12 章 &nbsp; 分治"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   分治搜尋策略","text":"<p>我們已經學過，搜尋演算法分為兩大類。</p> <ul> <li>暴力搜尋：它透過走訪資料結構實現，時間複雜度為 \\(O(n)\\) 。</li> <li>自適應搜尋：它利用特有的資料組織形式或先驗資訊，時間複雜度可達到 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 。</li> </ul> <p>實際上，時間複雜度為 \\(O(\\log n)\\) 的搜尋演算法通常是基於分治策略實現的，例如二分搜尋和樹。</p> <ul> <li>二分搜尋的每一步都將問題（在陣列中搜索目標元素）分解為一個小問題（在陣列的一半中搜索目標元素），這個過程一直持續到陣列為空或找到目標元素為止。</li> <li>樹是分治思想的代表，在二元搜尋樹、AVL 樹、堆積等資料結構中，各種操作的時間複雜度皆為 \\(O(\\log n)\\) 。</li> </ul> <p>二分搜尋的分治策略如下所示。</p> <ul> <li>問題可以分解：二分搜尋遞迴地將原問題（在陣列中進行查詢）分解為子問題（在陣列的一半中進行查詢），這是透過比較中間元素和目標元素來實現的。</li> <li>子問題是獨立的：在二分搜尋中，每輪只處理一個子問題，它不受其他子問題的影響。</li> <li>子問題的解無須合併：二分搜尋旨在查詢一個特定元素，因此不需要將子問題的解進行合併。當子問題得到解決時，原問題也會同時得到解決。</li> </ul> <p>分治能夠提升搜尋效率，本質上是因為暴力搜尋每輪只能排除一個選項，而分治搜尋每輪可以排除一半選項。</p>","path":["第 12 章 &nbsp; 分治","12.2 &nbsp; 分治搜尋策略"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   基於分治實現二分搜尋","text":"<p>在之前的章節中，二分搜尋是基於遞推（迭代）實現的。現在我們基於分治（遞迴）來實現它。</p> <p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> ，其中所有元素都是唯一的，請查詢元素 <code>target</code> 。</p> <p>從分治角度，我們將搜尋區間 \\([i, j]\\) 對應的子問題記為 \\(f(i, j)\\) 。</p> <p>以原問題 \\(f(0, n-1)\\) 為起始點，透過以下步驟進行二分搜尋。</p> <ol> <li>計算搜尋區間 \\([i, j]\\) 的中點 \\(m\\) ，根據它排除一半搜尋區間。</li> <li>遞迴求解規模減小一半的子問題，可能為 \\(f(i, m-1)\\) 或 \\(f(m+1, j)\\) 。</li> <li>迴圈第 <code>1.</code> 步和第 <code>2.</code> 步，直至找到 <code>target</code> 或區間為空時返回。</li> </ol> <p>圖 12-4 展示了在陣列中二分搜尋元素 \\(6\\) 的分治過程。</p> <p></p> <p> 圖 12-4   二分搜尋的分治過程 </p> <p>在實現程式碼中，我們宣告一個遞迴函式 <code>dfs()</code> 來求解問題 \\(f(i, j)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"二分搜尋：問題 f(i, j)\"\"\"\n    # 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j:\n        return -1\n    # 計算中點索引 m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # 找到目標元素，返回其索引\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋\"\"\"\n    n = len(nums)\n    # 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* 二分搜尋：問題 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // 求解問題 f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // 如果區間為空，代表沒有目標元素，則返回 -1\n    if i &gt; j {\n        return -1\n    }\n    //    計算索引中點\n    m := i + ((j - i) &gt;&gt; 1)\n    //判斷中點與目標元素大小\n    if nums[m] &lt; target {\n        // 小於則遞迴右半陣列\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // 大於則遞迴左半陣列\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // 找到目標元素，返回其索引\n        return m\n    }\n}\n\n/* 二分搜尋 */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j {\n        return -1\n    }\n    // 計算中點索引 m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // 找到目標元素，返回其索引\n        return m\n    }\n}\n\n/* 二分搜尋 */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 求解問題 f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // 若區間為空，代表無目標元素，則返回 -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // 計算中點索引 m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // 遞迴子問題 f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // 遞迴子問題 f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // 找到目標元素，返回其索引\n    return m;\n  }\n}\n\n/* 二分搜尋 */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // 求解問題 f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* 二分搜尋：問題 f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // 求解問題 f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* 二分搜尋：問題 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1\n    }\n    // 計算中點索引 m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // 找到目標元素，返回其索引\n        m\n    }\n}\n\n/* 二分搜尋 */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### 二分搜尋：問題 f(i, j) ###\ndef dfs(nums, target, i, j)\n  # 若區間為空，代表無目標元素，則返回 -1\n  return -1 if i &gt; j\n\n  # 計算中點索引 m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # 遞迴子問題 f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # 遞迴子問題 f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # 找到目標元素，返回其索引\n    return m\n  end\nend\n\n### 二分搜尋 ###\ndef binary_search(nums, target)\n  n = nums.length\n  # 求解問題 f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 12 章 &nbsp; 分治","12.2 &nbsp; 分治搜尋策略"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   構建二元樹問題","text":"<p>Question</p> <p>給定一棵二元樹的前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> ，請從中構建二元樹，返回二元樹的根節點。假設二元樹中沒有值重複的節點（如圖 12-5 所示）。</p> <p></p> <p> 圖 12-5   構建二元樹的示例資料 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   判斷是否為分治問題","text":"<p>原問題定義為從 <code>preorder</code> 和 <code>inorder</code> 構建二元樹，是一個典型的分治問題。</p> <ul> <li>問題可以分解：從分治的角度切入，我們可以將原問題劃分為兩個子問題：構建左子樹、構建右子樹，加上一步操作：初始化根節點。而對於每棵子樹（子問題），我們仍然可以複用以上劃分方法，將其劃分為更小的子樹（子問題），直至達到最小子問題（空子樹）時終止。</li> <li>子問題是獨立的：左子樹和右子樹是相互獨立的，它們之間沒有交集。在構建左子樹時，我們只需關注中序走訪和前序走訪中與左子樹對應的部分。右子樹同理。</li> <li>子問題的解可以合併：一旦得到了左子樹和右子樹（子問題的解），我們就可以將它們連結到根節點上，得到原問題的解。</li> </ul>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   如何劃分子樹","text":"<p>根據以上分析，這道題可以使用分治來求解，但如何透過前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> 來劃分左子樹和右子樹呢？</p> <p>根據定義，<code>preorder</code> 和 <code>inorder</code> 都可以劃分為三個部分。</p> <ul> <li>前序走訪：<code>[ 根節點 | 左子樹 | 右子樹 ]</code> ，例如圖 12-5 的樹對應 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li> <li>中序走訪：<code>[ 左子樹 | 根節點 ｜ 右子樹 ]</code> ，例如圖 12-5 的樹對應 <code>[ 9 | 3 | 1 2 7 ]</code> 。</li> </ul> <p>以上圖資料為例，我們可以透過圖 12-6 所示的步驟得到劃分結果。</p> <ol> <li>前序走訪的首元素 3 是根節點的值。</li> <li>查詢根節點 3 在 <code>inorder</code> 中的索引，利用該索引可將 <code>inorder</code> 劃分為 <code>[ 9 | 3 ｜ 1 2 7 ]</code> 。</li> <li>根據 <code>inorder</code> 的劃分結果，易得左子樹和右子樹的節點數量分別為 1 和 3 ，從而可將 <code>preorder</code> 劃分為 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li> </ol> <p></p> <p> 圖 12-6   在前序走訪和中序走訪中劃分子樹 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   基於變數描述子樹區間","text":"<p>根據以上劃分方法，我們已經得到根節點、左子樹、右子樹在 <code>preorder</code> 和 <code>inorder</code> 中的索引區間。而為了描述這些索引區間，我們需要藉助幾個指標變數。</p> <ul> <li>將當前樹的根節點在 <code>preorder</code> 中的索引記為 \\(i\\) 。</li> <li>將當前樹的根節點在 <code>inorder</code> 中的索引記為 \\(m\\) 。</li> <li>將當前樹在 <code>inorder</code> 中的索引區間記為 \\([l, r]\\) 。</li> </ul> <p>如表 12-1 所示，透過以上變數即可表示根節點在 <code>preorder</code> 中的索引，以及子樹在 <code>inorder</code> 中的索引區間。</p> <p> 表 12-1   根節點和子樹在前序走訪和中序走訪中的索引 </p> 根節點在 <code>preorder</code> 中的索引 子樹在 <code>inorder</code> 中的索引區間 當前樹 \\(i\\) \\([l, r]\\) 左子樹 \\(i + 1\\) \\([l, m-1]\\) 右子樹 \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>請注意，右子樹根節點索引中的 \\((m-l)\\) 的含義是“左子樹的節點數量”，建議結合圖 12-7 理解。</p> <p></p> <p> 圖 12-7   根節點和左右子樹的索引區間表示 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   程式碼實現","text":"<p>為了提升查詢 \\(m\\) 的效率，我們藉助一個雜湊表 <code>hmap</code> 來儲存陣列 <code>inorder</code> 中元素到索引的對映：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"構建二元樹：分治\"\"\"\n    # 子樹區間為空時終止\n    if r - l &lt; 0:\n        return None\n    # 初始化根節點\n    root = TreeNode(preorder[i])\n    # 查詢 m ，從而劃分左右子樹\n    m = inorder_map[preorder[i]]\n    # 子問題：構建左子樹\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # 子問題：構建右子樹\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # 返回根節點\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"構建二元樹\"\"\"\n    # 初始化雜湊表，儲存 inorder 元素到索引的對映\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* 構建二元樹：分治 */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return NULL;\n    // 初始化根節點\n    TreeNode *root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* 構建二元樹：分治 */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return null;\n    // 初始化根節點\n    TreeNode root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* 構建二元樹：分治 */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return null;\n    // 初始化根節點\n    TreeNode root = new(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* 構建二元樹：分治 */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // 子樹區間為空時終止\n    if r-l &lt; 0 {\n        return nil\n    }\n    // 初始化根節點\n    root := NewTreeNode(preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    m := inorderMap[preorder[i]]\n    // 子問題：構建左子樹\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // 子問題：構建右子樹\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* 構建二元樹：分治 */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // 子樹區間為空時終止\n    if r - l &lt; 0 {\n        return nil\n    }\n    // 初始化根節點\n    let root = TreeNode(x: preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    let m = inorderMap[preorder[i]]!\n    // 子問題：構建左子樹\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // 子問題：構建右子樹\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* 構建二元樹：分治 */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null;\n    // 初始化根節點\n    const root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    const m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nfunction buildTree(preorder, inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* 構建二元樹：分治 */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null;\n    // 初始化根節點\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    const m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* 構建二元樹：分治 */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // 子樹區間為空時終止\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // 初始化根節點\n  TreeNode? root = TreeNode(preorder[i]);\n  // 查詢 m ，從而劃分左右子樹\n  int m = inorderMap[preorder[i]]!;\n  // 子問題：構建左子樹\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // 子問題：構建右子樹\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // 返回根節點\n  return root;\n}\n\n/* 構建二元樹 */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // 初始化雜湊表，儲存 inorder 元素到索引的對映\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* 構建二元樹：分治 */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 子樹區間為空時終止\n    if r - l &lt; 0 {\n        return None;\n    }\n    // 初始化根節點\n    let root = TreeNode::new(preorder[i as usize]);\n    // 查詢 m ，從而劃分左右子樹\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // 子問題：構建左子樹\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    Some(root)\n}\n\n/* 構建二元樹 */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* 構建二元樹：分治 */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return NULL;\n    // 初始化根節點\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // 子問題：構建右子樹\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* 構建二元樹：分治 */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null\n    // 初始化根節點\n    val root = TreeNode(preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    val m = inorderMap[preorder[i]]!!\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### 構建二元樹：分治 ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # 子樹區間為空時終止\n  return if r - l &lt; 0\n\n  # 初始化根節點\n  root = TreeNode.new(preorder[i])\n  # 查詢 m ，從而劃分左右子樹\n  m = inorder_map[preorder[i]]\n  # 子問題：構建左子樹\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # 子問題：構建右子樹\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # 返回根節點\n  root\nend\n\n### 構建二元樹 ###\ndef build_tree(preorder, inorder)\n  # 初始化雜湊表，儲存 inorder 元素到索引的對映\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 12-8 展示了構建二元樹的遞迴過程，各個節點是在向下“遞”的過程中建立的，而各條邊（引用）是在向上“迴”的過程中建立的。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 12-8   構建二元樹的遞迴過程 </p> <p>每個遞迴函式內的前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> 的劃分結果如圖 12-9 所示。</p> <p></p> <p> 圖 12-9   每個遞迴函式中的劃分結果 </p> <p>設樹的節點數量為 \\(n\\) ，初始化每一個節點（執行一個遞迴函式 <code>dfs()</code> ）使用 \\(O(1)\\) 時間。因此總體時間複雜度為 \\(O(n)\\) 。</p> <p>雜湊表儲存 <code>inorder</code> 元素到索引的對映，空間複雜度為 \\(O(n)\\) 。在最差情況下，即二元樹退化為鏈結串列時，遞迴深度達到 \\(n\\) ，使用 \\(O(n)\\) 的堆疊幀空間。因此總體空間複雜度為 \\(O(n)\\) 。</p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   分治演算法","text":"<p>分治（divide and conquer），全稱分而治之，是一種非常重要且常見的演算法策略。分治通常基於遞迴實現，包括“分”和“治”兩個步驟。</p> <ol> <li>分（劃分階段）：遞迴地將原問題分解為兩個或多個子問題，直至到達最小子問題時終止。</li> <li>治（合併階段）：從已知解的最小子問題開始，從底至頂地將子問題的解進行合併，從而構建出原問題的解。</li> </ol> <p>如圖 12-1 所示，“合併排序”是分治策略的典型應用之一。</p> <ol> <li>分：遞迴地將原陣列（原問題）劃分為兩個子陣列（子問題），直到子陣列只剩一個元素（最小子問題）。</li> <li>治：從底至頂地將有序的子陣列（子問題的解）進行合併，從而得到有序的原陣列（原問題的解）。</li> </ol> <p></p> <p> 圖 12-1   合併排序的分治策略 </p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   如何判斷分治問題","text":"<p>一個問題是否適合使用分治解決，通常可以參考以下幾個判斷依據。</p> <ol> <li>問題可以分解：原問題可以分解成規模更小、類似的子問題，以及能夠以相同方式遞迴地進行劃分。</li> <li>子問題是獨立的：子問題之間沒有重疊，互不依賴，可以獨立解決。</li> <li>子問題的解可以合併：原問題的解透過合併子問題的解得來。</li> </ol> <p>顯然，合併排序滿足以上三個判斷依據。</p> <ol> <li>問題可以分解：遞迴地將陣列（原問題）劃分為兩個子陣列（子問題）。</li> <li>子問題是獨立的：每個子陣列都可以獨立地進行排序（子問題可以獨立進行求解）。</li> <li>子問題的解可以合併：兩個有序子陣列（子問題的解）可以合併為一個有序陣列（原問題的解）。</li> </ol>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   透過分治提升效率","text":"<p>分治不僅可以有效地解決演算法問題，往往還可以提升演算法效率。在排序演算法中，快速排序、合併排序、堆積排序相較於選擇、冒泡、插入排序更快，就是因為它們應用了分治策略。</p> <p>那麼，我們不禁發問：為什麼分治可以提升演算法效率，其底層邏輯是什麼？換句話說，將大問題分解為多個子問題、解決子問題、將子問題的解合併為原問題的解，這幾步的效率為什麼比直接解決原問題的效率更高？這個問題可以從操作數量和平行計算兩方面來討論。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   操作數量最佳化","text":"<p>以“泡沫排序”為例，其處理一個長度為 \\(n\\) 的陣列需要 \\(O(n^2)\\) 時間。假設我們按照圖 12-2 所示的方式，將陣列從中點處分為兩個子陣列，則劃分需要 \\(O(n)\\) 時間，排序每個子陣列需要 \\(O((n / 2)^2)\\) 時間，合併兩個子陣列需要 \\(O(n)\\) 時間，總體時間複雜度為：</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> 圖 12-2   劃分陣列前後的泡沫排序 </p> <p>接下來，我們計算以下不等式，其左邊和右邊分別為劃分前和劃分後的操作總數：</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>這意味著當 \\(n &gt; 4\\) 時，劃分後的操作數量更少，排序效率應該更高。請注意，劃分後的時間複雜度仍然是平方階 \\(O(n^2)\\) ，只是複雜度中的常數項變小了。</p> <p>進一步想，如果我們把子陣列不斷地再從中點處劃分為兩個子陣列，直至子陣列只剩一個元素時停止劃分呢？這種思路實際上就是“合併排序”，時間複雜度為 \\(O(n \\log n)\\) 。</p> <p>再思考，如果我們多設定幾個劃分點，將原陣列平均劃分為 \\(k\\) 個子陣列呢？這種情況與“桶排序”非常類似，它非常適合排序海量資料，理論上時間複雜度可以達到 \\(O(n + k)\\) 。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   平行計算最佳化","text":"<p>我們知道，分治生成的子問題是相互獨立的，因此通常可以並行解決。也就是說，分治不僅可以降低演算法的時間複雜度，還有利於作業系統的並行最佳化。</p> <p>並行最佳化在多核或多處理器的環境中尤其有效，因為系統可以同時處理多個子問題，更加充分地利用計算資源，從而顯著減少總體的執行時間。</p> <p>比如在圖 12-3 所示的“桶排序”中，我們將海量的資料平均分配到各個桶中，則可將所有桶的排序任務分散到各個計算單元，完成後再合併結果。</p> <p></p> <p> 圖 12-3   桶排序的平行計算 </p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   分治常見應用","text":"<p>一方面，分治可以用來解決許多經典演算法問題。</p> <ul> <li>尋找最近點對：該演算法首先將點集分成兩部分，然後分別找出兩部分中的最近點對，最後找出跨越兩部分的最近點對。</li> <li>大整數乘法：例如 Karatsuba 演算法，它將大整數乘法分解為幾個較小的整數的乘法和加法。</li> <li>矩陣乘法：例如 Strassen 演算法，它將大矩陣乘法分解為多個小矩陣的乘法和加法。</li> <li>河內塔問題：河內塔問題可以透過遞迴解決，這是典型的分治策略應用。</li> <li>求解逆序對：在一個序列中，如果前面的數字大於後面的數字，那麼這兩個數字構成一個逆序對。求解逆序對問題可以利用分治的思想，藉助合併排序進行求解。</li> </ul> <p>另一方面，分治在演算法和資料結構的設計中應用得非常廣泛。</p> <ul> <li>二分搜尋：二分搜尋是將有序陣列從中點索引處分為兩部分，然後根據目標值與中間元素值比較結果，決定排除哪一半區間，並在剩餘區間執行相同的二分操作。</li> <li>合併排序：本節開頭已介紹，不再贅述。</li> <li>快速排序：快速排序是選取一個基準值，然後把陣列分為兩個子陣列，一個子陣列的元素比基準值小，另一子陣列的元素比基準值大，再對這兩部分進行相同的劃分操作，直至子陣列只剩下一個元素。</li> <li>桶排序：桶排序的基本思想是將資料分散到多個桶，然後對每個桶內的元素進行排序，最後將各個桶的元素依次取出，從而得到一個有序陣列。</li> <li>樹：例如二元搜尋樹、AVL 樹、紅黑樹、B 樹、B+ 樹等，它們的查詢、插入和刪除等操作都可以視為分治策略的應用。</li> <li>堆積：堆積是一種特殊的完全二元樹，其各種操作，如插入、刪除和堆積化，實際上都隱含了分治的思想。</li> <li>雜湊表：雖然雜湊表並不直接應用分治，但某些雜湊衝突解決方案間接應用了分治策略，例如，鏈式位址中的長鏈結串列會被轉化為紅黑樹，以提升查詢效率。</li> </ul> <p>可以看出，分治是一種“潤物細無聲”的演算法思想，隱含在各種演算法與資料結構之中。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   河內塔問題","text":"<p>在合併排序和構建二元樹中，我們都是將原問題分解為兩個規模為原問題一半的子問題。然而對於河內塔問題，我們採用不同的分解策略。</p> <p>Question</p> <p>給定三根柱子，記為 <code>A</code>、<code>B</code> 和 <code>C</code> 。起始狀態下，柱子 <code>A</code> 上套著 \\(n\\) 個圓盤，它們從上到下按照從小到大的順序排列。我們的任務是要把這 \\(n\\) 個圓盤移到柱子 <code>C</code> 上，並保持它們的原有順序不變（如圖 12-10 所示）。在移動圓盤的過程中，需要遵守以下規則。</p> <ol> <li>圓盤只能從一根柱子頂部拿出，從另一根柱子頂部放入。</li> <li>每次只能移動一個圓盤。</li> <li>小圓盤必須時刻位於大圓盤之上。</li> </ol> <p></p> <p> 圖 12-10   河內塔問題示例 </p> <p>我們將規模為 \\(i\\) 的河內塔問題記作 \\(f(i)\\) 。例如 \\(f(3)\\) 代表將 \\(3\\) 個圓盤從 <code>A</code> 移動至 <code>C</code> 的河內塔問題。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   考慮基本情況","text":"<p>如圖 12-11 所示，對於問題 \\(f(1)\\) ，即當只有一個圓盤時，我們將它直接從 <code>A</code> 移動至 <code>C</code> 即可。</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> 圖 12-11   規模為 1 的問題的解 </p> <p>如圖 12-12 所示，對於問題 \\(f(2)\\) ，即當有兩個圓盤時，由於要時刻滿足小圓盤在大圓盤之上，因此需要藉助 <code>B</code> 來完成移動。</p> <ol> <li>先將上面的小圓盤從 <code>A</code> 移至 <code>B</code> 。</li> <li>再將大圓盤從 <code>A</code> 移至 <code>C</code> 。</li> <li>最後將小圓盤從 <code>B</code> 移至 <code>C</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 12-12   規模為 2 的問題的解 </p> <p>解決問題 \\(f(2)\\) 的過程可總結為：將兩個圓盤藉助 <code>B</code> 從 <code>A</code> 移至 <code>C</code> 。其中，<code>C</code> 稱為目標柱、<code>B</code> 稱為緩衝柱。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   子問題分解","text":"<p>對於問題 \\(f(3)\\) ，即當有三個圓盤時，情況變得稍微複雜了一些。</p> <p>因為已知 \\(f(1)\\) 和 \\(f(2)\\) 的解，所以我們可從分治角度思考，將 <code>A</code> 頂部的兩個圓盤看作一個整體，執行圖 12-13 所示的步驟。這樣三個圓盤就被順利地從 <code>A</code> 移至 <code>C</code> 了。</p> <ol> <li>令 <code>B</code> 為目標柱、<code>C</code> 為緩衝柱，將兩個圓盤從 <code>A</code> 移至 <code>B</code> 。</li> <li>將 <code>A</code> 中剩餘的一個圓盤從 <code>A</code> 直接移動至 <code>C</code> 。</li> <li>令 <code>C</code> 為目標柱、<code>A</code> 為緩衝柱，將兩個圓盤從 <code>B</code> 移至 <code>C</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 12-13   規模為 3 的問題的解 </p> <p>從本質上看，我們將問題 \\(f(3)\\) 劃分為兩個子問題 \\(f(2)\\) 和一個子問題 \\(f(1)\\) 。按順序解決這三個子問題之後，原問題隨之得到解決。這說明子問題是獨立的，而且解可以合併。</p> <p>至此，我們可總結出圖 12-14 所示的解決河內塔問題的分治策略：將原問題 \\(f(n)\\) 劃分為兩個子問題 \\(f(n-1)\\) 和一個子問題 \\(f(1)\\) ，並按照以下順序解決這三個子問題。</p> <ol> <li>將 \\(n-1\\) 個圓盤藉助 <code>C</code> 從 <code>A</code> 移至 <code>B</code> 。</li> <li>將剩餘 \\(1\\) 個圓盤從 <code>A</code> 直接移至 <code>C</code> 。</li> <li>將 \\(n-1\\) 個圓盤藉助 <code>A</code> 從 <code>B</code> 移至 <code>C</code> 。</li> </ol> <p>對於這兩個子問題 \\(f(n-1)\\) ，可以透過相同的方式進行遞迴劃分，直至達到最小子問題 \\(f(1)\\) 。而 \\(f(1)\\) 的解是已知的，只需一次移動操作即可。</p> <p></p> <p> 圖 12-14   解決河內塔問題的分治策略 </p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>在程式碼中，我們宣告一個遞迴函式 <code>dfs(i, src, buf, tar)</code> ，它的作用是將柱 <code>src</code> 頂部的 \\(i\\) 個圓盤藉助緩衝柱 <code>buf</code> 移動至目標柱 <code>tar</code> ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"移動一個圓盤\"\"\"\n    # 從 src 頂部拿出一個圓盤\n    pan = src.pop()\n    # 將圓盤放入 tar 頂部\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"求解河內塔問題 f(i)\"\"\"\n    # 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1:\n        move(src, tar)\n        return\n    # 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf)\n    # 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    # 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"求解河內塔問題\"\"\"\n    n = len(A)\n    # 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* 移動一個圓盤 */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src.back();\n    src.pop_back();\n    // 將圓盤放入 tar 頂部\n    tar.push_back(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* 移動一個圓盤 */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // 從 src 頂部拿出一個圓盤\n    Integer pan = src.remove(src.size() - 1);\n    // 將圓盤放入 tar 頂部\n    tar.add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* 移動一個圓盤 */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // 將圓盤放入 tar 頂部\n    tar.Add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    DFS(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    Move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    DFS(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* 移動一個圓盤 */\nfunc move(src, tar *list.List) {\n    // 從 src 頂部拿出一個圓盤\n    pan := src.Back()\n    // 將圓盤放入 tar 頂部\n    tar.PushBack(pan.Value)\n    // 移除 src 頂部圓盤\n    src.Remove(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfsHanota(i-1, src, tar, buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* 求解河內塔問題 */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* 移動一個圓盤 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // 從 src 頂部拿出一個圓盤\n    let pan = src.popLast()!\n    // 將圓盤放入 tar 頂部\n    tar.append(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src: &amp;src, tar: &amp;tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* 求解河內塔問題 */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // 串列尾部是柱子頂部\n    // 將 src 頂部 n 個圓盤藉助 B 移到 C\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* 移動一個圓盤 */\nfunction move(src, tar) {\n    // 從 src 頂部拿出一個圓盤\n    const pan = src.pop();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfunction dfs(i, src, buf, tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* 移動一個圓盤 */\nfunction move(src: number[], tar: number[]): void {\n    // 從 src 頂部拿出一個圓盤\n    const pan = src.pop();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* 移動一個圓盤 */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // 從 src 頂部拿出一個圓盤\n  int pan = src.removeLast();\n  // 將圓盤放入 tar 頂部\n  tar.add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // 若 src 只剩下一個圓盤，則直接將其移到 tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n  dfs(i - 1, src, tar, buf);\n  // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n  move(src, tar);\n  // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n  dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // 將 A 頂部 n 個圓盤藉助 B 移到 C\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* 移動一個圓盤 */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // 從 src 頂部拿出一個圓盤\n    let pan = src.pop().unwrap();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move_pan(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* 移動一個圓盤 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // 將圓盤放入 tar 頂部\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, srcSize, tar, tarSize);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* 移動一個圓盤 */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // 從 src 頂部拿出一個圓盤\n    val pan = src.removeAt(src.size - 1)\n    // 將圓盤放入 tar 頂部\n    tar.add(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar)\n}\n\n/* 求解河內塔問題 */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### 移動一個圓盤 ###\ndef move(src, tar)\n  # 從 src 頂部拿出一個圓盤\n  pan = src.pop\n  # 將圓盤放入 tar 頂部\n  tar &lt;&lt; pan\nend\n\n### 求解河內塔問題 f(i) ###\ndef dfs(i, src, buf, tar)\n  # 若 src 只剩下一個圓盤，則直接將其移到 tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n  dfs(i - 1, src, tar, buf)\n  # 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n  move(src, tar)\n  # 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n  dfs(i - 1, buf, src, tar)\nend\n\n### 求解河內塔問題 ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # 將 A 頂部 n 個圓盤藉助 B 移到 C\n  dfs(n, _A, _B, _C)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 12-15 所示，河內塔問題形成一棵高度為 \\(n\\) 的遞迴樹，每個節點代表一個子問題，對應一個開啟的 <code>dfs()</code> 函式，因此時間複雜度為 \\(O(2^n)\\) ，空間複雜度為 \\(O(n)\\) 。</p> <p></p> <p> 圖 12-15   河內塔問題的遞迴樹 </p> <p>Quote</p> <p>河內塔問題源自一個古老的傳說。在古印度的一個寺廟裡，僧侶們有三根高大的鑽石柱子，以及 \\(64\\) 個大小不一的金圓盤。僧侶們不斷地移動圓盤，他們相信在最後一個圓盤被正確放置的那一刻，這個世界就會結束。</p> <p>然而，即使僧侶們每秒鐘移動一次，總共需要大約 \\(2^{64} \\approx 1.84×10^{19}\\) 秒，合約 \\(5850\\) 億年，遠遠超過了現在對宇宙年齡的估計。所以，倘若這個傳說是真的，我們應該不需要擔心世界末日的到來。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   小結","text":"","path":["第 12 章 &nbsp; 分治","12.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>分治是一種常見的演算法設計策略，包括分（劃分）和治（合併）兩個階段，通常基於遞迴實現。</li> <li>判斷是否是分治演算法問題的依據包括：問題能否分解、子問題是否獨立、子問題能否合併。</li> <li>合併排序是分治策略的典型應用，其遞迴地將陣列劃分為等長的兩個子陣列，直到只剩一個元素時開始逐層合併，從而完成排序。</li> <li>引入分治策略往往可以提升演算法效率。一方面，分治策略減少了操作數量；另一方面，分治後有利於系統的並行最佳化。</li> <li>分治既可以解決許多演算法問題，也廣泛應用於資料結構與演算法設計中，處處可見其身影。</li> <li>相較於暴力搜尋，自適應搜尋效率更高。時間複雜度為 \\(O(\\log n)\\) 的搜尋演算法通常是基於分治策略實現的。</li> <li>二分搜尋是分治策略的另一個典型應用，它不包含將子問題的解進行合併的步驟。我們可以透過遞迴分治實現二分搜尋。</li> <li>在構建二元樹的問題中，構建樹（原問題）可以劃分為構建左子樹和右子樹（子問題），這可以透過劃分前序走訪和中序走訪的索引區間來實現。</li> <li>在河內塔問題中，一個規模為 \\(n\\) 的問題可以劃分為兩個規模為 \\(n-1\\) 的子問題和一個規模為 \\(1\\) 的子問題。按順序解決這三個子問題後，原問題隨之得到解決。</li> </ul>","path":["第 12 章 &nbsp; 分治","12.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"第 14 章   動態規劃","text":"<p>Abstract</p> <p>小溪匯入河流，江河匯入大海。</p> <p>動態規劃將小問題的解彙集成大問題的答案，一步步引領我們走向解決問題的彼岸。</p>","path":["第 14 章 &nbsp; 動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"本章內容","text":"<ul> <li>14.1   初探動態規劃</li> <li>14.2   DP 問題特性</li> <li>14.3   DP 解題思路</li> <li>14.4   0-1 背包問題</li> <li>14.5   完全背包問題</li> <li>14.6   編輯距離問題</li> <li>14.7   小結</li> </ul>","path":["第 14 章 &nbsp; 動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   動態規劃問題特性","text":"<p>在上一節中，我們學習了動態規劃是如何透過子問題分解來求解原問題的。實際上，子問題分解是一種通用的演算法思路，在分治、動態規劃、回溯中的側重點不同。</p> <ul> <li>分治演算法遞迴地將原問題劃分為多個相互獨立的子問題，直至最小子問題，並在回溯中合併子問題的解，最終得到原問題的解。</li> <li>動態規劃也對問題進行遞迴分解，但與分治演算法的主要區別是，動態規劃中的子問題是相互依賴的，在分解過程中會出現許多重疊子問題。</li> <li>回溯演算法在嘗試和回退中窮舉所有可能的解，並透過剪枝避免不必要的搜尋分支。原問題的解由一系列決策步驟構成，我們可以將每個決策步驟之前的子序列看作一個子問題。</li> </ul> <p>實際上，動態規劃常用來求解最最佳化問題，它們不僅包含重疊子問題，還具有另外兩大特性：最優子結構、無後效性。</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   最優子結構","text":"<p>我們對爬樓梯問題稍作改動，使之更加適合展示最優子結構概念。</p> <p>爬樓梯最小代價</p> <p>給定一個樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，每一階樓梯上都貼有一個非負整數，表示你在該臺階所需要付出的代價。給定一個非負整數陣列 \\(cost\\) ，其中 \\(cost[i]\\) 表示在第 \\(i\\) 個臺階需要付出的代價，\\(cost[0]\\) 為地面（起始點）。請計算最少需要付出多少代價才能到達頂部？</p> <p>如圖 14-6 所示，若第 \\(1\\)、\\(2\\)、\\(3\\) 階的代價分別為 \\(1\\)、\\(10\\)、\\(1\\) ，則從地面爬到第 \\(3\\) 階的最小代價為 \\(2\\) 。</p> <p></p> <p> 圖 14-6   爬到第 3 階的最小代價 </p> <p>設 \\(dp[i]\\) 為爬到第 \\(i\\) 階累計付出的代價，由於第 \\(i\\) 階只可能從 \\(i - 1\\) 階或 \\(i - 2\\) 階走來，因此 \\(dp[i]\\) 只可能等於 \\(dp[i - 1] + cost[i]\\) 或 \\(dp[i - 2] + cost[i]\\) 。為了儘可能減少代價，我們應該選擇兩者中較小的那一個：</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>這便可以引出最優子結構的含義：原問題的最優解是從子問題的最優解構建得來的。</p> <p>本題顯然具有最優子結構：我們從兩個子問題最優解 \\(dp[i-1]\\) 和 \\(dp[i-2]\\) 中挑選出較優的那一個，並用它構建出原問題 \\(dp[i]\\) 的最優解。</p> <p>那麼，上一節的爬樓梯題目有沒有最優子結構呢？它的目標是求解方案數量，看似是一個計數問題，但如果換一種問法：“求解最大方案數量”。我們意外地發現，雖然題目修改前後是等價的，但最優子結構浮現出來了：第 \\(n\\) 階最大方案數量等於第 \\(n-1\\) 階和第 \\(n-2\\) 階最大方案數量之和。所以說，最優子結構的解釋方式比較靈活，在不同問題中會有不同的含義。</p> <p>根據狀態轉移方程，以及初始狀態 \\(dp[1] = cost[1]\\) 和 \\(dp[2] = cost[2]\\) ，我們就可以得到動態規劃程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"爬樓梯最小代價：動態規劃\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [0] * (n + 1)\n    # 初始狀態：預設最小子問題的解\n    dp[1], dp[2] = cost[1], cost[2]\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;int&gt; dp(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初始狀態：預設最小子問題的解\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![-1; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int *dp = calloc(n + 1, sizeof(int));\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = IntArray(n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 爬樓梯最小代價：動態規劃 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = cost[1], cost[2]\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-7 展示了以上程式碼的動態規劃過程。</p> <p></p> <p> 圖 14-7   爬樓梯最小代價的動態規劃過程 </p> <p>本題也可以進行空間最佳化，將一維壓縮至零維，使得空間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"爬樓梯最小代價：空間最佳化後的動態規劃\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初始狀態：預設最小子問題的解\n    a, b := cost[1], cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 爬樓梯最小代價：動態規劃 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = cost[1], cost[2]\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# 爬樓梯最小代價：空間最佳化後的動態規劃\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   無後效性","text":"<p>無後效性是動態規劃能夠有效解決問題的重要特性之一，其定義為：給定一個確定的狀態，它的未來發展只與當前狀態有關，而與過去經歷的所有狀態無關。</p> <p>以爬樓梯問題為例，給定狀態 \\(i\\) ，它會發展出狀態 \\(i+1\\) 和狀態 \\(i+2\\) ，分別對應跳 \\(1\\) 步和跳 \\(2\\) 步。在做出這兩種選擇時，我們無須考慮狀態 \\(i\\) 之前的狀態，它們對狀態 \\(i\\) 的未來沒有影響。</p> <p>然而，如果我們給爬樓梯問題新增一個約束，情況就不一樣了。</p> <p>帶約束爬樓梯</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，但不能連續兩輪跳 \\(1\\) 階，請問有多少種方案可以爬到樓頂？</p> <p>如圖 14-8 所示，爬上第 \\(3\\) 階僅剩 \\(2\\) 種可行方案，其中連續三次跳 \\(1\\) 階的方案不滿足約束條件，因此被捨棄。</p> <p></p> <p> 圖 14-8   帶約束爬到第 3 階的方案數量 </p> <p>在該問題中，如果上一輪是跳 \\(1\\) 階上來的，那麼下一輪就必須跳 \\(2\\) 階。這意味著，下一步選擇不能由當前狀態（當前所在樓梯階數）獨立決定，還和前一個狀態（上一輪所在樓梯階數）有關。</p> <p>不難發現，此問題已不滿足無後效性，狀態轉移方程 \\(dp[i] = dp[i-1] + dp[i-2]\\) 也失效了，因為 \\(dp[i-1]\\) 代表本輪跳 \\(1\\) 階，但其中包含了許多“上一輪是跳 \\(1\\) 階上來的”方案，而為了滿足約束，我們就不能將 \\(dp[i-1]\\) 直接計入 \\(dp[i]\\) 中。</p> <p>為此，我們需要擴展狀態定義：狀態 \\([i, j]\\) 表示處在第 \\(i\\) 階並且上一輪跳了 \\(j\\) 階，其中 \\(j \\in \\{1, 2\\}\\) 。此狀態定義有效地區分了上一輪跳了 \\(1\\) 階還是 \\(2\\) 階，我們可以據此判斷當前狀態是從何而來的。</p> <ul> <li>當上一輪跳了 \\(1\\) 階時，上上一輪只能選擇跳 \\(2\\) 階，即 \\(dp[i, 1]\\) 只能從 \\(dp[i-1, 2]\\) 轉移過來。</li> <li>當上一輪跳了 \\(2\\) 階時，上上一輪可選擇跳 \\(1\\) 階或跳 \\(2\\) 階，即 \\(dp[i, 2]\\) 可以從 \\(dp[i-2, 1]\\) 或 \\(dp[i-2, 2]\\) 轉移過來。</li> </ul> <p>如圖 14-9 所示，在該定義下，\\(dp[i, j]\\) 表示狀態 \\([i, j]\\) 對應的方案數。此時狀態轉移方程為：</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> 圖 14-9   考慮約束下的遞推關係 </p> <p>最終，返回 \\(dp[n, 1] + dp[n, 2]\\) 即可，兩者之和代表爬到第 \\(n\\) 階的方案總數：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"帶約束爬樓梯：動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # 初始狀態：預設最小子問題的解\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int[][] dp = new int[n + 1][3];\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int[,] dp = new int[n + 1, 3];\n    // 初始狀態：預設最小子問題的解\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([][3]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // 初始狀態：預設最小子問題的解\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = Array(n + 1) { IntArray(3) }\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### 帶約束爬樓梯：動態規劃 ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # 初始狀態：預設最小子問題的解\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在上面的案例中，由於僅需多考慮前面一個狀態，因此我們仍然可以透過擴展狀態定義，使得問題重新滿足無後效性。然而，某些問題具有非常嚴重的“有後效性”。</p> <p>爬樓梯與障礙生成</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階。規定當爬到第 \\(i\\) 階時，系統自動會在第 \\(2i\\) 階上放上障礙物，之後所有輪都不允許跳到第 \\(2i\\) 階上。例如，前兩輪分別跳到了第 \\(2\\)、\\(3\\) 階上，則之後就不能跳到第 \\(4\\)、\\(6\\) 階上。請問有多少種方案可以爬到樓頂？</p> <p>在這個問題中，下次跳躍依賴過去所有的狀態，因為每一次跳躍都會在更高的階梯上設定障礙，並影響未來的跳躍。對於這類問題，動態規劃往往難以解決。</p> <p>實際上，許多複雜的組合最佳化問題（例如旅行商問題）不滿足無後效性。對於這類問題，我們通常會選擇使用其他方法，例如啟發式搜尋、遺傳演算法、強化學習等，從而在有限時間內得到可用的區域性最優解。</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   動態規劃解題思路","text":"<p>上兩節介紹了動態規劃問題的主要特徵，接下來我們一起探究兩個更加實用的問題。</p> <ol> <li>如何判斷一個問題是不是動態規劃問題？</li> <li>求解動態規劃問題該從何處入手，完整步驟是什麼？</li> </ol>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   問題判斷","text":"<p>總的來說，如果一個問題包含重疊子問題、最優子結構，並滿足無後效性，那麼它通常適合用動態規劃求解。然而，我們很難從問題描述中直接提取出這些特性。因此我們通常會放寬條件，先觀察問題是否適合使用回溯（窮舉）解決。</p> <p>適合用回溯解決的問題通常滿足“決策樹模型”，這種問題可以使用樹形結構來描述，其中每一個節點代表一個決策，每一條路徑代表一個決策序列。</p> <p>換句話說，如果問題包含明確的決策概念，並且解是透過一系列決策產生的，那麼它就滿足決策樹模型，通常可以使用回溯來解決。</p> <p>在此基礎上，動態規劃問題還有一些判斷的“加分項”。</p> <ul> <li>問題包含最大（小）或最多（少）等最最佳化描述。</li> <li>問題的狀態能夠使用一個串列、多維矩陣或樹來表示，並且一個狀態與其周圍的狀態存在遞推關係。</li> </ul> <p>相應地，也存在一些“減分項”。</p> <ul> <li>問題的目標是找出所有可能的解決方案，而不是找出最優解。</li> <li>問題描述中有明顯的排列組合的特徵，需要返回具體的多個方案。</li> </ul> <p>如果一個問題滿足決策樹模型，並具有較為明顯的“加分項”，我們就可以假設它是一個動態規劃問題，並在求解過程中驗證它。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   問題求解步驟","text":"<p>動態規劃的解題流程會因問題的性質和難度而有所不同，但通常遵循以下步驟：描述決策，定義狀態，建立 \\(dp\\) 表，推導狀態轉移方程，確定邊界條件等。</p> <p>為了更形象地展示解題步驟，我們使用一個經典問題“最小路徑和”來舉例。</p> <p>Question</p> <p>給定一個 \\(n \\times m\\) 的二維網格 <code>grid</code> ，網格中的每個單元格包含一個非負整數，表示該單元格的代價。機器人以左上角單元格為起始點，每次只能向下或者向右移動一步，直至到達右下角單元格。請返回從左上角到右下角的最小路徑和。</p> <p>圖 14-10 展示了一個例子，給定網格的最小路徑和為 \\(13\\) 。</p> <p></p> <p> 圖 14-10   最小路徑和示例資料 </p> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>本題的每一輪的決策就是從當前格子向下或向右走一步。設當前格子的行列索引為 \\([i, j]\\) ，則向下或向右走一步後，索引變為 \\([i+1, j]\\) 或 \\([i, j+1]\\) 。因此，狀態應包含行索引和列索引兩個變數，記為 \\([i, j]\\) 。</p> <p>狀態 \\([i, j]\\) 對應的子問題為：從起始點 \\([0, 0]\\) 走到 \\([i, j]\\) 的最小路徑和，解記為 \\(dp[i, j]\\) 。</p> <p>至此，我們就得到了圖 14-11 所示的二維 \\(dp\\) 矩陣，其尺寸與輸入網格 \\(grid\\) 相同。</p> <p></p> <p> 圖 14-11   狀態定義與 dp 表 </p> <p>Note</p> <p>動態規劃和回溯過程可以描述為一個決策序列，而狀態由所有決策變數構成。它應當包含描述解題進度的所有變數，其包含了足夠的資訊，能夠用來推導出下一個狀態。</p> <p>每個狀態都對應一個子問題，我們會定義一個 \\(dp\\) 表來儲存所有子問題的解，狀態的每個獨立變數都是 \\(dp\\) 表的一個維度。從本質上看，\\(dp\\) 表是狀態和子問題的解之間的對映。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>對於狀態 \\([i, j]\\) ，它只能從上邊格子 \\([i-1, j]\\) 和左邊格子 \\([i, j-1]\\) 轉移而來。因此最優子結構為：到達 \\([i, j]\\) 的最小路徑和由 \\([i, j-1]\\) 的最小路徑和與 \\([i-1, j]\\) 的最小路徑和中較小的那一個決定。</p> <p>根據以上分析，可推出圖 14-12 所示的狀態轉移方程：</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> 圖 14-12   最優子結構與狀態轉移方程 </p> <p>Note</p> <p>根據定義好的 \\(dp\\) 表，思考原問題和子問題的關係，找出透過子問題的最優解來構造原問題的最優解的方法，即最優子結構。</p> <p>一旦我們找到了最優子結構，就可以使用它來構建出狀態轉移方程。</p> <p>第三步：確定邊界條件和狀態轉移順序</p> <p>在本題中，處在首行的狀態只能從其左邊的狀態得來，處在首列的狀態只能從其上邊的狀態得來，因此首行 \\(i = 0\\) 和首列 \\(j = 0\\) 是邊界條件。</p> <p>如圖 14-13 所示，由於每個格子是由其左方格子和上方格子轉移而來，因此我們使用迴圈來走訪矩陣，外迴圈走訪各行，內迴圈走訪各列。</p> <p></p> <p> 圖 14-13   邊界條件與狀態轉移順序 </p> <p>Note</p> <p>邊界條件在動態規劃中用於初始化 \\(dp\\) 表，在搜尋中用於剪枝。</p> <p>狀態轉移順序的核心是要保證在計算當前問題的解時，所有它依賴的更小子問題的解都已經被正確地計算出來。</p> <p>根據以上分析，我們已經可以直接寫出動態規劃程式碼。然而子問題分解是一種從頂至底的思想，因此按照“暴力搜尋 \\(\\rightarrow\\) 記憶化搜尋 \\(\\rightarrow\\) 動態規劃”的順序實現更加符合思維習慣。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1","level":3,"title":"1.   方法一：暴力搜尋","text":"<p>從狀態 \\([i, j]\\) 開始搜尋，不斷分解為更小的狀態 \\([i-1, j]\\) 和 \\([i, j-1]\\) ，遞迴函式包括以下要素。</p> <ul> <li>遞迴參數：狀態 \\([i, j]\\) 。</li> <li>返回值：從 \\([0, 0]\\) 到 \\([i, j]\\) 的最小路徑和 \\(dp[i, j]\\) 。</li> <li>終止條件：當 \\(i = 0\\) 且 \\(j = 0\\) 時，返回代價 \\(grid[0, 0]\\) 。</li> <li>剪枝：當 \\(i &lt; 0\\) 時或 \\(j &lt; 0\\) 時索引越界，此時返回代價 \\(+\\infty\\) ，代表不可行。</li> </ul> <p>實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"最小路徑和：暴力搜尋\"\"\"\n    # 若為左上角單元格，則終止搜尋\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：暴力搜尋 */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：暴力搜尋 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：暴力搜尋 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：暴力搜尋 */\nfunction minPathSumDFS(grid, i, j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：暴力搜尋 */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // 若為左上角單元格，則終止搜尋\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 若行列索引越界，則返回 +∞ 代價\n  if (i &lt; 0 || j &lt; 0) {\n    // 在 Dart 中，int 型別是固定範圍的整數，不存在表示“無窮大”的值\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // 返回從左上角到 (i, j) 的最小路徑代價\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：暴力搜尋 */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：暴力搜尋 */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：暴力搜尋 ###\ndef min_path_sum_dfs(grid, i, j)\n  # 若為左上角單元格，則終止搜尋\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # 若行列索引越界，則返回 +∞ 代價\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # 返回從左上角到 (i, j) 的最小路徑代價\n  [left, up].min + grid[i][j]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-14 給出了以 \\(dp[2, 1]\\) 為根節點的遞迴樹，其中包含一些重疊子問題，其數量會隨著網格 <code>grid</code> 的尺寸變大而急劇增多。</p> <p>從本質上看，造成重疊子問題的原因為：存在多條路徑可以從左上角到達某一單元格。</p> <p></p> <p> 圖 14-14   暴力搜尋遞迴樹 </p> <p>每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 \\(m + n - 2\\) 步，所以最差時間複雜度為 \\(O(2^{m + n})\\) ，其中 \\(n\\) 和 \\(m\\) 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網格邊界時只剩下一種選擇，因此實際的路徑數量會少一些。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2","level":3,"title":"2.   方法二：記憶化搜尋","text":"<p>我們引入一個和網格 <code>grid</code> 相同尺寸的記憶串列 <code>mem</code> ，用於記錄各個子問題的解，並將重疊子問題進行剪枝：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"最小路徑和：記憶化搜尋\"\"\"\n    # 若為左上角單元格，則終止搜尋\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 若已有記錄，則直接返回\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # 左邊和上邊單元格的最小路徑代價\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：記憶化搜尋 */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // 若為左上角單元格，則終止搜尋\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 若行列索引越界，則返回 +∞ 代價\n  if (i &lt; 0 || j &lt; 0) {\n    // 在 Dart 中，int 型別是固定範圍的整數，不存在表示“無窮大”的值\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 若已有記錄，則直接返回\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // 左邊和上邊單元格的最小路徑代價\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // 記錄並返回左上角到 (i, j) 的最小路徑代價\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：記憶化搜尋 */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 若已有記錄，則直接返回\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：記憶化搜尋 */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：記憶化搜尋 ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # 若為左上角單元格，則終止搜尋\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # 若行列索引越界，則返回 +∞ 代價\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 若已有記錄，則直接返回\n  return mem[i][j] if mem[i][j] != -1\n  # 左邊和上邊單元格的最小路徑代價\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # 記錄並返回左上角到 (i, j) 的最小路徑代價\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-15 所示，在引入記憶化後，所有子問題的解只需計算一次，因此時間複雜度取決於狀態總數，即網格尺寸 \\(O(nm)\\) 。</p> <p></p> <p> 圖 14-15   記憶化搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3","level":3,"title":"3.   方法三：動態規劃","text":"<p>基於迭代實現動態規劃解法，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小路徑和：動態規劃\"\"\"\n    n, m = len(grid), len(grid[0])\n    # 初始化 dp 表\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # 狀態轉移：首行\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # 狀態轉移：首列\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # 狀態轉移：其餘行和列\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // 初始化 dp 表\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：動態規劃 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：動態規劃 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // 初始化 dp 表\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：動態規劃 */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：動態規劃 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：動態規劃 */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // 狀態轉移：首行\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // 狀態轉移：首列\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：動態規劃 */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // 初始化 dp 表\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // 釋放記憶體\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：動態規劃 */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // 初始化 dp 表\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：動態規劃 ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # 初始化 dp 表\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # 狀態轉移：首行\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # 狀態轉移：首列\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # 狀態轉移：其餘行和列\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-16 展示了最小路徑和的狀態轉移過程，其走訪了整個網格，因此時間複雜度為 \\(O(nm)\\) 。</p> <p>陣列 <code>dp</code> 大小為 \\(n \\times m\\) ，因此空間複雜度為 \\(O(nm)\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-16   最小路徑和的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   空間最佳化","text":"<p>由於每個格子只與其左邊和上邊的格子有關，因此我們可以只用一個單行陣列來實現 \\(dp\\) 表。</p> <p>請注意，因為陣列 <code>dp</code> 只能表示一行的狀態，所以我們無法提前初始化首列狀態，而是在走訪每行時更新它：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小路徑和：空間最佳化後的動態規劃\"\"\"\n    n, m = len(grid), len(grid[0])\n    # 初始化 dp 表\n    dp = [0] * m\n    # 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # 狀態轉移：其餘行\n    for i in range(1, n):\n        # 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        # 狀態轉移：其餘列\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // 初始化 dp 表\n    int[] dp = new int[m];\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // 初始化 dp 表\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // 初始化 dp 表\n    dp := make([]int, m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt; n; i++ {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行\n    for i in 1 ..&lt; n {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = new Array(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = new Array(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // 狀態轉移：其餘行\n  for (int i = 1; i &lt; n; i++) {\n    // 狀態轉移：首列\n    dp[0] = dp[0] + grid[i][0];\n    // 狀態轉移：其餘列\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // 初始化 dp 表\n    let mut dp = vec![0; m];\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for i in 1..n {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // 初始化 dp 表\n    int *dp = calloc(m, sizeof(int));\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // 初始化 dp 表\n    val dp = IntArray(m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行\n    for (i in 1..&lt;n) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：空間最佳化後的動態規劃 ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # 初始化 dp 表\n  dp = Array.new(m, 0)\n  # 狀態轉移：首行\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # 狀態轉移：其餘行\n  for i in 1...n\n    # 狀態轉移：首列\n    dp[0] = dp[0] + grid[i][0]\n    # 狀態轉移：其餘列\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   編輯距離問題","text":"<p>編輯距離，也稱 Levenshtein 距離，指兩個字串之間互相轉換的最少修改次數，通常用於在資訊檢索和自然語言處理中度量兩個序列的相似度。</p> <p>Question</p> <p>輸入兩個字串 \\(s\\) 和 \\(t\\) ，返回將 \\(s\\) 轉換為 \\(t\\) 所需的最少編輯步數。</p> <p>你可以在一個字串中進行三種編輯操作：插入一個字元、刪除一個字元、將字元替換為任意一個字元。</p> <p>如圖 14-27 所示，將 <code>kitten</code> 轉換為 <code>sitting</code> 需要編輯 3 步，包括 2 次替換操作與 1 次新增操作；將 <code>hello</code> 轉換為 <code>algo</code> 需要 3 步，包括 2 次替換操作和 1 次刪除操作。</p> <p></p> <p> 圖 14-27   編輯距離的示例資料 </p> <p>編輯距離問題可以很自然地用決策樹模型來解釋。字串對應樹節點，一輪決策（一次編輯操作）對應樹的一條邊。</p> <p>如圖 14-28 所示，在不限制操作的情況下，每個節點都可以派生出許多條邊，每條邊對應一種操作，這意味著從 <code>hello</code> 轉換到 <code>algo</code> 有許多種可能的路徑。</p> <p>從決策樹的角度看，本題的目標是求解節點 <code>hello</code> 和節點 <code>algo</code> 之間的最短路徑。</p> <p></p> <p> 圖 14-28   基於決策樹模型表示編輯距離問題 </p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   動態規劃思路","text":"<p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>每一輪的決策是對字串 \\(s\\) 進行一次編輯操作。</p> <p>我們希望在編輯操作的過程中，問題的規模逐漸縮小，這樣才能構建子問題。設字串 \\(s\\) 和 \\(t\\) 的長度分別為 \\(n\\) 和 \\(m\\) ，我們先考慮兩字串尾部的字元 \\(s[n-1]\\) 和 \\(t[m-1]\\) 。</p> <ul> <li>若 \\(s[n-1]\\) 和 \\(t[m-1]\\) 相同，我們可以跳過它們，直接考慮 \\(s[n-2]\\) 和 \\(t[m-2]\\) 。</li> <li>若 \\(s[n-1]\\) 和 \\(t[m-1]\\) 不同，我們需要對 \\(s\\) 進行一次編輯（插入、刪除、替換），使得兩字串尾部的字元相同，從而可以跳過它們，考慮規模更小的問題。</li> </ul> <p>也就是說，我們在字串 \\(s\\) 中進行的每一輪決策（編輯操作），都會使得 \\(s\\) 和 \\(t\\) 中剩餘的待匹配字元發生變化。因此，狀態為當前在 \\(s\\) 和 \\(t\\) 中考慮的第 \\(i\\) 和第 \\(j\\) 個字元，記為 \\([i, j]\\) 。</p> <p>狀態 \\([i, j]\\) 對應的子問題：將 \\(s\\) 的前 \\(i\\) 個字元更改為 \\(t\\) 的前 \\(j\\) 個字元所需的最少編輯步數。</p> <p>至此，得到一個尺寸為 \\((i+1) \\times (j+1)\\) 的二維 \\(dp\\) 表。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>考慮子問題 \\(dp[i, j]\\) ，其對應的兩個字串的尾部字元為 \\(s[i-1]\\) 和 \\(t[j-1]\\) ，可根據不同編輯操作分為圖 14-29 所示的三種情況。</p> <ol> <li>在 \\(s[i-1]\\) 之後新增 \\(t[j-1]\\) ，則剩餘子問題 \\(dp[i, j-1]\\) 。</li> <li>刪除 \\(s[i-1]\\) ，則剩餘子問題 \\(dp[i-1, j]\\) 。</li> <li>將 \\(s[i-1]\\) 替換為 \\(t[j-1]\\) ，則剩餘子問題 \\(dp[i-1, j-1]\\) 。</li> </ol> <p></p> <p> 圖 14-29   編輯距離的狀態轉移 </p> <p>根據以上分析，可得最優子結構：\\(dp[i, j]\\) 的最少編輯步數等於 \\(dp[i, j-1]\\)、\\(dp[i-1, j]\\)、\\(dp[i-1, j-1]\\) 三者中的最少編輯步數，再加上本次的編輯步數 \\(1\\) 。對應的狀態轉移方程為：</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>請注意，當 \\(s[i-1]\\) 和 \\(t[j-1]\\) 相同時，無須編輯當前字元，這種情況下的狀態轉移方程為：</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當兩字串都為空時，編輯步數為 \\(0\\) ，即 \\(dp[0, 0] = 0\\) 。當 \\(s\\) 為空但 \\(t\\) 不為空時，最少編輯步數等於 \\(t\\) 的長度，即首行 \\(dp[0, j] = j\\) 。當 \\(s\\) 不為空但 \\(t\\) 為空時，最少編輯步數等於 \\(s\\) 的長度，即首列 \\(dp[i, 0] = i\\) 。</p> <p>觀察狀態轉移方程，解 \\(dp[i, j]\\) 依賴左方、上方、左上方的解，因此透過兩層迴圈正序走訪整個 \\(dp\\) 表即可。</p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"編輯距離：動態規劃\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # 狀態轉移：首行首列\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # 狀態轉移：其餘行和列\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編輯距離：動態規劃 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編輯距離：動態規劃 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // 狀態轉移：首行首列\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編輯距離：動態規劃 */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // 狀態轉移：首行首列\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編輯距離：動態規劃 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // 狀態轉移：首行首列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編輯距離：動態規劃 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // 狀態轉移：首行首列\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // 若兩字元相等，則直接跳過此兩字元\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編輯距離：動態規劃 */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // 狀態轉移：首行首列\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編輯距離：動態規劃 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // 狀態轉移：首行首列\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編輯距離：動態規劃 ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # 狀態轉移：首行首列\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # 狀態轉移：其餘行和列\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # 若兩字元相等，則直接跳過此兩字元\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-30 所示，編輯距離問題的狀態轉移過程與背包問題非常類似，都可以看作填寫一個二維網格的過程。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-30   編輯距離的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   空間最佳化","text":"<p>由於 \\(dp[i,j]\\) 是由上方 \\(dp[i-1, j]\\)、左方 \\(dp[i, j-1]\\)、左上方 \\(dp[i-1, j-1]\\) 轉移而來的，而正序走訪會丟失左上方 \\(dp[i-1, j-1]\\) ，倒序走訪無法提前構建 \\(dp[i, j-1]\\) ，因此兩種走訪順序都不可取。</p> <p>為此，我們可以使用一個變數 <code>leftup</code> 來暫存左上方的解 \\(dp[i-1, j-1]\\) ，從而只需考慮左方和上方的解。此時的情況與完全背包問題相同，可使用正序走訪。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"編輯距離：空間最佳化後的動態規劃\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # 狀態轉移：首行\n    for j in range(1, m + 1):\n        dp[j] = j\n    # 狀態轉移：其餘行\n    for i in range(1, n + 1):\n        # 狀態轉移：首列\n        leftup = dp[0]  # 暫存 dp[i-1, j-1]\n        dp[0] += 1\n        # 狀態轉移：其餘列\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            else:\n                # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # 更新為下一輪的 dp[i-1, j-1]\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // 狀態轉移：首行\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for i := 1; i &lt;= n; i++ {\n        // 狀態轉移：首列\n        leftUp := dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftUp\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // 狀態轉移：首行\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for i in 1 ... n {\n        // 狀態轉移：首列\n        var leftup = dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 狀態轉移：首行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        let leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 狀態轉移：首行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        let leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // 狀態轉移：首行\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // 狀態轉移：其餘行\n  for (int i = 1; i &lt;= n; i++) {\n    // 狀態轉移：首列\n    int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n    dp[0] = i;\n    // 狀態轉移：其餘列\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // 若兩字元相等，則直接跳過此兩字元\n        dp[j] = leftup;\n      } else {\n        // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // 狀態轉移：首行\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // 狀態轉移：其餘行\n    for i in 1..=n {\n        // 狀態轉移：首列\n        let mut leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i as i32;\n        // 狀態轉移：其餘列\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // 狀態轉移：首行\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for (i in 1..n) {\n        // 狀態轉移：首列\n        var leftup = dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編輯距離：空間最佳化後的動態規劃 ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # 狀態轉移：首行\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # 狀態轉移：其餘行\n  for i in 1...(n + 1)\n    # 狀態轉移：首列\n    leftup = dp.first # 暫存 dp[i-1, j-1]\n    dp[0] += 1\n    # 狀態轉移：其餘列\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # 若兩字元相等，則直接跳過此兩字元\n        dp[j] = leftup\n      else\n        # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # 更新為下一輪的 dp[i-1, j-1]\n    end\n  end\n  dp[m]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   初探動態規劃","text":"<p>動態規劃（dynamic programming）是一個重要的演算法範式，它將一個問題分解為一系列更小的子問題，並透過儲存子問題的解來避免重複計算，從而大幅提升時間效率。</p> <p>在本節中，我們從一個經典例題入手，先給出它的暴力回溯解法，觀察其中包含的重疊子問題，再逐步導出更高效的動態規劃解法。</p> <p>爬樓梯</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，請問有多少種方案可以爬到樓頂？</p> <p>如圖 14-1 所示，對於一個 \\(3\\) 階樓梯，共有 \\(3\\) 種方案可以爬到樓頂。</p> <p></p> <p> 圖 14-1   爬到第 3 階的方案數量 </p> <p>本題的目標是求解方案數量，我們可以考慮透過回溯來窮舉所有可能性。具體來說，將爬樓梯想象為一個多輪選擇的過程：從地面出發，每輪選擇上 \\(1\\) 階或 \\(2\\) 階，每當到達樓梯頂部時就將方案數量加 \\(1\\) ，當越過樓梯頂部時就將其剪枝。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"回溯\"\"\"\n    # 當爬到第 n 階時，方案數量加 1\n    if state == n:\n        res[0] += 1\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：不允許越過第 n 階\n        if state + choice &gt; n:\n            continue\n        # 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res)\n        # 回退\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"爬樓梯：回溯\"\"\"\n    choices = [1, 2]  # 可選擇向上爬 1 階或 2 階\n    state = 0  # 從第 0 階開始爬\n    res = [0]  # 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* 回溯 */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    for (auto &amp;choice : choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // 可選擇向上爬 1 階或 2 階\n    int state = 0;                // 從第 0 階開始爬\n    vector&lt;int&gt; res = {0};        // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* 回溯 */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (Integer choice : choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // 可選擇向上爬 1 階或 2 階\n    int state = 0; // 從第 0 階開始爬\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* 回溯 */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    foreach (int choice in choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        Backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    int state = 0; // 從第 0 階開始爬\n    List&lt;int&gt; res = [0]; // 使用 res[0] 記錄方案數量\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* 回溯 */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // 走訪所有選擇\n    for _, choice := range choices {\n        // 剪枝：不允許越過第 n 階\n        if state+choice &gt; n {\n            continue\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state+choice, n, res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunc climbingStairsBacktrack(n int) int {\n    // 可選擇向上爬 1 階或 2 階\n    choices := []int{1, 2}\n    // 從第 0 階開始爬\n    state := 0\n    res := make([]int, 1)\n    // 使用 res[0] 記錄方案數量\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* 回溯 */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] += 1\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：不允許越過第 n 階\n        if state + choice &gt; n {\n            continue\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // 可選擇向上爬 1 階或 2 階\n    let state = 0 // 從第 0 階開始爬\n    var res: [Int] = []\n    res.append(0) // 使用 res[0] 記錄方案數量\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* 回溯 */\nfunction backtrack(choices, state, n, res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    const state = 0; // 從第 0 階開始爬\n    const res = new Map();\n    res.set(0, 0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* 回溯 */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    const state = 0; // 從第 0 階開始爬\n    const res = new Map();\n    res.set(0, 0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* 回溯 */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // 當爬到第 n 階時，方案數量加 1\n  if (state == n) {\n    res[0]++;\n  }\n  // 走訪所有選擇\n  for (int choice in choices) {\n    // 剪枝：不允許越過第 n 階\n    if (state + choice &gt; n) continue;\n    // 嘗試：做出選擇，更新狀態\n    backtrack(choices, state + choice, n, res);\n    // 回退\n  }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n  int state = 0; // 從第 0 階開始爬\n  List&lt;int&gt; res = [];\n  res.add(0); // 使用 res[0] 記錄方案數量\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* 回溯 */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // 走訪所有選擇\n    for &amp;choice in choices {\n        // 剪枝：不允許越過第 n 階\n        if state + choice &gt; n {\n            continue;\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // 可選擇向上爬 1 階或 2 階\n    let state = 0; // 從第 0 階開始爬\n    let mut res = Vec::new();\n    res.push(0); // 使用 res[0] 記錄方案數量\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* 回溯 */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res, len);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // 可選擇向上爬 1 階或 2 階\n    int state = 0;           // 從第 0 階開始爬\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // 使用 res[0] 記錄方案數量\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* 回溯 */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0] = res[0] + 1\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // 可選擇向上爬 1 階或 2 階\n    val state = 0 // 從第 0 階開始爬\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### 回溯 ###\ndef backtrack(choices, state, n, res)\n  # 當爬到第 n 階時，方案數量加 1\n  res[0] += 1 if state == n\n  # 走訪所有選擇\n  for choice in choices\n    # 剪枝：不允許越過第 n 階\n    next if state + choice &gt; n\n\n    # 嘗試：做出選擇，更新狀態\n    backtrack(choices, state + choice, n, res)\n  end\n  # 回退\nend\n\n### 爬樓梯：回溯 ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # 可選擇向上爬 1 階或 2 階\n  state = 0 # 從第 0 階開始爬\n  res = [0] # 使用 res[0] 記錄方案數量\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411","level":2,"title":"14.1.1   方法一：暴力搜尋","text":"<p>回溯演算法通常並不顯式地對問題進行拆解，而是將求解問題看作一系列決策步驟，透過試探和剪枝，搜尋所有可能的解。</p> <p>我們可以嘗試從問題分解的角度分析這道題。設爬到第 \\(i\\) 階共有 \\(dp[i]\\) 種方案，那麼 \\(dp[i]\\) 就是原問題，其子問題包括：</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>由於每輪只能上 \\(1\\) 階或 \\(2\\) 階，因此當我們站在第 \\(i\\) 階樓梯上時，上一輪只可能站在第 \\(i - 1\\) 階或第 \\(i - 2\\) 階上。換句話說，我們只能從第 \\(i -1\\) 階或第 \\(i - 2\\) 階邁向第 \\(i\\) 階。</p> <p>由此便可得出一個重要推論：爬到第 \\(i - 1\\) 階的方案數加上爬到第 \\(i - 2\\) 階的方案數就等於爬到第 \\(i\\) 階的方案數。公式如下：</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>這意味著在爬樓梯問題中，各個子問題之間存在遞推關係，原問題的解可以由子問題的解構建得來。圖 14-2 展示了該遞推關係。</p> <p></p> <p> 圖 14-2   方案數量遞推關係 </p> <p>我們可以根據遞推公式得到暴力搜尋解法。以 \\(dp[n]\\) 為起始點，遞迴地將一個較大問題拆解為兩個較小問題的和，直至到達最小子問題 \\(dp[1]\\) 和 \\(dp[2]\\) 時返回。其中，最小子問題的解是已知的，即 \\(dp[1] = 1\\)、\\(dp[2] = 2\\) ，表示爬到第 \\(1\\)、\\(2\\) 階分別有 \\(1\\)、\\(2\\) 種方案。</p> <p>觀察以下程式碼，它和標準回溯程式碼都屬於深度優先搜尋，但更加簡潔：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"搜尋\"\"\"\n    # 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"爬樓梯：搜尋\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* 搜尋 */\nint DFS(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* 搜尋 */\nfunc dfs(i int) int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* 搜尋 */\nfunc dfs(i: Int) -&gt; Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* 搜尋 */\nfunction dfs(i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* 搜尋 */\nfunction dfs(i: number): number {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* 搜尋 */\nint dfs(int i) {\n  // 已知 dp[1] 和 dp[2] ，返回之\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* 搜尋 */\nfn dfs(i: usize) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* 爬樓梯：搜尋 */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* 搜尋 */\nfun dfs(i: Int): Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### 搜尋 ###\ndef dfs(i)\n  # 已知 dp[1] 和 dp[2] ，返回之\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### 爬樓梯：搜尋 ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-3 展示了暴力搜尋形成的遞迴樹。對於問題 \\(dp[n]\\) ，其遞迴樹的深度為 \\(n\\) ，時間複雜度為 \\(O(2^n)\\) 。指數階屬於爆炸式增長，如果我們輸入一個比較大的 \\(n\\) ，則會陷入漫長的等待之中。</p> <p></p> <p> 圖 14-3   爬樓梯對應遞迴樹 </p> <p>觀察圖 14-3 ，指數階的時間複雜度是“重疊子問題”導致的。例如 \\(dp[9]\\) 被分解為 \\(dp[8]\\) 和 \\(dp[7]\\) ，\\(dp[8]\\) 被分解為 \\(dp[7]\\) 和 \\(dp[6]\\) ，兩者都包含子問題 \\(dp[7]\\) 。</p> <p>以此類推，子問題中包含更小的重疊子問題，子子孫孫無窮盡也。絕大部分計算資源都浪費在這些重疊的子問題上。</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412","level":2,"title":"14.1.2   方法二：記憶化搜尋","text":"<p>為了提升演算法效率，我們希望所有的重疊子問題都只被計算一次。為此，我們宣告一個陣列 <code>mem</code> 來記錄每個子問題的解，並在搜尋過程中將重疊子問題剪枝。</p> <ol> <li>當首次計算 \\(dp[i]\\) 時，我們將其記錄至 <code>mem[i]</code> ，以便之後使用。</li> <li>當再次需要計算 \\(dp[i]\\) 時，我們便可直接從 <code>mem[i]</code> 中獲取結果，從而避免重複計算該子問題。</li> </ol> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"記憶化搜尋\"\"\"\n    # 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 or i == 2:\n        return i\n    # 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # 記錄 dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"爬樓梯：記憶化搜尋\"\"\"\n    # mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* 記憶化搜尋 */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* 記憶化搜尋 */\nint dfs(int i, int[] mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* 記憶化搜尋 */\nint DFS(int i, int[] mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* 記憶化搜尋 */\nfunc dfsMem(i int, mem []int) int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* 記憶化搜尋 */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* 記憶化搜尋 */\nfunction dfs(i, mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* 記憶化搜尋 */\nfunction dfs(i: number, mem: number[]): number {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* 記憶化搜尋 */\nint dfs(int i, List&lt;int&gt; mem) {\n  // 已知 dp[1] 和 dp[2] ，返回之\n  if (i == 1 || i == 2) return i;\n  // 若存在記錄 dp[i] ，則直接返回之\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // 記錄 dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n  // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* 記憶化搜尋 */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* 記憶化搜尋 */\nint dfs(int i, int *mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* 記憶化搜尋 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2) return i\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### 記憶化搜尋 ###\ndef dfs(i, mem)\n  # 已知 dp[1] 和 dp[2] ，返回之\n  return i if i == 1 || i == 2\n  # 若存在記錄 dp[i] ，則直接返回之\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # 記錄 dp[i]\n  mem[i] = count\nend\n\n### 爬樓梯：記憶化搜尋 ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察圖 14-4 ，經過記憶化處理後，所有重疊子問題都只需計算一次，時間複雜度最佳化至 \\(O(n)\\) ，這是一個巨大的飛躍。</p> <p></p> <p> 圖 14-4   記憶化搜尋對應遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413","level":2,"title":"14.1.3   方法三：動態規劃","text":"<p>記憶化搜尋是一種“從頂至底”的方法：我們從原問題（根節點）開始，遞迴地將較大子問題分解為較小子問題，直至解已知的最小子問題（葉節點）。之後，透過回溯逐層收集子問題的解，構建出原問題的解。</p> <p>與之相反，動態規劃是一種“從底至頂”的方法：從最小子問題的解開始，迭代地構建更大子問題的解，直至得到原問題的解。</p> <p>由於動態規劃不包含回溯過程，因此只需使用迴圈迭代實現，無須使用遞迴。在以下程式碼中，我們初始化一個陣列 <code>dp</code> 來儲存子問題的解，它起到了與記憶化搜尋中陣列 <code>mem</code> 相同的記錄作用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"爬樓梯：動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [0] * (n + 1)\n    # 初始狀態：預設最小子問題的解\n    dp[1], dp[2] = 1, 2\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;int&gt; dp(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 爬樓梯：動態規劃 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 爬樓梯：動態規劃 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 爬樓梯：動態規劃 */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 爬樓梯：動態規劃 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1).fill(-1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 爬樓梯：動態規劃 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1).fill(-1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初始狀態：預設最小子問題的解\n  dp[1] = 1;\n  dp[2] = 2;\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 爬樓梯：動態規劃 */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![-1; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 爬樓梯：動態規劃 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = IntArray(n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 爬樓梯：動態規劃 ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = 1, 2\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-5 模擬了以上程式碼的執行過程。</p> <p></p> <p> 圖 14-5   爬樓梯的動態規劃過程 </p> <p>與回溯演算法一樣，動態規劃也使用“狀態”概念來表示問題求解的特定階段，每個狀態都對應一個子問題以及相應的區域性最優解。例如，爬樓梯問題的狀態定義為當前所在樓梯階數 \\(i\\) 。</p> <p>根據以上內容，我們可以總結出動態規劃的常用術語。</p> <ul> <li>將陣列 <code>dp</code> 稱為 dp 表，\\(dp[i]\\) 表示狀態 \\(i\\) 對應子問題的解。</li> <li>將最小子問題對應的狀態（第 \\(1\\) 階和第 \\(2\\) 階樓梯）稱為初始狀態。</li> <li>將遞推公式 \\(dp[i] = dp[i-1] + dp[i-2]\\) 稱為狀態轉移方程。</li> </ul>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   空間最佳化","text":"<p>細心的讀者可能發現了，由於 \\(dp[i]\\) 只與 \\(dp[i-1]\\) 和 \\(dp[i-2]\\) 有關，因此我們無須使用一個陣列 <code>dp</code> 來儲存所有子問題的解，而只需兩個變數滾動前進即可。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"爬樓梯：空間最佳化後的動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 爬樓梯：空間最佳化後的動態規劃 ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，由於省去了陣列 <code>dp</code> 佔用的空間，因此空間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) 。</p> <p>在動態規劃問題中，當前狀態往往僅與前面有限個狀態有關，這時我們可以只保留必要的狀態，透過“降維”來節省記憶體空間。這種空間最佳化技巧被稱為“滾動變數”或“滾動陣列”。</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 背包問題","text":"<p>背包問題是一個非常好的動態規劃入門題目，是動態規劃中最常見的問題形式。其具有很多變種，例如 0-1 背包問題、完全背包問題、多重背包問題等。</p> <p>在本節中，我們先來求解最常見的 0-1 背包問題。</p> <p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品只能選擇一次，問在限定背包容量下能放入物品的最大價值。</p> <p>觀察圖 14-17 ，由於物品編號 \\(i\\) 從 \\(1\\) 開始計數，陣列索引從 \\(0\\) 開始計數，因此物品 \\(i\\) 對應重量 \\(wgt[i-1]\\) 和價值 \\(val[i-1]\\) 。</p> <p></p> <p> 圖 14-17   0-1 背包的示例資料 </p> <p>我們可以將 0-1 背包問題看作一個由 \\(n\\) 輪決策組成的過程，對於每個物體都有不放入和放入兩種決策，因此該問題滿足決策樹模型。</p> <p>該問題的目標是求解“在限定背包容量下能放入物品的最大價值”，因此較大機率是一個動態規劃問題。</p> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>對於每個物品來說，不放入背包，背包容量不變；放入背包，背包容量減小。由此可得狀態定義：當前物品編號 \\(i\\) 和背包容量 \\(c\\) ，記為 \\([i, c]\\) 。</p> <p>狀態 \\([i, c]\\) 對應的子問題為：前 \\(i\\) 個物品在容量為 \\(c\\) 的背包中的最大價值，記為 \\(dp[i, c]\\) 。</p> <p>待求解的是 \\(dp[n, cap]\\) ，因此需要一個尺寸為 \\((n+1) \\times (cap+1)\\) 的二維 \\(dp\\) 表。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>當我們做出物品 \\(i\\) 的決策後，剩餘的是前 \\(i-1\\) 個物品決策的子問題，可分為以下兩種情況。</p> <ul> <li>不放入物品 \\(i\\) ：背包容量不變，狀態變化為 \\([i-1, c]\\) 。</li> <li>放入物品 \\(i\\) ：背包容量減少 \\(wgt[i-1]\\) ，價值增加 \\(val[i-1]\\) ，狀態變化為 \\([i-1, c-wgt[i-1]]\\) 。</li> </ul> <p>上述分析向我們揭示了本題的最優子結構：最大價值 \\(dp[i, c]\\) 等於不放入物品 \\(i\\) 和放入物品 \\(i\\) 兩種方案中價值更大的那一個。由此可推導出狀態轉移方程：</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>需要注意的是，若當前物品重量 \\(wgt[i - 1]\\) 超出剩餘背包容量 \\(c\\) ，則只能選擇不放入背包。</p> <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當無物品或背包容量為 \\(0\\) 時最大價值為 \\(0\\) ，即首列 \\(dp[i, 0]\\) 和首行 \\(dp[0, c]\\) 都等於 \\(0\\) 。</p> <p>當前狀態 \\([i, c]\\) 從上方的狀態 \\([i-1, c]\\) 和左上方的狀態 \\([i-1, c-wgt[i-1]]\\) 轉移而來，因此透過兩層迴圈正序走訪整個 \\(dp\\) 表即可。</p> <p>根據以上分析，我們接下來按順序實現暴力搜尋、記憶化搜尋、動態規劃解法。</p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1","level":3,"title":"1.   方法一：暴力搜尋","text":"<p>搜尋程式碼包含以下要素。</p> <ul> <li>遞迴參數：狀態 \\([i, c]\\) 。</li> <li>返回值：子問題的解 \\(dp[i, c]\\) 。</li> <li>終止條件：當物品編號越界 \\(i = 0\\) 或背包剩餘容量為 \\(0\\) 時，終止遞迴並返回價值 \\(0\\) 。</li> <li>剪枝：若當前物品重量超出背包剩餘容量，則只能選擇不放入背包。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 背包：暴力搜尋\"\"\"\n    # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 or c == 0:\n        return 0\n    # 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # 計算不放入和放入物品 i 的最大價值\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：暴力搜尋 */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：暴力搜尋 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // 返回兩種方案中價值更大的那一個\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：暴力搜尋 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：暴力搜尋 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：暴力搜尋 */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 若超過背包容量，則只能選擇不放入背包\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // 計算不放入和放入物品 i 的最大價值\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 返回兩種方案中價值更大的那一個\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：暴力搜尋 */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：暴力搜尋 */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：暴力搜尋 ###\ndef knapsack_dfs(wgt, val, i, c)\n  # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  return 0 if i == 0 || c == 0\n  # 若超過背包容量，則只能選擇不放入背包\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # 計算不放入和放入物品 i 的最大價值\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 返回兩種方案中價值更大的那一個\n  [no, yes].max\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-18 所示，由於每個物品都會產生不選和選兩條搜尋分支，因此時間複雜度為 \\(O(2^n)\\) 。</p> <p>觀察遞迴樹，容易發現其中存在重疊子問題，例如 \\(dp[1, 10]\\) 等。而當物品較多、背包容量較大，尤其是相同重量的物品較多時，重疊子問題的數量將會大幅增多。</p> <p></p> <p> 圖 14-18   0-1 背包問題的暴力搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2","level":3,"title":"2.   方法二：記憶化搜尋","text":"<p>為了保證重疊子問題只被計算一次，我們藉助記憶串列 <code>mem</code> 來記錄子問題的解，其中 <code>mem[i][c]</code> 對應 \\(dp[i, c]\\) 。</p> <p>引入記憶化之後，時間複雜度取決於子問題數量，也就是 \\(O(n \\times cap)\\) 。實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 背包：記憶化搜尋\"\"\"\n    # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 or c == 0:\n        return 0\n    # 若已有記錄，則直接返回\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # 計算不放入和放入物品 i 的最大價值\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：記憶化搜尋 */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // 返回兩種方案中價值更大的那一個\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 若已有記錄，則直接返回\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // 若超過背包容量，則只能選擇不放入背包\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // 計算不放入和放入物品 i 的最大價值\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 記錄並返回兩種方案中價值更大的那一個\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：記憶化搜尋 */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：記憶化搜尋 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：記憶化搜尋 ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  return 0 if i == 0 || c == 0\n  # 若已有記錄，則直接返回\n  return mem[i][c] if mem[i][c] != -1\n  # 若超過背包容量，則只能選擇不放入背包\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # 計算不放入和放入物品 i 的最大價值\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 記錄並返回兩種方案中價值更大的那一個\n  mem[i][c] = [no, yes].max\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-19 展示了在記憶化搜尋中被剪掉的搜尋分支。</p> <p></p> <p> 圖 14-19   0-1 背包問題的記憶化搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3","level":3,"title":"3.   方法三：動態規劃","text":"<p>動態規劃實質上就是在狀態轉移中填充 \\(dp\\) 表的過程，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 背包：動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：動態規劃 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：動態規劃 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：動態規劃 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：動態規劃 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：動態規劃 */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：動態規劃 */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：動態規劃 */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：動態規劃 ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-20 所示，時間複雜度和空間複雜度都由陣列 <code>dp</code> 大小決定，即 \\(O(n \\times cap)\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-20   0-1 背包問題的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   空間最佳化","text":"<p>由於每個狀態都只與其上一行的狀態有關，因此我們可以使用兩個陣列滾動前進，將空間複雜度從 \\(O(n^2)\\) 降至 \\(O(n)\\) 。</p> <p>進一步思考，我們能否僅用一個陣列實現空間最佳化呢？觀察可知，每個狀態都是由正上方或左上方的格子轉移過來的。假設只有一個陣列，當開始走訪第 \\(i\\) 行時，該陣列儲存的仍然是第 \\(i-1\\) 行的狀態。</p> <ul> <li>如果採取正序走訪，那麼走訪到 \\(dp[i, j]\\) 時，左上方 \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) 值可能已經被覆蓋，此時就無法得到正確的狀態轉移結果。</li> <li>如果採取倒序走訪，則不會發生覆蓋問題，狀態轉移可以正確進行。</li> </ul> <p>圖 14-21 展示了在單個陣列下從第 \\(i = 1\\) 行轉換至第 \\(i = 2\\) 行的過程。請思考正序走訪和倒序走訪的區別。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-21   0-1 背包的空間最佳化後的動態規劃過程 </p> <p>在程式碼實現中，我們僅需將陣列 <code>dp</code> 的第一維 \\(i\\) 直接刪除，並且把內迴圈更改為倒序走訪即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 背包：空間最佳化後的動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [0] * (cap + 1)\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 倒序走訪\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([]int, cap+1)\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 倒序走訪\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        // 倒序走訪\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(cap + 1).fill(0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(cap + 1).fill(0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    // 倒序走訪\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; cap + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        // 倒序走訪\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = IntArray(cap + 1)\n    // 狀態轉移\n    for (i in 1..n) {\n        // 倒序走訪\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：空間最佳化後的動態規劃 ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(cap + 1, 0)\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 倒序走訪\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[c] = dp[c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   小結","text":"","path":["第 14 章 &nbsp; 動態規劃","14.7 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>動態規劃對問題進行分解，並透過儲存子問題的解來規避重複計算，提高計算效率。</li> <li>不考慮時間的前提下，所有動態規劃問題都可以用回溯（暴力搜尋）進行求解，但遞迴樹中存在大量的重疊子問題，效率極低。透過引入記憶化串列，可以儲存所有計算過的子問題的解，從而保證重疊子問題只被計算一次。</li> <li>記憶化搜尋是一種從頂至底的遞迴式解法，而與之對應的動態規劃是一種從底至頂的遞推式解法，其如同“填寫表格”一樣。由於當前狀態僅依賴某些區域性狀態，因此我們可以消除 \\(dp\\) 表的一個維度，從而降低空間複雜度。</li> <li>子問題分解是一種通用的演算法思路，在分治、動態規劃、回溯中具有不同的性質。</li> <li>動態規劃問題有三大特性：重疊子問題、最優子結構、無後效性。</li> <li>如果原問題的最優解可以從子問題的最優解構建得來，則它就具有最優子結構。</li> <li>無後效性指對於一個狀態，其未來發展只與該狀態有關，而與過去經歷的所有狀態無關。許多組合最佳化問題不具有無後效性，無法使用動態規劃快速求解。</li> </ul> <p>背包問題</p> <ul> <li>背包問題是最典型的動態規劃問題之一，具有 0-1 背包、完全背包、多重背包等變種。</li> <li>0-1 背包的狀態定義為前 \\(i\\) 個物品在容量為 \\(c\\) 的背包中的最大價值。根據不放入背包和放入背包兩種決策，可得到最優子結構，並構建出狀態轉移方程。在空間最佳化中，由於每個狀態依賴正上方和左上方的狀態，因此需要倒序走訪串列，避免左上方狀態被覆蓋。</li> <li>完全背包問題的每種物品的選取數量無限制，因此選擇放入物品的狀態轉移與 0-1 背包問題不同。由於狀態依賴正上方和正左方的狀態，因此在空間最佳化中應當正序走訪。</li> <li>零錢兌換問題是完全背包問題的一個變種。它從求“最大”價值變為求“最小”硬幣數量，因此狀態轉移方程中的 \\(\\max()\\) 應改為 \\(\\min()\\) 。從追求“不超過”背包容量到追求“恰好”湊出目標金額，因此使用 \\(amt + 1\\) 來表示“無法湊出目標金額”的無效解。</li> <li>零錢兌換問題 II 從求“最少硬幣數量”改為求“硬幣組合數量”，狀態轉移方程相應地從 \\(\\min()\\) 改為求和運算子。</li> </ul> <p>編輯距離問題</p> <ul> <li>編輯距離（Levenshtein 距離）用於衡量兩個字串之間的相似度，其定義為從一個字串到另一個字串的最少編輯步數，編輯操作包括新增、刪除、替換。</li> <li>編輯距離問題的狀態定義為將 \\(s\\) 的前 \\(i\\) 個字元更改為 \\(t\\) 的前 \\(j\\) 個字元所需的最少編輯步數。當 \\(s[i] \\ne t[j]\\) 時，具有三種決策：新增、刪除、替換，它們都有相應的剩餘子問題。據此便可以找出最優子結構與構建狀態轉移方程。而當 \\(s[i] = t[j]\\) 時，無須編輯當前字元。</li> <li>在編輯距離中，狀態依賴其正上方、正左方、左上方的狀態，因此空間最佳化後正序或倒序走訪都無法正確地進行狀態轉移。為此，我們利用一個變數暫存左上方狀態，從而轉化到與完全背包問題等價的情況，可以在空間最佳化後進行正序走訪。</li> </ul>","path":["第 14 章 &nbsp; 動態規劃","14.7 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   完全背包問題","text":"<p>在本節中，我們先求解另一個常見的背包問題：完全背包，再瞭解它的一種特例：零錢兌換。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   完全背包問題","text":"<p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品可以重複選取，問在限定背包容量下能放入物品的最大價值。示例如圖 14-22 所示。</p> <p></p> <p> 圖 14-22   完全背包問題的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   動態規劃思路","text":"<p>完全背包問題和 0-1 背包問題非常相似，區別僅在於不限制物品的選擇次數。</p> <ul> <li>在 0-1 背包問題中，每種物品只有一個，因此將物品 \\(i\\) 放入背包後，只能從前 \\(i-1\\) 個物品中選擇。</li> <li>在完全背包問題中，每種物品的數量是無限的，因此將物品 \\(i\\) 放入背包後，仍可以從前 \\(i\\) 個物品中選擇。</li> </ul> <p>在完全背包問題的規定下，狀態 \\([i, c]\\) 的變化分為兩種情況。</p> <ul> <li>不放入物品 \\(i\\) ：與 0-1 背包問題相同，轉移至 \\([i-1, c]\\) 。</li> <li>放入物品 \\(i\\) ：與 0-1 背包問題不同，轉移至 \\([i, c-wgt[i-1]]\\) 。</li> </ul> <p>從而狀態轉移方程變為：</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>對比兩道題目的程式碼，狀態轉移中有一處從 \\(i-1\\) 變為 \\(i\\) ，其餘完全一致：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全背包：動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全背包：動態規劃 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全背包：動態規劃 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全背包：動態規劃 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全背包：動態規劃 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全背包：動態規劃 */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全背包：動態規劃 */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全背包：動態規劃 */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全背包：動態規劃 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   空間最佳化","text":"<p>由於當前狀態是從左邊和上邊的狀態轉移而來的，因此空間最佳化後應該對 \\(dp\\) 表中的每一行進行正序走訪。</p> <p>這個走訪順序與 0-1 背包正好相反。請藉助圖 14-23 來理解兩者的區別。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-23   完全背包問題在空間最佳化後的動態規劃過程 </p> <p>程式碼實現比較簡單，僅需將陣列 <code>dp</code> 的第一維刪除：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全背包：空間最佳化後的動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [0] * (cap + 1)\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([]int, cap+1)\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[c] = dp[c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; cap + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = IntArray(cap + 1)\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全背包：動態規劃 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n### 完全背包：空間最佳化後的動態規劃 ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(cap + 1, 0)\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[c] = dp[c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   零錢兌換問題","text":"<p>背包問題是一大類動態規劃問題的代表，其擁有很多變種，例如零錢兌換問題。</p> <p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 \\(-1\\) 。示例如圖 14-24 所示。</p> <p></p> <p> 圖 14-24   零錢兌換問題的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   動態規劃思路","text":"<p>零錢兌換可以看作完全背包問題的一種特殊情況，兩者具有以下關聯與不同點。</p> <ul> <li>兩道題可以相互轉換，“物品”對應“硬幣”、“物品重量”對應“硬幣面值”、“背包容量”對應“目標金額”。</li> <li>最佳化目標相反，完全背包問題是要最大化物品價值，零錢兌換問題是要最小化硬幣數量。</li> <li>完全背包問題是求“不超過”背包容量下的解，零錢兌換是求“恰好”湊到目標金額的解。</li> </ul> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>狀態 \\([i, a]\\) 對應的子問題為：前 \\(i\\) 種硬幣能夠湊出金額 \\(a\\) 的最少硬幣數量，記為 \\(dp[i, a]\\) 。</p> <p>二維 \\(dp\\) 表的尺寸為 \\((n+1) \\times (amt+1)\\) 。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>本題與完全背包問題的狀態轉移方程存在以下兩點差異。</p> <ul> <li>本題要求最小值，因此需將運算子 \\(\\max()\\) 更改為 \\(\\min()\\) 。</li> <li>最佳化主體是硬幣數量而非商品價值，因此在選中硬幣時執行 \\(+1\\) 即可。</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當目標金額為 \\(0\\) 時，湊出它的最少硬幣數量為 \\(0\\) ，即首列所有 \\(dp[i, 0]\\) 都等於 \\(0\\) 。</p> <p>當無硬幣時，無法湊出任意 \\(&gt; 0\\) 的目標金額，即是無效解。為使狀態轉移方程中的 \\(\\min()\\) 函式能夠識別並過濾無效解，我們考慮使用 \\(+ \\infty\\) 來表示它們，即令首行所有 \\(dp[0, a]\\) 都等於 \\(+ \\infty\\) 。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"<p>大多數程式語言並未提供 \\(+ \\infty\\) 變數，只能使用整型 <code>int</code> 的最大值來代替。而這又會導致大數越界：狀態轉移方程中的 \\(+ 1\\) 操作可能發生溢位。</p> <p>為此，我們採用數字 \\(amt + 1\\) 來表示無效解，因為湊出 \\(amt\\) 的硬幣數量最多為 \\(amt\\) 。最後返回前，判斷 \\(dp[n, amt]\\) 是否等於 \\(amt + 1\\) ，若是則返回 \\(-1\\) ，代表無法湊出目標金額。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：動態規劃\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # 初始化 dp 表\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 狀態轉移：首行首列\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # 狀態轉移：其餘行和列\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][amt + 1];\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* 零錢兌換：動態規劃 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, amt + 1];\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 狀態轉移：首行首列\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 狀態轉移：首行首列\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* 零錢兌換：動態規劃 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* 零錢兌換：動態規劃 */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 狀態轉移：首行首列\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案的較小值\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* 零錢兌換：動態規劃 */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 狀態轉移：首行首列\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* 零錢兌換：動態規劃 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 狀態轉移：首行首列\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### 零錢兌換：動態規劃 ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 狀態轉移：首行首列\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # 狀態轉移：其餘行和列\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 不選和選硬幣 i 這兩種方案的較小值\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-25 展示了零錢兌換的動態規劃過程，和完全背包問題非常相似。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-25   零錢兌換問題的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   空間最佳化","text":"<p>零錢兌換的空間最佳化的處理方式和完全背包問題一致：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：空間最佳化後的動態規劃\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # 初始化 dp 表\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            else:\n                # 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // 初始化 dp 表\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 正序走訪\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // 初始化 dp 表\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案的較小值\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // 初始化 dp 表\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // 初始化 dp 表\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### 零錢兌換：空間最佳化後的動態規劃 ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # 初始化 dp 表\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a]\n      else\n        # 不選和選硬幣 i 這兩種方案的較小值\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   零錢兌換問題 II","text":"<p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問湊出目標金額的硬幣組合數量。示例如圖 14-26 所示。</p> <p></p> <p> 圖 14-26   零錢兌換問題 II 的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   動態規劃思路","text":"<p>相比於上一題，本題目標是求組合數量，因此子問題變為：前 \\(i\\) 種硬幣能夠湊出金額 \\(a\\) 的組合數量。而 \\(dp\\) 表仍然是尺寸為 \\((n+1) \\times (amt + 1)\\) 的二維矩陣。</p> <p>當前狀態的組合數量等於不選當前硬幣與選當前硬幣這兩種決策的組合數量之和。狀態轉移方程為：</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>當目標金額為 \\(0\\) 時，無須選擇任何硬幣即可湊出目標金額，因此應將首列所有 \\(dp[i, 0]\\) 都初始化為 \\(1\\) 。當無硬幣時，無法湊出任何 \\(&gt;0\\) 的目標金額，因此首行所有 \\(dp[0, a]\\) 都等於 \\(0\\) 。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換 II：動態規劃\"\"\"\n    n = len(coins)\n    # 初始化 dp 表\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 初始化首列\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][amt + 1];\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* 零錢兌換 II：動態規劃 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, amt + 1];\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* 零錢兌換 II：動態規劃 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 初始化首列\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* 零錢兌換 II：動態規劃 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 初始化首列\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* 零錢兌換 II：動態規劃 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 初始化首列\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* 零錢兌換 II：動態規劃 */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 初始化首列\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 初始化首列\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案之和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* 零錢兌換 II：動態規劃 */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 初始化首列\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* 零錢兌換 II：動態規劃 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 初始化首列\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### 零錢兌換 II：動態規劃 ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 初始化首列\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 不選和選硬幣 i 這兩種方案之和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   空間最佳化","text":"<p>空間最佳化處理方式相同，刪除硬幣維度即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換 II：空間最佳化後的動態規劃\"\"\"\n    n = len(coins)\n    # 初始化 dp 表\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            else:\n                # 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // 初始化 dp 表\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 正序走訪\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案之和\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // 初始化 dp 表\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // 初始化 dp 表\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### 零錢兌換 II：空間最佳化後的動態規劃 ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # 初始化 dp 表\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a]\n      else\n        # 不選和選硬幣 i 這兩種方案之和\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"第 9 章   圖","text":"<p>Abstract</p> <p>在生命旅途中，我們就像是一個個節點，被無數看不見的邊相連。</p> <p>每一次的相識與相離，都在這張巨大的網路圖中留下獨特的印記。</p>","path":["第 9 章 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"本章內容","text":"<ul> <li>9.1   圖</li> <li>9.2   圖基礎操作</li> <li>9.3   圖的走訪</li> <li>9.4   小結</li> </ul>","path":["第 9 章 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   圖","text":"<p>圖（graph）是一種非線性資料結構，由頂點（vertex）和邊（edge）組成。我們可以將圖 \\(G\\) 抽象地表示為一組頂點 \\(V\\) 和一組邊 \\(E\\) 的集合。以下示例展示了一個包含 5 個頂點和 7 條邊的圖。</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>如果將頂點看作節點，將邊看作連線各個節點的引用（指標），我們就可以將圖看作一種從鏈結串列拓展而來的資料結構。如圖 9-1 所示，相較於線性關係（鏈結串列）和分治關係（樹），網路關係（圖）的自由度更高，因而更為複雜。</p> <p></p> <p> 圖 9-1   鏈結串列、樹、圖之間的關係 </p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   圖的常見型別與術語","text":"<p>根據邊是否具有方向，可分為無向圖（undirected graph）和有向圖（directed graph），如圖 9-2 所示。</p> <ul> <li>在無向圖中，邊表示兩頂點之間的“雙向”連線關係，例如微信或 QQ 中的“好友關係”。</li> <li>在有向圖中，邊具有方向性，即 \\(A \\rightarrow B\\) 和 \\(A \\leftarrow B\\) 兩個方向的邊是相互獨立的，例如微博或抖音上的“關注”與“被關注”關係。</li> </ul> <p></p> <p> 圖 9-2   有向圖與無向圖 </p> <p>根據所有頂點是否連通，可分為連通圖（connected graph）和非連通圖（disconnected graph），如圖 9-3 所示。</p> <ul> <li>對於連通圖，從某個頂點出發，可以到達其餘任意頂點。</li> <li>對於非連通圖，從某個頂點出發，至少有一個頂點無法到達。</li> </ul> <p></p> <p> 圖 9-3   連通圖與非連通圖 </p> <p>我們還可以為邊新增“權重”變數，從而得到如圖 9-4 所示的有權圖（weighted graph）。例如在《王者榮耀》等手遊中，系統會根據共同遊戲時間來計算玩家之間的“親密度”，這種親密度網路就可以用有權圖來表示。</p> <p></p> <p> 圖 9-4   有權圖與無權圖 </p> <p>圖資料結構包含以下常用術語。</p> <ul> <li>鄰接（adjacency）：當兩頂點之間存在邊相連時，稱這兩頂點“鄰接”。在圖 9-4 中，頂點 1 的鄰接頂點為頂點 2、3、5。</li> <li>路徑（path）：從頂點 A 到頂點 B 經過的邊構成的序列被稱為從 A 到 B 的“路徑”。在圖 9-4 中，邊序列 1-5-2-4 是頂點 1 到頂點 4 的一條路徑。</li> <li>度（degree）：一個頂點擁有的邊數。對於有向圖，入度（in-degree）表示有多少條邊指向該頂點，出度（out-degree）表示有多少條邊從該頂點指出。</li> </ul>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   圖的表示","text":"<p>圖的常用表示方式包括“鄰接矩陣”和“鄰接表”。以下使用無向圖進行舉例。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   鄰接矩陣","text":"<p>設圖的頂點數量為 \\(n\\) ，鄰接矩陣（adjacency matrix）使用一個 \\(n \\times n\\) 大小的矩陣來表示圖，每一行（列）代表一個頂點，矩陣元素代表邊，用 \\(1\\) 或 \\(0\\) 表示兩個頂點之間是否存在邊。</p> <p>如圖 9-5 所示，設鄰接矩陣為 \\(M\\)、頂點串列為 \\(V\\) ，那麼矩陣元素 \\(M[i, j] = 1\\) 表示頂點 \\(V[i]\\) 到頂點 \\(V[j]\\) 之間存在邊，反之 \\(M[i, j] = 0\\) 表示兩頂點之間無邊。</p> <p></p> <p> 圖 9-5   圖的鄰接矩陣表示 </p> <p>鄰接矩陣具有以下特性。</p> <ul> <li>在簡單圖中，頂點不能與自身相連，此時鄰接矩陣主對角線元素沒有意義。</li> <li>對於無向圖，兩個方向的邊等價，此時鄰接矩陣關於主對角線對稱。</li> <li>將鄰接矩陣的元素從 \\(1\\) 和 \\(0\\) 替換為權重，則可表示有權圖。</li> </ul> <p>使用鄰接矩陣表示圖時，我們可以直接訪問矩陣元素以獲取邊，因此增刪查改操作的效率很高，時間複雜度均為 \\(O(1)\\) 。然而，矩陣的空間複雜度為 \\(O(n^2)\\) ，記憶體佔用較多。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   鄰接表","text":"<p>鄰接表（adjacency list）使用 \\(n\\) 個鏈結串列來表示圖，鏈結串列節點表示頂點。第 \\(i\\) 個鏈結串列對應頂點 \\(i\\) ，其中儲存了該頂點的所有鄰接頂點（與該頂點相連的頂點）。圖 9-6 展示了一個使用鄰接表儲存的圖的示例。</p> <p></p> <p> 圖 9-6   圖的鄰接表表示 </p> <p>鄰接表僅儲存實際存在的邊，而邊的總數通常遠小於 \\(n^2\\) ，因此它更加節省空間。然而，在鄰接表中需要透過走訪鏈結串列來查詢邊，因此其時間效率不如鄰接矩陣。</p> <p>觀察圖 9-6 ，鄰接表結構與雜湊表中的“鏈式位址”非常相似，因此我們也可以採用類似的方法來最佳化效率。比如當鏈結串列較長時，可以將鏈結串列轉化為 AVL 樹或紅黑樹，從而將時間效率從 \\(O(n)\\) 最佳化至 \\(O(\\log n)\\) ；還可以把鏈結串列轉換為雜湊表，從而將時間複雜度降至 \\(O(1)\\) 。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   圖的常見應用","text":"<p>如表 9-1 所示，許多現實系統可以用圖來建模，相應的問題也可以約化為圖計算問題。</p> <p> 表 9-1   現實生活中常見的圖 </p> 頂點 邊 圖計算問題 社交網路 使用者 好友關係 潛在好友推薦 地鐵線路 站點 站點間的連通性 最短路線推薦 太陽系 星體 星體間的萬有引力作用 行星軌道計算","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   圖的基礎操作","text":"<p>圖的基礎操作可分為對“邊”的操作和對“頂點”的操作。在“鄰接矩陣”和“鄰接表”兩種表示方法下，實現方式有所不同。</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   基於鄰接矩陣的實現","text":"<p>給定一個頂點數量為 \\(n\\) 的無向圖，則各種操作的實現方式如圖 9-7 所示。</p> <ul> <li>新增或刪除邊：直接在鄰接矩陣中修改指定的邊即可，使用 \\(O(1)\\) 時間。而由於是無向圖，因此需要同時更新兩個方向的邊。</li> <li>新增頂點：在鄰接矩陣的尾部新增一行一列，並全部填 \\(0\\) 即可，使用 \\(O(n)\\) 時間。</li> <li>刪除頂點：在鄰接矩陣中刪除一行一列。當刪除首行首列時達到最差情況，需要將 \\((n-1)^2\\) 個元素“向左上移動”，從而使用 \\(O(n^2)\\) 時間。</li> <li>初始化：傳入 \\(n\\) 個頂點，初始化長度為 \\(n\\) 的頂點串列 <code>vertices</code> ，使用 \\(O(n)\\) 時間；初始化 \\(n \\times n\\) 大小的鄰接矩陣 <code>adjMat</code> ，使用 \\(O(n^2)\\) 時間。</li> </ul> 初始化鄰接矩陣新增邊刪除邊新增頂點刪除頂點 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-7   鄰接矩陣的初始化、增刪邊、增刪頂點 </p> <p>以下是基於鄰接矩陣表示圖的實現程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"基於鄰接矩陣實現的無向圖類別\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"建構子\"\"\"\n        # 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n        self.vertices: list[int] = []\n        # 鄰接矩陣，行列索引對應“頂點索引”\n        self.adj_mat: list[list[int]] = []\n        # 新增頂點\n        for val in vertices:\n            self.add_vertex(val)\n        # 新增邊\n        # 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"獲取頂點數量\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"新增頂點\"\"\"\n        n = self.size()\n        # 向頂點串列中新增新頂點的值\n        self.vertices.append(val)\n        # 在鄰接矩陣中新增一行\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # 在鄰接矩陣中新增一列\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"刪除頂點\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # 在頂點串列中移除索引 index 的頂點\n        self.vertices.pop(index)\n        # 在鄰接矩陣中刪除索引 index 的行\n        self.adj_mat.pop(index)\n        # 在鄰接矩陣中刪除索引 index 的列\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"新增邊\"\"\"\n        # 參數 i, j 對應 vertices 元素索引\n        # 索引越界與相等處理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"刪除邊\"\"\"\n        # 參數 i, j 對應 vertices 元素索引\n        # 索引越界與相等處理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"列印鄰接矩陣\"\"\"\n        print(\"頂點串列 =\", self.vertices)\n        print(\"鄰接矩陣 =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n  public:\n    /* 建構子 */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // 新增頂點\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* 新增頂點 */\n    void addVertex(int val) {\n        int n = size();\n        // 向頂點串列中新增新頂點的值\n        vertices.push_back(val);\n        // 在鄰接矩陣中新增一行\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // 在鄰接矩陣中新增一列\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.erase(vertices.begin() + index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.erase(adjMat.begin() + index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    void addEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    void removeEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    void print() {\n        cout &lt;&lt; \"頂點串列 = \";\n        printVector(vertices);\n        cout &lt;&lt; \"鄰接矩陣 =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // 新增頂點\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* 新增頂點 */\n    public void addVertex(int val) {\n        int n = size();\n        // 向頂點串列中新增新頂點的值\n        vertices.add(val);\n        // 在鄰接矩陣中新增一行\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // 在鄰接矩陣中新增一列\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void addEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void removeEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* 列印鄰接矩陣 */\n    public void print() {\n        System.out.print(\"頂點串列 = \");\n        System.out.println(vertices);\n        System.out.println(\"鄰接矩陣 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    List&lt;List&lt;int&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* 新增頂點 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // 向頂點串列中新增新頂點的值\n        vertices.Add(val);\n        // 在鄰接矩陣中新增一行\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // 在鄰接矩陣中新增一列\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.RemoveAt(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.RemoveAt(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void AddEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void RemoveEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    public void Print() {\n        Console.Write(\"頂點串列 = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"鄰接矩陣 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\ntype graphAdjMat struct {\n    // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    vertices []int\n    // 鄰接矩陣，行列索引對應“頂點索引”\n    adjMat [][]int\n}\n\n/* 建構子 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // 新增頂點\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // 初始化圖\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // 新增邊\n    // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* 獲取頂點數量 */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* 新增頂點 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // 向頂點串列中新增新頂點的值\n    g.vertices = append(g.vertices, val)\n    // 在鄰接矩陣中新增一行\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // 在鄰接矩陣中新增一列\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* 刪除頂點 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // 在鄰接矩陣中刪除索引 index 的行\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // 在鄰接矩陣中刪除索引 index 的列\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* 新增邊 */\n// 參數 i, j 對應 vertices 元素索引\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* 刪除邊 */\n// 參數 i, j 對應 vertices 元素索引\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* 列印鄰接矩陣 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t頂點串列 = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t鄰接矩陣 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    private var vertices: [Int] // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    private var adjMat: [[Int]] // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // 新增頂點\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* 新增頂點 */\n    func addVertex(val: Int) {\n        let n = size()\n        // 向頂點串列中新增新頂點的值\n        vertices.append(val)\n        // 在鄰接矩陣中新增一行\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // 在鄰接矩陣中新增一列\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* 刪除頂點 */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"越界\")\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.remove(at: index)\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.remove(at: index)\n        // 在鄰接矩陣中刪除索引 index 的列\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    func addEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"越界\")\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    func removeEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"越界\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 列印鄰接矩陣 */\n    func print() {\n        Swift.print(\"頂點串列 = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"鄰接矩陣 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* 新增頂點 */\n    addVertex(val) {\n        const n = this.size();\n        // 向頂點串列中新增新頂點的值\n        this.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 在鄰接矩陣中新增一列\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        this.vertices.splice(index, 1);\n\n        // 在鄰接矩陣中刪除索引 index 的行\n        this.adjMat.splice(index, 1);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    addEdge(i, j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    removeEdge(i, j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    print() {\n        console.log('頂點串列 = ', this.vertices);\n        console.log('鄰接矩陣 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vertices: number[]; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    adjMat: number[][]; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* 新增頂點 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // 向頂點串列中新增新頂點的值\n        this.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 在鄰接矩陣中新增一列\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        this.vertices.splice(index, 1);\n\n        // 在鄰接矩陣中刪除索引 index 的行\n        this.adjMat.splice(index, 1);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    addEdge(i: number, j: number): void {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    removeEdge(i: number, j: number): void {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    print(): void {\n        console.log('頂點串列 = ', this.vertices);\n        console.log('鄰接矩陣 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // 頂點元素，元素代表“頂點值”，索引代表“頂點索引”\n  List&lt;List&lt;int&gt;&gt; adjMat = []; //鄰接矩陣，行列索引對應“頂點索引”\n\n  /* 建構子 */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // 新增頂點\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // 新增邊\n    // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* 獲取頂點數量 */\n  int size() {\n    return vertices.length;\n  }\n\n  /* 新增頂點 */\n  void addVertex(int val) {\n    int n = size();\n    // 向頂點串列中新增新頂點的值\n    vertices.add(val);\n    // 在鄰接矩陣中新增一行\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // 在鄰接矩陣中新增一列\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* 刪除頂點 */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    vertices.removeAt(index);\n    // 在鄰接矩陣中刪除索引 index 的行\n    adjMat.removeAt(index);\n    // 在鄰接矩陣中刪除索引 index 的列\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* 新增邊 */\n  // 參數 i, j 對應 vertices 元素索引\n  void addEdge(int i, int j) {\n    // 索引越界與相等處理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* 刪除邊 */\n  // 參數 i, j 對應 vertices 元素索引\n  void removeEdge(int i, int j) {\n    // 索引越界與相等處理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* 列印鄰接矩陣 */\n  void printAdjMat() {\n    print(\"頂點串列 = $vertices\");\n    print(\"鄰接矩陣 = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* 基於鄰接矩陣實現的無向圖型別 */\npub struct GraphAdjMat {\n    // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    pub vertices: Vec&lt;i32&gt;,\n    // 鄰接矩陣，行列索引對應“頂點索引”\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* 建構子 */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // 新增頂點\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* 獲取頂點數量 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* 新增頂點 */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // 向頂點串列中新增新頂點的值\n        self.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        self.adj_mat.push(vec![0; n]);\n        // 在鄰接矩陣中新增一列\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        self.vertices.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        self.adj_mat.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* 新增邊 */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // 參數 i, j 對應 vertices 元素索引\n        // 索引越界與相等處理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // 參數 i, j 對應 vertices 元素索引\n        // 索引越界與相等處理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    pub fn print(&amp;self) {\n        println!(\"頂點串列 = {:?}\", self.vertices);\n        println!(\"鄰接矩陣 =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* 基於鄰接矩陣實現的無向圖結構體 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* 建構子 */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* 析構函式 */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* 新增頂點 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"圖的頂點數量已達最大值\\n\");\n        return;\n    }\n    // 新增第 n 個頂點，並將第 n 行和列置零\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* 刪除頂點 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"頂點索引越界\\n\");\n        return;\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // 在鄰接矩陣中刪除索引 index 的行\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // 在鄰接矩陣中刪除索引 index 的列\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* 新增邊 */\n// 參數 i, j 對應 vertices 元素索引\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"邊索引越界或相等\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* 刪除邊 */\n// 參數 i, j 對應 vertices 元素索引\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"邊索引越界或相等\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* 列印鄰接矩陣 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"頂點串列 = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"鄰接矩陣 =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    init {\n        // 新增頂點\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* 新增頂點 */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // 向頂點串列中新增新頂點的值\n        vertices.add(_val)\n        // 在鄰接矩陣中新增一行\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // 在鄰接矩陣中新增一列\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* 刪除頂點 */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.removeAt(index)\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.removeAt(index)\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    fun addEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    fun removeEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 列印鄰接矩陣 */\n    fun print() {\n        print(\"頂點串列 = \")\n        println(vertices)\n        println(\"鄰接矩陣 =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### 基於鄰接矩陣實現的無向圖類別 ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### 建構子 ###\n    # 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    @vertices = []\n    # 鄰接矩陣，行列索引對應“頂點索引”\n    @adj_mat = []\n    # 新增頂點\n    vertices.each { |val| add_vertex(val) }\n    # 新增邊\n    # 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### 獲取頂點數量 ###\n  def size\n    @vertices.length\n  end\n\n  ### 新增頂點 ###\n  def add_vertex(val)\n    n = size\n    # 向頂點串列中新增新頂點的值\n    @vertices &lt;&lt; val\n    # 在鄰接矩陣中新增一行\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # 在鄰接矩陣中新增一列\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### 刪除頂點 ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # 在頂點串列中移除索引 index 的頂點\n    @vertices.delete_at(index)\n    # 在鄰接矩陣中刪除索引 index 的行\n    @adj_mat.delete_at(index)\n    # 在鄰接矩陣中刪除索引 index 的列\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### 新增邊 ###\n  def add_edge(i, j)\n    # 參數 i, j 對應 vertices 元素索引\n    # 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### 刪除邊 ###\n  def remove_edge(i, j)\n    # 參數 i, j 對應 vertices 元素索引\n    # 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### 列印鄰接矩陣 ###\n  def __print__\n    puts \"頂點串列 = #{@vertices}\"\n    puts '鄰接矩陣 ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   基於鄰接表的實現","text":"<p>設無向圖的頂點總數為 \\(n\\)、邊總數為 \\(m\\) ，則可根據圖 9-8 所示的方法實現各種操作。</p> <ul> <li>新增邊：在頂點對應鏈結串列的末尾新增邊即可，使用 \\(O(1)\\) 時間。因為是無向圖，所以需要同時新增兩個方向的邊。</li> <li>刪除邊：在頂點對應鏈結串列中查詢並刪除指定邊，使用 \\(O(m)\\) 時間。在無向圖中，需要同時刪除兩個方向的邊。</li> <li>新增頂點：在鄰接表中新增一個鏈結串列，並將新增頂點作為鏈結串列頭節點，使用 \\(O(1)\\) 時間。</li> <li>刪除頂點：需走訪整個鄰接表，刪除包含指定頂點的所有邊，使用 \\(O(n + m)\\) 時間。</li> <li>初始化：在鄰接表中建立 \\(n\\) 個頂點和 \\(2m\\) 條邊，使用 \\(O(n + m)\\) 時間。</li> </ul> 初始化鄰接表新增邊刪除邊新增頂點刪除頂點 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-8   鄰接表的初始化、增刪邊、增刪頂點 </p> <p>以下是鄰接表的程式碼實現。對比圖 9-8 ，實際程式碼有以下不同。</p> <ul> <li>為了方便新增與刪除頂點，以及簡化程式碼，我們使用串列（動態陣列）來代替鏈結串列。</li> <li>使用雜湊表來儲存鄰接表，<code>key</code> 為頂點例項，<code>value</code> 為該頂點的鄰接頂點串列（鏈結串列）。</li> </ul> <p>另外，我們在鄰接表中使用 <code>Vertex</code> 類別來表示頂點，這樣做的原因是：如果與鄰接矩陣一樣，用串列索引來區分不同頂點，那麼假設要刪除索引為 \\(i\\) 的頂點，則需走訪整個鄰接表，將所有大於 \\(i\\) 的索引全部減 \\(1\\) ，效率很低。而如果每個頂點都是唯一的 <code>Vertex</code> 例項，刪除某一頂點之後就無須改動其他頂點了。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"基於鄰接表實現的無向圖類別\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"建構子\"\"\"\n        # 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # 新增所有頂點和邊\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"獲取頂點數量\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"新增邊\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 新增邊 vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"刪除邊\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 刪除邊 vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"新增頂點\"\"\"\n        if vet in self.adj_list:\n            return\n        # 在鄰接表中新增一個新鏈結串列\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"刪除頂點\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        self.adj_list.pop(vet)\n        # 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"列印鄰接表\"\"\"\n        print(\"鄰接表 =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n  public:\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* 在 vector 中刪除指定節點 */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* 建構子 */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // 新增所有頂點和邊\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int size() {\n        return adjList.size();\n    }\n\n    /* 新增邊 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"不存在頂點\");\n        // 新增邊 vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* 刪除邊 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"不存在頂點\");\n        // 刪除邊 vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* 新增頂點 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* 刪除頂點 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"不存在頂點\");\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.erase(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    void print() {\n        cout &lt;&lt; \"鄰接表 =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* 建構子 */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // 新增所有頂點和邊\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* 新增邊 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 新增邊 vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* 刪除邊 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 刪除邊 vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* 新增頂點 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* 刪除頂點 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.remove(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    public void print() {\n        System.out.println(\"鄰接表 =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* 建構子 */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // 新增所有頂點和邊\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* 新增邊 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 新增邊 vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* 刪除邊 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 刪除邊 vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* 新增頂點 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList.Add(vet, []);\n    }\n\n    /* 刪除頂點 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.Remove(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    public void Print() {\n        Console.WriteLine(\"鄰接表 =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* 基於鄰接表實現的無向圖類別 */\ntype graphAdjList struct {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList map[Vertex][]Vertex\n}\n\n/* 建構子 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // 新增所有頂點和邊\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* 獲取頂點數量 */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* 新增邊 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 新增邊 vet1 - vet2, 新增匿名 struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* 刪除邊 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 刪除邊 vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* 新增頂點 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // 在鄰接表中新增一個新鏈結串列\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* 刪除頂點 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    delete(g.adjList, vet)\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* 列印鄰接表 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"鄰接表 = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* 建構子 */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // 新增所有頂點和邊\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* 新增邊 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"參數錯誤\")\n        }\n        // 新增邊 vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* 刪除邊 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"參數錯誤\")\n        }\n        // 刪除邊 vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* 新增頂點 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = []\n    }\n\n    /* 刪除頂點 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"參數錯誤\")\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.removeValue(forKey: vet)\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* 列印鄰接表 */\n    public func print() {\n        Swift.print(\"鄰接表 =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList;\n\n    /* 建構子 */\n    constructor(edges) {\n        this.adjList = new Map();\n        // 新增所有頂點和邊\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* 新增邊 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 新增邊 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 刪除邊 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 刪除邊 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 新增頂點 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // 在鄰接表中新增一個新鏈結串列\n        this.adjList.set(vet, []);\n    }\n\n    /* 刪除頂點 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        this.adjList.delete(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 列印鄰接表 */\n    print() {\n        console.log('鄰接表 =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* 建構子 */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // 新增所有頂點和邊\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* 新增邊 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 新增邊 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 刪除邊 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 刪除邊 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 新增頂點 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // 在鄰接表中新增一個新鏈結串列\n        this.adjList.set(vet, []);\n    }\n\n    /* 刪除頂點 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        this.adjList.delete(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 列印鄰接表 */\n    print(): void {\n        console.log('鄰接表 =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n  // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* 建構子 */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* 獲取頂點數量 */\n  int size() {\n    return adjList.length;\n  }\n\n  /* 新增邊 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 新增邊 vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* 刪除邊 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 刪除邊 vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* 新增頂點 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // 在鄰接表中新增一個新鏈結串列\n    adjList[vet] = [];\n  }\n\n  /* 刪除頂點 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    adjList.remove(vet);\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* 列印鄰接表 */\n  void printAdjList() {\n    print(\"鄰接表 =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* 基於鄰接表實現的無向圖型別 */\npub struct GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* 建構子 */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // 新增所有頂點和邊\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* 獲取頂點數量 */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* 新增邊 */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 新增邊 vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* 刪除邊 */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 刪除邊 vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* 新增頂點 */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // 在鄰接表中新增一個新鏈結串列\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* 刪除頂點 */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        self.adj_list.remove(&amp;vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    pub fn print(&amp;self) {\n        println!(\"鄰接表 =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* 節點結構體 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // 頂點\n    struct AdjListNode *next; // 後繼節點\n} AdjListNode;\n\n/* 查詢頂點對應的節點 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 新增邊輔助函式 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // 頭插法\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* 刪除邊輔助函式 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // 在鏈結串列中搜索 vet 對應節點\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // 將 vet 對應節點從鏈結串列中刪除\n    pre-&gt;next = cur-&gt;next;\n    // 釋放記憶體\n    free(cur);\n}\n\n/* 基於鄰接表實現的無向圖類別 */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // 節點陣列\n    int size;                     // 節點數量\n} GraphAdjList;\n\n/* 建構子 */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* 析構函式 */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* 查詢頂點對應的節點 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 新增邊 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // 新增邊 vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* 刪除邊 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // 刪除邊 vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* 新增頂點 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // 在鄰接表中新增一個新鏈結串列\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* 刪除頂點 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // 將該頂點之後的頂點向前移動，以填補空缺\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* 建構子 */\n    init {\n        // 新增所有頂點和邊\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* 獲取頂點數量 */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* 新增邊 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 新增邊 vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* 刪除邊 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 刪除邊 vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* 新增頂點 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = mutableListOf()\n    }\n\n    /* 刪除頂點 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.remove(vet)\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* 列印鄰接表 */\n    fun print() {\n        println(\"鄰接表 =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### 基於鄰接表實現的無向圖類別 ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### 建構子 ###\n  def initialize(edges)\n    # 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    @adj_list = {}\n    # 新增所有頂點和邊\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### 獲取頂點數量 ###\n  def size\n    @adj_list.length\n  end\n\n  ### 新增邊 ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### 刪除邊 ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # 刪除邊 vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### 新增頂點 ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # 在鄰接表中新增一個新鏈結串列\n    @adj_list[vet] = []\n  end\n\n  ### 刪除頂點 ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    @adj_list.delete(vet)\n    # 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### 列印鄰接表 ###\n  def __print__\n    puts '鄰接表 ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   效率對比","text":"<p>設圖中共有 \\(n\\) 個頂點和 \\(m\\) 條邊，表 9-2 對比了鄰接矩陣和鄰接表的時間效率和空間效率。請注意，鄰接表（鏈結串列）對應本文實現，而鄰接表（雜湊表）專指將所有鏈結串列替換為雜湊表後的實現。</p> <p> 表 9-2   鄰接矩陣與鄰接表對比 </p> 鄰接矩陣 鄰接表（鏈結串列） 鄰接表（雜湊表） 判斷是否鄰接 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 新增邊 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 刪除邊 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 新增頂點 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) 刪除頂點 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) 記憶體空間佔用 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>觀察表 9-2 ，似乎鄰接表（雜湊表）的時間效率與空間效率最優。但實際上，在鄰接矩陣中操作邊的效率更高，只需一次陣列訪問或賦值操作即可。綜合來看，鄰接矩陣體現了“以空間換時間”的原則，而鄰接表體現了“以時間換空間”的原則。</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   圖的走訪","text":"<p>樹代表的是“一對多”的關係，而圖則具有更高的自由度，可以表示任意的“多對多”關係。因此，我們可以把樹看作圖的一種特例。顯然，樹的走訪操作也是圖的走訪操作的一種特例。</p> <p>圖和樹都需要應用搜索演算法來實現走訪操作。圖的走訪方式也可分為兩種：廣度優先走訪和深度優先走訪。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   廣度優先走訪","text":"<p>廣度優先走訪是一種由近及遠的走訪方式，從某個節點出發，始終優先訪問距離最近的頂點，並一層層向外擴張。如圖 9-9 所示，從左上角頂點出發，首先走訪該頂點的所有鄰接頂點，然後走訪下一個頂點的所有鄰接頂點，以此類推，直至所有頂點訪問完畢。</p> <p></p> <p> 圖 9-9   圖的廣度優先走訪 </p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   演算法實現","text":"<p>BFS 通常藉助佇列來實現，程式碼如下所示。佇列具有“先入先出”的性質，這與 BFS 的“由近及遠”的思想異曲同工。</p> <ol> <li>將走訪起始頂點 <code>startVet</code> 加入佇列，並開啟迴圈。</li> <li>在迴圈的每輪迭代中，彈出佇列首頂點並記錄訪問，然後將該頂點的所有鄰接頂點加入到佇列尾部。</li> <li>迴圈步驟 <code>2.</code> ，直到所有頂點被訪問完畢後結束。</li> </ol> <p>為了防止重複走訪頂點，我們需要藉助一個雜湊集合 <code>visited</code> 來記錄哪些節點已被訪問。</p> <p>Tip</p> <p>雜湊集合可以看作一個只儲存 <code>key</code> 而不儲存 <code>value</code> 的雜湊表，它可以在 \\(O(1)\\) 時間複雜度下進行 <code>key</code> 的增刪查改操作。根據 <code>key</code> 的唯一性，雜湊集合通常用於資料去重等場景。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"廣度優先走訪\"\"\"\n    # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n    # 頂點走訪序列\n    res = []\n    # 雜湊集合，用於記錄已被訪問過的頂點\n    visited = set[Vertex]([start_vet])\n    # 佇列用於實現 BFS\n    que = deque[Vertex]([start_vet])\n    # 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while len(que) &gt; 0:\n        vet = que.popleft()  # 佇列首頂點出隊\n        res.append(vet)  # 記錄訪問頂點\n        # 走訪該頂點的所有鄰接頂點\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # 跳過已被訪問的頂點\n            que.append(adj_vet)  # 只入列未訪問的頂點\n            visited.add(adj_vet)  # 標記該頂點已被訪問\n    # 返回頂點走訪序列\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂點走訪序列\n    vector&lt;Vertex *&gt; res;\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // 佇列用於實現 BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // 佇列首頂點出隊\n        res.push_back(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // 跳過已被訪問的頂點\n            que.push(adjVet);        // 只入列未訪問的頂點\n            visited.emplace(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // 佇列首頂點出隊\n        res.add(vet);            // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // 跳過已被訪問的頂點\n            que.offer(adjVet);   // 只入列未訪問的頂點\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // 佇列用於實現 BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // 佇列首頂點出隊\n        res.Add(vet);               // 記錄訪問頂點\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // 跳過已被訪問的頂點\n            }\n            que.Enqueue(adjVet);   // 只入列未訪問的頂點\n            visited.Add(adjVet);   // 標記該頂點已被訪問\n        }\n    }\n\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂點走訪序列\n    res := make([]Vertex, 0)\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // 佇列用於實現 BFS, 使用切片模擬佇列\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    for len(queue) &gt; 0 {\n        // 佇列首頂點出隊\n        vet := queue[0]\n        queue = queue[1:]\n        // 記錄訪問頂點\n        res = append(res, vet)\n        // 走訪該頂點的所有鄰接頂點\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // 只入列未訪問的頂點\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂點走訪序列\n    var res: [Vertex] = []\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // 佇列用於實現 BFS\n    var que: [Vertex] = [startVet]\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while !que.isEmpty {\n        let vet = que.removeFirst() // 佇列首頂點出隊\n        res.append(vet) // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // 跳過已被訪問的頂點\n            }\n            que.append(adjVet) // 只入列未訪問的頂點\n            visited.insert(adjVet) // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphBFS(graph, startVet) {\n    // 頂點走訪序列\n    const res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited = new Set();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    const que = [startVet];\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.length) {\n        const vet = que.shift(); // 佇列首頂點出隊\n        res.push(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 跳過已被訪問的頂點\n            }\n            que.push(adjVet); // 只入列未訪問的頂點\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂點走訪序列\n    const res: Vertex[] = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    const que = [startVet];\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.length) {\n        const vet = que.shift(); // 佇列首頂點出隊\n        res.push(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 跳過已被訪問的頂點\n            }\n            que.push(adjVet); // 只入列未訪問\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* 廣度優先走訪 */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  // 頂點走訪序列\n  List&lt;Vertex&gt; res = [];\n  // 雜湊集合，用於記錄已被訪問過的頂點\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // 佇列用於實現 BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // 佇列首頂點出隊\n    res.add(vet); // 記錄訪問頂點\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // 跳過已被訪問的頂點\n      }\n      que.add(adjVet); // 只入列未訪問的頂點\n      visited.add(adjVet); // 標記該頂點已被訪問\n    }\n  }\n  // 返回頂點走訪序列\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂點走訪序列\n    let mut res = vec![];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // 佇列用於實現 BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // 記錄訪問頂點\n\n        // 走訪該頂點的所有鄰接頂點\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // 跳過已被訪問的頂點\n                }\n                que.push_back(adj_vet); // 只入列未訪問的頂點\n                visited.insert(adj_vet); // 標記該頂點已被訪問\n            }\n        }\n    }\n    // 返回頂點走訪序列\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* 節點佇列結構體 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* 建構子 */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* 判斷佇列是否為空 */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* 入列操作 */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* 出列操作 */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* 檢查頂點是否已被訪問 */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // 走訪查詢節點，使用 O(n) 時間\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // 佇列用於實現 BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // 佇列首頂點出隊\n        res[(*resSize)++] = vet;      // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // 跳過已被訪問的頂點\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // 只入列未訪問的頂點\n                visited[(*visitedSize)++] = node-&gt;vertex; // 標記該頂點已被訪問\n            }\n            node = node-&gt;next;\n        }\n    }\n    // 釋放記憶體\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // 頂點走訪序列\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // 佇列用於實現 BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.isEmpty()) {\n        val vet = que.poll() // 佇列首頂點出隊\n        res.add(vet)         // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // 跳過已被訪問的頂點\n            que.offer(adjVet)   // 只入列未訪問的頂點\n            visited.add(adjVet) // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### 廣度優先走訪 ###\ndef graph_bfs(graph, start_vet)\n  # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  # 頂點走訪序列\n  res = []\n  # 雜湊集合，用於記錄已被訪問過的頂點\n  visited = Set.new([start_vet])\n  # 佇列用於實現 BFS\n  que = [start_vet]\n  # 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n  while que.length &gt; 0\n    vet = que.shift # 佇列首頂點出隊\n    res &lt;&lt; vet # 記錄訪問頂點\n    # 走訪該頂點的所有鄰接頂點\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # 跳過已被訪問的頂點\n      que &lt;&lt; adj_vet # 只入列未訪問的頂點\n      visited.add(adj_vet) # 標記該頂點已被訪問\n    end\n  end\n  # 返回頂點走訪序列\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>程式碼相對抽象，建議對照圖 9-10 來加深理解。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-10   圖的廣度優先走訪步驟 </p> <p>廣度優先走訪的序列是否唯一？</p> <p>不唯一。廣度優先走訪只要求按“由近及遠”的順序走訪，而多個相同距離的頂點的走訪順序允許被任意打亂。以圖 9-10 為例，頂點 \\(1\\)、\\(3\\) 的訪問順序可以交換，頂點 \\(2\\)、\\(4\\)、\\(6\\) 的訪問順序也可以任意交換。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   複雜度分析","text":"<p>時間複雜度：所有頂點都會入列並出隊一次，使用 \\(O(|V|)\\) 時間；在走訪鄰接頂點的過程中，由於是無向圖，因此所有邊都會被訪問 \\(2\\) 次，使用 \\(O(2|E|)\\) 時間；總體使用 \\(O(|V| + |E|)\\) 時間。</p> <p>空間複雜度：串列 <code>res</code> ，雜湊集合 <code>visited</code> ，佇列 <code>que</code> 中的頂點數量最多為 \\(|V|\\) ，使用 \\(O(|V|)\\) 空間。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   深度優先走訪","text":"<p>深度優先走訪是一種優先走到底、無路可走再回頭的走訪方式。如圖 9-11 所示，從左上角頂點出發，訪問當前頂點的某個鄰接頂點，直到走到盡頭時返回，再繼續走到盡頭並返回，以此類推，直至所有頂點走訪完成。</p> <p></p> <p> 圖 9-11   圖的深度優先走訪 </p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   演算法實現","text":"<p>這種“走到盡頭再返回”的演算法範式通常基於遞迴來實現。與廣度優先走訪類似，在深度優先走訪中，我們也需要藉助一個雜湊集合 <code>visited</code> 來記錄已被訪問的頂點，以避免重複訪問頂點。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"深度優先走訪輔助函式\"\"\"\n    res.append(vet)  # 記錄訪問頂點\n    visited.add(vet)  # 標記該頂點已被訪問\n    # 走訪該頂點的所有鄰接頂點\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # 跳過已被訪問的頂點\n        # 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"深度優先走訪\"\"\"\n    # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n    # 頂點走訪序列\n    res = []\n    # 雜湊集合，用於記錄已被訪問過的頂點\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // 記錄訪問頂點\n    visited.emplace(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂點走訪序列\n    vector&lt;Vertex *&gt; res;\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* 深度優先走訪輔助函式 */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // 記錄訪問頂點\n    visited.Add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // 跳過已被訪問的頂點                             \n        }\n        // 遞迴訪問鄰接頂點\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* 深度優先走訪輔助函式 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append 操作會返回新的的引用，必須讓原引用重新賦值為新slice的引用\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // 走訪該頂點的所有鄰接頂點\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // 遞迴訪問鄰接頂點\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂點走訪序列\n    res := make([]Vertex, 0)\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* 深度優先走訪輔助函式 */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // 記錄訪問頂點\n    visited.insert(vet) // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂點走訪序列\n    var res: [Vertex] = []\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphDFS(graph, startVet) {\n    // 頂點走訪序列\n    const res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* 深度優先走訪輔助函式 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂點走訪序列\n    const res: Vertex[] = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // 記錄訪問頂點\n  visited.add(vet); // 標記該頂點已被訪問\n  // 走訪該頂點的所有鄰接頂點\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // 跳過已被訪問的頂點\n    }\n    // 遞迴訪問鄰接頂點\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* 深度優先走訪 */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // 頂點走訪序列\n  List&lt;Vertex&gt; res = [];\n  // 雜湊集合，用於記錄已被訪問過的頂點\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* 深度優先走訪輔助函式 */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // 記錄訪問頂點\n    visited.insert(vet); // 標記該頂點已被訪問\n                         // 走訪該頂點的所有鄰接頂點\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // 跳過已被訪問的頂點\n            }\n            // 遞迴訪問鄰接頂點\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂點走訪序列\n    let mut res = vec![];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* 檢查頂點是否已被訪問 */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // 走訪查詢節點，使用 O(n) 時間\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // 記錄訪問頂點\n    res[(*resSize)++] = vet;\n    // 走訪該頂點的所有鄰接頂點\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // 跳過已被訪問的頂點\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // 遞迴訪問鄰接頂點\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* 深度優先走訪輔助函式 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // 記錄訪問頂點\n    visited.add(vet) // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // 頂點走訪序列\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### 深度優先走訪輔助函式 ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # 記錄訪問頂點\n  visited.add(vet) # 標記該頂點已被訪問\n  # 走訪該頂點的所有鄰接頂點\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # 跳過已被訪問的頂點\n    # 遞迴訪問鄰接頂點\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### 深度優先走訪 ###\ndef graph_dfs(graph, start_vet)\n  # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  # 頂點走訪序列\n  res = []\n  # 雜湊集合，用於記錄已被訪問過的頂點\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>深度優先走訪的演算法流程如圖 9-12 所示。</p> <ul> <li>直虛線代表向下遞推，表示開啟了一個新的遞迴方法來訪問新頂點。</li> <li>曲虛線代表向上回溯，表示此遞迴方法已經返回，回溯到了開啟此方法的位置。</li> </ul> <p>為了加深理解，建議將圖 9-12 與程式碼結合起來，在腦中模擬（或者用筆畫下來）整個 DFS 過程，包括每個遞迴方法何時開啟、何時返回。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-12   圖的深度優先走訪步驟 </p> <p>深度優先走訪的序列是否唯一？</p> <p>與廣度優先走訪類似，深度優先走訪序列的順序也不是唯一的。給定某頂點，先往哪個方向探索都可以，即鄰接頂點的順序可以任意打亂，都是深度優先走訪。</p> <p>以樹的走訪為例，“根 \\(\\rightarrow\\) 左 \\(\\rightarrow\\) 右”“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”“左 \\(\\rightarrow\\) 右 \\(\\rightarrow\\) 根”分別對應前序、中序、後序走訪，它們展示了三種走訪優先順序，然而這三者都屬於深度優先走訪。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   複雜度分析","text":"<p>時間複雜度：所有頂點都會被訪問 \\(1\\) 次，使用 \\(O(|V|)\\) 時間；所有邊都會被訪問 \\(2\\) 次，使用 \\(O(2|E|)\\) 時間；總體使用 \\(O(|V| + |E|)\\) 時間。</p> <p>空間複雜度：串列 <code>res</code> ，雜湊集合 <code>visited</code> 頂點數量最多為 \\(|V|\\) ，遞迴深度最大為 \\(|V|\\) ，因此使用 \\(O(|V|)\\) 空間。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   小結","text":"","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>圖由頂點和邊組成，可以表示為一組頂點和一組邊構成的集合。</li> <li>相較於線性關係（鏈結串列）和分治關係（樹），網路關係（圖）具有更高的自由度，因而更為複雜。</li> <li>有向圖的邊具有方向性，連通圖中的任意頂點均可達，有權圖的每條邊都包含權重變數。</li> <li>鄰接矩陣利用矩陣來表示圖，每一行（列）代表一個頂點，矩陣元素代表邊，用 \\(1\\) 或 \\(0\\) 表示兩個頂點之間有邊或無邊。鄰接矩陣在增刪查改操作上效率很高，但空間佔用較多。</li> <li>鄰接表使用多個鏈結串列來表示圖，第 \\(i\\) 個鏈結串列對應頂點 \\(i\\) ，其中儲存了該頂點的所有鄰接頂點。鄰接表相對於鄰接矩陣更加節省空間，但由於需要走訪鏈結串列來查詢邊，因此時間效率較低。</li> <li>當鄰接表中的鏈結串列過長時，可以將其轉換為紅黑樹或雜湊表，從而提升查詢效率。</li> <li>從演算法思想的角度分析，鄰接矩陣體現了“以空間換時間”，鄰接表體現了“以時間換空間”。</li> <li>圖可用於建模各類現實系統，如社交網路、地鐵線路等。</li> <li>樹是圖的一種特例，樹的走訪也是圖的走訪的一種特例。</li> <li>圖的廣度優先走訪是一種由近及遠、層層擴張的搜尋方式，通常藉助佇列實現。</li> <li>圖的深度優先走訪是一種優先走到底、無路可走時再回溯的搜尋方式，常基於遞迴來實現。</li> </ul>","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：路徑的定義是頂點序列還是邊序列？</p> <p>維基百科上不同語言版本的定義不一致：英文版是“路徑是一個邊序列”，而中文版是“路徑是一個頂點序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>在本文中，路徑被視為一個邊序列，而不是一個頂點序列。這是因為兩個頂點之間可能存在多條邊連線，此時每條邊都對應一條路徑。</p> <p>Q：非連通圖中是否會有無法走訪到的點？</p> <p>在非連通圖中，從某個頂點出發，至少有一個頂點無法到達。走訪非連通圖需要設定多個起點，以走訪到圖的所有連通分量。</p> <p>Q：在鄰接表中，“與該頂點相連的所有頂點”的頂點順序是否有要求？</p> <p>可以是任意順序。但在實際應用中，可能需要按照指定規則來排序，比如按照頂點新增的次序，或者按照頂點值大小的順序等，這樣有助於快速查詢“帶有某種極值”的頂點。</p>","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"第 15 章   貪婪","text":"<p>Abstract</p> <p>向日葵朝著太陽轉動，時刻追求自身成長的最大可能。</p> <p>貪婪策略在一輪輪的簡單選擇中，逐步導向最佳答案。</p>","path":["第 15 章 &nbsp; 貪婪"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"本章內容","text":"<ul> <li>15.1   貪婪演算法</li> <li>15.2   分數背包問題</li> <li>15.3   最大容量問題</li> <li>15.4   最大切分乘積問題</li> <li>15.5   小結</li> </ul>","path":["第 15 章 &nbsp; 貪婪"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   分數背包問題","text":"<p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品只能選擇一次，但可以選擇物品的一部分，價值根據選擇的重量比例計算，問在限定背包容量下背包中物品的最大價值。示例如圖 15-3 所示。</p> <p></p> <p> 圖 15-3   分數背包問題的示例資料 </p> <p>分數背包問題和 0-1 背包問題整體上非常相似，狀態包含當前物品 \\(i\\) 和容量 \\(c\\) ，目標是求限定背包容量下的最大價值。</p> <p>不同點在於，本題允許只選擇物品的一部分。如圖 15-4 所示，我們可以對物品任意地進行切分，並按照重量比例來計算相應價值。</p> <ol> <li>對於物品 \\(i\\) ，它在單位重量下的價值為 \\(val[i-1] / wgt[i-1]\\) ，簡稱單位價值。</li> <li>假設放入一部分物品 \\(i\\) ，重量為 \\(w\\) ，則背包增加的價值為 \\(w \\times val[i-1] / wgt[i-1]\\) 。</li> </ol> <p></p> <p> 圖 15-4   物品在單位重量下的價值 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>最大化背包內物品總價值，本質上是最大化單位重量下的物品價值。由此便可推理出圖 15-5 所示的貪婪策略。</p> <ol> <li>將物品按照單位價值從高到低進行排序。</li> <li>走訪所有物品，每輪貪婪地選擇單位價值最高的物品。</li> <li>若剩餘背包容量不足，則使用當前物品的一部分填滿背包。</li> </ol> <p></p> <p> 圖 15-5   分數背包問題的貪婪策略 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>我們建立了一個物品類別 <code>Item</code> ，以便將物品按照單位價值進行排序。迴圈進行貪婪選擇，當背包已滿時跳出並返回解：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"物品\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # 物品重量\n        self.v = v  # 物品價值\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"分數背包：貪婪\"\"\"\n    # 建立物品串列，包含兩個屬性：重量、價值\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # 迴圈貪婪選擇\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v\n            cap -= item.w\n        else:\n            # 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap\n            # 已無剩餘容量，因此跳出迴圈\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* 物品 */\nclass Item {\n  public:\n    int w; // 物品重量\n    int v; // 物品價值\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // 迴圈貪婪選擇\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double)item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* 物品 */\nclass Item {\n    int w; // 物品重量\n    int v; // 物品價值\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // 迴圈貪婪選擇\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double) item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* 物品 */\nclass Item(int w, int v) {\n    public int w = w; // 物品重量\n    public int v = v; // 物品價值\n}\n\n/* 分數背包：貪婪 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // 迴圈貪婪選擇\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double)item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* 物品 */\ntype Item struct {\n    w int // 物品重量\n    v int // 物品價值\n}\n\n/* 分數背包：貪婪 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // 迴圈貪婪選擇\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* 物品 */\nclass Item {\n    var w: Int // 物品重量\n    var v: Int // 物品價值\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* 分數背包：貪婪 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // 迴圈貪婪選擇\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* 物品 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // 物品重量\n        this.v = v; // 物品價值\n    }\n}\n\n/* 分數背包：貪婪 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 迴圈貪婪選擇\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* 物品 */\nclass Item {\n    w: number; // 物品重量\n    v: number; // 物品價值\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分數背包：貪婪 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 迴圈貪婪選擇\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* 物品 */\nclass Item {\n  int w; // 物品重量\n  int v; // 物品價值\n\n  Item(this.w, this.v);\n}\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // 建立物品串列，包含兩個屬性：重量、價值\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // 按照單位價值 item.v / item.w 從高到低進行排序\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // 迴圈貪婪選擇\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // 若剩餘容量充足，則將當前物品整個裝進背包\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // 若剩餘容量不足，則將當前物品的一部分裝進背包\n      res += item.v / item.w * cap;\n      // 已無剩餘容量，因此跳出迴圈\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* 物品 */\nstruct Item {\n    w: i32, // 物品重量\n    v: i32, // 物品價值\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* 分數背包：貪婪 */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // 迴圈貪婪選擇\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* 物品 */\ntypedef struct {\n    int w; // 物品重量\n    int v; // 物品價值\n} Item;\n\n/* 分數背包：貪婪 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // 迴圈貪婪選擇\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* 物品 */\nclass Item(\n    val w: Int, // 物品\n    val v: Int  // 物品價值\n)\n\n/* 分數背包：貪婪 */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // 迴圈貪婪選擇\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += item.v.toDouble() / item.w * cap\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### 物品 ###\nclass Item\n  attr_accessor :w # 物品重量\n  attr_accessor :v # 物品價值\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### 分數背包：貪婪 ###\ndef fractional_knapsack(wgt, val, cap)\n  # 建立物品串列，包含兩個屬性：重量，價值\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # 按照單位價值 item.v / item.w 從高到低進行排序\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # 迴圈貪婪選擇\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # 若剩餘容量充足，則將當前物品整個裝進背包\n      res += item.v\n      cap -= item.w\n    else\n      # 若剩餘容量不足，則將當前物品的一部分裝進背包\n      res += (item.v.to_f / item.w) * cap\n      # 已無剩餘容量，因此跳出迴圈\n      break\n    end\n  end\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>內建排序演算法的時間複雜度通常為 \\(O(\\log n)\\) ，空間複雜度通常為 \\(O(\\log n)\\) 或 \\(O(n)\\) ，取決於程式語言的具體實現。</p> <p>除排序之外，在最差情況下，需要走訪整個物品串列，因此時間複雜度為 \\(O(n)\\) ，其中 \\(n\\) 為物品數量。</p> <p>由於初始化了一個 <code>Item</code> 物件串列，因此空間複雜度為 \\(O(n)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>採用反證法。假設物品 \\(x\\) 是單位價值最高的物品，使用某演算法求得最大價值為 <code>res</code> ，但該解中不包含物品 \\(x\\) 。</p> <p>現在從背包中拿出單位重量的任意物品，並替換為單位重量的物品 \\(x\\) 。由於物品 \\(x\\) 的單位價值最高，因此替換後的總價值一定大於 <code>res</code> 。這與 <code>res</code> 是最優解矛盾，說明最優解中必須包含物品 \\(x\\) 。</p> <p>對於該解中的其他物品，我們也可以構建出上述矛盾。總而言之，單位價值更大的物品總是更優選擇，這說明貪婪策略是有效的。</p> <p>如圖 15-6 所示，如果將物品重量和物品單位價值分別看作一張二維圖表的橫軸和縱軸，則分數背包問題可轉化為“求在有限橫軸區間下圍成的最大面積”。這個類比可以幫助我們從幾何角度理解貪婪策略的有效性。</p> <p></p> <p> 圖 15-6   分數背包問題的幾何表示 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   貪婪演算法","text":"<p>貪婪演算法（greedy algorithm）是一種常見的解決最佳化問題的演算法，其基本思想是在問題的每個決策階段，都選擇當前看起來最優的選擇，即貪婪地做出區域性最優的決策，以期獲得全域性最優解。貪婪演算法簡潔且高效，在許多實際問題中有著廣泛的應用。</p> <p>貪婪演算法和動態規劃都常用於解決最佳化問題。它們之間存在一些相似之處，比如都依賴最優子結構性質，但工作原理不同。</p> <ul> <li>動態規劃會根據之前階段的所有決策來考慮當前決策，並使用過去子問題的解來構建當前子問題的解。</li> <li>貪婪演算法不會考慮過去的決策，而是一路向前地進行貪婪選擇，不斷縮小問題範圍，直至問題被解決。</li> </ul> <p>我們先透過例題“零錢兌換”瞭解貪婪演算法的工作原理。這道題已經在“完全背包問題”章節中介紹過，相信你對它並不陌生。</p> <p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 \\(-1\\) 。</p> <p>本題採取的貪婪策略如圖 15-1 所示。給定目標金額，我們貪婪地選擇不大於且最接近它的硬幣，不斷迴圈該步驟，直至湊出目標金額為止。</p> <p></p> <p> 圖 15-1   零錢兌換的貪婪策略 </p> <p>實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：貪婪\"\"\"\n    # 假設 coins 串列有序\n    i = len(coins) - 1\n    count = 0\n    # 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0:\n        # 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # 選擇 coins[i]\n        amt -= coins[i]\n        count += 1\n    # 若未找到可行方案，則返回 -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.size() - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.length - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* 零錢兌換：貪婪 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.Length - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* 零錢兌換：貪婪 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // 假設 coins 串列有序\n    i := len(coins) - 1\n    count := 0\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    for amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // 選擇 coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // 若未找到可行方案，則返回 -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* 零錢兌換：貪婪 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // 假設 coins 串列有序\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // 選擇 coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* 零錢兌換：貪婪 */\nfunction coinChangeGreedy(coins, amt) {\n    // 假設 coins 陣列有序\n    let i = coins.length - 1;\n    let count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* 零錢兌換：貪婪 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // 假設 coins 陣列有序\n    let i = coins.length - 1;\n    let count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // 假設 coins 串列有序\n  int i = coins.length - 1;\n  int count = 0;\n  // 迴圈進行貪婪選擇，直到無剩餘金額\n  while (amt &gt; 0) {\n    // 找到小於且最接近剩餘金額的硬幣\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // 選擇 coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // 若未找到可行方案，則返回 -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* 零錢兌換：貪婪 */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // 假設 coins 串列有序\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // 若未找到可行方案，則返回 -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // 假設 coins 串列有序\n    int i = size - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* 零錢兌換：貪婪 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // 假設 coins 串列有序\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (am &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // 選擇 coins[i]\n        am -= coins[i]\n        count++\n    }\n    // 若未找到可行方案，則返回 -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### 零錢兌換：貪婪 ###\ndef coin_change_greedy(coins, amt)\n  # 假設 coins 串列有序\n  i = coins.length - 1\n  count = 0\n  # 迴圈進行貪婪選擇，直到無剩餘金額\n  while amt &gt; 0\n    # 找到小於且最接近剩餘金額的硬幣\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # 選擇 coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # 若未找到可行方案， 則返回 -1\n  amt == 0 ? count : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>你可能會不由地發出感嘆：So clean ！貪婪演算法僅用約十行程式碼就解決了零錢兌換問題。</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   貪婪演算法的優點與侷限性","text":"<p>貪婪演算法不僅操作直接、實現簡單，而且通常效率也很高。在以上程式碼中，記硬幣最小面值為 \\(\\min(coins)\\) ，則貪婪選擇最多迴圈 \\(amt / \\min(coins)\\) 次，時間複雜度為 \\(O(amt / \\min(coins))\\) 。這比動態規劃解法的時間複雜度 \\(O(n \\times amt)\\) 小了一個數量級。</p> <p>然而，對於某些硬幣面值組合，貪婪演算法並不能找到最優解。圖 15-2 給出了兩個示例。</p> <ul> <li>正例 \\(coins = [1, 5, 10, 20, 50, 100]\\)：在該硬幣組合下，給定任意 \\(amt\\) ，貪婪演算法都可以找到最優解。</li> <li>反例 \\(coins = [1, 20, 50]\\)：假設 \\(amt = 60\\) ，貪婪演算法只能找到 \\(50 + 1 \\times 10\\) 的兌換組合，共計 \\(11\\) 枚硬幣，但動態規劃可以找到最優解 \\(20 + 20 + 20\\) ，僅需 \\(3\\) 枚硬幣。</li> <li>反例 \\(coins = [1, 49, 50]\\)：假設 \\(amt = 98\\) ，貪婪演算法只能找到 \\(50 + 1 \\times 48\\) 的兌換組合，共計 \\(49\\) 枚硬幣，但動態規劃可以找到最優解 \\(49 + 49\\) ，僅需 \\(2\\) 枚硬幣。</li> </ul> <p></p> <p> 圖 15-2   貪婪演算法無法找出最優解的示例 </p> <p>也就是說，對於零錢兌換問題，貪婪演算法無法保證找到全域性最優解，並且有可能找到非常差的解。它更適合用動態規劃解決。</p> <p>一般情況下，貪婪演算法的適用情況分以下兩種。</p> <ol> <li>可以保證找到最優解：貪婪演算法在這種情況下往往是最優選擇，因為它往往比回溯、動態規劃更高效。</li> <li>可以找到近似最優解：貪婪演算法在這種情況下也是可用的。對於很多複雜問題來說，尋找全域性最優解非常困難，能以較高效率找到次優解也是非常不錯的。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   貪婪演算法特性","text":"<p>那麼問題來了，什麼樣的問題適合用貪婪演算法求解呢？或者說，貪婪演算法在什麼情況下可以保證找到最優解？</p> <p>相較於動態規劃，貪婪演算法的使用條件更加苛刻，其主要關注問題的兩個性質。</p> <ul> <li>貪婪選擇性質：只有當局部最優選擇始終可以導致全域性最優解時，貪婪演算法才能保證得到最優解。</li> <li>最優子結構：原問題的最優解包含子問題的最優解。</li> </ul> <p>最優子結構已經在“動態規劃”章節中介紹過，這裡不再贅述。值得注意的是，一些問題的最優子結構並不明顯，但仍然可使用貪婪演算法解決。</p> <p>我們主要探究貪婪選擇性質的判斷方法。雖然它的描述看上去比較簡單，但實際上對於許多問題，證明貪婪選擇性質並非易事。</p> <p>例如零錢兌換問題，我們雖然能夠容易地舉出反例，對貪婪選擇性質進行證偽，但證實的難度較大。如果問：滿足什麼條件的硬幣組合可以使用貪婪演算法求解？我們往往只能憑藉直覺或舉例子來給出一個模稜兩可的答案，而難以給出嚴謹的數學證明。</p> <p>Quote</p> <p>有一篇論文給出了一個 \\(O(n^3)\\) 時間複雜度的演算法，用於判斷一個硬幣組合能否使用貪婪演算法找出任意金額的最優解。</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   貪婪演算法解題步驟","text":"<p>貪婪問題的解決流程大體可分為以下三步。</p> <ol> <li>問題分析：梳理與理解問題特性，包括狀態定義、最佳化目標和約束條件等。這一步在回溯和動態規劃中都有涉及。</li> <li>確定貪婪策略：確定如何在每一步中做出貪婪選擇。這個策略能夠在每一步減小問題的規模，並最終解決整個問題。</li> <li>正確性證明：通常需要證明問題具有貪婪選擇性質和最優子結構。這個步驟可能需要用到數學證明，例如歸納法或反證法等。</li> </ol> <p>確定貪婪策略是求解問題的核心步驟，但實施起來可能並不容易，主要有以下原因。</p> <ul> <li>不同問題的貪婪策略的差異較大。對於許多問題來說，貪婪策略比較淺顯，我們透過一些大概的思考與嘗試就能得出。而對於一些複雜問題，貪婪策略可能非常隱蔽，這種情況就非常考驗個人的解題經驗與演算法能力了。</li> <li>某些貪婪策略具有較強的迷惑性。當我們滿懷信心設計好貪婪策略，寫出解題程式碼並提交執行，很可能發現部分測試樣例無法透過。這是因為設計的貪婪策略只是“部分正確”的，上文介紹的零錢兌換就是一個典型案例。</li> </ul> <p>為了保證正確性，我們應該對貪婪策略進行嚴謹的數學證明，通常需要用到反證法或數學歸納法。</p> <p>然而，正確性證明也很可能不是一件易事。如若沒有頭緒，我們通常會選擇面向測試用例進行程式碼除錯，一步步修改與驗證貪婪策略。</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   貪婪演算法典型例題","text":"<p>貪婪演算法常常應用在滿足貪婪選擇性質和最優子結構的最佳化問題中，以下列舉了一些典型的貪婪演算法問題。</p> <ul> <li>硬幣找零問題：在某些硬幣組合下，貪婪演算法總是可以得到最優解。</li> <li>區間排程問題：假設你有一些任務，每個任務在一段時間內進行，你的目標是完成儘可能多的任務。如果每次都選擇結束時間最早的任務，那麼貪婪演算法就可以得到最優解。</li> <li>分數背包問題：給定一組物品和一個載重量，你的目標是選擇一組物品，使得總重量不超過載重量，且總價值最大。如果每次都選擇價效比最高（價值 / 重量）的物品，那麼貪婪演算法在一些情況下可以得到最優解。</li> <li>股票買賣問題：給定一組股票的歷史價格，你可以進行多次買賣，但如果你已經持有股票，那麼在賣出之前不能再買，目標是獲取最大利潤。</li> <li>霍夫曼編碼：霍夫曼編碼是一種用於無損資料壓縮的貪婪演算法。透過構建霍夫曼樹，每次選擇出現頻率最低的兩個節點合併，最後得到的霍夫曼樹的帶權路徑長度（編碼長度）最小。</li> <li>Dijkstra 演算法：它是一種解決給定源頂點到其餘各頂點的最短路徑問題的貪婪演算法。</li> </ul>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   最大容量問題","text":"<p>Question</p> <p>輸入一個陣列 \\(ht\\) ，其中的每個元素代表一個垂直隔板的高度。陣列中的任意兩個隔板，以及它們之間的空間可以組成一個容器。</p> <p>容器的容量等於高度和寬度的乘積（面積），其中高度由較短的隔板決定，寬度是兩個隔板的陣列索引之差。</p> <p>請在陣列中選擇兩個隔板，使得組成的容器的容量最大，返回最大容量。示例如圖 15-7 所示。</p> <p></p> <p> 圖 15-7   最大容量問題的示例資料 </p> <p>容器由任意兩個隔板圍成，因此本題的狀態為兩個隔板的索引，記為 \\([i, j]\\) 。</p> <p>根據題意，容量等於高度乘以寬度，其中高度由短板決定，寬度是兩隔板的陣列索引之差。設容量為 \\(cap[i, j]\\) ，則可得計算公式：</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>設陣列長度為 \\(n\\) ，兩個隔板的組合數量（狀態總數）為 \\(C_n^2 = \\frac{n(n - 1)}{2}\\) 個。最直接地，我們可以窮舉所有狀態，從而求得最大容量，時間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>這道題還有更高效率的解法。如圖 15-8 所示，現選取一個狀態 \\([i, j]\\) ，其滿足索引 \\(i &lt; j\\) 且高度 \\(ht[i] &lt; ht[j]\\) ，即 \\(i\\) 為短板、\\(j\\) 為長板。</p> <p></p> <p> 圖 15-8   初始狀態 </p> <p>如圖 15-9 所示，若此時將長板 \\(j\\) 向短板 \\(i\\) 靠近，則容量一定變小。</p> <p>這是因為在移動長板 \\(j\\) 後，寬度 \\(j-i\\) 肯定變小；而高度由短板決定，因此高度只可能不變（ \\(i\\) 仍為短板）或變小（移動後的 \\(j\\) 成為短板）。</p> <p></p> <p> 圖 15-9   向內移動長板後的狀態 </p> <p>反向思考，我們只有向內收縮短板 \\(i\\) ，才有可能使容量變大。因為雖然寬度一定變小，但高度可能會變大（移動後的短板 \\(i\\) 可能會變長）。例如在圖 15-10 中，移動短板後面積變大。</p> <p></p> <p> 圖 15-10   向內移動短板後的狀態 </p> <p>由此便可推出本題的貪婪策略：初始化兩指標，使其分列容器兩端，每輪向內收縮短板對應的指標，直至兩指標相遇。</p> <p>圖 15-11 展示了貪婪策略的執行過程。</p> <ol> <li>初始狀態下，指標 \\(i\\) 和 \\(j\\) 分列陣列兩端。</li> <li>計算當前狀態的容量 \\(cap[i, j]\\) ，並更新最大容量。</li> <li>比較板 \\(i\\) 和板 \\(j\\) 的高度，並將短板向內移動一格。</li> <li>迴圈執行第 <code>2.</code> 步和第 <code>3.</code> 步，直至 \\(i\\) 和 \\(j\\) 相遇時結束。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 15-11   最大容量問題的貪婪過程 </p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>程式碼迴圈最多 \\(n\\) 輪，因此時間複雜度為 \\(O(n)\\) 。</p> <p>變數 \\(i\\)、\\(j\\)、\\(res\\) 使用常數大小的額外空間，因此空間複雜度為 \\(O(1)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"最大容量：貪婪\"\"\"\n    # 初始化 i, j，使其分列陣列兩端\n    i, j = 0, len(ht) - 1\n    # 初始最大容量為 0\n    res = 0\n    # 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j:\n        # 更新最大容量\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # 向內移動短板\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.size() - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(int[] ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.length - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* 最大容量：貪婪 */\nint MaxCapacity(int[] ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.Length - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* 最大容量：貪婪 */\nfunc maxCapacity(ht []int) int {\n    // 初始化 i, j，使其分列陣列兩端\n    i, j := 0, len(ht)-1\n    // 初始最大容量為 0\n    res := 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    for i &lt; j {\n        // 更新最大容量\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* 最大容量：貪婪 */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // 初始化 i, j，使其分列陣列兩端\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // 初始最大容量為 0\n    var res = 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j {\n        // 更新最大容量\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* 最大容量：貪婪 */\nfunction maxCapacity(ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    let i = 0,\n        j = ht.length - 1;\n    // 初始最大容量為 0\n    let res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* 最大容量：貪婪 */\nfunction maxCapacity(ht: number[]): number {\n    // 初始化 i, j，使其分列陣列兩端\n    let i = 0,\n        j = ht.length - 1;\n    // 初始最大容量為 0\n    let res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(List&lt;int&gt; ht) {\n  // 初始化 i, j，使其分列陣列兩端\n  int i = 0, j = ht.length - 1;\n  // 初始最大容量為 0\n  int res = 0;\n  // 迴圈貪婪選擇，直至兩板相遇\n  while (i &lt; j) {\n    // 更新最大容量\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // 向內移動短板\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* 最大容量：貪婪 */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // 初始化 i, j，使其分列陣列兩端\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // 初始最大容量為 0\n    let mut res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j {\n        // 更新最大容量\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(int ht[], int htLength) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0;\n    int j = htLength - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* 最大容量：貪婪 */\nfun maxCapacity(ht: IntArray): Int {\n    // 初始化 i, j，使其分列陣列兩端\n    var i = 0\n    var j = ht.size - 1\n    // 初始最大容量為 0\n    var res = 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### 最大容量：貪婪 ###\ndef max_capacity(ht)\n  # 初始化 i, j，使其分列陣列兩端\n  i, j = 0, ht.length - 1\n  # 初始最大容量為 0\n  res = 0\n\n  # 迴圈貪婪選擇，直至兩板相遇\n  while i &lt; j\n    # 更新最大容量\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # 向內移動短板\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>之所以貪婪比窮舉更快，是因為每輪的貪婪選擇都會“跳過”一些狀態。</p> <p>比如在狀態 \\(cap[i, j]\\) 下，\\(i\\) 為短板、\\(j\\) 為長板。若貪婪地將短板 \\(i\\) 向內移動一格，會導致圖 15-12 所示的狀態被“跳過”。這意味著之後無法驗證這些狀態的容量大小。</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> 圖 15-12   移動短板導致被跳過的狀態 </p> <p>觀察發現，這些被跳過的狀態實際上就是將長板 \\(j\\) 向內移動的所有狀態。前面我們已經證明內移長板一定會導致容量變小。也就是說，被跳過的狀態都不可能是最優解，跳過它們不會導致錯過最優解。</p> <p>以上分析說明，移動短板的操作是“安全”的，貪婪策略是有效的。</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   最大切分乘積問題","text":"<p>Question</p> <p>給定一個正整數 \\(n\\) ，將其切分為至少兩個正整數的和，求切分後所有整數的乘積最大是多少，如圖 15-13 所示。</p> <p></p> <p> 圖 15-13   最大切分乘積的問題定義 </p> <p>假設我們將 \\(n\\) 切分為 \\(m\\) 個整數因子，其中第 \\(i\\) 個因子記為 \\(n_i\\) ，即</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>本題的目標是求得所有整數因子的最大乘積，即</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>我們需要思考的是：切分數量 \\(m\\) 應該多大，每個 \\(n_i\\) 應該是多少？</p>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>根據經驗，兩個整數的乘積往往比它們的加和更大。假設從 \\(n\\) 中分出一個因子 \\(2\\) ，則它們的乘積為 \\(2(n-2)\\) 。我們將該乘積與 \\(n\\) 作比較：</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>如圖 15-14 所示，當 \\(n \\geq 4\\) 時，切分出一個 \\(2\\) 後乘積會變大，這說明大於等於 \\(4\\) 的整數都應該被切分。</p> <p>貪婪策略一：如果切分方案中包含 \\(\\geq 4\\) 的因子，那麼它就應該被繼續切分。最終的切分方案只應出現 \\(1\\)、\\(2\\)、\\(3\\) 這三種因子。</p> <p></p> <p> 圖 15-14   切分導致乘積變大 </p> <p>接下來思考哪個因子是最優的。在 \\(1\\)、\\(2\\)、\\(3\\) 這三個因子中，顯然 \\(1\\) 是最差的，因為 \\(1 \\times (n-1) &lt; n\\) 恆成立，即切分出 \\(1\\) 反而會導致乘積減小。</p> <p>如圖 15-15 所示，當 \\(n = 6\\) 時，有 \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\) 。這意味著切分出 \\(3\\) 比切分出 \\(2\\) 更優。</p> <p>貪婪策略二：在切分方案中，最多隻應存在兩個 \\(2\\) 。因為三個 \\(2\\) 總是可以替換為兩個 \\(3\\) ，從而獲得更大的乘積。</p> <p></p> <p> 圖 15-15   最優切分因子 </p> <p>綜上所述，可推理出以下貪婪策略。</p> <ol> <li>輸入整數 \\(n\\) ，從其不斷地切分出因子 \\(3\\) ，直至餘數為 \\(0\\)、\\(1\\)、\\(2\\) 。</li> <li>當餘數為 \\(0\\) 時，代表 \\(n\\) 是 \\(3\\) 的倍數，因此不做任何處理。</li> <li>當餘數為 \\(2\\) 時，不繼續劃分，保留。</li> <li>當餘數為 \\(1\\) 時，由於 \\(2 \\times 2 &gt; 1 \\times 3\\) ，因此應將最後一個 \\(3\\) 替換為 \\(2\\) 。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>如圖 15-16 所示，我們無須透過迴圈來切分整數，而可以利用向下整除運算得到 \\(3\\) 的個數 \\(a\\) ，用取模運算得到餘數 \\(b\\) ，此時有：</p> \\[ n = 3 a + b \\] <p>請注意，對於 \\(n \\leq 3\\) 的邊界情況，必須拆分出一個 \\(1\\) ，乘積為 \\(1 \\times (n - 1)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"最大切分乘積：貪婪\"\"\"\n    # 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    a, b = n // 3, n % 3\n    if b == 1:\n        # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # 當餘數為 2 時，不做處理\n        return int(math.pow(3, a)) * 2\n    # 當餘數為 0 時，不做處理\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int)pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int) Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* 最大切分乘積：貪婪 */\nint MaxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* 最大切分乘積：貪婪 */\nfunc maxProductCutting(n int) int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // 當餘數為 2 時，不做處理\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* 最大切分乘積：貪婪 */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // 當餘數為 2 時，不做處理\n        return pow(3, a) * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* 最大切分乘積：貪婪 */\nfunction maxProductCutting(n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 當餘數為 2 時，不做處理\n        return Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* 最大切分乘積：貪婪 */\nfunction maxProductCutting(n: number): number {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 當餘數為 2 時，不做處理\n        return Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n  // 當 n &lt;= 3 時，必須切分出一個 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // 當餘數為 2 時，不做處理\n    return (pow(3, a) * 2).toInt();\n  }\n  // 當餘數為 0 時，不做處理\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* 最大切分乘積：貪婪 */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // 當餘數為 2 時，不做處理\n        3_i32.pow(a as u32) * 2\n    } else {\n        // 當餘數為 0 時，不做處理\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* 最大切分乘積：貪婪 */\nfun maxProductCutting(n: Int): Int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### 最大切分乘積：貪婪 ###\ndef max_product_cutting(n)\n  # 當 n &lt;= 3 時，必須切分出一個 1\n  return 1 * (n - 1) if n &lt;= 3\n  # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n  a, b = n / 3, n % 3\n  # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # 當餘數為 2 時，不做處理\n  return (3.pow(a) * 2).to_i if b == 2\n  # 當餘數為 0 時，不做處理\n  3.pow(a).to_i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 15-16   最大切分乘積的計算方法 </p> <p>時間複雜度取決於程式語言的冪運算的實現方法。以 Python 為例，常用的冪計算函式有三種。</p> <ul> <li>運算子 <code>**</code> 和函式 <code>pow()</code> 的時間複雜度均為 \\(O(\\log⁡ a)\\) 。</li> <li>函式 <code>math.pow()</code> 內部呼叫 C 語言庫的 <code>pow()</code> 函式，其執行浮點取冪，時間複雜度為 \\(O(1)\\) 。</li> </ul> <p>變數 \\(a\\) 和 \\(b\\) 使用常數大小的額外空間，因此空間複雜度為 \\(O(1)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>使用反證法，只分析 \\(n \\geq 4\\) 的情況。</p> <ol> <li>所有因子 \\(\\leq 3\\) ：假設最優切分方案中存在 \\(\\geq 4\\) 的因子 \\(x\\) ，那麼一定可以將其繼續劃分為 \\(2(x-2)\\) ，從而獲得更大（或相等）的乘積。這與假設矛盾。</li> <li>切分方案不包含 \\(1\\) ：假設最優切分方案中存在一個因子 \\(1\\) ，那麼它一定可以合併入另外一個因子中，以獲得更大的乘積。這與假設矛盾。</li> <li>切分方案最多包含兩個 \\(2\\) ：假設最優切分方案中包含三個 \\(2\\) ，那麼一定可以替換為兩個 \\(3\\) ，乘積更大。這與假設矛盾。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   小結","text":"","path":["第 15 章 &nbsp; 貪婪","15.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>貪婪演算法通常用於解決最最佳化問題，其原理是在每個決策階段都做出區域性最優的決策，以期獲得全域性最優解。</li> <li>貪婪演算法會迭代地做出一個又一個的貪婪選擇，每輪都將問題轉化成一個規模更小的子問題，直到問題被解決。</li> <li>貪婪演算法不僅實現簡單，還具有很高的解題效率。相比於動態規劃，貪婪演算法的時間複雜度通常更低。</li> <li>在零錢兌換問題中，對於某些硬幣組合，貪婪演算法可以保證找到最優解；對於另外一些硬幣組合則不然，貪婪演算法可能找到很差的解。</li> <li>適合用貪婪演算法求解的問題具有兩大性質：貪婪選擇性質和最優子結構。貪婪選擇性質代表貪婪策略的有效性。</li> <li>對於某些複雜問題，貪婪選擇性質的證明並不簡單。相對來說，證偽更加容易，例如零錢兌換問題。</li> <li>求解貪婪問題主要分為三步：問題分析、確定貪婪策略、正確性證明。其中，確定貪婪策略是核心步驟，正確性證明往往是難點。</li> <li>分數背包問題在 0-1 背包的基礎上，允許選擇物品的一部分，因此可使用貪婪演算法求解。貪婪策略的正確性可以使用反證法來證明。</li> <li>最大容量問題可使用窮舉法求解，時間複雜度為 \\(O(n^2)\\) 。透過設計貪婪策略，每輪向內移動短板，可將時間複雜度最佳化至 \\(O(n)\\) 。</li> <li>在最大切分乘積問題中，我們先後推理出兩個貪婪策略：\\(\\geq 4\\) 的整數都應該繼續切分，最優切分因子為 \\(3\\) 。程式碼中包含冪運算，時間複雜度取決於冪運算實現方法，通常為 \\(O(1)\\) 或 \\(O(\\log n)\\) 。</li> </ul>","path":["第 15 章 &nbsp; 貪婪","15.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"第 6 章   雜湊表","text":"<p>Abstract</p> <p>在計算機世界中，雜湊表如同一位聰慧的圖書管理員。</p> <p>他知道如何計算索書號，從而可以快速找到目標圖書。</p>","path":["第 6 章 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"本章內容","text":"<ul> <li>6.1   雜湊表</li> <li>6.2   雜湊衝突</li> <li>6.3   雜湊演算法</li> <li>6.4   小結</li> </ul>","path":["第 6 章 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   雜湊演算法","text":"<p>前兩節介紹了雜湊表的工作原理和雜湊衝突的處理方法。然而無論是開放定址還是鏈式位址，它們只能保證雜湊表可以在發生衝突時正常工作，而無法減少雜湊衝突的發生。</p> <p>如果雜湊衝突過於頻繁，雜湊表的效能則會急劇劣化。如圖 6-8 所示，對於鏈式位址雜湊表，理想情況下鍵值對均勻分佈在各個桶中，達到最佳查詢效率；最差情況下所有鍵值對都儲存到同一個桶中，時間複雜度退化至 \\(O(n)\\) 。</p> <p></p> <p> 圖 6-8   雜湊衝突的最佳情況與最差情況 </p> <p>鍵值對的分佈情況由雜湊函式決定。回憶雜湊函式的計算步驟，先計算雜湊值，再對陣列長度取模：</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>觀察以上公式，當雜湊表容量 <code>capacity</code> 固定時，雜湊演算法 <code>hash()</code> 決定了輸出值，進而決定了鍵值對在雜湊表中的分佈情況。</p> <p>這意味著，為了降低雜湊衝突的發生機率，我們應當將注意力集中在雜湊演算法 <code>hash()</code> 的設計上。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631","level":2,"title":"6.3.1   雜湊演算法的目標","text":"<p>為了實現“既快又穩”的雜湊表資料結構，雜湊演算法應具備以下特點。</p> <ul> <li>確定性：對於相同的輸入，雜湊演算法應始終產生相同的輸出。這樣才能確保雜湊表是可靠的。</li> <li>效率高：計算雜湊值的過程應該足夠快。計算開銷越小，雜湊表的實用性越高。</li> <li>均勻分佈：雜湊演算法應使得鍵值對均勻分佈在雜湊表中。分佈越均勻，雜湊衝突的機率就越低。</li> </ul> <p>實際上，雜湊演算法除了可以用於實現雜湊表，還廣泛應用於其他領域中。</p> <ul> <li>密碼儲存：為了保護使用者密碼的安全，系統通常不會直接儲存使用者的明文密碼，而是儲存密碼的雜湊值。當用戶輸入密碼時，系統會對輸入的密碼計算雜湊值，然後與儲存的雜湊值進行比較。如果兩者匹配，那麼密碼就被視為正確。</li> <li>資料完整性檢查：資料傳送方可以計算資料的雜湊值並將其一同傳送；接收方可以重新計算接收到的資料的雜湊值，並與接收到的雜湊值進行比較。如果兩者匹配，那麼資料就被視為完整。</li> </ul> <p>對於密碼學的相關應用，為了防止從雜湊值推導出原始密碼等逆向工程，雜湊演算法需要具備更高等級的安全特性。</p> <ul> <li>單向性：無法透過雜湊值反推出關於輸入資料的任何資訊。</li> <li>抗碰撞性：應當極難找到兩個不同的輸入，使得它們的雜湊值相同。</li> <li>雪崩效應：輸入的微小變化應當導致輸出的顯著且不可預測的變化。</li> </ul> <p>請注意，“均勻分佈”與“抗碰撞性”是兩個獨立的概念，滿足均勻分佈不一定滿足抗碰撞性。例如，在隨機輸入 <code>key</code> 下，雜湊函式 <code>key % 100</code> 可以產生均勻分佈的輸出。然而該雜湊演算法過於簡單，所有後兩位相等的 <code>key</code> 的輸出都相同，因此我們可以很容易地從雜湊值反推出可用的 <code>key</code> ，從而破解密碼。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632","level":2,"title":"6.3.2   雜湊演算法的設計","text":"<p>雜湊演算法的設計是一個需要考慮許多因素的複雜問題。然而對於某些要求不高的場景，我們也能設計一些簡單的雜湊演算法。</p> <ul> <li>加法雜湊：對輸入的每個字元的 ASCII 碼進行相加，將得到的總和作為雜湊值。</li> <li>乘法雜湊：利用乘法的不相關性，每輪乘以一個常數，將各個字元的 ASCII 碼累積到雜湊值中。</li> <li>互斥或雜湊：將輸入資料的每個元素透過互斥或操作累積到一個雜湊值中。</li> <li>旋轉雜湊：將每個字元的 ASCII 碼累積到一個雜湊值中，每次累積之前都會對雜湊值進行旋轉操作。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"加法雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"乘法雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"互斥或雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"旋轉雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* 加法雜湊 */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* 加法雜湊 */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* 加法雜湊 */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* 加法雜湊 */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 乘法雜湊 */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 互斥或雜湊 */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* 旋轉雜湊 */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* 加法雜湊 */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 乘法雜湊 */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 互斥或雜湊 */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* 旋轉雜湊 */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* 加法雜湊 */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乘法雜湊 */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 互斥或雜湊 */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 旋轉雜湊 */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* 加法雜湊 */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乘法雜湊 */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 互斥或雜湊 */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 旋轉雜湊 */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* 加法雜湊 */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* 加法雜湊 */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 乘法雜湊 */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 互斥或雜湊 */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* 旋轉雜湊 */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* 加法雜湊 */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* 加法雜湊 */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 乘法雜湊 */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 互斥或雜湊 */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* 旋轉雜湊 */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### 加法雜湊 ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### 乘法雜湊 ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### 互斥或雜湊 ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### 旋轉雜湊 ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察發現，每種雜湊演算法的最後一步都是對大質數 \\(1000000007\\) 取模，以確保雜湊值在合適的範圍內。值得思考的是，為什麼要強調對質數取模，或者說對合數取模的弊端是什麼？這是一個有趣的問題。</p> <p>先給出結論：使用大質數作為模數，可以最大化地保證雜湊值的均勻分佈。因為質數不與其他數字存在公約數，可以減少因取模操作而產生的週期性模式，從而避免雜湊衝突。</p> <p>舉個例子，假設我們選擇合數 \\(9\\) 作為模數，它可以被 \\(3\\) 整除，那麼所有可以被 \\(3\\) 整除的 <code>key</code> 都會被對映到 \\(0\\)、\\(3\\)、\\(6\\) 這三個雜湊值。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>如果輸入 <code>key</code> 恰好滿足這種等差數列的資料分佈，那麼雜湊值就會出現聚堆積，從而加重雜湊衝突。現在，假設將 <code>modulus</code> 替換為質數 \\(13\\) ，由於 <code>key</code> 和 <code>modulus</code> 之間不存在公約數，因此輸出的雜湊值的均勻性會明顯提升。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>值得說明的是，如果能夠保證 <code>key</code> 是隨機均勻分佈的，那麼選擇質數或者合數作為模數都可以，它們都能輸出均勻分佈的雜湊值。而當 <code>key</code> 的分佈存在某種週期性時，對合數取模更容易出現聚集現象。</p> <p>總而言之，我們通常選取質數作為模數，並且這個質數最好足夠大，以儘可能消除週期性模式，提升雜湊演算法的穩健性。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633","level":2,"title":"6.3.3   常見雜湊演算法","text":"<p>不難發現，以上介紹的簡單雜湊演算法都比較“脆弱”，遠遠沒有達到雜湊演算法的設計目標。例如，由於加法和互斥或滿足交換律，因此加法雜湊和互斥或雜湊無法區分內容相同但順序不同的字串，這可能會加劇雜湊衝突，並引起一些安全問題。</p> <p>在實際中，我們通常會用一些標準雜湊演算法，例如 MD5、SHA-1、SHA-2 和 SHA-3 等。它們可以將任意長度的輸入資料對映到恆定長度的雜湊值。</p> <p>近一個世紀以來，雜湊演算法處在不斷升級與最佳化的過程中。一部分研究人員努力提升雜湊演算法的效能，另一部分研究人員和駭客則致力於尋找雜湊演算法的安全性問題。表 6-2 展示了在實際應用中常見的雜湊演算法。</p> <ul> <li>MD5 和 SHA-1 已多次被成功攻擊，因此它們被各類安全應用棄用。</li> <li>SHA-2 系列中的 SHA-256 是最安全的雜湊演算法之一，仍未出現成功的攻擊案例，因此常用在各類安全應用與協議中。</li> <li>SHA-3 相較 SHA-2 的實現開銷更低、計算效率更高，但目前使用覆蓋度不如 SHA-2 系列。</li> </ul> <p> 表 6-2   常見的雜湊演算法 </p> MD5 SHA-1 SHA-2 SHA-3 推出時間 1992 1995 2002 2008 輸出長度 128 bit 160 bit 256/512 bit 224/256/384/512 bit 雜湊衝突 較多 較多 很少 很少 安全等級 低，已被成功攻擊 低，已被成功攻擊 高 高 應用 已被棄用，仍用於資料完整性檢查 已被棄用 加密貨幣交易驗證、數字簽名等 可用於替代 SHA-2","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634","level":2,"title":"6.3.4   資料結構的雜湊值","text":"<p>我們知道，雜湊表的 <code>key</code> 可以是整數、小數或字串等資料型別。程式語言通常會為這些資料型別提供內建的雜湊演算法，用於計算雜湊表中的桶索引。以 Python 為例，我們可以呼叫 <code>hash()</code> 函式來計算各種資料型別的雜湊值。</p> <ul> <li>整數和布林量的雜湊值就是其本身。</li> <li>浮點數和字串的雜湊值計算較為複雜，有興趣的讀者請自行學習。</li> <li>元組的雜湊值是對其中每一個元素進行雜湊，然後將這些雜湊值組合起來，得到單一的雜湊值。</li> <li>物件的雜湊值基於其記憶體位址生成。透過重寫物件的雜湊方法，可實現基於內容生成雜湊值。</li> </ul> <p>Tip</p> <p>請注意，不同程式語言的內建雜湊值計算函式的定義和方法不同。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# 整數 3 的雜湊值為 3\n\nbol = True\nhash_bol = hash(bol)\n# 布林量 True 的雜湊值為 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# 小數 3.14159 的雜湊值為 326484311674566659\n\nstr = \"Hello 演算法\"\nhash_str = hash(str)\n# 字串“Hello 演算法”的雜湊值為 4617003410720528961\n\ntup = (12836, \"小哈\")\nhash_tup = hash(tup)\n# 元組 (12836, '小哈') 的雜湊值為 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# 節點物件 &lt;ListNode object at 0x1058fd810&gt; 的雜湊值為 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// 整數 3 的雜湊值為 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// 布林量 1 的雜湊值為 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// 小數 3.14159 的雜湊值為 4614256650576692846\n\nstring str = \"Hello 演算法\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// 字串“Hello 演算法”的雜湊值為 15466937326284535026\n\n// 在 C++ 中，內建 std:hash() 僅提供基本資料型別的雜湊值計算\n// 陣列、物件的雜湊值計算需要自行實現\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// 整數 3 的雜湊值為 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// 布林量 true 的雜湊值為 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// 小數 3.14159 的雜湊值為 -1340954729\n\nString str = \"Hello 演算法\";\nint hashStr = str.hashCode();\n// 字串“Hello 演算法”的雜湊值為 -727081396\n\nObject[] arr = { 12836, \"小哈\" };\nint hashTup = Arrays.hashCode(arr);\n// 陣列 [12836, 小哈] 的雜湊值為 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// 節點物件 utils.ListNode@7dc5e7b4 的雜湊值為 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// 整數 3 的雜湊值為 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// 布林量 true 的雜湊值為 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// 小數 3.14159 的雜湊值為 -1340954729;\n\nstring str = \"Hello 演算法\";\nint hashStr = str.GetHashCode();\n// 字串“Hello 演算法”的雜湊值為 -586107568;\n\nobject[] arr = [12836, \"小哈\"];\nint hashTup = arr.GetHashCode();\n// 陣列 [12836, 小哈] 的雜湊值為 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// 節點物件 0 的雜湊值為 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go 未提供內建 hash code 函式\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// 整數 3 的雜湊值為 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// 布林量 true 的雜湊值為 -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// 小數 3.14159 的雜湊值為 -2465384235396674631\n\nlet str = \"Hello 演算法\"\nlet hashStr = str.hashValue\n// 字串“Hello 演算法”的雜湊值為 -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"小哈\")]\nlet hashTup = arr.hashValue\n// 陣列 [AnyHashable(12836), AnyHashable(\"小哈\")] 的雜湊值為 -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// 節點物件 utils.ListNode 的雜湊值為 -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript 未提供內建 hash code 函式\n</code></pre> built_in_hash.ts<pre><code>// TypeScript 未提供內建 hash code 函式\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// 整數 3 的雜湊值為 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// 布林值 true 的雜湊值為 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// 小數 3.14159 的雜湊值為 2570631074981783\n\nString str = \"Hello 演算法\";\nint hashStr = str.hashCode;\n// 字串“Hello 演算法”的雜湊值為 468167534\n\nList arr = [12836, \"小哈\"];\nint hashArr = arr.hashCode;\n// 陣列 [12836, 小哈] 的雜湊值為 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// 節點物件 Instance of 'ListNode' 的雜湊值為 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// 整數 3 的雜湊值為 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// 布林量 true 的雜湊值為 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// 小數 3.14159 的雜湊值為 2566941990314602357\n\nlet str = \"Hello 演算法\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// 字串“Hello 演算法”的雜湊值為 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"小哈\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// 元組 (12836, \"小哈\") 的雜湊值為 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// 節點物件 RefCell { value: ListNode { val: 42, next: None } } 的雜湊值為15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C 未提供內建 hash code 函式\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// 整數 3 的雜湊值為 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// 布林量 true 的雜湊值為 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// 小數 3.14159 的雜湊值為 -1340954729\n\nval str = \"Hello 演算法\"\nval hashStr = str.hashCode()\n// 字串“Hello 演算法”的雜湊值為 -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"小哈\")\nval hashTup = arr.hashCode()\n// 陣列 [12836, 小哈] 的雜湊值為 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// 節點物件 utils.ListNode@1d81eb93 的雜湊值為 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# 整數 3 的雜湊值為 -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# 布林量 true 的雜湊值為 -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# 小數 3.14159 的雜湊值為 -1479186995943067893\n\nstr = \"Hello 演算法\"\nhash_str = str.hash\n# 字串“Hello 演算法”的雜湊值為 -4075943250025831763\n\ntup = [12836, '小哈']\nhash_tup = tup.hash\n# 元組 (12836, '小哈') 的雜湊值為 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# 節點物件 #&lt;ListNode:0x000078133140ab70&gt; 的雜湊值為 4302940560806366381\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在許多程式語言中，只有不可變物件才可作為雜湊表的 <code>key</code> 。假如我們將串列（動態陣列）作為 <code>key</code> ，當串列的內容發生變化時，它的雜湊值也隨之改變，我們就無法在雜湊表中查詢到原先的 <code>value</code> 了。</p> <p>雖然自定義物件（比如鏈結串列節點）的成員變數是可變的，但它是可雜湊的。這是因為物件的雜湊值通常是基於記憶體位址生成的，即使物件的內容發生了變化，但它的記憶體位址不變，雜湊值仍然是不變的。</p> <p>細心的你可能發現在不同控制檯中執行程式時，輸出的雜湊值是不同的。這是因為 Python 直譯器在每次啟動時，都會為字串雜湊函式加入一個隨機的鹽（salt）值。這種做法可以有效防止 HashDoS 攻擊，提升雜湊演算法的安全性。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   雜湊衝突","text":"<p>上一節提到，通常情況下雜湊函式的輸入空間遠大於輸出空間，因此理論上雜湊衝突是不可避免的。比如，輸入空間為全體整數，輸出空間為陣列容量大小，則必然有多個整數對映至同一桶索引。</p> <p>雜湊衝突會導致查詢結果錯誤，嚴重影響雜湊表的可用性。為了解決該問題，每當遇到雜湊衝突時，我們就進行雜湊表擴容，直至衝突消失為止。此方法簡單粗暴且有效，但效率太低，因為雜湊表擴容需要進行大量的資料搬運與雜湊值計算。為了提升效率，我們可以採用以下策略。</p> <ol> <li>改良雜湊表資料結構，使得雜湊表可以在出現雜湊衝突時正常工作。</li> <li>僅在必要時，即當雜湊衝突比較嚴重時，才執行擴容操作。</li> </ol> <p>雜湊表的結構改良方法主要包括“鏈式位址”和“開放定址”。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   鏈式位址","text":"<p>在原始雜湊表中，每個桶僅能儲存一個鍵值對。鏈式位址（separate chaining）將單個元素轉換為鏈結串列，將鍵值對作為鏈結串列節點，將所有發生衝突的鍵值對都儲存在同一鏈結串列中。圖 6-5 展示了一個鏈式位址雜湊表的例子。</p> <p></p> <p> 圖 6-5   鏈式位址雜湊表 </p> <p>基於鏈式位址實現的雜湊表的操作方法發生了以下變化。</p> <ul> <li>查詢元素：輸入 <code>key</code> ，經過雜湊函式得到桶索引，即可訪問鏈結串列頭節點，然後走訪鏈結串列並對比 <code>key</code> 以查詢目標鍵值對。</li> <li>新增元素：首先透過雜湊函式訪問鏈結串列頭節點，然後將節點（鍵值對）新增到鏈結串列中。</li> <li>刪除元素：根據雜湊函式的結果訪問鏈結串列頭部，接著走訪鏈結串列以查詢目標節點並將其刪除。</li> </ul> <p>鏈式位址存在以下侷限性。</p> <ul> <li>佔用空間增大：鏈結串列包含節點指標，它相比陣列更加耗費記憶體空間。</li> <li>查詢效率降低：因為需要線性走訪鏈結串列來查詢對應元素。</li> </ul> <p>以下程式碼給出了鏈式位址雜湊表的簡單實現，需要注意兩點。</p> <ul> <li>使用串列（動態陣列）代替鏈結串列，從而簡化程式碼。在這種設定下，雜湊表（陣列）包含多個桶，每個桶都是一個串列。</li> <li>以下實現包含雜湊表擴容方法。當負載因子超過 \\(\\frac{2}{3}\\) 時，我們將雜湊表擴容至原先的 \\(2\\) 倍。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"鏈式位址雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self.size = 0  # 鍵值對數量\n        self.capacity = 4  # 雜湊表容量\n        self.load_thres = 2.0 / 3.0  # 觸發擴容的負載因子閾值\n        self.extend_ratio = 2  # 擴容倍數\n        self.buckets = [[] for _ in range(self.capacity)]  # 桶陣列\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負載因子\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"查詢操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，若找到 key ，則返回對應 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # 若未找到 key ，則返回 None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"新增操作\"\"\"\n        # 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # 若無該 key ，則將鍵值對新增至尾部\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，從中刪除鍵值對\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"擴容雜湊表\"\"\"\n        # 暫存原雜湊表\n        buckets = self.buckets\n        # 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n  private:\n    int size;                       // 鍵值對數量\n    int capacity;                   // 雜湊表容量\n    double loadThres;               // 觸發擴容的負載因子閾值\n    int extendRatio;                // 擴容倍數\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // 桶陣列\n\n  public:\n    /* 建構子 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* 析構方法 */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // 釋放記憶體\n                delete pair;\n            }\n        }\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // 若未找到 key ，則返回空字串\n        return \"\";\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // 從中刪除鍵值對\n                delete tmp;                       // 釋放記憶體\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // 釋放記憶體\n                delete pair;\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    int size; // 鍵值對數量\n    int capacity; // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio; // 擴容倍數\n    List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n    /* 建構子 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 查詢操作 */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    void put(int key, String val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，從中刪除鍵值對\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    int size; // 鍵值對數量\n    int capacity; // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio; // 擴容倍數\n    List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n    /* 建構子 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // 走訪桶，若找到 key ，則返回對應 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // 走訪桶，從中刪除鍵值對\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void Extend() {\n        // 暫存原雜湊表\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* 鏈式位址雜湊表 */\ntype hashMapChaining struct {\n    size        int      // 鍵值對數量\n    capacity    int      // 雜湊表容量\n    loadThres   float64  // 觸發擴容的負載因子閾值\n    extendRatio int      // 擴容倍數\n    buckets     [][]pair // 桶陣列\n}\n\n/* 建構子 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* 雜湊函式 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* 負載因子 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* 查詢操作 */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // 走訪桶，若找到 key ，則返回對應 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // 若未找到 key ，則返回空字串\n    return \"\"\n}\n\n/* 新增操作 */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // 當負載因子超過閾值時，執行擴容\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // 若無該 key ，則將鍵值對新增至尾部\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* 刪除操作 */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // 走訪桶，從中刪除鍵值對\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // 切片刪除\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* 擴容雜湊表 */\nfunc (m *hashMapChaining) extend() {\n    // 暫存原雜湊表\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // 初始化擴容後的新雜湊表\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* 列印雜湊表 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    var loadThres: Double // 觸發擴容的負載因子閾值\n    var extendRatio: Int // 擴容倍數\n    var buckets: [[Pair]] // 桶陣列\n\n    /* 建構子 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* 雜湊函式 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負載因子 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，若找到 key ，則返回對應 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // 若未找到 key ，則返回 nil\n        return nil\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，從中刪除鍵值對\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    func extend() {\n        // 暫存原雜湊表\n        let bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    #size; // 鍵值對數量\n    #capacity; // 雜湊表容量\n    #loadThres; // 觸發擴容的負載因子閾值\n    #extendRatio; // 擴容倍數\n    #buckets; // 桶陣列\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key, val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend() {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    #size: number; // 鍵值對數量\n    #capacity: number; // 雜湊表容量\n    #loadThres: number; // 觸發擴容的負載因子閾值\n    #extendRatio: number; // 擴容倍數\n    #buckets: Pair[][]; // 桶陣列\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* 查詢操作 */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key: number, val: string): void {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend(): void {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n  late int size; // 鍵值對數量\n  late int capacity; // 雜湊表容量\n  late double loadThres; // 觸發擴容的負載因子閾值\n  late int extendRatio; // 擴容倍數\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n  /* 建構子 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* 雜湊函式 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* 負載因子 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，若找到 key ，則返回對應 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // 若未找到 key ，則返回 null\n    return null;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // 若無該 key ，則將鍵值對新增至尾部\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，從中刪除鍵值對\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* 擴容雜湊表 */\n  void extend() {\n    // 暫存原雜湊表\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // 初始化擴容後的新雜湊表\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* 鏈式位址雜湊表 */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* 建構子 */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* 負載因子 */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* 刪除操作 */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // 走訪桶，從中刪除鍵值對\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // 若未找到 key ，則返回 None\n        None\n    }\n\n    /* 擴容雜湊表 */\n    fn extend(&amp;mut self) {\n        // 暫存原雜湊表\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* 新增操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // 若無該 key ，則將鍵值對新增至尾部\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* 查詢操作 */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // 走訪桶，若找到 key ，則返回對應 val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // 若未找到 key ，則返回 None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* 鏈結串列節點 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* 鏈式位址雜湊表 */\ntypedef struct {\n    int size;         // 鍵值對數量\n    int capacity;     // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio;  // 擴容倍數\n    Node **buckets;   // 桶陣列\n} HashMapChaining;\n\n/* 建構子 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* 析構函式 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* 雜湊函式 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負載因子 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 查詢操作 */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // 走訪桶，若找到 key ，則返回對應 val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // 若未找到 key ，則返回空字串\n}\n\n/* 新增操作 */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // 若遇到指定 key ，則更新對應 val 並返回\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // 若無該 key ，則將鍵值對新增至鏈結串列頭部\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* 擴容雜湊表 */\nvoid extend(HashMapChaining *hashMap) {\n    // 暫存原雜湊表\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // 初始化擴容後的新雜湊表\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // 釋放記憶體\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* 刪除操作 */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // 從中刪除鍵值對\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // 釋放記憶體\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* 列印雜湊表 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    val loadThres: Double // 觸發擴容的負載因子閾值\n    val extendRatio: Int // 擴容倍數\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // 桶陣列\n\n    /* 建構子 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負載因子 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // 若未找到 key ，則返回 null\n        return null\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，從中刪除鍵值對\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fun extend() {\n        // 暫存原雜湊表\n        val bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        // mutablelist 無固定大小\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### 鍵式位址雜湊表 ###\nclass HashMapChaining\n  ### 建構子 ###\n  def initialize\n    @size = 0 # 鍵值對數量\n    @capacity = 4 # 雜湊表容量\n    @load_thres = 2.0 / 3.0 # 觸發擴容的負載因子閾值\n    @extend_ratio = 2 # 擴容倍數\n    @buckets = Array.new(@capacity) { [] } # 桶陣列\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負載因子 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，若找到 key ，則返回對應 val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # 若未找到 key , 則返回 nil\n    nil\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    # 當負載因子超過閾值時，執行擴容\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # 若無該 key ，則將鍵值對新增至尾部\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，從中刪除鍵值對\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### 擴容雜湊表 ###\n  def extend\n    # 暫存原雜湊表\n    buckets = @buckets\n    # 初始化擴容後的新雜湊表\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # 將鍵值對從原雜湊表搬運至新雜湊表\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得注意的是，當鏈結串列很長時，查詢效率 \\(O(n)\\) 很差。此時可以將鏈結串列轉換為“AVL 樹”或“紅黑樹”，從而將查詢操作的時間複雜度最佳化至 \\(O(\\log n)\\) 。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   開放定址","text":"<p>開放定址（open addressing）不引入額外的資料結構，而是透過“多次探測”來處理雜湊衝突，探測方式主要包括線性探查、平方探測和多次雜湊等。</p> <p>下面以線性探查為例，介紹開放定址雜湊表的工作機制。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   線性探查","text":"<p>線性探查採用固定步長的線性搜尋來進行探測，其操作方法與普通雜湊表有所不同。</p> <ul> <li>插入元素：透過雜湊函式計算桶索引，若發現桶內已有元素，則從衝突位置向後線性走訪（步長通常為 \\(1\\) ），直至找到空桶，將元素插入其中。</li> <li>查詢元素：若發現雜湊衝突，則使用相同步長向後進行線性走訪，直到找到對應元素，返回 <code>value</code> 即可；如果遇到空桶，說明目標元素不在雜湊表中，返回 <code>None</code> 。</li> </ul> <p>圖 6-6 展示了開放定址（線性探查）雜湊表的鍵值對分佈。根據此雜湊函式，最後兩位相同的 <code>key</code> 都會被對映到相同的桶。而透過線性探查，它們被依次儲存在該桶以及之下的桶中。</p> <p></p> <p> 圖 6-6   開放定址（線性探查）雜湊表的鍵值對分佈 </p> <p>然而，線性探查容易產生“聚集現象”。具體來說，陣列中連續被佔用的位置越長，這些連續位置發生雜湊衝突的可能性越大，從而進一步促使該位置的聚堆積生長，形成惡性迴圈，最終導致增刪查改操作效率劣化。</p> <p>值得注意的是，我們不能在開放定址雜湊表中直接刪除元素。這是因為刪除元素會在陣列內產生一個空桶 <code>None</code> ，而當查詢元素時，線性探查到該空桶就會返回，因此在該空桶之下的元素都無法再被訪問到，程式可能誤判這些元素不存在，如圖 6-7 所示。</p> <p></p> <p> 圖 6-7   在開放定址中刪除元素導致的查詢問題 </p> <p>為了解決該問題，我們可以採用懶刪除（lazy deletion）機制：它不直接從雜湊表中移除元素，而是利用一個常數 <code>TOMBSTONE</code> 來標記這個桶。在該機制下，<code>None</code> 和 <code>TOMBSTONE</code> 都代表空桶，都可以放置鍵值對。但不同的是，線性探查到 <code>TOMBSTONE</code> 時應該繼續走訪，因為其之下可能還存在鍵值對。</p> <p>然而，懶刪除可能會加速雜湊表的效能退化。這是因為每次刪除操作都會產生一個刪除標記，隨著 <code>TOMBSTONE</code> 的增加，搜尋時間也會增加，因為線性探查可能需要跳過多個 <code>TOMBSTONE</code> 才能找到目標元素。</p> <p>為此，考慮在線性探查中記錄遇到的首個 <code>TOMBSTONE</code> 的索引，並將搜尋到的目標元素與該 <code>TOMBSTONE</code> 交換位置。這樣做的好處是當每次查詢或新增元素時，元素會被移動至距離理想位置（探測起始點）更近的桶，從而最佳化查詢效率。</p> <p>以下程式碼實現了一個包含懶刪除的開放定址（線性探查）雜湊表。為了更加充分地使用雜湊表的空間，我們將雜湊表看作一個“環形陣列”，當越過陣列尾部時，回到頭部繼續走訪。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"開放定址雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self.size = 0  # 鍵值對數量\n        self.capacity = 4  # 雜湊表容量\n        self.load_thres = 2.0 / 3.0  # 觸發擴容的負載因子閾值\n        self.extend_ratio = 2  # 擴容倍數\n        self.buckets: list[Pair | None] = [None] * self.capacity  # 桶陣列\n        self.TOMBSTONE = Pair(-1, \"-1\")  # 刪除標記\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負載因子\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"搜尋 key 對應的桶索引\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # 線性探查，當遇到空桶時跳出\n        while self.buckets[index] is not None:\n            # 若遇到 key ，返回對應的桶索引\n            if self.buckets[index].key == key:\n                # 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # 返回移動後的桶索引\n                return index  # 返回桶索引\n            # 記錄遇到的首個刪除標記\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % self.capacity\n        # 若 key 不存在，則返回新增點的索引\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"查詢操作\"\"\"\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則返回對應 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # 若鍵值對不存在，則返回 None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"新增操作\"\"\"\n        # 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則覆蓋 val 並返回\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # 若鍵值對不存在，則新增該鍵值對\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則用刪除標記覆蓋它\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"擴容雜湊表\"\"\"\n        # 暫存原雜湊表\n        buckets_tmp = self.buckets\n        # 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // 鍵值對數量\n    int capacity = 4;                     // 雜湊表容量\n    const double loadThres = 2.0 / 3.0;     // 觸發擴容的負載因子閾值\n    const int extendRatio = 2;            // 擴容倍數\n    vector&lt;Pair *&gt; buckets;               // 桶陣列\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // 刪除標記\n\n  public:\n    /* 建構子 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* 析構方法 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != nullptr) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index]-&gt;key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // 若鍵值對不存在，則返回空字串\n        return \"\";\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private int size; // 鍵值對數量\n    private int capacity = 4; // 雜湊表容量\n    private final double loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n    private final int extendRatio = 2; // 擴容倍數\n    private Pair[] buckets; // 桶陣列\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // 刪除標記\n\n    /* 建構子 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* 雜湊函式 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index].key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    public String get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void put(int key, String val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    private void extend() {\n        // 暫存原雜湊表\n        Pair[] bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    int size; // 鍵值對數量\n    int capacity = 4; // 雜湊表容量\n    double loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n    int extendRatio = 2; // 擴容倍數\n    Pair[] buckets; // 桶陣列\n    Pair TOMBSTONE = new(-1, \"-1\"); // 刪除標記\n\n    /* 建構子 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index].key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void Extend() {\n        // 暫存原雜湊表\n        Pair[] bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* 開放定址雜湊表 */\ntype hashMapOpenAddressing struct {\n    size        int     // 鍵值對數量\n    capacity    int     // 雜湊表容量\n    loadThres   float64 // 觸發擴容的負載因子閾值\n    extendRatio int     // 擴容倍數\n    buckets     []*pair // 桶陣列\n    TOMBSTONE   *pair   // 刪除標記\n}\n\n/* 建構子 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* 雜湊函式 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // 根據鍵計算雜湊值\n}\n\n/* 負載因子 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // 計算當前負載因子\n}\n\n/* 搜尋 key 對應的桶索引 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // 獲取初始索引\n    firstTombstone := -1     // 記錄遇到的第一個TOMBSTONE的位置\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // 返回移動後的桶索引\n            }\n            return index // 返回找到的索引\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // 記錄遇到的首個刪除標記的位置\n        }\n        index = (index + 1) % h.capacity // 線性探查，越過尾部則返回頭部\n    }\n    // 若 key 不存在，則返回新增點的索引\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* 查詢操作 */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // 若找到鍵值對，則返回對應 val\n    }\n    return \"\" // 若鍵值對不存在，則返回 \"\"\n}\n\n/* 新增操作 */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // 當負載因子超過閾值時，執行擴容\n    }\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // 若鍵值對不存在，則新增該鍵值對\n        h.size++\n    } else {\n        h.buckets[index].val = val // 若找到鍵值對，則覆蓋 val\n    }\n}\n\n/* 刪除操作 */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // 若找到鍵值對，則用刪除標記覆蓋它\n        h.size--\n    }\n}\n\n/* 擴容雜湊表 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // 暫存原雜湊表\n    h.capacity *= h.extendRatio           // 更新容量\n    h.buckets = make([]*pair, h.capacity) // 初始化擴容後的新雜湊表\n    h.size = 0                            // 重置大小\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* 列印雜湊表 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    var loadThres: Double // 觸發擴容的負載因子閾值\n    var extendRatio: Int // 擴容倍數\n    var buckets: [Pair?] // 桶陣列\n    var TOMBSTONE: Pair // 刪除標記\n\n    /* 建構子 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* 雜湊函式 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負載因子 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // 線性探查，當遇到空桶時跳出\n        while buckets[index] != nil {\n            // 若遇到 key ，返回對應的桶索引\n            if buckets[index]!.key == key {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 返回移動後的桶索引\n                }\n                return index // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則返回對應 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // 若鍵值對不存在，則返回 null\n        return nil\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* 擴容雜湊表 */\n    func extend() {\n        // 暫存原雜湊表\n        let bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    #size; // 鍵值對數量\n    #capacity; // 雜湊表容量\n    #loadThres; // 觸發擴容的負載因子閾值\n    #extendRatio; // 擴容倍數\n    #buckets; // 桶陣列\n    #TOMBSTONE; // 刪除標記\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0; // 鍵值對數量\n        this.#capacity = 4; // 雜湊表容量\n        this.#loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n        this.#extendRatio = 2; // 擴容倍數\n        this.#buckets = Array(this.#capacity).fill(null); // 桶陣列\n        this.#TOMBSTONE = new Pair(-1, '-1'); // 刪除標記\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (this.#buckets[index] !== null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (this.#buckets[index].key === key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % this.#capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key, val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key) {\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend() {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private size: number; // 鍵值對數量\n    private capacity: number; // 雜湊表容量\n    private loadThres: number; // 觸發擴容的負載因子閾值\n    private extendRatio: number; // 擴容倍數\n    private buckets: Array&lt;Pair | null&gt;; // 桶陣列\n    private TOMBSTONE: Pair; // 刪除標記\n\n    /* 建構子 */\n    constructor() {\n        this.size = 0; // 鍵值對數量\n        this.capacity = 4; // 雜湊表容量\n        this.loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n        this.extendRatio = 2; // 擴容倍數\n        this.buckets = Array(this.capacity).fill(null); // 桶陣列\n        this.TOMBSTONE = new Pair(-1, '-1'); // 刪除標記\n    }\n\n    /* 雜湊函式 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* 負載因子 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (this.buckets[index] !== null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (this.buckets[index]!.key === key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % this.capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    get(key: number): string | null {\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key: number, val: string): void {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* 刪除操作 */\n    remove(key: number): void {\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    private extend(): void {\n        // 暫存原雜湊表\n        const bucketsTmp = this.buckets;\n        // 初始化擴容後的新雜湊表\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n  late int _size; // 鍵值對數量\n  int _capacity = 4; // 雜湊表容量\n  double _loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n  int _extendRatio = 2; // 擴容倍數\n  late List&lt;Pair?&gt; _buckets; // 桶陣列\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // 刪除標記\n\n  /* 建構子 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* 雜湊函式 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* 負載因子 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* 搜尋 key 對應的桶索引 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // 線性探查，當遇到空桶時跳出\n    while (_buckets[index] != null) {\n      // 若遇到 key ，返回對應的桶索引\n      if (_buckets[index]!.key == key) {\n        // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // 返回移動後的桶索引\n        }\n        return index; // 返回桶索引\n      }\n      // 記錄遇到的首個刪除標記\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // 計算桶索引，越過尾部則返回頭部\n      index = (index + 1) % _capacity;\n    }\n    // 若 key 不存在，則返回新增點的索引\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則返回對應 val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // 若鍵值對不存在，則返回 null\n    return null;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則覆蓋 val 並返回\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // 若鍵值對不存在，則新增該鍵值對\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則用刪除標記覆蓋它\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* 擴容雜湊表 */\n  void extend() {\n    // 暫存原雜湊表\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // 初始化擴容後的新雜湊表\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* 開放定址雜湊表 */\nstruct HashMapOpenAddressing {\n    size: usize,                // 鍵值對數量\n    capacity: usize,            // 雜湊表容量\n    load_thres: f64,            // 觸發擴容的負載因子閾值\n    extend_ratio: usize,        // 擴容倍數\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // 桶陣列\n    TOMBSTONE: Option&lt;Pair&gt;,    // 刪除標記\n}\n\nimpl HashMapOpenAddressing {\n    /* 建構子 */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* 負載因子 */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while self.buckets[index].is_some() {\n            // 若遇到 key，返回對應的桶索引\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // 若之前遇到了刪除標記，則將建值對移動至該索引\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % self.capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* 查詢操作 */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // 若鍵值對不存在，則返回 null\n        None\n    }\n\n    /* 新增操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* 刪除操作 */\n    fn remove(&amp;mut self, key: i32) {\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fn extend(&amp;mut self) {\n        // 暫存原雜湊表\n        let buckets_tmp = self.buckets.clone();\n        // 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* 列印雜湊表 */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* 開放定址雜湊表 */\ntypedef struct {\n    int size;         // 鍵值對數量\n    int capacity;     // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio;  // 擴容倍數\n    Pair **buckets;   // 桶陣列\n    Pair *TOMBSTONE;  // 刪除標記\n} HashMapOpenAddressing;\n\n/* 建構子 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* 析構函式 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* 雜湊函式 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負載因子 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 搜尋 key 對應的桶索引 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // 線性探查，當遇到空桶時跳出\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // 若遇到 key ，返回對應的桶索引\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // 返回移動後的桶索引\n            }\n            return index; // 返回桶索引\n        }\n        // 記錄遇到的首個刪除標記\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // 計算桶索引，越過尾部則返回頭部\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // 若 key 不存在，則返回新增點的索引\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* 查詢操作 */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則返回對應 val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // 若鍵值對不存在，則返回空字串\n    return \"\";\n}\n\n/* 新增操作 */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則覆蓋 val 並返回\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // 若鍵值對不存在，則新增該鍵值對\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* 刪除操作 */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則用刪除標記覆蓋它\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* 擴容雜湊表 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // 暫存原雜湊表\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // 初始化擴容後的新雜湊表\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* 列印雜湊表 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private var size: Int               // 鍵值對數量\n    private var capacity: Int           // 雜湊表容量\n    private val loadThres: Double       // 觸發擴容的負載因子閾值\n    private val extendRatio: Int        // 擴容倍數\n    private var buckets: Array&lt;Pair?&gt;   // 桶陣列\n    private val TOMBSTONE: Pair         // 刪除標記\n\n    /* 建構子 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負載因子 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index]?.key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 返回移動後的桶索引\n                }\n                return index // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // 若鍵值對不存在，則返回 null\n        return null\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fun extend() {\n        // 暫存原雜湊表\n        val bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### 開放定址雜湊表 ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # 刪除標記\n\n  ### 建構子 ###\n  def initialize\n    @size = 0 # 鍵值對數量\n    @capacity = 4 # 雜湊表容量\n    @load_thres = 2.0 / 3.0 # 觸發擴容的負載因子閾值\n    @extend_ratio = 2 # 擴容倍數\n    @buckets = Array.new(@capacity) # 桶陣列\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負載因子 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 搜尋 key 對應的桶索引 ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # 線性探查，當遇到空桶時跳出\n    while !@buckets[index].nil?\n      # 若遇到 key ，返回對應的桶索引\n      if @buckets[index].key == key\n        # 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # 返回移動後的桶索引\n        end\n        return index # 返回桶索引\n      end\n      # 記錄遇到的首個刪除標記\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # 計算桶索引，越過尾部則返回頭部\n      index = (index + 1) % @capacity\n    end\n    # 若 key 不存在，則返回新增點的索引\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則返回對應 val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # 若鍵值對不存在，則返回 nil\n    nil\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    # 當負載因子超過閾值時，執行擴容\n    extend if load_factor &gt; @load_thres\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則覆蓋 val 開返回\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # 若鍵值對不存在，則新增該鍵值對\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則用刪除標記覆蓋它\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### 擴容雜湊表 ###\n  def extend\n    # 暫存原雜湊表\n    buckets_tmp = @buckets\n    # 初始化擴容後的新雜湊表\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # 將鍵值對從原雜湊表搬運至新雜湊表\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   平方探測","text":"<p>平方探測與線性探查類似，都是開放定址的常見策略之一。當發生衝突時，平方探測不是簡單地跳過一個固定的步數，而是跳過“探測次數的平方”的步數，即 \\(1, 4, 9, \\dots\\) 步。</p> <p>平方探測主要具有以下優勢。</p> <ul> <li>平方探測透過跳過探測次數平方的距離，試圖緩解線性探查的聚集效應。</li> <li>平方探測會跳過更大的距離來尋找空位置，有助於資料分佈得更加均勻。</li> </ul> <p>然而，平方探測並不是完美的。</p> <ul> <li>仍然存在聚集現象，即某些位置比其他位置更容易被佔用。</li> <li>由於平方的增長，平方探測可能不會探測整個雜湊表，這意味著即使雜湊表中有空桶，平方探測也可能無法訪問到它。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   多次雜湊","text":"<p>顧名思義，多次雜湊方法使用多個雜湊函式 \\(f_1(x)\\)、\\(f_2(x)\\)、\\(f_3(x)\\)、\\(\\dots\\) 進行探測。</p> <ul> <li>插入元素：若雜湊函式 \\(f_1(x)\\) 出現衝突，則嘗試 \\(f_2(x)\\) ，以此類推，直到找到空位後插入元素。</li> <li>查詢元素：在相同的雜湊函式順序下進行查詢，直到找到目標元素時返回；若遇到空位或已嘗試所有雜湊函式，說明雜湊表中不存在該元素，則返回 <code>None</code> 。</li> </ul> <p>與線性探查相比，多次雜湊方法不易產生聚集，但多個雜湊函式會帶來額外的計算量。</p> <p>Tip</p> <p>請注意，開放定址（線性探查、平方探測和多次雜湊）雜湊表都存在“不能直接刪除元素”的問題。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   程式語言的選擇","text":"<p>各種程式語言採取了不同的雜湊表實現策略，下面舉幾個例子。</p> <ul> <li>Python 採用開放定址。字典 <code>dict</code> 使用偽隨機數進行探測。</li> <li>Java 採用鏈式位址。自 JDK 1.8 以來，當 <code>HashMap</code> 內陣列長度達到 64 且鏈結串列長度達到 8 時，鏈結串列會轉換為紅黑樹以提升查詢效能。</li> <li>Go 採用鏈式位址。Go 規定每個桶最多儲存 8 個鍵值對，超出容量則連線一個溢位桶；當溢位桶過多時，會執行一次特殊的等量擴容操作，以確保效能。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   雜湊表","text":"<p>雜湊表（hash table），又稱散列表，它透過建立鍵 <code>key</code> 與值 <code>value</code> 之間的對映，實現高效的元素查詢。具體而言，我們向雜湊表中輸入一個鍵 <code>key</code> ，則可以在 \\(O(1)\\) 時間內獲取對應的值 <code>value</code> 。</p> <p>如圖 6-1 所示，給定 \\(n\\) 個學生，每個學生都有“姓名”和“學號”兩項資料。假如我們希望實現“輸入一個學號，返回對應的姓名”的查詢功能，則可以採用圖 6-1 所示的雜湊表來實現。</p> <p></p> <p> 圖 6-1   雜湊表的抽象表示 </p> <p>除雜湊表外，陣列和鏈結串列也可以實現查詢功能，它們的效率對比如表 6-1 所示。</p> <ul> <li>新增元素：僅需將元素新增至陣列（鏈結串列）的尾部即可，使用 \\(O(1)\\) 時間。</li> <li>查詢元素：由於陣列（鏈結串列）是亂序的，因此需要走訪其中的所有元素，使用 \\(O(n)\\) 時間。</li> <li>刪除元素：需要先查詢到元素，再從陣列（鏈結串列）中刪除，使用 \\(O(n)\\) 時間。</li> </ul> <p> 表 6-1   元素查詢效率對比 </p> 陣列 鏈結串列 雜湊表 查詢元素 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) 新增元素 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>觀察發現，在雜湊表中進行增刪查改的時間複雜度都是 \\(O(1)\\) ，非常高效。</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#611","level":2,"title":"6.1.1   雜湊表常用操作","text":"<p>雜湊表的常見操作包括：初始化、查詢操作、新增鍵值對和刪除鍵值對等，示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># 初始化雜湊表\nhmap: dict = {}\n\n# 新增操作\n# 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n# 查詢操作\n# 向雜湊表中輸入鍵 key ，得到值 value\nname: str = hmap[15937]\n\n# 刪除操作\n# 在雜湊表中刪除鍵值對 (key, value)\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* 初始化雜湊表 */\nunordered_map&lt;int, string&gt; map;\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\";\nmap[15937] = \"小囉\";\nmap[16750] = \"小算\";\nmap[13276] = \"小法\";\nmap[10583] = \"小鴨\";\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nstring name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* 初始化雜湊表 */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.put(12836, \"小哈\");\nmap.put(15937, \"小囉\");\nmap.put(16750, \"小算\");\nmap.put(13276, \"小法\");\nmap.put(10583, \"小鴨\");\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nString name = map.get(15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* 初始化雜湊表 */\nDictionary&lt;int, string&gt; map = new() {\n    /* 新增操作 */\n    // 在雜湊表中新增鍵值對 (key, value)\n    { 12836, \"小哈\" },\n    { 15937, \"小囉\" },\n    { 16750, \"小算\" },\n    { 13276, \"小法\" },\n    { 10583, \"小鴨\" }\n};\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nstring name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* 初始化雜湊表 */\nhmap := make(map[int]string)\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nname := hmap[15937]\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* 初始化雜湊表 */\nvar map: [Int: String] = [:]\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\"\nmap[15937] = \"小囉\"\nmap[16750] = \"小算\"\nmap[13276] = \"小法\"\nmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map[15937]!\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* 初始化雜湊表 */\nconst map = new Map();\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.set(12836, '小哈');\nmap.set(15937, '小囉');\nmap.set(16750, '小算');\nmap.set(13276, '小法');\nmap.set(10583, '小鴨');\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map.get(15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* 初始化雜湊表 */\nconst map = new Map&lt;number, string&gt;();\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.set(12836, '小哈');\nmap.set(15937, '小囉');\nmap.set(16750, '小算');\nmap.set(13276, '小法');\nmap.set(10583, '小鴨');\nconsole.info('\\n新增完成後，雜湊表為\\nKey -&gt; Value');\nconsole.info(map);\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map.get(15937);\nconsole.info('\\n輸入學號 15937 ，查詢到姓名 ' + name);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.delete(10583);\nconsole.info('\\n刪除 10583 後，雜湊表為\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* 初始化雜湊表 */\nMap&lt;int, String&gt; map = {};\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\";\nmap[15937] = \"小囉\";\nmap[16750] = \"小算\";\nmap[13276] = \"小法\";\nmap[10583] = \"小鴨\";\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nString name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* 初始化雜湊表 */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.insert(12836, \"小哈\".to_string());\nmap.insert(15937, \"小囉\".to_string());\nmap.insert(16750, \"小算\".to_string());\nmap.insert(13279, \"小法\".to_string());\nmap.insert(10583, \"小鴨\".to_string());\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C 未提供內建雜湊表\n</code></pre> hash_map.kt<pre><code>/* 初始化雜湊表 */\nval map = HashMap&lt;Int,String&gt;()\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\"\nmap[15937] = \"小囉\"\nmap[16750] = \"小算\"\nmap[13276] = \"小法\"\nmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nval name = map[15937]\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># 初始化雜湊表\nhmap = {}\n\n# 新增操作\n# 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n# 查詢操作\n# 向雜湊表中輸入鍵 key ，得到值 value\nname = hmap[15937]\n\n# 刪除操作\n# 在雜湊表中刪除鍵值對 (key, value)\nhmap.delete(10583)\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>雜湊表有三種常用的走訪方式：走訪鍵值對、走訪鍵和走訪值。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># 走訪雜湊表\n# 走訪鍵值對 key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# 單獨走訪鍵 key\nfor key in hmap.keys():\n    print(key)\n# 單獨走訪值 value\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// 使用迭代器走訪 key-&gt;value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// 單獨走訪鍵 key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// 單獨走訪值 value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// 單獨走訪鍵 key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// 單獨走訪值 value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// 單獨走訪鍵 key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// 單獨走訪值 value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// 單獨走訪鍵 Key\nfor key in map.keys {\n    print(key)\n}\n// 單獨走訪值 Value\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* 走訪雜湊表 */\nconsole.info('\\n走訪鍵值對 Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\n單獨走訪鍵 Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n單獨走訪值 Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* 走訪雜湊表 */\nconsole.info('\\n走訪鍵值對 Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\n單獨走訪鍵 Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n單獨走訪值 Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// 單獨走訪鍵 Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// 單獨走訪值 Value\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// 單獨走訪鍵 Key\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// 單獨走訪值 Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C 未提供內建雜湊表\n</code></pre> hash_map.kt<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// 單獨走訪鍵 key\nfor (key in map.keys) {\n    println(key)\n}\n// 單獨走訪值 value\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># 走訪雜湊表\n# 走訪鍵值對 key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# 單獨走訪鍵 key\nhmap.keys.each { |key| puts key }\n\n# 單獨走訪值 value\nhmap.values.each { |val| puts val }\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#612","level":2,"title":"6.1.2   雜湊表簡單實現","text":"<p>我們先考慮最簡單的情況，僅用一個陣列來實現雜湊表。在雜湊表中，我們將陣列中的每個空位稱為桶（bucket），每個桶可儲存一個鍵值對。因此，查詢操作就是找到 <code>key</code> 對應的桶，並在桶中獲取 <code>value</code> 。</p> <p>那麼，如何基於 <code>key</code> 定位對應的桶呢？這是透過雜湊函式（hash function）實現的。雜湊函式的作用是將一個較大的輸入空間對映到一個較小的輸出空間。在雜湊表中，輸入空間是所有 <code>key</code> ，輸出空間是所有桶（陣列索引）。換句話說，輸入一個 <code>key</code> ，我們可以透過雜湊函式得到該 <code>key</code> 對應的鍵值對在陣列中的儲存位置。</p> <p>輸入一個 <code>key</code> ，雜湊函式的計算過程分為以下兩步。</p> <ol> <li>透過某種雜湊演算法 <code>hash()</code> 計算得到雜湊值。</li> <li>將雜湊值對桶數量（陣列長度）<code>capacity</code> 取模，從而獲取該 <code>key</code> 對應的桶（陣列索引）<code>index</code> 。</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>隨後，我們就可以利用 <code>index</code> 在雜湊表中訪問對應的桶，從而獲取 <code>value</code> 。</p> <p>設陣列長度 <code>capacity = 100</code>、雜湊演算法 <code>hash(key) = key</code> ，易得雜湊函式為 <code>key % 100</code> 。圖 6-2 以 <code>key</code> 學號和 <code>value</code> 姓名為例，展示了雜湊函式的工作原理。</p> <p></p> <p> 圖 6-2   雜湊函式工作原理 </p> <p>以下程式碼實現了一個簡單雜湊表。其中，我們將 <code>key</code> 和 <code>value</code> 封裝成一個類別 <code>Pair</code> ，以表示鍵值對。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"鍵值對\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"基於陣列實現的雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        # 初始化陣列，包含 100 個桶\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"查詢操作\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"新增和更新操作\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        index: int = self.hash_func(key)\n        # 置為 None ，代表刪除\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"獲取所有鍵值對\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"獲取所有鍵\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"獲取所有值\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* 鍵值對 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // 釋放記憶體\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // 釋放記憶體並置為 nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* 獲取所有鍵值對 */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* 鍵值對 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* 雜湊函式 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* 刪除操作 */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // 置為 null ，代表刪除\n        buckets.set(index, null);\n    }\n\n    /* 獲取所有鍵值對 */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* 鍵值對 int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // 置為 null ，代表刪除\n        buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* 鍵值對 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* 基於陣列實現的雜湊表 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* 初始化雜湊表 */\nfunc newArrayHashMap() *arrayHashMap {\n    // 初始化陣列，包含 100 個桶\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* 雜湊函式 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* 查詢操作 */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* 新增操作 */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* 刪除操作 */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // 置為 nil ，代表刪除\n    a.buckets[index] = nil\n}\n\n/* 獲取所有鍵對 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* 獲取所有鍵 */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* 獲取所有值 */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* 列印雜湊表 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* 鍵值對 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // 初始化陣列，包含 100 個桶\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* 雜湊函式 */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // 置為 nil ，代表刪除\n        buckets[index] = nil\n    }\n\n    /* 獲取所有鍵值對 */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* 獲取所有鍵 */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* 獲取所有值 */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* 鍵值對 Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // 初始化陣列，包含 100 個桶\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* 刪除操作 */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // 置為 null ，代表刪除\n        this.#buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有鍵 */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有值 */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* 鍵值對 Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // 初始化陣列，包含 100 個桶\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* 雜湊函式 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* 查詢操作 */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* 刪除操作 */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // 置為 null ，代表刪除\n        this.buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有鍵 */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有值 */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* 列印雜湊表 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* 鍵值對 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // 初始化陣列，包含 100 個桶\n    _buckets = List.filled(100, null);\n  }\n\n  /* 雜湊函式 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* 獲取所有鍵值對 */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* 獲取所有鍵 */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* 獲取所有值 */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* 鍵值對 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* 基於陣列實現的雜湊表 */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // 初始化陣列，包含 100 個桶\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* 查詢操作 */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* 新增操作 */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* 刪除操作 */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // 置為 None ，代表刪除\n        self.buckets[index] = None;\n    }\n\n    /* 獲取所有鍵值對 */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* 獲取所有鍵 */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* 獲取所有值 */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* 列印雜湊表 */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* 鍵值對 int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* 基於陣列實現的雜湊表 */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* 建構子 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* 析構函式 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* 新增操作 */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* 刪除操作 */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* 獲取所有鍵值對 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* 獲取所有鍵 */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* 獲取所有值 */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* 列印雜湊表 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* 鍵值對 */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    // 初始化陣列，包含 100 個桶\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // 置為 null ，代表刪除\n        buckets[index] = null\n    }\n\n    /* 獲取所有鍵值對 */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* 獲取所有鍵 */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* 獲取所有值 */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### 鍵值對 ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### 基於陣列實現的雜湊表 ###\nclass ArrayHashMap\n  ### 建構子 ###\n  def initialize\n    # 初始化陣列，包含 100 個桶\n    @buckets = Array.new(100)\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    # 置為 nil ，代表刪除\n    @buckets[index] = nil\n  end\n\n  ### 獲取所有鍵值對 ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### 獲取所有鍵 ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### 獲取所有值 ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#613","level":2,"title":"6.1.3   雜湊衝突與擴容","text":"<p>從本質上看，雜湊函式的作用是將所有 <code>key</code> 構成的輸入空間對映到陣列所有索引構成的輸出空間，而輸入空間往往遠大於輸出空間。因此，理論上一定存在“多個輸入對應相同輸出”的情況。</p> <p>對於上述示例中的雜湊函式，當輸入的 <code>key</code> 後兩位相同時，雜湊函式的輸出結果也相同。例如，查詢學號為 12836 和 20336 的兩個學生時，我們得到：</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>如圖 6-3 所示，兩個學號指向了同一個姓名，這顯然是不對的。我們將這種多個輸入對應同一輸出的情況稱為雜湊衝突（hash collision）。</p> <p></p> <p> 圖 6-3   雜湊衝突示例 </p> <p>容易想到，雜湊表容量 \\(n\\) 越大，多個 <code>key</code> 被分配到同一個桶中的機率就越低，衝突就越少。因此，我們可以透過擴容雜湊表來減少雜湊衝突。</p> <p>如圖 6-4 所示，擴容前鍵值對 <code>(136, A)</code> 和 <code>(236, D)</code> 發生衝突，擴容後衝突消失。</p> <p></p> <p> 圖 6-4   雜湊表擴容 </p> <p>類似於陣列擴容，雜湊表擴容需將所有鍵值對從原雜湊表遷移至新雜湊表，非常耗時；並且由於雜湊表容量 <code>capacity</code> 改變，我們需要透過雜湊函式來重新計算所有鍵值對的儲存位置，這進一步增加了擴容過程的計算開銷。為此，程式語言通常會預留足夠大的雜湊表容量，防止頻繁擴容。</p> <p>負載因子（load factor）是雜湊表的一個重要概念，其定義為雜湊表的元素數量除以桶數量，用於衡量雜湊衝突的嚴重程度，也常作為雜湊表擴容的觸發條件。例如在 Java 中，當負載因子超過 \\(0.75\\) 時，系統會將雜湊表擴容至原先的 \\(2\\) 倍。</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   小結","text":"","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>輸入 <code>key</code> ，雜湊表能夠在 \\(O(1)\\) 時間內查詢到 <code>value</code> ，效率非常高。</li> <li>常見的雜湊表操作包括查詢、新增鍵值對、刪除鍵值對和走訪雜湊表等。</li> <li>雜湊函式將 <code>key</code> 對映為陣列索引，從而訪問對應桶並獲取 <code>value</code> 。</li> <li>兩個不同的 <code>key</code> 可能在經過雜湊函式後得到相同的陣列索引，導致查詢結果出錯，這種現象被稱為雜湊衝突。</li> <li>雜湊表容量越大，雜湊衝突的機率就越低。因此可以透過擴容雜湊表來緩解雜湊衝突。與陣列擴容類似，雜湊表擴容操作的開銷很大。</li> <li>負載因子定義為雜湊表中元素數量除以桶數量，反映了雜湊衝突的嚴重程度，常用作觸發雜湊表擴容的條件。</li> <li>鏈式位址透過將單個元素轉化為鏈結串列，將所有衝突元素儲存在同一個鏈結串列中。然而，鏈結串列過長會降低查詢效率，可以透過進一步將鏈結串列轉換為紅黑樹來提高效率。</li> <li>開放定址透過多次探測來處理雜湊衝突。線性探查使用固定步長，缺點是不能刪除元素，且容易產生聚集。多次雜湊使用多個雜湊函式進行探測，相較線性探查更不易產生聚集，但多個雜湊函式增加了計算量。</li> <li>不同程式語言採取了不同的雜湊表實現。例如，Java 的 <code>HashMap</code> 使用鏈式位址，而 Python 的 <code>Dict</code> 採用開放定址。</li> <li>在雜湊表中，我們希望雜湊演算法具有確定性、高效率和均勻分佈的特點。在密碼學中，雜湊演算法還應該具備抗碰撞性和雪崩效應。</li> <li>雜湊演算法通常採用大質數作為模數，以最大化地保證雜湊值均勻分佈，減少雜湊衝突。</li> <li>常見的雜湊演算法包括 MD5、SHA-1、SHA-2 和 SHA-3 等。MD5 常用於校驗檔案完整性，SHA-2 常用於安全應用與協議。</li> <li>程式語言通常會為資料型別提供內建雜湊演算法，用於計算雜湊表中的桶索引。通常情況下，只有不可變物件是可雜湊的。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：雜湊表的時間複雜度在什麼情況下是 \\(O(n)\\) ？</p> <p>當雜湊衝突比較嚴重時，雜湊表的時間複雜度會退化至 \\(O(n)\\) 。當雜湊函式設計得比較好、容量設定比較合理、衝突比較平均時，時間複雜度是 \\(O(1)\\) 。我們使用程式語言內建的雜湊表時，通常認為時間複雜度是 \\(O(1)\\) 。</p> <p>Q：為什麼不使用雜湊函式 \\(f(x) = x\\) 呢？這樣就不會有衝突了。</p> <p>在 \\(f(x) = x\\) 雜湊函式下，每個元素對應唯一的桶索引，這與陣列等價。然而，輸入空間通常遠大於輸出空間（陣列長度），因此雜湊函式的最後一步往往是對陣列長度取模。換句話說，雜湊表的目標是將一個較大的狀態空間對映到一個較小的空間，並提供 \\(O(1)\\) 的查詢效率。</p> <p>Q：雜湊表底層實現是陣列、鏈結串列、二元樹，但為什麼效率可以比它們更高呢？</p> <p>首先，雜湊表的時間效率變高，但空間效率變低了。雜湊表有相當一部分記憶體未使用。</p> <p>其次，只是在特定使用場景下時間效率變高了。如果一個功能能夠在相同的時間複雜度下使用陣列或鏈結串列實現，那麼通常比雜湊表更快。這是因為雜湊函式計算需要開銷，時間複雜度的常數項更大。</p> <p>最後，雜湊表的時間複雜度可能發生劣化。例如在鏈式位址中，我們採取在鏈結串列或紅黑樹中執行查詢操作，仍然有退化至 \\(O(n)\\) 時間的風險。</p> <p>Q：多次雜湊有不能直接刪除元素的缺陷嗎？標記為已刪除的空間還能再次使用嗎？</p> <p>多次雜湊是開放定址的一種，開放定址法都有不能直接刪除元素的缺陷，需要透過標記刪除。標記為已刪除的空間可以再次使用。當將新元素插入雜湊表，並且透過雜湊函式找到標記為已刪除的位置時，該位置可以被新元素使用。這樣做既能保持雜湊表的探測序列不變，又能保證雜湊表的空間使用率。</p> <p>Q：為什麼在線性探查中，查詢元素的時候會出現雜湊衝突呢？</p> <p>查詢的時候透過雜湊函式找到對應的桶和鍵值對，發現 <code>key</code> 不匹配，這就代表有雜湊衝突。因此，線性探查法會根據預先設定的步長依次向下查詢，直至找到正確的鍵值對或無法找到跳出為止。</p> <p>Q：為什麼雜湊表擴容能夠緩解雜湊衝突？</p> <p>雜湊函式的最後一步往往是對陣列長度 \\(n\\) 取模（取餘），讓輸出值落在陣列索引範圍內；在擴容後，陣列長度 \\(n\\) 發生變化，而 <code>key</code> 對應的索引也可能發生變化。原先落在同一個桶的多個 <code>key</code> ，在擴容後可能會被分配到多個桶中，從而實現雜湊衝突的緩解。</p> <p>Q：如果為了高效的存取，那麼直接使用陣列不就好了嗎？</p> <p>當資料的 <code>key</code> 是連續的小範圍整數時，直接用陣列即可，簡單高效。但當 <code>key</code> 是其他型別（例如字串）時，就需要藉助雜湊函式將 <code>key</code> 對映為陣列索引，再透過桶陣列儲存元素，這樣的結構就是雜湊表。</p>","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"第 8 章   堆積","text":"<p>Abstract</p> <p>堆積就像是山嶽峰巒，層疊起伏、形態各異。</p> <p>座座山峰高低錯落，而最高的山峰總是最先映入眼簾。</p>","path":["第 8 章 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"本章內容","text":"<ul> <li>8.1   堆積</li> <li>8.2   建堆積操作</li> <li>8.3   Top-k 問題</li> <li>8.4   小結</li> </ul>","path":["第 8 章 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   建堆積操作","text":"<p>在某些情況下，我們希望使用一個串列的所有元素來構建一個堆積，這個過程被稱為“建堆積操作”。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   藉助入堆積操作實現","text":"<p>我們首先建立一個空堆積，然後走訪串列，依次對每個元素執行“入堆積操作”，即先將元素新增至堆積的尾部，再對該元素執行“從底至頂”堆積化。</p> <p>每當一個元素入堆積，堆積的長度就加一。由於節點是從頂到底依次被新增進二元樹的，因此堆積是“自上而下”構建的。</p> <p>設元素數量為 \\(n\\) ，每個元素的入堆積操作使用 \\(O(\\log{n})\\) 時間，因此該建堆積方法的時間複雜度為 \\(O(n \\log n)\\) 。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   透過走訪堆積化實現","text":"<p>實際上，我們可以實現一種更為高效的建堆積方法，共分為兩步。</p> <ol> <li>將串列所有元素原封不動地新增到堆積中，此時堆積的性質尚未得到滿足。</li> <li>倒序走訪堆積（層序走訪的倒序），依次對每個非葉節點執行“從頂至底堆積化”。</li> </ol> <p>每當堆積化一個節點後，以該節點為根節點的子樹就形成一個合法的子堆積。而由於是倒序走訪，因此堆積是“自下而上”構建的。</p> <p>之所以選擇倒序走訪，是因為這樣能夠保證當前節點之下的子樹已經是合法的子堆積，這樣堆積化當前節點才是有效的。</p> <p>值得說明的是，由於葉節點沒有子節點，因此它們天然就是合法的子堆積，無須堆積化。如以下程式碼所示，最後一個非葉節點是最後一個節點的父節點，我們從它開始倒序走訪並執行堆積化：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"建構子，根據輸入串列建堆積\"\"\"\n    # 將串列元素原封不動新增進堆積\n    self.max_heap = nums\n    # 堆積化除葉節點以外的其他所有節點\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(vector&lt;int&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = nums;\n    // 堆積化除葉節點以外的其他所有節點\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // 堆積化除葉節點以外的其他所有節點\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = new List&lt;int&gt;(nums);\n    // 堆積化除葉節點以外的其他所有節點\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 建構子，根據切片建堆積 */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // 將串列元素原封不動新增進堆積\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // 堆積化除葉節點以外的其他所有節點\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* 建構子，根據輸入串列建堆積 */\ninit(nums: [Int]) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = nums\n    // 堆積化除葉節點以外的其他所有節點\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 建構子，建立空堆積或根據輸入串列建堆積 */\nconstructor(nums) {\n    // 將串列元素原封不動新增進堆積\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // 堆積化除葉節點以外的其他所有節點\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 建構子，建立空堆積或根據輸入串列建堆積 */\nconstructor(nums?: number[]) {\n    // 將串列元素原封不動新增進堆積\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // 堆積化除葉節點以外的其他所有節點\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(List&lt;int&gt; nums) {\n  // 將串列元素原封不動新增進堆積\n  _maxHeap = nums;\n  // 堆積化除葉節點以外的其他所有節點\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 建構子，根據輸入串列建堆積 */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // 將串列元素原封不動新增進堆積\n    let mut heap = MaxHeap { max_heap: nums };\n    // 堆積化除葉節點以外的其他所有節點\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* 建構子，根據切片建堆積 */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // 所有元素入堆積\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // 堆積化除葉節點以外的其他所有節點\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* 大頂堆積 */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // 使用串列而非陣列，這樣無須考慮擴容問題\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* 建構子，根據輸入串列建堆積 */\n    init {\n        // 將串列元素原封不動新增進堆積\n        maxHeap.addAll(nums!!)\n        // 堆積化除葉節點以外的其他所有節點\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* 獲取左子節點的索引 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 獲取右子節點的索引 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 獲取父節點的索引 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // 向下整除\n    }\n\n    /* 交換元素 */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* 獲取堆積大小 */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* 判斷堆積是否為空 */\n    fun isEmpty(): Boolean {\n        /* 判斷堆積是否為空 */\n        return size() == 0\n    }\n\n    /* 訪問堆積頂元素 */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* 元素入堆積 */\n    fun push(_val: Int) {\n        // 新增節點\n        maxHeap.add(_val)\n        // 從底至頂堆積化\n        siftUp(size() - 1)\n    }\n\n    /* 從節點 i 開始，從底至頂堆積化 */\n    private fun siftUp(it: Int) {\n        // Kotlin的函式參數不可變，因此建立臨時變數\n        var i = it\n        while (true) {\n            // 獲取節點 i 的父節點\n            val p = parent(i)\n            // 當“越過根節點”或“節點無須修復”時，結束堆積化\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // 交換兩節點\n            swap(i, p)\n            // 迴圈向上堆積化\n            i = p\n        }\n    }\n\n    /* 元素出堆積 */\n    fun pop(): Int {\n        // 判空處理\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        swap(0, size() - 1)\n        // 刪除節點\n        val _val = maxHeap.removeAt(size() - 1)\n        // 從頂至底堆積化\n        siftDown(0)\n        // 返回堆積頂元素\n        return _val\n    }\n\n    /* 從節點 i 開始，從頂至底堆積化 */\n    private fun siftDown(it: Int) {\n        // Kotlin的函式參數不可變，因此建立臨時變數\n        var i = it\n        while (true) {\n            // 判斷節點 i, l, r 中值最大的節點，記為 ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n            if (ma == i) break\n            // 交換兩節點\n            swap(i, ma)\n            // 迴圈向下堆積化\n            i = ma\n        }\n    }\n\n    /* 列印堆積（二元樹） */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 建構子，根據輸入串列建堆積 ###\ndef initialize(nums)\n  # 將串列元素原封不動新增進堆積\n  @max_heap = nums\n  # 堆積化除葉節點以外的其他所有節點\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   複雜度分析","text":"<p>下面，我們來嘗試推算第二種建堆積方法的時間複雜度。</p> <ul> <li>假設完全二元樹的節點數量為 \\(n\\) ，則葉節點數量為 \\((n + 1) / 2\\) ，其中 \\(/\\) 為向下整除。因此需要堆積化的節點數量為 \\((n - 1) / 2\\) 。</li> <li>在從頂至底堆積化的過程中，每個節點最多堆積化到葉節點，因此最大迭代次數為二元樹高度 \\(\\log n\\) 。</li> </ul> <p>將上述兩者相乘，可得到建堆積過程的時間複雜度為 \\(O(n \\log n)\\) 。但這個估算結果並不準確，因為我們沒有考慮到二元樹底層節點數量遠多於頂層節點的性質。</p> <p>接下來我們來進行更為準確的計算。為了降低計算難度，假設給定一個節點數量為 \\(n\\) 、高度為 \\(h\\) 的“完美二元樹”，該假設不會影響計算結果的正確性。</p> <p></p> <p> 圖 8-5   完美二元樹的各層節點數量 </p> <p>如圖 8-5 所示，節點“從頂至底堆積化”的最大迭代次數等於該節點到葉節點的距離，而該距離正是“節點高度”。因此，我們可以對各層的“節點數量 \\(\\times\\) 節點高度”求和，得到所有節點的堆積化迭代次數的總和。</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>化簡上式需要藉助中學的數列知識，先將 \\(T(h)\\) 乘以 \\(2\\) ，得到：</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>使用錯位相減法，用下式 \\(2 T(h)\\) 減去上式 \\(T(h)\\) ，可得：</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>觀察上式，發現 \\(T(h)\\) 是一個等比數列，可直接使用求和公式，得到時間複雜度為：</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>進一步，高度為 \\(h\\) 的完美二元樹的節點數量為 \\(n = 2^{h+1} - 1\\) ，易得複雜度為 \\(O(2^h) = O(n)\\) 。以上推算表明，輸入串列並建堆積的時間複雜度為 \\(O(n)\\) ，非常高效。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   堆積","text":"<p>堆積（heap）是一種滿足特定條件的完全二元樹，主要可分為兩種型別，如圖 8-1 所示。</p> <ul> <li>小頂堆積（min heap）：任意節點的值 \\(\\leq\\) 其子節點的值。</li> <li>大頂堆積（max heap）：任意節點的值 \\(\\geq\\) 其子節點的值。</li> </ul> <p></p> <p> 圖 8-1   小頂堆積與大頂堆積 </p> <p>堆積作為完全二元樹的一個特例，具有以下特性。</p> <ul> <li>最底層節點靠左填充，其他層的節點都被填滿。</li> <li>我們將二元樹的根節點稱為“堆積頂”，將底層最靠右的節點稱為“堆積底”。</li> <li>對於大頂堆積（小頂堆積），堆積頂元素（根節點）的值是最大（最小）的。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   堆積的常用操作","text":"<p>需要指出的是，許多程式語言提供的是優先佇列（priority queue），這是一種抽象的資料結構，定義為具有優先順序排序的佇列。</p> <p>實際上，堆積通常用於實現優先佇列，大頂堆積相當於元素按從大到小的順序出列的優先佇列。從使用角度來看，我們可以將“優先佇列”和“堆積”看作等價的資料結構。因此，本書對兩者不做特別區分，統一稱作“堆積”。</p> <p>堆積的常用操作見表 8-1 ，方法名需要根據程式語言來確定。</p> <p> 表 8-1   堆積的操作效率 </p> 方法名 描述 時間複雜度 <code>push()</code> 元素入堆積 \\(O(\\log n)\\) <code>pop()</code> 堆積頂元素出堆積 \\(O(\\log n)\\) <code>peek()</code> 訪問堆積頂元素（對於大 / 小頂堆積分別為最大 / 小值） \\(O(1)\\) <code>size()</code> 獲取堆積的元素數量 \\(O(1)\\) <code>isEmpty()</code> 判斷堆積是否為空 \\(O(1)\\) <p>在實際應用中，我們可以直接使用程式語言提供的堆積類別（或優先佇列類別）。</p> <p>類似於排序演算法中的“從小到大排列”和“從大到小排列”，我們可以透過設定一個 <code>flag</code> 或修改 <code>Comparator</code> 實現“小頂堆積”與“大頂堆積”之間的轉換。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># 初始化小頂堆積\nmin_heap, flag = [], 1\n# 初始化大頂堆積\nmax_heap, flag = [], -1\n\n# Python 的 heapq 模組預設實現小頂堆積\n# 考慮將“元素取負”後再入堆積，這樣就可以將大小關係顛倒，從而實現大頂堆積\n# 在本示例中，flag = 1 時對應小頂堆積，flag = -1 時對應大頂堆積\n\n# 元素入堆積\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# 獲取堆積頂元素\npeek: int = flag * max_heap[0] # 5\n\n# 堆積頂元素出堆積\n# 出堆積元素會形成一個從大到小的序列\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# 獲取堆積大小\nsize: int = len(max_heap)\n\n# 判斷堆積是否為空\nis_empty: bool = not max_heap\n\n# 輸入串列並建堆積\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// 初始化大頂堆積\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* 元素入堆積 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.top(); // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.size();\n\n/* 判斷堆積是否為空 */\nbool isEmpty = maxHeap.empty();\n\n/* 輸入串列並建堆積 */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparator 即可）\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* 元素入堆積 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.peek(); // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.size();\n\n/* 判斷堆積是否為空 */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* 輸入串列並建堆積 */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparer 即可）\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* 元素入堆積 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.Peek();//5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.Count;\n\n/* 判斷堆積是否為空 */\nbool isEmpty = maxHeap.Count == 0;\n\n/* 輸入串列並建堆積 */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// Go 語言中可以透過實現 heap.Interface 來構建整數大頂堆積\n// 實現 heap.Interface 需要同時實現 sort.Interface\ntype intHeap []any\n\n// Push heap.Interface 的方法，實現推入元素到堆積\nfunc (h *intHeap) Push(x any) {\n    // Push 和 Pop 使用 pointer receiver 作為參數\n    // 因為它們不僅會對切片的內容進行調整，還會修改切片的長度。\n    *h = append(*h, x.(int))\n}\n\n// Pop heap.Interface 的方法，實現彈出堆積頂元素\nfunc (h *intHeap) Pop() any {\n    // 待出堆積元素存放在最後\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len sort.Interface 的方法\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less sort.Interface 的方法\nfunc (h *intHeap) Less(i, j int) bool {\n    // 如果實現小頂堆積，則需要調整為小於號\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap sort.Interface 的方法\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top 獲取堆積頂元素\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* 初始化堆積 */\n    // 初始化大頂堆積\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* 元素入堆積 */\n    // 呼叫 heap.Interface 的方法，來新增元素\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* 獲取堆積頂元素 */\n    top := maxHeap.Top()\n    fmt.Printf(\"堆積頂元素為 %d\\n\", top)\n\n    /* 堆積頂元素出堆積 */\n    // 呼叫 heap.Interface 的方法，來移除元素\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* 獲取堆積大小 */\n    size := len(*maxHeap)\n    fmt.Printf(\"堆積元素數量為 %d\\n\", size)\n\n    /* 判斷堆積是否為空 */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"堆積是否為空 %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* 初始化堆積 */\n// Swift 的 Heap 型別同時支持最大堆積和最小堆積，且需要引入 swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* 元素入堆積 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* 獲取堆積頂元素 */\nvar peek = heap.max()!\n\n/* 堆積頂元素出堆積 */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* 獲取堆積大小 */\nlet size = heap.count\n\n/* 判斷堆積是否為空 */\nlet isEmpty = heap.isEmpty\n\n/* 輸入串列並建堆積 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript 未提供內建 Heap 類別\n</code></pre> heap.ts<pre><code>// TypeScript 未提供內建 Heap 類別\n</code></pre> heap.dart<pre><code>// Dart 未提供內建 Heap 類別\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* 初始化堆積 */\n// 初始化小頂堆積\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// 初始化大頂堆積\nlet mut max_heap = BinaryHeap::new();\n\n/* 元素入堆積 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* 獲取堆積頂元素 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* 獲取堆積大小 */\nlet size = max_heap.len();\n\n/* 判斷堆積是否為空 */\nlet is_empty = max_heap.is_empty();\n\n/* 輸入串列並建堆積 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C 未提供內建 Heap 類別\n</code></pre> heap.kt<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparator 即可）\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* 元素入堆積 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* 獲取堆積頂元素 */\nvar peek = maxHeap.peek() // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* 獲取堆積大小 */\nval size = maxHeap.size\n\n/* 判斷堆積是否為空 */\nval isEmpty = maxHeap.isEmpty()\n\n/* 輸入串列並建堆積 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby 未提供內建 Heap 類別\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   堆積的實現","text":"<p>下文實現的是大頂堆積。若要將其轉換為小頂堆積，只需將所有大小邏輯判斷進行逆轉（例如，將 \\(\\geq\\) 替換為 \\(\\leq\\) ）。感興趣的讀者可以自行實現。</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   堆積的儲存與表示","text":"<p>“二元樹”章節講過，完全二元樹非常適合用陣列來表示。由於堆積正是一種完全二元樹，因此我們將採用陣列來儲存堆積。</p> <p>當使用陣列表示二元樹時，元素代表節點值，索引代表節點在二元樹中的位置。節點指標透過索引對映公式來實現。</p> <p>如圖 8-2 所示，給定索引 \\(i\\) ，其左子節點的索引為 \\(2i + 1\\) ，右子節點的索引為 \\(2i + 2\\) ，父節點的索引為 \\((i - 1) / 2\\)（向下整除）。當索引越界時，表示空節點或節點不存在。</p> <p></p> <p> 圖 8-2   堆積的表示與儲存 </p> <p>我們可以將索引對映公式封裝成函式，方便後續使用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"獲取左子節點的索引\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"獲取右子節點的索引\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"獲取父節點的索引\"\"\"\n    return (i - 1) // 2  # 向下整除\n</code></pre> my_heap.cpp<pre><code>/* 獲取左子節點的索引 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.java<pre><code>/* 獲取左子節點的索引 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.cs<pre><code>/* 獲取左子節點的索引 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint Parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.go<pre><code>/* 獲取左子節點的索引 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* 獲取右子節點的索引 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* 獲取父節點的索引 */\nfunc (h *maxHeap) parent(i int) int {\n    // 向下整除\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* 獲取左子節點的索引 */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.js<pre><code>/* 獲取左子節點的索引 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // 向下整除\n}\n</code></pre> my_heap.ts<pre><code>/* 獲取左子節點的索引 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // 向下整除\n}\n</code></pre> my_heap.dart<pre><code>/* 獲取左子節點的索引 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // 向下整除\n}\n</code></pre> my_heap.rs<pre><code>/* 獲取左子節點的索引 */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.c<pre><code>/* 獲取左子節點的索引 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // 向下取整\n}\n</code></pre> my_heap.kt<pre><code>/* 獲取左子節點的索引 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.rb<pre><code>### 獲取左子節點的索引 ###\ndef left(i)\n  2 * i + 1\nend\n\n### 獲取右子節點的索引 ###\ndef right(i)\n  2 * i + 2\nend\n\n### 獲取父節點的索引 ###\ndef parent(i)\n  (i - 1) / 2     # 向下整除\nend\n</code></pre>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   訪問堆積頂元素","text":"<p>堆積頂元素即為二元樹的根節點，也就是串列的首個元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"訪問堆積頂元素\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* 訪問堆積頂元素 */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* 訪問堆積頂元素 */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* 訪問堆積頂元素 */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* 訪問堆積頂元素 */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* 訪問堆積頂元素 */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* 訪問堆積頂元素 */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* 訪問堆積頂元素 */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* 訪問堆積頂元素 */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### 訪問堆積頂元素 ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   元素入堆積","text":"<p>給定元素 <code>val</code> ，我們首先將其新增到堆積底。新增之後，由於 <code>val</code> 可能大於堆積中其他元素，堆積的成立條件可能已被破壞，因此需要修復從插入節點到根節點的路徑上的各個節點，這個操作被稱為堆積化（heapify）。</p> <p>考慮從入堆積節點開始，從底至頂執行堆積化。如圖 8-3 所示，我們比較插入節點與其父節點的值，如果插入節點更大，則將它們交換。然後繼續執行此操作，從底至頂修復堆積中的各個節點，直至越過根節點或遇到無須交換的節點時結束。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-3   元素入堆積步驟 </p> <p>設節點總數為 \\(n\\) ，則樹的高度為 \\(O(\\log n)\\) 。由此可知，堆積化操作的迴圈輪數最多為 \\(O(\\log n)\\) ，元素入堆積操作的時間複雜度為 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"元素入堆積\"\"\"\n    # 新增節點\n    self.max_heap.append(val)\n    # 從底至頂堆積化\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"從節點 i 開始，從底至頂堆積化\"\"\"\n    while True:\n        # 獲取節點 i 的父節點\n        p = self.parent(i)\n        # 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # 交換兩節點\n        self.swap(i, p)\n        # 迴圈向上堆積化\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n    // 新增節點\n    maxHeap.push_back(val);\n    // 從底至頂堆積化\n    siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 交換兩節點\n        swap(maxHeap[i], maxHeap[p]);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n    // 新增節點\n    maxHeap.add(val);\n    // 從底至頂堆積化\n    siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // 交換兩節點\n        swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 元素入堆積 */\nvoid Push(int val) {\n    // 新增節點\n    maxHeap.Add(val);\n    // 從底至頂堆積化\n    SiftUp(Size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid SiftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = Parent(i);\n        // 若“越過根節點”或“節點無須修復”，則結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 交換兩節點\n        Swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 元素入堆積 */\nfunc (h *maxHeap) push(val any) {\n    // 新增節點\n    h.data = append(h.data, val)\n    // 從底至頂堆積化\n    h.siftUp(len(h.data) - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // 獲取節點 i 的父節點\n        p := h.parent(i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // 交換兩節點\n        h.swap(i, p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 元素入堆積 */\nfunc push(val: Int) {\n    // 新增節點\n    maxHeap.append(val)\n    // 從底至頂堆積化\n    siftUp(i: size() - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // 獲取節點 i 的父節點\n        let p = parent(i: i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // 交換兩節點\n        swap(i: i, j: p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 元素入堆積 */\npush(val) {\n    // 新增節點\n    this.#maxHeap.push(val);\n    // 從底至頂堆積化\n    this.#siftUp(this.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\n#siftUp(i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        const p = this.#parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // 交換兩節點\n        this.#swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 元素入堆積 */\npush(val: number): void {\n    // 新增節點\n    this.maxHeap.push(val);\n    // 從底至頂堆積化\n    this.siftUp(this.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nsiftUp(i: number): void {\n    while (true) {\n        // 獲取節點 i 的父節點\n        const p = this.parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // 交換兩節點\n        this.swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n  // 新增節點\n  _maxHeap.add(val);\n  // 從底至頂堆積化\n  siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n  while (true) {\n    // 獲取節點 i 的父節點\n    int p = _parent(i);\n    // 當“越過根節點”或“節點無須修復”時，結束堆積化\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // 交換兩節點\n    _swap(i, p);\n    // 迴圈向上堆積化\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 元素入堆積 */\nfn push(&amp;mut self, val: i32) {\n    // 新增節點\n    self.max_heap.push(val);\n    // 從底至頂堆積化\n    self.sift_up(self.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // 節點 i 已經是堆積頂節點了，結束堆積化\n        if i == 0 {\n            break;\n        }\n        // 獲取節點 i 的父節點\n        let p = Self::parent(i);\n        // 當“節點無須修復”時，結束堆積化\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // 交換兩節點\n        self.swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 元素入堆積 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // 預設情況下，不應該新增這麼多節點\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // 新增節點\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // 從底至頂堆積化\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(maxHeap, i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // 交換兩節點\n        swap(maxHeap, i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 元素入堆積 */\nfun push(_val: Int) {\n    // 新增節點\n    maxHeap.add(_val)\n    // 從底至頂堆積化\n    siftUp(size() - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfun siftUp(it: Int) {\n    // Kotlin的函式參數不可變，因此建立臨時變數\n    var i = it\n    while (true) {\n        // 獲取節點 i 的父節點\n        val p = parent(i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // 交換兩節點\n        swap(i, p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 元素入堆積 ###\ndef push(val)\n  # 新增節點\n  @max_heap &lt;&lt; val\n  # 從底至頂堆積化\n  sift_up(size - 1)\nend\n\n### 從節點 i 開始，從底至頂堆積化 ###\ndef sift_up(i)\n  loop do\n    # 獲取節點 i 的父節點\n    p = parent(i)\n    # 當“越過根節點”或“節點無須修復”時，結束堆積化\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # 交換兩節點\n    swap(i, p)\n    # 迴圈向上堆積化\n    i = p\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   堆積頂元素出堆積","text":"<p>堆積頂元素是二元樹的根節點，即串列首元素。如果我們直接從串列中刪除首元素，那麼二元樹中所有節點的索引都會發生變化，這將使得後續使用堆積化進行修復變得困難。為了儘量減少元素索引的變動，我們採用以下操作步驟。</p> <ol> <li>交換堆積頂元素與堆積底元素（交換根節點與最右葉節點）。</li> <li>交換完成後，將堆積底從串列中刪除（注意，由於已經交換，因此實際上刪除的是原來的堆積頂元素）。</li> <li>從根節點開始，從頂至底執行堆積化。</li> </ol> <p>如圖 8-4 所示，“從頂至底堆積化”的操作方向與“從底至頂堆積化”相反，我們將根節點的值與其兩個子節點的值進行比較，將最大的子節點與根節點交換。然後迴圈執行此操作，直到越過葉節點或遇到無須交換的節點時結束。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-4   堆積頂元素出堆積步驟 </p> <p>與元素入堆積操作相似，堆積頂元素出堆積操作的時間複雜度也為 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"元素出堆積\"\"\"\n    # 判空處理\n    if self.is_empty():\n        raise IndexError(\"堆積為空\")\n    # 交換根節點與最右葉節點（交換首元素與尾元素）\n    self.swap(0, self.size() - 1)\n    # 刪除節點\n    val = self.max_heap.pop()\n    # 從頂至底堆積化\n    self.sift_down(0)\n    # 返回堆積頂元素\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"從節點 i 開始，從頂至底堆積化\"\"\"\n    while True:\n        # 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i:\n            break\n        # 交換兩節點\n        self.swap(i, ma)\n        # 迴圈向下堆積化\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* 元素出堆積 */\nvoid pop() {\n    // 判空處理\n    if (isEmpty()) {\n        throw out_of_range(\"堆積為空\");\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // 刪除節點\n    maxHeap.pop_back();\n    // 從頂至底堆積化\n    siftDown(0);\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 元素出堆積 */\nint pop() {\n    // 判空處理\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(0, size() - 1);\n    // 刪除節點\n    int val = maxHeap.remove(size() - 1);\n    // 從頂至底堆積化\n    siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 元素出堆積 */\nint Pop() {\n    // 判空處理\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    Swap(0, Size() - 1);\n    // 刪除節點\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // 從頂至底堆積化\n    SiftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid SiftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 若“節點 i 最大”或“越過葉節點”，則結束堆積化\n        if (ma == i) break;\n        // 交換兩節點\n        Swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 元素出堆積 */\nfunc (h *maxHeap) pop() any {\n    // 判空處理\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    h.swap(0, h.size()-1)\n    // 刪除節點\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // 從頂至底堆積化\n    h.siftDown(0)\n\n    // 返回堆積頂元素\n    return val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if max == i {\n            break\n        }\n        // 交換兩節點\n        h.swap(i, max)\n        // 迴圈向下堆積化\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 元素出堆積 */\nfunc pop() -&gt; Int {\n    // 判空處理\n    if isEmpty() {\n        fatalError(\"堆積為空\")\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(i: 0, j: size() - 1)\n    // 刪除節點\n    let val = maxHeap.remove(at: size() - 1)\n    // 從頂至底堆積化\n    siftDown(i: 0)\n    // 返回堆積頂元素\n    return val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        swap(i: i, j: ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 元素出堆積 */\npop() {\n    // 判空處理\n    if (this.isEmpty()) throw new Error('堆積為空');\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    this.#swap(0, this.size() - 1);\n    // 刪除節點\n    const val = this.#maxHeap.pop();\n    // 從頂至底堆積化\n    this.#siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\n#siftDown(i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) break;\n        // 交換兩節點\n        this.#swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 元素出堆積 */\npop(): number {\n    // 判空處理\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    this.swap(0, this.size() - 1);\n    // 刪除節點\n    const val = this.maxHeap.pop();\n    // 從頂至底堆積化\n    this.siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nsiftDown(i: number): void {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) break;\n        // 交換兩節點\n        this.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 元素出堆積 */\nint pop() {\n  // 判空處理\n  if (isEmpty()) throw Exception('堆積為空');\n  // 交換根節點與最右葉節點（交換首元素與尾元素）\n  _swap(0, size() - 1);\n  // 刪除節點\n  int val = _maxHeap.removeLast();\n  // 從頂至底堆積化\n  siftDown(0);\n  // 返回堆積頂元素\n  return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n  while (true) {\n    // 判斷節點 i, l, r 中值最大的節點，記為 ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    if (ma == i) break;\n    // 交換兩節點\n    _swap(i, ma);\n    // 迴圈向下堆積化\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 元素出堆積 */\nfn pop(&amp;mut self) -&gt; i32 {\n    // 判空處理\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    self.swap(0, self.size() - 1);\n    // 刪除節點\n    let val = self.max_heap.pop().unwrap();\n    // 從頂至底堆積化\n    self.sift_down(0);\n    // 返回堆積頂元素\n    val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break;\n        }\n        // 交換兩節點\n        self.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 元素出堆積 */\nint pop(MaxHeap *maxHeap) {\n    // 判空處理\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // 刪除節點\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // 從頂至底堆積化\n    siftDown(maxHeap, 0);\n\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (max == i) {\n            break;\n        }\n        // 交換兩節點\n        swap(maxHeap, i, max);\n        // 迴圈向下堆積化\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 元素出堆積 */\nfun pop(): Int {\n    // 判空處理\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(0, size() - 1)\n    // 刪除節點\n    val _val = maxHeap.removeAt(size() - 1)\n    // 從頂至底堆積化\n    siftDown(0)\n    // 返回堆積頂元素\n    return _val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfun siftDown(it: Int) {\n    // Kotlin的函式參數不可變，因此建立臨時變數\n    var i = it\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) break\n        // 交換兩節點\n        swap(i, ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 元素出堆積 ###\ndef pop\n  # 判空處理\n  raise IndexError, \"堆積為空\" if is_empty?\n  # 交換根節點與最右葉節點（交換首元素與尾元素）\n  swap(0, size - 1)\n  # 刪除節點\n  val = @max_heap.pop\n  # 從頂至底堆積化\n  sift_down(0)\n  # 返回堆積頂元素\n  val\nend\n\n### 從節點 i 開始，從頂至底堆積化 ###\ndef sift_down(i)\n  loop do\n    # 判斷節點 i, l, r 中值最大的節點，記為 ma\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    break if ma == i\n\n    # 交換兩節點\n    swap(i, ma)\n    # 迴圈向下堆積化\n    i = ma\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   堆積的常見應用","text":"<ul> <li>優先佇列：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 \\(O(\\log n)\\) ，而建堆積操作為 \\(O(n)\\) ，這些操作都非常高效。</li> <li>堆積排序：給定一組資料，我們可以用它們建立一個堆積，然後不斷地執行元素出堆積操作，從而得到有序資料。然而，我們通常會使用一種更優雅的方式實現堆積排序，詳見“堆積排序”章節。</li> <li>獲取最大的 \\(k\\) 個元素：這是一個經典的演算法問題，同時也是一種典型應用，例如選擇熱度前 10 的新聞作為微博熱搜，選取銷量前 10 的商品等。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   小結","text":"","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>堆積是一棵完全二元樹，根據成立條件可分為大頂堆積和小頂堆積。大（小）頂堆積的堆積頂元素是最大（小）的。</li> <li>優先佇列的定義是具有出列優先順序的佇列，通常使用堆積來實現。</li> <li>堆積的常用操作及其對應的時間複雜度包括：元素入堆積 \\(O(\\log n)\\)、堆積頂元素出堆積 \\(O(\\log n)\\) 和訪問堆積頂元素 \\(O(1)\\) 等。</li> <li>完全二元樹非常適合用陣列表示，因此我們通常使用陣列來儲存堆積。</li> <li>堆積化操作用於維護堆積的性質，在入堆積和出堆積操作中都會用到。</li> <li>輸入 \\(n\\) 個元素並建堆積的時間複雜度可以最佳化至 \\(O(n)\\) ，非常高效。</li> <li>Top-k 是一個經典演算法問題，可以使用堆積資料結構高效解決，時間複雜度為 \\(O(n \\log k)\\) 。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：資料結構的“堆積”與記憶體管理的“堆積”是同一個概念嗎？</p> <p>兩者不是同一個概念，只是碰巧都叫“堆積”。計算機系統記憶體中的堆積是動態記憶體分配的一部分，程式在執行時可以使用它來儲存資料。程式可以請求一定量的堆積記憶體，用於儲存如物件和陣列等複雜結構。當這些資料不再需要時，程式需要釋放這些記憶體，以防止記憶體流失。相較於堆疊記憶體，堆積記憶體的管理和使用需要更謹慎，使用不當可能會導致記憶體流失和野指標等問題。</p>","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-k 問題","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的無序陣列 <code>nums</code> ，請返回陣列中最大的 \\(k\\) 個元素。</p> <p>對於該問題，我們先介紹兩種思路比較直接的解法，再介紹效率更高的堆積解法。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#831","level":2,"title":"8.3.1   方法一：走訪選擇","text":"<p>我們可以進行圖 8-6 所示的 \\(k\\) 輪走訪，分別在每輪中提取第 \\(1\\)、\\(2\\)、\\(\\dots\\)、\\(k\\) 大的元素，時間複雜度為 \\(O(nk)\\) 。</p> <p>此方法只適用於 \\(k \\ll n\\) 的情況，因為當 \\(k\\) 與 \\(n\\) 比較接近時，其時間複雜度趨向於 \\(O(n^2)\\) ，非常耗時。</p> <p></p> <p> 圖 8-6   走訪尋找最大的 k 個元素 </p> <p>Tip</p> <p>當 \\(k = n\\) 時，我們可以得到完整的有序序列，此時等價於“選擇排序”演算法。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#832","level":2,"title":"8.3.2   方法二：排序","text":"<p>如圖 8-7 所示，我們可以先對陣列 <code>nums</code> 進行排序，再返回最右邊的 \\(k\\) 個元素，時間複雜度為 \\(O(n \\log n)\\) 。</p> <p>顯然，該方法“超額”完成任務了，因為我們只需找出最大的 \\(k\\) 個元素即可，而不需要排序其他元素。</p> <p></p> <p> 圖 8-7   排序尋找最大的 k 個元素 </p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#833","level":2,"title":"8.3.3   方法三：堆積","text":"<p>我們可以基於堆積更加高效地解決 Top-k 問題，流程如圖 8-8 所示。</p> <ol> <li>初始化一個小頂堆積，其堆積頂元素最小。</li> <li>先將陣列的前 \\(k\\) 個元素依次入堆積。</li> <li>從第 \\(k + 1\\) 個元素開始，若當前元素大於堆積頂元素，則將堆積頂元素出堆積，並將當前元素入堆積。</li> <li>走訪完成後，堆積中儲存的就是最大的 \\(k\\) 個元素。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-8   基於堆積尋找最大的 k 個元素 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"基於堆積查詢陣列中最大的 k 個元素\"\"\"\n    # 初始化小頂堆積\n    heap = []\n    # 將陣列的前 k 個元素入堆積\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i in range(k, len(nums)):\n        # 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // 初始化小頂堆積\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // 初始化小頂堆積\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // 初始化小頂堆積\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // 初始化小頂堆積\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // 將陣列的前 k 個元素入堆積\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i := k; i &lt; len(nums); i++ {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // 初始化一個小頂堆積，並將前 k 個元素建堆積\n    var heap = Heap(nums.prefix(k))\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i in nums.indices.dropFirst(k) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* 元素入堆積 */\nfunction pushMinHeap(maxHeap, val) {\n    // 元素取反\n    maxHeap.push(-val);\n}\n\n/* 元素出堆積 */\nfunction popMinHeap(maxHeap) {\n    // 元素取反\n    return -maxHeap.pop();\n}\n\n/* 訪問堆積頂元素 */\nfunction peekMinHeap(maxHeap) {\n    // 元素取反\n    return -maxHeap.peek();\n}\n\n/* 取出堆積中元素 */\nfunction getMinHeap(maxHeap) {\n    // 元素取反\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunction topKHeap(nums, k) {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    const maxHeap = new MaxHeap([]);\n    // 將陣列的前 k 個元素入堆積\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (let i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // 返回堆積中元素\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* 元素入堆積 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // 元素取反\n    maxHeap.push(-val);\n}\n\n/* 元素出堆積 */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // 元素取反\n    return -maxHeap.pop();\n}\n\n/* 訪問堆積頂元素 */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // 元素取反\n    return -maxHeap.peek();\n}\n\n/* 取出堆積中元素 */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // 元素取反\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    const maxHeap = new MaxHeap([]);\n    // 將陣列的前 k 個元素入堆積\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (let i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // 返回堆積中元素\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // 初始化小頂堆積，將陣列的前 k 個元素入堆積\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // 從第 k+1 個元素開始，保持堆積的長度為 k\n  for (int i = k; i &lt; nums.length; i++) {\n    // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap 是大頂堆積，使用 Reverse 將元素取反，從而實現小頂堆積\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // 將陣列的前 k 個元素入堆積\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for &amp;num in nums.iter().skip(k) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* 元素入堆積 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // 元素取反\n    push(maxHeap, -val);\n}\n\n/* 元素出堆積 */\nint popMinHeap(MaxHeap *maxHeap) {\n    // 元素取反\n    return -pop(maxHeap);\n}\n\n/* 訪問堆積頂元素 */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // 元素取反\n    return -peek(maxHeap);\n}\n\n/* 取出堆積中元素 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // 將堆積中所有元素取反並存入 res 陣列\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* 取出堆積中元素 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // 將堆積中所有元素取反並存入 res 陣列\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// 基於堆積查詢陣列中最大的 k 個元素的函式\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // 釋放記憶體\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // 初始化小頂堆積\n    val heap = PriorityQueue&lt;Int&gt;()\n    // 將陣列的前 k 個元素入堆積\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (i in k..&lt;nums.size) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### 基於堆積查詢陣列中最大的 k 個元素 ###\ndef top_k_heap(nums, k)\n  # 初始化小頂堆積\n  # 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n  max_heap = MaxHeap.new([])\n\n  # 將陣列的前 k 個元素入堆積\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # 從第 k+1 個元素開始，保持堆積的長度為 k\n  for i in k...nums.length\n    # 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總共執行了 \\(n\\) 輪入堆積和出堆積，堆積的最大長度為 \\(k\\) ，因此時間複雜度為 \\(O(n \\log k)\\) 。該方法的效率很高，當 \\(k\\) 較小時，時間複雜度趨向 \\(O(n)\\) ；當 \\(k\\) 較大時，時間複雜度不會超過 \\(O(n \\log n)\\) 。</p> <p>另外，該方法適用於動態資料流的使用場景。在不斷加入資料時，我們可以持續維護堆積內的元素，從而實現最大的 \\(k\\) 個元素的動態更新。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"序","text":"<p>幾年前，我在力扣上分享了“劍指 Offer”系列題解，受到了許多讀者的鼓勵和支持。在與讀者交流期間，我最常被問的一個問題是“如何入門演算法”。逐漸地，我對這個問題產生了濃厚的興趣。</p> <p>兩眼一抹黑地刷題似乎是最受歡迎的方法，簡單、直接且有效。然而刷題就如同玩“掃雷”遊戲，自學能力強的人能夠順利將地雷逐個排掉，而基礎不足的人很可能被炸得滿頭是包，並在挫折中步步退縮。通讀教材也是一種常見做法，但對於面向求職的人來說，畢業論文、投遞簡歷、準備筆試和面試已經消耗了大部分精力，啃厚重的書往往變成了一項艱鉅的挑戰。</p> <p>如果你也面臨類似的困擾，那麼很幸運這本書“找”到了你。本書是我對這個問題給出的答案，即使不是最優解，也至少是一次積極的嘗試。本書雖然不足以讓你直接拿到 Offer，但會引導你探索資料結構與演算法的“知識地圖”，帶你瞭解不同“地雷”的形狀、大小和分佈位置，讓你掌握各種“排雷方法”。有了這些本領，相信你可以更加自如地刷題和閱讀文獻，逐步構建起完整的知識體系。</p> <p>我深深贊同費曼教授所言：“Knowledge isn't free. You have to pay attention.”從這個意義上看，這本書並非完全“免費”。為了不辜負你為本書所付出的寶貴“注意力”，我會竭盡所能，投入最大的“注意力”來完成本書的創作。</p> <p>本人自知學疏才淺，書中內容雖然已經過一段時間的打磨，但一定仍有許多錯誤，懇請各位老師和同學批評指正。</p> <p></p> Hello，演算法！ <p>計算機的出現給世界帶來了巨大變革，它憑藉高速的計算能力和出色的可程式設計性，成為了執行演算法與處理資料的理想媒介。無論是電子遊戲的逼真畫面、自動駕駛的智慧決策，還是 AlphaGo 的精彩棋局、ChatGPT 的自然互動，這些應用都是演算法在計算機上的精妙演繹。</p> <p>事實上，在計算機問世之前，演算法和資料結構就已經存在於世界的各個角落。早期的演算法相對簡單，例如古代的計數方法和工具製作步驟等。隨著文明的進步，演算法逐漸變得更加精細和複雜。從巧奪天工的匠人技藝、到解放生產力的工業產品、再到宇宙執行的科學規律，幾乎每一件平凡或令人驚歎的事物背後，都隱藏著精妙的演算法思想。</p> <p>同樣，資料結構無處不在：大到社會網路，小到地鐵線路，許多系統都可以建模為“圖”；大到一個國家，小到一個家庭，社會的主要組織形式呈現出“樹”的特徵；冬天的衣服就像“堆疊”，最先穿上的最後才能脫下；羽毛球筒則如同“佇列”，一端放入、另一端取出；字典就像一個“雜湊表”，能夠快速查詢目標詞條。</p> <p>本書旨在透過清晰易懂的動畫圖解和可執行的程式碼示例，使讀者理解演算法和資料結構的核心概念，並能夠透過程式設計來實現它們。在此基礎上，本書致力於揭示演算法在複雜世界中的生動體現，展現演算法之美。希望本書能夠幫助到你！</p>","path":["序"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"第 1 章   初識演算法","text":"<p>Abstract</p> <p>一位少女翩翩起舞，與資料交織在一起，裙襬上飄揚著演算法的旋律。</p> <p>她邀請你共舞，請緊跟她的步伐，踏入充滿邏輯與美感的演算法世界。</p>","path":["第 1 章 &nbsp; 初識演算法"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"本章內容","text":"<ul> <li>1.1   演算法無處不在</li> <li>1.2   演算法是什麼</li> <li>1.3   小結</li> </ul>","path":["第 1 章 &nbsp; 初識演算法"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   演算法無處不在","text":"<p>當我們聽到“演算法”這個詞時，很自然地會想到數學。然而實際上，許多演算法並不涉及複雜數學，而是更多地依賴基本邏輯，這些邏輯在我們的日常生活中處處可見。</p> <p>在正式探討演算法之前，有一個有趣的事實值得分享：你已經在不知不覺中學會了許多演算法，並習慣將它們應用到日常生活中了。下面我將舉幾個具體的例子來證實這一點。</p> <p>例一：查字典。在字典裡，每個漢字都對應一個拼音，而字典是按照拼音字母順序排列的。假設我們需要查詢一個拼音首字母為 \\(r\\) 的字，通常會按照圖 1-1 所示的方式實現。</p> <ol> <li>翻開字典約一半的頁數，檢視該頁的首字母是什麼，假設首字母為 \\(m\\) 。</li> <li>由於在拼音字母表中 \\(r\\) 位於 \\(m\\) 之後，所以排除字典前半部分，查詢範圍縮小到後半部分。</li> <li>不斷重複步驟 <code>1.</code> 和步驟 <code>2.</code> ，直至找到拼音首字母為 \\(r\\) 的頁碼為止。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 1-1   查字典步驟 </p> <p>查字典這個小學生必備技能，實際上就是著名的“二分搜尋”演算法。從資料結構的角度，我們可以把字典視為一個已排序的“陣列”；從演算法的角度，我們可以將上述查字典的一系列操作看作“二分搜尋”。</p> <p>例二：整理撲克。我們在打牌時，每局都需要整理手中的撲克牌，使其從小到大排列，實現流程如圖 1-2 所示。</p> <ol> <li>將撲克牌劃分為“有序”和“無序”兩部分，並假設初始狀態下最左 1 張撲克牌已經有序。</li> <li>在無序部分抽出一張撲克牌，插入至有序部分的正確位置；完成後最左 2 張撲克已經有序。</li> <li>不斷迴圈步驟 <code>2.</code> ，每一輪將一張撲克牌從無序部分插入至有序部分，直至所有撲克牌都有序。</li> </ol> <p></p> <p> 圖 1-2   撲克排序步驟 </p> <p>上述整理撲克牌的方法本質上是“插入排序”演算法，它在處理小型資料集時非常高效。許多程式語言的排序庫函式中都有插入排序的身影。</p> <p>例三：貨幣找零。假設我們在超市購買了 \\(69\\) 元的商品，給了收銀員 \\(100\\) 元，則收銀員需要找我們 \\(31\\) 元。他會很自然地完成如圖 1-3 所示的思考。</p> <ol> <li>可選項是比 \\(31\\) 元面值更小的貨幣，包括 \\(1\\) 元、\\(5\\) 元、\\(10\\) 元、\\(20\\) 元。</li> <li>從可選項中拿出最大的 \\(20\\) 元，剩餘 \\(31 - 20 = 11\\) 元。</li> <li>從剩餘可選項中拿出最大的 \\(10\\) 元，剩餘 \\(11 - 10 = 1\\) 元。</li> <li>從剩餘可選項中拿出最大的 \\(1\\) 元，剩餘 \\(1 - 1 = 0\\) 元。</li> <li>完成找零，方案為 \\(20 + 10 + 1 = 31\\) 元。</li> </ol> <p></p> <p> 圖 1-3   貨幣找零過程 </p> <p>在以上步驟中，我們每一步都採取當前看來最好的選擇（儘可能用大面額的貨幣），最終得到了可行的找零方案。從資料結構與演算法的角度看，這種方法本質上是“貪婪”演算法。</p> <p>小到烹飪一道菜，大到星際航行，幾乎所有問題的解決都離不開演算法。計算機的出現使得我們能夠透過程式設計將資料結構儲存在記憶體中，同時編寫程式碼呼叫 CPU 和 GPU 執行演算法。這樣一來，我們就能把生活中的問題轉移到計算機上，以更高效的方式解決各種複雜問題。</p> <p>Tip</p> <p>如果你對資料結構、演算法、陣列和二分搜尋等概念仍感到一知半解，請繼續往下閱讀，本書將引導你邁入資料結構與演算法的知識殿堂。</p>","path":["第 1 章 &nbsp; 初識演算法","1.1 &nbsp; 演算法無處不在"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   小結","text":"","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>演算法在日常生活中無處不在，並不是遙不可及的高深知識。實際上，我們已經在不知不覺中學會了許多演算法，用以解決生活中的大小問題。</li> <li>查字典的原理與二分搜尋演算法相一致。二分搜尋演算法體現了分而治之的重要演算法思想。</li> <li>整理撲克的過程與插入排序演算法非常類似。插入排序演算法適合排序小型資料集。</li> <li>貨幣找零的步驟本質上是貪婪演算法，每一步都採取當前看來最好的選擇。</li> <li>演算法是在有限時間內解決特定問題的一組指令或操作步驟，而資料結構是計算機中組織和儲存資料的方式。</li> <li>資料結構與演算法緊密相連。資料結構是演算法的基石，而演算法為資料結構注入生命力。</li> <li>我們可以將資料結構與演算法類比為拼裝積木，積木代表資料，積木的形狀和連線方式等代表資料結構，拼裝積木的步驟則對應演算法。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：作為一名程式設計師，我在日常工作中從未用演算法解決過問題，常用演算法都被程式語言封裝好了，直接用就可以了；這是否意味著我們工作中的問題還沒有到達需要演算法的程度？</p> <p>如果把具體的工作技能比作是武功的“招式”的話，那麼基礎科目應該更像是“內功”。</p> <p>我認為學演算法（以及其他基礎科目）的意義不是在於在工作中從零實現它，而是基於學到的知識，在解決問題時能夠作出專業的反應和判斷，從而提升工作的整體質量。舉一個簡單例子，每種程式語言都內建了排序函式：</p> <ul> <li>如果我們沒有學過資料結構與演算法，那麼給定任何資料，我們可能都塞給這個排序函式去做了。執行順暢、效能不錯，看上去並沒有什麼問題。</li> <li>但如果學過演算法，我們就會知道內建排序函式的時間複雜度是 \\(O(n \\log n)\\) ；而如果給定的資料是固定位數的整數（例如學號），那麼我們就可以用效率更高的“基數排序”來做，將時間複雜度降為 \\(O(nk)\\) ，其中 \\(k\\) 為位數。當資料體量很大時，節省出來的執行時間就能創造較大價值（成本降低、體驗變好等）。</li> </ul> <p>在工程領域中，大量問題是難以達到最優解的，許多問題只是被“差不多”地解決了。問題的難易程度一方面取決於問題本身的性質，另一方面也取決於觀測問題的人的知識儲備。人的知識越完備、經驗越多，分析問題就會越深入，問題就能被解決得更優雅。</p>","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   演算法是什麼","text":"","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   演算法定義","text":"<p>演算法（algorithm）是在有限時間內解決特定問題的一組指令或操作步驟，它具有以下特性。</p> <ul> <li>問題是明確的，包含清晰的輸入和輸出定義。</li> <li>具有可行性，能夠在有限步驟、時間和記憶體空間下完成。</li> <li>各步驟都有確定的含義，在相同的輸入和執行條件下，輸出始終相同。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   資料結構定義","text":"<p>資料結構（data structure）是組織和儲存資料的方式，涵蓋資料內容、資料之間關係和資料操作方法，它具有以下設計目標。</p> <ul> <li>空間佔用儘量少，以節省計算機記憶體。</li> <li>資料操作儘可能快速，涵蓋資料訪問、新增、刪除、更新等。</li> <li>提供簡潔的資料表示和邏輯資訊，以便演算法高效執行。</li> </ul> <p>資料結構設計是一個充滿權衡的過程。如果想在某方面取得提升，往往需要在另一方面作出妥協。下面舉兩個例子。</p> <ul> <li>鏈結串列相較於陣列，在資料新增和刪除操作上更加便捷，但犧牲了資料訪問速度。</li> <li>圖相較於鏈結串列，提供了更豐富的邏輯資訊，但需要佔用更大的記憶體空間。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   資料結構與演算法的關係","text":"<p>如圖 1-4 所示，資料結構與演算法高度相關、緊密結合，具體表現在以下三個方面。</p> <ul> <li>資料結構是演算法的基石。資料結構為演算法提供了結構化儲存的資料，以及操作資料的方法。</li> <li>演算法為資料結構注入生命力。資料結構本身僅儲存資料資訊，結合演算法才能解決特定問題。</li> <li>演算法通常可以基於不同的資料結構實現，但執行效率可能相差很大，選擇合適的資料結構是關鍵。</li> </ul> <p></p> <p> 圖 1-4   資料結構與演算法的關係 </p> <p>資料結構與演算法猶如圖 1-5 所示的拼裝積木。一套積木，除了包含許多零件之外，還附有詳細的組裝說明書。我們按照說明書一步步操作，就能組裝出精美的積木模型。</p> <p></p> <p> 圖 1-5   拼裝積木 </p> <p>兩者的詳細對應關係如表 1-1 所示。</p> <p> 表 1-1   將資料結構與演算法類比為拼裝積木 </p> 資料結構與演算法 拼裝積木 輸入資料 未拼裝的積木 資料結構 積木組織形式，包括形狀、大小、連線方式等 演算法 把積木拼成目標形態的一系列操作步驟 輸出資料 積木模型 <p>值得說明的是，資料結構與演算法是獨立於程式語言的。正因如此，本書得以提供基於多種程式語言的實現。</p> <p>約定俗成的簡稱</p> <p>在實際討論時，我們通常會將“資料結構與演算法”簡稱為“演算法”。比如眾所周知的 LeetCode 演算法題目，實際上同時考查資料結構和演算法兩方面的知識。</p>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"第 0 章   前言","text":"<p>Abstract</p> <p>演算法猶如美妙的交響樂，每一行程式碼都像韻律般流淌。</p> <p>願這本書在你的腦海中輕輕響起，留下獨特而深刻的旋律。</p>","path":["第 0 章 &nbsp; 前言"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"本章內容","text":"<ul> <li>0.1   關於本書</li> <li>0.2   如何使用本書</li> <li>0.3   小結</li> </ul>","path":["第 0 章 &nbsp; 前言"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   關於本書","text":"<p>本專案旨在建立一本開源、免費、對新手友好的資料結構與演算法入門教程。</p> <ul> <li>全書採用動畫圖解，內容清晰易懂、學習曲線平滑，引導初學者探索資料結構與演算法的知識地圖。</li> <li>源程式碼可一鍵執行，幫助讀者在練習中提升程式設計技能，瞭解演算法工作原理和資料結構底層實現。</li> <li>提倡讀者互助學習，歡迎大家在評論區提出問題與分享見解，在交流討論中共同進步。</li> </ul>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   目標讀者","text":"<p>若你是演算法初學者，從未接觸過演算法，或者已經有一些刷題經驗，對資料結構與演算法有模糊的認識，在會與不會之間反覆橫跳，那麼本書正是為你量身定製的！</p> <p>如果你已經積累一定的刷題量，熟悉大部分題型，那麼本書可助你回顧與梳理演算法知識體系，倉庫源程式碼可以當作“刷題工具庫”或“演算法字典”來使用。</p> <p>若你是演算法“大神”，我們期待收到你的寶貴建議，或者一起參與創作。</p> <p>前置條件</p> <p>你需要至少具備任一語言的程式設計基礎，能夠閱讀和編寫簡單程式碼。</p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   內容結構","text":"<p>本書的主要內容如圖 0-1 所示。</p> <ul> <li>複雜度分析：資料結構和演算法的評價維度與方法。時間複雜度和空間複雜度的推算方法、常見型別、示例等。</li> <li>資料結構：基本資料型別和資料結構的分類方法。陣列、鏈結串列、堆疊、佇列、雜湊表、樹、堆積、圖等資料結構的定義、優缺點、常用操作、常見型別、典型應用、實現方法等。</li> <li>演算法：搜尋、排序、分治、回溯、動態規劃、貪婪等演算法的定義、優缺點、效率、應用場景、解題步驟和示例問題等。</li> </ul> <p></p> <p> 圖 0-1   本書主要內容 </p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   致謝","text":"<p>本書在開源社群眾多貢獻者的共同努力下不斷完善。感謝每一位投入時間與精力的撰稿人，他們是（按照 GitHub 自動生成的順序）：krahets、coderonion、Gonglja、nuomi1、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、rongyi、msk397、gvenusleo、khoaxuantu、rivertwilight、K3v123、gyt95、zhuoqinyue、yuelinxin、Zuoxun、mingXta、Phoenix0415、FangYuan33、GN-Yu、longsizhuo、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、pengchzn、QiLOL、magentaqin、hello-ikun、JoseHung、qualifier1024、thomasq0、sunshinesDL、L-Super、Guanngxu、Transmigration-zhou、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、Shyam-Chen、theNefelibatas、longranger2、codeberg-user、xiongsp、JeffersonHuang、prinpal、seven1240、Wonderdch、malone6、xiaomiusa87、gaofer、bluebean-cloud、a16su、SamJin98、hongyun-robot、nanlei、XiaChuerwu、yd-j、iron-irax、mgisr、steventimes、junminhong、heshuyue、danny900714、MolDuM、Nigh、Dr-XYZ、XC-Zero、reeswell、PXG-XPG、NI-SW、Horbin-Magician、Enlightenus、YangXuanyi、beatrix-chan、DullSword、xjr7670、jiaxianhua、qq909244296、iStig、boloboloda、hts0000、gledfish、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、linyejoe2、liuxjerry、llql1211、fbigm、echo1937、szu17dmy、dshlstarr、Yucao-cy、coderlef、czruby、bongbongbakudan、beintentional、ZongYangL、ZhongYuuu、ZhongGuanbin、hezhizhen、linzeyan、ZJKung、luluxia、xb534、ztkuaikuai、yw-1021、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yanedie、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、sslmj2020、smilelsb、siqyka、selear、sdshaoda、Xi-Row、popozhu、nuquist19、noobcodemaker、XiaoK29、chadyi、lyl625760、lucaswangdev、0130w、shanghai-Jerry、EJackYang、Javesun99、eltociear、lipusheng、KNChiu、BlindTerran、ShiMaRing、lovelock、FreddieLi、FloranceYeh、fanchenggang、gltianwen、goerll、nedchu、curly210102、CuB3y0nd、KraHsu、CarrotDLaw、youshaoXG、bubble9um、Asashishi、Asa0oo0o0o、fanenr、eagleanurag、akshiterate、52coder、foursevenlove、KorsChen、GaochaoZhu、hopkings2008、yang-le、realwujing、Evilrabbit520、Umer-Jahangir、Turing-1024-Lee、Suremotoo、paoxiaomooo、Chieko-Seren、Allen-Scai、ymmmas、Risuntsy、Richard-Zhang1019、RafaelCaso、qingpeng9802、primexiao、Urbaner3、zhongfq、nidhoggfgg、MwumLi、CreatorMetaSky、martinx、ZnYang2018、hugtyftg、logan-qiu、psychelzh、Keynman、KeiichiKasai 和 KawaiiAsh。</p> <p>本書的程式碼審閱工作由 coderonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、khoaxuantu、krahets、night-cruise、nuomi1、Reanon 和 rongyi 完成（按照首字母順序排列）。感謝他們付出的時間與精力，正是他們確保了各語言程式碼的規範與統一。</p> <p>本書的繁體中文版由 Shyam-Chen 和 Dr-XYZ 審閱，英文版由 yuelinxin、K3v123、QiLOL、Phoenix0415、SamJin98、yanedie、RafaelCaso、pengchzn、thomasq0 和 magentaqin 審閱，日文版由 eltociear 審閱。正是因為他們的持續貢獻，這本書才能夠服務於更廣泛的讀者群體，感謝他們。</p> <p>本書的 ePub 電子書生成工具由 zhongfq 開發。感謝他的貢獻，為讀者提供了更加自由的閱讀方式。</p> <p>在本書的創作過程中，我得到了許多人的幫助。</p> <ul> <li>感謝我在公司的導師李汐博士，在一次暢談中你鼓勵我“快行動起來”，堅定了我寫這本書的決心；</li> <li>感謝我的女朋友泡泡作為本書的首位讀者，從演算法小白的角度提出許多寶貴建議，使得本書更適合新手閱讀；</li> <li>感謝騰寶、琦寶、飛寶為本書起了一個富有創意的名字，喚起大家寫下第一行程式碼“Hello World!”的美好回憶；</li> <li>感謝校銓在智慧財產權方面提供的專業幫助，這對本開源書的完善起到了重要作用；</li> <li>感謝蘇潼為本書設計了精美的封面和 logo ，並在我的強迫症的驅使下多次耐心修改；</li> <li>感謝 @squidfunk 提供的排版建議，以及他開發的開源文件主題 Material-for-MkDocs 。</li> </ul> <p>在寫作過程中，我閱讀了許多關於資料結構與演算法的教材和文章。這些作品為本書提供了優秀的範本，確保了本書內容的準確性與品質。在此感謝所有老師和前輩的傑出貢獻！</p> <p>本書倡導手腦並用的學習方式，在這一點上我深受《動手學深度學習》的啟發。在此向各位讀者強烈推薦這本優秀的著作。</p> <p>衷心感謝我的父母，正是你們一直以來的支持與鼓勵，讓我有機會做這件富有趣味的事。</p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   如何使用本書","text":"<p>Tip</p> <p>為了獲得最佳的閱讀體驗，建議你通讀本節內容。</p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   行文風格約定","text":"<ul> <li>標題後標註 <code>*</code> 的是選讀章節，內容相對困難。如果你的時間有限，可以先跳過。</li> <li>專業術語會使用黑體（紙質版和 PDF 版）或新增下劃線（網頁版），例如陣列（array）。建議記住它們，以便閱讀文獻。</li> <li>重點內容和總結性語句會 加粗，這類文字值得特別關注。</li> <li>有特指含義的詞句會使用“引號”標註，以避免歧義。</li> <li>當涉及程式語言之間不一致的名詞時，本書均以 Python 為準，例如使用 <code>None</code> 來表示“空”。</li> <li>本書部分放棄了程式語言的註釋規範，以換取更加緊湊的內容排版。註釋主要分為三種類型：標題註釋、內容註釋、多行註釋。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"標題註釋，用於標註函式、類別、測試樣例等\"\"\"\n\n# 內容註釋，用於詳解程式碼\n\n\"\"\"\n多行\n註釋\n\"\"\"\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n// 多行\n// 註釋\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>### 標題註釋，用於標註函式、類別、測試樣例等 ###\n\n# 內容註釋，用於詳解程式碼\n\n# 多行\n# 註釋\n</code></pre>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   在動畫圖解中高效學習","text":"<p>相較於文字，影片和圖片具有更高的資訊密度和結構化程度，更易於理解。在本書中，重點和難點知識將主要透過動畫以圖解形式展示，而文字則作為解釋與補充。</p> <p>如果你在閱讀本書時，發現某段內容提供瞭如圖 0-2 所示的動畫圖解，請以圖為主、以文字為輔，綜合兩者來理解內容。</p> <p></p> <p> 圖 0-2   動畫圖解示例 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   在程式碼實踐中加深理解","text":"<p>本書的配套程式碼託管在 GitHub 倉庫。如圖 0-3 所示，源程式碼附有測試樣例，可一鍵執行。</p> <p>如果時間允許，建議你參照程式碼自行敲一遍。如果學習時間有限，請至少通讀並執行所有程式碼。</p> <p>與閱讀程式碼相比，編寫程式碼的過程往往能帶來更多收穫。動手學，才是真的學。</p> <p></p> <p> 圖 0-3   執行程式碼示例 </p> <p>執行程式碼的前置工作主要分為三步。</p> <p>第一步：安裝本地程式設計環境。請參照附錄所示的教程進行安裝，如果已安裝，則可跳過此步驟。</p> <p>第二步：克隆或下載程式碼倉庫。前往 GitHub 倉庫。如果已經安裝 Git ，可以透過以下命令克隆本倉庫：</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>當然，你也可以在圖 0-4 所示的位置，點選“Download ZIP”按鈕直接下載程式碼壓縮包，然後在本地解壓即可。</p> <p></p> <p> 圖 0-4   克隆倉庫與下載程式碼 </p> <p>第三步：執行源程式碼。如圖 0-5 所示，對於頂部標有檔案名稱的程式碼塊，我們可以在倉庫的 <code>codes</code> 檔案夾內找到對應的源程式碼檔案。源程式碼檔案可一鍵執行，將幫助你節省不必要的除錯時間，讓你能夠專注於學習內容。</p> <p></p> <p> 圖 0-5   程式碼塊與對應的源程式碼檔案 </p> <p>除了本地執行程式碼，網頁版還支持 Python 程式碼的視覺化執行（基於 pythontutor 實現）。如圖 0-6 所示，你可以點選程式碼塊下方的“視覺化執行”來展開檢視，觀察演算法程式碼的執行過程；也可以點選“全屏觀看”，以獲得更好的閱覽體驗。</p> <p></p> <p> 圖 0-6   Python 程式碼的視覺化執行 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   在提問討論中共同成長","text":"<p>在閱讀本書時，請不要輕易跳過那些沒學明白的知識點。歡迎在評論區提出你的問題，我和小夥伴們將竭誠為你解答，一般情況下可在兩天內回覆。</p> <p>如圖 0-7 所示，網頁版每個章節的底部都配有評論區。希望你能多關注評論區的內容。一方面，你可以瞭解大家遇到的問題，從而查漏補缺，激發更深入的思考。另一方面，期待你能慷慨地回答其他小夥伴的問題，分享你的見解，幫助他人進步。</p> <p></p> <p> 圖 0-7   評論區示例 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   演算法學習路線","text":"<p>從總體上看，我們可以將學習資料結構與演算法的過程劃分為三個階段。</p> <ol> <li>階段一：演算法入門。我們需要熟悉各種資料結構的特點和用法，學習不同演算法的原理、流程、用途和效率等方面的內容。</li> <li>階段二：刷演算法題。建議從熱門題目開刷，先積累至少 100 道題目，熟悉主流的演算法問題。初次刷題時，“知識遺忘”可能是一個挑戰，但請放心，這是很正常的。我們可以按照“艾賓浩斯遺忘曲線”來複習題目，通常在進行 3～5 輪的重複後，就能將其牢記在心。推薦的題單和刷題計劃請見此 GitHub 倉庫。</li> <li>階段三：搭建知識體系。在學習方面，我們可以閱讀演算法專欄文章、解題框架和演算法教材，以不斷豐富知識體系。在刷題方面，可以嘗試採用進階刷題策略，如按專題分類、一題多解、一解多題等，相關的刷題心得可以在各個社群找到。</li> </ol> <p>如圖 0-8 所示，本書內容主要涵蓋“階段一”，旨在幫助你更高效地展開階段二和階段三的學習。</p> <p></p> <p> 圖 0-8   演算法學習路線 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   小結","text":"","path":["第 0 章 &nbsp; 前言","0.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>本書的主要受眾是演算法初學者。如果你已有一定基礎，本書能幫助你系統回顧演算法知識，書中源程式碼也可作為“刷題工具庫”使用。</li> <li>書中內容主要包括複雜度分析、資料結構和演算法三部分，涵蓋了該領域的大部分主題。</li> <li>對於演算法新手，在初學階段閱讀一本入門書至關重要，可以少走許多彎路。</li> <li>書中的動畫圖解通常用於介紹重點和難點知識。閱讀本書時，應給予這些內容更多關注。</li> <li>實踐乃學習程式設計之最佳途徑。強烈建議執行源程式碼並親自敲程式碼。</li> <li>本書網頁版的每個章節都設有評論區，歡迎隨時分享你的疑惑與見解。</li> </ul>","path":["第 0 章 &nbsp; 前言","0.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"參考文獻","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] 嚴蔚敏. 資料結構（C 語言版）.</p> <p>[5] 鄧俊輝. 資料結構（C++ 語言版，第三版）.</p> <p>[6] 馬克 艾倫 維斯著，陳越譯. 資料結構與演算法分析：Java語言描述（第三版）.</p> <p>[7] 程傑. 大話資料結構.</p> <p>[8] 王爭. 資料結構與演算法之美.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["參考文獻"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"第 10 章   搜尋","text":"<p>Abstract</p> <p>搜尋是一場未知的冒險，我們或許需要走遍神秘空間的每個角落，又或許可以快速鎖定目標。</p> <p>在這場尋覓之旅中，每一次探索都可能得到一個未曾料想的答案。</p>","path":["第 10 章 &nbsp; 搜尋"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"本章內容","text":"<ul> <li>10.1   二分搜尋</li> <li>10.2   二分搜尋插入點</li> <li>10.3   二分搜尋邊界</li> <li>10.4   雜湊最佳化策略</li> <li>10.5   重識搜尋演算法</li> <li>10.6   小結</li> </ul>","path":["第 10 章 &nbsp; 搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   二分搜尋","text":"<p>二分搜尋（binary search）是一種基於分治策略的高效搜尋演算法。它利用資料的有序性，每輪縮小一半搜尋範圍，直至找到目標元素或搜尋區間為空為止。</p> <p>Question</p> <p>給定一個長度為 \\(n\\) 的陣列 <code>nums</code> ，元素按從小到大的順序排列且不重複。請查詢並返回元素 <code>target</code> 在該陣列中的索引。若陣列不包含該元素，則返回 \\(-1\\) 。示例如圖 10-1 所示。</p> <p></p> <p> 圖 10-1   二分搜尋示例資料 </p> <p>如圖 10-2 所示，我們先初始化指標 \\(i = 0\\) 和 \\(j = n - 1\\) ，分別指向陣列首元素和尾元素，代表搜尋區間 \\([0, n - 1]\\) 。請注意，中括號表示閉區間，其包含邊界值本身。</p> <p>接下來，迴圈執行以下兩步。</p> <ol> <li>計算中點索引 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) ，其中 \\(\\lfloor \\: \\rfloor\\) 表示向下取整操作。</li> <li>判斷 <code>nums[m]</code> 和 <code>target</code> 的大小關係，分為以下三種情況。<ol> <li>當 <code>nums[m] &lt; target</code> 時，說明 <code>target</code> 在區間 \\([m + 1, j]\\) 中，因此執行 \\(i = m + 1\\) 。</li> <li>當 <code>nums[m] &gt; target</code> 時，說明 <code>target</code> 在區間 \\([i, m - 1]\\) 中，因此執行 \\(j = m - 1\\) 。</li> <li>當 <code>nums[m] = target</code> 時，說明找到 <code>target</code> ，因此返回索引 \\(m\\) 。</li> </ol> </li> </ol> <p>若陣列不包含目標元素，搜尋區間最終會縮小為空。此時返回 \\(-1\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 10-2   二分搜尋流程 </p> <p>值得注意的是，由於 \\(i\\) 和 \\(j\\) 都是 <code>int</code> 型別，因此 \\(i + j\\) 可能會超出 <code>int</code> 型別的取值範圍。為了避免大數越界，我們通常採用公式 \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) 來計算中點。</p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋（雙閉區間）\"\"\"\n    # 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    i, j = 0, len(nums) - 1\n    # 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j:\n        # 理論上 Python 的數字可以無限大（取決於記憶體大小），無須考慮大數越界問題\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # 此情況說明 target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # 此情況說明 target 在區間 [i, m-1] 中\n        else:\n            return m  # 找到目標元素，返回其索引\n    return -1  # 未找到目標元素，返回 -1\n</code></pre> binary_search.cpp<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.size() - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(int[] nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分搜尋（雙閉區間） */\nint BinarySearch(int[] nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.Length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // 計算中點索引 m\n        if (nums[m] &lt; target)      // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else                       // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分搜尋（雙閉區間） */\nfunc binarySearch(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    i, j := 0, len(nums)-1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    for i &lt;= j {\n        m := i + (j-i)/2      // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分搜尋（雙閉區間） */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分搜尋（雙閉區間） */\nfunction binarySearch(nums, target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let i = 0,\n        j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        // 計算中點索引 m ，使用 parseInt() 向下取整\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else return m; // 找到目標元素，返回其索引\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分搜尋（雙閉區間） */\nfunction binarySearch(nums: number[], target: number): number {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let i = 0,\n        j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        // 計算中點索引 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    return -1; // 未找到目標元素，返回 -1\n}\n</code></pre> binary_search.dart<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n  int i = 0, j = nums.length - 1;\n  // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      // 此情況說明 target 在區間 [m+1, j] 中\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // 此情況說明 target 在區間 [i, m-1] 中\n      j = m - 1;\n    } else {\n      // 找到目標元素，返回其索引\n      return m;\n    }\n  }\n  // 未找到目標元素，返回 -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分搜尋（雙閉區間） */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(int *nums, int len, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = len - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分搜尋（雙閉區間） */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    var i = 0\n    var j = nums.size - 1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        else  // 找到目標元素，返回其索引\n            return m\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分搜尋（雙閉區間） ###\ndef binary_search(nums, target)\n  # 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n  i, j = 0, nums.length - 1\n\n  # 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n  while i &lt;= j\n    # 理論上 Ruby 的數字可以無限大（取決於記憶體大小），無須考慮大數越界問題\n    m = (i + j) / 2   # 計算中點索引 m\n\n    if nums[m] &lt; target\n      i = m + 1 # 此情況說明 target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # 此情況說明 target 在區間 [i, m-1] 中\n    else\n      return m  # 找到目標元素，返回其索引\n    end\n  end\n\n  -1  # 未找到目標元素，返回 -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>時間複雜度為 \\(O(\\log n)\\) ：在二分迴圈中，區間每輪縮小一半，因此迴圈次數為 \\(\\log_2 n\\) 。</p> <p>空間複雜度為 \\(O(1)\\) ：指標 \\(i\\) 和 \\(j\\) 使用常數大小空間。</p>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   區間表示方法","text":"<p>除了上述雙閉區間外，常見的區間表示還有“左閉右開”區間，定義為 \\([0, n)\\) ，即左邊界包含自身，右邊界不包含自身。在該表示下，區間 \\([i, j)\\) 在 \\(i = j\\) 時為空。</p> <p>我們可以基於該表示實現具有相同功能的二分搜尋演算法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋（左閉右開區間）\"\"\"\n    # 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    i, j = 0, len(nums)\n    # 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # 此情況說明 target 在區間 [m+1, j) 中\n        elif nums[m] &gt; target:\n            j = m  # 此情況說明 target 在區間 [i, m) 中\n        else:\n            return m  # 找到目標元素，返回其索引\n    return -1  # 未找到目標元素，返回 -1\n</code></pre> binary_search.cpp<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.size();\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(int[] nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分搜尋（左閉右開區間） */\nint BinarySearchLCRO(int[] nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.Length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // 計算中點索引 m\n        if (nums[m] &lt; target)      // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else                       // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分搜尋（左閉右開區間） */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    i, j := 0, len(nums)\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    for i &lt; j {\n        m := i + (j-i)/2      // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分搜尋（左閉右開區間） */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分搜尋（左閉右開區間） */\nfunction binarySearchLCRO(nums, target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let i = 0,\n        j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        // 計算中點索引 m ，使用 parseInt() 向下取整\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        // 找到目標元素，返回其索引\n        else return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分搜尋（左閉右開區間） */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let i = 0,\n        j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        // 計算中點索引 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    return -1; // 未找到目標元素，返回 -1\n}\n</code></pre> binary_search.dart<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n  int i = 0, j = nums.length;\n  // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      // 此情況說明 target 在區間 [m+1, j) 中\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // 此情況說明 target 在區間 [i, m) 中\n      j = m;\n    } else {\n      // 找到目標元素，返回其索引\n      return m;\n    }\n  }\n  // 未找到目標元素，返回 -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分搜尋（左閉右開區間） */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = len;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分搜尋（左閉右開區間） */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    var i = 0\n    var j = nums.size\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        else  // 找到目標元素，返回其索引\n            return m\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分搜尋（左閉右開區間） ###\ndef binary_search_lcro(nums, target)\n  # 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n  i, j = 0, nums.length\n\n  # 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n  while i &lt; j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # 此情況說明 target 在區間 [m+1, j) 中\n    elsif nums[m] &gt; target\n      j = m - 1 # 此情況說明 target 在區間 [i, m) 中\n    else\n      return m  # 找到目標元素，返回其索引\n    end\n  end\n\n  -1  # 未找到目標元素，返回 -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 10-3 所示，在兩種區間表示下，二分搜尋演算法的初始化、迴圈條件和縮小區間操作皆有所不同。</p> <p>由於“雙閉區間”表示中的左右邊界都被定義為閉區間，因此透過指標 \\(i\\) 和指標 \\(j\\) 縮小區間的操作也是對稱的。這樣更不容易出錯，因此一般建議採用“雙閉區間”的寫法。</p> <p></p> <p> 圖 10-3   兩種區間定義 </p>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   優點與侷限性","text":"<p>二分搜尋在時間和空間方面都有較好的效能。</p> <ul> <li>二分搜尋的時間效率高。在大資料量下，對數階的時間複雜度具有顯著優勢。例如，當資料大小 \\(n = 2^{20}\\) 時，線性查詢需要 \\(2^{20} = 1048576\\) 輪迴圈，而二分搜尋僅需 \\(\\log_2 2^{20} = 20\\) 輪迴圈。</li> <li>二分搜尋無須額外空間。相較於需要藉助額外空間的搜尋演算法（例如雜湊查詢），二分搜尋更加節省空間。</li> </ul> <p>然而，二分搜尋並非適用於所有情況，主要有以下原因。</p> <ul> <li>二分搜尋僅適用於有序資料。若輸入資料無序，為了使用二分搜尋而專門進行排序，得不償失。因為排序演算法的時間複雜度通常為 \\(O(n \\log n)\\) ，比線性查詢和二分搜尋都更高。對於頻繁插入元素的場景，為保持陣列有序性，需要將元素插入到特定位置，時間複雜度為 \\(O(n)\\) ，也是非常昂貴的。</li> <li>二分搜尋僅適用於陣列。二分搜尋需要跳躍式（非連續地）訪問元素，而在鏈結串列中執行跳躍式訪問的效率較低，因此不適合應用在鏈結串列或基於鏈結串列實現的資料結構。</li> <li>小資料量下，線性查詢效能更佳。在線性查詢中，每輪只需 1 次判斷操作；而在二分搜尋中，需要 1 次加法、1 次除法、1 ~ 3 次判斷操作、1 次加法（減法），共 4 ~ 6 個單元操作；因此，當資料量 \\(n\\) 較小時，線性查詢反而比二分搜尋更快。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   二分搜尋邊界","text":"","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   查詢左邊界","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> ，其中可能包含重複元素。請返回陣列中最左一個元素 <code>target</code> 的索引。若陣列中不包含該元素，則返回 \\(-1\\) 。</p> <p>回憶二分搜尋插入點的方法，搜尋完成後 \\(i\\) 指向最左一個 <code>target</code> ，因此查詢插入點本質上是在查詢最左一個 <code>target</code> 的索引。</p> <p>考慮透過查詢插入點的函式實現查詢左邊界。請注意，陣列中可能不包含 <code>target</code> ，這種情況可能導致以下兩種結果。</p> <ul> <li>插入點的索引 \\(i\\) 越界。</li> <li>元素 <code>nums[i]</code> 與 <code>target</code> 不相等。</li> </ul> <p>當遇到以上兩種情況時，直接返回 \\(-1\\) 即可。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋最左一個 target\"\"\"\n    # 等價於查詢 target 的插入點\n    i = binary_search_insertion(nums, target)\n    # 未找到 target ，返回 -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # 找到 target ，返回索引 i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 二分搜尋最左一個 target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 二分搜尋最左一個 target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // 等價於查詢 target 的插入點\n    i := binarySearchInsertion(nums, target)\n    // 未找到 target ，返回 -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 二分搜尋最左一個 target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // 等價於查詢 target 的插入點\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // 未找到 target ，返回 -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* 二分搜尋最左一個 target */\nfunction binarySearchLeftEdge(nums, target) {\n    // 等價於查詢 target 的插入點\n    const i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 二分搜尋最左一個 target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 等價於查詢 target 的插入點\n    const i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // 等價於查詢 target 的插入點\n  int i = binarySearchInsertion(nums, target);\n  // 未找到 target ，返回 -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // 找到 target ，返回索引 i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 二分搜尋最左一個 target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 等價於查詢 target 的插入點\n    let i = binary_search_insertion(nums, target);\n    // 未找到 target ，返回 -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binarySearchInsertion(nums, numSize, target);\n    // 未找到 target ，返回 -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 二分搜尋最左一個 target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // 等價於查詢 target 的插入點\n    val i = binarySearchInsertion(nums, target)\n    // 未找到 target ，返回 -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### 二分搜尋最左一個 target ###\ndef binary_search_left_edge(nums, target)\n  # 等價於查詢 target 的插入點\n  i = binary_search_insertion(nums, target)\n\n  # 未找到 target ，返回 -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # 找到 target ，返回索引 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   查詢右邊界","text":"<p>那麼如何查詢最右一個 <code>target</code> 呢？最直接的方式是修改程式碼，替換在 <code>nums[m] == target</code> 情況下的指標收縮操作。程式碼在此省略，有興趣的讀者可以自行實現。</p> <p>下面我們介紹兩種更加取巧的方法。</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   複用查詢左邊界","text":"<p>實際上，我們可以利用查詢最左元素的函式來查詢最右元素，具體方法為：將查詢最右一個 <code>target</code> 轉化為查詢最左一個 <code>target + 1</code>。</p> <p>如圖 10-7 所示，查詢完成後，指標 \\(i\\) 指向最左一個 <code>target + 1</code>（如果存在），而 \\(j\\) 指向最右一個 <code>target</code> ，因此返回 \\(j\\) 即可。</p> <p></p> <p> 圖 10-7   將查詢右邊界轉化為查詢左邊界 </p> <p>請注意，返回的插入點是 \\(i\\) ，因此需要將其減 \\(1\\) ，從而獲得 \\(j\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋最右一個 target\"\"\"\n    # 轉化為查詢最左一個 target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j 指向最右一個 target ，i 指向首個大於 target 的元素\n    j = i - 1\n    # 未找到 target ，返回 -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # 找到 target ，返回索引 j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 二分搜尋最右一個 target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 二分搜尋最右一個 target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // 轉化為查詢最左一個 target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    j := i - 1\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 二分搜尋最右一個 target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // 轉化為查詢最左一個 target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    let j = i - 1\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* 二分搜尋最右一個 target */\nfunction binarySearchRightEdge(nums, target) {\n    // 轉化為查詢最左一個 target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    const j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 二分搜尋最右一個 target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 轉化為查詢最左一個 target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    const j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // 轉化為查詢最左一個 target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j 指向最右一個 target ，i 指向首個大於 target 的元素\n  int j = i - 1;\n  // 未找到 target ，返回 -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // 找到 target ，返回索引 j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 二分搜尋最右一個 target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 轉化為查詢最左一個 target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    let j = i - 1;\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 二分搜尋最右一個 target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // 轉化為查詢最左一個 target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    val j = i - 1\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### 二分搜尋最右一個 target ###\ndef binary_search_right_edge(nums, target)\n  # 轉化為查詢最左一個 target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j 指向最右一個 target ，i 指向首個大於 target 的元素\n  j = i - 1\n\n  # 未找到 target ，返回 -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # 找到 target ，返回索引 j\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   轉化為查詢元素","text":"<p>我們知道，當陣列不包含 <code>target</code> 時，最終 \\(i\\) 和 \\(j\\) 會分別指向首個大於、小於 <code>target</code> 的元素。</p> <p>因此，如圖 10-8 所示，我們可以構造一個陣列中不存在的元素，用於查詢左右邊界。</p> <ul> <li>查詢最左一個 <code>target</code> ：可以轉化為查詢 <code>target - 0.5</code> ，並返回指標 \\(i\\) 。</li> <li>查詢最右一個 <code>target</code> ：可以轉化為查詢 <code>target + 0.5</code> ，並返回指標 \\(j\\) 。</li> </ul> <p></p> <p> 圖 10-8   將查詢邊界轉化為查詢元素 </p> <p>程式碼在此省略，以下兩點值得注意。</p> <ul> <li>給定陣列不包含小數，這意味著我們無須關心如何處理相等的情況。</li> <li>因為該方法引入了小數，所以需要將函式中的變數 <code>target</code> 改為浮點數型別（Python 無須改動）。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   二分搜尋插入點","text":"<p>二分搜尋不僅可用於搜尋目標元素，還可用於解決許多變種問題，比如搜尋目標元素的插入位置。</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   無重複元素的情況","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> 和一個元素 <code>target</code> ，陣列不存在重複元素。現將 <code>target</code> 插入陣列 <code>nums</code> 中，並保持其有序性。若陣列中已存在元素 <code>target</code> ，則插入到其左方。請返回插入後 <code>target</code> 在陣列中的索引。示例如圖 10-4 所示。</p> <p></p> <p> 圖 10-4   二分搜尋插入點示例資料 </p> <p>如果想複用上一節的二分搜尋程式碼，則需要回答以下兩個問題。</p> <p>問題一：當陣列中包含 <code>target</code> 時，插入點的索引是否是該元素的索引？</p> <p>題目要求將 <code>target</code> 插入到相等元素的左邊，這意味著新插入的 <code>target</code> 替換了原來 <code>target</code> 的位置。也就是說，當陣列包含 <code>target</code> 時，插入點的索引就是該 <code>target</code> 的索引。</p> <p>問題二：當陣列中不存在 <code>target</code> 時，插入點是哪個元素的索引？</p> <p>進一步思考二分搜尋過程：當 <code>nums[m] &lt; target</code> 時 \\(i\\) 移動，這意味著指標 \\(i\\) 在向大於等於 <code>target</code> 的元素靠近。同理，指標 \\(j\\) 始終在向小於等於 <code>target</code> 的元素靠近。</p> <p>因此二分結束時一定有：\\(i\\) 指向首個大於 <code>target</code> 的元素，\\(j\\) 指向首個小於 <code>target</code> 的元素。易得當陣列不包含 <code>target</code> 時，插入索引為 \\(i\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋插入點（無重複元素）\"\"\"\n    i, j = 0, len(nums) - 1  # 初始化雙閉區間 [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # target 在區間 [i, m-1] 中\n        else:\n            return m  # 找到 target ，返回插入點 m\n    # 未找到 target ，返回插入點 i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分搜尋插入點（無重複元素） */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 計算中點索引 m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target 在區間 [i, m-1] 中\n            j = m - 1\n        } else {\n            // 找到 target ，返回插入點 m\n            return m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if nums[m] &gt; target {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            return m // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target 在區間 [m+1, j] 中\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target 在區間 [i, m-1] 中\n    } else {\n      return m; // 找到 target ，返回插入點 m\n    }\n  }\n  // 未找到 target ，返回插入點 i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分搜尋插入點（無重複元素） */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化雙閉區間 [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m;\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分搜尋插入點（無重複元素） */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            return m // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分搜尋插入點（無重複元素） ###\ndef binary_search_insertion_simple(nums, target)\n  # 初始化雙閉區間 [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # target 在區間 [i, m-1] 中\n    else\n      return m  # 找到 target ，返回插入點 m\n    end\n  end\n\n  i # 未找到 target ，返回插入點 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   存在重複元素的情況","text":"<p>Question</p> <p>在上一題的基礎上，規定陣列可能包含重複元素，其餘不變。</p> <p>假設陣列中存在多個 <code>target</code> ，則普通二分搜尋只能返回其中一個 <code>target</code> 的索引，而無法確定該元素的左邊和右邊還有多少 <code>target</code>。</p> <p>題目要求將目標元素插入到最左邊，所以我們需要查詢陣列中最左一個 <code>target</code> 的索引。初步考慮透過圖 10-5 所示的步驟實現。</p> <ol> <li>執行二分搜尋，得到任意一個 <code>target</code> 的索引，記為 \\(k\\) 。</li> <li>從索引 \\(k\\) 開始，向左進行線性走訪，當找到最左邊的 <code>target</code> 時返回。</li> </ol> <p></p> <p> 圖 10-5   線性查詢重複元素的插入點 </p> <p>此方法雖然可用，但其包含線性查詢，因此時間複雜度為 \\(O(n)\\) 。當陣列中存在很多重複的 <code>target</code> 時，該方法效率很低。</p> <p>現考慮拓展二分搜尋程式碼。如圖 10-6 所示，整體流程保持不變，每輪先計算中點索引 \\(m\\) ，再判斷 <code>target</code> 和 <code>nums[m]</code> 的大小關係，分為以下幾種情況。</p> <ul> <li>當 <code>nums[m] &lt; target</code> 或 <code>nums[m] &gt; target</code> 時，說明還沒有找到 <code>target</code> ，因此採用普通二分搜尋的縮小區間操作，從而使指標 \\(i\\) 和 \\(j\\) 向 <code>target</code> 靠近。</li> <li>當 <code>nums[m] == target</code> 時，說明小於 <code>target</code> 的元素在區間 \\([i, m - 1]\\) 中，因此採用 \\(j = m - 1\\) 來縮小區間，從而使指標 \\(j\\) 向小於 <code>target</code> 的元素靠近。</li> </ul> <p>迴圈完成後，\\(i\\) 指向最左邊的 <code>target</code> ，\\(j\\) 指向首個小於 <code>target</code> 的元素，因此索引 \\(i\\) 就是插入點。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 10-6   二分搜尋重複元素的插入點的步驟 </p> <p>觀察以下程式碼，判斷分支 <code>nums[m] &gt; target</code> 和 <code>nums[m] == target</code> 的操作相同，因此兩者可以合併。</p> <p>即便如此，我們仍然可以將判斷條件保持展開，因為其邏輯更加清晰、可讀性更好。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋插入點（存在重複元素）\"\"\"\n    i, j = 0, len(nums) - 1  # 初始化雙閉區間 [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # target 在區間 [i, m-1] 中\n        else:\n            j = m - 1  # 首個小於 target 的元素在區間 [i, m-1] 中\n    # 返回插入點 i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 計算中點索引 m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target 在區間 [i, m-1] 中\n            j = m - 1\n        } else {\n            // 首個小於 target 的元素在區間 [i, m-1] 中\n            j = m - 1\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if nums[m] &gt; target {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1 // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target 在區間 [m+1, j] 中\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target 在區間 [i, m-1] 中\n    } else {\n      j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n    }\n  }\n  // 返回插入點 i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分搜尋插入點（存在重複元素） */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化雙閉區間 [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1 // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分搜尋插入點（存在重複元素） ###\ndef binary_search_insertion(nums, target)\n  # 初始化雙閉區間 [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # target 在區間 [i, m-1] 中\n    else\n      j = m - 1 # 首個小於 target 的元素在區間 [i, m-1] 中\n    end\n  end\n\n  i # 返回插入點 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>本節的程式碼都是“雙閉區間”寫法。有興趣的讀者可以自行實現“左閉右開”寫法。</p> <p>總的來看，二分搜尋無非就是給指標 \\(i\\) 和 \\(j\\) 分別設定搜尋目標，目標可能是一個具體的元素（例如 <code>target</code> ），也可能是一個元素範圍（例如小於 <code>target</code> 的元素）。</p> <p>在不斷的迴圈二分中，指標 \\(i\\) 和 \\(j\\) 都逐漸逼近預先設定的目標。最終，它們或是成功找到答案，或是越過邊界後停止。</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   雜湊最佳化策略","text":"<p>在演算法題中，我們常透過將線性查詢替換為雜湊查詢來降低演算法的時間複雜度。我們藉助一個演算法題來加深理解。</p> <p>Question</p> <p>給定一個整數陣列 <code>nums</code> 和一個目標元素 <code>target</code> ，請在陣列中搜索“和”為 <code>target</code> 的兩個元素，並返回它們的陣列索引。返回任意一個解即可。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   線性查詢：以時間換空間","text":"<p>考慮直接走訪所有可能的組合。如圖 10-9 所示，我們開啟一個兩層迴圈，在每輪中判斷兩個整數的和是否為 <code>target</code> ，若是，則返回它們的索引。</p> <p></p> <p> 圖 10-9   線性查詢求解兩數之和 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法一：暴力列舉\"\"\"\n    # 兩層迴圈，時間複雜度為 O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法一：暴力列舉 */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法一：暴力列舉 */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法一：暴力列舉 */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法一：暴力列舉 */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法一：暴力列舉 */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法一：暴力列舉 */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法一：暴力列舉 */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法一： 暴力列舉 */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 兩層迴圈，時間複雜度為 O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法一：暴力列舉 */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 方法一：暴力列舉 */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法一：暴力列舉 */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法一：暴力列舉 ###\ndef two_sum_brute_force(nums, target)\n  # 兩層迴圈，時間複雜度為 O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>此方法的時間複雜度為 \\(O(n^2)\\) ，空間複雜度為 \\(O(1)\\) ，在大資料量下非常耗時。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042","level":2,"title":"10.4.2   雜湊查詢：以空間換時間","text":"<p>考慮藉助一個雜湊表，鍵值對分別為陣列元素和元素索引。迴圈走訪陣列，每輪執行圖 10-10 所示的步驟。</p> <ol> <li>判斷數字 <code>target - nums[i]</code> 是否在雜湊表中，若是，則直接返回這兩個元素的索引。</li> <li>將鍵值對 <code>nums[i]</code> 和索引 <code>i</code> 新增進雜湊表。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> 圖 10-10   輔助雜湊表求解兩數之和 </p> <p>實現程式碼如下所示，僅需單層迴圈即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法二：輔助雜湊表\"\"\"\n    # 輔助雜湊表，空間複雜度為 O(n)\n    dic = {}\n    # 單層迴圈，時間複雜度為 O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法二：輔助雜湊表 */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 輔助雜湊表，空間複雜度為 O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法二：輔助雜湊表 */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // 輔助雜湊表，空間複雜度為 O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法二：輔助雜湊表 */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // 輔助雜湊表，空間複雜度為 O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法二：輔助雜湊表 */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    hashTable := map[int]int{}\n    // 單層迴圈，時間複雜度為 O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法二：輔助雜湊表 */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    var dic: [Int: Int] = [:]\n    // 單層迴圈，時間複雜度為 O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法二：輔助雜湊表 */\nfunction twoSumHashTable(nums, target) {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let m = {};\n    // 單層迴圈，時間複雜度為 O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法二：輔助雜湊表 */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法二： 輔助雜湊表 */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 輔助雜湊表，空間複雜度為 O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // 單層迴圈，時間複雜度為 O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法二：輔助雜湊表 */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let mut dic = HashMap::new();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 雜湊表 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // 基於 uthash.h 實現\n} HashTable;\n\n/* 雜湊表查詢 */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* 雜湊表元素插入 */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* 方法二：輔助雜湊表 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法二：輔助雜湊表 */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 輔助雜湊表，空間複雜度為 O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // 單層迴圈，時間複雜度為 O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法二：輔助雜湊表 ###\ndef two_sum_hash_table(nums, target)\n  # 輔助雜湊表，空間複雜度為 O(n)\n  dic = {}\n  # 單層迴圈，時間複雜度為 O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>此方法透過雜湊查詢將時間複雜度從 \\(O(n^2)\\) 降至 \\(O(n)\\) ，大幅提升執行效率。</p> <p>由於需要維護一個額外的雜湊表，因此空間複雜度為 \\(O(n)\\) 。儘管如此，該方法的整體時空效率更為均衡，因此它是本題的最優解法。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   重識搜尋演算法","text":"<p>搜尋演算法（searching algorithm）用於在資料結構（例如陣列、鏈結串列、樹或圖）中搜索一個或一組滿足特定條件的元素。</p> <p>搜尋演算法可根據實現思路分為以下兩類。</p> <ul> <li>透過走訪資料結構來定位目標元素，例如陣列、鏈結串列、樹和圖的走訪等。</li> <li>利用資料組織結構或資料包含的先驗資訊，實現高效元素查詢，例如二分搜尋、雜湊查詢和二元搜尋樹查詢等。</li> </ul> <p>不難發現，這些知識點都已在前面的章節中介紹過，因此搜尋演算法對於我們來說並不陌生。在本節中，我們將從更加系統的視角切入，重新審視搜尋演算法。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   暴力搜尋","text":"<p>暴力搜尋透過走訪資料結構的每個元素來定位目標元素。</p> <ul> <li>“線性搜尋”適用於陣列和鏈結串列等線性資料結構。它從資料結構的一端開始，逐個訪問元素，直到找到目標元素或到達另一端仍沒有找到目標元素為止。</li> <li>“廣度優先搜尋”和“深度優先搜尋”是圖和樹的兩種走訪策略。廣度優先搜尋從初始節點開始逐層搜尋，由近及遠地訪問各個節點。深度優先搜尋從初始節點開始，沿著一條路徑走到頭，再回溯並嘗試其他路徑，直到走訪完整個資料結構。</li> </ul> <p>暴力搜尋的優點是簡單且通用性好，無須對資料做預處理和藉助額外的資料結構。</p> <p>然而，此類演算法的時間複雜度為 \\(O(n)\\) ，其中 \\(n\\) 為元素數量，因此在資料量較大的情況下效能較差。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   自適應搜尋","text":"<p>自適應搜尋利用資料的特有屬性（例如有序性）來最佳化搜尋過程，從而更高效地定位目標元素。</p> <ul> <li>“二分搜尋”利用資料的有序性實現高效查詢，僅適用於陣列。</li> <li>“雜湊查詢”利用雜湊表將搜尋資料和目標資料建立為鍵值對對映，從而實現查詢操作。</li> <li>“樹查詢”在特定的樹結構（例如二元搜尋樹）中，基於比較節點值來快速排除節點，從而定位目標元素。</li> </ul> <p>此類演算法的優點是效率高，時間複雜度可達到 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 。</p> <p>然而，使用這些演算法往往需要對資料進行預處理。例如，二分搜尋需要預先對陣列進行排序，雜湊查詢和樹查詢都需要藉助額外的資料結構，維護這些資料結構也需要額外的時間和空間開銷。</p> <p>Tip</p> <p>自適應搜尋演算法常被稱為查詢演算法，主要用於在特定資料結構中快速檢索目標元素。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   搜尋方法選取","text":"<p>給定大小為 \\(n\\) 的一組資料，我們可以使用線性搜尋、二分搜尋、樹查詢、雜湊查詢等多種方法從中搜索目標元素。各個方法的工作原理如圖 10-11 所示。</p> <p></p> <p> 圖 10-11   多種搜尋策略 </p> <p>上述幾種方法的操作效率與特性如表 10-1 所示。</p> <p> 表 10-1   查詢演算法效率對比 </p> 線性搜尋 二分搜尋 樹查詢 雜湊查詢 查詢元素 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) 插入元素 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 額外空間 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) 資料預處理 / 排序 \\(O(n \\log n)\\) 建樹 \\(O(n \\log n)\\) 建雜湊表 \\(O(n)\\) 資料是否有序 無序 有序 有序 無序 <p>搜尋演算法的選擇還取決規模、搜尋效能要求、資料查詢與更新頻率等。</p> <p>線性搜尋</p> <ul> <li>通用性較好，無須任何資料預處理操作。假如我們僅需查詢一次資料，那麼其他三種方法的資料預處理的時間比線性搜尋的時間還要更長。</li> <li>適用於體量較小的資料，此情況下時間複雜度對效率影響較小。</li> <li>適用於資料更新頻率較高的場景，因為該方法不需要對資料進行任何額外維護。</li> </ul> <p>二分搜尋</p> <ul> <li>適用於大資料量的情況，效率表現穩定，最差時間複雜度為 \\(O(\\log n)\\) 。</li> <li>資料量不能過大，因為儲存陣列需要連續的記憶體空間。</li> <li>不適用於高頻增刪資料的場景，因為維護有序陣列的開銷較大。</li> </ul> <p>雜湊查詢</p> <ul> <li>適合對查詢效能要求很高的場景，平均時間複雜度為 \\(O(1)\\) 。</li> <li>不適合需要有序資料或範圍查詢的場景，因為雜湊表無法維護資料的有序性。</li> <li>對雜湊函式和雜湊衝突處理策略的依賴性較高，具有較大的效能劣化風險。</li> <li>不適合資料量過大的情況，因為雜湊表需要額外空間來最大程度地減少衝突，從而提供良好的查詢效能。</li> </ul> <p>樹查詢</p> <ul> <li>適用於海量資料，因為樹節點在記憶體中是分散儲存的。</li> <li>適合需要維護有序資料或範圍查詢的場景。</li> <li>在持續增刪節點的過程中，二元搜尋樹可能產生傾斜，時間複雜度劣化至 \\(O(n)\\) 。</li> <li>若使用 AVL 樹或紅黑樹，則各項操作可在 \\(O(\\log n)\\) 效率下穩定執行，但維護樹平衡的操作會增加額外的開銷。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   小結","text":"","path":["第 10 章 &nbsp; 搜尋","10.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>二分搜尋依賴資料的有序性，透過迴圈逐步縮減一半搜尋區間來進行查詢。它要求輸入資料有序，且僅適用於陣列或基於陣列實現的資料結構。</li> <li>暴力搜尋透過走訪資料結構來定位資料。線性搜尋適用於陣列和鏈結串列，廣度優先搜尋和深度優先搜尋適用於圖和樹。此類演算法通用性好，無須對資料進行預處理，但時間複雜度 \\(O(n)\\) 較高。</li> <li>雜湊查詢、樹查詢和二分搜尋屬於高效搜尋方法，可在特定資料結構中快速定位目標元素。此類演算法效率高，時間複雜度可達 \\(O(\\log n)\\) 甚至 \\(O(1)\\) ，但通常需要藉助額外資料結構。</li> <li>實際中，我們需要對資料規模、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。</li> <li>線性搜尋適用於小型或頻繁更新的資料；二分搜尋適用於大型、排序的資料；雜湊查詢適用於對查詢效率要求較高且無須範圍查詢的資料；樹查詢適用於需要維護順序和支持範圍查詢的大型動態資料。</li> <li>用雜湊查詢替換線性查詢是一種常用的最佳化執行時間的策略，可將時間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) 。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"第 11 章   排序","text":"<p>Abstract</p> <p>排序猶如一把將混亂變為秩序的魔法鑰匙，使我們能以更高效的方式理解與處理資料。</p> <p>無論是簡單的升序，還是複雜的分類排列，排序都向我們展示了資料的和諧美感。</p>","path":["第 11 章 &nbsp; 排序"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"本章內容","text":"<ul> <li>11.1   排序演算法</li> <li>11.2   選擇排序</li> <li>11.3   泡沫排序</li> <li>11.4   插入排序</li> <li>11.5   快速排序</li> <li>11.6   合併排序</li> <li>11.7   堆積排序</li> <li>11.8   桶排序</li> <li>11.9   計數排序</li> <li>11.10   基數排序</li> <li>11.11   小結</li> </ul>","path":["第 11 章 &nbsp; 排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   泡沫排序","text":"<p>泡沫排序（bubble sort）透過連續地比較與交換相鄰元素實現排序。這個過程就像氣泡從底部升到頂部一樣，因此得名泡沫排序。</p> <p>如圖 11-4 所示，冒泡過程可以利用元素交換操作來模擬：從陣列最左端開始向右走訪，依次比較相鄰元素大小，如果“左元素 &gt; 右元素”就交換二者。走訪完成後，最大的元素會被移動到陣列的最右端。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-4   利用元素交換操作模擬冒泡 </p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   演算法流程","text":"<p>設陣列的長度為 \\(n\\) ，泡沫排序的步驟如圖 11-5 所示。</p> <ol> <li>首先，對 \\(n\\) 個元素執行“冒泡”，將陣列的最大元素交換至正確位置。</li> <li>接下來，對剩餘 \\(n - 1\\) 個元素執行“冒泡”，將第二大元素交換至正確位置。</li> <li>以此類推，經過 \\(n - 1\\) 輪“冒泡”後，前 \\(n - 1\\) 大的元素都被交換至正確位置。</li> <li>僅剩的一個元素必定是最小元素，無須排序，因此陣列排序完成。</li> </ol> <p></p> <p> 圖 11-5   泡沫排序流程 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"泡沫排序\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(n - 1, 0, -1):\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* 泡沫排序 */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                // 這裡使用了 std::swap() 函式\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* 泡沫排序 */\nvoid bubbleSort(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* 泡沫排序 */\nvoid BubbleSort(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* 泡沫排序 */\nfunc bubbleSort(nums []int) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* 泡沫排序 */\nfunc bubbleSort(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* 泡沫排序 */\nfunction bubbleSort(nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* 泡沫排序 */\nfunction bubbleSort(nums: number[]): void {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* 泡沫排序 */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // 外迴圈：未排序區間為 [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* 泡沫排序 */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* 泡沫排序 */\nvoid bubbleSort(int nums[], int size) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* 泡沫排序 */\nfun bubbleSort(nums: IntArray) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### 泡沫排序 ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (n - 1).downto(1)\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   效率最佳化","text":"<p>我們發現，如果某輪“冒泡”中沒有執行任何交換操作，說明陣列已經完成排序，可直接返回結果。因此，可以增加一個標誌位 <code>flag</code> 來監測這種情況，一旦出現就立即返回。</p> <p>經過最佳化，泡沫排序的最差時間複雜度和平均時間複雜度仍為 \\(O(n^2)\\) ；但當輸入陣列完全有序時，可達到最佳時間複雜度 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"泡沫排序（標誌最佳化）\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # 初始化標誌位\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # 記錄交換元素\n        if not flag:\n            break  # 此輪“冒泡”未交換任何元素，直接跳出\n</code></pre> bubble_sort.cpp<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                // 這裡使用了 std::swap() 函式\n                swap(nums[j], nums[j + 1]);\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag)\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* 泡沫排序（標誌最佳化） */\nvoid bubbleSortWithFlag(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag)\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid BubbleSortWithFlag(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // 記錄交換元素\n            }\n        }\n        if (!flag) break;     // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunc bubbleSortWithFlag(nums []int) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // 記錄交換元素\n            }\n        }\n        if flag == false { // 此輪“冒泡”未交換任何元素，直接跳出\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // 初始化標誌位\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // 記錄交換元素\n            }\n        }\n        if !flag { // 此輪“冒泡”未交換任何元素，直接跳出\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunction bubbleSortWithFlag(nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // 外迴圈：未排序區間為 [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // 初始化標誌位\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // 記錄交換元素\n      }\n    }\n    if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* 泡沫排序（標誌最佳化） */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // 記錄交換元素\n            }\n        }\n        if !flag {\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* 泡沫排序（標誌最佳化） */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // 記錄交換元素\n            }\n        }\n        if (!flag) break // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### 泡沫排序（標誌最佳化）###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # 初始化標誌位\n\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # 記錄交換元素\n      end\n    end\n\n    break unless flag # 此輪“冒泡”未交換任何元素，直接跳出\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、自適應排序：各輪“冒泡”走訪的陣列長度依次為 \\(n - 1\\)、\\(n - 2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，總和為 \\((n - 1) n / 2\\) 。在引入 <code>flag</code> 最佳化後，最佳時間複雜度可達到 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>穩定排序：由於在“冒泡”中遇到相等元素不交換。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   桶排序","text":"<p>前述幾種排序演算法都屬於“基於比較的排序演算法”，它們透過比較元素間的大小來實現排序。此類排序演算法的時間複雜度無法超越 \\(O(n \\log n)\\) 。接下來，我們將探討幾種“非比較排序演算法”，它們的時間複雜度可以達到線性階。</p> <p>桶排序（bucket sort）是分治策略的一個典型應用。它透過設定一些具有大小順序的桶，每個桶對應一個數據範圍，將資料平均分配到各個桶中；然後，在每個桶內部分別執行排序；最終按照桶的順序將所有資料合併。</p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   演算法流程","text":"<p>考慮一個長度為 \\(n\\) 的陣列，其元素是範圍 \\([0, 1)\\) 內的浮點數。桶排序的流程如圖 11-13 所示。</p> <ol> <li>初始化 \\(k\\) 個桶，將 \\(n\\) 個元素分配到 \\(k\\) 個桶中。</li> <li>對每個桶分別執行排序（這裡採用程式語言的內建排序函式）。</li> <li>按照桶從小到大的順序合併結果。</li> </ol> <p></p> <p> 圖 11-13   桶排序演算法流程 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"桶排序\"\"\"\n    # 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. 將陣列元素分配到各個桶中\n    for num in nums:\n        # 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        i = int(num * k)\n        # 將 num 新增進桶 i\n        buckets[i].append(num)\n    # 2. 對各個桶執行排序\n    for bucket in buckets:\n        # 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort()\n    # 3. 走訪桶合併結果\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* 桶排序 */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. 將陣列元素分配到各個桶中\n    for (float num : nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = num * k;\n        // 將 num 新增進桶 bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. 對各個桶執行排序\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. 走訪桶合併結果\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* 桶排序 */\nvoid bucketSort(float[] nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (float num : nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = (int) (num * k);\n        // 將 num 新增進桶 i\n        buckets.get(i).add(num);\n    }\n    // 2. 對各個桶執行排序\n    for (List&lt;Float&gt; bucket : buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        Collections.sort(bucket);\n    }\n    // 3. 走訪桶合併結果\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* 桶排序 */\nvoid BucketSort(float[] nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    foreach (float num in nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = (int)(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].Add(num);\n    }\n    // 2. 對各個桶執行排序\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.Sort();\n    }\n    // 3. 走訪桶合併結果\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* 桶排序 */\nfunc bucketSort(nums []float64) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for _, num := range nums {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        i := int(num * float64(k))\n        // 將 num 新增進桶 i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. 對各個桶執行排序\n    for i := 0; i &lt; k; i++ {\n        // 使用內建切片排序函式，也可以替換成其他排序演算法\n        sort.Float64s(buckets[i])\n    }\n    // 3. 走訪桶合併結果\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* 桶排序 */\nfunc bucketSort(nums: inout [Double]) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. 將陣列元素分配到各個桶中\n    for num in nums {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        let i = Int(num * Double(k))\n        // 將 num 新增進桶 i\n        buckets[i].append(num)\n    }\n    // 2. 對各個桶執行排序\n    for i in buckets.indices {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        buckets[i].sort()\n    }\n    // 3. 走訪桶合併結果\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* 桶排序 */\nfunction bucketSort(nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (const num of nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        const i = Math.floor(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for (const bucket of buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. 走訪桶合併結果\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* 桶排序 */\nfunction bucketSort(nums: number[]): void {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (const num of nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        const i = Math.floor(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for (const bucket of buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. 走訪桶合併結果\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* 桶排序 */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. 將陣列元素分配到各個桶中\n  for (double _num in nums) {\n    // 輸入資料範圍為 [0, 1)，使用 _num * k 對映到索引範圍 [0, k-1]\n    int i = (_num * k).toInt();\n    // 將 _num 新增進桶 bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. 對各個桶執行排序\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. 走訪桶合併結果\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* 桶排序 */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. 將陣列元素分配到各個桶中\n    for &amp;num in nums.iter() {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        let i = (num * k as f64) as usize;\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for bucket in &amp;mut buckets {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. 走訪桶合併結果\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* 桶排序 */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // 初始化 k = n/2 個桶\n    int *sizes = malloc(k * sizeof(int));          // 記錄每個桶的大小\n    float **buckets = malloc(k * sizeof(float *)); // 動態陣列的陣列（桶）\n    // 為每個桶預分配足夠的空間\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. 對各個桶執行排序\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. 合併排序後的桶\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // 釋放記憶體\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* 桶排序 */\nfun bucketSort(nums: FloatArray) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (num in nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        val i = (num * k).toInt()\n        // 將 num 新增進桶 i\n        buckets[i].add(num)\n    }\n    // 2. 對各個桶執行排序\n    for (bucket in buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort()\n    }\n    // 3. 走訪桶合併結果\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### 桶排序 ###\ndef bucket_sort(nums)\n  # 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. 將陣列元素分配到各個桶中\n  nums.each do |num|\n    # 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n    i = (num * k).to_i\n    # 將 num 新增進桶 i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. 對各個桶執行排序\n  buckets.each do |bucket|\n    # 使用內建排序函式，也可以替換成其他排序演算法\n    bucket.sort!\n  end\n\n  # 3. 走訪桶合併結果\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   演算法特性","text":"<p>桶排序適用於處理體量很大的資料。例如，輸入資料包含 100 萬個元素，由於空間限制，系統記憶體無法一次性載入所有資料。此時，可以將資料分成 1000 個桶，然後分別對每個桶進行排序，最後將結果合併。</p> <ul> <li>時間複雜度為 \\(O(n + k)\\) ：假設元素在各個桶內平均分佈，那麼每個桶內的元素數量為 \\(\\frac{n}{k}\\) 。假設排序單個桶使用 \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) 時間，則排序所有桶使用 \\(O(n \\log\\frac{n}{k})\\) 時間。當桶數量 \\(k\\) 比較大時，時間複雜度則趨向於 \\(O(n)\\) 。合併結果時需要走訪所有桶和元素，花費 \\(O(n + k)\\) 時間。在最差情況下，所有資料被分配到一個桶中，且排序該桶使用 \\(O(n^2)\\) 時間。</li> <li>空間複雜度為 \\(O(n + k)\\)、非原地排序：需要藉助 \\(k\\) 個桶和總共 \\(n\\) 個元素的額外空間。</li> <li>桶排序是否穩定取決於排序桶內元素的演算法是否穩定。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   如何實現平均分配","text":"<p>桶排序的時間複雜度理論上可以達到 \\(O(n)\\) ，關鍵在於將元素均勻分配到各個桶中，因為實際資料往往不是均勻分佈的。例如，我們想要將淘寶上的所有商品按價格範圍平均分配到 10 個桶中，但商品價格分佈不均，低於 100 元的非常多，高於 1000 元的非常少。若將價格區間平均劃分為 10 個，各個桶中的商品數量差距會非常大。</p> <p>為實現平均分配，我們可以先設定一條大致的分界線，將資料粗略地分到 3 個桶中。分配完畢後，再將商品較多的桶繼續劃分為 3 個桶，直至所有桶中的元素數量大致相等。</p> <p>如圖 11-14 所示，這種方法本質上是建立一棵遞迴樹，目標是讓葉節點的值儘可能平均。當然，不一定要每輪將資料劃分為 3 個桶，具體劃分方式可根據資料特點靈活選擇。</p> <p></p> <p> 圖 11-14   遞迴劃分桶 </p> <p>如果我們提前知道商品價格的機率分佈，則可以根據資料機率分佈設定每個桶的價格分界線。值得注意的是，資料分佈並不一定需要特意統計，也可以根據資料特點採用某種機率模型進行近似。</p> <p>如圖 11-15 所示，我們假設商品價格服從正態分佈，這樣就可以合理地設定價格區間，從而將商品平均分配到各個桶中。</p> <p></p> <p> 圖 11-15   根據機率分佈劃分桶 </p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   計數排序","text":"<p>計數排序（counting sort）透過統計元素數量來實現排序，通常應用於整數陣列。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   簡單實現","text":"<p>先來看一個簡單的例子。給定一個長度為 \\(n\\) 的陣列 <code>nums</code> ，其中的元素都是“非負整數”，計數排序的整體流程如圖 11-16 所示。</p> <ol> <li>走訪陣列，找出其中的最大數字，記為 \\(m\\) ，然後建立一個長度為 \\(m + 1\\) 的輔助陣列 <code>counter</code> 。</li> <li>藉助 <code>counter</code> 統計 <code>nums</code> 中各數字的出現次數，其中 <code>counter[num]</code> 對應數字 <code>num</code> 的出現次數。統計方法很簡單，只需走訪 <code>nums</code>（設當前數字為 <code>num</code>），每輪將 <code>counter[num]</code> 增加 \\(1\\) 即可。</li> <li>由於 <code>counter</code> 的各個索引天然有序，因此相當於所有數字已經排序好了。接下來，我們走訪 <code>counter</code> ，根據各數字出現次數從小到大的順序填入 <code>nums</code> 即可。</li> </ol> <p></p> <p> 圖 11-16   計數排序流程 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"計數排序\"\"\"\n    # 簡單實現，無法用於排序物件\n    # 1. 統計陣列最大元素 m\n    m = max(nums)\n    # 2. 統計各數字的出現次數\n    # counter[num] 代表 num 的出現次數\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. 走訪 counter ，將各元素填入原陣列 nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid CountingSortNaive(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunc countingSortNaive(nums []int) {\n    // 1. 統計陣列最大元素 m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. 統計陣列最大元素 m\n    let m = nums.max()!\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunction countingSortNaive(nums) {\n    // 1. 統計陣列最大元素 m\n    let m = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunction countingSortNaive(nums: number[]): void {\n    // 1. 統計陣列最大元素 m\n    let m: number = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. 統計陣列最大元素 m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 統計各數字的出現次數\n  // counter[_num] 代表 _num 的出現次數\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. 走訪 counter ，將各元素填入原陣列 nums\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. 統計陣列最大元素 m\n    let m = *nums.iter().max().unwrap();\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(int nums[], int size) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. 釋放記憶體\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfun countingSortNaive(nums: IntArray) {\n    // 1. 統計陣列最大元素 m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計數排序 ###\ndef counting_sort_naive(nums)\n  # 簡單實現，無法用於排序物件\n  # 1. 統計陣列最大元素 m\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. 統計各數字的出現次數\n  # counter[num] 代表 num 的出現次數\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. 走訪 counter ，將各元素填入原陣列 nums\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>計數排序與桶排序的關聯</p> <p>從桶排序的角度看，我們可以將計數排序中的計數陣列 <code>counter</code> 的每個索引視為一個桶，將統計數量的過程看作將各個元素分配到對應的桶中。本質上，計數排序是桶排序在整型資料下的一個特例。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   完整實現","text":"<p>細心的讀者可能發現了，如果輸入資料是物件，上述步驟 <code>3.</code> 就失效了。假設輸入資料是商品物件，我們想按照商品價格（類別的成員變數）對商品進行排序，而上述演算法只能給出價格的排序結果。</p> <p>那麼如何才能得到原資料的排序結果呢？我們首先計算 <code>counter</code> 的“前綴和”。顧名思義，索引 <code>i</code> 處的前綴和 <code>prefix[i]</code> 等於陣列前 <code>i</code> 個元素之和：</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>前綴和具有明確的意義，<code>prefix[num] - 1</code> 代表元素 <code>num</code> 在結果陣列 <code>res</code> 中最後一次出現的索引。這個資訊非常關鍵，因為它告訴我們各個元素應該出現在結果陣列的哪個位置。接下來，我們倒序走訪原陣列 <code>nums</code> 的每個元素 <code>num</code> ，在每輪迭代中執行以下兩步。</p> <ol> <li>將 <code>num</code> 填入陣列 <code>res</code> 的索引 <code>prefix[num] - 1</code> 處。</li> <li>令前綴和 <code>prefix[num]</code> 減小 \\(1\\) ，從而得到下次放置 <code>num</code> 的索引。</li> </ol> <p>走訪完成後，陣列 <code>res</code> 中就是排序好的結果，最後使用 <code>res</code> 覆蓋原陣列 <code>nums</code> 即可。圖 11-17 展示了完整的計數排序流程。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-17   計數排序步驟 </p> <p>計數排序的實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"計數排序\"\"\"\n    # 完整實現，可排序物件，並且是穩定排序\n    # 1. 統計陣列最大元素 m\n    m = max(nums)\n    # 2. 統計各數字的出現次數\n    # counter[num] 代表 num 的出現次數\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    # 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    # 初始化陣列 res 用於記錄結果\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # 將 num 放置到對應索引處\n        counter[num] -= 1  # 令前綴和自減 1 ，得到下次放置 num 的索引\n    # 使用結果陣列 res 覆蓋原陣列 nums\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--;              // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid CountingSort(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunc countingSort(nums []int) {\n    // 1. 統計陣列最大元素 m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // 將 num 放置到對應索引處\n        res[counter[num]-1] = num\n        // 令前綴和自減 1 ，得到下次放置 num 的索引\n        counter[num]--\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunc countingSort(nums: inout [Int]) {\n    // 1. 統計陣列最大元素 m\n    let m = nums.max()!\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // 將 num 放置到對應索引處\n        counter[num] -= 1 // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunction countingSort(nums) {\n    // 1. 統計陣列最大元素 m\n    let m = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunction countingSort(nums: number[]): void {\n    // 1. 統計陣列最大元素 m\n    let m: number = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. 統計陣列最大元素 m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 統計各數字的出現次數\n  // counter[_num] 代表 _num 的出現次數\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n  // 即 counter[_num]-1 是 _num 在 res 中最後一次出現的索引\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n  // 初始化陣列 res 用於記錄結果\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // 將 _num 放置到對應索引處\n    counter[_num]--; // 令前綴和自減 1 ，得到下次放置 _num 的索引\n  }\n  // 使用結果陣列 res 覆蓋原陣列 nums\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. 統計陣列最大元素 m\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // 將 num 放置到對應索引處\n        counter[num as usize] -= 1; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(int nums[], int size) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--;              // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    memcpy(nums, res, size * sizeof(int));\n    // 5. 釋放記憶體\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfun countingSort(nums: IntArray) {\n    // 1. 統計陣列最大元素 m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // 將 num 放置到對應索引處\n        counter[num]-- // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計數排序 ###\ndef counting_sort(nums)\n  # 完整實現，可排序物件，並且是穩定排序\n  # 1. 統計陣列最大元素 m\n  m = nums.max\n  # 2. 統計各數字的出現次數\n  # counter[num] 代表 num 的出現次數\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n  # 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. 倒序走訪 nums, 將各元素填入結果陣列 res\n  # 初始化陣列 res 用於記錄結果\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # 將 num 放置到對應索引處\n    counter[num] -= 1 # 令前綴和自減 1 ，得到下次放置 num 的索引\n  end\n  # 使用結果陣列 res 覆蓋原陣列 nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n + m)\\)、非自適應排序 ：涉及走訪 <code>nums</code> 和走訪 <code>counter</code> ，都使用線性時間。一般情況下 \\(n \\gg m\\) ，時間複雜度趨於 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(n + m)\\)、非原地排序：藉助了長度分別為 \\(n\\) 和 \\(m\\) 的陣列 <code>res</code> 和 <code>counter</code> 。</li> <li>穩定排序：由於向 <code>res</code> 中填充元素的順序是“從右向左”的，因此倒序走訪 <code>nums</code> 可以避免改變相等元素之間的相對位置，從而實現穩定排序。實際上，正序走訪 <code>nums</code> 也可以得到正確的排序結果，但結果是非穩定的。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   侷限性","text":"<p>看到這裡，你也許會覺得計數排序非常巧妙，僅透過統計數量就可以實現高效的排序。然而，使用計數排序的前置條件相對較為嚴格。</p> <p>計數排序只適用於非負整數。若想將其用於其他型別的資料，需要確保這些資料可以轉換為非負整數，並且在轉換過程中不能改變各個元素之間的相對大小關係。例如，對於包含負數的整數陣列，可以先給所有數字加上一個常數，將全部數字轉化為正數，排序完成後再轉換回去。</p> <p>計數排序適用於資料量大但資料範圍較小的情況。比如，在上述示例中 \\(m\\) 不能太大，否則會佔用過多空間。而當 \\(n \\ll m\\) 時，計數排序使用 \\(O(m)\\) 時間，可能比 \\(O(n \\log n)\\) 的排序演算法還要慢。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   堆積排序","text":"<p>Tip</p> <p>閱讀本節前，請確保已學完“堆積”章節。</p> <p>堆積排序（heap sort）是一種基於堆積資料結構實現的高效排序演算法。我們可以利用已經學過的“建堆積操作”和“元素出堆積操作”實現堆積排序。</p> <ol> <li>輸入陣列並建立小頂堆積，此時最小元素位於堆積頂。</li> <li>不斷執行出堆積操作，依次記錄出堆積元素，即可得到從小到大排序的序列。</li> </ol> <p>以上方法雖然可行，但需要藉助一個額外陣列來儲存彈出的元素，比較浪費空間。在實際中，我們通常使用一種更加優雅的實現方式。</p>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   演算法流程","text":"<p>設陣列的長度為 \\(n\\) ，堆積排序的流程如圖 11-12 所示。</p> <ol> <li>輸入陣列並建立大頂堆積。完成後，最大元素位於堆積頂。</li> <li>將堆積頂元素（第一個元素）與堆積底元素（最後一個元素）交換。完成交換後，堆積的長度減 \\(1\\) ，已排序元素數量加 \\(1\\) 。</li> <li>從堆積頂元素開始，從頂到底執行堆積化操作（sift down）。完成堆積化後，堆積的性質得到修復。</li> <li>迴圈執行第 <code>2.</code> 步和第 <code>3.</code> 步。迴圈 \\(n - 1\\) 輪後，即可完成陣列排序。</li> </ol> <p>Tip</p> <p>實際上，元素出堆積操作中也包含第 <code>2.</code> 步和第 <code>3.</code> 步，只是多了一個彈出元素的步驟。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-12   堆積排序步驟 </p> <p>在程式碼實現中，我們使用了與“堆積”章節相同的從頂至底堆積化 <code>sift_down()</code> 函式。值得注意的是，由於堆積的長度會隨著提取最大元素而減小，因此我們需要給 <code>sift_down()</code> 函式新增一個長度參數 \\(n\\) ，用於指定堆積的當前有效長度。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"堆積的長度為 n ，從節點 i 開始，從頂至底堆積化\"\"\"\n    while True:\n        # 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i:\n            break\n        # 交換兩節點\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # 迴圈向下堆積化\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"堆積排序\"\"\"\n    # 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in range(len(nums) - 1, 0, -1):\n        # 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums[0], nums[i] = nums[i], nums[0]\n        # 以根節點為起點，從頂至底進行堆積化\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) {\n            break;\n        }\n        // 交換兩節點\n        swap(nums[i], nums[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        swap(nums[0], nums[i]);\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(int[] nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid HeapSort(int[] nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // 以根節點為起點，從頂至底進行堆積化\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfunc heapSort(nums *[]int) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        nums.swapAt(i, ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfunc heapSort(nums: inout [Int]) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in nums.indices.dropFirst().reversed() {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums.swapAt(0, i)\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) {\n            break;\n        }\n        // 交換兩節點\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfunction heapSort(nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) {\n            break;\n        }\n        // 交換兩節點\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfunction heapSort(nums: number[]): void {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // 判斷節點 i, l, r 中值最大的節點，記為 ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    if (ma == i) break;\n    // 交換兩節點\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // 迴圈向下堆積化\n    i = ma;\n  }\n}\n\n/* 堆積排序 */\nvoid heapSort(List&lt;int&gt; nums) {\n  // 建堆積操作：堆積化除葉節點以外的其他所有節點\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // 從堆積中提取最大元素，迴圈 n-1 輪\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // 以根節點為起點，從頂至底進行堆積化\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break;\n        }\n        // 交換兩節點\n        nums.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in (1..nums.len()).rev() {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums.swap(0, i);\n        // 以根節點為起點，從頂至底進行堆積化\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) {\n            break;\n        }\n        // 交換兩節點\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(int nums[], int n) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = n - 1; i &gt; 0; --i) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) \n            break\n        // 交換兩節點\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfun heapSort(nums: IntArray) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (i in nums.size - 1 downTo 1) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 ###\ndef sift_down(nums, n, i)\n  while true\n    # 判斷節點 i, l, r 中值最大的節點，記為 ma\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    break if ma == i\n    # 交換兩節點\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # 迴圈向下堆積化\n    i = ma\n  end\nend\n\n### 堆積排序 ###\ndef heap_sort(nums)\n  # 建堆積操作：堆積化除葉節點以外的其他所有節點\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # 從堆積中提取最大元素，迴圈 n-1 輪\n  (nums.length - 1).downto(1) do |i|\n    # 交換根節點與最右葉節點（交換首元素與尾元素）\n    nums[0], nums[i] = nums[i], nums[0]\n    # 以根節點為起點，從頂至底進行堆積化\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：建堆積操作使用 \\(O(n)\\) 時間。從堆積中提取最大元素的時間複雜度為 \\(O(\\log n)\\) ，共迴圈 \\(n - 1\\) 輪。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：幾個指標變數使用 \\(O(1)\\) 空間。元素交換和堆積化操作都是在原陣列上進行的。</li> <li>非穩定排序：在交換堆積頂元素和堆積底元素時，相等元素的相對位置可能發生變化。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   插入排序","text":"<p>插入排序（insertion sort）是一種簡單的排序演算法，它的工作原理與手動整理一副牌的過程非常相似。</p> <p>具體來說，我們在未排序區間選擇一個基準元素，將該元素與其左側已排序區間的元素逐一比較大小，並將該元素插入到正確的位置。</p> <p>圖 11-6 展示了陣列插入元素的操作流程。設基準元素為 <code>base</code> ，我們需要將從目標索引到 <code>base</code> 之間的所有元素向右移動一位，然後將 <code>base</code> 賦值給目標索引。</p> <p></p> <p> 圖 11-6   單次插入操作 </p>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   演算法流程","text":"<p>插入排序的整體流程如圖 11-7 所示。</p> <ol> <li>初始狀態下，陣列的第 1 個元素已完成排序。</li> <li>選取陣列的第 2 個元素作為 <code>base</code> ，將其插入到正確位置後，陣列的前 2 個元素已排序。</li> <li>選取第 3 個元素作為 <code>base</code> ，將其插入到正確位置後，陣列的前 3 個元素已排序。</li> <li>以此類推，在最後一輪中，選取最後一個元素作為 <code>base</code> ，將其插入到正確位置後，所有元素均已排序。</li> </ol> <p></p> <p> 圖 11-7   插入排序流程 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"插入排序\"\"\"\n    # 外迴圈：已排序區間為 [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # 將 nums[j] 向右移動一位\n            j -= 1\n        nums[j + 1] = base  # 將 base 賦值到正確位置\n</code></pre> insertion_sort.cpp<pre><code>/* 插入排序 */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* 插入排序 */\nvoid insertionSort(int[] nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base;        // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* 插入排序 */\nvoid InsertionSort(int[] nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = bas;         // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* 插入排序 */\nfunc insertionSort(nums []int) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // 將 nums[j] 向右移動一位\n            j--\n        }\n        nums[j+1] = base // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* 插入排序 */\nfunc insertionSort(nums: inout [Int]) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // 將 nums[j] 向右移動一位\n            j -= 1\n        }\n        nums[j + 1] = base // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* 插入排序 */\nfunction insertionSort(nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* 插入排序 */\nfunction insertionSort(nums: number[]): void {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* 插入排序 */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // 外迴圈：已排序區間為 [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n      j--;\n    }\n    nums[j + 1] = base; // 將 base 賦值到正確位置\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* 插入排序 */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // 將 nums[j] 向右移動一位\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* 插入排序 */\nvoid insertionSort(int nums[], int size) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // 將 nums[j] 向右移動一位\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // 將 base 賦值到正確位置\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* 插入排序 */\nfun insertionSort(nums: IntArray) {\n    //外迴圈: 已排序元素為 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // 將 nums[j] 向右移動一位\n            j--\n        }\n        nums[j + 1] = base        // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### 插入排序 ###\ndef insertion_sort(nums)\n  n = nums.length\n  # 外迴圈：已排序區間為 [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # 將 nums[j] 向右移動一位\n      j -= 1\n    end\n    nums[j + 1] = base # 將 base 賦值到正確位置\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、自適應排序：在最差情況下，每次插入操作分別需要迴圈 \\(n - 1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 次，求和得到 \\((n - 1) n / 2\\) ，因此時間複雜度為 \\(O(n^2)\\) 。在遇到有序資料時，插入操作會提前終止。當輸入陣列完全有序時，插入排序達到最佳時間複雜度 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>穩定排序：在插入操作過程中，我們會將元素插入到相等元素的右側，不會改變它們的順序。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   插入排序的優勢","text":"<p>插入排序的時間複雜度為 \\(O(n^2)\\) ，而我們即將學習的快速排序的時間複雜度為 \\(O(n \\log n)\\) 。儘管插入排序的時間複雜度更高，但在資料量較小的情況下，插入排序通常更快。</p> <p>這個結論與線性查詢和二分搜尋的適用情況的結論類似。快速排序這類 \\(O(n \\log n)\\) 的演算法屬於基於分治策略的排序演算法，往往包含更多單元計算操作。而在資料量較小時，\\(n^2\\) 和 \\(n \\log n\\) 的數值比較接近，複雜度不佔主導地位，每輪中的單元操作數量起到決定性作用。</p> <p>實際上，許多程式語言（例如 Java）的內建排序函式採用了插入排序，大致思路為：對於長陣列，採用基於分治策略的排序演算法，例如快速排序；對於短陣列，直接使用插入排序。</p> <p>雖然泡沫排序、選擇排序和插入排序的時間複雜度都為 \\(O(n^2)\\) ，但在實際情況中，插入排序的使用頻率顯著高於泡沫排序和選擇排序，主要有以下原因。</p> <ul> <li>泡沫排序基於元素交換實現，需要藉助一個臨時變數，共涉及 3 個單元操作；插入排序基於元素賦值實現，僅需 1 個單元操作。因此，泡沫排序的計算開銷通常比插入排序更高。</li> <li>選擇排序在任何情況下的時間複雜度都為 \\(O(n^2)\\) 。如果給定一組部分有序的資料，插入排序通常比選擇排序效率更高。</li> <li>選擇排序不穩定，無法應用於多級排序。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   合併排序","text":"<p>合併排序（merge sort）是一種基於分治策略的排序演算法，包含圖 11-10 所示的“劃分”和“合併”階段。</p> <ol> <li>劃分階段：透過遞迴不斷地將陣列從中點處分開，將長陣列的排序問題轉換為短陣列的排序問題。</li> <li>合併階段：當子陣列長度為 1 時終止劃分，開始合併，持續地將左右兩個較短的有序陣列合併為一個較長的有序陣列，直至結束。</li> </ol> <p></p> <p> 圖 11-10   合併排序的劃分與合併階段 </p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   演算法流程","text":"<p>如圖 11-11 所示，“劃分階段”從頂至底遞迴地將陣列從中點切分為兩個子陣列。</p> <ol> <li>計算陣列中點 <code>mid</code> ，遞迴劃分左子陣列（區間 <code>[left, mid]</code> ）和右子陣列（區間 <code>[mid + 1, right]</code> ）。</li> <li>遞迴執行步驟 <code>1.</code> ，直至子陣列區間長度為 1 時終止。</li> </ol> <p>“合併階段”從底至頂地將左子陣列和右子陣列合併為一個有序陣列。需要注意的是，從長度為 1 的子陣列開始合併，合併階段中的每個子陣列都是有序的。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-11   合併排序步驟 </p> <p>觀察發現，合併排序與二元樹後序走訪的遞迴順序是一致的。</p> <ul> <li>後序走訪：先遞迴左子樹，再遞迴右子樹，最後處理根節點。</li> <li>合併排序：先遞迴左子陣列，再遞迴右子陣列，最後處理合併。</li> </ul> <p>合併排序的實現如以下程式碼所示。請注意，<code>nums</code> 的待合併區間為 <code>[left, right]</code> ，而 <code>tmp</code> 的對應區間為 <code>[0, right - left]</code> 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"合併左子陣列和右子陣列\"\"\"\n    # 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    # 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    tmp = [0] * (right - left + 1)\n    # 初始化左子陣列和右子陣列的起始索引\n    i, j, k = left, mid + 1, 0\n    # 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"合併排序\"\"\"\n    # 終止條件\n    if left &gt;= right:\n        return  # 當子陣列長度為 1 時終止遞迴\n    # 劃分階段\n    mid = (left + right) // 2 # 計算中點\n    merge_sort(nums, left, mid)  # 遞迴左子陣列\n    merge_sort(nums, mid + 1, right)  # 遞迴右子陣列\n    # 合併階段\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    vector&lt;int&gt; tmp(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    mergeSort(nums, left, mid);      // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int[] tmp = new int[right - left + 1];\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid mergeSort(int[] nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2; // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* 合併左子陣列和右子陣列 */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int[] tmp = new int[right - left + 1];\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid MergeSort(int[] nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right) return;       // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    MergeSort(nums, left, mid);      // 遞迴左子陣列\n    MergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* 合併左子陣列和右子陣列 */\nfunc merge(nums []int, left, mid, right int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    tmp := make([]int, right-left+1)\n    // 初始化左子陣列和右子陣列的起始索引\n    i, j, k := left, mid+1, 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* 合併排序 */\nfunc mergeSort(nums []int, left, right int) {\n    // 終止條件\n    if left &gt;= right {\n        return\n    }\n    // 劃分階段\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // 合併階段\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* 合併左子陣列和右子陣列 */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // 初始化左子陣列和右子陣列的起始索引\n    var i = left, j = mid + 1, k = 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* 合併排序 */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // 終止條件\n    if left &gt;= right { // 當子陣列長度為 1 時終止遞迴\n        return\n    }\n    // 劃分階段\n    let mid = left + (right - left) / 2 // 計算中點\n    mergeSort(nums: &amp;nums, left: left, right: mid) // 遞迴左子陣列\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // 遞迴右子陣列\n    // 合併階段\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* 合併左子陣列和右子陣列 */\nfunction merge(nums, left, mid, right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    const tmp = new Array(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfunction mergeSort(nums, left, right) {\n    // 終止條件\n    if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    let mid = Math.floor(left + (right - left) / 2); // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* 合併左子陣列和右子陣列 */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    const tmp = new Array(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // 終止條件\n    if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    let mid = Math.floor(left + (right - left) / 2); // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n  // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // 初始化左子陣列和右子陣列的起始索引\n  int i = left, j = mid + 1, k = 0;\n  // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* 合併排序 */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // 終止條件\n  if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n  // 劃分階段\n  int mid = left + (right - left) ~/ 2; // 計算中點\n  mergeSort(nums, left, mid); // 遞迴左子陣列\n  mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n  // 合併階段\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* 合併左子陣列和右子陣列 */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // 初始化左子陣列和右子陣列的起始索引\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // 終止條件\n    if left &gt;= right {\n        return; // 當子陣列長度為 1 時終止遞迴\n    }\n\n    // 劃分階段\n    let mid = left + (right - left) / 2; // 計算中點\n    merge_sort(nums, left, mid); // 遞迴左子陣列\n    merge_sort(nums, mid + 1, right); // 遞迴右子陣列\n\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(int *nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // 釋放記憶體\n    free(tmp);\n}\n\n/* 合併排序 */\nvoid mergeSort(int *nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    mergeSort(nums, left, mid);      // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* 合併左子陣列和右子陣列 */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    val tmp = IntArray(right - left + 1)\n    // 初始化左子陣列和右子陣列的起始索引\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* 合併排序 */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // 終止條件\n    if (left &gt;= right) return  // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    val mid = left + (right - left) / 2 // 計算中點\n    mergeSort(nums, left, mid) // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right) // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### 合併左子陣列和右子陣列 ###\ndef merge(nums, left, mid, right)\n  # 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n  # 建立一個臨時陣列 tmp，用於存放合併後的結果\n  tmp = Array.new(right - left + 1, 0)\n  # 初始化左子陣列和右子陣列的起始索引\n  i, j, k = left, mid + 1, 0\n  # 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### 合併排序 ###\ndef merge_sort(nums, left, right)\n  # 終止條件\n  # 當子陣列長度為 1 時終止遞迴\n  return if left &gt;= right\n  # 劃分階段\n  mid = left + (right - left) / 2 # 計算中點\n  merge_sort(nums, left, mid) # 遞迴左子陣列\n  merge_sort(nums, mid + 1, right) # 遞迴右子陣列\n  # 合併階段\n  merge(nums, left, mid, right)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：劃分產生高度為 \\(\\log n\\) 的遞迴樹，每層合併的總操作數量為 \\(n\\) ，因此總體時間複雜度為 \\(O(n \\log n)\\) 。</li> <li>空間複雜度為 \\(O(n)\\)、非原地排序：遞迴深度為 \\(\\log n\\) ，使用 \\(O(\\log n)\\) 大小的堆疊幀空間。合併操作需要藉助輔助陣列實現，使用 \\(O(n)\\) 大小的額外空間。</li> <li>穩定排序：在合併過程中，相等元素的次序保持不變。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   鏈結串列排序","text":"<p>對於鏈結串列，合併排序相較於其他排序演算法具有顯著優勢，可以將鏈結串列排序任務的空間複雜度最佳化至 \\(O(1)\\) 。</p> <ul> <li>劃分階段：可以使用“迭代”替代“遞迴”來實現鏈結串列劃分工作，從而省去遞迴使用的堆疊幀空間。</li> <li>合併階段：在鏈結串列中，節點增刪操作僅需改變引用（指標）即可實現，因此合併階段（將兩個短有序鏈結串列合併為一個長有序鏈結串列）無須建立額外鏈結串列。</li> </ul> <p>具體實現細節比較複雜，有興趣的讀者可以查閱相關資料進行學習。</p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   快速排序","text":"<p>快速排序（quick sort）是一種基於分治策略的排序演算法，執行高效，應用廣泛。</p> <p>快速排序的核心操作是“哨兵劃分”，其目標是：選擇陣列中的某個元素作為“基準數”，將所有小於基準數的元素移到其左側，而大於基準數的元素移到其右側。具體來說，哨兵劃分的流程如圖 11-8 所示。</p> <ol> <li>選取陣列最左端元素作為基準數，初始化兩個指標 <code>i</code> 和 <code>j</code> 分別指向陣列的兩端。</li> <li>設定一個迴圈，在每輪中使用 <code>i</code>（<code>j</code>）分別尋找第一個比基準數大（小）的元素，然後交換這兩個元素。</li> <li>迴圈執行步驟 <code>2.</code> ，直到 <code>i</code> 和 <code>j</code> 相遇時停止，最後將基準數交換至兩個子陣列的分界線。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-8   哨兵劃分步驟 </p> <p>哨兵劃分完成後，原陣列被劃分成三部分：左子陣列、基準數、右子陣列，且滿足“左子陣列任意元素 \\(\\leq\\) 基準數 \\(\\leq\\) 右子陣列任意元素”。因此，我們接下來只需對這兩個子陣列進行排序。</p> <p>快速排序的分治策略</p> <p>哨兵劃分的實質是將一個較長陣列的排序問題簡化為兩個較短陣列的排序問題。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"哨兵劃分\"\"\"\n    # 以 nums[left] 為基準數\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 從右向左找首個小於基準數的元素\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 從左向右找首個大於基準數的元素\n        # 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 返回基準數的索引\n</code></pre> quick_sort.cpp<pre><code>/* 哨兵劃分 */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 從左向右找首個大於基準數的元素\n        swap(nums[i], nums[j]); // 交換這兩個元素\n    }\n    swap(nums[i], nums[left]);  // 將基準數交換至兩子陣列的分界線\n    return i;                   // 返回基準數的索引\n}\n</code></pre> quick_sort.java<pre><code>/* 元素交換 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint partition(int[] nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.cs<pre><code>/* 元素交換 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* 哨兵劃分 */\nint Partition(int[] nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        Swap(nums, i, j); // 交換這兩個元素\n    }\n    Swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.go<pre><code>/* 哨兵劃分 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // 以 nums[left] 為基準數\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 從右向左找首個小於基準數的元素\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 返回基準數的索引\n}\n</code></pre> quick_sort.swift<pre><code>/* 哨兵劃分 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // 從左向右找首個大於基準數的元素\n        }\n        nums.swapAt(i, j) // 交換這兩個元素\n    }\n    nums.swapAt(i, left) // 將基準數交換至兩子陣列的分界線\n    return i // 返回基準數的索引\n}\n</code></pre> quick_sort.js<pre><code>/* 元素交換 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\npartition(nums, left, right) {\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.ts<pre><code>/* 元素交換 */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\npartition(nums: number[], left: number, right: number): number {\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.dart<pre><code>/* 元素交換 */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 以 nums[left] 為基準數\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n    _swap(nums, i, j); // 交換這兩個元素\n  }\n  _swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n  return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.rs<pre><code>/* 哨兵劃分 */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 以 nums[left] 為基準數\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        nums.swap(i, j); // 交換這兩個元素\n    }\n    nums.swap(i, left); // 將基準數交換至兩子陣列的分界線\n    i // 返回基準數的索引\n}\n</code></pre> quick_sort.c<pre><code>/* 元素交換 */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint partition(int nums[], int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 從左向右找首個大於基準數的元素\n        }\n        // 交換這兩個元素\n        swap(nums, i, j);\n    }\n    // 將基準數交換至兩子陣列的分界線\n    swap(nums, i, left);\n    // 返回基準數的索引\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* 元素交換 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* 哨兵劃分 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // 從左向右找首個大於基準數的元素\n        swap(nums, i, j)  // 交換這兩個元素\n    }\n    swap(nums, i, left)   // 將基準數交換至兩子陣列的分界線\n    return i              // 返回基準數的索引\n}\n</code></pre> quick_sort.rb<pre><code>### 哨兵劃分 ###\ndef partition(nums, left, right)\n  # 以 nums[left] 為基準數\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 從右向左找首個小於基準數的元素\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 從左向右找首個大於基準數的元素\n    end\n    # 元素交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 將基準數交換至兩子陣列的分界線\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 返回基準數的索引\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   演算法流程","text":"<p>快速排序的整體流程如圖 11-9 所示。</p> <ol> <li>首先，對原陣列執行一次“哨兵劃分”，得到未排序的左子陣列和右子陣列。</li> <li>然後，對左子陣列和右子陣列分別遞迴執行“哨兵劃分”。</li> <li>持續遞迴，直至子陣列長度為 1 時終止，從而完成整個陣列的排序。</li> </ol> <p></p> <p> 圖 11-9   快速排序流程 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"快速排序\"\"\"\n    # 子陣列長度為 1 時終止遞迴\n    if left &gt;= right:\n        return\n    # 哨兵劃分\n    pivot = self.partition(nums, left, right)\n    # 遞迴左子陣列、右子陣列\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* 快速排序 */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* 快速排序 */\nvoid quickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* 快速排序 */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = Partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* 快速排序 */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return\n    }\n    // 哨兵劃分\n    pivot := q.partition(nums, left, right)\n    // 遞迴左子陣列、右子陣列\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* 快速排序 */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return\n    }\n    // 哨兵劃分\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 快速排序 */\nquickSort(nums, left, right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) return;\n    // 哨兵劃分\n    const pivot = this.partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* 快速排序 */\nquickSort(nums: number[], left: number, right: number): void {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) {\n        return;\n    }\n    // 哨兵劃分\n    const pivot = this.partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* 快速排序 */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 子陣列長度為 1 時終止遞迴\n  if (left &gt;= right) return;\n  // 哨兵劃分\n  int pivot = _partition(nums, left, right);\n  // 遞迴左子陣列、右子陣列\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* 快速排序 */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return;\n    }\n    // 哨兵劃分\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // 遞迴左子陣列、右子陣列\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* 快速排序 */\nvoid quickSort(int nums[], int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) {\n        return;\n    }\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* 快速排序 */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) return\n    // 哨兵劃分\n    val pivot = partition(nums, left, right)\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### 快速排序類別 ###\ndef quick_sort(nums, left, right)\n  # 子陣列長度不為 1 時遞迴\n  if left &lt; right\n    # 哨兵劃分\n    pivot = partition(nums, left, right)\n    # 遞迴左子陣列、右子陣列\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：在平均情況下，哨兵劃分的遞迴層數為 \\(\\log n\\) ，每層中的總迴圈數為 \\(n\\) ，總體使用 \\(O(n \\log n)\\) 時間。在最差情況下，每輪哨兵劃分操作都將長度為 \\(n\\) 的陣列劃分為長度為 \\(0\\) 和 \\(n - 1\\) 的兩個子陣列，此時遞迴層數達到 \\(n\\) ，每層中的迴圈數為 \\(n\\) ，總體使用 \\(O(n^2)\\) 時間。</li> <li>空間複雜度為 \\(O(n)\\)、原地排序：在輸入陣列完全倒序的情況下，達到最差遞迴深度 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。排序操作是在原陣列上進行的，未藉助額外陣列。</li> <li>非穩定排序：在哨兵劃分的最後一步，基準數可能會被交換至相等元素的右側。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   快速排序為什麼快","text":"<p>從名稱上就能看出，快速排序在效率方面應該具有一定的優勢。儘管快速排序的平均時間複雜度與“合併排序”和“堆積排序”相同，但通常快速排序的效率更高，主要有以下原因。</p> <ul> <li>出現最差情況的機率很低：雖然快速排序的最差時間複雜度為 \\(O(n^2)\\) ，沒有合併排序穩定，但在絕大多數情況下，快速排序能在 \\(O(n \\log n)\\) 的時間複雜度下執行。</li> <li>快取使用效率高：在執行哨兵劃分操作時，系統可將整個子陣列載入到快取，因此訪問元素的效率較高。而像“堆積排序”這類演算法需要跳躍式訪問元素，從而缺乏這一特性。</li> <li>複雜度的常數係數小：在上述三種演算法中，快速排序的比較、賦值、交換等操作的總數量最少。這與“插入排序”比“泡沫排序”更快的原因類似。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   基準數最佳化","text":"<p>快速排序在某些輸入下的時間效率可能降低。舉一個極端例子，假設輸入陣列是完全倒序的，由於我們選擇最左端元素作為基準數，那麼在哨兵劃分完成後，基準數被交換至陣列最右端，導致左子陣列長度為 \\(n - 1\\)、右子陣列長度為 \\(0\\) 。如此遞迴下去，每輪哨兵劃分後都有一個子陣列的長度為 \\(0\\) ，分治策略失效，快速排序退化為“泡沫排序”的近似形式。</p> <p>為了儘量避免這種情況發生，我們可以最佳化哨兵劃分中的基準數的選取策略。例如，我們可以隨機選取一個元素作為基準數。然而，如果運氣不佳，每次都選到不理想的基準數，效率仍然不盡如人意。</p> <p>需要注意的是，程式語言通常生成的是“偽隨機數”。如果我們針對偽隨機數序列構建一個特定的測試樣例，那麼快速排序的效率仍然可能劣化。</p> <p>為了進一步改進，我們可以在陣列中選取三個候選元素（通常為陣列的首、尾、中點元素），並將這三個候選元素的中位數作為基準數。這樣一來，基準數“既不太小也不太大”的機率將大幅提升。當然，我們還可以選取更多候選元素，以進一步提高演算法的穩健性。採用這種方法後，時間複雜度劣化至 \\(O(n^2)\\) 的機率大大降低。</p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"選取三個候選元素的中位數\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m 在 l 和 r 之間\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l 在 m 和 r 之間\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"哨兵劃分（三數取中值）\"\"\"\n    # 以 nums[left] 為基準數\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # 將中位數交換至陣列最左端\n    nums[left], nums[med] = nums[med], nums[left]\n    # 以 nums[left] 為基準數\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 從右向左找首個小於基準數的元素\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 從左向右找首個大於基準數的元素\n        # 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 返回基準數的索引\n</code></pre> quick_sort.cpp<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums[left], nums[med]);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 從左向右找首個大於基準數的元素\n        swap(nums[i], nums[j]); // 交換這兩個元素\n    }\n    swap(nums[i], nums[left]);  // 將基準數交換至兩子陣列的分界線\n    return i;                   // 返回基準數的索引\n}\n</code></pre> quick_sort.java<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partition(int[] nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.cs<pre><code>/* 選取三個候選元素的中位數 */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint Partition(int[] nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    Swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        Swap(nums, i, j); // 交換這兩個元素\n    }\n    Swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.go<pre><code>/* 選取三個候選元素的中位數 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l 在 m 和 r 之間\n    }\n    return right\n}\n\n/* 哨兵劃分（三數取中值）*/\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // 以 nums[left] 為基準數\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // 將中位數交換至陣列最左端\n    nums[left], nums[med] = nums[med], nums[left]\n    // 以 nums[left] 為基準數\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- //從右向左找首個小於基準數的元素\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ //從左向右找首個大於基準數的元素\n        }\n        //元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    //將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i //返回基準數的索引\n}\n</code></pre> quick_sort.swift<pre><code>/* 選取三個候選元素的中位數 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l 在 m 和 r 之間\n    }\n    return right\n}\n\n/* 哨兵劃分（三數取中值） */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 選取三個候選元素的中位數\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // 將中位數交換至陣列最左端\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 選取三個候選元素的中位數 */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m 在 l 和 r 之間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l 在 m 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\npartition(nums, left, right) {\n    // 選取三個候選元素的中位數\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 將中位數交換至陣列最左端\n    this.swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.ts<pre><code>/* 選取三個候選元素的中位數 */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m 在 l 和 r 之間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l 在 m 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\npartition(nums: number[], left: number, right: number): number {\n    // 選取三個候選元素的中位數\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 將中位數交換至陣列最左端\n    this.swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 從左向右找首個大於基準數的元素\n        }\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.dart<pre><code>/* 選取三個候選元素的中位數 */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m 在 l 和 r 之間\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l 在 m 和 r 之間\n  return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 選取三個候選元素的中位數\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // 將中位數交換至陣列最左端\n  _swap(nums, left, med);\n  // 以 nums[left] 為基準數\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n    _swap(nums, i, j); // 交換這兩個元素\n  }\n  _swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n  return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.rs<pre><code>/* 選取三個候選元素的中位數 */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l 在 m 和 r 之間\n    }\n    right\n}\n\n/* 哨兵劃分（三數取中值） */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 選取三個候選元素的中位數\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    nums.swap(left, med);\n    // 以 nums[left] 為基準數\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        nums.swap(i, j); // 交換這兩個元素\n    }\n    nums.swap(i, left); // 將基準數交換至兩子陣列的分界線\n    i // 返回基準數的索引\n}\n</code></pre> quick_sort.c<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partitionMedian(int nums[], int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i;            // 返回基準數的索引\n}\n</code></pre> quick_sort.kt<pre><code>/* 選取三個候選元素的中位數 */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m 在 l 和 r 之間\n    if ((l in m..r) || (l in r..m))\n        return left // l 在 m 和 r 之間\n    return right\n}\n\n/* 哨兵劃分（三數取中值） */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // 選取三個候選元素的中位數\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med)\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // 從左向右找首個大於基準數的元素\n        swap(nums, i, j)             // 交換這兩個元素\n    }\n    swap(nums, i, left)              // 將基準數交換至兩子陣列的分界線\n    return i                         // 返回基準數的索引\n}\n</code></pre> quick_sort.rb<pre><code>### 選取三個候選元素的中位數 ###\ndef median_three(nums, left, mid, right)\n  # 選取三個候選元素的中位數\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m 在 l 和 r 之間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l 在 m 和 r 之間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### 哨兵劃分（三數取中值）###\ndef partition(nums, left, right)\n  ### 以 nums[left] 為基準數\n  med = median_three(nums, left, (left + right) / 2, right)\n  # 將中位數交換至陣列最左斷\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 從右向左找首個小於基準數的元素\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 從左向右找首個大於基準數的元素\n    end\n    # 元素交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 將基準數交換至兩子陣列的分界線\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 返回基準數的索引\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   遞迴深度最佳化","text":"<p>在某些輸入下，快速排序可能佔用空間較多。以完全有序的輸入陣列為例，設遞迴中的子陣列長度為 \\(m\\) ，每輪哨兵劃分操作都將產生長度為 \\(0\\) 的左子陣列和長度為 \\(m - 1\\) 的右子陣列，這意味著每一層遞迴呼叫減少的問題規模非常小（只減少一個元素），遞迴樹的高度會達到 \\(n - 1\\) ，此時需要佔用 \\(O(n)\\) 大小的堆疊幀空間。</p> <p>為了防止堆疊幀空間的累積，我們可以在每輪哨兵排序完成後，比較兩個子陣列的長度，僅對較短的子陣列進行遞迴。由於較短子陣列的長度不會超過 \\(n / 2\\) ，因此這種方法能確保遞迴深度不超過 \\(\\log n\\) ，從而將最差空間複雜度最佳化至 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"快速排序（遞迴深度最佳化）\"\"\"\n    # 子陣列長度為 1 時終止\n    while left &lt; right:\n        # 哨兵劃分操作\n        pivot = self.partition(nums, left, right)\n        # 對兩個子陣列中較短的那個執行快速排序\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # 遞迴排序左子陣列\n            left = pivot + 1  # 剩餘未排序區間為 [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # 遞迴排序右子陣列\n            right = pivot - 1  # 剩餘未排序區間為 [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1;                 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1;                 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = Partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // 遞迴排序左子陣列\n            left = pivot + 1;  // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* 快速排序（遞迴深度最佳化）*/\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // 子陣列長度為 1 時終止\n    for left &lt; right {\n        // 哨兵劃分操作\n        pivot := q.partition(nums, left, right)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // 遞迴排序左子陣列\n            left = pivot + 1                 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // 遞迴排序右子陣列\n            right = pivot - 1                 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* 快速排序（遞迴深度最佳化） */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // 子陣列長度為 1 時終止\n    while left &lt; right {\n        // 哨兵劃分操作\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // 遞迴排序左子陣列\n            left = pivot + 1 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // 遞迴排序右子陣列\n            right = pivot - 1 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* 快速排序（遞迴深度最佳化） */\nquickSort(nums, left, right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        let pivot = this.partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* 快速排序（遞迴深度最佳化） */\nquickSort(nums: number[], left: number, right: number): void {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        let pivot = this.partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 子陣列長度為 1 時終止\n  while (left &lt; right) {\n    // 哨兵劃分操作\n    int pivot = _partition(nums, left, right);\n    // 對兩個子陣列中較短的那個執行快速排序\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n      left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n      right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* 快速排序（遞迴深度最佳化） */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // 子陣列長度為 1 時終止\n    while left &lt; right {\n        // 哨兵劃分操作\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // 對兩個子陣列中較短的那個執行快速排序\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            // 遞迴排序左子陣列\n            quickSortTailCall(nums, left, pivot - 1);\n            // 剩餘未排序區間為 [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // 遞迴排序右子陣列\n            quickSortTailCall(nums, pivot + 1, right);\n            // 剩餘未排序區間為 [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* 快速排序（遞迴深度最佳化） */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // 子陣列長度為 1 時終止\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // 哨兵劃分操作\n        val pivot = partition(nums, l, r)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // 遞迴排序左子陣列\n            l = pivot + 1 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // 遞迴排序右子陣列\n            r = pivot - 1 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### 快速排序（遞迴深度最佳化）###\ndef quick_sort(nums, left, right)\n  # 子陣列長度不為 1 時遞迴\n  while left &lt; right\n    # 哨兵劃分\n    pivot = partition(nums, left, right)\n    # 對兩個子陣列中較短的那個執行快速排序\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # 剩餘未排序區間為 [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # 剩餘未排序區間為 [left, pivot - 1]\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   基數排序","text":"<p>上一節介紹了計數排序，它適用於資料量 \\(n\\) 較大但資料範圍 \\(m\\) 較小的情況。假設我們需要對 \\(n = 10^6\\) 個學號進行排序，而學號是一個 \\(8\\) 位數字，這意味著資料範圍 \\(m = 10^8\\) 非常大，使用計數排序需要分配大量記憶體空間，而基數排序可以避免這種情況。</p> <p>基數排序（radix sort）的核心思想與計數排序一致，也透過統計個數來實現排序。在此基礎上，基數排序利用數字各位之間的遞進關係，依次對每一位進行排序，從而得到最終的排序結果。</p>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   演算法流程","text":"<p>以學號資料為例，假設數字的最低位是第 \\(1\\) 位，最高位是第 \\(8\\) 位，基數排序的流程如圖 11-18 所示。</p> <ol> <li>初始化位數 \\(k = 1\\) 。</li> <li>對學號的第 \\(k\\) 位執行“計數排序”。完成後，資料會根據第 \\(k\\) 位從小到大排序。</li> <li>將 \\(k\\) 增加 \\(1\\) ，然後返回步驟 <code>2.</code> 繼續迭代，直到所有位都排序完成後結束。</li> </ol> <p></p> <p> 圖 11-18   基數排序演算法流程 </p> <p>下面剖析程式碼實現。對於一個 \\(d\\) 進位制的數字 \\(x\\) ，要獲取其第 \\(k\\) 位 \\(x_k\\) ，可以使用以下計算公式：</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>其中 \\(\\lfloor a \\rfloor\\) 表示對浮點數 \\(a\\) 向下取整，而 \\(\\bmod \\: d\\) 表示對 \\(d\\) 取模（取餘）。對於學號資料，\\(d = 10\\) 且 \\(k \\in [1, 8]\\) 。</p> <p>此外，我們需要小幅改動計數排序程式碼，使之可以根據數字的第 \\(k\\) 位進行排序：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"獲取元素 num 的第 k 位，其中 exp = 10^(k-1)\"\"\"\n    # 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"計數排序（根據 nums 第 k 位排序）\"\"\"\n    # 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    counter = [0] * 10\n    n = len(nums)\n    # 統計 0~9 各數字的出現次數\n    for i in range(n):\n        d = digit(nums[i], exp)  # 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1  # 統計數字 d 的出現次數\n    # 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # 倒序走訪，根據桶內統計結果，將各元素填入 res\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]  # 將當前元素填入索引 j\n        counter[d] -= 1  # 將 d 的數量減 1\n    # 使用結果覆蓋原陣列 nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"基數排序\"\"\"\n    # 獲取陣列的最大元素，用於判斷最大位數\n    m = max(nums)\n    # 按照從低位到高位的順序走訪\n    exp = 1\n    while exp &lt;= m:\n        # 對陣列元素的第 k 位執行計數排序\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # 即 exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = *max_element(nums.begin(), nums.end());\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(int[] nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int[] counter = new int[10];\n    int n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(int[] nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nvoid RadixSort(int[] nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunc countingSortDigit(nums []int, exp int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    counter := make([]int, 10)\n    n := len(nums)\n    // 統計 0~9 各數字的出現次數\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++             // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]    // 將當前元素填入索引 j\n        counter[d]--        // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* 基數排序 */\nfunc radixSort(nums []int) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    var counter = Array(repeating: 0, count: 10)\n    // 統計 0~9 各數字的出現次數\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1 // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i] // 將當前元素填入索引 j\n        counter[d] -= 1 // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* 基數排序 */\nfunc radixSort(nums: inout [Int]) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunction countingSortDigit(nums, exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d]--; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nfunction radixSort(nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m = Math.max(... nums);\n    // 按照從低位到高位的順序走訪\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d]--; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nfunction radixSort(nums: number[]): void {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m: number = Math.max(... nums);\n    // 按照從低位到高位的順序走訪\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* 獲取元素 _num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n  return (_num ~/ exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // 統計 0~9 各數字的出現次數\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n    counter[d]++; // 統計數字 d 的出現次數\n  }\n  // 求前綴和，將“出現個數”轉換為“陣列索引”\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // 倒序走訪，根據桶內統計結果，將各元素填入 res\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n    res[j] = nums[i]; // 將當前元素填入索引 j\n    counter[d]--; // 將 d 的數量減 1\n  }\n  // 使用結果覆蓋原陣列 nums\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(List&lt;int&gt; nums) {\n  // 獲取陣列的最大元素，用於判斷最大位數\n  // dart 中 int 的長度是 64 位的\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // 按照從低位到高位的順序走訪\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // 對陣列元素的第 k 位執行計數排序\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // 即 exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return ((num / exp) % 10) as usize;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // 統計 0~9 各數字的出現次數\n    for i in 0..n {\n        let d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d] -= 1; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    nums.copy_from_slice(&amp;res);\n}\n\n/* 基數排序 */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m = *nums.into_iter().max().unwrap();\n    // 按照從低位到高位的順序走訪\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // 初始化為 0 以支持後續記憶體釋放\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; size; i++) {\n        // 獲取 nums[i] 第 k 位，記為 d\n        int d = digit(nums[i], exp);\n        // 統計數字 d 的出現次數\n        counter[d]++;\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // 釋放記憶體\n    free(res);\n    free(counter);\n}\n\n/* 基數排序 */\nvoid radixSort(int nums[], int size) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    val counter = IntArray(10)\n    val n = nums.size\n    // 統計 0~9 各數字的出現次數\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]       // 將當前元素填入索引 j\n        counter[d]--           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* 基數排序 */\nfun radixSort(nums: IntArray) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // 按照從低位到高位的順序走訪\n    while (exp &lt;= m) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) ###\ndef digit(num, exp)\n  # 轉入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n  (num / exp) % 10\nend\n\n### 計數排序（根據 nums 第 k 位排序）###\ndef counting_sort_digit(nums, exp)\n  # 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n  counter = Array.new(10, 0)\n  n = nums.length\n  # 統計 0~9 各數字的出現次數\n  for i in 0...n\n    d = digit(nums[i], exp) # 獲取 nums[i] 第 k 位，記為 d\n    counter[d] += 1 # 統計數字 d 的出現次數\n  end\n  # 求前綴和，將“出現個數”轉換為“陣列索引”\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # 倒序走訪，根據桶內統計結果，將各元素填入 res\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # 獲取 d 在陣列中的索引 j\n    res[j] = nums[i] # 將當前元素填入索引 j\n    counter[d] -= 1 # 將 d 的數量減 1\n  end\n  # 使用結果覆蓋原陣列 nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### 基數排序 ###\ndef radix_sort(nums)\n  # 獲取陣列的最大元素，用於判斷最大位數\n  m = nums.max\n  # 按照從低位到高位的順序走訪\n  exp = 1\n  while exp &lt;= m\n    # 對陣列元素的第 k 位執行計數排序\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # 即 exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>為什麼從最低位開始排序？</p> <p>在連續的排序輪次中，後一輪排序會覆蓋前一輪排序的結果。舉例來說，如果第一輪排序結果 \\(a &lt; b\\) ，而第二輪排序結果 \\(a &gt; b\\) ，那麼第二輪的結果將取代第一輪的結果。由於數字的高位優先順序高於低位，因此應該先排序低位再排序高位。</p>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   演算法特性","text":"<p>相較於計數排序，基數排序適用於數值範圍較大的情況，但前提是資料必須可以表示為固定位數的格式，且位數不能過大。例如，浮點數不適合使用基數排序，因為其位數 \\(k\\) 過大，可能導致時間複雜度 \\(O(nk) \\gg O(n^2)\\) 。</p> <ul> <li>時間複雜度為 \\(O(nk)\\)、非自適應排序：設資料量為 \\(n\\)、資料為 \\(d\\) 進位制、最大位數為 \\(k\\) ，則對某一位執行計數排序使用 \\(O(n + d)\\) 時間，排序所有 \\(k\\) 位使用 \\(O((n + d)k)\\) 時間。通常情況下，\\(d\\) 和 \\(k\\) 都相對較小，時間複雜度趨向 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(n + d)\\)、非原地排序：與計數排序相同，基數排序需要藉助長度為 \\(n\\) 和 \\(d\\) 的陣列 <code>res</code> 和 <code>counter</code> 。</li> <li>穩定排序：當計數排序穩定時，基數排序也穩定；當計數排序不穩定時，基數排序無法保證得到正確的排序結果。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   選擇排序","text":"<p>選擇排序（selection sort）的工作原理非常簡單：開啟一個迴圈，每輪從未排序區間選擇最小的元素，將其放到已排序區間的末尾。</p> <p>設陣列的長度為 \\(n\\) ，選擇排序的演算法流程如圖 11-2 所示。</p> <ol> <li>初始狀態下，所有元素未排序，即未排序（索引）區間為 \\([0, n-1]\\) 。</li> <li>選取區間 \\([0, n-1]\\) 中的最小元素，將其與索引 \\(0\\) 處的元素交換。完成後，陣列前 1 個元素已排序。</li> <li>選取區間 \\([1, n-1]\\) 中的最小元素，將其與索引 \\(1\\) 處的元素交換。完成後，陣列前 2 個元素已排序。</li> <li>以此類推。經過 \\(n - 1\\) 輪選擇與交換後，陣列前 \\(n - 1\\) 個元素已排序。</li> <li>僅剩的一個元素必定是最大元素，無須排序，因此陣列排序完成。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-2   選擇排序步驟 </p> <p>在程式碼中，我們用 \\(k\\) 來記錄未排序區間內的最小元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"選擇排序\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [i, n-1]\n    for i in range(n - 1):\n        # 內迴圈：找到未排序區間內的最小元素\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # 記錄最小元素的索引\n        # 將該最小元素與未排序區間的首個元素交換\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* 選擇排序 */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* 選擇排序 */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* 選擇排序 */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* 選擇排序 */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // 內迴圈：找到未排序區間內的最小元素\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // 記錄最小元素的索引\n                k = j\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* 選擇排序 */\nfunc selectionSort(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i in nums.indices.dropLast() {\n        // 內迴圈：找到未排序區間內的最小元素\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* 選擇排序 */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* 選擇排序 */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* 選擇排序 */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // 外迴圈：未排序區間為 [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // 內迴圈：找到未排序區間內的最小元素\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // 記錄最小元素的索引\n    }\n    // 將該最小元素與未排序區間的首個元素交換\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* 選擇排序 */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i in 0..n - 1 {\n        // 內迴圈：找到未排序區間內的最小元素\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* 選擇排序 */\nvoid selectionSort(int nums[], int n) {\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* 選擇排序 */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // 內迴圈：找到未排序區間內的最小元素\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### 選擇排序 ###\ndef selection_sort(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [i, n-1]\n  for i in 0...(n - 1)\n    # 內迴圈：找到未排序區間內的最小元素\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # 記錄最小元素的索引\n      end\n    end\n    # 將該最小元素與未排序區間的首個元素交換\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.2 &nbsp; 選擇排序"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、非自適應排序：外迴圈共 \\(n - 1\\) 輪，第一輪的未排序區間長度為 \\(n\\) ，最後一輪的未排序區間長度為 \\(2\\) ，即各輪外迴圈分別包含 \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(3\\)、\\(2\\) 輪內迴圈，求和為 \\(\\frac{(n - 1)(n + 2)}{2}\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>非穩定排序：如圖 11-3 所示，元素 <code>nums[i]</code> 有可能被交換至與其相等的元素的右邊，導致兩者的相對順序發生改變。</li> </ul> <p> 圖 11-3   選擇排序非穩定示例 </p>","path":["第 11 章 &nbsp; 排序","11.2 &nbsp; 選擇排序"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   排序演算法","text":"<p>排序演算法（sorting algorithm）用於對一組資料按照特定順序進行排列。排序演算法有著廣泛的應用，因為有序資料通常能夠被更高效地查詢、分析和處理。</p> <p>如圖 11-1 所示，排序演算法中的資料型別可以是整數、浮點數、字元或字串等。排序的判斷規則可根據需求設定，如數字大小、字元 ASCII 碼順序或自定義規則。</p> <p></p> <p> 圖 11-1   資料型別和判斷規則示例 </p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   評價維度","text":"<p>執行效率：我們期望排序演算法的時間複雜度儘量低，且總體操作數量較少（時間複雜度中的常數項變小）。對於大資料量的情況，執行效率顯得尤為重要。</p> <p>就地性：顧名思義，原地排序透過在原陣列上直接操作實現排序，無須藉助額外的輔助陣列，從而節省記憶體。通常情況下，原地排序的資料搬運操作較少，執行速度也更快。</p> <p>穩定性：穩定排序在完成排序後，相等元素在陣列中的相對順序不發生改變。</p> <p>穩定排序是多級排序場景的必要條件。假設我們有一個儲存學生資訊的表格，第 1 列和第 2 列分別是姓名和年齡。在這種情況下，非穩定排序可能導致輸入資料的有序性喪失：</p> <pre><code># 輸入資料是按照姓名排序好的\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# 假設使用非穩定排序演算法按年齡排序串列，\n# 結果中 ('D', 19) 和 ('A', 19) 的相對位置改變，\n# 輸入資料按姓名排序的性質丟失\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>自適應性：自適應排序能夠利用輸入資料已有的順序資訊來減少計算量，達到更優的時間效率。自適應排序演算法的最佳時間複雜度通常優於平均時間複雜度。</p> <p>是否基於比較：基於比較的排序依賴比較運算子（\\(&lt;\\)、\\(=\\)、\\(&gt;\\)）來判斷元素的相對順序，從而排序整個陣列，理論最優時間複雜度為 \\(O(n \\log n)\\) 。而非比較排序不使用比較運算子，時間複雜度可達 \\(O(n)\\) ，但其通用性相對較差。</p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   理想排序演算法","text":"<p>執行快、原地、穩定、自適應、通用性好。顯然，迄今為止尚未發現兼具以上所有特性的排序演算法。因此，在選擇排序演算法時，需要根據具體的資料特點和問題需求來決定。</p> <p>接下來，我們將共同學習各種排序演算法，並基於上述評價維度對各個排序演算法的優缺點進行分析。</p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   小結","text":"","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>泡沫排序透過交換相鄰元素來實現排序。透過新增一個標誌位來實現提前返回，我們可以將泡沫排序的最佳時間複雜度最佳化到 \\(O(n)\\) 。</li> <li>插入排序每輪將未排序區間內的元素插入到已排序區間的正確位置，從而完成排序。雖然插入排序的時間複雜度為 \\(O(n^2)\\) ，但由於單元操作相對較少，因此在小資料量的排序任務中非常受歡迎。</li> <li>快速排序基於哨兵劃分操作實現排序。在哨兵劃分中，有可能每次都選取到最差的基準數，導致時間複雜度劣化至 \\(O(n^2)\\) 。引入中位數基準數或隨機基準數可以降低這種劣化的機率。透過優先遞迴較短子區間，可有效減小遞迴深度，將空間複雜度最佳化到 \\(O(\\log n)\\) 。</li> <li>合併排序包括劃分和合並兩個階段，典型地體現了分治策略。在合併排序中，排序陣列需要建立輔助陣列，空間複雜度為 \\(O(n)\\) ；然而排序鏈結串列的空間複雜度可以最佳化至 \\(O(1)\\) 。</li> <li>桶排序包含三個步驟：資料分桶、桶內排序和合並結果。它同樣體現了分治策略，適用於資料體量很大的情況。桶排序的關鍵在於對資料進行平均分配。</li> <li>計數排序是桶排序的一個特例，它透過統計資料出現的次數來實現排序。計數排序適用於資料量大但資料範圍有限的情況，並且要求資料能夠轉換為正整數。</li> <li>基數排序透過逐位排序來實現資料排序，要求資料能夠表示為固定位數的數字。</li> <li>總的來說，我們希望找到一種排序演算法，具有高效率、穩定、原地以及自適應性等優點。然而，正如其他資料結構和演算法一樣，沒有一種排序演算法能夠同時滿足所有這些條件。在實際應用中，我們需要根據資料的特性來選擇合適的排序演算法。</li> <li>圖 11-19 對比了主流排序演算法的效率、穩定性、就地性和自適應性等。</li> </ul> <p> 圖 11-19   排序演算法對比 </p>","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：排序演算法穩定性在什麼情況下是必需的？</p> <p>在現實中，我們有可能基於物件的某個屬性進行排序。例如，學生有姓名和身高兩個屬性，我們希望實現一個多級排序：先按照姓名進行排序，得到 <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> ；再對身高進行排序。由於排序演算法不穩定，因此可能得到 <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> 。</p> <p>可以發現，學生 D 和 C 的位置發生了交換，姓名的有序性被破壞了，而這是我們不希望看到的。</p> <p>Q：哨兵劃分中“從右往左查詢”與“從左往右查詢”的順序可以交換嗎？</p> <p>不行，當我們以最左端元素為基準數時，必須先“從右往左查詢”再“從左往右查詢”。這個結論有些反直覺，我們來剖析一下原因。</p> <p>哨兵劃分 <code>partition()</code> 的最後一步是交換 <code>nums[left]</code> 和 <code>nums[i]</code> 。完成交換後，基準數左邊的元素都 <code>&lt;=</code> 基準數，這就要求最後一步交換前 <code>nums[left] &gt;= nums[i]</code> 必須成立。假設我們先“從左往右查詢”，那麼如果找不到比基準數更大的元素，則會在 <code>i == j</code> 時跳出迴圈，此時可能 <code>nums[j] == nums[i] &gt; nums[left]</code>。也就是說，此時最後一步交換操作會把一個比基準數更大的元素交換至陣列最左端，導致哨兵劃分失敗。</p> <p>舉個例子，給定陣列 <code>[0, 0, 0, 0, 1]</code> ，如果先“從左向右查詢”，哨兵劃分後陣列為 <code>[1, 0, 0, 0, 0]</code> ，這個結果是不正確的。</p> <p>再深入思考一下，如果我們選擇 <code>nums[right]</code> 為基準數，那麼正好反過來，必須先“從左往右查詢”。</p> <p>Q：關於快速排序的遞迴深度最佳化，為什麼選短的陣列能保證遞迴深度不超過 \\(\\log n\\) ？</p> <p>遞迴深度就是當前未返回的遞迴方法的數量。每輪哨兵劃分我們將原陣列劃分為兩個子陣列。在遞迴深度最佳化後，向下遞迴的子陣列長度最大為原陣列長度的一半。假設最差情況，一直為一半長度，那麼最終的遞迴深度就是 \\(\\log n\\) 。</p> <p>回顧原始的快速排序，我們有可能會連續地遞迴長度較大的陣列，最差情況下為 \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，遞迴深度為 \\(n\\) 。遞迴深度最佳化可以避免這種情況出現。</p> <p>Q：當陣列中所有元素都相等時，快速排序的時間複雜度是 \\(O(n^2)\\) 嗎？該如何處理這種退化情況？</p> <p>是的。對於這種情況，可以考慮透過哨兵劃分將陣列劃分為三個部分：小於、等於、大於基準數。僅向下遞迴小於和大於的兩部分。在該方法下，輸入元素全部相等的陣列，僅一輪哨兵劃分即可完成排序。</p> <p>Q：桶排序的最差時間複雜度為什麼是 \\(O(n^2)\\) ？</p> <p>最差情況下，所有元素被分至同一個桶中。如果我們採用一個 \\(O(n^2)\\) 演算法來排序這些元素，則時間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"第 5 章   堆疊與佇列","text":"<p>Abstract</p> <p>堆疊如同疊貓貓，而佇列就像貓貓排隊。</p> <p>兩者分別代表先入後出和先入先出的邏輯關係。</p>","path":["第 5 章 &nbsp; 堆疊與佇列"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"本章內容","text":"<ul> <li>5.1   堆疊</li> <li>5.2   佇列</li> <li>5.3   雙向佇列</li> <li>5.4   小結</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   雙向佇列","text":"<p>在佇列中，我們僅能刪除頭部元素或在尾部新增元素。如圖 5-7 所示，雙向佇列（double-ended queue）提供了更高的靈活性，允許在頭部和尾部執行元素的新增或刪除操作。</p> <p></p> <p> 圖 5-7   雙向佇列的操作 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   雙向佇列常用操作","text":"<p>雙向佇列的常用操作如表 5-3 所示，具體的方法名稱需要根據所使用的程式語言來確定。</p> <p> 表 5-3   雙向佇列操作效率 </p> 方法名 描述 時間複雜度 <code>push_first()</code> 將元素新增至佇列首 \\(O(1)\\) <code>push_last()</code> 將元素新增至佇列尾 \\(O(1)\\) <code>pop_first()</code> 刪除佇列首元素 \\(O(1)\\) <code>pop_last()</code> 刪除佇列尾元素 \\(O(1)\\) <code>peek_first()</code> 訪問佇列首元素 \\(O(1)\\) <code>peek_last()</code> 訪問佇列尾元素 \\(O(1)\\) <p>同樣地，我們可以直接使用程式語言中已實現的雙向佇列類別：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# 初始化雙向佇列\ndeq: deque[int] = deque()\n\n# 元素入列\ndeq.append(2)      # 新增至佇列尾\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # 新增至佇列首\ndeq.appendleft(1)\n\n# 訪問元素\nfront: int = deq[0]  # 佇列首元素\nrear: int = deq[-1]  # 佇列尾元素\n\n# 元素出列\npop_front: int = deq.popleft()  # 佇列首元素出列\npop_rear: int = deq.pop()       # 佇列尾元素出列\n\n# 獲取雙向佇列的長度\nsize: int = len(deq)\n\n# 判斷雙向佇列是否為空\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* 初始化雙向佇列 */\ndeque&lt;int&gt; deque;\n\n/* 元素入列 */\ndeque.push_back(2);   // 新增至佇列尾\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // 新增至佇列首\ndeque.push_front(1);\n\n/* 訪問元素 */\nint front = deque.front(); // 佇列首元素\nint back = deque.back();   // 佇列尾元素\n\n/* 元素出列 */\ndeque.pop_front();  // 佇列首元素出列\ndeque.pop_back();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.size();\n\n/* 判斷雙向佇列是否為空 */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* 初始化雙向佇列 */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* 元素入列 */\ndeque.offerLast(2);   // 新增至佇列尾\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // 新增至佇列首\ndeque.offerFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.peekFirst();  // 佇列首元素\nint peekLast = deque.peekLast();    // 佇列尾元素\n\n/* 元素出列 */\nint popFirst = deque.pollFirst();  // 佇列首元素出列\nint popLast = deque.pollLast();    // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.size();\n\n/* 判斷雙向佇列是否為空 */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* 初始化雙向佇列 */\n// 在 C# 中，將鏈結串列 LinkedList 看作雙向佇列來使用\nLinkedList&lt;int&gt; deque = new();\n\n/* 元素入列 */\ndeque.AddLast(2);   // 新增至佇列尾\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // 新增至佇列首\ndeque.AddFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.First.Value;  // 佇列首元素\nint peekLast = deque.Last.Value;    // 佇列尾元素\n\n/* 元素出列 */\ndeque.RemoveFirst();  // 佇列首元素出列\ndeque.RemoveLast();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.Count;\n\n/* 判斷雙向佇列是否為空 */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* 初始化雙向佇列 */\n// 在 Go 中，將 list 作為雙向佇列使用\ndeque := list.New()\n\n/* 元素入列 */\ndeque.PushBack(2)      // 新增至佇列尾\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // 新增至佇列首\ndeque.PushFront(1)\n\n/* 訪問元素 */\nfront := deque.Front() // 佇列首元素\nrear := deque.Back()   // 佇列尾元素\n\n/* 元素出列 */\ndeque.Remove(front)    // 佇列首元素出列\ndeque.Remove(rear)     // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nsize := deque.Len()\n\n/* 判斷雙向佇列是否為空 */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* 初始化雙向佇列 */\n// Swift 沒有內建的雙向佇列類別，可以把 Array 當作雙向佇列來使用\nvar deque: [Int] = []\n\n/* 元素入列 */\ndeque.append(2) // 新增至佇列尾\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // 新增至佇列首\ndeque.insert(1, at: 0)\n\n/* 訪問元素 */\nlet peekFirst = deque.first! // 佇列首元素\nlet peekLast = deque.last! // 佇列尾元素\n\n/* 元素出列 */\n// 使用 Array 模擬時 popFirst 的複雜度為 O(n)\nlet popFirst = deque.removeFirst() // 佇列首元素出列\nlet popLast = deque.removeLast() // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nlet size = deque.count\n\n/* 判斷雙向佇列是否為空 */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* 初始化雙向佇列 */\n// JavaScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用\nconst deque = [];\n\n/* 元素入列 */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 訪問元素 */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* 元素出列 */\n// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* 獲取雙向佇列的長度 */\nconst size = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* 初始化雙向佇列 */\n// TypeScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用\nconst deque: number[] = [];\n\n/* 元素入列 */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 訪問元素 */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* 元素出列 */\n// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* 獲取雙向佇列的長度 */\nconst size: number = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* 初始化雙向佇列 */\n// 在 Dart 中，Queue 被定義為雙向佇列\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* 元素入列 */\ndeque.addLast(2);  // 新增至佇列尾\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // 新增至佇列首\ndeque.addFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.first; // 佇列首元素\nint peekLast = deque.last;   // 佇列尾元素\n\n/* 元素出列 */\nint popFirst = deque.removeFirst(); // 佇列首元素出列\nint popLast = deque.removeLast();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* 初始化雙向佇列 */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 元素入列 */\ndeque.push_back(2);  // 新增至佇列尾\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // 新增至佇列首\ndeque.push_front(1);\n\n/* 訪問元素 */\nif let Some(front) = deque.front() { // 佇列首元素\n}\nif let Some(rear) = deque.back() {   // 佇列尾元素\n}\n\n/* 元素出列 */\nif let Some(pop_front) = deque.pop_front() { // 佇列首元素出列\n}\nif let Some(pop_rear) = deque.pop_back() {   // 佇列尾元素出列\n}\n\n/* 獲取雙向佇列的長度 */\nlet size = deque.len();\n\n/* 判斷雙向佇列是否為空 */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C 未提供內建雙向佇列\n</code></pre> deque.kt<pre><code>/* 初始化雙向佇列 */\nval deque = LinkedList&lt;Int&gt;()\n\n/* 元素入列 */\ndeque.offerLast(2)  // 新增至佇列尾\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // 新增至佇列首\ndeque.offerFirst(1)\n\n/* 訪問元素 */\nval peekFirst = deque.peekFirst() // 佇列首元素\nval peekLast = deque.peekLast()   // 佇列尾元素\n\n/* 元素出列 */\nval popFirst = deque.pollFirst() // 佇列首元素出列\nval popLast = deque.pollLast()   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nval size = deque.size\n\n/* 判斷雙向佇列是否為空 */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># 初始化雙向佇列\n# Ruby 沒有內直的雙端佇列，只能把 Array 當作雙端佇列來使用\ndeque = []\n\n# 元素如隊\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# 請注意，由於是陣列，Array#unshift 方法的時間複雜度為 O(n)\ndeque.unshift(3)\ndeque.unshift(1)\n\n# 訪問元素\npeek_first = deque.first\npeek_last = deque.last\n\n# 元素出列\n# 請注意，由於是陣列， Array#shift 方法的時間複雜度為 O(n)\npop_front = deque.shift\npop_back = deque.pop\n\n# 獲取雙向佇列的長度\nsize = deque.length\n\n# 判斷雙向佇列是否為空\nis_empty = size.zero?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   雙向佇列實現 *","text":"<p>雙向佇列的實現與佇列類似，可以選擇鏈結串列或陣列作為底層資料結構。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   基於雙向鏈結串列的實現","text":"<p>回顧上一節內容，我們使用普通單向鏈結串列來實現佇列，因為它可以方便地刪除頭節點（對應出列操作）和在尾節點後新增新節點（對應入列操作）。</p> <p>對於雙向佇列而言，頭部和尾部都可以執行入列和出列操作。換句話說，雙向佇列需要實現另一個對稱方向的操作。為此，我們採用“雙向鏈結串列”作為雙向佇列的底層資料結構。</p> <p>如圖 5-8 所示，我們將雙向鏈結串列的頭節點和尾節點視為雙向佇列的佇列首和佇列尾，同時實現在兩端新增和刪除節點的功能。</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 5-8   基於鏈結串列實現雙向佇列的入列出列操作 </p> <p>實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"雙向鏈結串列節點\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"建構子\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # 後繼節點引用\n        self.prev: ListNode | None = None  # 前驅節點引用\n\nclass LinkedListDeque:\n    \"\"\"基於雙向鏈結串列實現的雙向佇列\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._front: ListNode | None = None  # 頭節點 front\n        self._rear: ListNode | None = None  # 尾節點 rear\n        self._size: int = 0  # 雙向佇列的長度\n\n    def size(self) -&gt; int:\n        \"\"\"獲取雙向佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷雙向佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"入列操作\"\"\"\n        node = ListNode(num)\n        # 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # 佇列首入列操作\n        elif is_front:\n            # 將 node 新增至鏈結串列頭部\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # 更新頭節點\n        # 佇列尾入列操作\n        else:\n            # 將 node 新增至鏈結串列尾部\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # 更新尾節點\n        self._size += 1  # 更新佇列長度\n\n    def push_first(self, num: int):\n        \"\"\"佇列首入列\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"佇列尾入列\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"出列操作\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        # 佇列首出列操作\n        if is_front:\n            val: int = self._front.val  # 暫存頭節點值\n            # 刪除頭節點\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # 更新頭節點\n        # 佇列尾出列操作\n        else:\n            val: int = self._rear.val  # 暫存尾節點值\n            # 刪除尾節點\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # 更新尾節點\n        self._size -= 1  # 更新佇列長度\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"佇列首出列\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"佇列尾出列\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"訪問佇列尾元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回陣列用於列印\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* 雙向鏈結串列節點 */\nstruct DoublyListNode {\n    int val;              // 節點值\n    DoublyListNode *next; // 後繼節點指標\n    DoublyListNode *prev; // 前驅節點指標\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize = 0;              // 雙向佇列的長度\n\n  public:\n    /* 建構子 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* 析構方法 */\n    ~LinkedListDeque() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* 獲取雙向佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列操作 */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty())\n            front = rear = node;\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // 更新頭節點\n        // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // 更新尾節點\n        }\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* 出列操作 */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"佇列為空\");\n        int val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front-&gt;val; // 暫存頭節點值\n            // 刪除頭節點\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // 更新頭節點\n        // 佇列尾出列操作\n        } else {\n            val = rear-&gt;val; // 暫存尾節點值\n            // 刪除尾節點\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // 更新尾節點\n        }\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* 佇列尾出列 */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return front-&gt;val;\n    }\n\n    /* 訪問佇列尾元素 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return rear-&gt;val;\n    }\n\n    /* 返回陣列用於列印 */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    int val; // 節點值\n    ListNode next; // 後繼節點引用\n    ListNode prev; // 前驅節點引用\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private ListNode front, rear; // 頭節點 front ，尾節點 rear\n    private int queSize = 0; // 雙向佇列的長度\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列操作 */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty())\n            front = rear = node;\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front.prev = node;\n            node.next = front;\n            front = node; // 更新頭節點\n        // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // 更新尾節點\n        }\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* 出列操作 */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front.val; // 暫存頭節點值\n            // 刪除頭節點\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // 更新頭節點\n        // 佇列尾出列操作\n        } else {\n            val = rear.val; // 暫存尾節點值\n            // 刪除尾節點\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // 更新尾節點\n        }\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* 佇列尾出列 */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 訪問佇列尾元素 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode(int val) {\n    public int val = val;       // 節點值\n    public ListNode? next = null; // 後繼節點引用\n    public ListNode? prev = null; // 前驅節點引用\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    ListNode? front, rear; // 頭節點 front, 尾節點 rear\n    int queSize = 0;      // 雙向佇列的長度\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入列操作 */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front!.prev = node;\n            node.next = front;\n            front = node; // 更新頭節點                           \n        }\n        // 佇列尾入列操作\n        else {\n            // 將 node 新增至鏈結串列尾部\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // 更新尾節點\n        }\n\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* 出列操作 */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front?.val; // 暫存頭節點值\n            // 刪除頭節點\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // 更新頭節點\n        }\n        // 佇列尾出列操作\n        else {\n            val = rear?.val;  // 暫存尾節點值\n            // 刪除尾節點\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // 更新尾節點\n        }\n\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* 佇列尾出列 */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* 訪問佇列尾元素 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* 返回陣列用於列印 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* 基於雙向鏈結串列實現的雙向佇列 */\ntype linkedListDeque struct {\n    // 使用內建包 list\n    data *list.List\n}\n\n/* 初始化雙端佇列 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* 佇列首元素入列 */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* 佇列尾元素入列 */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* 佇列首元素出列 */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 佇列尾元素出列 */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問佇列首元素 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* 訪問佇列尾元素 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* 獲取佇列的長度 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* 判斷佇列是否為空 */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 後繼節點引用\n    weak var prev: ListNode? // 前驅節點引用\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private var front: ListNode? // 頭節點 front\n    private var rear: ListNode? // 尾節點 rear\n    private var _size: Int // 雙向佇列的長度\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取雙向佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列操作 */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // 佇列首入列操作\n        else if isFront {\n            // 將 node 新增至鏈結串列頭部\n            front?.prev = node\n            node.next = front\n            front = node // 更新頭節點\n        }\n        // 佇列尾入列操作\n        else {\n            // 將 node 新增至鏈結串列尾部\n            rear?.next = node\n            node.prev = rear\n            rear = node // 更新尾節點\n        }\n        _size += 1 // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* 佇列尾入列 */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* 出列操作 */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        let val: Int\n        // 佇列首出列操作\n        if isFront {\n            val = front!.val // 暫存頭節點值\n            // 刪除頭節點\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // 更新頭節點\n        }\n        // 佇列尾出列操作\n        else {\n            val = rear!.val // 暫存尾節點值\n            // 刪除尾節點\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // 更新尾節點\n        }\n        _size -= 1 // 更新佇列長度\n        return val\n    }\n\n    /* 佇列首出列 */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* 佇列尾出列 */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* 訪問佇列首元素 */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return front!.val\n    }\n\n    /* 訪問佇列尾元素 */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return rear!.val\n    }\n\n    /* 返回陣列用於列印 */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    prev; // 前驅節點引用 (指標)\n    next; // 後繼節點引用 (指標)\n    val; // 節點值\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    #front; // 頭節點 front\n    #rear; // 尾節點 rear\n    #queSize; // 雙向佇列的長度\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* 佇列尾入列操作 */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // 更新尾節點\n        }\n        this.#queSize++;\n    }\n\n    /* 佇列首入列操作 */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // 將 node 新增至鏈結串列頭部\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // 更新頭節點\n        }\n        this.#queSize++;\n    }\n\n    /* 佇列尾出列操作 */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // 儲存尾節點值\n        // 刪除尾節點\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // 更新尾節點\n        this.#queSize--;\n        return value;\n    }\n\n    /* 佇列首出列操作 */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // 儲存尾節點值\n        // 刪除頭節點\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // 更新頭節點\n        this.#queSize--;\n        return value;\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 列印雙向佇列 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    prev: ListNode; // 前驅節點引用 (指標)\n    next: ListNode; // 後繼節點引用 (指標)\n    val: number; // 節點值\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private front: ListNode; // 頭節點 front\n    private rear: ListNode; // 尾節點 rear\n    private queSize: number; // 雙向佇列的長度\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* 佇列尾入列操作 */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // 更新尾節點\n        }\n        this.queSize++;\n    }\n\n    /* 佇列首入列操作 */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // 將 node 新增至鏈結串列頭部\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // 更新頭節點\n        }\n        this.queSize++;\n    }\n\n    /* 佇列尾出列操作 */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // 儲存尾節點值\n        // 刪除尾節點\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // 更新尾節點\n        this.queSize--;\n        return value;\n    }\n\n    /* 佇列首出列操作 */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // 儲存尾節點值\n        // 刪除頭節點\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // 更新頭節點\n        this.queSize--;\n        return value;\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 列印雙向佇列 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n  int val; // 節點值\n  ListNode? next; // 後繼節點引用\n  ListNode? prev; // 前驅節點引用\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* 基於雙向鏈結串列實現的雙向對列 */\nclass LinkedListDeque {\n  late ListNode? _front; // 頭節點 _front\n  late ListNode? _rear; // 尾節點 _rear\n  int _queSize = 0; // 雙向佇列的長度\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* 獲取雙向佇列長度 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* 判斷雙向佇列是否為空 */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* 入列操作 */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // 若鏈結串列為空，則令 _front 和 _rear 都指向 node\n      _front = _rear = node;\n    } else if (isFront) {\n      // 佇列首入列操作\n      // 將 node 新增至鏈結串列頭部\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // 更新頭節點\n    } else {\n      // 佇列尾入列操作\n      // 將 node 新增至鏈結串列尾部\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // 更新尾節點\n    }\n    _queSize++; // 更新佇列長度\n  }\n\n  /* 佇列首入列 */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* 佇列尾入列 */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* 出列操作 */\n  int? pop(bool isFront) {\n    // 若佇列為空，直接返回 null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // 佇列首出列操作\n      val = _front!.val; // 暫存頭節點值\n      // 刪除頭節點\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // 更新頭節點\n    } else {\n      // 佇列尾出列操作\n      val = _rear!.val; // 暫存尾節點值\n      // 刪除尾節點\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // 更新尾節點\n    }\n    _queSize--; // 更新佇列長度\n    return val;\n  }\n\n  /* 佇列首出列 */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* 佇列尾出列 */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* 訪問佇列首元素 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* 訪問佇列尾元素 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* 返回陣列用於列印 */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* 雙向鏈結串列節點 */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // 節點值\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 後繼節點指標\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 前驅節點指標\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 頭節點 front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 尾節點 rear\n    que_size: usize,                         // 雙向佇列的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取雙向佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* 入列操作 */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // 佇列首入列操作\n        if is_front {\n            match self.front.take() {\n                // 若鏈結串列為空，則令 front 和 rear 都指向 node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // 將 node 新增至鏈結串列頭部\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // 更新頭節點\n                }\n            }\n        }\n        // 佇列尾入列操作\n        else {\n            match self.rear.take() {\n                // 若鏈結串列為空，則令 front 和 rear 都指向 node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // 將 node 新增至鏈結串列尾部\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // 更新尾節點\n                }\n            }\n        }\n        self.que_size += 1; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* 出列操作 */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // 若佇列為空，直接返回 None\n        if self.is_empty() {\n            return None;\n        };\n        // 佇列首出列操作\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // 更新頭節點\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // 更新佇列長度\n                old_front.borrow().val\n            })\n        }\n        // 佇列尾出列操作\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // 更新尾節點\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // 更新佇列長度\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* 佇列首出列 */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* 佇列尾出列 */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 訪問佇列尾元素 */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* 返回陣列用於列印 */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* 雙向鏈結串列節點 */\ntypedef struct DoublyListNode {\n    int val;                     // 節點值\n    struct DoublyListNode *next; // 後繼節點\n    struct DoublyListNode *prev; // 前驅節點\n} DoublyListNode;\n\n/* 建構子 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* 析構函式 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\ntypedef struct {\n    DoublyListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize;                  // 雙向佇列的長度\n} LinkedListDeque;\n\n/* 建構子 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* 析構函式 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // 釋放所有節點\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // 釋放 deque 結構體\n    free(deque);\n}\n\n/* 獲取佇列的長度 */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* 入列 */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // 若鏈結串列為空，則令 front 和 rear 都指向node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // 佇列首入列操作\n    else if (isFront) {\n        // 將 node 新增至鏈結串列頭部\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // 更新頭節點\n    }\n    // 佇列尾入列操作\n    else {\n        // 將 node 新增至鏈結串列尾部\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // 更新佇列長度\n}\n\n/* 佇列首入列 */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* 佇列尾入列 */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* 訪問佇列首元素 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* 訪問佇列尾元素 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* 出列 */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // 佇列首出列操作\n    if (isFront) {\n        val = peekFirst(deque); // 暫存頭節點值\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // 更新頭節點\n    }\n    // 佇列尾出列操作\n    else {\n        val = peekLast(deque); // 暫存尾節點值\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // 更新尾節點\n    }\n    deque-&gt;queSize--; // 更新佇列長度\n    return val;\n}\n\n/* 佇列首出列 */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* 佇列尾出列 */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* 列印佇列 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // 複製鏈結串列中的資料到陣列\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode(var _val: Int) {\n    // 節點值\n    var next: ListNode? = null // 後繼節點引用\n    var prev: ListNode? = null // 前驅節點引用\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // 頭節點 front\n    private var rear: ListNode? = null // 尾節點 rear\n    private var queSize: Int = 0 // 雙向佇列的長度\n\n    /* 獲取雙向佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入列操作 */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // 佇列首入列操作\n        } else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front?.prev = node\n            node.next = front\n            front = node // 更新頭節點\n            // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear?.next = node\n            node.prev = rear\n            rear = node // 更新尾節點\n        }\n        queSize++ // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* 佇列尾入列 */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* 出列操作 */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // 佇列首出列操作\n        if (isFront) {\n            _val = front!!._val // 暫存頭節點值\n            // 刪除頭節點\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // 更新頭節點\n            // 佇列尾出列操作\n        } else {\n            _val = rear!!._val // 暫存尾節點值\n            // 刪除尾節點\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // 更新尾節點\n        }\n        queSize-- // 更新佇列長度\n        return _val\n    }\n\n    /* 佇列首出列 */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* 佇列尾出列 */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* 訪問佇列首元素 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 訪問佇列尾元素 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* 返回陣列用於列印 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n### 雙向鏈結串列節點\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # 後繼節點引用\n  attr_accessor :prev # 前軀節點引用\n\n  ### 建構子 ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### 基於雙向鏈結串列實現的雙向佇列 ###\nclass LinkedListDeque\n  ### 獲取雙向佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @front = nil  # 頭節點 front\n    @rear = nil   # 尾節點 rear\n    @size = 0     # 雙向佇列的長度\n  end\n\n  ### 判斷雙向佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 入列操作 ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # 若鏈結串列為空， 則令 front 和 rear 都指向 node\n    if is_empty?\n      @front = @rear = node\n    # 佇列首入列操作\n    elsif is_front\n      # 將 node 新增至鏈結串列頭部\n      @front.prev = node\n      node.next = @front\n      @front = node # 更新頭節點\n    # 佇列尾入列操作\n    else\n      # 將 node 新增至鏈結串列尾部\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # 更新尾節點\n    end\n    @size += 1 # 更新佇列長度\n  end\n\n  ### 佇列首入列 ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### 佇列尾入列 ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### 出列操作 ###\n  def pop(is_front)\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    # 佇列首出列操作\n    if is_front\n      val = @front.val # 暫存頭節點值\n      # 刪除頭節點\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # 更新頭節點\n    # 佇列尾出列操作\n    else\n      val = @rear.val # 暫存尾節點值\n      # 刪除尾節點\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # 更新尾節點\n    end\n    @size -= 1 # 更新佇列長度\n\n    val\n  end\n\n  ### 佇列首出列 ###\n  def pop_first\n    pop(true)\n  end\n\n  ### 佇列首出列 ###\n  def pop_last\n    pop(false)\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek_first\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @front.val\n  end\n\n  ### 訪問佇列尾元素 ###\n  def peek_last\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @rear.val\n  end\n\n  ### 返回陣列用於列印 ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>如圖 5-9 所示，與基於陣列實現佇列類似，我們也可以使用環形陣列來實現雙向佇列。</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 5-9   基於陣列實現雙向佇列的入列出列操作 </p> <p>在佇列的實現基礎上，僅需增加“佇列首入列”和“佇列尾出列”的方法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"基於環形陣列實現的雙向佇列\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"建構子\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取雙向佇列的容量\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"獲取雙向佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷雙向佇列是否為空\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"計算環形陣列索引\"\"\"\n        # 透過取餘操作實現陣列首尾相連\n        # 當 i 越過陣列尾部後，回到頭部\n        # 當 i 越過陣列頭部後，回到尾部\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"佇列首入列\"\"\"\n        if self._size == self.capacity():\n            print(\"雙向佇列已滿\")\n            return\n        # 佇列首指標向左移動一位\n        # 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        self._front = self.index(self._front - 1)\n        # 將 num 新增至佇列首\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"佇列尾入列\"\"\"\n        if self._size == self.capacity():\n            print(\"雙向佇列已滿\")\n            return\n        # 計算佇列尾指標，指向佇列尾索引 + 1\n        rear = self.index(self._front + self._size)\n        # 將 num 新增至佇列尾\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"佇列首出列\"\"\"\n        num = self.peek_first()\n        # 佇列首指標向後移動一位\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"佇列尾出列\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"訪問佇列尾元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        # 計算尾元素索引\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回陣列用於列印\"\"\"\n        # 僅轉換有效長度範圍內的串列元素\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // 用於儲存雙向佇列元素的陣列\n    int front;        // 佇列首指標，指向佇列首元素\n    int queSize;      // 雙向佇列長度\n\n  public:\n    /* 建構子 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* 獲取雙向佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    int index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity();\n    }\n\n    /* 佇列首入列 */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"雙向佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"雙向佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    int popFirst() {\n        int num = peekFirst();\n        // 佇列首指標向後移動一位\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        // 計算尾元素索引\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private int[] nums; // 用於儲存雙向佇列元素的陣列\n    private int front; // 佇列首指標，指向佇列首元素\n    private int queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    private int index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity();\n    }\n\n    /* 佇列首入列 */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    public int popFirst() {\n        int num = peekFirst();\n        // 佇列首指標向後移動一位\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // 計算尾元素索引\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    int[] nums;  // 用於儲存雙向佇列元素的陣列\n    int front;   // 佇列首指標，指向佇列首元素\n    int queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    int Index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* 佇列首入列 */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = Index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = Index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // 佇列首指標向後移動一位\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // 計算尾元素索引\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* 基於環形陣列實現的雙向佇列 */\ntype arrayDeque struct {\n    nums        []int // 用於儲存雙向佇列元素的陣列\n    front       int   // 佇列首指標，指向佇列首元素\n    queSize     int   // 雙向佇列長度\n    queCapacity int   // 佇列容量（即最大容納元素數量）\n}\n\n/* 初始化佇列 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 獲取雙向佇列的長度 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* 判斷雙向佇列是否為空 */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 計算環形陣列索引 */\nfunc (q *arrayDeque) index(i int) int {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部後，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* 佇列首入列 */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"雙向佇列已滿\")\n        return\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n    q.front = q.index(q.front - 1)\n    // 將 num 新增至佇列首\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* 佇列尾入列 */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"雙向佇列已滿\")\n        return\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    rear := q.index(q.front + q.queSize)\n    // 將 num 新增至佇列尾\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* 佇列首出列 */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // 佇列首指標向後移動一位\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* 佇列尾出列 */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* 訪問佇列首元素 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 訪問佇列尾元素 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // 計算尾元素索引\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (q *arrayDeque) toSlice() []int {\n    // 僅轉換有效長度範圍內的串列元素\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private var nums: [Int] // 用於儲存雙向佇列元素的陣列\n    private var front: Int // 佇列首指標，指向佇列首元素\n    private var _size: Int // 雙向佇列長度\n\n    /* 建構子 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 獲取雙向佇列的容量 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 獲取雙向佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 計算環形陣列索引 */\n    private func index(i: Int) -&gt; Int {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        (i + capacity()) % capacity()\n    }\n\n    /* 佇列首入列 */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"雙向佇列已滿\")\n            return\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(i: front - 1)\n        // 將 num 新增至佇列首\n        nums[front] = num\n        _size += 1\n    }\n\n    /* 佇列尾入列 */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"雙向佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        let rear = index(i: front + size())\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* 佇列首出列 */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // 佇列首指標向後移動一位\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* 佇列尾出列 */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return nums[front]\n    }\n\n    /* 訪問佇列尾元素 */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        // 計算尾元素索引\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    func toArray() -&gt; [Int] {\n        // 僅轉換有效長度範圍內的串列元素\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    #nums; // 用於儲存雙向佇列元素的陣列\n    #front; // 佇列首指標，指向佇列首元素\n    #queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 計算環形陣列索引 */\n    index(i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* 佇列首入列 */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        this.#front = this.index(this.#front - 1);\n        // 將 num 新增至佇列首\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* 佇列尾入列 */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // 將 num 新增至佇列尾\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* 佇列首出列 */\n    popFirst() {\n        const num = this.peekFirst();\n        // 佇列首指標向後移動一位\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 計算尾元素索引\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private nums: number[]; // 用於儲存雙向佇列元素的陣列\n    private front: number; // 佇列首指標，指向佇列首元素\n    private queSize: number; // 雙向佇列長度\n\n    /* 建構子 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 計算環形陣列索引 */\n    index(i: number): number {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* 佇列首入列 */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        this.front = this.index(this.front - 1);\n        // 將 num 新增至佇列首\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* 佇列尾入列 */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // 將 num 新增至佇列尾\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* 佇列首出列 */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // 佇列首指標向後移動一位\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 計算尾元素索引\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    toArray(): number[] {\n        // 僅轉換有效長度範圍內的串列元素\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // 用於儲存雙向佇列元素的陣列\n  late int _front; // 佇列首指標，指向佇列首元素\n  late int _queSize; // 雙向佇列長度\n\n  /* 建構子 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* 獲取雙向佇列的容量 */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* 獲取雙向佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷雙向佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 計算環形陣列索引 */\n  int index(int i) {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部後，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return (i + capacity()) % capacity();\n  }\n\n  /* 佇列首入列 */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"雙向佇列已滿\");\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 _front 越過陣列頭部後回到尾部\n    _front = index(_front - 1);\n    // 將 _num 新增至佇列首\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* 佇列尾入列 */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"雙向佇列已滿\");\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    int rear = index(_front + _queSize);\n    // 將 _num 新增至佇列尾\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* 佇列首出列 */\n  int popFirst() {\n    int _num = peekFirst();\n    // 佇列首指標向右移動一位\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* 佇列尾出列 */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"雙向佇列為空\");\n    }\n    return _nums[_front];\n  }\n\n  /* 訪問佇列尾元素 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"雙向佇列為空\");\n    }\n    // 計算尾元素索引\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* 返回陣列用於列印 */\n  List&lt;int&gt; toArray() {\n    // 僅轉換有效長度範圍內的串列元素\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* 基於環形陣列實現的雙向佇列 */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // 用於儲存雙向佇列元素的陣列\n    front: usize,    // 佇列首指標，指向佇列首元素\n    que_size: usize, // 雙向佇列長度\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* 建構子 */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取雙向佇列的容量 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* 獲取雙向佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 計算環形陣列索引 */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* 佇列首入列 */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        self.front = self.index(self.front as i32 - 1);\n        // 將 num 新增至佇列首\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* 佇列尾入列 */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // 將 num 新增至佇列尾\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* 佇列首出列 */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // 佇列首指標向後移動一位\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* 佇列尾出列 */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* 訪問佇列首元素 */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"雙向佇列為空\")\n        };\n        self.nums[self.front]\n    }\n\n    /* 訪問佇列尾元素 */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"雙向佇列為空\")\n        };\n        // 計算尾元素索引\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // 僅轉換有效長度範圍內的串列元素\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* 基於環形陣列實現的雙向佇列 */\ntypedef struct {\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 尾指標，指向佇列尾 + 1\n    int queCapacity; // 佇列容量\n} ArrayDeque;\n\n/* 建構子 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // 初始化陣列\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* 析構函式 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* 獲取雙向佇列的容量 */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* 獲取雙向佇列的長度 */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 判斷雙向佇列是否為空 */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* 計算環形陣列索引 */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部時，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* 佇列首入列 */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"雙向佇列已滿\\r\\n\");\n        return;\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 front 越過陣列頭部回到尾部\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // 將 num 新增到佇列首\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* 佇列尾入列 */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"雙向佇列已滿\\r\\n\");\n        return;\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // 將 num 新增至佇列尾\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* 訪問佇列首元素 */\nint peekFirst(ArrayDeque *deque) {\n    // 訪問異常：雙向佇列為空\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* 訪問佇列尾元素 */\nint peekLast(ArrayDeque *deque) {\n    // 訪問異常：雙向佇列為空\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* 佇列首出列 */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // 佇列首指標向後移動一位\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 佇列尾出列 */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 返回陣列用於列印 */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* 建構子 */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // 用於儲存雙向佇列元素的陣列\n    private var front: Int = 0 // 佇列首指標，指向佇列首元素\n    private var queSize: Int = 0 // 雙向佇列長度\n\n    /* 獲取雙向佇列的容量 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 獲取雙向佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 計算環形陣列索引 */\n    private fun index(i: Int): Int {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity()\n    }\n\n    /* 佇列首入列 */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"雙向佇列已滿\")\n            return\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1)\n        // 將 num 新增至佇列首\n        nums[front] = num\n        queSize++\n    }\n\n    /* 佇列尾入列 */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"雙向佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        val rear = index(front + queSize)\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        queSize++\n    }\n\n    /* 佇列首出列 */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // 佇列首指標向後移動一位\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* 佇列尾出列 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 訪問佇列尾元素 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 計算尾元素索引\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    fun toArray(): IntArray {\n        // 僅轉換有效長度範圍內的串列元素\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### 基於環形陣列實現的雙向佇列 ###\nclass ArrayDeque\n  ### 獲取雙向佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### 獲取雙向佇列的容量 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 判斷雙向佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 佇列首入列 ###\n  def push_first(num)\n    if size == capacity\n      puts '雙向佇列已滿'\n      return\n    end\n\n    # 佇列首指標向左移動一位\n    # 透過取餘操作實現 front 越過陣列頭部後回到尾部\n    @front = index(@front - 1)\n    # 將 num 新增至佇列首\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### 佇列尾入列 ###\n  def push_last(num)\n    if size == capacity\n      puts '雙向佇列已滿'\n      return\n    end\n\n    # 計算佇列尾指標，指向佇列尾索引 + 1\n    rear = index(@front + size)\n    # 將 num 新增至佇列尾\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### 佇列首出列 ###\n  def pop_first\n    num = peek_first\n    # 佇列首指標向後移動一位\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### 佇列尾出列 ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek_first\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 訪問佇列尾元素 ###\n  def peek_last\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    # 計算尾元素索引\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### 返回陣列用於列印 ###\n  def to_array\n    # 僅轉換有效長度範圍內的串列元素\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### 計算環形陣列索引 ###\n  def index(i)\n    # 透過取餘操作實現陣列首尾相連\n    # 當 i 越過陣列尾部後，回到頭部\n    # 當 i 越過陣列頭部後，回到尾部\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   雙向佇列應用","text":"<p>雙向佇列兼具堆疊與佇列的邏輯，因此它可以實現這兩者的所有應用場景，同時提供更高的自由度。</p> <p>我們知道，軟體的“撤銷”功能通常使用堆疊來實現：系統將每次更改操作 <code>push</code> 到堆疊中，然後透過 <code>pop</code> 實現撤銷。然而，考慮到系統資源的限制，軟體通常會限制撤銷的步數（例如僅允許儲存 \\(50\\) 步）。當堆疊的長度超過 \\(50\\) 時，軟體需要在堆疊底（佇列首）執行刪除操作。但堆疊無法實現該功能，此時就需要使用雙向佇列來替代堆疊。請注意，“撤銷”的核心邏輯仍然遵循堆疊的先入後出原則，只是雙向佇列能夠更加靈活地實現一些額外邏輯。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   佇列","text":"<p>佇列（queue）是一種遵循先入先出規則的線性資料結構。顧名思義，佇列模擬了排隊現象，即新來的人不斷加入佇列尾部，而位於佇列頭部的人逐個離開。</p> <p>如圖 5-4 所示，我們將佇列頭部稱為“佇列首”，尾部稱為“佇列尾”，將把元素加入列尾的操作稱為“入列”，刪除佇列首元素的操作稱為“出列”。</p> <p></p> <p> 圖 5-4   佇列的先入先出規則 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   佇列常用操作","text":"<p>佇列的常見操作如表 5-2 所示。需要注意的是，不同程式語言的方法名稱可能會有所不同。我們在此採用與堆疊相同的方法命名。</p> <p> 表 5-2   佇列操作效率 </p> 方法名 描述 時間複雜度 <code>push()</code> 元素入列，即將元素新增至佇列尾 \\(O(1)\\) <code>pop()</code> 佇列首元素出列 \\(O(1)\\) <code>peek()</code> 訪問佇列首元素 \\(O(1)\\) <p>我們可以直接使用程式語言中現成的佇列類別：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# 初始化佇列\n# 在 Python 中，我們一般將雙向佇列類別 deque 當作佇列使用\n# 雖然 queue.Queue() 是純正的佇列類別，但不太好用，因此不推薦\nque: deque[int] = deque()\n\n# 元素入列\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# 訪問佇列首元素\nfront: int = que[0]\n\n# 元素出列\npop: int = que.popleft()\n\n# 獲取佇列的長度\nsize: int = len(que)\n\n# 判斷佇列是否為空\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* 初始化佇列 */\nqueue&lt;int&gt; queue;\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nint front = queue.front();\n\n/* 元素出列 */\nqueue.pop();\n\n/* 獲取佇列的長度 */\nint size = queue.size();\n\n/* 判斷佇列是否為空 */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* 初始化佇列 */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* 元素入列 */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.peek();\n\n/* 元素出列 */\nint pop = queue.poll();\n\n/* 獲取佇列的長度 */\nint size = queue.size();\n\n/* 判斷佇列是否為空 */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* 初始化佇列 */\nQueue&lt;int&gt; queue = new();\n\n/* 元素入列 */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.Peek();\n\n/* 元素出列 */\nint pop = queue.Dequeue();\n\n/* 獲取佇列的長度 */\nint size = queue.Count;\n\n/* 判斷佇列是否為空 */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* 初始化佇列 */\n// 在 Go 中，將 list 作為佇列來使用\nqueue := list.New()\n\n/* 元素入列 */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* 訪問佇列首元素 */\npeek := queue.Front()\n\n/* 元素出列 */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* 獲取佇列的長度 */\nsize := queue.Len()\n\n/* 判斷佇列是否為空 */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* 初始化佇列 */\n// Swift 沒有內建的佇列類別，可以把 Array 當作佇列來使用\nvar queue: [Int] = []\n\n/* 元素入列 */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* 訪問佇列首元素 */\nlet peek = queue.first!\n\n/* 元素出列 */\n// 由於是陣列，因此 removeFirst 的複雜度為 O(n)\nlet pool = queue.removeFirst()\n\n/* 獲取佇列的長度 */\nlet size = queue.count\n\n/* 判斷佇列是否為空 */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* 初始化佇列 */\n// JavaScript 沒有內建的佇列，可以把 Array 當作佇列來使用\nconst queue = [];\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nconst peek = queue[0];\n\n/* 元素出列 */\n// 底層是陣列，因此 shift() 方法的時間複雜度為 O(n)\nconst pop = queue.shift();\n\n/* 獲取佇列的長度 */\nconst size = queue.length;\n\n/* 判斷佇列是否為空 */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* 初始化佇列 */\n// TypeScript 沒有內建的佇列，可以把 Array 當作佇列來使用\nconst queue: number[] = [];\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nconst peek = queue[0];\n\n/* 元素出列 */\n// 底層是陣列，因此 shift() 方法的時間複雜度為 O(n)\nconst pop = queue.shift();\n\n/* 獲取佇列的長度 */\nconst size = queue.length;\n\n/* 判斷佇列是否為空 */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* 初始化佇列 */\n// 在 Dart 中，佇列類別 Qeque 是雙向佇列，也可作為佇列使用\nQueue&lt;int&gt; queue = Queue();\n\n/* 元素入列 */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.first;\n\n/* 元素出列 */\nint pop = queue.removeFirst();\n\n/* 獲取佇列的長度 */\nint size = queue.length;\n\n/* 判斷佇列是否為空 */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* 初始化雙向佇列 */\n// 在 Rust 中使用雙向佇列作為普通佇列來使用\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 元素入列 */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* 訪問佇列首元素 */\nif let Some(front) = deque.front() {\n}\n\n/* 元素出列 */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* 獲取佇列的長度 */\nlet size = deque.len();\n\n/* 判斷佇列是否為空 */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C 未提供內建佇列\n</code></pre> queue.kt<pre><code>/* 初始化佇列 */\nval queue = LinkedList&lt;Int&gt;()\n\n/* 元素入列 */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* 訪問佇列首元素 */\nval peek = queue.peek()\n\n/* 元素出列 */\nval pop = queue.poll()\n\n/* 獲取佇列的長度 */\nval size = queue.size\n\n/* 判斷佇列是否為空 */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># 初始化佇列\n# Ruby 內建的佇列（Thread::Queue) 沒有 peek 和走訪方法，可以把 Array 當作佇列來使用\nqueue = []\n\n# 元素入列\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# 訪問佇列元素\npeek = queue.first\n\n# 元素出列\n# 清注意，由於是陣列，Array#shift 方法時間複雜度為 O(n)\npop = queue.shift\n\n# 獲取佇列的長度\nsize = queue.length\n\n# 判斷佇列是否為空\nis_empty = queue.empty?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   佇列實現","text":"<p>為了實現佇列，我們需要一種資料結構，可以在一端新增元素，並在另一端刪除元素，鏈結串列和陣列都符合要求。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   基於鏈結串列的實現","text":"<p>如圖 5-5 所示，我們可以將鏈結串列的“頭節點”和“尾節點”分別視為“佇列首”和“佇列尾”，規定佇列尾僅可新增節點，佇列首僅可刪除節點。</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> 圖 5-5   基於鏈結串列實現佇列的入列出列操作 </p> <p>以下是用鏈結串列實現佇列的程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"基於鏈結串列實現的佇列\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._front: ListNode | None = None  # 頭節點 front\n        self._rear: ListNode | None = None  # 尾節點 rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"獲取佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"入列\"\"\"\n        # 在尾節點後新增 num\n        node = ListNode(num)\n        # 如果佇列為空，則令頭、尾節點都指向該節點\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # 如果佇列不為空，則將該節點新增到尾節點後\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出列\"\"\"\n        num = self.peek()\n        # 刪除頭節點\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"佇列為空\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"轉化為串列用於列印\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        freeMemoryLinkedList(front);\n    }\n\n    /* 獲取佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    void push(int num) {\n        // 在尾節點後新增 num\n        ListNode *node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    int pop() {\n        int num = peek();\n        // 刪除頭節點\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // 釋放記憶體\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"佇列為空\");\n        return front-&gt;val;\n    }\n\n    /* 將鏈結串列轉化為 Vector 並返回 */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private ListNode front, rear; // 頭節點 front ，尾節點 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列 */\n    public void push(int num) {\n        // 在尾節點後新增 num\n        ListNode node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node;\n            rear = node;\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    public int pop() {\n        int num = peek();\n        // 刪除頭節點\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // 頭節點 front ，尾節點 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入列 */\n    public void Push(int num) {\n        // 在尾節點後新增 num\n        ListNode node = new(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node;\n            rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    public int Pop() {\n        int num = Peek();\n        // 刪除頭節點\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* 基於鏈結串列實現的佇列 */\ntype linkedListQueue struct {\n    // 使用內建包 list 來實現佇列\n    data *list.List\n}\n\n/* 初始化佇列 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* 入列 */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* 出列 */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問佇列首元素 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* 獲取佇列的長度 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* 判斷佇列是否為空 */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private var front: ListNode? // 頭節點\n    private var rear: ListNode? // 尾節點\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列 */\n    func push(num: Int) {\n        // 在尾節點後新增 num\n        let node = ListNode(x: num)\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* 出列 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 刪除頭節點\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"佇列為空\")\n        }\n        return front!.val\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    #front; // 頭節點 #front\n    #rear; // 尾節點 #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* 入列 */\n    push(num) {\n        // 在尾節點後新增 num\n        const node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* 出列 */\n    pop() {\n        const num = this.peek();\n        // 刪除頭節點\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek() {\n        if (this.size === 0) throw new Error('佇列為空');\n        return this.#front.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private front: ListNode | null; // 頭節點 front\n    private rear: ListNode | null; // 尾節點 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* 入列 */\n    push(num: number): void {\n        // 在尾節點後新增 num\n        const node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* 出列 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('佇列為空');\n        // 刪除頭節點\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek(): number {\n        if (this.size === 0) throw new Error('佇列為空');\n        return this.front!.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n  ListNode? _front; // 頭節點 _front\n  ListNode? _rear; // 尾節點 _rear\n  int _queSize = 0; // 佇列長度\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* 獲取佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 入列 */\n  void push(int _num) {\n    // 在尾節點後新增 _num\n    final node = ListNode(_num);\n    // 如果佇列為空，則令頭、尾節點都指向該節點\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // 如果佇列不為空，則將該節點新增到尾節點後\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* 出列 */\n  int pop() {\n    final int _num = peek();\n    // 刪除頭節點\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('佇列為空');\n    }\n    return _front!.val;\n  }\n\n  /* 將鏈結串列轉化為 Array 並返回 */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* 基於鏈結串列實現的佇列 */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 頭節點 front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 尾節點 rear\n    que_size: usize,                         // 佇列的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 判斷佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* 入列 */\n    pub fn push(&amp;mut self, num: T) {\n        // 在尾節點後新增 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // 如果佇列不為空，則將該節點新增到尾節點後\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // 如果佇列為空，則令頭、尾節點都指向該節點\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* 出列 */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* 訪問佇列首元素 */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* 基於鏈結串列實現的佇列 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* 建構子 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* 析構函式 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // 釋放所有節點\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // 釋放 queue 結構體\n    free(queue);\n}\n\n/* 獲取佇列的長度 */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* 入列 */\nvoid push(LinkedListQueue *queue, int num) {\n    // 尾節點處新增 node\n    ListNode *node = newListNode(num);\n    // 如果佇列為空，則令頭、尾節點都指向該節點\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // 如果佇列不為空，則將該節點新增到尾節點後\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* 訪問佇列首元素 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* 出列 */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 列印佇列 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // 複製鏈結串列中的資料到陣列\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue(\n    // 頭節點 front ，尾節點 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* 獲取佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入列 */\n    fun push(num: Int) {\n        // 在尾節點後新增 num\n        val node = ListNode(num)\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node\n            rear = node\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* 出列 */\n    fun pop(): Int {\n        val num = peek()\n        // 刪除頭節點\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### 基於鏈結串列頭現的佇列 ###\nclass LinkedListQueue\n  ### 獲取佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @front = nil  # 頭節點 front\n    @rear = nil   # 尾節點 rear\n    @size = 0\n  end\n\n  ### 判斷佇列是否為空 ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### 入列 ###\n  def push(num)\n    # 在尾節點後新增 num\n    node = ListNode.new(num)\n\n    # 如果佇列為空，則令頭，尾節點都指向該節點\n    if @front.nil?\n      @front = node\n      @rear = node\n    # 如果佇列不為空，則令該節點新增到尾節點後\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### 出列 ###\n  def pop\n    num = peek\n    # 刪除頭節點\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek\n    raise IndexError, '佇列為空' if is_empty?\n\n    @front.val\n  end\n\n  ### 將鏈結串列為 Array 並返回 ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>在陣列中刪除首元素的時間複雜度為 \\(O(n)\\) ，這會導致出列操作效率較低。然而，我們可以採用以下巧妙方法來避免這個問題。</p> <p>我們可以使用一個變數 <code>front</code> 指向佇列首元素的索引，並維護一個變數 <code>size</code> 用於記錄佇列長度。定義 <code>rear = front + size</code> ，這個公式計算出的 <code>rear</code> 指向佇列尾元素之後的下一個位置。</p> <p>基於此設計，陣列中包含元素的有效區間為 <code>[front, rear - 1]</code>，各種操作的實現方法如圖 5-6 所示。</p> <ul> <li>入列操作：將輸入元素賦值給 <code>rear</code> 索引處，並將 <code>size</code> 增加 1 。</li> <li>出列操作：只需將 <code>front</code> 增加 1 ，並將 <code>size</code> 減少 1 。</li> </ul> <p>可以看到，入列和出列操作都只需進行一次操作，時間複雜度均為 \\(O(1)\\) 。</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> 圖 5-6   基於陣列實現佇列的入列出列操作 </p> <p>你可能會發現一個問題：在不斷進行入列和出列的過程中，<code>front</code> 和 <code>rear</code> 都在向右移動，當它們到達陣列尾部時就無法繼續移動了。為了解決此問題，我們可以將陣列視為首尾相接的“環形陣列”。</p> <p>對於環形陣列，我們需要讓 <code>front</code> 或 <code>rear</code> 在越過陣列尾部時，直接回到陣列頭部繼續走訪。這種週期性規律可以透過“取餘操作”來實現，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"基於環形陣列實現的佇列\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"建構子\"\"\"\n        self._nums: list[int] = [0] * size  # 用於儲存佇列元素的陣列\n        self._front: int = 0  # 佇列首指標，指向佇列首元素\n        self._size: int = 0  # 佇列長度\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取佇列的容量\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"獲取佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"入列\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"佇列已滿\")\n        # 計算佇列尾指標，指向佇列尾索引 + 1\n        # 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        rear: int = (self._front + self._size) % self.capacity()\n        # 將 num 新增至佇列尾\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出列\"\"\"\n        num: int = self.peek()\n        # 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"佇列為空\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"返回串列用於列印\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n  private:\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 佇列長度\n    int queCapacity; // 佇列容量\n\n  public:\n    ArrayQueue(int capacity) {\n        // 初始化陣列\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* 獲取佇列的容量 */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* 獲取佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列 */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % queCapacity;\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    int pop() {\n        int num = peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"佇列為空\");\n        return nums[front];\n    }\n\n    /* 將陣列轉化為 Vector 並返回 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private int[] nums; // 用於儲存佇列元素的陣列\n    private int front; // 佇列首指標，指向佇列首元素\n    private int queSize; // 佇列長度\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % capacity();\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    public int pop() {\n        int num = peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 返回陣列 */\n    public int[] toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    int[] nums;  // 用於儲存佇列元素的陣列\n    int front;   // 佇列首指標，指向佇列首元素\n    int queSize; // 佇列長度\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 獲取佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % Capacity();\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    public int Pop() {\n        int num = Peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* 返回陣列 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* 基於環形陣列實現的佇列 */\ntype arrayQueue struct {\n    nums        []int // 用於儲存佇列元素的陣列\n    front       int   // 佇列首指標，指向佇列首元素\n    queSize     int   // 佇列長度\n    queCapacity int   // 佇列容量（即最大容納元素數量）\n}\n\n/* 初始化佇列 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 獲取佇列的長度 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* 判斷佇列是否為空 */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 入列 */\nfunc (q *arrayQueue) push(num int) {\n    // 當 rear == queCapacity 表示佇列已滿\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    rear := (q.front + q.queSize) % q.queCapacity\n    // 將 num 新增至佇列尾\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* 出列 */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* 訪問佇列首元素 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private var nums: [Int] // 用於儲存佇列元素的陣列\n    private var front: Int // 佇列首指標，指向佇列首元素\n    private var _size: Int // 佇列長度\n\n    init(capacity: Int) {\n        // 初始化陣列\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 獲取佇列的容量 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 獲取佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列 */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        let rear = (front + size()) % capacity()\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* 出列 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"佇列為空\")\n        }\n        return nums[front]\n    }\n\n    /* 返回陣列 */\n    func toArray() -&gt; [Int] {\n        // 僅轉換有效長度範圍內的串列元素\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    #nums; // 用於儲存佇列元素的陣列\n    #front = 0; // 佇列首指標，指向佇列首元素\n    #queSize = 0; // 佇列長度\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* 獲取佇列的容量 */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 入列 */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        const rear = (this.#front + this.size) % this.capacity;\n        // 將 num 新增至佇列尾\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* 出列 */\n    pop() {\n        const num = this.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek() {\n        if (this.isEmpty()) throw new Error('佇列為空');\n        return this.#nums[this.#front];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private nums: number[]; // 用於儲存佇列元素的陣列\n    private front: number; // 佇列首指標，指向佇列首元素\n    private queSize: number; // 佇列長度\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 入列 */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        const rear = (this.front + this.queSize) % this.capacity;\n        // 將 num 新增至佇列尾\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* 出列 */\n    pop(): number {\n        const num = this.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('佇列為空');\n        return this.nums[this.front];\n    }\n\n    /* 返回 Array */\n    toArray(): number[] {\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // 用於儲存佇列元素的陣列\n  late int _front; // 佇列首指標，指向佇列首元素\n  late int _queSize; // 佇列長度\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* 獲取佇列的容量 */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* 獲取佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 入列 */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"佇列已滿\");\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    int rear = (_front + _queSize) % capaCity();\n    // 將 _num 新增至佇列尾\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* 出列 */\n  int pop() {\n    int _num = peek();\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"佇列為空\");\n    }\n    return _nums[_front];\n  }\n\n  /* 返回 Array */\n  List&lt;int&gt; toArray() {\n    // 僅轉換有效長度範圍內的串列元素\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* 基於環形陣列實現的佇列 */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // 用於儲存佇列元素的陣列\n    front: i32,        // 佇列首指標，指向佇列首元素\n    que_size: i32,     // 佇列長度\n    que_capacity: i32, // 佇列容量\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* 建構子 */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* 獲取佇列的容量 */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* 獲取佇列的長度 */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* 判斷佇列是否為空 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 入列 */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // 將 num 新增至佇列尾\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* 出列 */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* 訪問佇列首元素 */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* 返回陣列 */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* 基於環形陣列實現的佇列 */\ntypedef struct {\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 尾指標，指向佇列尾 + 1\n    int queCapacity; // 佇列容量\n} ArrayQueue;\n\n/* 建構子 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // 初始化陣列\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* 析構函式 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* 獲取佇列的容量 */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* 獲取佇列的長度 */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* 訪問佇列首元素 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* 入列 */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"佇列已滿\\r\\n\");\n        return;\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // 將 num 新增至佇列尾\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* 出列 */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 返回陣列用於列印 */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // 用於儲存佇列元素的陣列\n    private var front: Int = 0 // 佇列首指標，指向佇列首元素\n    private var queSize: Int = 0 // 佇列長度\n\n    /* 獲取佇列的容量 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 獲取佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 入列 */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        val rear = (front + queSize) % capacity()\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        queSize++\n    }\n\n    /* 出列 */\n    fun pop(): Int {\n        val num = peek()\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 返回陣列 */\n    fun toArray(): IntArray {\n        // 僅轉換有效長度範圍內的串列元素\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### 基於環形陣列實現的佇列 ###\nclass ArrayQueue\n  ### 獲取佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # 用於儲存佇列元素的陣列\n    @front = 0 # 佇列首指標，指向佇列首元素\n    @size = 0 # 佇列長度\n  end\n\n  ### 獲取佇列的容量 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 判斷佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 入列 ###\n  def push(num)\n    raise IndexError, '佇列已滿' if size == capacity\n\n    # 計算佇列尾指標，指向佇列尾索引 + 1\n    # 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    rear = (@front + size) % capacity\n    # 將 num 新增至佇列尾\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### 出列 ###\n  def pop\n    num = peek\n    # 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek\n    raise IndexError, '佇列為空' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 返回串列用於列印 ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>以上實現的佇列仍然具有侷限性：其長度不可變。然而，這個問題不難解決，我們可以將陣列替換為動態陣列，從而引入擴容機制。有興趣的讀者可以嘗試自行實現。</p> <p>兩種實現的對比結論與堆疊一致，在此不再贅述。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   佇列典型應用","text":"<ul> <li>淘寶訂單。購物者下單後，訂單將加入佇列中，系統隨後會根據順序處理佇列中的訂單。在雙十一期間，短時間內會產生海量訂單，高併發成為工程師們需要重點攻克的問題。</li> <li>各類待辦事項。任何需要實現“先來後到”功能的場景，例如印表機的任務佇列、餐廳的出餐佇列等，佇列在這些場景中可以有效地維護處理順序。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   堆疊","text":"<p>堆疊（stack）是一種遵循先入後出邏輯的線性資料結構。</p> <p>我們可以將堆疊類比為桌面上的一疊盤子，規定每次只能移動一個盤子，那麼想取出底部的盤子，則需要先將上面的盤子依次移走。我們將盤子替換為各種型別的元素（如整數、字元、物件等），就得到了堆疊這種資料結構。</p> <p>如圖 5-1 所示，我們把堆積疊元素的頂部稱為“堆疊頂”，底部稱為“堆疊底”。將把元素新增到堆疊頂的操作叫作“入堆疊”，刪除堆疊頂元素的操作叫作“出堆疊”。</p> <p></p> <p> 圖 5-1   堆疊的先入後出規則 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   堆疊的常用操作","text":"<p>堆疊的常用操作如表 5-1 所示，具體的方法名需要根據所使用的程式語言來確定。在此，我們以常見的 <code>push()</code>、<code>pop()</code>、<code>peek()</code> 命名為例。</p> <p> 表 5-1   堆疊的操作效率 </p> 方法 描述 時間複雜度 <code>push()</code> 元素入堆疊（新增至堆疊頂） \\(O(1)\\) <code>pop()</code> 堆疊頂元素出堆疊 \\(O(1)\\) <code>peek()</code> 訪問堆疊頂元素 \\(O(1)\\) <p>通常情況下，我們可以直接使用程式語言內建的堆疊類別。然而，某些語言可能沒有專門提供堆疊類別，這時我們可以將該語言的“陣列”或“鏈結串列”當作堆疊來使用，並在程式邏輯上忽略與堆疊無關的操作。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># 初始化堆疊\n# Python 沒有內建的堆疊類別，可以把 list 當作堆疊來使用\nstack: list[int] = []\n\n# 元素入堆疊\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# 訪問堆疊頂元素\npeek: int = stack[-1]\n\n# 元素出堆疊\npop: int = stack.pop()\n\n# 獲取堆疊的長度\nsize: int = len(stack)\n\n# 判斷是否為空\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* 初始化堆疊 */\nstack&lt;int&gt; stack;\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nint top = stack.top();\n\n/* 元素出堆疊 */\nstack.pop(); // 無返回值\n\n/* 獲取堆疊的長度 */\nint size = stack.size();\n\n/* 判斷是否為空 */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* 初始化堆疊 */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.peek();\n\n/* 元素出堆疊 */\nint pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nint size = stack.size();\n\n/* 判斷是否為空 */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* 初始化堆疊 */\nStack&lt;int&gt; stack = new();\n\n/* 元素入堆疊 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.Peek();\n\n/* 元素出堆疊 */\nint pop = stack.Pop();\n\n/* 獲取堆疊的長度 */\nint size = stack.Count;\n\n/* 判斷是否為空 */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* 初始化堆疊 */\n// 在 Go 中，推薦將 Slice 當作堆疊來使用\nvar stack []int\n\n/* 元素入堆疊 */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* 訪問堆疊頂元素 */\npeek := stack[len(stack)-1]\n\n/* 元素出堆疊 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* 獲取堆疊的長度 */\nsize := len(stack)\n\n/* 判斷是否為空 */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* 初始化堆疊 */\n// Swift 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nvar stack: [Int] = []\n\n/* 元素入堆疊 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* 訪問堆疊頂元素 */\nlet peek = stack.last!\n\n/* 元素出堆疊 */\nlet pop = stack.removeLast()\n\n/* 獲取堆疊的長度 */\nlet size = stack.count\n\n/* 判斷是否為空 */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* 初始化堆疊 */\n// JavaScript 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nconst stack = [];\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nconst peek = stack[stack.length-1];\n\n/* 元素出堆疊 */\nconst pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nconst size = stack.length;\n\n/* 判斷是否為空 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* 初始化堆疊 */\n// TypeScript 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nconst stack: number[] = [];\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nconst peek = stack[stack.length - 1];\n\n/* 元素出堆疊 */\nconst pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nconst size = stack.length;\n\n/* 判斷是否為空 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* 初始化堆疊 */\n// Dart 沒有內建的堆疊類別，可以把 List 當作堆疊來使用\nList&lt;int&gt; stack = [];\n\n/* 元素入堆疊 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.last;\n\n/* 元素出堆疊 */\nint pop = stack.removeLast();\n\n/* 獲取堆疊的長度 */\nint size = stack.length;\n\n/* 判斷是否為空 */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* 初始化堆疊 */\n// 把 Vec 當作堆疊來使用\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nlet top = stack.last().unwrap();\n\n/* 元素出堆疊 */\nlet pop = stack.pop().unwrap();\n\n/* 獲取堆疊的長度 */\nlet size = stack.len();\n\n/* 判斷是否為空 */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C 未提供內建堆疊\n</code></pre> stack.kt<pre><code>/* 初始化堆疊 */\nval stack = Stack&lt;Int&gt;()\n\n/* 元素入堆疊 */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* 訪問堆疊頂元素 */\nval peek = stack.peek()\n\n/* 元素出堆疊 */\nval pop = stack.pop()\n\n/* 獲取堆疊的長度 */\nval size = stack.size\n\n/* 判斷是否為空 */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># 初始化堆疊\n# Ruby 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nstack = []\n\n# 元素入堆疊\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# 訪問堆疊頂元素\npeek = stack.last\n\n# 元素出堆疊\npop = stack.pop\n\n# 獲取堆疊的長度\nsize = stack.length\n\n# 判斷是否為空\nis_empty = stack.empty?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   堆疊的實現","text":"<p>為了深入瞭解堆疊的執行機制，我們來嘗試自己實現一個堆疊類別。</p> <p>堆疊遵循先入後出的原則，因此我們只能在堆疊頂新增或刪除元素。然而，陣列和鏈結串列都可以在任意位置新增和刪除元素，因此堆疊可以視為一種受限制的陣列或鏈結串列。換句話說，我們可以“遮蔽”陣列或鏈結串列的部分無關操作，使其對外表現的邏輯符合堆疊的特性。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   基於鏈結串列的實現","text":"<p>使用鏈結串列實現堆疊時，我們可以將鏈結串列的頭節點視為堆疊頂，尾節點視為堆疊底。</p> <p>如圖 5-2 所示，對於入堆疊操作，我們只需將元素插入鏈結串列頭部，這種節點插入方法被稱為“頭插法”。而對於出堆疊操作，只需將頭節點從鏈結串列中刪除即可。</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> 圖 5-2   基於鏈結串列實現堆疊的入堆疊出堆疊操作 </p> <p>以下是基於鏈結串列實現堆疊的示例程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"基於鏈結串列實現的堆疊\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"獲取堆疊的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷堆疊是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"入堆疊\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出堆疊\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問堆疊頂元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"轉化為串列用於列印\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // 將頭節點作為堆疊頂\n    int stkSize;        // 堆疊的長度\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* 獲取堆疊的長度 */\n    int size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // 釋放記憶體\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"堆疊為空\");\n        return stackTop-&gt;val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private ListNode stackPeek; // 將頭節點作為堆疊頂\n    private int stkSize = 0; // 堆疊的長度\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // 將頭節點作為堆疊頂\n    int stkSize = 0;   // 堆疊的長度\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* 基於鏈結串列實現的堆疊 */\ntype linkedListStack struct {\n    // 使用內建包 list 來實現堆疊\n    data *list.List\n}\n\n/* 初始化堆疊 */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* 入堆疊 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* 出堆疊 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問堆疊頂元素 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* 獲取堆疊的長度 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* 判斷堆疊是否為空 */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private var _peek: ListNode? // 將頭節點作為堆疊頂\n    private var _size: Int // 堆疊的長度\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取堆疊的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷堆疊是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入堆疊 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* 出堆疊 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* 訪問堆疊頂元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return _peek!.val\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    #stackPeek; // 將頭節點作為堆疊頂\n    #stkSize = 0; // 堆疊的長度\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* 入堆疊 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* 出堆疊 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('堆疊為空');\n        return this.#stackPeek.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // 將頭節點作為堆疊頂\n    private stkSize: number = 0; // 堆疊的長度\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* 入堆疊 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* 出堆疊 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('堆疊為空');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('堆疊為空');\n        return this.stackPeek.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* 基於鏈結串列類別實現的堆疊 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // 將頭節點作為堆疊頂\n  int _stkSize = 0; // 堆疊的長度\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* 獲取堆疊的長度 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* 判斷堆疊是否為空 */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* 入堆疊 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* 出堆疊 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* 訪問堆疊頂元素 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* 將鏈結串列轉化為 List 並返回 */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* 基於鏈結串列實現的堆疊 */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 將頭節點作為堆疊頂\n    stk_size: usize,                              // 堆疊的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* 獲取堆疊的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* 判斷堆疊是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* 入堆疊 */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* 出堆疊 */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* 訪問堆疊頂元素 */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* 基於鏈結串列實現的堆疊 */\ntypedef struct {\n    ListNode *top; // 將頭節點作為堆疊頂\n    int size;      // 堆疊的長度\n} LinkedListStack;\n\n/* 建構子 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* 析構函式 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* 獲取堆疊的長度 */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* 判斷堆疊是否為空 */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* 入堆疊 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // 更新新加節點指標域\n    node-&gt;val = num;     // 更新新加節點資料域\n    s-&gt;top = node;       // 更新堆疊頂\n    s-&gt;size++;           // 更新堆疊大小\n}\n\n/* 訪問堆疊頂元素 */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"堆疊為空\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* 出堆疊 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // 釋放記憶體\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // 將頭節點作為堆疊頂\n    private var stkSize: Int = 0 // 堆疊的長度\n) {\n\n    /* 獲取堆疊的長度 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* 判斷堆疊是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入堆疊 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* 出堆疊 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* 訪問堆疊頂元素 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### 基於鏈結串列實現的堆疊 ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @size = 0\n  end\n\n  ### 判斷堆疊是否為空 ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### 入堆疊 ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### 出堆疊 ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### 訪問堆疊頂元素 ###\n  def peek\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @peek.val\n  end\n\n  ### 將鏈結串列轉化為 Array 並反回 ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>使用陣列實現堆疊時，我們可以將陣列的尾部作為堆疊頂。如圖 5-3 所示，入堆疊與出堆疊操作分別對應在陣列尾部新增元素與刪除元素，時間複雜度都為 \\(O(1)\\) 。</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> 圖 5-3   基於陣列實現堆疊的入堆疊出堆疊操作 </p> <p>由於入堆疊的元素可能會源源不斷地增加，因此我們可以使用動態陣列，這樣就無須自行處理陣列擴容問題。以下為示例程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"基於陣列實現的堆疊\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"獲取堆疊的長度\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷堆疊是否為空\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"入堆疊\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"出堆疊\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問堆疊頂元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"返回串列用於列印\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* 獲取堆疊的長度 */\n    int size() {\n        return stack.size();\n    }\n\n    /* 判斷堆疊是否為空 */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* 入堆疊 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* 出堆疊 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"堆疊為空\");\n        return stack.back();\n    }\n\n    /* 返回 Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // 初始化串列（動態陣列）\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* 獲取堆疊的長度 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* 判斷堆疊是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* 出堆疊 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // 初始化串列（動態陣列）\n        stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* 出堆疊 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* 基於陣列實現的堆疊 */\ntype arrayStack struct {\n    data []int // 資料\n}\n\n/* 初始化堆疊 */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // 設定堆疊的長度為 0，容量為 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* 堆疊的長度 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* 堆疊是否為空 */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* 入堆疊 */\nfunc (s *arrayStack) push(v int) {\n    // 切片會自動擴容\n    s.data = append(s.data, v)\n}\n\n/* 出堆疊 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* 獲取堆疊頂元素 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // 初始化串列（動態陣列）\n        stack = []\n    }\n\n    /* 獲取堆疊的長度 */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* 判斷堆疊是否為空 */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* 入堆疊 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* 出堆疊 */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return stack.removeLast()\n    }\n\n    /* 訪問堆疊頂元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return stack.last!\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* 入堆疊 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* 出堆疊 */\n    pop() {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.#stack.pop();\n    }\n\n    /* 訪問堆疊頂元素 */\n    top() {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* 入堆疊 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* 出堆疊 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.stack.pop();\n    }\n\n    /* 訪問堆疊頂元素 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* 獲取堆疊的長度 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* 判斷堆疊是否為空 */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* 入堆疊 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* 出堆疊 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* 訪問堆疊頂元素 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stack.last;\n  }\n\n  /* 將堆疊轉化為 Array 並返回 */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* 基於陣列實現的堆疊 */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* 初始化堆疊 */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* 獲取堆疊的長度 */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* 判斷堆疊是否為空 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* 入堆疊 */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* 出堆疊 */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* 訪問堆疊頂元素 */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"堆疊為空\")\n        };\n        self.stack.last()\n    }\n\n    /* 返回 &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* 基於陣列實現的堆疊 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* 建構子 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // 初始化一個大容量，避免擴容\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* 析構函式 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* 獲取堆疊的長度 */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* 判斷堆疊是否為空 */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* 入堆疊 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"堆疊已滿\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* 訪問堆疊頂元素 */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"堆疊為空\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* 出堆疊 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    // 初始化串列（動態陣列）\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* 獲取堆疊的長度 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* 判斷堆疊是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入堆疊 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* 出堆疊 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* 訪問堆疊頂元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### 基於陣列實現的堆疊 ###\nclass ArrayStack\n  ### 建構子 ###\n  def initialize\n    @stack = []\n  end\n\n  ### 獲取堆疊的長度 ###\n  def size\n    @stack.length\n  end\n\n  ### 判斷堆疊是否為空 ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### 入堆疊 ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### 出堆疊 ###\n  def pop\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @stack.pop\n  end\n\n  ### 訪問堆疊頂元素 ###\n  def peek\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @stack.last\n  end\n\n  ### 返回串列用於列印 ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513","level":2,"title":"5.1.3   兩種實現對比","text":"<p>支持操作</p> <p>兩種實現都支持堆疊定義中的各項操作。陣列實現額外支持隨機訪問，但這已超出了堆疊的定義範疇，因此一般不會用到。</p> <p>時間效率</p> <p>在基於陣列的實現中，入堆疊和出堆疊操作都在預先分配好的連續記憶體中進行，具有很好的快取本地性，因此效率較高。然而，如果入堆疊時超出陣列容量，會觸發擴容機制，導致該次入堆疊操作的時間複雜度變為 \\(O(n)\\) 。</p> <p>在基於鏈結串列的實現中，鏈結串列的擴容非常靈活，不存在上述陣列擴容時效率降低的問題。但是，入堆疊操作需要初始化節點物件並修改指標，因此效率相對較低。不過，如果入堆疊元素本身就是節點物件，那麼可以省去初始化步驟，從而提高效率。</p> <p>綜上所述，當入堆疊與出堆疊操作的元素是基本資料型別時，例如 <code>int</code> 或 <code>double</code> ，我們可以得出以下結論。</p> <ul> <li>基於陣列實現的堆疊在觸發擴容時效率會降低，但由於擴容是低頻操作，因此平均效率更高。</li> <li>基於鏈結串列實現的堆疊可以提供更加穩定的效率表現。</li> </ul> <p>空間效率</p> <p>在初始化串列時，系統會為串列分配“初始容量”，該容量可能超出實際需求；並且，擴容機制通常是按照特定倍率（例如 2 倍）進行擴容的，擴容後的容量也可能超出實際需求。因此，基於陣列實現的堆疊可能造成一定的空間浪費。</p> <p>然而，由於鏈結串列節點需要額外儲存指標，因此鏈結串列節點佔用的空間相對較大。</p> <p>綜上，我們不能簡單地確定哪種實現更加節省記憶體，需要針對具體情況進行分析。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   堆疊的典型應用","text":"<ul> <li>瀏覽器中的後退與前進、軟體中的撤銷與反撤銷。每當我們開啟新的網頁，瀏覽器就會對上一個網頁執行入堆疊，這樣我們就可以通過後退操作回到上一個網頁。後退操作實際上是在執行出堆疊。如果要同時支持後退和前進，那麼需要兩個堆疊來配合實現。</li> <li>程式記憶體管理。每次呼叫函式時，系統都會在堆疊頂新增一個堆疊幀，用於記錄函式的上下文資訊。在遞迴函式中，向下遞推階段會不斷執行入堆疊操作，而向上回溯階段則會不斷執行出堆疊操作。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   小結","text":"","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>堆疊是一種遵循先入後出原則的資料結構，可透過陣列或鏈結串列來實現。</li> <li>在時間效率方面，堆疊的陣列實現具有較高的平均效率，但在擴容過程中，單次入堆疊操作的時間複雜度會劣化至 \\(O(n)\\) 。相比之下，堆疊的鏈結串列實現具有更為穩定的效率表現。</li> <li>在空間效率方面，堆疊的陣列實現可能導致一定程度的空間浪費。但需要注意的是，鏈結串列節點所佔用的記憶體空間比陣列元素更大。</li> <li>佇列是一種遵循先入先出原則的資料結構，同樣可以透過陣列或鏈結串列來實現。在時間效率和空間效率的對比上，佇列的結論與前述堆疊的結論相似。</li> <li>雙向佇列是一種具有更高自由度的佇列，它允許在兩端進行元素的新增和刪除操作。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：瀏覽器的前進後退是否是雙向鏈結串列實現？</p> <p>瀏覽器的前進後退功能本質上是“堆疊”的體現。當用戶訪問一個新頁面時，該頁面會被新增到堆疊頂；當用戶點選後退按鈕時，該頁面會從堆疊頂彈出。使用雙向佇列可以方便地實現一些額外操作，這個在“雙向佇列”章節有提到。</p> <p>Q：在出堆疊後，是否需要釋放出堆疊節點的記憶體？</p> <p>如果後續仍需要使用彈出節點，則不需要釋放記憶體。若之後不需要用到，<code>Java</code> 和 <code>Python</code> 等語言擁有自動垃圾回收機制，因此不需要手動釋放記憶體；在 <code>C</code> 和 <code>C++</code> 中需要手動釋放記憶體。</p> <p>Q：雙向佇列像是兩個堆疊拼接在了一起，它的用途是什麼？</p> <p>雙向佇列就像是堆疊和佇列的組合或兩個堆疊拼在了一起。它表現的是堆疊 + 佇列的邏輯，因此可以實現堆疊與佇列的所有應用，並且更加靈活。</p> <p>Q：撤銷（undo）和反撤銷（redo）具體是如何實現的？</p> <p>使用兩個堆疊，堆疊 <code>A</code> 用於撤銷，堆疊 <code>B</code> 用於反撤銷。</p> <ol> <li>每當使用者執行一個操作，將這個操作壓入堆疊 <code>A</code> ，並清空堆疊 <code>B</code> 。</li> <li>當用戶執行“撤銷”時，從堆疊 <code>A</code> 中彈出最近的操作，並將其壓入堆疊 <code>B</code> 。</li> <li>當用戶執行“反撤銷”時，從堆疊 <code>B</code> 中彈出最近的操作，並將其壓入堆疊 <code>A</code> 。</li> </ol>","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"第 7 章   樹","text":"<p>Abstract</p> <p>參天大樹充滿生命力，根深葉茂，分枝扶疏。</p> <p>它為我們展現了資料分治的生動形態。</p>","path":["第 7 章 &nbsp; 樹"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"本章內容","text":"<ul> <li>7.1   二元樹</li> <li>7.2   二元樹走訪</li> <li>7.3   二元樹陣列表示</li> <li>7.4   二元搜尋樹</li> <li>7.5   AVL *</li> <li>7.6   小結</li> </ul>","path":["第 7 章 &nbsp; 樹"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   二元樹陣列表示","text":"<p>在鏈結串列表示下，二元樹的儲存單元為節點 <code>TreeNode</code> ，節點之間透過指標相連線。上一節介紹了鏈結串列表示下的二元樹的各項基本操作。</p> <p>那麼，我們能否用陣列來表示二元樹呢？答案是肯定的。</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   表示完美二元樹","text":"<p>先分析一個簡單案例。給定一棵完美二元樹，我們將所有節點按照層序走訪的順序儲存在一個陣列中，則每個節點都對應唯一的陣列索引。</p> <p>根據層序走訪的特性，我們可以推導出父節點索引與子節點索引之間的“對映公式”：若某節點的索引為 \\(i\\) ，則該節點的左子節點索引為 \\(2i + 1\\) ，右子節點索引為 \\(2i + 2\\) 。圖 7-12 展示了各個節點索引之間的對映關係。</p> <p></p> <p> 圖 7-12   完美二元樹的陣列表示 </p> <p>對映公式的角色相當於鏈結串列中的節點引用（指標）。給定陣列中的任意一個節點，我們都可以透過對映公式來訪問它的左（右）子節點。</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   表示任意二元樹","text":"<p>完美二元樹是一個特例，在二元樹的中間層通常存在許多 <code>None</code> 。由於層序走訪序列並不包含這些 <code>None</code> ，因此我們無法僅憑該序列來推測 <code>None</code> 的數量和分佈位置。這意味著存在多種二元樹結構都符合該層序走訪序列。</p> <p>如圖 7-13 所示，給定一棵非完美二元樹，上述陣列表示方法已經失效。</p> <p></p> <p> 圖 7-13   層序走訪序列對應多種二元樹可能性 </p> <p>為了解決此問題，我們可以考慮在層序走訪序列中顯式地寫出所有 <code>None</code> 。如圖 7-14 所示，這樣處理後，層序走訪序列就可以唯一表示二元樹了。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 二元樹的陣列表示\n# 使用 None 來表示空位\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 最大值 INT_MAX 標記空位\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 的包裝類別 Integer ，就可以使用 null 來標記空位\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int? 可空型別 ，就可以使用 null 來標記空位\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 any 型別的切片, 就可以使用 nil 來標記空位\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 Int? 可空型別 ，就可以使用 nil 來標記空位\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int? 可空型別 ，就可以使用 null 來標記空位\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 None 來標記空位\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 最大值標記空位，因此要求節點值不能為 INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### 二元樹的陣列表示 ###\n# 使用 nil 來表示空位\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> 圖 7-14   任意型別二元樹的陣列表示 </p> <p>值得說明的是，完全二元樹非常適合使用陣列來表示。回顧完全二元樹的定義，<code>None</code> 只出現在最底層且靠右的位置，因此所有 <code>None</code> 一定出現在層序走訪序列的末尾。</p> <p>這意味著使用陣列表示完全二元樹時，可以省略儲存所有 <code>None</code> ，非常方便。圖 7-15 給出了一個例子。</p> <p></p> <p> 圖 7-15   完全二元樹的陣列表示 </p> <p>以下程式碼實現了一棵基於陣列表示的二元樹，包括以下幾種操作。</p> <ul> <li>給定某節點，獲取它的值、左（右）子節點、父節點。</li> <li>獲取前序走訪、中序走訪、後序走訪、層序走訪序列。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"陣列表示下的二元樹類別\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"建構子\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"串列容量\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的值\"\"\"\n        # 若索引越界，則返回 None ，代表空位\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的左子節點的索引\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的右子節點的索引\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的父節點的索引\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"層序走訪\"\"\"\n        self.res = []\n        # 直接走訪陣列\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"深度優先走訪\"\"\"\n        if self.val(i) is None:\n            return\n        # 前序走訪\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # 中序走訪\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # 後序走訪\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"前序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"中序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"後序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n  public:\n    /* 建構子 */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* 串列容量 */\n    int size() {\n        return tree.size();\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    int val(int i) {\n        // 若索引越界，則返回 INT_MAX ，代表空位\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // 直接走訪陣列\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* 前序走訪 */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* 深度優先走訪 */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // 若為空位，則返回\n        if (val(i) == INT_MAX)\n            return;\n        // 前序走訪\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // 中序走訪\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // 後序走訪\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* 建構子 */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* 串列容量 */\n    public int size() {\n        return tree.size();\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    public Integer val(int i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // 直接走訪陣列\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // 若為空位，則返回\n        if (val(i) == null)\n            return;\n        // 前序走訪\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // 中序走訪\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // 後序走訪\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* 前序走訪 */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* 串列容量 */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    public int? Val(int i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // 直接走訪陣列\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // 若為空位，則返回\n        if (!Val(i).HasValue)\n            return;\n        // 前序走訪\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // 中序走訪\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // 後序走訪\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* 前序走訪 */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* 陣列表示下的二元樹類別 */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* 建構子 */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* 串列容量 */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* 獲取索引為 i 節點的值 */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // 若索引越界，則返回 null ，代表空位\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* 獲取索引為 i 節點的左子節點的索引 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* 獲取索引為 i 節點的右子節點的索引 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* 獲取索引為 i 節點的父節點的索引 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* 層序走訪 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // 直接走訪陣列\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* 深度優先走訪 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // 若為空位，則返回\n    if abt.val(i) == nil {\n        return\n    }\n    // 前序走訪\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // 中序走訪\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // 後序走訪\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* 前序走訪 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* 中序走訪 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* 後序走訪 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* 建構子 */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* 串列容量 */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    func val(i: Int) -&gt; Int? {\n        // 若索引越界，則返回 null ，代表空位\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // 直接走訪陣列\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* 深度優先走訪 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // 若為空位，則返回\n        guard let val = val(i: i) else {\n            return\n        }\n        // 前序走訪\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // 中序走訪\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // 後序走訪\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* 前序走訪 */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* 中序走訪 */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* 後序走訪 */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* 建構子 */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* 串列容量 */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    val(i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // 向下整除\n    }\n\n    /* 層序走訪 */\n    levelOrder() {\n        let res = [];\n        // 直接走訪陣列\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    #dfs(i, order, res) {\n        // 若為空位，則返回\n        if (this.val(i) === null) return;\n        // 前序走訪\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中序走訪\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後序走訪\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 前序走訪 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* 建構子 */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* 串列容量 */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    val(i: number): number | null {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // 向下整除\n    }\n\n    /* 層序走訪 */\n    levelOrder(): number[] {\n        let res = [];\n        // 直接走訪陣列\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // 若為空位，則返回\n        if (this.val(i) === null) return;\n        // 前序走訪\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中序走訪\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後序走訪\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 前序走訪 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* 建構子 */\n  ArrayBinaryTree(this._tree);\n\n  /* 串列容量 */\n  int size() {\n    return _tree.length;\n  }\n\n  /* 獲取索引為 i 節點的值 */\n  int? val(int i) {\n    // 若索引越界，則返回 null ，代表空位\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* 獲取索引為 i 節點的左子節點的索引 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* 獲取索引為 i 節點的右子節點的索引 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* 獲取索引為 i 節點的父節點的索引 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* 層序走訪 */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* 深度優先走訪 */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // 若為空位，則返回\n    if (val(i) == null) {\n      return;\n    }\n    // 前序走訪\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // 中序走訪\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // 後序走訪\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* 前序走訪 */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* 中序走訪 */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* 後序走訪 */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* 陣列表示下的二元樹類別 */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* 建構子 */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* 串列容量 */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // 若索引越界，則返回 None ，代表空位\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* 深度優先走訪 */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // 前序走訪\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // 中序走訪\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // 後序走訪\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* 前序走訪 */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* 中序走訪 */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* 後序走訪 */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* 陣列表示下的二元樹結構體 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* 建構子 */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* 析構函式 */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* 串列容量 */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* 獲取索引為 i 節點的值 */\nint val(ArrayBinaryTree *abt, int i) {\n    // 若索引越界，則返回 INT_MAX ，代表空位\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* 層序走訪 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // 直接走訪陣列\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* 深度優先走訪 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // 若為空位，則返回\n    if (val(abt, i) == INT_MAX)\n        return;\n    // 前序走訪\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // 中序走訪\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // 後序走訪\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* 前序走訪 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 中序走訪 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 後序走訪 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* 串列容量 */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    fun _val(i: Int): Int? {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // 直接走訪陣列\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* 深度優先走訪 */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // 若為空位，則返回\n        if (_val(i) == null)\n            return\n        // 前序走訪\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // 中序走訪\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // 後序走訪\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* 前序走訪 */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* 中序走訪 */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* 後序走訪 */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### 陣列表示下的二元樹類別 ###\nclass ArrayBinaryTree\n  ### 建構子 ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### 串列容量 ###\n  def size\n    @tree.length\n  end\n\n  ### 獲取索引為 i 節點的值 ###\n  def val(i)\n    # 若索引越界，則返回 nil ，代表空位\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### 獲取索引為 i 節點的左子節點的索引 ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### 獲取索引為 i 節點的右子節點的索引 ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### 獲取索引為 i 節點的父節點的索引 ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### 層序走訪 ###\n  def level_order\n    @res = []\n\n    # 直接走訪陣列\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### 深度優先走訪 ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # 前序走訪\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # 中序走訪\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # 後序走訪\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### 前序走訪 ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### 中序走訪 ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### 後序走訪 ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   優點與侷限性","text":"<p>二元樹的陣列表示主要有以下優點。</p> <ul> <li>陣列儲存在連續的記憶體空間中，對快取友好，訪問與走訪速度較快。</li> <li>不需要儲存指標，比較節省空間。</li> <li>允許隨機訪問節點。</li> </ul> <p>然而，陣列表示也存在一些侷限性。</p> <ul> <li>陣列儲存需要連續記憶體空間，因此不適合儲存資料量過大的樹。</li> <li>增刪節點需要透過陣列插入與刪除操作實現，效率較低。</li> <li>當二元樹中存在大量 <code>None</code> 時，陣列中包含的節點資料比重較低，空間利用率較低。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL 樹 *","text":"<p>在“二元搜尋樹”章節中我們提到，在多次插入和刪除操作後，二元搜尋樹可能退化為鏈結串列。在這種情況下，所有操作的時間複雜度將從 \\(O(\\log n)\\) 劣化為 \\(O(n)\\) 。</p> <p>如圖 7-24 所示，經過兩次刪除節點操作，這棵二元搜尋樹便會退化為鏈結串列。</p> <p></p> <p> 圖 7-24   AVL 樹在刪除節點後發生退化 </p> <p>再例如，在圖 7-25 所示的完美二元樹中插入兩個節點後，樹將嚴重向左傾斜，查詢操作的時間複雜度也隨之劣化。</p> <p></p> <p> 圖 7-25   AVL 樹在插入節點後發生退化 </p> <p>1962 年 G. M. Adelson-Velsky 和 E. M. Landis 在論文“An algorithm for the organization of information”中提出了 AVL 樹。論文中詳細描述了一系列操作，確保在持續新增和刪除節點後，AVL 樹不會退化，從而使得各種操作的時間複雜度保持在 \\(O(\\log n)\\) 級別。換句話說，在需要頻繁進行增刪查改操作的場景中，AVL 樹能始終保持高效的資料操作效能，具有很好的應用價值。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl","level":2,"title":"7.5.1   AVL 樹常見術語","text":"<p>AVL 樹既是二元搜尋樹，也是平衡二元樹，同時滿足這兩類二元樹的所有性質，因此是一種平衡二元搜尋樹（balanced binary search tree）。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   節點高度","text":"<p>由於 AVL 樹的相關操作需要獲取節點高度，因此我們需要為節點類別新增 <code>height</code> 變數：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL 樹節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # 節點值\n        self.height: int = 0                # 節點高度\n        self.left: TreeNode | None = None   # 左子節點引用\n        self.right: TreeNode | None = None  # 右子節點引用\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nstruct TreeNode {\n    int val{};          // 節點值\n    int height = 0;     // 節點高度\n    TreeNode *left{};   // 左子節點\n    TreeNode *right{};  // 右子節點\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    public int val;        // 節點值\n    public int height;     // 節點高度\n    public TreeNode left;  // 左子節點\n    public TreeNode right; // 右子節點\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode(int? x) {\n    public int? val = x;    // 節點值\n    public int height;      // 節點高度\n    public TreeNode? left;  // 左子節點引用\n    public TreeNode? right; // 右子節點引用\n}\n</code></pre> <pre><code>/* AVL 樹節點結構體 */\ntype TreeNode struct {\n    Val    int       // 節點值\n    Height int       // 節點高度\n    Left   *TreeNode // 左子節點引用\n    Right  *TreeNode // 右子節點引用\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    var val: Int // 節點值\n    var height: Int // 節點高度\n    var left: TreeNode? // 左子節點\n    var right: TreeNode? // 右子節點\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    val; // 節點值\n    height; //節點高度\n    left; // 左子節點指標\n    right; // 右子節點指標\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    val: number;            // 節點值\n    height: number;         // 節點高度\n    left: TreeNode | null;  // 左子節點指標\n    right: TreeNode | null; // 右子節點指標\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n  int val;         // 節點值\n  int height;      // 節點高度\n  TreeNode? left;  // 左子節點\n  TreeNode? right; // 右子節點\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL 樹節點結構體 */\nstruct TreeNode {\n    val: i32,                               // 節點值\n    height: i32,                            // 節點高度\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子節點\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子節點\n}\n\nimpl TreeNode {\n    /* 建構子 */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點結構體 */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* 建構子 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode(val _val: Int) {  // 節點值\n    val height: Int = 0          // 節點高度\n    val left: TreeNode? = null   // 左子節點\n    val right: TreeNode? = null  // 右子節點\n}\n</code></pre> <pre><code>### AVL 樹節點類別 ###\nclass TreeNode\n  attr_accessor :val    # 節點值\n  attr_accessor :height # 節點高度\n  attr_accessor :left   # 左子節點引用\n  attr_accessor :right  # 右子節點引用\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>“節點高度”是指從該節點到它的最遠葉節點的距離，即所經過的“邊”的數量。需要特別注意的是，葉節點的高度為 \\(0\\) ，而空節點的高度為 \\(-1\\) 。我們將建立兩個工具函式，分別用於獲取和更新節點的高度：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"獲取節點高度\"\"\"\n    # 空節點高度為 -1 ，葉節點高度為 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"更新節點高度\"\"\"\n    # 節點高度等於最高子樹高度 + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* 獲取節點高度 */\nint height(TreeNode *node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode *node) {\n    // 節點高度等於最高子樹高度 + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* 獲取節點高度 */\nint height(TreeNode node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* 獲取節點高度 */\nint Height(TreeNode? node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid UpdateHeight(TreeNode node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* 獲取節點高度 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* 更新節點高度 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // 節點高度等於最高子樹高度 + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* 獲取節點高度 */\nfunc height(node: TreeNode?) -&gt; Int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    node?.height ?? -1\n}\n\n/* 更新節點高度 */\nfunc updateHeight(node: TreeNode?) {\n    // 節點高度等於最高子樹高度 + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* 獲取節點高度 */\nheight(node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node === null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\n#updateHeight(node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* 獲取節點高度 */\nheight(node: TreeNode): number {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node === null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nupdateHeight(node: TreeNode): void {\n    // 節點高度等於最高子樹高度 + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* 獲取節點高度 */\nint height(TreeNode? node) {\n  // 空節點高度為 -1 ，葉節點高度為 0\n  return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode? node) {\n  // 節點高度等於最高子樹高度 + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* 獲取節點高度 */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* 更新節點高度 */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // 節點高度等於最高子樹高度 + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 獲取節點高度 */\nint height(TreeNode *node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // 節點高度等於最高子樹高度 + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* 獲取節點高度 */\nfun height(node: TreeNode?): Int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node?.height ?: -1\n}\n\n/* 更新節點高度 */\nfun updateHeight(node: TreeNode?) {\n    // 節點高度等於最高子樹高度 + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### 獲取節點高度 ###\ndef height(node)\n  # 空節點高度為 -1 ，葉節點高度為 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### 更新節點高度 ###\ndef update_height(node)\n  # 節點高度等於最高子樹高度 + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   節點平衡因子","text":"<p>節點的平衡因子（balance factor）定義為節點左子樹的高度減去右子樹的高度，同時規定空節點的平衡因子為 \\(0\\) 。我們同樣將獲取節點平衡因子的功能封裝成函式，方便後續使用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"獲取平衡因子\"\"\"\n    # 空節點平衡因子為 0\n    if node is None:\n        return 0\n    # 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode *node) {\n    // 空節點平衡因子為 0\n    if (node == nullptr)\n        return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode node) {\n    // 空節點平衡因子為 0\n    if (node == null)\n        return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* 獲取平衡因子 */\nint BalanceFactor(TreeNode? node) {\n    // 空節點平衡因子為 0\n    if (node == null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* 獲取平衡因子 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // 空節點平衡因子為 0\n    if node == nil {\n        return 0\n    }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* 獲取平衡因子 */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // 空節點平衡因子為 0\n    guard let node = node else { return 0 }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* 獲取平衡因子 */\nbalanceFactor(node) {\n    // 空節點平衡因子為 0\n    if (node === null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* 獲取平衡因子 */\nbalanceFactor(node: TreeNode): number {\n    // 空節點平衡因子為 0\n    if (node === null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode? node) {\n  // 空節點平衡因子為 0\n  if (node == null) return 0;\n  // 節點平衡因子 = 左子樹高度 - 右子樹高度\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* 獲取平衡因子 */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // 空節點平衡因子為 0\n        None =&gt; 0,\n        // 節點平衡因子 = 左子樹高度 - 右子樹高度\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode *node) {\n    // 空節點平衡因子為 0\n    if (node == NULL) {\n        return 0;\n    }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* 獲取平衡因子 */\nfun balanceFactor(node: TreeNode?): Int {\n    // 空節點平衡因子為 0\n    if (node == null) return 0\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### 獲取平衡因子 ###\ndef balance_factor(node)\n  # 空節點平衡因子為 0\n  return 0 if node.nil?\n\n  # 節點平衡因子 = 左子樹高度 - 右子樹高度\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>設平衡因子為 \\(f\\) ，則一棵 AVL 樹的任意節點的平衡因子皆滿足 \\(-1 \\le f \\le 1\\) 。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl","level":2,"title":"7.5.2   AVL 樹旋轉","text":"<p>AVL 樹的特點在於“旋轉”操作，它能夠在不影響二元樹的中序走訪序列的前提下，使失衡節點重新恢復平衡。換句話說，旋轉操作既能保持“二元搜尋樹”的性質，也能使樹重新變為“平衡二元樹”。</p> <p>我們將平衡因子絕對值 \\(&gt; 1\\) 的節點稱為“失衡節點”。根據節點失衡情況的不同，旋轉操作分為四種：右旋、左旋、先右旋後左旋、先左旋後右旋。下面詳細介紹這些旋轉操作。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   右旋","text":"<p>如圖 7-26 所示，節點下方為平衡因子。從底至頂看，二元樹中首個失衡節點是“節點 3”。我們關注以該失衡節點為根節點的子樹，將該節點記為 <code>node</code> ，其左子節點記為 <code>child</code> ，執行“右旋”操作。完成右旋後，子樹恢復平衡，並且仍然保持二元搜尋樹的性質。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-26   右旋操作步驟 </p> <p>如圖 7-27 所示，當節點 <code>child</code> 有右子節點（記為 <code>grand_child</code> ）時，需要在右旋中新增一步：將 <code>grand_child</code> 作為 <code>node</code> 的左子節點。</p> <p></p> <p> 圖 7-27   有 grand_child 的右旋操作 </p> <p>“向右旋轉”是一種形象化的說法，實際上需要透過修改節點指標來實現，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"右旋操作\"\"\"\n    child = node.left\n    grand_child = child.right\n    # 以 child 為原點，將 node 向右旋轉\n    child.right = node\n    node.left = grand_child\n    # 更新節點高度\n    self.update_height(node)\n    self.update_height(child)\n    # 返回旋轉後子樹的根節點\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 右旋操作 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // 以 child 為原點，將 node 向右旋轉\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 右旋操作 */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 右旋操作 */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 右旋操作 */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // 以 child 為原點，將 node 向右旋轉\n    child.Right = node\n    node.Left = grandChild\n    // 更新節點高度\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 右旋操作 */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // 以 child 為原點，將 node 向右旋轉\n    child?.right = node\n    node?.left = grandChild\n    // 更新節點高度\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 右旋操作 */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 右旋操作 */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 右旋操作 */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // 以 child 為原點，將 node 向右旋轉\n  child.right = node;\n  node.left = grandChild;\n  // 更新節點高度\n  updateHeight(node);\n  updateHeight(child);\n  // 返回旋轉後子樹的根節點\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 右旋操作 */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // 以 child 為原點，將 node 向右旋轉\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // 更新節點高度\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 返回旋轉後子樹的根節點\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 右旋操作 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // 以 child 為原點，將 node 向右旋轉\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 右旋操作 */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node\n    node.left = grandChild\n    // 更新節點高度\n    updateHeight(node)\n    updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 右旋操作 ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # 以 child 為原點，將 node 向右旋轉\n  child.right = node\n  node.left = grand_child\n  # 更新節點高度\n  update_height(node)\n  update_height(child)\n  # 返回旋轉後子樹的根節點\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   左旋","text":"<p>相應地，如果考慮上述失衡二元樹的“映象”，則需要執行圖 7-28 所示的“左旋”操作。</p> <p></p> <p> 圖 7-28   左旋操作 </p> <p>同理，如圖 7-29 所示，當節點 <code>child</code> 有左子節點（記為 <code>grand_child</code> ）時，需要在左旋中新增一步：將 <code>grand_child</code> 作為 <code>node</code> 的右子節點。</p> <p></p> <p> 圖 7-29   有 grand_child 的左旋操作 </p> <p>可以觀察到，右旋和左旋操作在邏輯上是映象對稱的，它們分別解決的兩種失衡情況也是對稱的。基於對稱性，我們只需將右旋的實現程式碼中的所有的 <code>left</code> 替換為 <code>right</code> ，將所有的 <code>right</code> 替換為 <code>left</code> ，即可得到左旋的實現程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"左旋操作\"\"\"\n    child = node.right\n    grand_child = child.left\n    # 以 child 為原點，將 node 向左旋轉\n    child.left = node\n    node.right = grand_child\n    # 更新節點高度\n    self.update_height(node)\n    self.update_height(child)\n    # 返回旋轉後子樹的根節點\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 左旋操作 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // 以 child 為原點，將 node 向左旋轉\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 左旋操作 */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 左旋操作 */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 左旋操作 */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // 以 child 為原點，將 node 向左旋轉\n    child.Left = node\n    node.Right = grandChild\n    // 更新節點高度\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 左旋操作 */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // 以 child 為原點，將 node 向左旋轉\n    child?.left = node\n    node?.right = grandChild\n    // 更新節點高度\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 左旋操作 */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 左旋操作 */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 左旋操作 */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // 以 child 為原點，將 node 向左旋轉\n  child.left = node;\n  node.right = grandChild;\n  // 更新節點高度\n  updateHeight(node);\n  updateHeight(child);\n  // 返回旋轉後子樹的根節點\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 左旋操作 */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // 以 child 為原點，將 node 向左旋轉\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // 更新節點高度\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 返回旋轉後子樹的根節點\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 左旋操作 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // 以 child 為原點，將 node 向左旋轉\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 左旋操作 */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node\n    node.right = grandChild\n    // 更新節點高度\n    updateHeight(node)\n    updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 左旋操作 ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # 以 child 為原點，將 node 向左旋轉\n  child.left = node\n  node.right = grand_child\n  # 更新節點高度\n  update_height(node)\n  update_height(child)\n  # 返回旋轉後子樹的根節點\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   先左旋後右旋","text":"<p>對於圖 7-30 中的失衡節點 3 ，僅使用左旋或右旋都無法使子樹恢復平衡。此時需要先對 <code>child</code> 執行“左旋”，再對 <code>node</code> 執行“右旋”。</p> <p></p> <p> 圖 7-30   先左旋後右旋 </p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   先右旋後左旋","text":"<p>如圖 7-31 所示，對於上述失衡二元樹的映象情況，需要先對 <code>child</code> 執行“右旋”，再對 <code>node</code> 執行“左旋”。</p> <p></p> <p> 圖 7-31   先右旋後左旋 </p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   旋轉的選擇","text":"<p>圖 7-32 展示的四種失衡情況與上述案例逐個對應，分別需要採用右旋、先左旋後右旋、先右旋後左旋、左旋的操作。</p> <p></p> <p> 圖 7-32   AVL 樹的四種旋轉情況 </p> <p>如下表所示，我們透過判斷失衡節點的平衡因子以及較高一側子節點的平衡因子的正負號，來確定失衡節點屬於圖 7-32 中的哪種情況。</p> <p> 表 7-3   四種旋轉情況的選擇條件 </p> 失衡節點的平衡因子 子節點的平衡因子 應採用的旋轉方法 \\(&gt; 1\\) （左偏樹） \\(\\geq 0\\) 右旋 \\(&gt; 1\\) （左偏樹） \\(&lt;0\\) 先左旋後右旋 \\(&lt; -1\\) （右偏樹） \\(\\leq 0\\) 左旋 \\(&lt; -1\\) （右偏樹） \\(&gt;0\\) 先右旋後左旋 <p>為了便於使用，我們將旋轉操作封裝成一個函式。有了這個函式，我們就能對各種失衡情況進行旋轉，使失衡節點重新恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"執行旋轉操作，使該子樹重新恢復平衡\"\"\"\n    # 獲取節點 node 的平衡因子\n    balance_factor = self.balance_factor(node)\n    # 左偏樹\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # 右旋\n            return self.right_rotate(node)\n        else:\n            # 先左旋後右旋\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # 右偏樹\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # 左旋\n            return self.left_rotate(node)\n        else:\n            # 先右旋後左旋\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # 平衡樹，無須旋轉，直接返回\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode *rotate(TreeNode *node) {\n    // 獲取節點 node 的平衡因子\n    int _balanceFactor = balanceFactor(node);\n    // 左偏樹\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode rotate(TreeNode node) {\n    // 獲取節點 node 的平衡因子\n    int balanceFactor = balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode? Rotate(TreeNode? node) {\n    // 獲取節點 node 的平衡因子\n    int balanceFactorInt = BalanceFactor(node);\n    // 左偏樹\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // 右旋\n            return RightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // 左旋\n            return LeftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // 獲取節點 node 的平衡因子\n    // Go 推薦短變數，這裡 bf 指代 t.balanceFactor\n    bf := t.balanceFactor(node)\n    // 左偏樹\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // 右旋\n            return t.rightRotate(node)\n        } else {\n            // 先左旋後右旋\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // 右偏樹\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // 左旋\n            return t.leftRotate(node)\n        } else {\n            // 先右旋後左旋\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // 獲取節點 node 的平衡因子\n    let balanceFactor = balanceFactor(node: node)\n    // 左偏樹\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // 右旋\n            return rightRotate(node: node)\n        } else {\n            // 先左旋後右旋\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // 右偏樹\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // 左旋\n            return leftRotate(node: node)\n        } else {\n            // 先右旋後左旋\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\n#rotate(node) {\n    // 獲取節點 node 的平衡因子\n    const balanceFactor = this.balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return this.#rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return this.#leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nrotate(node: TreeNode): TreeNode {\n    // 獲取節點 node 的平衡因子\n    const balanceFactor = this.balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return this.rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return this.leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode? rotate(TreeNode? node) {\n  // 獲取節點 node 的平衡因子\n  int factor = balanceFactor(node);\n  // 左偏樹\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // 右旋\n      return rightRotate(node);\n    } else {\n      // 先左旋後右旋\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // 右偏樹\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // 左旋\n      return leftRotate(node);\n    } else {\n      // 先右旋後左旋\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // 平衡樹，無須旋轉，直接返回\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // 獲取節點 node 的平衡因子\n    let balance_factor = Self::balance_factor(node.clone());\n    // 左偏樹\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // 右旋\n            Self::right_rotate(Some(node))\n        } else {\n            // 先左旋後右旋\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // 右偏樹\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // 左旋\n            Self::left_rotate(Some(node))\n        } else {\n            // 先右旋後左旋\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // 平衡樹，無須旋轉，直接返回\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode *rotate(TreeNode *node) {\n    // 獲取節點 node 的平衡因子\n    int bf = balanceFactor(node);\n    // 左偏樹\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfun rotate(node: TreeNode): TreeNode {\n    // 獲取節點 node 的平衡因子\n    val balanceFactor = balanceFactor(node)\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node)\n        } else {\n            // 先左旋後右旋\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node)\n        } else {\n            // 先右旋後左旋\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 執行旋轉操作，使該子樹重新恢復平衡 ###\ndef rotate(node)\n  # 獲取節點 node 的平衡因子\n  balance_factor = balance_factor(node)\n  # 左遍樹\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # 右旋\n      return right_rotate(node)\n    else\n      # 先左旋後右旋\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # 右遍樹\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # 左旋\n      return left_rotate(node)\n    else\n      # 先右旋後左旋\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # 平衡樹，無須旋轉，直接返回\n  node\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl","level":2,"title":"7.5.3   AVL 樹常用操作","text":"","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   插入節點","text":"<p>AVL 樹的節點插入操作與二元搜尋樹在主體上類似。唯一的區別在於，在 AVL 樹中插入節點後，從該節點到根節點的路徑上可能會出現一系列失衡節點。因此，我們需要從這個節點開始，自底向上執行旋轉操作，使所有失衡節點恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"插入節點\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"遞迴插入節點（輔助方法）\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. 查詢插入位置並插入節點\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # 重複節點不插入，直接返回\n        return node\n    # 更新節點高度\n    self.update_height(node)\n    # 2. 執行旋轉操作，使該子樹重新恢復平衡\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* 插入節點 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // 重複節點不插入，直接返回\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 插入節點 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // 重複節點不插入，直接返回\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 插入節點 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // 重複節點不插入，直接返回\n    UpdateHeight(node);  // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = Rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 插入節點 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* 遞迴插入節點（輔助函式） */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // 重複節點不插入，直接返回\n        return node\n    }\n    // 更新節點高度\n    t.updateHeight(node)\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = t.rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 插入節點 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* 遞迴插入節點（輔助方法） */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // 重複節點不插入，直接返回\n    }\n    updateHeight(node: node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node: node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 插入節點 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // 重複節點不插入，直接返回\n    this.#updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.#rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 插入節點 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // 重複節點不插入，直接返回\n    }\n    this.updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 插入節點 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. 查詢插入位置並插入節點 */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // 重複節點不插入，直接返回\n  updateHeight(node); // 更新節點高度\n  /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n  node = rotate(node);\n  // 返回子樹的根節點\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 插入節點 */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 查詢插入位置並插入節點 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // 重複節點不插入，直接返回\n                }\n            }\n            Self::update_height(Some(node.clone())); // 更新節點高度\n\n            /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n            node = Self::rotate(Some(node)).unwrap();\n            // 返回子樹的根節點\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 插入節點 */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* 遞迴插入節點（輔助函式） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // 重複節點不插入，直接返回\n        return node;\n    }\n    // 更新節點高度\n    updateHeight(node);\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 插入節點 */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* 遞迴插入節點（輔助方法） */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. 查詢插入位置並插入節點 */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // 重複節點不插入，直接返回\n    updateHeight(node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 插入節點 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### 遞迴插入節點（輔助方法）###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. 查詢插入位置並插入節點\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # 重複節點不插入，直接返回\n    return node\n  end\n  # 更新節點高度\n  update_height(node)\n  # 2. 執行旋轉操作，使該子樹重新恢復平衡\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_2","level":3,"title":"2.   刪除節點","text":"<p>類似地，在二元搜尋樹的刪除節點方法的基礎上，需要從底至頂執行旋轉操作，使所有失衡節點恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"刪除節點\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"遞迴刪除節點（輔助方法）\"\"\"\n    if node is None:\n        return None\n    # 1. 查詢節點並刪除\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # 子節點數量 = 0 ，直接刪除 node 並返回\n            if child is None:\n                return None\n            # 子節點數量 = 1 ，直接刪除 node\n            else:\n                node = child\n        else:\n            # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # 更新節點高度\n    self.update_height(node)\n    # 2. 執行旋轉操作，使該子樹重新恢復平衡\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // 子節點數量 = 1 ，直接刪除 node\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 刪除節點 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = Rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 刪除節點 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* 遞迴刪除節點（輔助函式） */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. 查詢節點並刪除 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // 子節點數量 = 0 ，直接刪除 node 並返回\n                return nil\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // 更新節點高度\n    t.updateHeight(node)\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = t.rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 刪除節點 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. 查詢節點並刪除 */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if child == nil {\n                return nil\n            }\n            // 子節點數量 = 1 ，直接刪除 node\n            else {\n                node = child\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node: node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 刪除節點 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child === null) return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.#rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 刪除節點 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child === null) {\n                return null;\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. 查詢節點並刪除 */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // 子節點數量 = 0 ，直接刪除 node 並返回\n      if (child == null)\n        return null;\n      // 子節點數量 = 1 ，直接刪除 node\n      else\n        node = child;\n    } else {\n      // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // 更新節點高度\n  /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n  node = rotate(node);\n  // 返回子樹的根節點\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 刪除節點 */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 查詢節點並刪除 */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // 子節點數量 = 0 ，直接刪除 node 並返回\n                    None =&gt; {\n                        return None;\n                    }\n                    // 子節點數量 = 1 ，直接刪除 node\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // 更新節點高度\n\n            /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n            node = Self::rotate(Some(node)).unwrap();\n            // 返回子樹的根節點\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 刪除節點 */\n// 由於引入了 stdio.h ，此處無法使用 remove 關鍵詞\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* 遞迴刪除節點（輔助函式） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // 更新節點高度\n    updateHeight(node);\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 刪除節點 */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. 查詢節點並刪除 */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 刪除節點 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### 遞迴刪除節點（輔助方法）###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. 查詢節點並刪除\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # 子節點數量 = 0 ，直接刪除 node 並返回\n      return if child.nil?\n      # 子節點數量 = 1 ，直接刪除 node\n      node = child\n    else\n      # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # 更新節點高度\n  update_height(node)\n  # 2. 執行旋轉操作，使該子樹重新恢復平衡\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   查詢節點","text":"<p>AVL 樹的節點查詢操作與二元搜尋樹一致，在此不再贅述。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl","level":2,"title":"7.5.4   AVL 樹典型應用","text":"<ul> <li>組織和儲存大型資料，適用於高頻查詢、低頻增刪的場景。</li> <li>用於構建資料庫中的索引系統。</li> <li>紅黑樹也是一種常見的平衡二元搜尋樹。相較於 AVL 樹，紅黑樹的平衡條件更寬鬆，插入與刪除節點所需的旋轉操作更少，節點增刪操作的平均效率更高。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   二元搜尋樹","text":"<p>如圖 7-16 所示，二元搜尋樹（binary search tree）滿足以下條件。</p> <ol> <li>對於根節點，左子樹中所有節點的值 \\(&lt;\\) 根節點的值 \\(&lt;\\) 右子樹中所有節點的值。</li> <li>任意節點的左、右子樹也是二元搜尋樹，即同樣滿足條件 <code>1.</code> 。</li> </ol> <p></p> <p> 圖 7-16   二元搜尋樹 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   二元搜尋樹的操作","text":"<p>我們將二元搜尋樹封裝為一個類別 <code>BinarySearchTree</code> ，並宣告一個成員變數 <code>root</code> ，指向樹的根節點。</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   查詢節點","text":"<p>給定目標節點值 <code>num</code> ，可以根據二元搜尋樹的性質來查詢。如圖 7-17 所示，我們宣告一個節點 <code>cur</code> ，從二元樹的根節點 <code>root</code> 出發，迴圈比較節點值 <code>cur.val</code> 和 <code>num</code> 之間的大小關係。</p> <ul> <li>若 <code>cur.val &lt; num</code> ，說明目標節點在 <code>cur</code> 的右子樹中，因此執行 <code>cur = cur.right</code> 。</li> <li>若 <code>cur.val &gt; num</code> ，說明目標節點在 <code>cur</code> 的左子樹中，因此執行 <code>cur = cur.left</code> 。</li> <li>若 <code>cur.val = num</code> ，說明找到目標節點，跳出迴圈並返回該節點。</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-17   二元搜尋樹查詢節點示例 </p> <p>二元搜尋樹的查詢操作與二分搜尋演算法的工作原理一致，都是每輪排除一半情況。迴圈次數最多為二元樹的高度，當二元樹平衡時，使用 \\(O(\\log n)\\) 時間。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"查詢節點\"\"\"\n    cur = self._root\n    # 迴圈查詢，越過葉節點後跳出\n    while cur is not None:\n        # 目標節點在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 目標節點在 cur 的左子樹中\n        elif cur.val &gt; num:\n            cur = cur.left\n        # 找到目標節點，跳出迴圈\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* 查詢節點 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 目標節點在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* 查詢節點 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 查詢節點 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* 查詢節點 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // 迴圈查詢，越過葉節點後跳出\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // 目標節點在 cur 的右子樹中\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // 目標節點在 cur 的左子樹中\n            node = node.Left\n        } else {\n            // 找到目標節點，跳出迴圈\n            break\n        }\n    }\n    // 返回目標節點\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 查詢節點 */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 目標節點在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 目標節點在 cur 的左子樹中\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // 找到目標節點，跳出迴圈\n        else {\n            break\n        }\n    }\n    // 返回目標節點\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* 查詢節點 */\nsearch(num) {\n    let cur = this.root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num) cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 查詢節點 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num) cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 查詢節點 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 目標節點在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 目標節點在 cur 的左子樹中\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // 找到目標節點，跳出迴圈\n    else\n      break;\n  }\n  // 返回目標節點\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 查詢節點 */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 目標節點在 cur 的右子樹中\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // 目標節點在 cur 的左子樹中\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // 找到目標節點，跳出迴圈\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // 返回目標節點\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* 查詢節點 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // 目標節點在 cur 的右子樹中\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // 目標節點在 cur 的左子樹中\n            cur = cur-&gt;left;\n        } else {\n            // 找到目標節點，跳出迴圈\n            break;\n        }\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 查詢節點 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 目標節點在 cur 的左子樹中\n        else if (cur._val &gt; num)\n            cur.left\n        // 找到目標節點，跳出迴圈\n        else\n            break\n    }\n    // 返回目標節點\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### 查詢節點 ###\ndef search(num)\n  cur = @root\n\n  # 迴圈查詢，越過葉節點後跳出\n  while !cur.nil?\n    # 目標節點在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 目標節點在 cur 的左子樹中\n    elsif cur.val &gt; num\n      cur = cur.left\n    # 找到目標節點，跳出迴圈\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   插入節點","text":"<p>給定一個待插入元素 <code>num</code> ，為了保持二元搜尋樹“左子樹 &lt; 根節點 &lt; 右子樹”的性質，插入操作流程如圖 7-18 所示。</p> <ol> <li>查詢插入位置：與查詢操作相似，從根節點出發，根據當前節點值和 <code>num</code> 的大小關係迴圈向下搜尋，直到越過葉節點（走訪至 <code>None</code> ）時跳出迴圈。</li> <li>在該位置插入節點：初始化節點 <code>num</code> ，將該節點置於 <code>None</code> 的位置。</li> </ol> <p></p> <p> 圖 7-18   在二元搜尋樹中插入節點 </p> <p>在程式碼實現中，需要注意以下兩點。</p> <ul> <li>二元搜尋樹不允許存在重複節點，否則將違反其定義。因此，若待插入節點在樹中已存在，則不執行插入，直接返回。</li> <li>為了實現插入節點，我們需要藉助節點 <code>pre</code> 儲存上一輪迴圈的節點。這樣在走訪至 <code>None</code> 時，我們可以獲取到其父節點，從而完成節點插入操作。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"插入節點\"\"\"\n    # 若樹為空，則初始化根節點\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # 迴圈查詢，越過葉節點後跳出\n    cur, pre = self._root, None\n    while cur is not None:\n        # 找到重複節點，直接返回\n        if cur.val == num:\n            return\n        pre = cur\n        # 插入位置在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 插入位置在 cur 的左子樹中\n        else:\n            cur = cur.left\n    # 插入節點\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* 插入節點 */\nvoid insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 找到重複節點，直接返回\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur-&gt;left;\n    }\n    // 插入節點\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* 插入節點 */\nvoid insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 插入節點\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 插入節點 */\nvoid Insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n\n    // 插入節點\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* 插入節點 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // 若樹為空，則初始化根節點\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // 待插入節點之前的節點位置\n    var pre *TreeNode = nil\n    // 迴圈查詢，越過葉節點後跳出\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // 插入節點\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 插入節點 */\nfunc insert(num: Int) {\n    // 若樹為空，則初始化根節點\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 找到重複節點，直接返回\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // 插入位置在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 插入位置在 cur 的左子樹中\n        else {\n            cur = cur?.left\n        }\n    }\n    // 插入節點\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* 插入節點 */\ninsert(num) {\n    // 若樹為空，則初始化根節點\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到重複節點，直接返回\n        if (cur.val === num) return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 插入節點\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 插入節點 */\ninsert(num: number): void {\n    // 若樹為空，則初始化根節點\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到重複節點，直接返回\n        if (cur.val === num) return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 插入節點\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 插入節點 */\nvoid insert(int _num) {\n  // 若樹為空，則初始化根節點\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 找到重複節點，直接返回\n    if (cur.val == _num) return;\n    pre = cur;\n    // 插入位置在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 插入位置在 cur 的左子樹中\n    else\n      cur = cur.left;\n  }\n  // 插入節點\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 插入節點 */\npub fn insert(&amp;mut self, num: i32) {\n    // 若樹為空，則初始化根節點\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 找到重複節點，直接返回\n            Ordering::Equal =&gt; return,\n            // 插入位置在 cur 的右子樹中\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 插入位置在 cur 的左子樹中\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 插入節點\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* 插入節點 */\nvoid insert(BinarySearchTree *bst, int num) {\n    // 若樹為空，則初始化根節點\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        // 找到重複節點，直接返回\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 插入位置在 cur 的右子樹中\n            cur = cur-&gt;right;\n        } else {\n            // 插入位置在 cur 的左子樹中\n            cur = cur-&gt;left;\n        }\n    }\n    // 插入節點\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 插入節點 */\nfun insert(num: Int) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur._val == num)\n            return\n        pre = cur\n        // 插入位置在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 插入位置在 cur 的左子樹中\n        else\n            cur.left\n    }\n    // 插入節點\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### 插入節點 ###\ndef insert(num)\n  # 若樹為空，則初始化根節點\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # 迴圈查詢，越過葉節點後跳出\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 找到重複節點，直接返回\n    return if cur.val == num\n\n    pre = cur\n    # 插入位置在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 插入位置在 cur 的左子樹中\n    else\n      cur = cur.left\n    end\n  end\n\n  # 插入節點\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>與查詢節點相同，插入節點使用 \\(O(\\log n)\\) 時間。</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   刪除節點","text":"<p>先在二元樹中查詢到目標節點，再將其刪除。與插入節點類似，我們需要保證在刪除操作完成後，二元搜尋樹的“左子樹 &lt; 根節點 &lt; 右子樹”的性質仍然滿足。因此，我們根據目標節點的子節點數量，分 0、1 和 2 三種情況，執行對應的刪除節點操作。</p> <p>如圖 7-19 所示，當待刪除節點的度為 \\(0\\) 時，表示該節點是葉節點，可以直接刪除。</p> <p></p> <p> 圖 7-19   在二元搜尋樹中刪除節點（度為 0 ） </p> <p>如圖 7-20 所示，當待刪除節點的度為 \\(1\\) 時，將待刪除節點替換為其子節點即可。</p> <p></p> <p> 圖 7-20   在二元搜尋樹中刪除節點（度為 1 ） </p> <p>當待刪除節點的度為 \\(2\\) 時，我們無法直接刪除它，而需要使用一個節點替換該節點。由於要保持二元搜尋樹“左子樹 \\(&lt;\\) 根節點 \\(&lt;\\) 右子樹”的性質，因此這個節點可以是右子樹的最小節點或左子樹的最大節點。</p> <p>假設我們選擇右子樹的最小節點（中序走訪的下一個節點），則刪除操作流程如圖 7-21 所示。</p> <ol> <li>找到待刪除節點在“中序走訪序列”中的下一個節點，記為 <code>tmp</code> 。</li> <li>用 <code>tmp</code> 的值覆蓋待刪除節點的值，並在樹中遞迴刪除節點 <code>tmp</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-21   在二元搜尋樹中刪除節點（度為 2 ） </p> <p>刪除節點操作同樣使用 \\(O(\\log n)\\) 時間，其中查詢待刪除節點需要 \\(O(\\log n)\\) 時間，獲取中序走訪後繼節點需要 \\(O(\\log n)\\) 時間。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"刪除節點\"\"\"\n    # 若樹為空，直接提前返回\n    if self._root is None:\n        return\n    # 迴圈查詢，越過葉節點後跳出\n    cur, pre = self._root, None\n    while cur is not None:\n        # 找到待刪除節點，跳出迴圈\n        if cur.val == num:\n            break\n        pre = cur\n        # 待刪除節點在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 待刪除節點在 cur 的左子樹中\n        else:\n            cur = cur.left\n    # 若無待刪除節點，則直接返回\n    if cur is None:\n        return\n\n    # 子節點數量 = 0 or 1\n    if cur.left is None or cur.right is None:\n        # 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        child = cur.left or cur.right\n        # 刪除節點 cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # 若刪除節點為根節點，則重新指定根節點\n            self._root = child\n    # 子節點數量 = 2\n    else:\n        # 獲取中序走訪中 cur 的下一個節點\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # 遞迴刪除節點 tmp\n        self.remove(tmp.val)\n        # 用 tmp 覆蓋 cur\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* 刪除節點 */\nvoid remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur-&gt;left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == nullptr)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n        // 釋放記憶體\n        delete cur;\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // 遞迴刪除節點 tmp\n        remove(tmp-&gt;val);\n        // 用 tmp 覆蓋 cur\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* 刪除節點 */\nvoid remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        remove(tmp.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 刪除節點 */\nvoid Remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        TreeNode? child = cur.left ?? cur.right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        Remove(tmp.val!.Value);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* 刪除節點 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // 若樹為空，直接提前返回\n    if cur == nil {\n        return\n    }\n    // 待刪除節點之前的節點位置\n    var pre *TreeNode = nil\n    // 迴圈查詢，越過葉節點後跳出\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // 待刪除節點在右子樹中\n            cur = cur.Right\n        } else {\n            // 待刪除節點在左子樹中\n            cur = cur.Left\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur == nil {\n        return\n    }\n    // 子節點數為 0 或 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // 取出待刪除節點的子節點\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // 刪除節點 cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            bst.root = child\n        }\n        // 子節點數為 2\n    } else {\n        // 獲取中序走訪中待刪除節點 cur 的下一個節點\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // 遞迴刪除節點 tmp\n        bst.remove(tmp.Val.(int))\n        // 用 tmp 覆蓋 cur\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 刪除節點 */\nfunc remove(num: Int) {\n    // 若樹為空，直接提前返回\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 找到待刪除節點，跳出迴圈\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // 待刪除節點在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 待刪除節點在 cur 的左子樹中\n        else {\n            cur = cur?.left\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur == nil {\n        return\n    }\n    // 子節點數量 = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        let child = cur?.left ?? cur?.right\n        // 刪除節點 cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // 遞迴刪除節點 tmp\n        remove(num: tmp!.val)\n        // 用 tmp 覆蓋 cur\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* 刪除節點 */\nremove(num) {\n    // 若樹為空，直接提前返回\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val === num) break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur === null) return;\n    // 子節點數量 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        const child = cur.left !== null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            this.root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        this.remove(tmp.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 刪除節點 */\nremove(num: number): void {\n    // 若樹為空，直接提前返回\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val === num) break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur === null) return;\n    // 子節點數量 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            this.root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // 遞迴刪除節點 tmp\n        this.remove(tmp!.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 刪除節點 */\nvoid remove(int _num) {\n  // 若樹為空，直接提前返回\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 找到待刪除節點，跳出迴圈\n    if (cur.val == _num) break;\n    pre = cur;\n    // 待刪除節點在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 待刪除節點在 cur 的左子樹中\n    else\n      cur = cur.left;\n  }\n  // 若無待刪除節點，直接返回\n  if (cur == null) return;\n  // 子節點數量 = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n    TreeNode? child = cur.left ?? cur.right;\n    // 刪除節點 cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // 若刪除節點為根節點，則重新指定根節點\n      _root = child;\n    }\n  } else {\n    // 子節點數量 = 2\n    // 獲取中序走訪中 cur 的下一個節點\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // 遞迴刪除節點 tmp\n    remove(tmp.val);\n    // 用 tmp 覆蓋 cur\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 刪除節點 */\npub fn remove(&amp;mut self, num: i32) {\n    // 若樹為空，直接提前返回\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 找到待刪除節點，跳出迴圈\n            Ordering::Equal =&gt; break,\n            // 待刪除節點在 cur 的右子樹中\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 待刪除節點在 cur 的左子樹中\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // 子節點數量 = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // 刪除節點 cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // 若刪除節點為根節點，則重新指定根節點\n                self.root = child;\n            }\n        }\n        // 子節點數量 = 2\n        (Some(_), Some(_)) =&gt; {\n            // 獲取中序走訪中 cur 的下一個節點\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // 遞迴刪除節點 tmp\n            self.remove(tmp_val);\n            // 用 tmp 覆蓋 cur\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* 刪除節點 */\n// 由於引入了 stdio.h ，此處無法使用 remove 關鍵詞\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // 若樹為空，直接提前返回\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 待刪除節點在 root 的右子樹中\n            cur = cur-&gt;right;\n        } else {\n            // 待刪除節點在 root 的左子樹中\n            cur = cur-&gt;left;\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == NULL)\n        return;\n    // 判斷待刪除節點是否存在子節點\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* 子節點數量 = 0 or 1 */\n        // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // 刪除節點 cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // 釋放記憶體\n        free(cur);\n    } else {\n        /* 子節點數量 = 2 */\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // 遞迴刪除節點 tmp\n        removeItem(bst, tmp-&gt;val);\n        // 用 tmp 覆蓋 cur\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 刪除節點 */\nfun remove(num: Int) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur._val == num)\n            break\n        pre = cur\n        // 待刪除節點在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur.left\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child\n        }\n        // 子節點數量 = 2\n    } else {\n        // 獲取中序走訪中 cur 的下一個節點\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // 遞迴刪除節點 tmp\n        remove(tmp._val)\n        // 用 tmp 覆蓋 cur\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### 刪除節點 ###\ndef remove(num)\n  # 若樹為空，直接提前返回\n  return if @root.nil?\n\n  # 迴圈查詢，越過葉節點後跳出\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 找到待刪除節點，跳出迴圈\n    break if cur.val == num\n\n    pre = cur\n    # 待刪除節點在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 待刪除節點在 cur 的左子樹中\n    else\n      cur = cur.left\n    end\n  end\n  # 若無待刪除節點，則直接返回\n  return if cur.nil?\n\n  # 子節點數量 = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # 當子節點數量 = 0 / 1 時， child = null / 該子節點\n    child = cur.left || cur.right\n    # 刪除節點 cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # 若刪除節點為根節點，則重新指定根節點\n      @root = child\n    end\n  # 子節點數量 = 2\n  else\n    # 獲取中序走訪中 cur 的下一個節點\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # 遞迴刪除節點 tmp\n    remove(tmp.val)\n    # 用 tmp 覆蓋 cur\n    cur.val = tmp.val\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   中序走訪有序","text":"<p>如圖 7-22 所示，二元樹的中序走訪遵循“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”的走訪順序，而二元搜尋樹滿足“左子節點 \\(&lt;\\) 根節點 \\(&lt;\\) 右子節點”的大小關係。</p> <p>這意味著在二元搜尋樹中進行中序走訪時，總是會優先走訪下一個最小節點，從而得出一個重要性質：二元搜尋樹的中序走訪序列是升序的。</p> <p>利用中序走訪升序的性質，我們在二元搜尋樹中獲取有序資料僅需 \\(O(n)\\) 時間，無須進行額外的排序操作，非常高效。</p> <p></p> <p> 圖 7-22   二元搜尋樹的中序走訪序列 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   二元搜尋樹的效率","text":"<p>給定一組資料，我們考慮使用陣列或二元搜尋樹儲存。觀察表 7-2 ，二元搜尋樹的各項操作的時間複雜度都是對數階，具有穩定且高效的效能。只有在高頻新增、低頻查詢刪除資料的場景下，陣列比二元搜尋樹的效率更高。</p> <p> 表 7-2   陣列與搜尋樹的效率對比 </p> 無序陣列 二元搜尋樹 查詢元素 \\(O(n)\\) \\(O(\\log n)\\) 插入元素 \\(O(1)\\) \\(O(\\log n)\\) 刪除元素 \\(O(n)\\) \\(O(\\log n)\\) <p>在理想情況下，二元搜尋樹是“平衡”的，這樣就可以在 \\(\\log n\\) 輪迴圈內查詢任意節點。</p> <p>然而，如果我們在二元搜尋樹中不斷地插入和刪除節點，可能導致二元樹退化為圖 7-23 所示的鏈結串列，這時各種操作的時間複雜度也會退化為 \\(O(n)\\) 。</p> <p></p> <p> 圖 7-23   二元搜尋樹退化 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   二元搜尋樹常見應用","text":"<ul> <li>用作系統中的多級索引，實現高效的查詢、插入、刪除操作。</li> <li>作為某些搜尋演算法的底層資料結構。</li> <li>用於儲存資料流，以保持其有序狀態。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   二元樹","text":"<p>二元樹（binary tree）是一種非線性資料結構，代表“祖先”與“後代”之間的派生關係，體現了“一分為二”的分治邏輯。與鏈結串列類似，二元樹的基本單元是節點，每個節點包含值、左子節點引用和右子節點引用。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"二元樹節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # 節點值\n        self.left: TreeNode | None = None  # 左子節點引用\n        self.right: TreeNode | None = None # 右子節點引用\n</code></pre> <pre><code>/* 二元樹節點結構體 */\nstruct TreeNode {\n    int val;          // 節點值\n    TreeNode *left;   // 左子節點指標\n    TreeNode *right;  // 右子節點指標\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    int val;         // 節點值\n    TreeNode left;   // 左子節點引用\n    TreeNode right;  // 右子節點引用\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode(int? x) {\n    public int? val = x;    // 節點值\n    public TreeNode? left;  // 左子節點引用\n    public TreeNode? right; // 右子節點引用\n}\n</code></pre> <pre><code>/* 二元樹節點結構體 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* 建構子 */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // 左子節點指標\n        Right: nil, // 右子節點指標\n        Val:   v,   // 節點值\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    var val: Int // 節點值\n    var left: TreeNode? // 左子節點引用\n    var right: TreeNode? // 右子節點引用\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    val; // 節點值\n    left; // 左子節點指標\n    right; // 右子節點指標\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.left = left === undefined ? null : left; // 左子節點引用\n        this.right = right === undefined ? null : right; // 右子節點引用\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n  int val;         // 節點值\n  TreeNode? left;  // 左子節點引用\n  TreeNode? right; // 右子節點引用\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 二元樹節點結構體 */\nstruct TreeNode {\n    val: i32,                               // 節點值\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子節點引用\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子節點引用\n}\n\nimpl TreeNode {\n    /* 建構子 */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點結構體 */\ntypedef struct TreeNode {\n    int val;                // 節點值\n    int height;             // 節點高度\n    struct TreeNode *left;  // 左子節點指標\n    struct TreeNode *right; // 右子節點指標\n} TreeNode;\n\n/* 建構子 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode(val _val: Int) {  // 節點值\n    val left: TreeNode? = null   // 左子節點引用\n    val right: TreeNode? = null  // 右子節點引用\n}\n</code></pre> <pre><code>### 二元樹節點類別 ###\nclass TreeNode\n  attr_accessor :val    # 節點值\n  attr_accessor :left   # 左子節點引用\n  attr_accessor :right  # 右子節點引用\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>每個節點都有兩個引用（指標），分別指向左子節點（left-child node）和右子節點（right-child node），該節點被稱為這兩個子節點的父節點（parent node）。當給定一個二元樹的節點時，我們將該節點的左子節點及其以下節點形成的樹稱為該節點的左子樹（left subtree），同理可得右子樹（right subtree）。</p> <p>在二元樹中，除葉節點外，其他所有節點都包含子節點和非空子樹。如圖 7-1 所示，如果將“節點 2”視為父節點，則其左子節點和右子節點分別是“節點 4”和“節點 5”，左子樹是“節點 4 及其以下節點形成的樹”，右子樹是“節點 5 及其以下節點形成的樹”。</p> <p></p> <p> 圖 7-1   父節點、子節點、子樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   二元樹常見術語","text":"<p>二元樹的常用術語如圖 7-2 所示。</p> <ul> <li>根節點（root node）：位於二元樹頂層的節點，沒有父節點。</li> <li>葉節點（leaf node）：沒有子節點的節點，其兩個指標均指向 <code>None</code> 。</li> <li>邊（edge）：連線兩個節點的線段，即節點引用（指標）。</li> <li>節點所在的層（level）：從頂至底遞增，根節點所在層為 1 。</li> <li>節點的度（degree）：節點的子節點的數量。在二元樹中，度的取值範圍是 0、1、2 。</li> <li>二元樹的高度（height）：從根節點到最遠葉節點所經過的邊的數量。</li> <li>節點的深度（depth）：從根節點到該節點所經過的邊的數量。</li> <li>節點的高度（height）：從距離該節點最遠的葉節點到該節點所經過的邊的數量。</li> </ul> <p></p> <p> 圖 7-2   二元樹的常用術語 </p> <p>Tip</p> <p>請注意，我們通常將“高度”和“深度”定義為“經過的邊的數量”，但有些題目或教材可能會將其定義為“經過的節點的數量”。在這種情況下，高度和深度都需要加 1 。</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   二元樹基本操作","text":"","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   初始化二元樹","text":"<p>與鏈結串列類似，首先初始化節點，然後構建引用（指標）。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 初始化二元樹\n# 初始化節點\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// 初始化節點\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* 初始化二元樹 */\n// 初始化節點\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// 構建節點之間的引用（指標）\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// 初始化節點\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* 初始化二元樹 */\n// 初始化節點\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* 初始化二元樹 */\n// 初始化節點\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// 初始化節點\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// 構建節點之間的引用（指標）\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// 構建節點之間的引用（指標）\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// 初始化節點\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># 初始化二元樹\n# 初始化節點\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   插入與刪除節點","text":"<p>與鏈結串列類似，在二元樹中插入與刪除節點可以透過修改指標來實現。圖 7-3 給出了一個示例。</p> <p></p> <p> 圖 7-3   在二元樹中插入與刪除節點 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 插入與刪除節點\np = TreeNode(0)\n# 在 n1 -&gt; n2 中間插入節點 P\nn1.left = p\np.left = n2\n# 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* 插入與刪除節點 */\nTreeNode* P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1-&gt;left = P;\nP-&gt;left = n2;\n// 刪除節點 P\nn1-&gt;left = n2;\n// 釋放記憶體\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* 插入與刪除節點 */\nTreeNode P = new(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* 插入與刪除節點 */\n// 在 n1 -&gt; n2 中間插入節點 P\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// 刪除節點 P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P\nP.left = n2\n// 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* 插入與刪除節點 */\nlet P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* 插入與刪除節點 */\nconst P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* 插入與刪除節點 */\nTreeNode P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// 刪除節點 p\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* 插入與刪除節點 */\nTreeNode *P = newTreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1-&gt;left = P;\nP-&gt;left = n2;\n// 刪除節點 P\nn1-&gt;left = n2;\n// 釋放記憶體\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P\nP.left = n2\n// 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># 插入與刪除節點\n_p = TreeNode.new(0)\n# 在 n1 -&gt; n2 中間插入節點 _p\nn1.left = _p\n_p.left = n2\n# 刪除節點\nn1.left = n2\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>需要注意的是，插入節點可能會改變二元樹的原有邏輯結構，而刪除節點通常意味著刪除該節點及其所有子樹。因此，在二元樹中，插入與刪除通常是由一套操作配合完成的，以實現有實際意義的操作。</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   常見二元樹型別","text":"","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   完美二元樹","text":"<p>如圖 7-4 所示，完美二元樹（perfect binary tree）所有層的節點都被完全填滿。在完美二元樹中，葉節點的度為 \\(0\\) ，其餘所有節點的度都為 \\(2\\) ；若樹的高度為 \\(h\\) ，則節點總數為 \\(2^{h+1} - 1\\) ，呈現標準的指數級關係，反映了自然界中常見的細胞分裂現象。</p> <p>Tip</p> <p>請注意，在中文社群中，完美二元樹常被稱為滿二元樹。</p> <p></p> <p> 圖 7-4   完美二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   完全二元樹","text":"<p>如圖 7-5 所示，完全二元樹（complete binary tree）僅允許最底層的節點不完全填滿，且最底層的節點必須從左至右依次連續填充。請注意，完美二元樹也是一棵完全二元樹。</p> <p></p> <p> 圖 7-5   完全二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   完滿二元樹","text":"<p>如圖 7-6 所示，完滿二元樹（full binary tree）除了葉節點之外，其餘所有節點都有兩個子節點。</p> <p></p> <p> 圖 7-6   完滿二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   平衡二元樹","text":"<p>如圖 7-7 所示，平衡二元樹（balanced binary tree）中任意節點的左子樹和右子樹的高度之差的絕對值不超過 1 。</p> <p></p> <p> 圖 7-7   平衡二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   二元樹的退化","text":"<p>圖 7-8 展示了二元樹的理想結構與退化結構。當二元樹的每層節點都被填滿時，達到“完美二元樹”；而當所有節點都偏向一側時，二元樹退化為“鏈結串列”。</p> <ul> <li>完美二元樹是理想情況，可以充分發揮二元樹“分治”的優勢。</li> <li>鏈結串列則是另一個極端，各項操作都變為線性操作，時間複雜度退化至 \\(O(n)\\) 。</li> </ul> <p></p> <p> 圖 7-8   二元樹的最佳結構與最差結構 </p> <p>如表 7-1 所示，在最佳結構和最差結構下，二元樹的葉節點數量、節點總數、高度等達到極大值或極小值。</p> <p> 表 7-1   二元樹的最佳結構與最差結構 </p> 完美二元樹 鏈結串列 第 \\(i\\) 層的節點數量 \\(2^{i-1}\\) \\(1\\) 高度為 \\(h\\) 的樹的葉節點數量 \\(2^h\\) \\(1\\) 高度為 \\(h\\) 的樹的節點總數 \\(2^{h+1} - 1\\) \\(h + 1\\) 節點總數為 \\(n\\) 的樹的高度 \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   二元樹走訪","text":"<p>從物理結構的角度來看，樹是一種基於鏈結串列的資料結構，因此其走訪方式是透過指標逐個訪問節點。然而，樹是一種非線性資料結構，這使得走訪樹比走訪鏈結串列更加複雜，需要藉助搜尋演算法來實現。</p> <p>二元樹常見的走訪方式包括層序走訪、前序走訪、中序走訪和後序走訪等。</p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   層序走訪","text":"<p>如圖 7-9 所示，層序走訪（level-order traversal）從頂部到底部逐層走訪二元樹，並在每一層按照從左到右的順序訪問節點。</p> <p>層序走訪本質上屬於廣度優先走訪（breadth-first traversal），也稱廣度優先搜尋（breadth-first search, BFS），它體現了一種“一圈一圈向外擴展”的逐層走訪方式。</p> <p></p> <p> 圖 7-9   二元樹的層序走訪 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   程式碼實現","text":"<p>廣度優先走訪通常藉助“佇列”來實現。佇列遵循“先進先出”的規則，而廣度優先走訪則遵循“逐層推進”的規則，兩者背後的思想是一致的。實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"層序走訪\"\"\"\n    # 初始化佇列，加入根節點\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # 初始化一個串列，用於儲存走訪序列\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # 隊列出隊\n        res.append(node.val)  # 儲存節點值\n        if node.left is not None:\n            queue.append(node.left)  # 左子節點入列\n        if node.right is not None:\n            queue.append(node.right)  # 右子節點入列\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* 層序走訪 */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // 初始化佇列，加入根節點\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // 初始化一個串列，用於儲存走訪序列\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // 隊列出隊\n        vec.push_back(node-&gt;val); // 儲存節點值\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // 左子節點入列\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // 右子節點入列\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* 層序走訪 */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // 初始化佇列，加入根節點\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // 初始化一個串列，用於儲存走訪序列\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // 隊列出隊\n        list.add(node.val);           // 儲存節點值\n        if (node.left != null)\n            queue.offer(node.left);   // 左子節點入列\n        if (node.right != null)\n            queue.offer(node.right);  // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* 層序走訪 */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // 初始化佇列，加入根節點\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // 初始化一個串列，用於儲存走訪序列\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // 隊列出隊\n        list.Add(node.val!.Value);       // 儲存節點值\n        if (node.left != null)\n            queue.Enqueue(node.left);    // 左子節點入列\n        if (node.right != null)\n            queue.Enqueue(node.right);   // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* 層序走訪 */\nfunc levelOrder(root *TreeNode) []any {\n    // 初始化佇列，加入根節點\n    queue := list.New()\n    queue.PushBack(root)\n    // 初始化一個切片，用於儲存走訪序列\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // 隊列出隊\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // 儲存節點值\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // 左子節點入列\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // 右子節點入列\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* 層序走訪 */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // 初始化佇列，加入根節點\n    var queue: [TreeNode] = [root]\n    // 初始化一個串列，用於儲存走訪序列\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // 隊列出隊\n        list.append(node.val) // 儲存節點值\n        if let left = node.left {\n            queue.append(left) // 左子節點入列\n        }\n        if let right = node.right {\n            queue.append(right) // 右子節點入列\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* 層序走訪 */\nfunction levelOrder(root) {\n    // 初始化佇列，加入根節點\n    const queue = [root];\n    // 初始化一個串列，用於儲存走訪序列\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // 隊列出隊\n        list.push(node.val); // 儲存節點值\n        if (node.left) queue.push(node.left); // 左子節點入列\n        if (node.right) queue.push(node.right); // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* 層序走訪 */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // 初始化佇列，加入根節點\n    const queue = [root];\n    // 初始化一個串列，用於儲存走訪序列\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // 隊列出隊\n        list.push(node.val); // 儲存節點值\n        if (node.left) {\n            queue.push(node.left); // 左子節點入列\n        }\n        if (node.right) {\n            queue.push(node.right); // 右子節點入列\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* 層序走訪 */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // 初始化佇列，加入根節點\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // 初始化一個串列，用於儲存走訪序列\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // 隊列出隊\n    res.add(node!.val); // 儲存節點值\n    if (node.left != null) queue.add(node.left); // 左子節點入列\n    if (node.right != null) queue.add(node.right); // 右子節點入列\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* 層序走訪 */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // 初始化佇列，加入根節點\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // 初始化一個串列，用於儲存走訪序列\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // 隊列出隊\n        vec.push(node.borrow().val); // 儲存節點值\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // 左子節點入列\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // 右子節點入列\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* 層序走訪 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* 輔助佇列 */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* 輔助佇列 */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // 佇列指標\n    front = 0, rear = 0;\n    // 加入根節點\n    queue[rear++] = root;\n    // 初始化一個串列，用於儲存走訪序列\n    /* 輔助陣列 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // 陣列指標\n    index = 0;\n    while (front &lt; rear) {\n        // 隊列出隊\n        node = queue[front++];\n        // 儲存節點值\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // 左子節點入列\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // 右子節點入列\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // 更新陣列長度的值\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // 釋放輔助陣列空間\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* 層序走訪 */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // 初始化佇列，加入根節點\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // 初始化一個串列，用於儲存走訪序列\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // 隊列出隊\n        list.add(node?._val!!)       // 儲存節點值\n        if (node.left != null)\n            queue.offer(node.left)   // 左子節點入列\n        if (node.right != null)\n            queue.offer(node.right)  // 右子節點入列\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### 層序走訪 ###\ndef level_order(root)\n  # 初始化佇列，加入根節點\n  queue = [root]\n  # 初始化一個串列，用於儲存走訪序列\n  res = []\n  while !queue.empty?\n    node = queue.shift # 隊列出隊\n    res &lt;&lt; node.val # 儲存節點值\n    queue &lt;&lt; node.left unless node.left.nil? # 左子節點入列\n    queue &lt;&lt; node.right unless node.right.nil? # 右子節點入列\n  end\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   複雜度分析","text":"<ul> <li>時間複雜度為 \\(O(n)\\) ：所有節點被訪問一次，使用 \\(O(n)\\) 時間，其中 \\(n\\) 為節點數量。</li> <li>空間複雜度為 \\(O(n)\\) ：在最差情況下，即滿二元樹時，走訪到最底層之前，佇列中最多同時存在 \\((n + 1) / 2\\) 個節點，佔用 \\(O(n)\\) 空間。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   前序、中序、後序走訪","text":"<p>相應地，前序、中序和後序走訪都屬於深度優先走訪（depth-first traversal），也稱深度優先搜尋（depth-first search, DFS），它體現了一種“先走到盡頭，再回溯繼續”的走訪方式。</p> <p>圖 7-10 展示了對二元樹進行深度優先走訪的工作原理。深度優先走訪就像是繞著整棵二元樹的外圍“走”一圈，在每個節點都會遇到三個位置，分別對應前序走訪、中序走訪和後序走訪。</p> <p></p> <p> 圖 7-10   二元搜尋樹的前序、中序、後序走訪 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   程式碼實現","text":"<p>深度優先搜尋通常基於遞迴實現：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"前序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"中序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"後序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* 前序走訪 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* 中序走訪 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* 後序走訪 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* 前序走訪 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* 中序走訪 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* 後序走訪 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* 前序走訪 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* 中序走訪 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* 後序走訪 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* 前序走訪 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* 前序走訪 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* 前序走訪 */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 中序走訪 */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 後序走訪 */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* 前序走訪 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* 中序走訪 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* 後序走訪 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### 前序走訪 ###\ndef pre_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### 中序走訪 ###\ndef in_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### 後序走訪 ###\ndef post_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>深度優先搜尋也可以基於迭代實現，有興趣的讀者可以自行研究。</p> <p>圖 7-11 展示了前序走訪二元樹的遞迴過程，其可分為“遞”和“迴”兩個逆向的部分。</p> <ol> <li>“遞”表示開啟新方法，程式在此過程中訪問下一個節點。</li> <li>“迴”表示函式返回，代表當前節點已經訪問完畢。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 7-11   前序走訪的遞迴過程 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   複雜度分析","text":"<ul> <li>時間複雜度為 \\(O(n)\\) ：所有節點被訪問一次，使用 \\(O(n)\\) 時間。</li> <li>空間複雜度為 \\(O(n)\\) ：在最差情況下，即樹退化為鏈結串列時，遞迴深度達到 \\(n\\) ，系統佔用 \\(O(n)\\) 堆疊幀空間。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   小結","text":"","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>二元樹是一種非線性資料結構，體現“一分為二”的分治邏輯。每個二元樹節點包含一個值以及兩個指標，分別指向其左子節點和右子節點。</li> <li>對於二元樹中的某個節點，其左（右）子節點及其以下形成的樹被稱為該節點的左（右）子樹。</li> <li>二元樹的相關術語包括根節點、葉節點、層、度、邊、高度和深度等。</li> <li>二元樹的初始化、節點插入和節點刪除操作與鏈結串列操作方法類似。</li> <li>常見的二元樹型別有完美二元樹、完全二元樹、完滿二元樹和平衡二元樹。完美二元樹是最理想的狀態，而鏈結串列是退化後的最差狀態。</li> <li>二元樹可以用陣列表示，方法是將節點值和空位按層序走訪順序排列，並根據父節點與子節點之間的索引對映關係來實現指標。</li> <li>二元樹的層序走訪是一種廣度優先搜尋方法，它體現了“一圈一圈向外擴展”的逐層走訪方式，通常透過佇列來實現。</li> <li>前序、中序、後序走訪皆屬於深度優先搜尋，它們體現了“先走到盡頭，再回溯繼續”的走訪方式，通常使用遞迴來實現。</li> <li>二元搜尋樹是一種高效的元素查詢資料結構，其查詢、插入和刪除操作的時間複雜度均為 \\(O(\\log n)\\) 。當二元搜尋樹退化為鏈結串列時，各項時間複雜度會劣化至 \\(O(n)\\) 。</li> <li>AVL 樹，也稱平衡二元搜尋樹，它透過旋轉操作確保在不斷插入和刪除節點後樹仍然保持平衡。</li> <li>AVL 樹的旋轉操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或刪除節點後，AVL 樹會從底向頂執行旋轉操作，使樹重新恢復平衡。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：對於只有一個節點的二元樹，樹的高度和根節點的深度都是 \\(0\\) 嗎？</p> <p>是的，因為高度和深度通常定義為“經過的邊的數量”。</p> <p>Q：二元樹中的插入與刪除一般由一套操作配合完成，這裡的“一套操作”指什麼呢？可以理解為資源的子節點的資源釋放嗎？</p> <p>拿二元搜尋樹來舉例，刪除節點操作要分三種情況處理，其中每種情況都需要進行多個步驟的節點操作。</p> <p>Q：為什麼 DFS 走訪二元樹有前、中、後三種順序，分別有什麼用呢？</p> <p>與順序和逆序走訪陣列類似，前序、中序、後序走訪是三種二元樹走訪方法，我們可以使用它們得到一個特定順序的走訪結果。例如在二元搜尋樹中，由於節點大小滿足 <code>左子節點值 &lt; 根節點值 &lt; 右子節點值</code> ，因此我們只要按照“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”的優先順序走訪樹，就可以獲得有序的節點序列。</p> <p>Q：右旋操作是處理失衡節點 <code>node</code>、<code>child</code>、<code>grand_child</code> 之間的關係，那 <code>node</code> 的父節點和 <code>node</code> 原來的連線不需要維護嗎？右旋操作後豈不是斷掉了？</p> <p>我們需要從遞迴的視角來看這個問題。右旋操作 <code>right_rotate(root)</code> 傳入的是子樹的根節點，最終 <code>return child</code> 返回旋轉之後的子樹的根節點。子樹的根節點和其父節點的連線是在該函式返回後完成的，不屬於右旋操作的維護範圍。</p> <p>Q：在 C++ 中，函式被劃分到 <code>private</code> 和 <code>public</code> 中，這方面有什麼考量嗎？為什麼要將 <code>height()</code> 函式和 <code>updateHeight()</code> 函式分別放在 <code>public</code> 和 <code>private</code> 中呢？</p> <p>主要看方法的使用範圍，如果方法只在類別內部使用，那麼就設計為 <code>private</code> 。例如，使用者單獨呼叫 <code>updateHeight()</code> 是沒有意義的，它只是插入、刪除操作中的一步。而 <code>height()</code> 是訪問節點高度，類似於 <code>vector.size()</code> ，因此設定成 <code>public</code> 以便使用。</p> <p>Q：如何從一組輸入資料構建一棵二元搜尋樹？根節點的選擇是不是很重要？</p> <p>是的，構建樹的方法已在二元搜尋樹程式碼中的 <code>build_tree()</code> 方法中給出。至於根節點的選擇，我們通常會將輸入資料排序，然後將中點元素作為根節點，再遞迴地構建左右子樹。這樣做可以最大程度保證樹的平衡性。</p> <p>Q：在 Java 中，字串對比是否一定要用 <code>equals()</code> 方法？</p> <p>在 Java 中，對於基本資料型別，<code>==</code> 用於對比兩個變數的值是否相等。對於引用型別，兩種符號的工作原理是不同的。</p> <ul> <li><code>==</code> ：用來比較兩個變數是否指向同一個物件，即它們在記憶體中的位置是否相同。</li> <li><code>equals()</code>：用來對比兩個物件的值是否相等。</li> </ul> <p>因此，如果要對比值，我們應該使用 <code>equals()</code> 。然而，透過 <code>String a = \"hi\"; String b = \"hi\";</code> 初始化的字串都儲存在字串常數池中，它們指向同一個物件，因此也可以用 <code>a == b</code> 來比較兩個字串的內容。</p> <p>Q：廣度優先走訪到最底層之前，佇列中的節點數量是 \\(2^h\\) 嗎？</p> <p>是的，例如高度 \\(h = 2\\) 的滿二元樹，其節點總數 \\(n = 7\\) ，則底層節點數量 \\(4 = 2^h = (n + 1) / 2\\) 。</p>","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]}]}
\ No newline at end of file
+{"config":{"separator":"[\\s\\-_,:!=\\[\\]()\\\\\"`/]+|\\.(?!\\d)"},"items":[{"location":"chapter_appendix/","level":1,"title":"第 16 章   附錄","text":"","path":["第 16 章 &nbsp; 附錄"],"tags":[]},{"location":"chapter_appendix/#_1","level":2,"title":"本章內容","text":"<ul> <li>16.1   程式設計環境安裝</li> <li>16.2   一起參與創作</li> <li>16.3   術語表</li> </ul>","path":["第 16 章 &nbsp; 附錄"],"tags":[]},{"location":"chapter_appendix/contribution/","level":1,"title":"16.2   一起參與創作","text":"<p>由於筆者能力有限，書中難免存在一些遺漏和錯誤，請您諒解。如果您發現了筆誤、連結失效、內容缺失、文字歧義、解釋不清晰或行文結構不合理等問題，請協助我們進行修正，以給讀者提供更優質的學習資源。</p> <p>所有撰稿人的 GitHub ID 將在本書倉庫、網頁版和 PDF 版的主頁上進行展示，以感謝他們對開源社群的無私奉獻。</p> <p>開源的魅力</p> <p>紙質圖書的兩次印刷的間隔時間往往較久，內容更新非常不方便。</p> <p>而在本開源書中，內容更迭的時間被縮短至數日甚至幾個小時。</p>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#1","level":3,"title":"1.   內容微調","text":"<p>如圖 16-3 所示，每個頁面的右上角都有“編輯圖示”。您可以按照以下步驟修改文字或程式碼。</p> <ol> <li>點選“編輯圖示”，如果遇到“需要 Fork 此倉庫”的提示，請同意該操作。</li> <li>修改 Markdown 源檔案內容，檢查內容的正確性，並儘量保持排版格式的統一。</li> <li>在頁面底部填寫修改說明，然後點選“Propose file change”按鈕。頁面跳轉後，點選“Create pull request”按鈕即可發起拉取請求。</li> </ol> <p></p> <p> 圖 16-3   頁面編輯按鍵 </p> <p>圖片無法直接修改，需要透過新建 Issue 或評論留言來描述問題，我們會盡快重新繪製並替換圖片。</p>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#2","level":3,"title":"2.   內容創作","text":"<p>如果您有興趣參與此開源專案，包括將程式碼翻譯成其他程式語言、擴展文章內容等，那麼需要實施以下 Pull Request 工作流程。</p> <ol> <li>登入 GitHub ，將本書的程式碼倉庫 Fork 到個人帳號下。</li> <li>進入您的 Fork 倉庫網頁，使用 <code>git clone</code> 命令將倉庫克隆至本地。</li> <li>在本地進行內容創作，並進行完整測試，驗證程式碼的正確性。</li> <li>將本地所做更改 Commit ，然後 Push 至遠端倉庫。</li> <li>重新整理倉庫網頁，點選“Create pull request”按鈕即可發起拉取請求。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/contribution/#3-docker","level":3,"title":"3.   Docker 部署","text":"<p>在 <code>hello-algo</code> 根目錄下，執行以下 Docker 指令碼，即可在 <code>http://localhost:8000</code> 訪問本專案：</p> <pre><code>docker-compose up -d\n</code></pre> <p>使用以下命令即可刪除部署：</p> <pre><code>docker-compose down\n</code></pre>","path":["第 16 章 &nbsp; 附錄","16.2 &nbsp; 一起參與創作"],"tags":[]},{"location":"chapter_appendix/installation/","level":1,"title":"16.1   程式設計環境安裝","text":"","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1611-ide","level":2,"title":"16.1.1   安裝 IDE","text":"<p>推薦使用開源、輕量的 VS Code 作為本地整合開發環境（IDE）。訪問 VS Code 官網，根據作業系統選擇相應版本的 VS Code 進行下載和安裝。</p> <p></p> <p> 圖 16-1   從官網下載 VS Code </p> <p>VS Code 擁有強大的擴展包生態系統，支持大多數程式語言的執行和除錯。以 Python 為例，安裝“Python Extension Pack”擴展包之後，即可進行 Python 程式碼除錯。安裝步驟如圖 16-2 所示。</p> <p></p> <p> 圖 16-2   安裝 VS Code 擴展包 </p>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1612","level":2,"title":"16.1.2   安裝語言環境","text":"","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#1-python","level":3,"title":"1.   Python 環境","text":"<ol> <li>下載並安裝 Miniconda3 ，需要 Python 3.10 或更新版本。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>python</code> ，安裝 Python Extension Pack 。</li> <li>（可選）在命令列輸入 <code>pip install black</code> ，安裝程式碼格式化工具。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#2-cc","level":3,"title":"2.   C/C++ 環境","text":"<ol> <li>Windows 系統需要安裝 MinGW（配置教程）；MacOS 自帶 Clang ，無須安裝。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>c++</code> ，安裝 C/C++ Extension Pack 。</li> <li>（可選）開啟 Settings 頁面，搜尋 <code>Clang_format_fallback Style</code> 程式碼格式化選項，設定為 <code>{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }</code> 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#3-java","level":3,"title":"3.   Java 環境","text":"<ol> <li>下載並安裝 OpenJDK（版本需滿足 &gt; JDK 9）。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>java</code> ，安裝 Extension Pack for Java 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#4-c","level":3,"title":"4.   C# 環境","text":"<ol> <li>下載並安裝 .Net 8.0 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>C# Dev Kit</code> ，安裝 C# Dev Kit （配置教程）。</li> <li>也可使用 Visual Studio（安裝教程）。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#5-go","level":3,"title":"5.   Go 環境","text":"<ol> <li>下載並安裝 go 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>go</code> ，安裝 Go 。</li> <li>按快捷鍵 <code>Ctrl + Shift + P</code> 撥出命令欄，輸入 go ，選擇 <code>Go: Install/Update Tools</code> ，全部勾選並安裝即可。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#6-swift","level":3,"title":"6.   Swift 環境","text":"<ol> <li>下載並安裝 Swift 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>swift</code> ，安裝 Swift for Visual Studio Code 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#7-javascript","level":3,"title":"7.   JavaScript 環境","text":"<ol> <li>下載並安裝 Node.js 。</li> <li>（可選）在 VS Code 的擴充功能市場中搜索 <code>Prettier</code> ，安裝程式碼格式化工具。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#8-typescript","level":3,"title":"8.   TypeScript 環境","text":"<ol> <li>同 JavaScript 環境安裝步驟。</li> <li>安裝 TypeScript Execute (tsx) 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>typescript</code> ，安裝 Pretty TypeScript Errors 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#9-dart","level":3,"title":"9.   Dart 環境","text":"<ol> <li>下載並安裝 Dart 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>dart</code> ，安裝 Dart 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/installation/#10-rust","level":3,"title":"10.   Rust 環境","text":"<ol> <li>下載並安裝 Rust 。</li> <li>在 VS Code 的擴充功能市場中搜索 <code>rust</code> ，安裝 rust-analyzer 。</li> </ol>","path":["第 16 章 &nbsp; 附錄","16.1 &nbsp; 程式設計環境安裝"],"tags":[]},{"location":"chapter_appendix/terminology/","level":1,"title":"16.3   術語表","text":"<p>表 16-1 列出了書中出現的重要術語，值得注意以下幾點。</p> <ul> <li>建議記住名詞的英文叫法，以便閱讀英文文獻。</li> <li>部分名詞在簡體中文和繁體中文下的叫法不同。</li> </ul> <p> 表 16-1   資料結構與演算法的重要名詞 </p> English 簡體中文 繁體中文 algorithm 算法 演算法 data structure 数据结构 資料結構 code 代码 程式碼 file 文件 檔案 function 函数 函式 method 方法 方法 variable 变量 變數 asymptotic complexity analysis 渐近复杂度分析 漸近複雜度分析 time complexity 时间复杂度 時間複雜度 space complexity 空间复杂度 空間複雜度 loop 循环 迴圈 iteration 迭代 迭代 recursion 递归 遞迴 tail recursion 尾递归 尾遞迴 recursion tree 递归树 遞迴樹 big-\\(O\\) notation 大 \\(O\\) 记号 大 \\(O\\) 記號 asymptotic upper bound 渐近上界 漸近上界 sign-magnitude 原码 原碼 1’s complement 反码 一補數 2’s complement 补码 二補數 array 数组 陣列 index 索引 索引 linked list 链表 鏈結串列 linked list node, list node 链表节点 鏈結串列節點 head node 头节点 頭節點 tail node 尾节点 尾節點 list 列表 串列 dynamic array 动态数组 動態陣列 hard disk 硬盘 硬碟 random-access memory (RAM) 内存 記憶體 cache memory 缓存 快取 cache miss 缓存未命中 快取未命中 cache hit rate 缓存命中率 快取命中率 stack 栈 堆疊 top of the stack 栈顶 堆疊頂 bottom of the stack 栈底 堆疊底 queue 队列 佇列 double-ended queue 双向队列 雙向佇列 front of the queue 队首 佇列首 rear of the queue 队尾 佇列尾 hash table 哈希表 雜湊表 hash set 哈希集合 雜湊集合 bucket 桶 桶 hash function 哈希函数 雜湊函式 hash collision 哈希冲突 雜湊衝突 load factor 负载因子 負載因子 separate chaining 链式地址 鏈結位址 open addressing 开放寻址 開放定址 linear probing 线性探测 線性探查 lazy deletion 懒删除 懶刪除 binary tree 二叉树 二元樹 tree node 树节点 樹節點 left-child node 左子节点 左子節點 right-child node 右子节点 右子節點 parent node 父节点 父節點 left subtree 左子树 左子樹 right subtree 右子树 右子樹 root node 根节点 根節點 leaf node 叶节点 葉節點 edge 边 邊 level 层 層 degree 度 度 height 高度 高度 depth 深度 深度 perfect binary tree 完美二叉树 完美二元樹 complete binary tree 完全二叉树 完全二元樹 full binary tree 完满二叉树 完滿二元樹 balanced binary tree 平衡二叉树 平衡二元樹 binary search tree 二叉搜索树 二元搜尋樹 AVL tree AVL 树 AVL 樹 red-black tree 红黑树 紅黑樹 level-order traversal 层序遍历 層序走訪 breadth-first traversal 广度优先遍历 廣度優先走訪 depth-first traversal 深度优先遍历 深度優先走訪 binary search tree 二叉搜索树 二元搜尋樹 balanced binary search tree 平衡二叉搜索树 平衡二元搜尋樹 balance factor 平衡因子 平衡因子 heap 堆 堆積 max heap 大顶堆 大頂堆積 min heap 小顶堆 小頂堆積 priority queue 优先队列 優先佇列 heapify 堆化 堆積化 top-\\(k\\) problem Top-\\(k\\) 问题 Top-\\(k\\) 問題 graph 图 圖 vertex 顶点 頂點 undirected graph 无向图 無向圖 directed graph 有向图 有向圖 connected graph 连通图 連通圖 disconnected graph 非连通图 非連通圖 weighted graph 有权图 有權圖 adjacency 邻接 鄰接 path 路径 路徑 in-degree 入度 入度 out-degree 出度 出度 adjacency matrix 邻接矩阵 鄰接矩陣 adjacency list 邻接表 鄰接表 breadth-first search 广度优先搜索 廣度優先搜尋 depth-first search 深度优先搜索 深度優先搜尋 binary search 二分查找 二分搜尋 searching algorithm 搜索算法 搜尋演算法 sorting algorithm 排序算法 排序演算法 selection sort 选择排序 選擇排序 bubble sort 冒泡排序 泡沫排序 insertion sort 插入排序 插入排序 quick sort 快速排序 快速排序 merge sort 归并排序 合併排序 heap sort 堆排序 堆積排序 bucket sort 桶排序 桶排序 counting sort 计数排序 計數排序 radix sort 基数排序 基數排序 divide and conquer 分治 分治 hanota problem 汉诺塔问题 河內塔問題 backtracking algorithm 回溯算法 回溯演算法 constraint 约束 約束 solution 解 解 state 状态 狀態 pruning 剪枝 剪枝 permutations problem 全排列问题 全排列問題 subset-sum problem 子集和问题 子集合問題 \\(n\\)-queens problem \\(n\\) 皇后问题 \\(n\\) 皇后問題 dynamic programming 动态规划 動態規劃 initial state 初始状态 初始狀態 state-transition equation 状态转移方程 狀態轉移方程 knapsack problem 背包问题 背包問題 edit distance problem 编辑距离问题 編輯距離問題 greedy algorithm 贪心算法 貪婪演算法","path":["第 16 章 &nbsp; 附錄","16.3 &nbsp; 術語表"],"tags":[]},{"location":"chapter_array_and_linkedlist/","level":1,"title":"第 4 章   陣列與鏈結串列","text":"<p>Abstract</p> <p>資料結構的世界如同一堵厚實的磚牆。</p> <p>陣列的磚塊整齊排列，逐個緊貼。鏈結串列的磚塊分散各處，連線的藤蔓自由地穿梭於磚縫之間。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/#_1","level":2,"title":"本章內容","text":"<ul> <li>4.1   陣列</li> <li>4.2   鏈結串列</li> <li>4.3   串列</li> <li>4.4   記憶體與快取 *</li> <li>4.5   小結</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/","level":1,"title":"4.1   陣列","text":"<p>陣列（array）是一種線性資料結構，其將相同型別的元素儲存在連續的記憶體空間中。我們將元素在陣列中的位置稱為該元素的索引（index）。圖 4-1 展示了陣列的主要概念和儲存方式。</p> <p></p> <p> 圖 4-1   陣列定義與儲存方式 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#411","level":2,"title":"4.1.1   陣列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#1","level":3,"title":"1.   初始化陣列","text":"<p>我們可以根據需求選用陣列的兩種初始化方式：無初始值、給定初始值。在未指定初始值的情況下，大多數程式語言會將陣列元素初始化為 \\(0\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code># 初始化陣列\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> array.cpp<pre><code>/* 初始化陣列 */\n// 儲存在堆疊上\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// 儲存在堆積上（需要手動釋放空間）\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n</code></pre> array.java<pre><code>/* 初始化陣列 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n</code></pre> array.cs<pre><code>/* 初始化陣列 */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n</code></pre> array.go<pre><code>/* 初始化陣列 */\nvar arr [5]int\n// 在 Go 中，指定長度時（[5]int）為陣列，不指定長度時（[]int）為切片\n// 由於 Go 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度\n// 為了方便實現擴容 extend() 方法，以下將切片（Slice）看作陣列（Array）\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> array.swift<pre><code>/* 初始化陣列 */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n</code></pre> array.js<pre><code>/* 初始化陣列 */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n</code></pre> array.ts<pre><code>/* 初始化陣列 */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> array.dart<pre><code>/* 初始化陣列 */\nList&lt;int&gt; arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> array.rs<pre><code>/* 初始化陣列 */\nlet arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]\nlet slice: &amp;[i32] = &amp;[0; 5];\n// 在 Rust 中，指定長度時（[i32; 5]）為陣列，不指定長度時（&amp;[i32]）為切片\n// 由於 Rust 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度\n// Vector 是 Rust 一般情況下用作動態陣列的型別\n// 為了方便實現擴容 extend() 方法，以下將 vector 看作陣列（array）\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> array.c<pre><code>/* 初始化陣列 */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n</code></pre> array.kt<pre><code>/* 初始化陣列 */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n</code></pre> array.rb<pre><code># 初始化陣列\narr = Array.new(5, 0)\nnums = [1, 3, 2, 5, 4]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#2","level":3,"title":"2.   訪問元素","text":"<p>陣列元素被儲存在連續的記憶體空間中，這意味著計算陣列元素的記憶體位址非常容易。給定陣列記憶體位址（首元素記憶體位址）和某個元素的索引，我們可以使用圖 4-2 所示的公式計算得到該元素的記憶體位址，從而直接訪問該元素。</p> <p></p> <p> 圖 4-2   陣列元素的記憶體位址計算 </p> <p>觀察圖 4-2 ，我們發現陣列首個元素的索引為 \\(0\\) ，這似乎有些反直覺，因為從 \\(1\\) 開始計數會更自然。但從位址計算公式的角度看，索引本質上是記憶體位址的偏移量。首個元素的位址偏移量是 \\(0\\) ，因此它的索引為 \\(0\\) 是合理的。</p> <p>在陣列中訪問元素非常高效，我們可以在 \\(O(1)\\) 時間內隨機訪問陣列中的任意一個元素。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def random_access(nums: list[int]) -&gt; int:\n    \"\"\"隨機訪問元素\"\"\"\n    # 在區間 [0, len(nums)-1] 中隨機抽取一個數字\n    random_index = random.randint(0, len(nums) - 1)\n    # 獲取並返回隨機元素\n    random_num = nums[random_index]\n    return random_num\n</code></pre> array.cpp<pre><code>/* 隨機訪問元素 */\nint randomAccess(int *nums, int size) {\n    // 在區間 [0, size) 中隨機抽取一個數字\n    int randomIndex = rand() % size;\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.java<pre><code>/* 隨機訪問元素 */\nint randomAccess(int[] nums) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.cs<pre><code>/* 隨機訪問元素 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // 在區間 [0, nums.Length) 中隨機抽取一個數字\n    int randomIndex = random.Next(nums.Length);\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.go<pre><code>/* 隨機訪問元素 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    randomIndex := rand.Intn(len(nums))\n    // 獲取並返回隨機元素\n    randomNum = nums[randomIndex]\n    return\n}\n</code></pre> array.swift<pre><code>/* 隨機訪問元素 */\nfunc randomAccess(nums: [Int]) -&gt; Int {\n    // 在區間 [0, nums.count) 中隨機抽取一個數字\n    let randomIndex = nums.indices.randomElement()!\n    // 獲取並返回隨機元素\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.js<pre><code>/* 隨機訪問元素 */\nfunction randomAccess(nums) {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    const random_index = Math.floor(Math.random() * nums.length);\n    // 獲取並返回隨機元素\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.ts<pre><code>/* 隨機訪問元素 */\nfunction randomAccess(nums: number[]): number {\n    // 在區間 [0, nums.length) 中隨機抽取一個數字\n    const random_index = Math.floor(Math.random() * nums.length);\n    // 獲取並返回隨機元素\n    const random_num = nums[random_index];\n    return random_num;\n}\n</code></pre> array.dart<pre><code>/* 隨機訪問元素 */\nint randomAccess(List&lt;int&gt; nums) {\n  // 在區間 [0, nums.length) 中隨機抽取一個數字\n  int randomIndex = Random().nextInt(nums.length);\n  // 獲取並返回隨機元素\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n</code></pre> array.rs<pre><code>/* 隨機訪問元素 */\nfn random_access(nums: &amp;[i32]) -&gt; i32 {\n    // 在區間 [0, nums.len()) 中隨機抽取一個數字\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // 獲取並返回隨機元素\n    let random_num = nums[random_index];\n    random_num\n}\n</code></pre> array.c<pre><code>/* 隨機訪問元素 */\nint randomAccess(int *nums, int size) {\n    // 在區間 [0, size) 中隨機抽取一個數字\n    int randomIndex = rand() % size;\n    // 獲取並返回隨機元素\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n</code></pre> array.kt<pre><code>/* 隨機訪問元素 */\nfun randomAccess(nums: IntArray): Int {\n    // 在區間 [0, nums.size) 中隨機抽取一個數字\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // 獲取並返回隨機元素\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n</code></pre> array.rb<pre><code>### 隨機訪問元素 ###\ndef random_access(nums)\n  # 在區間 [0, nums.length) 中隨機抽取一個數字\n  random_index = Random.rand(0...nums.length)\n\n  # 獲取並返回隨機元素\n  nums[random_index]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#3","level":3,"title":"3.   插入元素","text":"<p>陣列元素在記憶體中是“緊挨著的”，它們之間沒有空間再存放任何資料。如圖 4-3 所示，如果想在陣列中間插入一個元素，則需要將該元素之後的所有元素都向後移動一位，之後再把元素賦值給該索引。</p> <p></p> <p> 圖 4-3   陣列插入元素示例 </p> <p>值得注意的是，由於陣列的長度是固定的，因此插入一個元素必定會導致陣列尾部元素“丟失”。我們將這個問題的解決方案留在“串列”章節中討論。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def insert(nums: list[int], num: int, index: int):\n    \"\"\"在陣列的索引 index 處插入元素 num\"\"\"\n    # 把索引 index 以及之後的所有元素向後移動一位\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # 將 num 賦給 index 處的元素\n    nums[index] = num\n</code></pre> array.cpp<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int *nums, int size, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.java<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int[] nums, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.cs<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid Insert(int[] nums, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = nums.Length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.go<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunc insert(nums []int, num int, index int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i := len(nums) - 1; i &gt; index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.swift<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.js<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunction insert(nums, num, index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.ts<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfunction insert(nums: number[], num: number, index: number): void {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (let i = nums.length - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.dart<pre><code>/* 在陣列的索引 index 處插入元素 _num */\nvoid insert(List&lt;int&gt; nums, int _num, int index) {\n  // 把索引 index 以及之後的所有元素向後移動一位\n  for (var i = nums.length - 1; i &gt; index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // 將 _num 賦給 index 處元素\n  nums[index] = _num;\n}\n</code></pre> array.rs<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfn insert(nums: &amp;mut [i32], num: i32, index: usize) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.c<pre><code>/* 在陣列的索引 index 處插入元素 num */\nvoid insert(int *nums, int size, int num, int index) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (int i = size - 1; i &gt; index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num;\n}\n</code></pre> array.kt<pre><code>/* 在陣列的索引 index 處插入元素 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // 把索引 index 以及之後的所有元素向後移動一位\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // 將 num 賦給 index 處的元素\n    nums[index] = num\n}\n</code></pre> array.rb<pre><code>### 在陣列的索引 index 處插入元素 num ###\ndef insert(nums, num, index)\n  # 把索引 index 以及之後的所有元素向後移動一位\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # 將 num 賦給 index 處的元素\n  nums[index] = num\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#4","level":3,"title":"4.   刪除元素","text":"<p>同理，如圖 4-4 所示，若想刪除索引 \\(i\\) 處的元素，則需要把索引 \\(i\\) 之後的元素都向前移動一位。</p> <p></p> <p> 圖 4-4   陣列刪除元素示例 </p> <p>請注意，刪除元素完成後，原先末尾的元素變得“無意義”了，所以我們無須特意去修改它。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def remove(nums: list[int], index: int):\n    \"\"\"刪除索引 index 處的元素\"\"\"\n    # 把索引 index 之後的所有元素向前移動一位\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n</code></pre> array.cpp<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(int *nums, int size, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.java<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(int[] nums, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.cs<pre><code>/* 刪除索引 index 處的元素 */\nvoid Remove(int[] nums, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.go<pre><code>/* 刪除索引 index 處的元素 */\nfunc remove(nums []int, index int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i := index; i &lt; len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n</code></pre> array.swift<pre><code>/* 刪除索引 index 處的元素 */\nfunc remove(nums: inout [Int], index: Int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.js<pre><code>/* 刪除索引 index 處的元素 */\nfunction remove(nums, index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.ts<pre><code>/* 刪除索引 index 處的元素 */\nfunction remove(nums: number[], index: number): void {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (let i = index; i &lt; nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.dart<pre><code>/* 刪除索引 index 處的元素 */\nvoid remove(List&lt;int&gt; nums, int index) {\n  // 把索引 index 之後的所有元素向前移動一位\n  for (var i = index; i &lt; nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n</code></pre> array.rs<pre><code>/* 刪除索引 index 處的元素 */\nfn remove(nums: &amp;mut [i32], index: usize) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.c<pre><code>/* 刪除索引 index 處的元素 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nvoid removeItem(int *nums, int size, int index) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (int i = index; i &lt; size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n</code></pre> array.kt<pre><code>/* 刪除索引 index 處的元素 */\nfun remove(nums: IntArray, index: Int) {\n    // 把索引 index 之後的所有元素向前移動一位\n    for (i in index..&lt;nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n</code></pre> array.rb<pre><code>### 刪除索引 index 處的元素 ###\ndef remove(nums, index)\n  # 把索引 index 之後的所有元素向前移動一位\n  for i in index...(nums.length - 1)\n    nums[i] = nums[i + 1]\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總的來看，陣列的插入與刪除操作有以下缺點。</p> <ul> <li>時間複雜度高：陣列的插入和刪除的平均時間複雜度均為 \\(O(n)\\) ，其中 \\(n\\) 為陣列長度。</li> <li>丟失元素：由於陣列的長度不可變，因此在插入元素後，超出陣列長度範圍的元素會丟失。</li> <li>記憶體浪費：我們可以初始化一個比較長的陣列，只用前面一部分，這樣在插入資料時，丟失的末尾元素都是“無意義”的，但這樣做會造成部分記憶體空間浪費。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#5","level":3,"title":"5.   走訪陣列","text":"<p>在大多數程式語言中，我們既可以透過索引走訪陣列，也可以直接走訪獲取陣列中的每個元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def traverse(nums: list[int]):\n    \"\"\"走訪陣列\"\"\"\n    count = 0\n    # 透過索引走訪陣列\n    for i in range(len(nums)):\n        count += nums[i]\n    # 直接走訪陣列元素\n    for num in nums:\n        count += num\n    # 同時走訪資料索引和元素\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n</code></pre> array.cpp<pre><code>/* 走訪陣列 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.java<pre><code>/* 走訪陣列 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (int num : nums) {\n        count += num;\n    }\n}\n</code></pre> array.cs<pre><code>/* 走訪陣列 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; nums.Length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n</code></pre> array.go<pre><code>/* 走訪陣列 */\nfunc traverse(nums []int) {\n    count := 0\n    // 透過索引走訪陣列\n    for i := 0; i &lt; len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // 直接走訪陣列元素\n    for _, num := range nums {\n        count += num\n    }\n    // 同時走訪資料索引和元素\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.swift<pre><code>/* 走訪陣列 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // 透過索引走訪陣列\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // 直接走訪陣列元素\n    for num in nums {\n        count += num\n    }\n    // 同時走訪資料索引和元素\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n</code></pre> array.js<pre><code>/* 走訪陣列 */\nfunction traverse(nums) {\n    let count = 0;\n    // 透過索引走訪陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.ts<pre><code>/* 走訪陣列 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // 透過索引走訪陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        count += nums[i];\n    }\n    // 直接走訪陣列元素\n    for (const num of nums) {\n        count += num;\n    }\n}\n</code></pre> array.dart<pre><code>/* 走訪陣列元素 */\nvoid traverse(List&lt;int&gt; nums) {\n  int count = 0;\n  // 透過索引走訪陣列\n  for (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n  }\n  // 直接走訪陣列元素\n  for (int _num in nums) {\n    count += _num;\n  }\n  // 透過 forEach 方法走訪陣列\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n</code></pre> array.rs<pre><code>/* 走訪陣列 */\nfn traverse(nums: &amp;[i32]) {\n    let mut _count = 0;\n    // 透過索引走訪陣列\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // 直接走訪陣列元素\n    _count = 0;\n    for &amp;num in nums {\n        _count += num;\n    }\n}\n</code></pre> array.c<pre><code>/* 走訪陣列 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // 透過索引走訪陣列\n    for (int i = 0; i &lt; size; i++) {\n        count += nums[i];\n    }\n}\n</code></pre> array.kt<pre><code>/* 走訪陣列 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // 透過索引走訪陣列\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // 直接走訪陣列元素\n    for (j in nums) {\n        count += j\n    }\n}\n</code></pre> array.rb<pre><code>### 走訪陣列 ###\ndef traverse(nums)\n  count = 0\n\n  # 透過索引走訪陣列\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # 直接走訪陣列元素\n  for num in nums\n    count += num\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#6","level":3,"title":"6.   查詢元素","text":"<p>在陣列中查詢指定元素需要走訪陣列，每輪判斷元素值是否匹配，若匹配則輸出對應索引。</p> <p>因為陣列是線性資料結構，所以上述查詢操作被稱為“線性查詢”。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def find(nums: list[int], target: int) -&gt; int:\n    \"\"\"在陣列中查詢指定元素\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n</code></pre> array.cpp<pre><code>/* 在陣列中查詢指定元素 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.java<pre><code>/* 在陣列中查詢指定元素 */\nint find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.cs<pre><code>/* 在陣列中查詢指定元素 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.go<pre><code>/* 在陣列中查詢指定元素 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i &lt; len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n</code></pre> array.swift<pre><code>/* 在陣列中查詢指定元素 */\nfunc find(nums: [Int], target: Int) -&gt; Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> array.js<pre><code>/* 在陣列中查詢指定元素 */\nfunction find(nums, target) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n</code></pre> array.ts<pre><code>/* 在陣列中查詢指定元素 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> array.dart<pre><code>/* 在陣列中查詢指定元素 */\nint find(List&lt;int&gt; nums, int target) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n</code></pre> array.rs<pre><code>/* 在陣列中查詢指定元素 */\nfn find(nums: &amp;[i32], target: i32) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> array.c<pre><code>/* 在陣列中查詢指定元素 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n</code></pre> array.kt<pre><code>/* 在陣列中查詢指定元素 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target)\n            return i\n    }\n    return -1\n}\n</code></pre> array.rb<pre><code>### 在陣列中查詢指定元素 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#7","level":3,"title":"7.   擴容陣列","text":"<p>在複雜的系統環境中，程式難以保證陣列之後的記憶體空間是可用的，從而無法安全地擴展陣列容量。因此在大多數程式語言中，陣列的長度是不可變的。</p> <p>如果我們希望擴容陣列，則需重新建立一個更大的陣列，然後把原陣列元素依次複製到新陣列。這是一個 \\(O(n)\\) 的操作，在陣列很大的情況下非常耗時。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array.py<pre><code>def extend(nums: list[int], enlarge: int) -&gt; list[int]:\n    \"\"\"擴展陣列長度\"\"\"\n    # 初始化一個擴展長度後的陣列\n    res = [0] * (len(nums) + enlarge)\n    # 將原陣列中的所有元素複製到新陣列\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # 返回擴展後的新陣列\n    return res\n</code></pre> array.cpp<pre><code>/* 擴展陣列長度 */\nint *extend(int *nums, int size, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int *res = new int[size + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 釋放記憶體\n    delete[] nums;\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.java<pre><code>/* 擴展陣列長度 */\nint[] extend(int[] nums, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int[] res = new int[nums.length + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.cs<pre><code>/* 擴展陣列長度 */\nint[] Extend(int[] nums, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int[] res = new int[nums.Length + enlarge];\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.go<pre><code>/* 擴展陣列長度 */\nfunc extend(nums []int, enlarge int) []int {\n    // 初始化一個擴展長度後的陣列\n    res := make([]int, len(nums)+enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for i, num := range nums {\n        res[i] = num\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.swift<pre><code>/* 擴展陣列長度 */\nfunc extend(nums: [Int], enlarge: Int) -&gt; [Int] {\n    // 初始化一個擴展長度後的陣列\n    var res = Array(repeating: 0, count: nums.count + enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.js<pre><code>/* 擴展陣列長度 */\n// 請注意，JavaScript 的 Array 是動態陣列，可以直接擴展\n// 為了方便學習，本函式將 Array 看作長度不可變的陣列\nfunction extend(nums, enlarge) {\n    // 初始化一個擴展長度後的陣列\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 將原陣列中的所有元素複製到新陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.ts<pre><code>/* 擴展陣列長度 */\n// 請注意，TypeScript 的 Array 是動態陣列，可以直接擴展\n// 為了方便學習，本函式將 Array 看作長度不可變的陣列\nfunction extend(nums: number[], enlarge: number): number[] {\n    // 初始化一個擴展長度後的陣列\n    const res = new Array(nums.length + enlarge).fill(0);\n    // 將原陣列中的所有元素複製到新陣列\n    for (let i = 0; i &lt; nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.dart<pre><code>/* 擴展陣列長度 */\nList&lt;int&gt; extend(List&lt;int&gt; nums, int enlarge) {\n  // 初始化一個擴展長度後的陣列\n  List&lt;int&gt; res = List.filled(nums.length + enlarge, 0);\n  // 將原陣列中的所有元素複製到新陣列\n  for (var i = 0; i &lt; nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // 返回擴展後的新陣列\n  return res;\n}\n</code></pre> array.rs<pre><code>/* 擴展陣列長度 */\nfn extend(nums: &amp;[i32], enlarge: usize) -&gt; Vec&lt;i32&gt; {\n    // 初始化一個擴展長度後的陣列\n    let mut res: Vec&lt;i32&gt; = vec![0; nums.len() + enlarge];\n    // 將原陣列中的所有元素複製到新\n    res[0..nums.len()].copy_from_slice(nums);\n\n    // 返回擴展後的新陣列\n    res\n}\n</code></pre> array.c<pre><code>/* 擴展陣列長度 */\nint *extend(int *nums, int size, int enlarge) {\n    // 初始化一個擴展長度後的陣列\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // 將原陣列中的所有元素複製到新陣列\n    for (int i = 0; i &lt; size; i++) {\n        res[i] = nums[i];\n    }\n    // 初始化擴展後的空間\n    for (int i = size; i &lt; size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // 返回擴展後的新陣列\n    return res;\n}\n</code></pre> array.kt<pre><code>/* 擴展陣列長度 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // 初始化一個擴展長度後的陣列\n    val res = IntArray(nums.size + enlarge)\n    // 將原陣列中的所有元素複製到新陣列\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // 返回擴展後的新陣列\n    return res\n}\n</code></pre> array.rb<pre><code>### 擴展陣列長度 ###\n# 請注意，Ruby 的 Array 是動態陣列，可以直接擴展\n# 為了方便學習，本函式將 Array 看作長度不可變的陣列\ndef extend(nums, enlarge)\n  # 初始化一個擴展長度後的陣列\n  res = Array.new(nums.length + enlarge, 0)\n\n  # 將原陣列中的所有元素複製到新陣列\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # 返回擴展後的新陣列\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#412","level":2,"title":"4.1.2   陣列的優點與侷限性","text":"<p>陣列儲存在連續的記憶體空間內，且元素型別相同。這種做法包含豐富的先驗資訊，系統可以利用這些資訊來最佳化資料結構的操作效率。</p> <ul> <li>空間效率高：陣列為資料分配了連續的記憶體塊，無須額外的結構開銷。</li> <li>支持隨機訪問：陣列允許在 \\(O(1)\\) 時間內訪問任何元素。</li> <li>快取區域性：當訪問陣列元素時，計算機不僅會載入它，還會快取其周圍的其他資料，從而藉助高速快取來提升後續操作的執行速度。</li> </ul> <p>連續空間儲存是一把雙刃劍，其存在以下侷限性。</p> <ul> <li>插入與刪除效率低：當陣列中元素較多時，插入與刪除操作需要移動大量的元素。</li> <li>長度不可變：陣列在初始化後長度就固定了，擴容陣列需要將所有資料複製到新陣列，開銷很大。</li> <li>空間浪費：如果陣列分配的大小超過實際所需，那麼多餘的空間就被浪費了。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/array/#413","level":2,"title":"4.1.3   陣列典型應用","text":"<p>陣列是一種基礎且常見的資料結構，既頻繁應用在各類演算法之中，也可用於實現各種複雜資料結構。</p> <ul> <li>隨機訪問：如果我們想隨機抽取一些樣本，那麼可以用陣列儲存，並生成一個隨機序列，根據索引實現隨機抽樣。</li> <li>排序和搜尋：陣列是排序和搜尋演算法最常用的資料結構。快速排序、合併排序、二分搜尋等都主要在陣列上進行。</li> <li>查詢表：當需要快速查詢一個元素或其對應關係時，可以使用陣列作為查詢表。假如我們想實現字元到 ASCII 碼的對映，則可以將字元的 ASCII 碼值作為索引，對應的元素存放在陣列中的對應位置。</li> <li>機器學習：神經網路中大量使用了向量、矩陣、張量之間的線性代數運算，這些資料都是以陣列的形式構建的。陣列是神經網路程式設計中最常使用的資料結構。</li> <li>資料結構實現：陣列可以用於實現堆疊、佇列、雜湊表、堆積、圖等資料結構。例如，圖的鄰接矩陣表示實際上是一個二維陣列。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.1 &nbsp; 陣列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/","level":1,"title":"4.2   鏈結串列","text":"<p>記憶體空間是所有程式的公共資源，在一個複雜的系統執行環境下，空閒的記憶體空間可能散落在記憶體各處。我們知道，儲存陣列的記憶體空間必須是連續的，而當陣列非常大時，記憶體可能無法提供如此大的連續空間。此時鏈結串列的靈活性優勢就體現出來了。</p> <p>鏈結串列（linked list）是一種線性資料結構，其中的每個元素都是一個節點物件，各個節點透過“引用”相連線。引用記錄了下一個節點的記憶體位址，透過它可以從當前節點訪問到下一個節點。</p> <p>鏈結串列的設計使得各個節點可以分散儲存在記憶體各處，它們的記憶體位址無須連續。</p> <p></p> <p> 圖 4-5   鏈結串列定義與儲存方式 </p> <p>觀察圖 4-5 ，鏈結串列的組成單位是節點（node）物件。每個節點都包含兩項資料：節點的“值”和指向下一節點的“引用”。</p> <ul> <li>鏈結串列的首個節點被稱為“頭節點”，最後一個節點被稱為“尾節點”。</li> <li>尾節點指向的是“空”，它在 Java、C++ 和 Python 中分別被記為 <code>null</code>、<code>nullptr</code> 和 <code>None</code> 。</li> <li>在 C、C++、Go 和 Rust 等支持指標的語言中，上述“引用”應被替換為“指標”。</li> </ul> <p>如以下程式碼所示，鏈結串列節點 <code>ListNode</code> 除了包含值，還需額外儲存一個引用（指標）。因此在相同資料量下，鏈結串列比陣列佔用更多的記憶體空間。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"鏈結串列節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # 節點值\n        self.next: ListNode | None = None # 指向下一節點的引用\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\nstruct ListNode {\n    int val;         // 節點值\n    ListNode *next;  // 指向下一節點的指標\n    ListNode(int x) : val(x), next(nullptr) {}  // 建構子\n};\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode next;  // 指向下一節點的引用\n    ListNode(int x) { val = x; }  // 建構子\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode(int x) {  //建構子\n    int val = x;         // 節點值\n    ListNode? next;      // 指向下一節點的引用\n}\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\ntype ListNode struct {\n    Val  int       // 節點值\n    Next *ListNode // 指向下一節點的指標\n}\n\n// NewListNode 建構子，建立一個新的鏈結串列\nfunc NewListNode(val int) *ListNode {\n    return &amp;ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 指向下一節點的引用\n\n    init(x: Int) { // 建構子\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // 節點值\n        this.next = (next === undefined ? null : next); // 指向下一節點的引用\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // 節點值\n        this.next = next === undefined ? null : next;  // 指向下一節點的引用\n    }\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\nclass ListNode {\n  int val; // 節點值\n  ListNode? next; // 指向下一節點的引用\n  ListNode(this.val, [this.next]); // 建構子\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n/* 鏈結串列節點類別 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // 節點值\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向下一節點的指標\n}\n</code></pre> <pre><code>/* 鏈結串列節點結構體 */\ntypedef struct ListNode {\n    int val;               // 節點值\n    struct ListNode *next; // 指向下一節點的指標\n} ListNode;\n\n/* 建構子 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 鏈結串列節點類別 */\n// 建構子\nclass ListNode(x: Int) {\n    val _val: Int = x          // 節點值\n    val next: ListNode? = null // 指向下一個節點的引用\n}\n</code></pre> <pre><code># 鏈結串列節點類別\nclass ListNode\n  attr_accessor :val  # 節點值\n  attr_accessor :next # 指向下一節點的引用\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n</code></pre>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#421","level":2,"title":"4.2.1   鏈結串列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#1","level":3,"title":"1.   初始化鏈結串列","text":"<p>建立鏈結串列分為兩步，第一步是初始化各個節點物件，第二步是構建節點之間的引用關係。初始化完成後，我們就可以從鏈結串列的頭節點出發，透過引用指向 <code>next</code> 依次訪問所有節點。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code># 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# 初始化各個節點\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.cpp<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// 構建節點之間的引用\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.java<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.cs<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.go<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// 構建節點之間的引用\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n</code></pre> linked_list.swift<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> linked_list.js<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.ts<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.dart<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\\\n// 初始化各個節點\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rs<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// 構建節點之間的引用\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n</code></pre> linked_list.c<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// 構建節點之間的引用\nn0-&gt;next = n1;\nn1-&gt;next = n2;\nn2-&gt;next = n3;\nn3-&gt;next = n4;\n</code></pre> linked_list.kt<pre><code>/* 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4 */\n// 初始化各個節點\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// 構建節點之間的引用\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n</code></pre> linked_list.rb<pre><code># 初始化鏈結串列 1 -&gt; 3 -&gt; 2 -&gt; 5 -&gt; 4\n# 初始化各個節點\nn0 = ListNode.new(1)\nn1 = ListNode.new(3)\nn2 = ListNode.new(2)\nn3 = ListNode.new(5)\nn4 = ListNode.new(4)\n# 構建節點之間的引用\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>陣列整體是一個變數，比如陣列 <code>nums</code> 包含元素 <code>nums[0]</code> 和 <code>nums[1]</code> 等，而鏈結串列是由多個獨立的節點物件組成的。我們通常將頭節點當作鏈結串列的代稱，比如以上程式碼中的鏈結串列可記作鏈結串列 <code>n0</code> 。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#2","level":3,"title":"2.   插入節點","text":"<p>在鏈結串列中插入節點非常容易。如圖 4-6 所示，假設我們想在相鄰的兩個節點 <code>n0</code> 和 <code>n1</code> 之間插入一個新節點 <code>P</code> ，則只需改變兩個節點引用（指標）即可，時間複雜度為 \\(O(1)\\) 。</p> <p>相比之下，在陣列中插入元素的時間複雜度為 \\(O(n)\\) ，在大資料量下的效率較低。</p> <p></p> <p> 圖 4-6   鏈結串列插入節點示例 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def insert(n0: ListNode, P: ListNode):\n    \"\"\"在鏈結串列的節點 n0 之後插入節點 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n</code></pre> linked_list.cpp<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.java<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.cs<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid Insert(ListNode n0, ListNode P) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.go<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.Next = P\n}\n</code></pre> linked_list.swift<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunc insert(n0: ListNode, P: ListNode) {\n    let n1 = n0.next\n    P.next = n1\n    n0.next = P\n}\n</code></pre> linked_list.js<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunction insert(n0, P) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.ts<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfunction insert(n0: ListNode, P: ListNode): void {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n</code></pre> linked_list.dart<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode n0, ListNode P) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n</code></pre> linked_list.rs<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\n#[allow(non_snake_case)]\npub fn insert&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, P: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(P);\n}\n</code></pre> linked_list.c<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0-&gt;next;\n    P-&gt;next = n1;\n    n0-&gt;next = P;\n}\n</code></pre> linked_list.kt<pre><code>/* 在鏈結串列的節點 n0 之後插入節點 P */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n</code></pre> linked_list.rb<pre><code>### 在鏈結串列的節點 n0 之後插入節點 _p ###\n# Ruby 的 `p` 是一個內建函式， `P` 是一個常數，所以可以使用 `_p` 代替\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#3","level":3,"title":"3.   刪除節點","text":"<p>如圖 4-7 所示，在鏈結串列中刪除節點也非常方便，只需改變一個節點的引用（指標）即可。</p> <p>請注意，儘管在刪除操作完成後節點 <code>P</code> 仍然指向 <code>n1</code> ，但實際上走訪此鏈結串列已經無法訪問到 <code>P</code> ，這意味著 <code>P</code> 已經不再屬於該鏈結串列了。</p> <p></p> <p> 圖 4-7   鏈結串列刪除節點 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def remove(n0: ListNode):\n    \"\"\"刪除鏈結串列的節點 n0 之後的首個節點\"\"\"\n    if not n0.next:\n        return\n    # n0 -&gt; P -&gt; n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n</code></pre> linked_list.cpp<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode *n0) {\n    if (n0-&gt;next == nullptr)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // 釋放記憶體\n    delete P;\n}\n</code></pre> linked_list.java<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.cs<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.go<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    P := n0.Next\n    n1 := P.Next\n    n0.Next = n1\n}\n</code></pre> linked_list.swift<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunc remove(n0: ListNode) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -&gt; P -&gt; n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.next = n1\n}\n</code></pre> linked_list.js<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunction remove(n0) {\n    if (!n0.next) return;\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.ts<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfunction remove(n0: ListNode): void {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -&gt; P -&gt; n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.next = n1;\n}\n</code></pre> linked_list.dart<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nvoid remove(ListNode n0) {\n  if (n0.next == null) return;\n  // n0 -&gt; P -&gt; n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n</code></pre> linked_list.rs<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\n#[allow(non_snake_case)]\npub fn remove&lt;T&gt;(n0: &amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;) {\n    // n0 -&gt; P -&gt; n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\n}\n</code></pre> linked_list.c<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nvoid removeItem(ListNode *n0) {\n    if (!n0-&gt;next)\n        return;\n    // n0 -&gt; P -&gt; n1\n    ListNode *P = n0-&gt;next;\n    ListNode *n1 = P-&gt;next;\n    n0-&gt;next = n1;\n    // 釋放記憶體\n    free(P);\n}\n</code></pre> linked_list.kt<pre><code>/* 刪除鏈結串列的節點 n0 之後的首個節點 */\nfun remove(n0: ListNode?) {\n    if (n0?.next == null)\n        return\n    // n0 -&gt; P -&gt; n1\n    val p = n0.next\n    val n1 = p?.next\n    n0.next = n1\n}\n</code></pre> linked_list.rb<pre><code>### 刪除鏈結串列的節點 n0 之後的首個節點 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -&gt; remove_node -&gt; n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#4","level":3,"title":"4.   訪問節點","text":"<p>在鏈結串列中訪問節點的效率較低。如上一節所述，我們可以在 \\(O(1)\\) 時間下訪問陣列中的任意元素。鏈結串列則不然，程式需要從頭節點出發，逐個向後走訪，直至找到目標節點。也就是說，訪問鏈結串列的第 \\(i\\) 個節點需要迴圈 \\(i - 1\\) 輪，時間複雜度為 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def access(head: ListNode, index: int) -&gt; ListNode | None:\n    \"\"\"訪問鏈結串列中索引為 index 的節點\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n</code></pre> linked_list.cpp<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.java<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.cs<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.go<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i &lt; index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return head\n}\n</code></pre> linked_list.swift<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunc access(head: ListNode, index: Int) -&gt; ListNode? {\n    var head: ListNode? = head\n    for _ in 0 ..&lt; index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n</code></pre> linked_list.js<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunction access(head, index) {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.ts<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfunction access(head: ListNode | null, index: number): ListNode | null {\n    for (let i = 0; i &lt; index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n</code></pre> linked_list.dart<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i &lt; index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n</code></pre> linked_list.rs<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\npub fn access&lt;T&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, index: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n    fn dfs&lt;T&gt;(\n        head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,\n        index: i32,\n    ) -&gt; Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        if index &lt;= 0 {\n            return head.cloned();\n        }\n\n        if let Some(node) = head {\n            dfs(node.borrow().next.as_ref(), index - 1)\n        } else {\n            None\n        }\n    }\n\n    dfs(Some(head).as_ref(), index)\n}\n</code></pre> linked_list.c<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i &lt; index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head-&gt;next;\n    }\n    return head;\n}\n</code></pre> linked_list.kt<pre><code>/* 訪問鏈結串列中索引為 index 的節點 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..&lt;index) {\n        if (h == null)\n            return null\n        h = h.next\n    }\n    return h\n}\n</code></pre> linked_list.rb<pre><code>### 訪問鏈結串列中索引為 index 的節點 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#5","level":3,"title":"5.   查詢節點","text":"<p>走訪鏈結串列，查詢其中值為 <code>target</code> 的節點，輸出該節點在鏈結串列中的索引。此過程也屬於線性查詢。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linked_list.py<pre><code>def find(head: ListNode, target: int) -&gt; int:\n    \"\"\"在鏈結串列中查詢值為 target 的首個節點\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n</code></pre> linked_list.cpp<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.java<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.cs<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint Find(ListNode? head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.go<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunc findNode(head *ListNode, target int) int {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.swift<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunc find(head: ListNode, target: Int) -&gt; Int {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n</code></pre> linked_list.js<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.ts<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfunction find(head: ListNode | null, target: number): number {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -1;\n}\n</code></pre> linked_list.dart<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode? head, int target) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n</code></pre> linked_list.rs<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\npub fn find&lt;T: PartialEq&gt;(head: Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;, target: T) -&gt; i32 {\n    fn find&lt;T: PartialEq&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, target: T, idx: i32) -&gt; i32 {\n        if let Some(node) = head {\n            if node.borrow().val == target {\n                return idx;\n            }\n            return find(node.borrow().next.as_ref(), target, idx + 1);\n        } else {\n            -1\n        }\n    }\n\n    find(Some(head).as_ref(), target, 0)\n}\n</code></pre> linked_list.c<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head) {\n        if (head-&gt;val == target)\n            return index;\n        head = head-&gt;next;\n        index++;\n    }\n    return -1;\n}\n</code></pre> linked_list.kt<pre><code>/* 在鏈結串列中查詢值為 target 的首個節點 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h._val == target)\n            return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n</code></pre> linked_list.rb<pre><code>### 在鏈結串列中查詢值為 target 的首個節點 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","level":2,"title":"4.2.2   陣列 vs. 鏈結串列","text":"<p>表 4-1 總結了陣列和鏈結串列的各項特點並對比了操作效率。由於它們採用兩種相反的儲存策略，因此各種性質和操作效率也呈現對立的特點。</p> <p> 表 4-1   陣列與鏈結串列的效率對比 </p> 陣列 鏈結串列 儲存方式 連續記憶體空間 分散記憶體空間 容量擴展 長度不可變 可靈活擴展 記憶體效率 元素佔用記憶體少、但可能浪費空間 元素佔用記憶體多 訪問元素 \\(O(1)\\) \\(O(n)\\) 新增元素 \\(O(n)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(1)\\)","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#423","level":2,"title":"4.2.3   常見鏈結串列型別","text":"<p>如圖 4-8 所示，常見的鏈結串列型別包括三種。</p> <ul> <li>單向鏈結串列：即前面介紹的普通鏈結串列。單向鏈結串列的節點包含值和指向下一節點的引用兩項資料。我們將首個節點稱為頭節點，將最後一個節點稱為尾節點，尾節點指向空 <code>None</code> 。</li> <li>環形鏈結串列：如果我們令單向鏈結串列的尾節點指向頭節點（首尾相接），則得到一個環形鏈結串列。在環形鏈結串列中，任意節點都可以視作頭節點。</li> <li>雙向鏈結串列：與單向鏈結串列相比，雙向鏈結串列記錄了兩個方向的引用。雙向鏈結串列的節點定義同時包含指向後繼節點（下一個節點）和前驅節點（上一個節點）的引用（指標）。相較於單向鏈結串列，雙向鏈結串列更具靈活性，可以朝兩個方向走訪鏈結串列，但相應地也需要佔用更多的記憶體空間。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class ListNode:\n    \"\"\"雙向鏈結串列節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # 節點值\n        self.next: ListNode | None = None  # 指向後繼節點的引用\n        self.prev: ListNode | None = None  # 指向前驅節點的引用\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\nstruct ListNode {\n    int val;         // 節點值\n    ListNode *next;  // 指向後繼節點的指標\n    ListNode *prev;  // 指向前驅節點的指標\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 建構子\n};\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode next;  // 指向後繼節點的引用\n    ListNode prev;  // 指向前驅節點的引用\n    ListNode(int x) { val = x; }  // 建構子\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode(int x) {  // 建構子\n    int val = x;    // 節點值\n    ListNode next;  // 指向後繼節點的引用\n    ListNode prev;  // 指向前驅節點的引用\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\ntype DoublyListNode struct {\n    Val  int             // 節點值\n    Next *DoublyListNode // 指向後繼節點的指標\n    Prev *DoublyListNode // 指向前驅節點的指標\n}\n\n// NewDoublyListNode 初始化\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &amp;DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 指向後繼節點的引用\n    var prev: ListNode? // 指向前驅節點的引用\n\n    init(x: Int) { // 建構子\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // 節點值\n        this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用\n        this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // 節點值\n        this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用\n        this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\nclass ListNode {\n    int val;        // 節點值\n    ListNode? next;  // 指向後繼節點的引用\n    ListNode? prev;  // 指向前驅節點的引用\n    ListNode(this.val, [this.next, this.prev]);  // 建構子\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 雙向鏈結串列節點型別 */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // 節點值\n    next: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向後繼節點的指標\n    prev: Option&lt;Rc&lt;RefCell&lt;ListNode&gt;&gt;&gt;, // 指向前驅節點的指標\n}\n\n/* 建構子 */\nimpl ListNode {\n    fn new(val: i32) -&gt; Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點結構體 */\ntypedef struct ListNode {\n    int val;               // 節點值\n    struct ListNode *next; // 指向後繼節點的指標\n    struct ListNode *prev; // 指向前驅節點的指標\n} ListNode;\n\n/* 建構子 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node-&gt;val = val;\n    node-&gt;next = NULL;\n    node-&gt;prev = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 雙向鏈結串列節點類別 */\n// 建構子\nclass ListNode(x: Int) {\n    val _val: Int = x           // 節點值\n    val next: ListNode? = null  // 指向後繼節點的引用\n    val prev: ListNode? = null  // 指向前驅節點的引用\n}\n</code></pre> <pre><code># 雙向鏈結串列節點類別\nclass ListNode\n  attr_accessor :val    # 節點值\n  attr_accessor :next   # 指向後繼節點的引用\n  attr_accessor :prev   # 指向前驅節點的引用\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n</code></pre> <p></p> <p> 圖 4-8   常見鏈結串列種類 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/linked_list/#424","level":2,"title":"4.2.4   鏈結串列典型應用","text":"<p>單向鏈結串列通常用於實現堆疊、佇列、雜湊表和圖等資料結構。</p> <ul> <li>堆疊與佇列：當插入和刪除操作都在鏈結串列的一端進行時，它表現的特性為先進後出，對應堆疊；當插入操作在鏈結串列的一端進行，刪除操作在鏈結串列的另一端進行，它表現的特性為先進先出，對應佇列。</li> <li>雜湊表：鏈式位址是解決雜湊衝突的主流方案之一，在該方案中，所有衝突的元素都會被放到一個鏈結串列中。</li> <li>圖：鄰接表是表示圖的一種常用方式，其中圖的每個頂點都與一個鏈結串列相關聯，鏈結串列中的每個元素都代表與該頂點相連的其他頂點。</li> </ul> <p>雙向鏈結串列常用於需要快速查詢前一個和後一個元素的場景。</p> <ul> <li>高階資料結構：比如在紅黑樹、B 樹中，我們需要訪問節點的父節點，這可以透過在節點中儲存一個指向父節點的引用來實現，類似於雙向鏈結串列。</li> <li>瀏覽器歷史：在網頁瀏覽器中，當用戶點選前進或後退按鈕時，瀏覽器需要知道使用者訪問過的前一個和後一個網頁。雙向鏈結串列的特性使得這種操作變得簡單。</li> <li>LRU 演算法：在快取淘汰（LRU）演算法中，我們需要快速找到最近最少使用的資料，以及支持快速新增和刪除節點。這時候使用雙向鏈結串列就非常合適。</li> </ul> <p>環形鏈結串列常用於需要週期性操作的場景，比如作業系統的資源排程。</p> <ul> <li>時間片輪轉排程演算法：在作業系統中，時間片輪轉排程演算法是一種常見的 CPU 排程演算法，它需要對一組程序進行迴圈。每個程序被賦予一個時間片，當時間片用完時，CPU 將切換到下一個程序。這種迴圈操作可以透過環形鏈結串列來實現。</li> <li>資料緩衝區：在某些資料緩衝區的實現中，也可能會使用環形鏈結串列。比如在音訊、影片播放器中，資料流可能會被分成多個緩衝塊並放入一個環形鏈結串列，以便實現無縫播放。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.2 &nbsp; 鏈結串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/","level":1,"title":"4.3   串列","text":"<p>串列（list）是一個抽象的資料結構概念，它表示元素的有序集合，支持元素訪問、修改、新增、刪除和走訪等操作，無須使用者考慮容量限制的問題。串列可以基於鏈結串列或陣列實現。</p> <ul> <li>鏈結串列天然可以看作一個串列，其支持元素增刪查改操作，並且可以靈活動態擴容。</li> <li>陣列也支持元素增刪查改，但由於其長度不可變，因此只能看作一個具有長度限制的串列。</li> </ul> <p>當使用陣列實現串列時，長度不可變的性質會導致串列的實用性降低。這是因為我們通常無法事先確定需要儲存多少資料，從而難以選擇合適的串列長度。若長度過小，則很可能無法滿足使用需求；若長度過大，則會造成記憶體空間浪費。</p> <p>為解決此問題，我們可以使用動態陣列（dynamic array）來實現串列。它繼承了陣列的各項優點，並且可以在程式執行過程中進行動態擴容。</p> <p>實際上，許多程式語言中的標準庫提供的串列是基於動態陣列實現的，例如 Python 中的 <code>list</code> 、Java 中的 <code>ArrayList</code> 、C++ 中的 <code>vector</code> 和 C# 中的 <code>List</code> 等。在接下來的討論中，我們將把“串列”和“動態陣列”視為等同的概念。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#431","level":2,"title":"4.3.1   串列常用操作","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#1","level":3,"title":"1.   初始化串列","text":"<p>我們通常使用“無初始值”和“有初始值”這兩種初始化方法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 初始化串列\n# 無初始值\nnums1: list[int] = []\n# 有初始值\nnums: list[int] = [1, 3, 2, 5, 4]\n</code></pre> list.cpp<pre><code>/* 初始化串列 */\n// 需注意，C++ 中 vector 即是本文描述的 nums\n// 無初始值\nvector&lt;int&gt; nums1;\n// 有初始值\nvector&lt;int&gt; nums = { 1, 3, 2, 5, 4 };\n</code></pre> list.java<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;();\n// 有初始值（注意陣列的元素型別需為 int[] 的包裝類別 Integer[]）\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList&lt;Integer&gt; nums = new ArrayList&lt;&gt;(Arrays.asList(numbers));\n</code></pre> list.cs<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;int&gt; nums1 = [];\n// 有初始值\nint[] numbers = [1, 3, 2, 5, 4];\nList&lt;int&gt; nums = [.. numbers];\n</code></pre> list_test.go<pre><code>/* 初始化串列 */\n// 無初始值\nnums1 := []int{}\n// 有初始值\nnums := []int{1, 3, 2, 5, 4}\n</code></pre> list.swift<pre><code>/* 初始化串列 */\n// 無初始值\nlet nums1: [Int] = []\n// 有初始值\nvar nums = [1, 3, 2, 5, 4]\n</code></pre> list.js<pre><code>/* 初始化串列 */\n// 無初始值\nconst nums1 = [];\n// 有初始值\nconst nums = [1, 3, 2, 5, 4];\n</code></pre> list.ts<pre><code>/* 初始化串列 */\n// 無初始值\nconst nums1: number[] = [];\n// 有初始值\nconst nums: number[] = [1, 3, 2, 5, 4];\n</code></pre> list.dart<pre><code>/* 初始化串列 */\n// 無初始值\nList&lt;int&gt; nums1 = [];\n// 有初始值\nList&lt;int&gt; nums = [1, 3, 2, 5, 4];\n</code></pre> list.rs<pre><code>/* 初始化串列 */\n// 無初始值\nlet nums1: Vec&lt;i32&gt; = Vec::new();\n// 有初始值\nlet nums: Vec&lt;i32&gt; = vec![1, 3, 2, 5, 4];\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 初始化串列 */\n// 無初始值\nvar nums1 = listOf&lt;Int&gt;()\n// 有初始值\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n</code></pre> list.rb<pre><code># 初始化串列\n# 無初始值\nnums1 = []\n# 有初始值\nnums = [1, 3, 2, 5, 4]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#2","level":3,"title":"2.   訪問元素","text":"<p>串列本質上是陣列，因此可以在 \\(O(1)\\) 時間內訪問和更新元素，效率很高。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 訪問元素\nnum: int = nums[1]  # 訪問索引 1 處的元素\n\n# 更新元素\nnums[1] = 0    # 將索引 1 處的元素更新為 0\n</code></pre> list.cpp<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.java<pre><code>/* 訪問元素 */\nint num = nums.get(1);  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums.set(1, 0);  // 將索引 1 處的元素更新為 0\n</code></pre> list.cs<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list_test.go<pre><code>/* 訪問元素 */\nnum := nums[1]  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0     // 將索引 1 處的元素更新為 0\n</code></pre> list.swift<pre><code>/* 訪問元素 */\nlet num = nums[1] // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0 // 將索引 1 處的元素更新為 0\n</code></pre> list.js<pre><code>/* 訪問元素 */\nconst num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.ts<pre><code>/* 訪問元素 */\nconst num: number = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.dart<pre><code>/* 訪問元素 */\nint num = nums[1];  // 訪問索引 1 處的元素\n\n/* 更新元素 */\nnums[1] = 0;  // 將索引 1 處的元素更新為 0\n</code></pre> list.rs<pre><code>/* 訪問元素 */\nlet num: i32 = nums[1];  // 訪問索引 1 處的元素\n/* 更新元素 */\nnums[1] = 0;             // 將索引 1 處的元素更新為 0\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 訪問元素 */\nval num = nums[1]       // 訪問索引 1 處的元素\n/* 更新元素 */\nnums[1] = 0             // 將索引 1 處的元素更新為 0\n</code></pre> list.rb<pre><code># 訪問元素\nnum = nums[1] # 訪問索引 1 處的元素\n# 更新元素\nnums[1] = 0 # 將索引 1 處的元素更新為 0\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#3","level":3,"title":"3.   插入與刪除元素","text":"<p>相較於陣列，串列可以自由地新增與刪除元素。在串列尾部新增元素的時間複雜度為 \\(O(1)\\) ，但插入和刪除元素的效率仍與陣列相同，時間複雜度為 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 清空串列\nnums.clear()\n\n# 在尾部新增元素\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# 在中間插入元素\nnums.insert(3, 6)  # 在索引 3 處插入數字 6\n\n# 刪除元素\nnums.pop(3)        # 刪除索引 3 處的元素\n</code></pre> list.cpp<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* 在中間插入元素 */\nnums.insert(nums.begin() + 3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.erase(nums.begin() + 3);      // 刪除索引 3 處的元素\n</code></pre> list.java<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.add(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);  // 刪除索引 3 處的元素\n</code></pre> list.cs<pre><code>/* 清空串列 */\nnums.Clear();\n\n/* 在尾部新增元素 */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* 在中間插入元素 */\nnums.Insert(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.RemoveAt(3);  // 刪除索引 3 處的元素\n</code></pre> list_test.go<pre><code>/* 清空串列 */\nnums = nil\n\n/* 在尾部新增元素 */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* 在中間插入元素 */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums = append(nums[:3], nums[4:]...) // 刪除索引 3 處的元素\n</code></pre> list.swift<pre><code>/* 清空串列 */\nnums.removeAll()\n\n/* 在尾部新增元素 */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* 在中間插入元素 */\nnums.insert(6, at: 3) // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(at: 3) // 刪除索引 3 處的元素\n</code></pre> list.js<pre><code>/* 清空串列 */\nnums.length = 0;\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.splice(3, 0, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.splice(3, 1);  // 刪除索引 3 處的元素\n</code></pre> list.ts<pre><code>/* 清空串列 */\nnums.length = 0;\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.splice(3, 0, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.splice(3, 1);  // 刪除索引 3 處的元素\n</code></pre> list.dart<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.insert(3, 6); // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.removeAt(3); // 刪除索引 3 處的元素\n</code></pre> list.rs<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* 在中間插入元素 */\nnums.insert(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);    // 刪除索引 3 處的元素\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 清空串列 */\nnums.clear();\n\n/* 在尾部新增元素 */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* 在中間插入元素 */\nnums.add(3, 6);  // 在索引 3 處插入數字 6\n\n/* 刪除元素 */\nnums.remove(3);  // 刪除索引 3 處的元素\n</code></pre> list.rb<pre><code># 清空串列\nnums.clear\n\n# 在尾部新增元素\nnums &lt;&lt; 1\nnums &lt;&lt; 3\nnums &lt;&lt; 2\nnums &lt;&lt; 5\nnums &lt;&lt; 4\n\n# 在中間插入元素\nnums.insert(3, 6) # 在索引 3 處插入數字 6\n\n# 刪除元素\nnums.delete_at(3) # 刪除索引 3 處的元素\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#4","level":3,"title":"4.   走訪串列","text":"<p>與陣列一樣，串列可以根據索引走訪，也可以直接走訪各元素。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 透過索引走訪串列\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# 直接走訪串列元素\nfor num in nums:\n    count += num\n</code></pre> list.cpp<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.java<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* 直接走訪串列元素 */\nfor (int num : nums) {\n    count += num;\n}\n</code></pre> list.cs<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (int i = 0; i &lt; nums.Count; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n</code></pre> list_test.go<pre><code>/* 透過索引走訪串列 */\ncount := 0\nfor i := 0; i &lt; len(nums); i++ {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n</code></pre> list.swift<pre><code>/* 透過索引走訪串列 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\ncount = 0\nfor num in nums {\n    count += num\n}\n</code></pre> list.js<pre><code>/* 透過索引走訪串列 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.ts<pre><code>/* 透過索引走訪串列 */\nlet count = 0;\nfor (let i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n</code></pre> list.dart<pre><code>/* 透過索引走訪串列 */\nint count = 0;\nfor (var i = 0; i &lt; nums.length; i++) {\n    count += nums[i];\n}\n\n/* 直接走訪串列元素 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n</code></pre> list.rs<pre><code>// 透過索引走訪串列\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// 直接走訪串列元素\n_count = 0;\nfor num in &amp;nums {\n    _count += num;\n}\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 透過索引走訪串列 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* 直接走訪串列元素 */\nfor (num in nums) {\n    count += num\n}\n</code></pre> list.rb<pre><code># 透過索引走訪串列\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# 直接走訪串列元素\ncount = 0\nfor num in nums\n    count += num\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#5","level":3,"title":"5.   拼接串列","text":"<p>給定一個新串列 <code>nums1</code> ，我們可以將其拼接到原串列的尾部。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 拼接兩個串列\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # 將串列 nums1 拼接到 nums 之後\n</code></pre> list.cpp<pre><code>/* 拼接兩個串列 */\nvector&lt;int&gt; nums1 = { 6, 8, 7, 10, 9 };\n// 將串列 nums1 拼接到 nums 之後\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n</code></pre> list.java<pre><code>/* 拼接兩個串列 */\nList&lt;Integer&gt; nums1 = new ArrayList&lt;&gt;(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.cs<pre><code>/* 拼接兩個串列 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list_test.go<pre><code>/* 拼接兩個串列 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.swift<pre><code>/* 拼接兩個串列 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.js<pre><code>/* 拼接兩個串列 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.ts<pre><code>/* 拼接兩個串列 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.dart<pre><code>/* 拼接兩個串列 */\nList&lt;int&gt; nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.rs<pre><code>/* 拼接兩個串列 */\nlet nums1: Vec&lt;i32&gt; = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 拼接兩個串列 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // 將串列 nums1 拼接到 nums 之後\n</code></pre> list.rb<pre><code># 拼接兩個串列\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#6","level":3,"title":"6.   排序串列","text":"<p>完成串列排序後，我們便可以使用在陣列類別演算法題中經常考查的“二分搜尋”和“雙指標”演算法。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby list.py<pre><code># 排序串列\nnums.sort()  # 排序後，串列元素從小到大排列\n</code></pre> list.cpp<pre><code>/* 排序串列 */\nsort(nums.begin(), nums.end());  // 排序後，串列元素從小到大排列\n</code></pre> list.java<pre><code>/* 排序串列 */\nCollections.sort(nums);  // 排序後，串列元素從小到大排列\n</code></pre> list.cs<pre><code>/* 排序串列 */\nnums.Sort(); // 排序後，串列元素從小到大排列\n</code></pre> list_test.go<pre><code>/* 排序串列 */\nsort.Ints(nums)  // 排序後，串列元素從小到大排列\n</code></pre> list.swift<pre><code>/* 排序串列 */\nnums.sort() // 排序後，串列元素從小到大排列\n</code></pre> list.js<pre><code>/* 排序串列 */\nnums.sort((a, b) =&gt; a - b);  // 排序後，串列元素從小到大排列\n</code></pre> list.ts<pre><code>/* 排序串列 */\nnums.sort((a, b) =&gt; a - b);  // 排序後，串列元素從小到大排列\n</code></pre> list.dart<pre><code>/* 排序串列 */\nnums.sort(); // 排序後，串列元素從小到大排列\n</code></pre> list.rs<pre><code>/* 排序串列 */\nnums.sort(); // 排序後，串列元素從小到大排列\n</code></pre> list.c<pre><code>// C 未提供內建動態陣列\n</code></pre> list.kt<pre><code>/* 排序串列 */\nnums.sort() // 排序後，串列元素從小到大排列\n</code></pre> list.rb<pre><code># 排序串列\nnums = nums.sort { |a, b| a &lt;=&gt; b } # 排序後，串列元素從小到大排列\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/list/#432","level":2,"title":"4.3.2   串列實現","text":"<p>許多程式語言內建了串列，例如 Java、C++、Python 等。它們的實現比較複雜，各個參數的設定也非常考究，例如初始容量、擴容倍數等。感興趣的讀者可以查閱原始碼進行學習。</p> <p>為了加深對串列工作原理的理解，我們嘗試實現一個簡易版串列，包括以下三個重點設計。</p> <ul> <li>初始容量：選取一個合理的陣列初始容量。在本示例中，我們選擇 10 作為初始容量。</li> <li>數量記錄：宣告一個變數 <code>size</code> ，用於記錄串列當前元素數量，並隨著元素插入和刪除即時更新。根據此變數，我們可以定位串列尾部，以及判斷是否需要擴容。</li> <li>擴容機制：若插入元素時串列容量已滿，則需要進行擴容。先根據擴容倍數建立一個更大的陣列，再將當前陣列的所有元素依次移動至新陣列。在本示例中，我們規定每次將陣列擴容至之前的 2 倍。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_list.py<pre><code>class MyList:\n    \"\"\"串列類別\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._capacity: int = 10  # 串列容量\n        self._arr: list[int] = [0] * self._capacity  # 陣列（儲存串列元素）\n        self._size: int = 0  # 串列長度（當前元素數量）\n        self._extend_ratio: int = 2  # 每次串列擴容的倍數\n\n    def size(self) -&gt; int:\n        \"\"\"獲取串列長度（當前元素數量）\"\"\"\n        return self._size\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取串列容量\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -&gt; int:\n        \"\"\"訪問元素\"\"\"\n        # 索引如果越界，則丟擲異常，下同\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"更新元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"在尾部新增元素\"\"\"\n        # 元素數量超出容量時，觸發擴容機制\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"在中間插入元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        # 元素數量超出容量時，觸發擴容機制\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # 將索引 index 以及之後的元素都向後移動一位\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # 更新元素數量\n        self._size += 1\n\n    def remove(self, index: int) -&gt; int:\n        \"\"\"刪除元素\"\"\"\n        if index &lt; 0 or index &gt;= self._size:\n            raise IndexError(\"索引越界\")\n        num = self._arr[index]\n        # 將索引 index 之後的元素都向前移動一位\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # 更新元素數量\n        self._size -= 1\n        # 返回被刪除的元素\n        return num\n\n    def extend_capacity(self):\n        \"\"\"串列擴容\"\"\"\n        # 新建一個長度為原陣列 _extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # 更新串列容量\n        self._capacity = len(self._arr)\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回有效長度的串列\"\"\"\n        return self._arr[: self._size]\n</code></pre> my_list.cpp<pre><code>/* 串列類別 */\nclass MyList {\n  private:\n    int *arr;             // 陣列（儲存串列元素）\n    int arrCapacity = 10; // 串列容量\n    int arrSize = 0;      // 串列長度（當前元素數量）\n    int extendRatio = 2;   // 每次串列擴容的倍數\n\n  public:\n    /* 建構子 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* 析構方法 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    int size() {\n        return arrSize;\n    }\n\n    /* 獲取串列容量 */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* 訪問元素 */\n    int get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    void add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 在中間插入元素 */\n    void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (size() == capacity())\n            extendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = size() - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 刪除元素 */\n    int remove(int index) {\n        if (index &lt; 0 || index &gt;= size())\n            throw out_of_range(\"索引越界\");\n        int num = arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        arrSize--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    void extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // 將原陣列中的所有元素複製到新陣列\n        for (int i = 0; i &lt; size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // 釋放記憶體\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* 將串列轉換為 Vector 用於列印 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; vec(size());\n        for (int i = 0; i &lt; size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n</code></pre> my_list.java<pre><code>/* 串列類別 */\nclass MyList {\n    private int[] arr; // 陣列（儲存串列元素）\n    private int capacity = 10; // 串列容量\n    private int size = 0; // 串列長度（當前元素數量）\n    private int extendRatio = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* 獲取串列長度（當前元素數量） */\n    public int size() {\n        return size;\n    }\n\n    /* 獲取串列容量 */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* 訪問元素 */\n    public int get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    public void set(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public void add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // 更新元素數量\n        size++;\n    }\n\n    /* 在中間插入元素 */\n    public void insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = size - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        size++;\n    }\n\n    /* 刪除元素 */\n    public int remove(int index) {\n        if (index &lt; 0 || index &gt;= size)\n            throw new IndexOutOfBoundsException(\"索引越界\");\n        int num = arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public void extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // 更新串列容量\n        capacity = arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public int[] toArray() {\n        int size = size();\n        // 僅轉換有效長度範圍內的串列元素\n        int[] arr = new int[size];\n        for (int i = 0; i &lt; size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.cs<pre><code>/* 串列類別 */\nclass MyList {\n    private int[] arr;           // 陣列（儲存串列元素）\n    private int arrCapacity = 10;    // 串列容量\n    private int arrSize = 0;         // 串列長度（當前元素數量）\n    private readonly int extendRatio = 2;  // 每次串列擴容的倍數\n\n    /* 建構子 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* 獲取串列容量 */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* 訪問元素 */\n    public int Get(int index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        return arr[index];\n    }\n\n    /* 更新元素 */\n    public void Set(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public void Add(int num) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 在中間插入元素 */\n    public void Insert(int index, int num) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        // 元素數量超出容量時，觸發擴容機制\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (int j = arrSize - 1; j &gt;= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // 更新元素數量\n        arrSize++;\n    }\n\n    /* 刪除元素 */\n    public int Remove(int index) {\n        if (index &lt; 0 || index &gt;= arrSize)\n            throw new IndexOutOfRangeException(\"索引越界\");\n        int num = arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (int j = index; j &lt; arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // 更新元素數量\n        arrSize--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public void ExtendCapacity() {\n        // 新建一個長度為 arrCapacity * extendRatio 的陣列，並將原陣列複製到新陣列\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // 更新串列容量\n        arrCapacity = arr.Length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] arr = new int[arrSize];\n        for (int i = 0; i &lt; arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.go<pre><code>/* 串列類別 */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* 建構子 */\nfunc newMyList() *myList {\n    return &amp;myList{\n        arrCapacity: 10,              // 串列容量\n        arr:         make([]int, 10), // 陣列（儲存串列元素）\n        arrSize:     0,               // 串列長度（當前元素數量）\n        extendRatio: 2,               // 每次串列擴容的倍數\n    }\n}\n\n/* 獲取串列長度（當前元素數量） */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  獲取串列容量 */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* 訪問元素 */\nfunc (l *myList) get(index int) int {\n    // 索引如果越界，則丟擲異常，下同\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    return l.arr[index]\n}\n\n/* 更新元素 */\nfunc (l *myList) set(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    l.arr[index] = num\n}\n\n/* 在尾部新增元素 */\nfunc (l *myList) add(num int) {\n    // 元素數量超出容量時，觸發擴容機制\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // 更新元素數量\n    l.arrSize++\n}\n\n/* 在中間插入元素 */\nfunc (l *myList) insert(num, index int) {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    // 元素數量超出容量時，觸發擴容機制\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // 將索引 index 以及之後的元素都向後移動一位\n    for j := l.arrSize - 1; j &gt;= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // 更新元素數量\n    l.arrSize++\n}\n\n/* 刪除元素 */\nfunc (l *myList) remove(index int) int {\n    if index &lt; 0 || index &gt;= l.arrSize {\n        panic(\"索引越界\")\n    }\n    num := l.arr[index]\n    // 將索引 index 之後的元素都向前移動一位\n    for j := index; j &lt; l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // 更新元素數量\n    l.arrSize--\n    // 返回被刪除的元素\n    return num\n}\n\n/* 串列擴容 */\nfunc (l *myList) extendCapacity() {\n    // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // 更新串列容量\n    l.arrCapacity = len(l.arr)\n}\n\n/* 返回有效長度的串列 */\nfunc (l *myList) toArray() []int {\n    // 僅轉換有效長度範圍內的串列元素\n    return l.arr[:l.arrSize]\n}\n</code></pre> my_list.swift<pre><code>/* 串列類別 */\nclass MyList {\n    private var arr: [Int] // 陣列（儲存串列元素）\n    private var _capacity: Int // 串列容量\n    private var _size: Int // 串列長度（當前元素數量）\n    private let extendRatio: Int // 每次串列擴容的倍數\n\n    /* 建構子 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 獲取串列容量 */\n    func capacity() -&gt; Int {\n        _capacity\n    }\n\n    /* 訪問元素 */\n    func get(index: Int) -&gt; Int {\n        // 索引如果越界則丟擲錯誤，下同\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        return arr[index]\n    }\n\n    /* 更新元素 */\n    func set(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        arr[index] = num\n    }\n\n    /* 在尾部新增元素 */\n    func add(num: Int) {\n        // 元素數量超出容量時，觸發擴容機制\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // 更新元素數量\n        _size += 1\n    }\n\n    /* 在中間插入元素 */\n    func insert(index: Int, num: Int) {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        // 元素數量超出容量時，觸發擴容機制\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for j in (index ..&lt; size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // 更新元素數量\n        _size += 1\n    }\n\n    /* 刪除元素 */\n    @discardableResult\n    func remove(index: Int) -&gt; Int {\n        if index &lt; 0 || index &gt;= size() {\n            fatalError(\"索引越界\")\n        }\n        let num = arr[index]\n        // 將將索引 index 之後的元素都向前移動一位\n        for j in index ..&lt; (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // 更新元素數量\n        _size -= 1\n        // 返回被刪除的元素\n        return num\n    }\n\n    /* 串列擴容 */\n    func extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // 更新串列容量\n        _capacity = arr.count\n    }\n\n    /* 將串列轉換為陣列 */\n    func toArray() -&gt; [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n</code></pre> my_list.js<pre><code>/* 串列類別 */\nclass MyList {\n    #arr = new Array(); // 陣列（儲存串列元素）\n    #capacity = 10; // 串列容量\n    #size = 0; // 串列長度（當前元素數量）\n    #extendRatio = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    size() {\n        return this.#size;\n    }\n\n    /* 獲取串列容量 */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* 訪問元素 */\n    get(index) {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        return this.#arr[index];\n    }\n\n    /* 更新元素 */\n    set(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        this.#arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    add(num) {\n        // 如果長度等於容量，則需要擴容\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 將新元素新增到串列尾部\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* 在中間插入元素 */\n    insert(index, num) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        // 元素數量超出容量時，觸發擴容機制\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (let j = this.#size - 1; j &gt;= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // 更新元素數量\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* 刪除元素 */\n    remove(index) {\n        if (index &lt; 0 || index &gt;= this.#size) throw new Error('索引越界');\n        let num = this.#arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for (let j = index; j &lt; this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // 更新元素數量\n        this.#size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // 更新串列容量\n        this.#capacity = this.#arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    toArray() {\n        let size = this.size();\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.ts<pre><code>/* 串列類別 */\nclass MyList {\n    private arr: Array&lt;number&gt;; // 陣列（儲存串列元素）\n    private _capacity: number = 10; // 串列容量\n    private _size: number = 0; // 串列長度（當前元素數量）\n    private extendRatio: number = 2; // 每次串列擴容的倍數\n\n    /* 建構子 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* 獲取串列容量 */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* 訪問元素 */\n    public get(index: number): number {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        return this.arr[index];\n    }\n\n    /* 更新元素 */\n    public set(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        this.arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    public add(num: number): void {\n        // 如果長度等於容量，則需要擴容\n        if (this._size === this._capacity) this.extendCapacity();\n        // 將新元素新增到串列尾部\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* 在中間插入元素 */\n    public insert(index: number, num: number): void {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        // 元素數量超出容量時，觸發擴容機制\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (let j = this._size - 1; j &gt;= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // 更新元素數量\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* 刪除元素 */\n    public remove(index: number): number {\n        if (index &lt; 0 || index &gt;= this._size) throw new Error('索引越界');\n        let num = this.arr[index];\n        // 將將索引 index 之後的元素都向前移動一位\n        for (let j = index; j &lt; this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // 更新元素數量\n        this._size--;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    public extendCapacity(): void {\n        // 新建一個長度為 size 的陣列，並將原陣列複製到新陣列\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // 更新串列容量\n        this._capacity = this.arr.length;\n    }\n\n    /* 將串列轉換為陣列 */\n    public toArray(): number[] {\n        let size = this.size();\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(size);\n        for (let i = 0; i &lt; size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n</code></pre> my_list.dart<pre><code>/* 串列類別 */\nclass MyList {\n  late List&lt;int&gt; _arr; // 陣列（儲存串列元素）\n  int _capacity = 10; // 串列容量\n  int _size = 0; // 串列長度（當前元素數量）\n  int _extendRatio = 2; // 每次串列擴容的倍數\n\n  /* 建構子 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* 獲取串列長度（當前元素數量）*/\n  int size() =&gt; _size;\n\n  /* 獲取串列容量 */\n  int capacity() =&gt; _capacity;\n\n  /* 訪問元素 */\n  int get(int index) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    return _arr[index];\n  }\n\n  /* 更新元素 */\n  void set(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    _arr[index] = _num;\n  }\n\n  /* 在尾部新增元素 */\n  void add(int _num) {\n    // 元素數量超出容量時，觸發擴容機制\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // 更新元素數量\n    _size++;\n  }\n\n  /* 在中間插入元素 */\n  void insert(int index, int _num) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    // 元素數量超出容量時，觸發擴容機制\n    if (_size == _capacity) extendCapacity();\n    // 將索引 index 以及之後的元素都向後移動一位\n    for (var j = _size - 1; j &gt;= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // 更新元素數量\n    _size++;\n  }\n\n  /* 刪除元素 */\n  int remove(int index) {\n    if (index &gt;= _size) throw RangeError('索引越界');\n    int _num = _arr[index];\n    // 將將索引 index 之後的元素都向前移動一位\n    for (var j = index; j &lt; _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // 更新元素數量\n    _size--;\n    // 返回被刪除的元素\n    return _num;\n  }\n\n  /* 串列擴容 */\n  void extendCapacity() {\n    // 新建一個長度為原陣列 _extendRatio 倍的新陣列\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // 將原陣列複製到新陣列\n    List.copyRange(_newNums, 0, _arr);\n    // 更新 _arr 的引用\n    _arr = _newNums;\n    // 更新串列容量\n    _capacity = _arr.length;\n  }\n\n  /* 將串列轉換為陣列 */\n  List&lt;int&gt; toArray() {\n    List&lt;int&gt; arr = [];\n    for (var i = 0; i &lt; _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n</code></pre> my_list.rs<pre><code>/* 串列類別 */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec&lt;i32&gt;,       // 陣列（儲存串列元素）\n    capacity: usize,     // 串列容量\n    size: usize,         // 串列長度（當前元素數量）\n    extend_ratio: usize, // 每次串列擴容的倍數\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* 建構子 */\n    pub fn new(capacity: usize) -&gt; Self {\n        let mut vec = vec![0; capacity];\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* 獲取串列長度（當前元素數量）*/\n    pub fn size(&amp;self) -&gt; usize {\n        return self.size;\n    }\n\n    /* 獲取串列容量 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        return self.capacity;\n    }\n\n    /* 訪問元素 */\n    pub fn get(&amp;self, index: usize) -&gt; i32 {\n        // 索引如果越界，則丟擲異常，下同\n        if index &gt;= self.size {\n            panic!(\"索引越界\")\n        };\n        return self.arr[index];\n    }\n\n    /* 更新元素 */\n    pub fn set(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size {\n            panic!(\"索引越界\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* 在尾部新增元素 */\n    pub fn add(&amp;mut self, num: i32) {\n        // 元素數量超出容量時，觸發擴容機制\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // 更新元素數量\n        self.size += 1;\n    }\n\n    /* 在中間插入元素 */\n    pub fn insert(&amp;mut self, index: usize, num: i32) {\n        if index &gt;= self.size() {\n            panic!(\"索引越界\")\n        };\n        // 元素數量超出容量時，觸發擴容機制\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // 將索引 index 以及之後的元素都向後移動一位\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // 更新元素數量\n        self.size += 1;\n    }\n\n    /* 刪除元素 */\n    pub fn remove(&amp;mut self, index: usize) -&gt; i32 {\n        if index &gt;= self.size() {\n            panic!(\"索引越界\")\n        };\n        let num = self.arr[index];\n        // 將索引 index 之後的元素都向前移動一位\n        for j in index..self.size - 1 {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // 更新元素數量\n        self.size -= 1;\n        // 返回被刪除的元素\n        return num;\n    }\n\n    /* 串列擴容 */\n    pub fn extend_capacity(&amp;mut self) {\n        // 新建一個長度為原陣列 extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // 更新串列容量\n        self.capacity = new_capacity;\n    }\n\n    /* 將串列轉換為陣列 */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;i32&gt; {\n        // 僅轉換有效長度範圍內的串列元素\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n</code></pre> my_list.c<pre><code>/* 串列類別 */\ntypedef struct {\n    int *arr;        // 陣列（儲存串列元素）\n    int capacity;    // 串列容量\n    int size;        // 串列大小\n    int extendRatio; // 串列每次擴容的倍數\n} MyList;\n\n/* 建構子 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums-&gt;capacity = 10;\n    nums-&gt;arr = malloc(sizeof(int) * nums-&gt;capacity);\n    nums-&gt;size = 0;\n    nums-&gt;extendRatio = 2;\n    return nums;\n}\n\n/* 析構函式 */\nvoid delMyList(MyList *nums) {\n    free(nums-&gt;arr);\n    free(nums);\n}\n\n/* 獲取串列長度 */\nint size(MyList *nums) {\n    return nums-&gt;size;\n}\n\n/* 獲取串列容量 */\nint capacity(MyList *nums) {\n    return nums-&gt;capacity;\n}\n\n/* 訪問元素 */\nint get(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    return nums-&gt;arr[index];\n}\n\n/* 更新元素 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; nums-&gt;size);\n    nums-&gt;arr[index] = num;\n}\n\n/* 在尾部新增元素 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 擴容\n    }\n    nums-&gt;arr[size(nums)] = num;\n    nums-&gt;size++;\n}\n\n/* 在中間插入元素 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    // 元素數量超出容量時，觸發擴容機制\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // 擴容\n    }\n    for (int i = size(nums); i &gt; index; --i) {\n        nums-&gt;arr[i] = nums-&gt;arr[i - 1];\n    }\n    nums-&gt;arr[index] = num;\n    nums-&gt;size++;\n}\n\n/* 刪除元素 */\n// 注意：stdio.h 佔用了 remove 關鍵詞\nint removeItem(MyList *nums, int index) {\n    assert(index &gt;= 0 &amp;&amp; index &lt; size(nums));\n    int num = nums-&gt;arr[index];\n    for (int i = index; i &lt; size(nums) - 1; i++) {\n        nums-&gt;arr[i] = nums-&gt;arr[i + 1];\n    }\n    nums-&gt;size--;\n    return num;\n}\n\n/* 串列擴容 */\nvoid extendCapacity(MyList *nums) {\n    // 先分配空間\n    int newCapacity = capacity(nums) * nums-&gt;extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums-&gt;arr;\n\n    // 複製舊資料到新資料\n    for (int i = 0; i &lt; size(nums); i++)\n        extend[i] = nums-&gt;arr[i];\n\n    // 釋放舊資料\n    free(temp);\n\n    // 更新新資料\n    nums-&gt;arr = extend;\n    nums-&gt;capacity = newCapacity;\n}\n\n/* 將串列轉換為 Array 用於列印 */\nint *toArray(MyList *nums) {\n    return nums-&gt;arr;\n}\n</code></pre> my_list.kt<pre><code>/* 串列類別 */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // 陣列（儲存串列元素）\n    private var capacity: Int = 10 // 串列容量\n    private var size: Int = 0 // 串列長度（當前元素數量）\n    private var extendRatio: Int = 2 // 每次串列擴容的倍數\n\n    /* 建構子 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* 獲取串列長度（當前元素數量） */\n    fun size(): Int {\n        return size\n    }\n\n    /* 獲取串列容量 */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* 訪問元素 */\n    fun get(index: Int): Int {\n        // 索引如果越界，則丟擲異常，下同\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        return arr[index]\n    }\n\n    /* 更新元素 */\n    fun set(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        arr[index] = num\n    }\n\n    /* 在尾部新增元素 */\n    fun add(num: Int) {\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // 更新元素數量\n        size++\n    }\n\n    /* 在中間插入元素 */\n    fun insert(index: Int, num: Int) {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        // 元素數量超出容量時，觸發擴容機制\n        if (size == capacity())\n            extendCapacity()\n        // 將索引 index 以及之後的元素都向後移動一位\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // 更新元素數量\n        size++\n    }\n\n    /* 刪除元素 */\n    fun remove(index: Int): Int {\n        if (index &lt; 0 || index &gt;= size)\n            throw IndexOutOfBoundsException(\"索引越界\")\n        val num = arr[index]\n        // 將將索引 index 之後的元素都向前移動一位\n        for (j in index..&lt;size - 1)\n            arr[j] = arr[j + 1]\n        // 更新元素數量\n        size--\n        // 返回被刪除的元素\n        return num\n    }\n\n    /* 串列擴容 */\n    fun extendCapacity() {\n        // 新建一個長度為原陣列 extendRatio 倍的新陣列，並將原陣列複製到新陣列\n        arr = arr.copyOf(capacity() * extendRatio)\n        // 更新串列容量\n        capacity = arr.size\n    }\n\n    /* 將串列轉換為陣列 */\n    fun toArray(): IntArray {\n        val size = size()\n        // 僅轉換有效長度範圍內的串列元素\n        val arr = IntArray(size)\n        for (i in 0..&lt;size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n</code></pre> my_list.rb<pre><code>### 串列類別 ###\nclass MyList\n  attr_reader :size       # 獲取串列長度（當前元素數量）\n  attr_reader :capacity   # 獲取串列容量\n\n  ### 建構子 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new(capacity)\n  end\n\n  ### 訪問元素 ###\n  def get(index)\n    # 索引如果越界，則丟擲異常，下同\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    @arr[index]\n  end\n\n  ### 訪問元素 ###\n  def set(index, num)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    @arr[index] = num\n  end\n\n  ### 在尾部新增元素 ###\n  def add(num)\n    # 元素數量超出容量時，觸發擴容機制\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # 更新元素數量\n    @size += 1\n  end\n\n  ### 在中間插入元素 ###\n  def insert(index, num)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n\n    # 元素數量超出容量時，觸發擴容機制\n    extend_capacity if size == capacity\n\n    # 將索引 index 以及之後的元素都向後移動一位\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j]\n    end\n    @arr[index] = num\n\n    # 更新元素數量\n    @size += 1\n  end\n\n  ### 刪除元素 ###\n  def remove(index)\n    raise IndexError, \"索引越界\" if index &lt; 0 || index &gt;= size\n    num = @arr[index]\n\n    # 將將索引 index 之後的元素都向前移動一位\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # 更新元素數量\n    @size -= 1\n\n    # 返回被刪除的元素\n    num\n  end\n\n  ### 串列擴容 ###\n  def extend_capacity\n    # 新建一個長度為原陣列 extend_ratio 倍的新陣列，並將原陣列複製到新陣列\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # 更新串列容量\n    @capacity = arr.length\n  end\n\n  ### 將串列轉換為陣列 ###\n  def to_array\n    sz = size\n    # 僅轉換有效長度範圍內的串列元素\n    arr = Array.new(sz)\n    for i in 0...sz\n      arr[i] = get(i)\n    end\n    arr\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.3 &nbsp; 串列"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/","level":1,"title":"4.4   記憶體與快取 *","text":"<p>在本章的前兩節中，我們探討了陣列和鏈結串列這兩種基礎且重要的資料結構，它們分別代表了“連續儲存”和“分散儲存”兩種物理結構。</p> <p>實際上，物理結構在很大程度上決定了程式對記憶體和快取的使用效率，進而影響演算法程式的整體效能。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","level":2,"title":"4.4.1   計算機儲存裝置","text":"<p>計算機中包括三種類型的儲存裝置：硬碟（hard disk）、記憶體（random-access memory, RAM）、快取（cache memory）。表 4-2 展示了它們在計算機系統中的不同角色和效能特點。</p> <p> 表 4-2   計算機的儲存裝置 </p> 硬碟 記憶體 快取 用途 長期儲存資料，包括作業系統、程式、檔案等 臨時儲存當前執行的程式和正在處理的資料 儲存經常訪問的資料和指令，減少 CPU 訪問記憶體的次數 易失性 斷電後資料不會丟失 斷電後資料會丟失 斷電後資料會丟失 容量 較大，TB 級別 較小，GB 級別 非常小，MB 級別 速度 較慢，幾百到幾千 MB/s 較快，幾十 GB/s 非常快，幾十到幾百 GB/s 價格（人民幣） 較便宜，幾毛到幾元 / GB 較貴，幾十到幾百元 / GB 非常貴，隨 CPU 打包計價 <p>我們可以將計算機儲存系統想象為圖 4-9 所示的金字塔結構。越靠近金字塔頂端的儲存裝置的速度越快、容量越小、成本越高。這種多層級的設計並非偶然，而是計算機科學家和工程師們經過深思熟慮的結果。</p> <ul> <li>硬碟難以被記憶體取代。首先，記憶體中的資料在斷電後會丟失，因此它不適合長期儲存資料；其次，記憶體的成本是硬碟的幾十倍，這使得它難以在消費者市場普及。</li> <li>快取的大容量和高速度難以兼得。隨著 L1、L2、L3 快取的容量逐步增大，其物理尺寸會變大，與 CPU 核心之間的物理距離會變遠，從而導致資料傳輸時間增加，元素訪問延遲變高。在當前技術下，多層級的快取結構是容量、速度和成本之間的最佳平衡點。</li> </ul> <p></p> <p> 圖 4-9   計算機儲存系統 </p> <p>Tip</p> <p>計算機的儲存層次結構體現了速度、容量和成本三者之間的精妙平衡。實際上，這種權衡普遍存在於所有工業領域，它要求我們在不同的優勢和限制之間找到最佳平衡點。</p> <p>總的來說，硬碟用於長期儲存大量資料，記憶體用於臨時儲存程式執行中正在處理的資料，而快取則用於儲存經常訪問的資料和指令，以提高程式執行效率。三者共同協作，確保計算機系統高效執行。</p> <p>如圖 4-10 所示，在程式執行時，資料會從硬碟中被讀取到記憶體中，供 CPU 計算使用。快取可以看作 CPU 的一部分，它透過智慧地從記憶體載入資料，給 CPU 提供高速的資料讀取，從而顯著提升程式的執行效率，減少對較慢的記憶體的依賴。</p> <p></p> <p> 圖 4-10   硬碟、記憶體和快取之間的資料流通 </p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","level":2,"title":"4.4.2   資料結構的記憶體效率","text":"<p>在記憶體空間利用方面，陣列和鏈結串列各自具有優勢和侷限性。</p> <p>一方面，記憶體是有限的，且同一塊記憶體不能被多個程式共享，因此我們希望資料結構能夠儘可能高效地利用空間。陣列的元素緊密排列，不需要額外的空間來儲存鏈結串列節點間的引用（指標），因此空間效率更高。然而，陣列需要一次性分配足夠的連續記憶體空間，這可能導致記憶體浪費，陣列擴容也需要額外的時間和空間成本。相比之下，鏈結串列以“節點”為單位進行動態記憶體分配和回收，提供了更大的靈活性。</p> <p>另一方面，在程式執行時，隨著反覆申請與釋放記憶體，空閒記憶體的碎片化程度會越來越高，從而導致記憶體的利用效率降低。陣列由於其連續的儲存方式，相對不容易導致記憶體碎片化。相反，鏈結串列的元素是分散儲存的，在頻繁的插入與刪除操作中，更容易導致記憶體碎片化。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","level":2,"title":"4.4.3   資料結構的快取效率","text":"<p>快取雖然在空間容量上遠小於記憶體，但它比記憶體快得多，在程式執行速度上起著至關重要的作用。由於快取的容量有限，只能儲存一小部分頻繁訪問的資料，因此當 CPU 嘗試訪問的資料不在快取中時，就會發生快取未命中（cache miss），此時 CPU 不得不從速度較慢的記憶體中載入所需資料。</p> <p>顯然，“快取未命中”越少，CPU 讀寫資料的效率就越高，程式效能也就越好。我們將 CPU 從快取中成功獲取資料的比例稱為快取命中率（cache hit rate），這個指標通常用來衡量快取效率。</p> <p>為了儘可能達到更高的效率，快取會採取以下資料載入機制。</p> <ul> <li>快取行：快取不是單個位元組地儲存與載入資料，而是以快取行為單位。相比於單個位元組的傳輸，快取行的傳輸形式更加高效。</li> <li>預取機制：處理器會嘗試預測資料訪問模式（例如順序訪問、固定步長跳躍訪問等），並根據特定模式將資料載入至快取之中，從而提升命中率。</li> <li>空間區域性：如果一個數據被訪問，那麼它附近的資料可能近期也會被訪問。因此，快取在載入某一資料時，也會載入其附近的資料，以提高命中率。</li> <li>時間區域性：如果一個數據被訪問，那麼它在不久的將來很可能再次被訪問。快取利用這一原理，透過保留最近訪問過的資料來提高命中率。</li> </ul> <p>實際上，陣列和鏈結串列對快取的利用效率是不同的，主要體現在以下幾個方面。</p> <ul> <li>佔用空間：鏈結串列元素比陣列元素佔用空間更多，導致快取中容納的有效資料量更少。</li> <li>快取行：鏈結串列資料分散在記憶體各處，而快取是“按行載入”的，因此載入到無效資料的比例更高。</li> <li>預取機制：陣列比鏈結串列的資料訪問模式更具“可預測性”，即系統更容易猜出即將被載入的資料。</li> <li>空間區域性：陣列被儲存在集中的記憶體空間中，因此被載入資料附近的資料更有可能即將被訪問。</li> </ul> <p>總體而言，陣列具有更高的快取命中率，因此它在操作效率上通常優於鏈結串列。這使得在解決演算法問題時，基於陣列實現的資料結構往往更受歡迎。</p> <p>需要注意的是，高快取效率並不意味著陣列在所有情況下都優於鏈結串列。實際應用中選擇哪種資料結構，應根據具體需求來決定。例如，陣列和鏈結串列都可以實現“堆疊”資料結構（下一章會詳細介紹），但它們適用於不同場景。</p> <ul> <li>在做演算法題時，我們會傾向於選擇基於陣列實現的堆疊，因為它提供了更高的操作效率和隨機訪問的能力，代價僅是需要預先為陣列分配一定的記憶體空間。</li> <li>如果資料量非常大、動態性很高、堆疊的預期大小難以估計，那麼基於鏈結串列實現的堆疊更加合適。鏈結串列能夠將大量資料分散儲存於記憶體的不同部分，並且避免了陣列擴容產生的額外開銷。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.4 &nbsp; 記憶體與快取 *"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/","level":1,"title":"4.5   小結","text":"","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>陣列和鏈結串列是兩種基本的資料結構，分別代表資料在計算機記憶體中的兩種儲存方式：連續空間儲存和分散空間儲存。兩者的特點呈現出互補的特性。</li> <li>陣列支持隨機訪問、佔用記憶體較少；但插入和刪除元素效率低，且初始化後長度不可變。</li> <li>鏈結串列透過更改引用（指標）實現高效的節點插入與刪除，且可以靈活調整長度；但節點訪問效率低、佔用記憶體較多。常見的鏈結串列型別包括單向鏈結串列、環形鏈結串列、雙向鏈結串列。</li> <li>串列是一種支持增刪查改的元素有序集合，通常基於動態陣列實現。它保留了陣列的優勢，同時可以靈活調整長度。</li> <li>串列的出現大幅提高了陣列的實用性，但可能導致部分記憶體空間浪費。</li> <li>程式執行時，資料主要儲存在記憶體中。陣列可提供更高的記憶體空間效率，而鏈結串列則在記憶體使用上更加靈活。</li> <li>快取透過快取行、預取機制以及空間區域性和時間區域性等資料載入機制，為 CPU 提供快速資料訪問，顯著提升程式的執行效率。</li> <li>由於陣列具有更高的快取命中率，因此它通常比鏈結串列更高效。在選擇資料結構時，應根據具體需求和場景做出恰當選擇。</li> </ul>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：陣列儲存在堆疊上和儲存在堆積上，對時間效率和空間效率是否有影響？</p> <p>儲存在堆疊上和堆積上的陣列都被儲存在連續記憶體空間內，資料操作效率基本一致。然而，堆疊和堆積具有各自的特點，從而導致以下不同點。</p> <ol> <li>分配和釋放效率：堆疊是一塊較小的記憶體，分配由編譯器自動完成；而堆積記憶體相對更大，可以在程式碼中動態分配，更容易碎片化。因此，堆積上的分配和釋放操作通常比堆疊上的慢。</li> <li>大小限制：堆疊記憶體相對較小，堆積的大小一般受限於可用記憶體。因此堆積更加適合儲存大型陣列。</li> <li>靈活性：堆疊上的陣列的大小需要在編譯時確定，而堆積上的陣列的大小可以在執行時動態確定。</li> </ol> <p>Q：為什麼陣列要求相同型別的元素，而在鏈結串列中卻沒有強調相同型別呢？</p> <p>鏈結串列由節點組成，節點之間透過引用（指標）連線，各個節點可以儲存不同型別的資料，例如 <code>int</code>、<code>double</code>、<code>string</code>、<code>object</code> 等。</p> <p>相對地，陣列元素則必須是相同型別的，這樣才能透過計算偏移量來獲取對應元素位置。例如，陣列同時包含 <code>int</code> 和 <code>long</code> 兩種型別，單個元素分別佔用 4 位元組和 8 位元組 ，此時就不能用以下公式計算偏移量了，因為陣列中包含了兩種“元素長度”。</p> <pre><code># 元素記憶體位址 = 陣列記憶體位址（首元素記憶體位址） + 元素長度 * 元素索引\n</code></pre> <p>Q：刪除節點 <code>P</code> 後，是否需要把 <code>P.next</code> 設為 <code>None</code> 呢？</p> <p>不修改 <code>P.next</code> 也可以。從該鏈結串列的角度看，從頭節點走訪到尾節點已經不會遇到 <code>P</code> 了。這意味著節點 <code>P</code> 已經從鏈結串列中刪除了，此時節點 <code>P</code> 指向哪裡都不會對該鏈結串列產生影響。</p> <p>從資料結構與演算法（做題）的角度看，不斷開沒有關係，只要保證程式的邏輯是正確的就行。從標準庫的角度看，斷開更加安全、邏輯更加清晰。如果不斷開，假設被刪除節點未被正常回收，那麼它會影響後繼節點的記憶體回收。</p> <p>Q：在鏈結串列中插入和刪除操作的時間複雜度是 \\(O(1)\\) 。但是增刪之前都需要 \\(O(n)\\) 的時間查詢元素，那為什麼時間複雜度不是 \\(O(n)\\) 呢？</p> <p>如果是先查詢元素、再刪除元素，時間複雜度確實是 \\(O(n)\\) 。然而，鏈結串列的 \\(O(1)\\) 增刪的優勢可以在其他應用上得到體現。例如，雙向佇列適合使用鏈結串列實現，我們維護一個指標變數始終指向頭節點、尾節點，每次插入與刪除操作都是 \\(O(1)\\) 。</p> <p>Q：圖“鏈結串列定義與儲存方式”中，淺藍色的儲存節點指標是佔用一塊記憶體位址嗎？還是和節點值各佔一半呢？</p> <p>該示意圖只是定性表示，定量表示需要根據具體情況進行分析。</p> <ul> <li>不同型別的節點值佔用的空間是不同的，比如 <code>int</code>、<code>long</code>、<code>double</code> 和例項物件等。</li> <li>指標變數佔用的記憶體空間大小根據所使用的作業系統及編譯環境而定，大多為 8 位元組或 4 位元組。</li> </ul> <p>Q：在串列末尾新增元素是否時時刻刻都為 \\(O(1)\\) ？</p> <p>如果新增元素時超出串列長度，則需要先擴容串列再新增。系統會申請一塊新的記憶體，並將原串列的所有元素搬運過去，這時候時間複雜度就會是 \\(O(n)\\) 。</p> <p>Q：“串列的出現極大地提高了陣列的實用性，但可能導致部分記憶體空間浪費”，這裡的空間浪費是指額外增加的變數如容量、長度、擴容倍數所佔的記憶體嗎？</p> <p>這裡的空間浪費主要有兩方面含義：一方面，串列都會設定一個初始長度，我們不一定需要用這麼多；另一方面，為了防止頻繁擴容，擴容一般會乘以一個係數，比如 \\(\\times 1.5\\) 。這樣一來，也會出現很多空位，我們通常不能完全填滿它們。</p> <p>Q：在 Python 中初始化 <code>n = [1, 2, 3]</code> 後，這 3 個元素的位址是相連的，但是初始化 <code>m = [2, 1, 3]</code> 會發現它們每個元素的 id 並不是連續的，而是分別跟 <code>n</code> 中的相同。這些元素的位址不連續，那麼 <code>m</code> 還是陣列嗎？</p> <p>假如把串列元素換成鏈結串列節點 <code>n = [n1, n2, n3, n4, n5]</code> ，通常情況下這 5 個節點物件也分散儲存在記憶體各處。然而，給定一個串列索引，我們仍然可以在 \\(O(1)\\) 時間內獲取節點記憶體位址，從而訪問到對應的節點。這是因為陣列中儲存的是節點的引用，而非節點本身。</p> <p>與許多語言不同，Python 中的數字也被包裝為物件，串列中儲存的不是數字本身，而是對數字的引用。因此，我們會發現兩個陣列中的相同數字擁有同一個 id ，並且這些數字的記憶體位址無須連續。</p> <p>Q：C++ STL 裡面的 <code>std::list</code> 已經實現了雙向鏈結串列，但好像一些演算法書上不怎麼直接使用它，是不是因為有什麼侷限性呢？</p> <p>一方面，我們往往更青睞使用陣列實現演算法，而只在必要時才使用鏈結串列，主要有兩個原因。</p> <ul> <li>空間開銷：由於每個元素需要兩個額外的指標（一個用於前一個元素，一個用於後一個元素），所以 <code>std::list</code> 通常比 <code>std::vector</code> 更佔用空間。</li> <li>快取不友好：由於資料不是連續存放的，因此 <code>std::list</code> 對快取的利用率較低。一般情況下，<code>std::vector</code> 的效能會更好。</li> </ul> <p>另一方面，必要使用鏈結串列的情況主要是二元樹和圖。堆疊和佇列往往會使用程式語言提供的 <code>stack</code> 和 <code>queue</code> ，而非鏈結串列。</p> <p>Q：操作 <code>res = [[0]] * n</code> 生成了一個二維串列，其中每一個 <code>[0]</code> 都是獨立的嗎？</p> <p>不是獨立的。此二維串列中，所有的 <code>[0]</code> 實際上是同一個物件的引用。如果我們修改其中一個元素，會發現所有的對應元素都會隨之改變。</p> <p>如果希望二維串列中的每個 <code>[0]</code> 都是獨立的，可以使用 <code>res = [[0] for _ in range(n)]</code> 來實現。這種方式的原理是初始化了 \\(n\\) 個獨立的 <code>[0]</code> 串列物件。</p> <p>Q：操作 <code>res = [0] * n</code> 生成了一個串列，其中每一個整數 0 都是獨立的嗎？</p> <p>在該串列中，所有整數 0 都是同一個物件的引用。這是因為 Python 對小整數（通常是 -5 到 256）採用了快取池機制，以便最大化物件複用，從而提升效能。</p> <p>雖然它們指向同一個物件，但我們仍然可以獨立修改串列中的每個元素，這是因為 Python 的整數是“不可變物件”。當我們修改某個元素時，實際上是切換為另一個物件的引用，而不是改變原有物件本身。</p> <p>然而，當串列元素是“可變物件”時（例如串列、字典或類別例項等），修改某個元素會直接改變該物件本身，所有引用該物件的元素都會產生相同變化。</p>","path":["第 4 章 &nbsp; 陣列與鏈結串列","4.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/","level":1,"title":"第 13 章   回溯","text":"<p>Abstract</p> <p>我們如同迷宮中的探索者，在前進的道路上可能會遇到困難。</p> <p>回溯的力量讓我們能夠重新開始，不斷嘗試，最終找到通往光明的出口。</p>","path":["第 13 章 &nbsp; 回溯"],"tags":[]},{"location":"chapter_backtracking/#_1","level":2,"title":"本章內容","text":"<ul> <li>13.1   回溯演算法</li> <li>13.2   全排列問題</li> <li>13.3   子集和問題</li> <li>13.4   N 皇后問題</li> <li>13.5   小結</li> </ul>","path":["第 13 章 &nbsp; 回溯"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/","level":1,"title":"13.1   回溯演算法","text":"<p>回溯演算法（backtracking algorithm）是一種透過窮舉來解決問題的方法，它的核心思想是從一個初始狀態出發，暴力搜尋所有可能的解決方案，當遇到正確的解則將其記錄，直到找到解或者嘗試了所有可能的選擇都無法找到解為止。</p> <p>回溯演算法通常採用“深度優先搜尋”來走訪解空間。在“二元樹”章節中，我們提到前序、中序和後序走訪都屬於深度優先搜尋。接下來，我們利用前序走訪構造一個回溯問題，逐步瞭解回溯演算法的工作原理。</p> <p>例題一</p> <p>給定一棵二元樹，搜尋並記錄所有值為 \\(7\\) 的節點，請返回節點串列。</p> <p>對於此題，我們前序走訪這棵樹，並判斷當前節點的值是否為 \\(7\\) ，若是，則將該節點的值加入結果串列 <code>res</code> 之中。相關過程實現如圖 13-1 和以下程式碼所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_i_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題一\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # 記錄解\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n</code></pre> preorder_traversal_i_compact.cpp<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(root);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.java<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 記錄解\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.cs<pre><code>/* 前序走訪：例題一 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n</code></pre> preorder_traversal_i_compact.go<pre><code>/* 前序走訪：例題一 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // 記錄解\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n</code></pre> preorder_traversal_i_compact.swift<pre><code>/* 前序走訪：例題一 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // 記錄解\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n</code></pre> preorder_traversal_i_compact.js<pre><code>/* 前序走訪：例題一 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 記錄解\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.ts<pre><code>/* 前序走訪：例題一 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // 記錄解\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.dart<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode? root, List&lt;TreeNode&gt; res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // 記錄解\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n</code></pre> preorder_traversal_i_compact.rs<pre><code>/* 前序走訪：例題一 */\nfn pre_order(res: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.as_ref());\n        pre_order(res, node.borrow().right.as_ref());\n    }\n}\n</code></pre> preorder_traversal_i_compact.c<pre><code>/* 前序走訪：例題一 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res[resSize++] = root;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n</code></pre> preorder_traversal_i_compact.kt<pre><code>/* 前序走訪：例題一 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n</code></pre> preorder_traversal_i_compact.rb<pre><code>### 前序走訪：例題一 ###\ndef pre_order(root)\n  return unless root\n\n  # 記錄解\n  $res &lt;&lt; root if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 13-1   在前序走訪中搜索節點 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1311","level":2,"title":"13.1.1   嘗試與回退","text":"<p>之所以稱之為回溯演算法，是因為該演算法在搜尋解空間時會採用“嘗試”與“回退”的策略。當演算法在搜尋過程中遇到某個狀態無法繼續前進或無法得到滿足條件的解時，它會撤銷上一步的選擇，退回到之前的狀態，並嘗試其他可能的選擇。</p> <p>對於例題一，訪問每個節點都代表一次“嘗試”，而越過葉節點或返回父節點的 <code>return</code> 則表示“回退”。</p> <p>值得說明的是，回退並不僅僅包括函式返回。為解釋這一點，我們對例題一稍作拓展。</p> <p>例題二</p> <p>在二元樹中搜索所有值為 \\(7\\) 的節點，請返回根節點到這些節點的路徑。</p> <p>在例題一程式碼的基礎上，我們需要藉助一個串列 <code>path</code> 記錄訪問過的節點路徑。當訪問到值為 \\(7\\) 的節點時，則複製 <code>path</code> 並新增進結果串列 <code>res</code> 。走訪完成後，<code>res</code> 中儲存的就是所有的解。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_ii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題二\"\"\"\n    if root is None:\n        return\n    # 嘗試\n    path.append(root)\n    if root.val == 7:\n        # 記錄解\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # 回退\n    path.pop()\n</code></pre> preorder_traversal_ii_compact.cpp<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // 嘗試\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    path.pop_back();\n}\n</code></pre> preorder_traversal_ii_compact.java<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // 嘗試\n    path.add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // 回退\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_ii_compact.cs<pre><code>/* 前序走訪：例題二 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // 嘗試\n    path.Add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // 回退\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_ii_compact.go<pre><code>/* 前序走訪：例題二 */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // 嘗試\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 記錄解\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // 回退\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_ii_compact.swift<pre><code>/* 前序走訪：例題二 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 嘗試\n    path.append(root)\n    if root.val == 7 {\n        // 記錄解\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // 回退\n    path.removeLast()\n}\n</code></pre> preorder_traversal_ii_compact.js<pre><code>/* 前序走訪：例題二 */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.ts<pre><code>/* 前序走訪：例題二 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_ii_compact.dart<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // 嘗試\n  path.add(root);\n  if (root.val == 7) {\n    // 記錄解\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // 回退\n  path.removeLast();\n}\n</code></pre> preorder_traversal_ii_compact.rs<pre><code>/* 前序走訪：例題二 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // 嘗試\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // 回退\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_ii_compact.c<pre><code>/* 前序走訪：例題二 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // 嘗試\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 記錄解\n        for (int i = 0; i &lt; pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    pathSize--;\n}\n</code></pre> preorder_traversal_ii_compact.kt<pre><code>/* 前序走訪：例題二 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // 嘗試\n    path!!.add(root)\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // 回退\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_ii_compact.rb<pre><code>### 前序走訪：例題二 ###\ndef pre_order(root)\n  return unless root\n\n  # 嘗試\n  $path &lt;&lt; root\n\n  # 記錄解\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # 回退\n  $path.pop\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在每次“嘗試”中，我們透過將當前節點新增進 <code>path</code> 來記錄路徑；而在“回退”前，我們需要將該節點從 <code>path</code> 中彈出，以恢復本次嘗試之前的狀態。</p> <p>觀察圖 13-2 所示的過程，我們可以將嘗試和回退理解為“前進”與“撤銷”，兩個操作互為逆向。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 13-2   嘗試與回退 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1312","level":2,"title":"13.1.2   剪枝","text":"<p>複雜的回溯問題通常包含一個或多個約束條件，約束條件通常可用於“剪枝”。</p> <p>例題三</p> <p>在二元樹中搜索所有值為 \\(7\\) 的節點，請返回根節點到這些節點的路徑，並要求路徑中不包含值為 \\(3\\) 的節點。</p> <p>為了滿足以上約束條件，我們需要新增剪枝操作：在搜尋過程中，若遇到值為 \\(3\\) 的節點，則提前返回，不再繼續搜尋。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_compact.py<pre><code>def pre_order(root: TreeNode):\n    \"\"\"前序走訪：例題三\"\"\"\n    # 剪枝\n    if root is None or root.val == 3:\n        return\n    # 嘗試\n    path.append(root)\n    if root.val == 7:\n        # 記錄解\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # 回退\n    path.pop()\n</code></pre> preorder_traversal_iii_compact.cpp<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode *root) {\n    // 剪枝\n    if (root == nullptr || root-&gt;val == 3) {\n        return;\n    }\n    // 嘗試\n    path.push_back(root);\n    if (root-&gt;val == 7) {\n        // 記錄解\n        res.push_back(path);\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    path.pop_back();\n}\n</code></pre> preorder_traversal_iii_compact.java<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode root) {\n    // 剪枝\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 嘗試\n    path.add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.add(new ArrayList&lt;&gt;(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // 回退\n    path.remove(path.size() - 1);\n}\n</code></pre> preorder_traversal_iii_compact.cs<pre><code>/* 前序走訪：例題三 */\nvoid PreOrder(TreeNode? root) {\n    // 剪枝\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // 嘗試\n    path.Add(root);\n    if (root.val == 7) {\n        // 記錄解\n        res.Add(new List&lt;TreeNode&gt;(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // 回退\n    path.RemoveAt(path.Count - 1);\n}\n</code></pre> preorder_traversal_iii_compact.go<pre><code>/* 前序走訪：例題三 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    // 剪枝\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // 嘗試\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // 記錄解\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // 回退\n    *path = (*path)[:len(*path)-1]\n}\n</code></pre> preorder_traversal_iii_compact.swift<pre><code>/* 前序走訪：例題三 */\nfunc preOrder(root: TreeNode?) {\n    // 剪枝\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // 嘗試\n    path.append(root)\n    if root.val == 7 {\n        // 記錄解\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // 回退\n    path.removeLast()\n}\n</code></pre> preorder_traversal_iii_compact.js<pre><code>/* 前序走訪：例題三 */\nfunction preOrder(root, path, res) {\n    // 剪枝\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.ts<pre><code>/* 前序走訪：例題三 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 剪枝\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // 嘗試\n    path.push(root);\n    if (root.val === 7) {\n        // 記錄解\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // 回退\n    path.pop();\n}\n</code></pre> preorder_traversal_iii_compact.dart<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(\n  TreeNode? root,\n  List&lt;TreeNode&gt; path,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // 嘗試\n  path.add(root);\n  if (root.val == 7) {\n    // 記錄解\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // 回退\n  path.removeLast();\n}\n</code></pre> preorder_traversal_iii_compact.rs<pre><code>/* 前序走訪：例題三 */\nfn pre_order(\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    path: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n) {\n    // 剪枝\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // 嘗試\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // 記錄解\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.as_ref());\n        pre_order(res, path, node.borrow().right.as_ref());\n        // 回退\n        path.pop();\n    }\n}\n</code></pre> preorder_traversal_iii_compact.c<pre><code>/* 前序走訪：例題三 */\nvoid preOrder(TreeNode *root) {\n    // 剪枝\n    if (root == NULL || root-&gt;val == 3) {\n        return;\n    }\n    // 嘗試\n    path[pathSize++] = root;\n    if (root-&gt;val == 7) {\n        // 記錄解\n        for (int i = 0; i &lt; pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n    // 回退\n    pathSize--;\n}\n</code></pre> preorder_traversal_iii_compact.kt<pre><code>/* 前序走訪：例題三 */\nfun preOrder(root: TreeNode?) {\n    // 剪枝\n    if (root == null || root._val == 3) {\n        return\n    }\n    // 嘗試\n    path!!.add(root)\n    if (root._val == 7) {\n        // 記錄解\n        res!!.add(path!!.toMutableList())\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // 回退\n    path!!.removeAt(path!!.size - 1)\n}\n</code></pre> preorder_traversal_iii_compact.rb<pre><code>### 前序走訪：例題三 ###\ndef pre_order(root)\n  # 剪枝\n  return if !root || root.val == 3\n\n  # 嘗試\n  $path.append(root)\n\n  # 記錄解\n  $res &lt;&lt; $path.dup if root.val == 7\n\n  pre_order(root.left)\n  pre_order(root.right)\n\n  # 回退\n  $path.pop\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>“剪枝”是一個非常形象的名詞。如圖 13-3 所示，在搜尋過程中，我們“剪掉”了不滿足約束條件的搜尋分支，避免許多無意義的嘗試，從而提高了搜尋效率。</p> <p></p> <p> 圖 13-3   根據約束條件剪枝 </p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1313","level":2,"title":"13.1.3   框架程式碼","text":"<p>接下來，我們嘗試將回溯的“嘗試、回退、剪枝”的主體框架提煉出來，提升程式碼的通用性。</p> <p>在以下框架程式碼中，<code>state</code> 表示問題的當前狀態，<code>choices</code> 表示當前狀態下可以做出的選擇：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"回溯演算法框架\"\"\"\n    # 判斷是否為解\n    if is_solution(state):\n        # 記錄解\n        record_solution(state, res)\n        # 不再繼續搜尋\n        return\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：判斷選擇是否合法\n        if is_valid(state, choice):\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State *state, vector&lt;Choice *&gt; &amp;choices, vector&lt;State *&gt; &amp;res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (Choice choice : choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (Choice choice : choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid Backtrack(State state, List&lt;Choice&gt; choices, List&lt;State&gt; res) {\n    // 判斷是否為解\n    if (IsSolution(state)) {\n        // 記錄解\n        RecordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    foreach (Choice choice in choices) {\n        // 剪枝：判斷選擇是否合法\n        if (IsValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // 判斷是否為解\n    if isSolution(state) {\n        // 記錄解\n        recordSolution(state, res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for _, choice := range choices {\n        // 剪枝：判斷選擇是否合法\n        if isValid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n    // 判斷是否為解\n    if isSolution(state: state) {\n        // 記錄解\n        recordSolution(state: state, res: &amp;res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：判斷選擇是否合法\n        if isValid(state: state, choice: choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state: &amp;state, choice: choice)\n            backtrack(state: &amp;state, choices: choices, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunction backtrack(state, choices, res) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (let choice of choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (let choice of choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State state, List&lt;Choice&gt;, List&lt;State&gt; res) {\n  // 判斷是否為解\n  if (isSolution(state)) {\n    // 記錄解\n    recordSolution(state, res);\n    // 不再繼續搜尋\n    return;\n  }\n  // 走訪所有選擇\n  for (Choice choice in choices) {\n    // 剪枝：判斷選擇是否合法\n    if (isValid(state, choice)) {\n      // 嘗試：做出選擇，更新狀態\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfn backtrack(state: &amp;mut State, choices: &amp;Vec&lt;Choice&gt;, res: &amp;mut Vec&lt;State&gt;) {\n    // 判斷是否為解\n    if is_solution(state) {\n        // 記錄解\n        record_solution(state, res);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：判斷選擇是否合法\n        if is_valid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res, numRes);\n        // 不再繼續搜尋\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; numChoices; i++) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, &amp;choices[i])) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, &amp;choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, &amp;choices[i]);\n        }\n    }\n}\n</code></pre> <pre><code>/* 回溯演算法框架 */\nfun backtrack(state: State?, choices: List&lt;Choice?&gt;, res: List&lt;State?&gt;?) {\n    // 判斷是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res)\n        // 不再繼續搜尋\n        return\n    }\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：判斷選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> <pre><code>### 回溯演算法框架 ###\ndef backtrack(state, choices, res)\n    # 判斷是否為解\n    if is_solution?(state)\n        # 記錄解\n        record_solution(state, res)\n        return\n    end\n\n    # 走訪所有選擇\n    for choice in choices\n        # 剪枝：判斷選擇是否合法\n        if is_valid?(state, choice)\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n        end\n    end\nend\n</code></pre> <p>接下來，我們基於框架程式碼來解決例題三。狀態 <code>state</code> 為節點走訪路徑，選擇 <code>choices</code> 為當前節點的左子節點和右子節點，結果 <code>res</code> 是路徑串列：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby preorder_traversal_iii_template.py<pre><code>def is_solution(state: list[TreeNode]) -&gt; bool:\n    \"\"\"判斷當前狀態是否為解\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"記錄解\"\"\"\n    res.append(list(state))\n\ndef is_valid(state: list[TreeNode], choice: TreeNode) -&gt; bool:\n    \"\"\"判斷在當前狀態下，該選擇是否合法\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"更新狀態\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"恢復狀態\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n    \"\"\"回溯演算法：例題三\"\"\"\n    # 檢查是否為解\n    if is_solution(state):\n        # 記錄解\n        record_solution(state, res)\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：檢查選擇是否合法\n        if is_valid(state, choice):\n            # 嘗試：做出選擇，更新狀態\n            make_choice(state, choice)\n            # 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice)\n</code></pre> preorder_traversal_iii_template.cpp<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(vector&lt;TreeNode *&gt; &amp;state) {\n    return !state.empty() &amp;&amp; state.back()-&gt;val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(vector&lt;TreeNode *&gt; &amp;state, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    res.push_back(state);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    return choice != nullptr &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(vector&lt;TreeNode *&gt; &amp;state, TreeNode *choice) {\n    state.pop_back();\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(vector&lt;TreeNode *&gt; &amp;state, vector&lt;TreeNode *&gt; &amp;choices, vector&lt;vector&lt;TreeNode *&gt;&gt; &amp;res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (TreeNode *choice : choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            vector&lt;TreeNode *&gt; nextChoices{choice-&gt;left, choice-&gt;right};\n            backtrack(state, nextChoices, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.java<pre><code>/* 判斷當前狀態是否為解 */\nboolean isSolution(List&lt;TreeNode&gt; state) {\n    return !state.isEmpty() &amp;&amp; state.get(state.size() - 1).val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.add(new ArrayList&lt;&gt;(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nboolean isValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (TreeNode choice : choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, Arrays.asList(choice.left, choice.right), res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.cs<pre><code>/* 判斷當前狀態是否為解 */\nbool IsSolution(List&lt;TreeNode&gt; state) {\n    return state.Count != 0 &amp;&amp; state[^1].val == 7;\n}\n\n/* 記錄解 */\nvoid RecordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    res.Add(new List&lt;TreeNode&gt;(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool IsValid(List&lt;TreeNode&gt; state, TreeNode choice) {\n    return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid MakeChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* 恢復狀態 */\nvoid UndoChoice(List&lt;TreeNode&gt; state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\n\n/* 回溯演算法：例題三 */\nvoid Backtrack(List&lt;TreeNode&gt; state, List&lt;TreeNode&gt; choices, List&lt;List&lt;TreeNode&gt;&gt; res) {\n    // 檢查是否為解\n    if (IsSolution(state)) {\n        // 記錄解\n        RecordSolution(state, res);\n    }\n    // 走訪所有選擇\n    foreach (TreeNode choice in choices) {\n        // 剪枝：檢查選擇是否合法\n        if (IsValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            MakeChoice(state, choice);\n            // 進行下一輪選擇\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            UndoChoice(state, choice);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.go<pre><code>/* 判斷當前狀態是否為解 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 &amp;&amp; (*state)[len(*state)-1].Val == 7\n}\n\n/* 記錄解 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\n    return choice != nil &amp;&amp; choice.Val != 3\n}\n\n/* 更新狀態 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* 恢復狀態 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\n\n/* 回溯演算法：例題三 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n    // 檢查是否為解\n    if isSolution(state) {\n        // 記錄解\n        recordSolution(state, res)\n    }\n    // 走訪所有選擇\n    for _, choice := range *choices {\n        // 剪枝：檢查選擇是否合法\n        if isValid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            // 進行下一輪選擇\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &amp;temp, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.swift<pre><code>/* 判斷當前狀態是否為解 */\nfunc isSolution(state: [TreeNode]) -&gt; Bool {\n    !state.isEmpty &amp;&amp; state.last!.val == 7\n}\n\n/* 記錄解 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -&gt; Bool {\n    choice != nil &amp;&amp; choice!.val != 3\n}\n\n/* 更新狀態 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* 恢復狀態 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\n\n/* 回溯演算法：例題三 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n    // 檢查是否為解\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &amp;res)\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：檢查選擇是否合法\n        if isValid(state: state, choice: choice) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state: &amp;state, choice: choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: [choice.left, choice.right].compactMap { $0 }, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state: &amp;state, choice: choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.js<pre><code>/* 判斷當前狀態是否為解 */\nfunction isSolution(state) {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 記錄解 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunction isValid(state, choice) {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 更新狀態 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfunction backtrack(state, choices, res) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.ts<pre><code>/* 判斷當前狀態是否為解 */\nfunction isSolution(state: TreeNode[]): boolean {\n    return state &amp;&amp; state[state.length - 1]?.val === 7;\n}\n\n/* 記錄解 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\n    return choice !== null &amp;&amp; choice.val !== 3;\n}\n\n/* 更新狀態 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res);\n    }\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice);\n            // 進行下一輪選擇\n            backtrack(state, [choice.left, choice.right], res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state);\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.dart<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(List&lt;TreeNode&gt; state) {\n  return state.isNotEmpty &amp;&amp; state.last.val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(List&lt;TreeNode&gt; state, List&lt;List&lt;TreeNode&gt;&gt; res) {\n  res.add(List.from(state));\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  return choice != null &amp;&amp; choice.val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* 恢復狀態 */\nvoid undoChoice(List&lt;TreeNode&gt; state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(\n  List&lt;TreeNode&gt; state,\n  List&lt;TreeNode?&gt; choices,\n  List&lt;List&lt;TreeNode&gt;&gt; res,\n) {\n  // 檢查是否為解\n  if (isSolution(state)) {\n    // 記錄解\n    recordSolution(state, res);\n  }\n  // 走訪所有選擇\n  for (TreeNode? choice in choices) {\n    // 剪枝：檢查選擇是否合法\n    if (isValid(state, choice)) {\n      // 嘗試：做出選擇，更新狀態\n      makeChoice(state, choice);\n      // 進行下一輪選擇\n      backtrack(state, [choice!.left, choice.right], res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      undoChoice(state, choice);\n    }\n  }\n}\n</code></pre> preorder_traversal_iii_template.rs<pre><code>/* 判斷當前狀態是否為解 */\nfn is_solution(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return !state.is_empty() &amp;&amp; state.last().unwrap().borrow().val == 7;\n}\n\n/* 記錄解 */\nfn record_solution(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    res.push(state.clone());\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfn is_valid(_: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; bool {\n    return choice.is_some() &amp;&amp; choice.unwrap().borrow().val != 3;\n}\n\n/* 更新狀態 */\nfn make_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, choice: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.push(choice);\n}\n\n/* 恢復狀態 */\nfn undo_choice(state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, _: Rc&lt;RefCell&lt;TreeNode&gt;&gt;) {\n    state.pop();\n}\n\n/* 回溯演算法：例題三 */\nfn backtrack(\n    state: &amp;mut Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,\n    choices: &amp;Vec&lt;Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;&gt;,\n) {\n    // 檢查是否為解\n    if is_solution(state) {\n        // 記錄解\n        record_solution(state, res);\n    }\n    // 走訪所有選擇\n    for &amp;choice in choices.iter() {\n        // 剪枝：檢查選擇是否合法\n        if is_valid(state, choice) {\n            // 嘗試：做出選擇，更新狀態\n            make_choice(state, choice.unwrap().clone());\n            // 進行下一輪選擇\n            backtrack(\n                state,\n                &amp;vec![\n                    choice.unwrap().borrow().left.as_ref(),\n                    choice.unwrap().borrow().right.as_ref(),\n                ],\n                res,\n            );\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undo_choice(state, choice.unwrap().clone());\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.c<pre><code>/* 判斷當前狀態是否為解 */\nbool isSolution(void) {\n    return pathSize &gt; 0 &amp;&amp; path[pathSize - 1]-&gt;val == 7;\n}\n\n/* 記錄解 */\nvoid recordSolution(void) {\n    for (int i = 0; i &lt; pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL &amp;&amp; choice-&gt;val != 3;\n}\n\n/* 更新狀態 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* 恢復狀態 */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* 回溯演算法：例題三 */\nvoid backtrack(TreeNode *choices[2]) {\n    // 檢查是否為解\n    if (isSolution()) {\n        // 記錄解\n        recordSolution();\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; 2; i++) {\n        TreeNode *choice = choices[i];\n        // 剪枝：檢查選擇是否合法\n        if (isValid(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(choice);\n            // 進行下一輪選擇\n            TreeNode *nextChoices[2] = {choice-&gt;left, choice-&gt;right};\n            backtrack(nextChoices);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice();\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.kt<pre><code>/* 判斷當前狀態是否為解 */\nfun isSolution(state: MutableList&lt;TreeNode?&gt;): Boolean {\n    return state.isNotEmpty() &amp;&amp; state[state.size - 1]?._val == 7\n}\n\n/* 記錄解 */\nfun recordSolution(state: MutableList&lt;TreeNode?&gt;?, res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;) {\n    res.add(state!!.toMutableList())\n}\n\n/* 判斷在當前狀態下，該選擇是否合法 */\nfun isValid(state: MutableList&lt;TreeNode?&gt;?, choice: TreeNode?): Boolean {\n    return choice != null &amp;&amp; choice._val != 3\n}\n\n/* 更新狀態 */\nfun makeChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* 恢復狀態 */\nfun undoChoice(state: MutableList&lt;TreeNode?&gt;, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* 回溯演算法：例題三 */\nfun backtrack(\n    state: MutableList&lt;TreeNode?&gt;,\n    choices: MutableList&lt;TreeNode?&gt;,\n    res: MutableList&lt;MutableList&lt;TreeNode?&gt;?&gt;\n) {\n    // 檢查是否為解\n    if (isSolution(state)) {\n        // 記錄解\n        recordSolution(state, res)\n    }\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：檢查選擇是否合法\n        if (isValid(state, choice)) {\n            // 嘗試：做出選擇，更新狀態\n            makeChoice(state, choice)\n            // 進行下一輪選擇\n            backtrack(state, mutableListOf(choice!!.left, choice.right), res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            undoChoice(state, choice)\n        }\n    }\n}\n</code></pre> preorder_traversal_iii_template.rb<pre><code>### 判斷當前狀態是否為解 ###\ndef is_solution?(state)\n  !state.empty? &amp;&amp; state.last.val == 7\nend\n\n### 記錄解 ###\ndef record_solution(state, res)\n  res &lt;&lt; state.dup\nend\n\n### 判斷在當前狀態下，該選擇是否合法 ###\ndef is_valid?(state, choice)\n  choice &amp;&amp; choice.val != 3\nend\n\n### 更新狀態 ###\ndef make_choice(state, choice)\n  state &lt;&lt; choice\nend\n\n### 恢復狀態 ###\ndef undo_choice(state, choice)\n  state.pop\nend\n\n### 回溯演算法：例題三 ###\ndef backtrack(state, choices, res)\n  # 檢查是否為解\n  record_solution(state, res) if is_solution?(state)\n\n  # 走訪所有選擇\n  for choice in choices\n    # 剪枝：檢查選擇是否合法\n    if is_valid?(state, choice)\n      # 嘗試：做出選擇，更新狀態\n      make_choice(state, choice)\n      # 進行下一輪選擇\n      backtrack(state, [choice.left, choice.right], res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      undo_choice(state, choice)\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>根據題意，我們在找到值為 \\(7\\) 的節點後應該繼續搜尋，因此需要將記錄解之後的 <code>return</code> 語句刪除。圖 13-4 對比了保留或刪除 <code>return</code> 語句的搜尋過程。</p> <p></p> <p> 圖 13-4   保留與刪除 return 的搜尋過程對比 </p> <p>相比基於前序走訪的程式碼實現，基於回溯演算法框架的程式碼實現雖然顯得囉唆，但通用性更好。實際上，許多回溯問題可以在該框架下解決。我們只需根據具體問題來定義 <code>state</code> 和 <code>choices</code> ，並實現框架中的各個方法即可。</p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1314","level":2,"title":"13.1.4   常用術語","text":"<p>為了更清晰地分析演算法問題，我們總結一下回溯演算法中常用術語的含義，並對照例題三給出對應示例，如表 13-1 所示。</p> <p> 表 13-1   常見的回溯演算法術語 </p> 名詞 定義 例題三 解（solution） 解是滿足問題特定條件的答案，可能有一個或多個 根節點到節點 \\(7\\) 的滿足約束條件的所有路徑 約束條件（constraint） 約束條件是問題中限制解的可行性的條件，通常用於剪枝 路徑中不包含節點 \\(3\\) 狀態（state） 狀態表示問題在某一時刻的情況，包括已經做出的選擇 當前已訪問的節點路徑，即 <code>path</code> 節點串列 嘗試（attempt） 嘗試是根據可用選擇來探索解空間的過程，包括做出選擇，更新狀態，檢查是否為解 遞迴訪問左（右）子節點，將節點新增進 <code>path</code> ，判斷節點的值是否為 \\(7\\) 回退（backtracking） 回退指遇到不滿足約束條件的狀態時，撤銷前面做出的選擇，回到上一個狀態 當越過葉節點、結束節點訪問、遇到值為 \\(3\\) 的節點時終止搜尋，函式返回 剪枝（pruning） 剪枝是根據問題特性和約束條件避免無意義的搜尋路徑的方法，可提高搜尋效率 當遇到值為 \\(3\\) 的節點時，則不再繼續搜尋 <p>Tip</p> <p>問題、解、狀態等概念是通用的，在分治、回溯、動態規劃、貪婪等演算法中都有涉及。</p>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1315","level":2,"title":"13.1.5   優點與侷限性","text":"<p>回溯演算法本質上是一種深度優先搜尋演算法，它嘗試所有可能的解決方案直到找到滿足條件的解。這種方法的優點在於能夠找到所有可能的解決方案，而且在合理的剪枝操作下，具有很高的效率。</p> <p>然而，在處理大規模或者複雜問題時，回溯演算法的執行效率可能難以接受。</p> <ul> <li>時間：回溯演算法通常需要走訪狀態空間的所有可能，時間複雜度可以達到指數階或階乘階。</li> <li>空間：在遞迴呼叫中需要儲存當前的狀態（例如路徑、用於剪枝的輔助變數等），當深度很大時，空間需求可能會變得很大。</li> </ul> <p>即便如此，回溯演算法仍然是某些搜尋問題和約束滿足問題的最佳解決方案。對於這些問題，由於無法預測哪些選擇可生成有效的解，因此我們必須對所有可能的選擇進行走訪。在這種情況下，關鍵是如何最佳化效率，常見的效率最佳化方法有兩種。</p> <ul> <li>剪枝：避免搜尋那些肯定不會產生解的路徑，從而節省時間和空間。</li> <li>啟發式搜尋：在搜尋過程中引入一些策略或者估計值，從而優先搜尋最有可能產生有效解的路徑。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/backtracking_algorithm/#1316","level":2,"title":"13.1.6   回溯典型例題","text":"<p>回溯演算法可用於解決許多搜尋問題、約束滿足問題和組合最佳化問題。</p> <p>搜尋問題：這類問題的目標是找到滿足特定條件的解決方案。</p> <ul> <li>全排列問題：給定一個集合，求出其所有可能的排列組合。</li> <li>子集和問題：給定一個集合和一個目標和，找到集合中所有和為目標和的子集。</li> <li>河內塔問題：給定三根柱子和一系列大小不同的圓盤，要求將所有圓盤從一根柱子移動到另一根柱子，每次只能移動一個圓盤，且不能將大圓盤放在小圓盤上。</li> </ul> <p>約束滿足問題：這類問題的目標是找到滿足所有約束條件的解。</p> <ul> <li>\\(n\\) 皇后：在 \\(n \\times n\\) 的棋盤上放置 \\(n\\) 個皇后，使得它們互不攻擊。</li> <li>數獨：在 \\(9 \\times 9\\) 的網格中填入數字 \\(1\\) ~ \\(9\\) ，使得每行、每列和每個 \\(3 \\times 3\\) 子網格中的數字不重複。</li> <li>圖著色問題：給定一個無向圖，用最少的顏色給圖的每個頂點著色，使得相鄰頂點顏色不同。</li> </ul> <p>組合最佳化問題：這類問題的目標是在一個組合空間中找到滿足某些條件的最優解。</p> <ul> <li>0-1 背包問題：給定一組物品和一個背包，每個物品有一定的價值和重量，要求在背包容量限制內，選擇物品使得總價值最大。</li> <li>旅行商問題：在一個圖中，從一個點出發，訪問所有其他點恰好一次後返回起點，求最短路徑。</li> <li>最大團問題：給定一個無向圖，找到最大的完全子圖，即子圖中的任意兩個頂點之間都有邊相連。</li> </ul> <p>請注意，對於許多組合最佳化問題，回溯不是最優解決方案。</p> <ul> <li>0-1 背包問題通常使用動態規劃解決，以達到更高的時間效率。</li> <li>旅行商是一個著名的 NP-Hard 問題，常用解法有遺傳演算法和蟻群演算法等。</li> <li>最大團問題是圖論中的一個經典問題，可用貪婪演算法等啟發式演算法來解決。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.1 &nbsp; 回溯演算法"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/","level":1,"title":"13.4   n 皇后問題","text":"<p>Question</p> <p>根據國際象棋的規則，皇后可以攻擊與同處一行、一列或一條斜線上的棋子。給定 \\(n\\) 個皇后和一個 \\(n \\times n\\) 大小的棋盤，尋找使得所有皇后之間無法相互攻擊的擺放方案。</p> <p>如圖 13-15 所示，當 \\(n = 4\\) 時，共可以找到兩個解。從回溯演算法的角度看，\\(n \\times n\\) 大小的棋盤共有 \\(n^2\\) 個格子，給出了所有的選擇 <code>choices</code> 。在逐個放置皇后的過程中，棋盤狀態在不斷地變化，每個時刻的棋盤就是狀態 <code>state</code> 。</p> <p></p> <p> 圖 13-15   4 皇后問題的解 </p> <p>圖 13-16 展示了本題的三個約束條件：多個皇后不能在同一行、同一列、同一條對角線上。值得注意的是，對角線分為主對角線 <code>\\</code> 和次對角線 <code>/</code> 兩種。</p> <p></p> <p> 圖 13-16   n 皇后問題的約束條件 </p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#1","level":3,"title":"1.   逐行放置策略","text":"<p>皇后的數量和棋盤的行數都為 \\(n\\) ，因此我們容易得到一個推論：棋盤每行都允許且只允許放置一個皇后。</p> <p>也就是說，我們可以採取逐行放置策略：從第一行開始，在每行放置一個皇后，直至最後一行結束。</p> <p>圖 13-17 所示為 4 皇后問題的逐行放置過程。受畫幅限制，圖 13-17 僅展開了第一行的其中一個搜尋分支，並且將不滿足列約束和對角線約束的方案都進行了剪枝。</p> <p></p> <p> 圖 13-17   逐行放置策略 </p> <p>從本質上看，逐行放置策略起到了剪枝的作用，它避免了同一行出現多個皇后的所有搜尋分支。</p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#2","level":3,"title":"2.   列與對角線剪枝","text":"<p>為了滿足列約束，我們可以利用一個長度為 \\(n\\) 的布林型陣列 <code>cols</code> 記錄每一列是否有皇后。在每次決定放置前，我們透過 <code>cols</code> 將已有皇后的列進行剪枝，並在回溯中動態更新 <code>cols</code> 的狀態。</p> <p>Tip</p> <p>請注意，矩陣的起點位於左上角，其中行索引從上到下增加，列索引從左到右增加。</p> <p>那麼，如何處理對角線約束呢？設棋盤中某個格子的行列索引為 \\((row, col)\\) ，選定矩陣中的某條主對角線，我們發現該對角線上所有格子的行索引減列索引都相等，即主對角線上所有格子的 \\(row - col\\) 為恆定值。</p> <p>也就是說，如果兩個格子滿足 \\(row_1 - col_1 = row_2 - col_2\\) ，則它們一定處在同一條主對角線上。利用該規律，我們可以藉助圖 13-18 所示的陣列 <code>diags1</code> 記錄每條主對角線上是否有皇后。</p> <p>同理，次對角線上的所有格子的 \\(row + col\\) 是恆定值。我們同樣也可以藉助陣列 <code>diags2</code> 來處理次對角線約束。</p> <p></p> <p> 圖 13-18   處理列約束和對角線約束 </p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/n_queens_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>請注意，\\(n\\) 維方陣中 \\(row - col\\) 的範圍是 \\([-n + 1, n - 1]\\) ，\\(row + col\\) 的範圍是 \\([0, 2n - 2]\\) ，所以主對角線和次對角線的數量都為 \\(2n - 1\\) ，即陣列 <code>diags1</code> 和 <code>diags2</code> 的長度都為 \\(2n - 1\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby n_queens.py<pre><code>def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"回溯演算法：n 皇后\"\"\"\n    # 當放置完所有行時，記錄解\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # 走訪所有列\n    for col in range(n):\n        # 計算該格子對應的主對角線和次對角線\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if not cols[col] and not diags1[diag1] and not diags2[diag2]:\n            # 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            cols[col] = diags1[diag1] = diags2[diag2] = True\n            # 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            # 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            cols[col] = diags1[diag1] = diags2[diag2] = False\n\ndef n_queens(n: int) -&gt; list[list[list[str]]]:\n    \"\"\"求解 n 皇后\"\"\"\n    # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # 記錄列是否有皇后\n    diags1 = [False] * (2 * n - 1)  # 記錄主對角線上是否有皇后\n    diags2 = [False] * (2 * n - 1)  # 記錄次對角線上是否有皇后\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n</code></pre> n_queens.cpp<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, vector&lt;vector&lt;string&gt;&gt; &amp;state, vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; &amp;res, vector&lt;bool&gt; &amp;cols,\n               vector&lt;bool&gt; &amp;diags1, vector&lt;bool&gt; &amp;diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nvector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; nQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    vector&lt;vector&lt;string&gt;&gt; state(n, vector&lt;string&gt;(n, \"#\"));\n    vector&lt;bool&gt; cols(n, false);           // 記錄列是否有皇后\n    vector&lt;bool&gt; diags1(2 * n - 1, false); // 記錄主對角線上是否有皇后\n    vector&lt;bool&gt; diags2(2 * n - 1, false); // 記錄次對角線上是否有皇后\n    vector&lt;vector&lt;vector&lt;string&gt;&gt;&gt; res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.java<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, List&lt;List&lt;String&gt;&gt; state, List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        List&lt;List&lt;String&gt;&gt; copyState = new ArrayList&lt;&gt;();\n        for (List&lt;String&gt; sRow : state) {\n            copyState.add(new ArrayList&lt;&gt;(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    List&lt;List&lt;String&gt;&gt; state = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;String&gt; row = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // 記錄列是否有皇后\n    boolean[] diags1 = new boolean[2 * n - 1]; // 記錄主對角線上是否有皇后\n    boolean[] diags2 = new boolean[2 * n - 1]; // 記錄次對角線上是否有皇后\n    List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = new ArrayList&lt;&gt;();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.cs<pre><code>/* 回溯演算法：n 皇后 */\nvoid Backtrack(int row, int n, List&lt;List&lt;string&gt;&gt; state, List&lt;List&lt;List&lt;string&gt;&gt;&gt; res,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        List&lt;List&lt;string&gt;&gt; copyState = [];\n        foreach (List&lt;string&gt; sRow in state) {\n            copyState.Add(new List&lt;string&gt;(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\";\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            Backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\";\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;string&gt;&gt;&gt; NQueens(int n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    List&lt;List&lt;string&gt;&gt; state = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;string&gt; row = [];\n        for (int j = 0; j &lt; n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // 記錄列是否有皇后\n    bool[] diags1 = new bool[2 * n - 1]; // 記錄主對角線上是否有皇后\n    bool[] diags2 = new bool[2 * n - 1]; // 記錄次對角線上是否有皇后\n    List&lt;List&lt;List&lt;string&gt;&gt;&gt; res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n</code></pre> n_queens.go<pre><code>/* 回溯演算法：n 皇后 */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有列\n    for col := 0; col &lt; n; col++ {\n        // 計算該格子對應的主對角線和次對角線\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !(*cols)[col] &amp;&amp; !(*diags1)[diag1] &amp;&amp; !(*diags2)[diag2] {\n            // 嘗試：將皇后放置在該格子\n            (*state)[row][col] = \"Q\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n            // 放置下一行\n            backtrack(row+1, n, state, res, cols, diags1, diags2)\n            // 回退：將該格子恢復為空位\n            (*state)[row][col] = \"#\"\n            (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunc nQueens(n int) [][][]string {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    state := make([][]string, n)\n    for i := 0; i &lt; n; i++ {\n        row := make([]string, n)\n        for i := 0; i &lt; n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // 記錄列是否有皇后\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &amp;state, &amp;res, &amp;cols, &amp;diags1, &amp;diags2)\n    return res\n}\n</code></pre> n_queens.swift<pre><code>/* 回溯演算法：n 皇后 */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        res.append(state)\n        return\n    }\n    // 走訪所有列\n    for col in 0 ..&lt; n {\n        // 計算該格子對應的主對角線和次對角線\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            cols[col] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // 放置下一行\n            backtrack(row: row + 1, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunc nQueens(n: Int) -&gt; [[[String]]] {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // 記錄列是否有皇后\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // 記錄主對角線上是否有皇后\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // 記錄次對角線上是否有皇后\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &amp;state, res: &amp;res, cols: &amp;cols, diags1: &amp;diags1, diags2: &amp;diags2)\n\n    return res\n}\n</code></pre> n_queens.js<pre><code>/* 回溯演算法：n 皇后 */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n    // 當放置完所有行時，記錄解\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // 走訪所有列\n    for (let col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunction nQueens(n) {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 記錄列是否有皇后\n    const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后\n    const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.ts<pre><code>/* 回溯演算法：n 皇后 */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // 當放置完所有行時，記錄解\n    if (row === n) {\n        res.push(state.map((row) =&gt; row.slice()));\n        return;\n    }\n    // 走訪所有列\n    for (let col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfunction nQueens(n: number): string[][][] {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    const state = Array.from({ length: n }, () =&gt; Array(n).fill('#'));\n    const cols = Array(n).fill(false); // 記錄列是否有皇后\n    const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后\n    const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.dart<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(\n  int row,\n  int n,\n  List&lt;List&lt;String&gt;&gt; state,\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res,\n  List&lt;bool&gt; cols,\n  List&lt;bool&gt; diags1,\n  List&lt;bool&gt; diags2,\n) {\n  // 當放置完所有行時，記錄解\n  if (row == n) {\n    List&lt;List&lt;String&gt;&gt; copyState = [];\n    for (List&lt;String&gt; sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // 走訪所有列\n  for (int col = 0; col &lt; n; col++) {\n    // 計算該格子對應的主對角線和次對角線\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n    if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n      // 嘗試：將皇后放置在該格子\n      state[row][col] = \"Q\";\n      cols[col] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // 放置下一行\n      backtrack(row + 1, n, state, res, cols, diags1, diags2);\n      // 回退：將該格子恢復為空位\n      state[row][col] = \"#\";\n      cols[col] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\n  }\n}\n\n/* 求解 n 皇后 */\nList&lt;List&lt;List&lt;String&gt;&gt;&gt; nQueens(int n) {\n  // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n  List&lt;List&lt;String&gt;&gt; state = List.generate(n, (index) =&gt; List.filled(n, \"#\"));\n  List&lt;bool&gt; cols = List.filled(n, false); // 記錄列是否有皇后\n  List&lt;bool&gt; diags1 = List.filled(2 * n - 1, false); // 記錄主對角線上是否有皇后\n  List&lt;bool&gt; diags2 = List.filled(2 * n - 1, false); // 記錄次對角線上是否有皇后\n  List&lt;List&lt;List&lt;String&gt;&gt;&gt; res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n</code></pre> n_queens.rs<pre><code>/* 回溯演算法：n 皇后 */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &amp;mut Vec&lt;Vec&lt;String&gt;&gt;,\n    res: &amp;mut Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt;,\n    cols: &amp;mut [bool],\n    diags1: &amp;mut [bool],\n    diags2: &amp;mut [bool],\n) {\n    // 當放置完所有行時，記錄解\n    if row == n {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有列\n    for col in 0..n {\n        // 計算該格子對應的主對角線和次對角線\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2] {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfn n_queens(n: usize) -&gt; Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    let mut state: Vec&lt;Vec&lt;String&gt;&gt; = vec![vec![\"#\".to_string(); n]; n];\n    let mut cols = vec![false; n]; // 記錄列是否有皇后\n    let mut diags1 = vec![false; 2 * n - 1]; // 記錄主對角線上是否有皇后\n    let mut diags2 = vec![false; 2 * n - 1]; // 記錄次對角線上是否有皇后\n    let mut res: Vec&lt;Vec&lt;Vec&lt;String&gt;&gt;&gt; = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &amp;mut state,\n        &amp;mut res,\n        &amp;mut cols,\n        &amp;mut diags1,\n        &amp;mut diags2,\n    );\n\n    res\n}\n</code></pre> n_queens.c<pre><code>/* 回溯演算法：n 皇后 */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i &lt; n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有列\n    for (int col = 0; col &lt; n; col++) {\n        // 計算該格子對應的主對角線和次對角線\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = 'Q';\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // 放置下一行\n            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);\n            // 回退：將該格子恢復為空位\n            state[row][col] = '#';\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    for (int i = 0; i &lt; n; ++i) {\n        for (int j = 0; j &lt; n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // 記錄列是否有皇后\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // 記錄主對角線上是否有皇后\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // 記錄次對角線上是否有皇后\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n</code></pre> n_queens.kt<pre><code>/* 回溯演算法：n 皇后 */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: MutableList&lt;MutableList&lt;String&gt;&gt;,\n    res: MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // 當放置完所有行時，記錄解\n    if (row == n) {\n        val copyState = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n        for (sRow in state) {\n            copyState.add(sRow.toMutableList())\n        }\n        res.add(copyState)\n        return\n    }\n    // 走訪所有列\n    for (col in 0..&lt;n) {\n        // 計算該格子對應的主對角線和次對角線\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n        if (!cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]) {\n            // 嘗試：將皇后放置在該格子\n            state[row][col] = \"Q\"\n            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // 放置下一行\n            backtrack(row + 1, n, state, res, cols, diags1, diags2)\n            // 回退：將該格子恢復為空位\n            state[row][col] = \"#\"\n            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* 求解 n 皇后 */\nfun nQueens(n: Int): MutableList&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt; {\n    // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n    val state = mutableListOf&lt;MutableList&lt;String&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val row = mutableListOf&lt;String&gt;()\n        for (j in 0..&lt;n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // 記錄列是否有皇后\n    val diags1 = BooleanArray(2 * n - 1) // 記錄主對角線上是否有皇后\n    val diags2 = BooleanArray(2 * n - 1) // 記錄次對角線上是否有皇后\n    val res = mutableListOf&lt;MutableList&lt;MutableList&lt;String&gt;&gt;?&gt;()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n</code></pre> n_queens.rb<pre><code>### 回溯演算法：n 皇后 ###\ndef backtrack(row, n, state, res, cols, diags1, diags2)\n  # 當放置完所有行時，記錄解\n  if row == n\n    res &lt;&lt; state.map { |row| row.dup }\n    return\n  end\n\n  # 走訪所有列\n  for col in 0...n\n    # 計算該格子對應的主對角線和次對角線\n    diag1 = row - col + n - 1\n    diag2 = row + col\n    # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后\n    if !cols[col] &amp;&amp; !diags1[diag1] &amp;&amp; !diags2[diag2]\n      # 嘗試：將皇后放置在該格子\n      state[row][col] = \"Q\"\n      cols[col] = diags1[diag1] = diags2[diag2] = true\n      # 放置下一行\n      backtrack(row + 1, n, state, res, cols, diags1, diags2)\n      # 回退：將該格子恢復為空位\n      state[row][col] = \"#\"\n      cols[col] = diags1[diag1] = diags2[diag2] = false\n    end\n  end\nend\n\n### 求解 n 皇后 ###\ndef n_queens(n)\n  # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位\n  state = Array.new(n) { Array.new(n, \"#\") }\n  cols = Array.new(n, false) # 記錄列是否有皇后\n  diags1 = Array.new(2 * n - 1, false) # 記錄主對角線上是否有皇后\n  diags2 = Array.new(2 * n - 1, false) # 記錄次對角線上是否有皇后\n  res = []\n  backtrack(0, n, state, res, cols, diags1, diags2)\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>逐行放置 \\(n\\) 次，考慮列約束，則從第一行到最後一行分別有 \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 個選擇，使用 \\(O(n!)\\) 時間。當記錄解時，需要複製矩陣 <code>state</code> 並新增進 <code>res</code> ，複製操作使用 \\(O(n^2)\\) 時間。因此，總體時間複雜度為 \\(O(n! \\cdot n^2)\\) 。實際上，根據對角線約束的剪枝也能夠大幅縮小搜尋空間，因而搜尋效率往往優於以上時間複雜度。</p> <p>陣列 <code>state</code> 使用 \\(O(n^2)\\) 空間，陣列 <code>cols</code>、<code>diags1</code> 和 <code>diags2</code> 皆使用 \\(O(n)\\) 空間。最大遞迴深度為 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。因此，空間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.4 &nbsp; n 皇后問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/","level":1,"title":"13.2   全排列問題","text":"<p>全排列問題是回溯演算法的一個典型應用。它的定義是在給定一個集合（如一個陣列或字串）的情況下，找出其中元素的所有可能的排列。</p> <p>表 13-2 列舉了幾個示例資料，包括輸入陣列和對應的所有排列。</p> <p> 表 13-2   全排列示例 </p> 輸入陣列 所有排列 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1321","level":2,"title":"13.2.1   無相等元素的情況","text":"<p>Question</p> <p>輸入一個整數陣列，其中不包含重複元素，返回所有可能的排列。</p> <p>從回溯演算法的角度看，我們可以把生成排列的過程想象成一系列選擇的結果。假設輸入陣列為 \\([1, 2, 3]\\) ，如果我們先選擇 \\(1\\) ，再選擇 \\(3\\) ，最後選擇 \\(2\\) ，則獲得排列 \\([1, 3, 2]\\) 。回退表示撤銷一個選擇，之後繼續嘗試其他選擇。</p> <p>從回溯程式碼的角度看，候選集合 <code>choices</code> 是輸入陣列中的所有元素，狀態 <code>state</code> 是直至目前已被選擇的元素。請注意，每個元素只允許被選擇一次，因此 <code>state</code> 中的所有元素都應該是唯一的。</p> <p>如圖 13-5 所示，我們可以將搜尋過程展開成一棵遞迴樹，樹中的每個節點代表當前狀態 <code>state</code> 。從根節點開始，經過三輪選擇後到達葉節點，每個葉節點都對應一個排列。</p> <p></p> <p> 圖 13-5   全排列的遞迴樹 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1","level":3,"title":"1.   重複選擇剪枝","text":"<p>為了實現每個元素只被選擇一次，我們考慮引入一個布林型陣列 <code>selected</code> ，其中 <code>selected[i]</code> 表示 <code>choices[i]</code> 是否已被選擇，並基於它實現以下剪枝操作。</p> <ul> <li>在做出選擇 <code>choice[i]</code> 後，我們就將 <code>selected[i]</code> 賦值為 \\(\\text{True}\\) ，代表它已被選擇。</li> <li>走訪選擇串列 <code>choices</code> 時，跳過所有已被選擇的節點，即剪枝。</li> </ul> <p>如圖 13-6 所示，假設我們第一輪選擇 1 ，第二輪選擇 3 ，第三輪選擇 2 ，則需要在第二輪剪掉元素 1 的分支，在第三輪剪掉元素 1 和元素 3 的分支。</p> <p></p> <p> 圖 13-6   全排列剪枝示例 </p> <p>觀察圖 13-6 發現，該剪枝操作將搜尋空間大小從 \\(O(n^n)\\) 減小至 \\(O(n!)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>想清楚以上資訊之後，我們就可以在框架程式碼中做“完形填空”了。為了縮短整體程式碼，我們不單獨實現框架程式碼中的各個函式，而是將它們展開在 <code>backtrack()</code> 函式中：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_i.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"回溯演算法：全排列 I\"\"\"\n    # 當狀態長度等於元素數量時，記錄解\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    for i, choice in enumerate(choices):\n        # 剪枝：不允許重複選擇元素\n        if not selected[i]:\n            # 嘗試：做出選擇，更新狀態\n            selected[i] = True\n            state.append(choice)\n            # 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = False\n            state.pop()\n\ndef permutations_i(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全排列 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_i.cpp<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push_back(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全排列 I */\nvector&lt;vector&lt;int&gt;&gt; permutationsI(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_i.java<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.add(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全排列 I */\nList&lt;List&lt;Integer&gt;&gt; permutationsI(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_i.cs<pre><code>/* 回溯演算法：全排列 I */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.Add(choice);\n            // 進行下一輪選擇\n            Backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全排列 I */\nList&lt;List&lt;int&gt;&gt; PermutationsI(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_i.go<pre><code>/* 回溯演算法：全排列 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 當狀態長度等於元素數量時，記錄解\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // 走訪所有選擇\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 剪枝：不允許重複選擇元素\n        if !(*selected)[i] {\n            // 嘗試：做出選擇，更新狀態\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 進行下一輪選擇\n            backtrackI(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全排列 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_i.swift<pre><code>/* 回溯演算法：全排列 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    for (i, choice) in choices.enumerated() {\n        // 剪枝：不允許重複選擇元素\n        if !selected[i] {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true\n            state.append(choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全排列 I */\nfunc permutationsI(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_i.js<pre><code>/* 回溯演算法：全排列 I */\nfunction backtrack(state, choices, selected, res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.ts<pre><code>/* 回溯演算法：全排列 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_i.dart<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 當狀態長度等於元素數量時，記錄解\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 剪枝：不允許重複選擇元素\n    if (!selected[i]) {\n      // 嘗試：做出選擇，更新狀態\n      selected[i] = true;\n      state.add(choice);\n      // 進行下一輪選擇\n      backtrack(state, choices, selected, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全排列 I */\nList&lt;List&lt;int&gt;&gt; permutationsI(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_i.rs<pre><code>/* 回溯演算法：全排列 I */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // 走訪所有選擇\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if !selected[i] {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state.clone(), choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全排列 I */\nfn permutations_i(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new(); // 狀態（子集）\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_i.c<pre><code>/* 回溯演算法：全排列 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 進行下一輪選擇\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全排列 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_i.kt<pre><code>/* 回溯演算法：全排列 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 剪枝：不允許重複選擇元素\n        if (!selected[i]) {\n            // 嘗試：做出選擇，更新狀態\n            selected[i] = true\n            state.add(choice)\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全排列 I */\nfun permutationsI(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_i.rb<pre><code>### 回溯演算法：全排列 I ###\ndef backtrack(state, choices, selected, res)\n  # 當狀態長度等於元素數量時，記錄解\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  choices.each_with_index do |choice, i|\n    # 剪枝：不允許重複選擇元素\n    unless selected[i]\n      # 嘗試：做出選擇，更新狀態\n      selected[i] = true\n      state &lt;&lt; choice\n      # 進行下一輪選擇\n      backtrack(state, choices, selected, res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全排列 I ###\ndef permutations_i(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1322","level":2,"title":"13.2.2   考慮相等元素的情況","text":"<p>Question</p> <p>輸入一個整數陣列，陣列中可能包含重複元素，返回所有不重複的排列。</p> <p>假設輸入陣列為 \\([1, 1, 2]\\) 。為了方便區分兩個重複元素 \\(1\\) ，我們將第二個 \\(1\\) 記為 \\(\\hat{1}\\) 。</p> <p>如圖 13-7 所示，上述方法生成的排列有一半是重複的。</p> <p></p> <p> 圖 13-7   重複排列 </p> <p>那麼如何去除重複的排列呢？最直接地，考慮藉助一個雜湊集合，直接對排列結果進行去重。然而這樣做不夠優雅，因為生成重複排列的搜尋分支沒有必要，應當提前識別並剪枝，這樣可以進一步提升演算法效率。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#1_1","level":3,"title":"1.   相等元素剪枝","text":"<p>觀察圖 13-8 ，在第一輪中，選擇 \\(1\\) 或選擇 \\(\\hat{1}\\) 是等價的，在這兩個選擇之下生成的所有排列都是重複的。因此應該把 \\(\\hat{1}\\) 剪枝。</p> <p>同理，在第一輪選擇 \\(2\\) 之後，第二輪選擇中的 \\(1\\) 和 \\(\\hat{1}\\) 也會產生重複分支，因此也應將第二輪的 \\(\\hat{1}\\) 剪枝。</p> <p>從本質上看，我們的目標是在某一輪選擇中，保證多個相等的元素僅被選擇一次。</p> <p></p> <p> 圖 13-8   重複排列剪枝 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"<p>在上一題的程式碼的基礎上，我們考慮在每一輪選擇中開啟一個雜湊集合 <code>duplicated</code> ，用於記錄該輪中已經嘗試過的元素，並將重複元素剪枝：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby permutations_ii.py<pre><code>def backtrack(\n    state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n    \"\"\"回溯演算法：全排列 II\"\"\"\n    # 當狀態長度等於元素數量時，記錄解\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    duplicated = set[int]()\n    for i, choice in enumerate(choices):\n        # 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if not selected[i] and choice not in duplicated:\n            # 嘗試：做出選擇，更新狀態\n            duplicated.add(choice)  # 記錄選擇過的元素值\n            selected[i] = True\n            state.append(choice)\n            # 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            # 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = False\n            state.pop()\n\ndef permutations_ii(nums: list[int]) -&gt; list[list[int]]:\n    \"\"\"全排列 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\n</code></pre> permutations_ii.cpp<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, const vector&lt;int&gt; &amp;choices, vector&lt;bool&gt; &amp;selected, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    unordered_set&lt;int&gt; duplicated;\n    for (int i = 0; i &lt; choices.size(); i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; duplicated.find(choice) == duplicated.end()) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.emplace(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push_back(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop_back();\n        }\n    }\n}\n\n/* 全排列 II */\nvector&lt;vector&lt;int&gt;&gt; permutationsII(vector&lt;int&gt; nums) {\n    vector&lt;int&gt; state;\n    vector&lt;bool&gt; selected(nums.size(), false);\n    vector&lt;vector&lt;int&gt;&gt; res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n</code></pre> permutations_ii.java<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(List&lt;Integer&gt; state, int[] choices, boolean[] selected, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size() == choices.length) {\n        res.add(new ArrayList&lt;Integer&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    Set&lt;Integer&gt; duplicated = new HashSet&lt;Integer&gt;();\n    for (int i = 0; i &lt; choices.length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.add(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.remove(state.size() - 1);\n        }\n    }\n}\n\n/* 全排列 II */\nList&lt;List&lt;Integer&gt;&gt; permutationsII(int[] nums) {\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;List&lt;Integer&gt;&gt;();\n    backtrack(new ArrayList&lt;Integer&gt;(), nums, new boolean[nums.length], res);\n    return res;\n}\n</code></pre> permutations_ii.cs<pre><code>/* 回溯演算法：全排列 II */\nvoid Backtrack(List&lt;int&gt; state, int[] choices, bool[] selected, List&lt;List&lt;int&gt;&gt; res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.Count == choices.Length) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    HashSet&lt;int&gt; duplicated = [];\n    for (int i = 0; i &lt; choices.Length; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.Contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.Add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.Add(choice);\n            // 進行下一輪選擇\n            Backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* 全排列 II */\nList&lt;List&lt;int&gt;&gt; PermutationsII(int[] nums) {\n    List&lt;List&lt;int&gt;&gt; res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\n</code></pre> permutations_ii.go<pre><code>/* 回溯演算法：全排列 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n    // 當狀態長度等於元素數量時，記錄解\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // 走訪所有選擇\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i &lt; len(*choices); i++ {\n        choice := (*choices)[i]\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if _, ok := duplicated[choice]; !ok &amp;&amp; !(*selected)[i] {\n            // 嘗試：做出選擇，更新狀態\n            // 記錄選擇過的元素值\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // 進行下一輪選擇\n            backtrackII(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            (*selected)[i] = false\n            *state = (*state)[:len(*state)-1]\n        }\n    }\n}\n\n/* 全排列 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&amp;state, &amp;nums, &amp;selected, &amp;res)\n    return res\n}\n</code></pre> permutations_ii.swift<pre><code>/* 回溯演算法：全排列 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    var duplicated: Set&lt;Int&gt; = []\n    for (i, choice) in choices.enumerated() {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if !selected[i], !duplicated.contains(choice) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.insert(choice) // 記錄選擇過的元素值\n            selected[i] = true\n            state.append(choice)\n            // 進行下一輪選擇\n            backtrack(state: &amp;state, choices: choices, selected: &amp;selected, res: &amp;res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* 全排列 II */\nfunc permutationsII(nums: [Int]) -&gt; [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &amp;state, choices: nums, selected: &amp;selected, res: &amp;res)\n    return res\n}\n</code></pre> permutations_ii.js<pre><code>/* 回溯演算法：全排列 II */\nfunction backtrack(state, choices, selected, res) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.ts<pre><code>/* 回溯演算法：全排列 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    const duplicated = new Set();\n    choices.forEach((choice, i) =&gt; {\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.has(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    });\n}\n\n/* 全排列 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n</code></pre> permutations_ii.dart<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  List&lt;int&gt; choices,\n  List&lt;bool&gt; selected,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 當狀態長度等於元素數量時，記錄解\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  Set&lt;int&gt; duplicated = {};\n  for (int i = 0; i &lt; choices.length; i++) {\n    int choice = choices[i];\n    // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n    if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n      // 嘗試：做出選擇，更新狀態\n      duplicated.add(choice); // 記錄選擇過的元素值\n      selected[i] = true;\n      state.add(choice);\n      // 進行下一輪選擇\n      backtrack(state, choices, selected, res);\n      // 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false;\n      state.removeLast();\n    }\n  }\n}\n\n/* 全排列 II */\nList&lt;List&lt;int&gt;&gt; permutationsII(List&lt;int&gt; nums) {\n  List&lt;List&lt;int&gt;&gt; res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n</code></pre> permutations_ii.rs<pre><code>/* 回溯演算法：全排列 II */\nfn backtrack(mut state: Vec&lt;i32&gt;, choices: &amp;[i32], selected: &amp;mut [bool], res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;) {\n    // 當狀態長度等於元素數量時，記錄解\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // 走訪所有選擇\n    let mut duplicated = HashSet::&lt;i32&gt;::new();\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if !selected[i] &amp;&amp; !duplicated.contains(&amp;choice) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.insert(choice); // 記錄選擇過的元素值\n            selected[i] = true;\n            state.push(choice);\n            // 進行下一輪選擇\n            backtrack(state.clone(), choices, selected, res);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n            state.pop();\n        }\n    }\n}\n\n/* 全排列 II */\nfn permutations_ii(nums: &amp;mut [i32]) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &amp;mut vec![false; nums.len()], &amp;mut res);\n    res\n}\n</code></pre> permutations_ii.c<pre><code>/* 回溯演算法：全排列 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i &lt; choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // 走訪所有選擇\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i &lt; choicesSize; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated[choice]) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated[choice] = true; // 記錄選擇過的元素值\n            selected[i] = true;\n            state[stateSize] = choice;\n            // 進行下一輪選擇\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false;\n        }\n    }\n}\n\n/* 全排列 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i &lt; numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n</code></pre> permutations_ii.kt<pre><code>/* 回溯演算法：全排列 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 當狀態長度等於元素數量時，記錄解\n    if (state.size == choices.size) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    val duplicated = HashSet&lt;Int&gt;()\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n        if (!selected[i] &amp;&amp; !duplicated.contains(choice)) {\n            // 嘗試：做出選擇，更新狀態\n            duplicated.add(choice) // 記錄選擇過的元素值\n            selected[i] = true\n            state.add(choice)\n            // 進行下一輪選擇\n            backtrack(state, choices, selected, res)\n            // 回退：撤銷選擇，恢復到之前的狀態\n            selected[i] = false\n            state.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* 全排列 II */\nfun permutationsII(nums: IntArray): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;()\n    backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)\n    return res\n}\n</code></pre> permutations_ii.rb<pre><code>### 回溯演算法：全排列 II ###\ndef backtrack(state, choices, selected, res)\n  # 當狀態長度等於元素數量時，記錄解\n  if state.length == choices.length\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  duplicated = Set.new\n  choices.each_with_index do |choice, i|\n    # 剪枝：不允許重複選擇元素 且 不允許重複選擇相等元素\n    if !selected[i] &amp;&amp; !duplicated.include?(choice)\n      # 嘗試：做出選擇，更新狀態\n      duplicated.add(choice)\n      selected[i] = true\n      state &lt;&lt; choice\n      # 進行下一輪選擇\n      backtrack(state, choices, selected, res)\n      # 回退：撤銷選擇，恢復到之前的狀態\n      selected[i] = false\n      state.pop\n    end\n  end\nend\n\n### 全排列 II ###\ndef permutations_ii(nums)\n  res = []\n  backtrack([], nums, Array.new(nums.length, false), res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>假設元素兩兩之間互不相同，則 \\(n\\) 個元素共有 \\(n!\\)  種排列（階乘）；在記錄結果時，需要複製長度為 \\(n\\) 的串列，使用 \\(O(n)\\) 時間。因此時間複雜度為 \\(O(n!n)\\) 。</p> <p>最大遞迴深度為 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。<code>selected</code> 使用 \\(O(n)\\) 空間。同一時刻最多共有 \\(n\\) 個 <code>duplicated</code> ，使用 \\(O(n^2)\\) 空間。因此空間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/permutations_problem/#3","level":3,"title":"3.   兩種剪枝對比","text":"<p>請注意，雖然 <code>selected</code> 和 <code>duplicated</code> 都用於剪枝，但兩者的目標不同。</p> <ul> <li>重複選擇剪枝：整個搜尋過程中只有一個 <code>selected</code> 。它記錄的是當前狀態中包含哪些元素，其作用是避免某個元素在 <code>state</code> 中重複出現。</li> <li>相等元素剪枝：每輪選擇（每個呼叫的 <code>backtrack</code> 函式）都包含一個 <code>duplicated</code> 。它記錄的是在本輪走訪（<code>for</code> 迴圈）中哪些元素已被選擇過，其作用是保證相等元素只被選擇一次。</li> </ul> <p>圖 13-9 展示了兩個剪枝條件的生效範圍。注意，樹中的每個節點代表一個選擇，從根節點到葉節點的路徑上的各個節點構成一個排列。</p> <p></p> <p> 圖 13-9   兩種剪枝條件的作用範圍 </p>","path":["第 13 章 &nbsp; 回溯","13.2 &nbsp; 全排列問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/","level":1,"title":"13.3   子集和問題","text":"","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1331","level":2,"title":"13.3.1   無重複元素的情況","text":"<p>Question</p> <p>給定一個正整數陣列 <code>nums</code> 和一個目標正整數 <code>target</code> ，請找出所有可能的組合，使得組合中的元素和等於 <code>target</code> 。給定陣列無重複元素，每個元素可以被選取多次。請以串列形式返回這些組合，串列中不應包含重複組合。</p> <p>例如，輸入集合 \\(\\{3, 4, 5\\}\\) 和目標整數 \\(9\\) ，解為 \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) 。需要注意以下兩點。</p> <ul> <li>輸入集合中的元素可以被無限次重複選取。</li> <li>子集不區分元素順序，比如 \\(\\{4, 5\\}\\) 和 \\(\\{5, 4\\}\\) 是同一個子集。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1","level":3,"title":"1.   參考全排列解法","text":"<p>類似於全排列問題，我們可以把子集的生成過程想象成一系列選擇的結果，並在選擇過程中即時更新“元素和”，當元素和等於 <code>target</code> 時，就將子集記錄至結果串列。</p> <p>而與全排列問題不同的是，本題集合中的元素可以被無限次選取，因此無須藉助 <code>selected</code> 布林串列來記錄元素是否已被選擇。我們可以對全排列程式碼進行小幅修改，初步得到解題程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i_naive.py<pre><code>def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    res: list[list[int]],\n):\n    \"\"\"回溯演算法：子集和 I\"\"\"\n    # 子集和等於 target 時，記錄解\n    if total == target:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    for i in range(len(choices)):\n        # 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target:\n            continue\n        # 嘗試：做出選擇，更新元素和 total\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_i_naive(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 I（包含重複子集）\"\"\"\n    state = []  # 狀態（子集）\n    total = 0  # 子集和\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, total, nums, res)\n    return res\n</code></pre> subset_sum_i_naive.cpp<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, int total, vector&lt;int&gt; &amp;choices, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    for (size_t i = 0; i &lt; choices.size(); i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nvector&lt;vector&lt;int&gt;&gt; subsetSumINaive(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;       // 狀態（子集）\n    int total = 0;           // 子集和\n    vector&lt;vector&lt;int&gt;&gt; res; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.java<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int total, int[] choices, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;Integer&gt;&gt; subsetSumINaive(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    int total = 0; // 子集和\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.cs<pre><code>/* 回溯演算法：子集和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int total, int[] choices, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choices.Length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;int&gt;&gt; SubsetSumINaive(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    int total = 0; // 子集和\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.go<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    for i := 0; i &lt; len(*choices); i++ {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total+(*choices)[i] &gt; target {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    total := 0              // 子集和\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumINaive(total, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.swift<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if total == target {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    for i in choices.indices {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target, total: total + choices[i], choices: choices, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunc subsetSumINaive(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let total = 0 // 子集和\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, total: total, choices: nums, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i_naive.js<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(state, target, total, choices, res) {\n    // 子集和等於 target 時，記錄解\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // 狀態（子集）\n    const total = 0; // 子集和\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.ts<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    for (let i = 0; i &lt; choices.length; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    const total = 0; // 子集和\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n</code></pre> subset_sum_i_naive.dart<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  int total,\n  List&lt;int&gt; choices,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  for (int i = 0; i &lt; choices.length; i++) {\n    // 剪枝：若子集和超過 target ，則跳過該選擇\n    if (total + choices[i] &gt; target) {\n      continue;\n    }\n    // 嘗試：做出選擇，更新元素和 total\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target, total + choices[i], choices, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 I（包含重複子集） */\nList&lt;List&lt;int&gt;&gt; subsetSumINaive(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  int total = 0; // 元素和\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n</code></pre> subset_sum_i_naive.rs<pre><code>/* 回溯演算法：子集和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    total: i32,\n    choices: &amp;[i32],\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if total == target {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    for i in 0..choices.len() {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if total + choices[i] &gt; target {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfn subset_sum_i_naive(nums: &amp;[i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    let total = 0; // 子集和\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, total, nums, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i_naive.c<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    for (int i = 0; i &lt; choicesSize; i++) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state[stateSize++] = choices[i];\n        // 進行下一輪選擇\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // 初始化解的數量為0\n    backtrack(target, 0, nums, numsSize);\n}\n</code></pre> subset_sum_i_naive.kt<pre><code>/* 回溯演算法：子集和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (total == target) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    for (i in choices.indices) {\n        // 剪枝：若子集和超過 target ，則跳過該選擇\n        if (total + choices[i] &gt; target) {\n            continue\n        }\n        // 嘗試：做出選擇，更新元素和 total\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target, total + choices[i], choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 I（包含重複子集） */\nfun subsetSumINaive(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    val total = 0 // 子集和\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, total, nums, res)\n    return res\n}\n</code></pre> subset_sum_i_naive.rb<pre><code>### 回溯演算法：子集和 I ###\ndef backtrack(state, target, total, choices, res)\n  # 子集和等於 target 時，記錄解\n  if total == target\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  for i in 0...choices.length\n    # 剪枝：若子集和超過 target ，則跳過該選擇\n    next if total + choices[i] &gt; target\n    # 嘗試：做出選擇，更新元素和 total\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target, total + choices[i], choices, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 I（包含重複子集）###\ndef subset_sum_i_naive(nums, target)\n  state = [] # 狀態（子集）\n  total = 0 # 子集和\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, total, nums, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>向以上程式碼輸入陣列 \\([3, 4, 5]\\) 和目標元素 \\(9\\) ，輸出結果為 \\([3, 3, 3], [4, 5], [5, 4]\\) 。雖然成功找出了所有和為 \\(9\\) 的子集，但其中存在重複的子集 \\([4, 5]\\) 和 \\([5, 4]\\) 。</p> <p>這是因為搜尋過程是區分選擇順序的，然而子集不區分選擇順序。如圖 13-10 所示，先選 \\(4\\) 後選 \\(5\\) 與先選 \\(5\\) 後選 \\(4\\) 是不同的分支，但對應同一個子集。</p> <p></p> <p> 圖 13-10   子集搜尋與越界剪枝 </p> <p>為了去除重複子集，一種直接的思路是對結果串列進行去重。但這個方法效率很低，有兩方面原因。</p> <ul> <li>當陣列元素較多，尤其是當 <code>target</code> 較大時，搜尋過程會產生大量的重複子集。</li> <li>比較子集（陣列）的異同非常耗時，需要先排序陣列，再比較陣列中每個元素的異同。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2","level":3,"title":"2.   重複子集剪枝","text":"<p>我們考慮在搜尋過程中透過剪枝進行去重。觀察圖 13-11 ，重複子集是在以不同順序選擇陣列元素時產生的，例如以下情況。</p> <ol> <li>當第一輪和第二輪分別選擇 \\(3\\) 和 \\(4\\) 時，會生成包含這兩個元素的所有子集，記為 \\([3, 4, \\dots]\\) 。</li> <li>之後，當第一輪選擇 \\(4\\) 時，則第二輪應該跳過 \\(3\\) ，因為該選擇產生的子集 \\([4, 3, \\dots]\\) 和第 <code>1.</code> 步中生成的子集完全重複。</li> </ol> <p>在搜尋過程中，每一層的選擇都是從左到右被逐個嘗試的，因此越靠右的分支被剪掉的越多。</p> <ol> <li>前兩輪選擇 \\(3\\) 和 \\(5\\) ，生成子集 \\([3, 5, \\dots]\\) 。</li> <li>前兩輪選擇 \\(4\\) 和 \\(5\\) ，生成子集 \\([4, 5, \\dots]\\) 。</li> <li>若第一輪選擇 \\(5\\) ，則第二輪應該跳過 \\(3\\) 和 \\(4\\) ，因為子集 \\([5, 3, \\dots]\\) 和 \\([5, 4, \\dots]\\) 與第 <code>1.</code> 步和第 <code>2.</code> 步中描述的子集完全重複。</li> </ol> <p></p> <p> 圖 13-11   不同選擇順序導致的重複子集 </p> <p>總結來看，給定輸入陣列 \\([x_1, x_2, \\dots, x_n]\\) ，設搜尋過程中的選擇序列為 \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) ，則該選擇序列需要滿足 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ，不滿足該條件的選擇序列都會造成重複，應當剪枝。</p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>為實現該剪枝，我們初始化變數 <code>start</code> ，用於指示走訪起始點。當做出選擇 \\(x_{i}\\) 後，設定下一輪從索引 \\(i\\) 開始走訪。這樣做就可以讓選擇序列滿足 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) ，從而保證子集唯一。</p> <p>除此之外，我們還對程式碼進行了以下兩項最佳化。</p> <ul> <li>在開啟搜尋前，先將陣列 <code>nums</code> 排序。在走訪所有選擇時，當子集和超過 <code>target</code> 時直接結束迴圈，因為後邊的元素更大，其子集和一定超過 <code>target</code> 。</li> <li>省去元素和變數 <code>total</code> ，透過在 <code>target</code> 上執行減法來統計元素和，當 <code>target</code> 等於 \\(0\\) 時記錄解。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_i.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"回溯演算法：子集和 I\"\"\"\n    # 子集和等於 target 時，記錄解\n    if target == 0:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    # 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in range(start, len(choices)):\n        # 剪枝一：若子集和超過 target ，則直接結束迴圈\n        # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0:\n            break\n        # 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 I\"\"\"\n    state = []  # 狀態（子集）\n    nums.sort()  # 對 nums 進行排序\n    start = 0  # 走訪起始點\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_i.cpp<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 I */\nvector&lt;vector&lt;int&gt;&gt; subsetSumI(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 狀態（子集）\n    sort(nums.begin(), nums.end()); // 對 nums 進行排序\n    int start = 0;                  // 走訪起始點\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.java<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;Integer&gt;&gt; subsetSumI(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    Arrays.sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.cs<pre><code>/* 回溯演算法：子集和 I */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;int&gt;&gt; SubsetSumI(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    Array.Sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.go<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i := start; i &lt; len(*choices); i++ {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    sort.Ints(nums)         // 對 nums 進行排序\n    start := 0              // 走訪起始點\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumI(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.swift<pre><code>/* 回溯演算法：子集和 I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in choices.indices.dropFirst(start) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 I */\nfunc subsetSumI(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let nums = nums.sorted() // 對 nums 進行排序\n    let start = 0 // 走訪起始點\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_i.js<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(state, target, choices, start, res) {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfunction subsetSumI(nums, target) {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.ts<pre><code>/* 回溯演算法：子集和 I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_i.dart<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  // 剪枝二：從 start 開始走訪，避免生成重複子集\n  for (int i = start; i &lt; choices.length; i++) {\n    // 剪枝一：若子集和超過 target ，則直接結束迴圈\n    // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 嘗試：做出選擇，更新 target, start\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 I */\nList&lt;List&lt;int&gt;&gt; subsetSumI(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  nums.sort(); // 對 nums 進行排序\n  int start = 0; // 走訪起始點\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_i.rs<pre><code>/* 回溯演算法：子集和 I */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for i in start..choices.len() {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 I */\nfn subset_sum_i(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    nums.sort(); // 對 nums 進行排序\n    let start = 0; // 走訪起始點\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_i.c<pre><code>/* 回溯演算法：子集和 I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 進行下一輪選擇\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // 對 nums 進行排序\n    int start = 0;                           // 走訪起始點\n    backtrack(target, nums, numsSize, start);\n}\n</code></pre> subset_sum_i.kt<pre><code>/* 回溯演算法：子集和 I */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    for (i in start..&lt;choices.size) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 I */\nfun subsetSumI(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    nums.sort() // 對 nums 進行排序\n    val start = 0 // 走訪起始點\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_i.rb<pre><code>### 回溯演算法：子集和 I ###\ndef backtrack(state, target, choices, start, res)\n  # 子集和等於 target 時，記錄解\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n  # 走訪所有選擇\n  # 剪枝二：從 start 開始走訪，避免生成重複子集\n  for i in start...choices.length\n    # 剪枝一：若子集和超過 target ，則直接結束迴圈\n    # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    break if target - choices[i] &lt; 0\n    # 嘗試：做出選擇，更新 target, start\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 I ###\ndef subset_sum_i(nums, target)\n  state = [] # 狀態（子集）\n  nums.sort! # 對 nums 進行排序\n  start = 0 # 走訪起始點\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 13-12 所示為將陣列 \\([3, 4, 5]\\) 和目標元素 \\(9\\) 輸入以上程式碼後的整體回溯過程。</p> <p></p> <p> 圖 13-12   子集和 I 回溯過程 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1332","level":2,"title":"13.3.2   考慮重複元素的情況","text":"<p>Question</p> <p>給定一個正整數陣列 <code>nums</code> 和一個目標正整數 <code>target</code> ，請找出所有可能的組合，使得組合中的元素和等於 <code>target</code> 。給定陣列可能包含重複元素，每個元素只可被選擇一次。請以串列形式返回這些組合，串列中不應包含重複組合。</p> <p>相比於上題，本題的輸入陣列可能包含重複元素，這引入了新的問題。例如，給定陣列 \\([4, \\hat{4}, 5]\\) 和目標元素 \\(9\\) ，則現有程式碼的輸出結果為 \\([4, 5], [\\hat{4}, 5]\\) ，出現了重複子集。</p> <p>造成這種重複的原因是相等元素在某輪中被多次選擇。在圖 13-13 中，第一輪共有三個選擇，其中兩個都為 \\(4\\) ，會產生兩個重複的搜尋分支，從而輸出重複子集；同理，第二輪的兩個 \\(4\\) 也會產生重複子集。</p> <p></p> <p> 圖 13-13   相等元素導致的重複子集 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#1_1","level":3,"title":"1.   相等元素剪枝","text":"<p>為解決此問題，我們需要限制相等元素在每一輪中只能被選擇一次。實現方式比較巧妙：由於陣列是已排序的，因此相等元素都是相鄰的。這意味著在某輪選擇中，若當前元素與其左邊元素相等，則說明它已經被選擇過，因此直接跳過當前元素。</p> <p>與此同時，本題規定每個陣列元素只能被選擇一次。幸運的是，我們也可以利用變數 <code>start</code> 來滿足該約束：當做出選擇 \\(x_{i}\\) 後，設定下一輪從索引 \\(i + 1\\) 開始向後走訪。這樣既能去除重複子集，也能避免重複選擇元素。</p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/subset_sum_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby subset_sum_ii.py<pre><code>def backtrack(\n    state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n    \"\"\"回溯演算法：子集和 II\"\"\"\n    # 子集和等於 target 時，記錄解\n    if target == 0:\n        res.append(list(state))\n        return\n    # 走訪所有選擇\n    # 剪枝二：從 start 開始走訪，避免生成重複子集\n    # 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in range(start, len(choices)):\n        # 剪枝一：若子集和超過 target ，則直接結束迴圈\n        # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0:\n            break\n        # 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start and choices[i] == choices[i - 1]:\n            continue\n        # 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        # 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        # 回退：撤銷選擇，恢復到之前的狀態\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -&gt; list[list[int]]:\n    \"\"\"求解子集和 II\"\"\"\n    state = []  # 狀態（子集）\n    nums.sort()  # 對 nums 進行排序\n    start = 0  # 走訪起始點\n    res = []  # 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n</code></pre> subset_sum_ii.cpp<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(vector&lt;int&gt; &amp;state, int target, vector&lt;int&gt; &amp;choices, int start, vector&lt;vector&lt;int&gt;&gt; &amp;res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.push_back(state);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.size(); i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push_back(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop_back();\n    }\n}\n\n/* 求解子集和 II */\nvector&lt;vector&lt;int&gt;&gt; subsetSumII(vector&lt;int&gt; &amp;nums, int target) {\n    vector&lt;int&gt; state;              // 狀態（子集）\n    sort(nums.begin(), nums.end()); // 對 nums 進行排序\n    int start = 0;                  // 走訪起始點\n    vector&lt;vector&lt;int&gt;&gt; res;        // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.java<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(List&lt;Integer&gt; state, int target, int[] choices, int start, List&lt;List&lt;Integer&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(new ArrayList&lt;&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.remove(state.size() - 1);\n    }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;Integer&gt;&gt; subsetSumII(int[] nums, int target) {\n    List&lt;Integer&gt; state = new ArrayList&lt;&gt;(); // 狀態（子集）\n    Arrays.sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;Integer&gt;&gt; res = new ArrayList&lt;&gt;(); // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.cs<pre><code>/* 回溯演算法：子集和 II */\nvoid Backtrack(List&lt;int&gt; state, int target, int[] choices, int start, List&lt;List&lt;int&gt;&gt; res) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.Add(new List&lt;int&gt;(state));\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choices.Length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.Add(choices[i]);\n        // 進行下一輪選擇\n        Backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;int&gt;&gt; SubsetSumII(int[] nums, int target) {\n    List&lt;int&gt; state = []; // 狀態（子集）\n    Array.Sort(nums); // 對 nums 進行排序\n    int start = 0; // 走訪起始點\n    List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.go<pre><code>/* 回溯演算法：子集和 II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i := start; i &lt; len(*choices); i++ {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target-(*choices)[i] &lt; 0 {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start &amp;&amp; (*choices)[i] == (*choices)[i-1] {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        *state = append(*state, (*choices)[i])\n        // 進行下一輪選擇\n        backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        *state = (*state)[:len(*state)-1]\n    }\n}\n\n/* 求解子集和 II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // 狀態（子集）\n    sort.Ints(nums)         // 對 nums 進行排序\n    start := 0              // 走訪起始點\n    res := make([][]int, 0) // 結果串列（子集串列）\n    backtrackSubsetSumII(start, target, &amp;state, &amp;nums, &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.swift<pre><code>/* 回溯演算法：子集和 II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.append(state)\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in choices.indices.dropFirst(start) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.append(choices[i])\n        // 進行下一輪選擇\n        backtrack(state: &amp;state, target: target - choices[i], choices: choices, start: i + 1, res: &amp;res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeLast()\n    }\n}\n\n/* 求解子集和 II */\nfunc subsetSumII(nums: [Int], target: Int) -&gt; [[Int]] {\n    var state: [Int] = [] // 狀態（子集）\n    let nums = nums.sorted() // 對 nums 進行排序\n    let start = 0 // 走訪起始點\n    var res: [[Int]] = [] // 結果串列（子集串列）\n    backtrack(state: &amp;state, target: target, choices: nums, start: start, res: &amp;res)\n    return res\n}\n</code></pre> subset_sum_ii.js<pre><code>/* 回溯演算法：子集和 II */\nfunction backtrack(state, target, choices, start, res) {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfunction subsetSumII(nums, target) {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.ts<pre><code>/* 回溯演算法：子集和 II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // 子集和等於 target 時，記錄解\n    if (target === 0) {\n        res.push([...state]);\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (let i = start; i &lt; choices.length; i++) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // 狀態（子集）\n    nums.sort((a, b) =&gt; a - b); // 對 nums 進行排序\n    const start = 0; // 走訪起始點\n    const res = []; // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n</code></pre> subset_sum_ii.dart<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(\n  List&lt;int&gt; state,\n  int target,\n  List&lt;int&gt; choices,\n  int start,\n  List&lt;List&lt;int&gt;&gt; res,\n) {\n  // 子集和等於 target 時，記錄解\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\n  }\n  // 走訪所有選擇\n  // 剪枝二：從 start 開始走訪，避免生成重複子集\n  // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n  for (int i = start; i &lt; choices.length; i++) {\n    // 剪枝一：若子集和超過 target ，則直接結束迴圈\n    // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    if (target - choices[i] &lt; 0) {\n      break;\n    }\n    // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n    if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // 嘗試：做出選擇，更新 target, start\n    state.add(choices[i]);\n    // 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i + 1, res);\n    // 回退：撤銷選擇，恢復到之前的狀態\n    state.removeLast();\n  }\n}\n\n/* 求解子集和 II */\nList&lt;List&lt;int&gt;&gt; subsetSumII(List&lt;int&gt; nums, int target) {\n  List&lt;int&gt; state = []; // 狀態（子集）\n  nums.sort(); // 對 nums 進行排序\n  int start = 0; // 走訪起始點\n  List&lt;List&lt;int&gt;&gt; res = []; // 結果串列（子集串列）\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n</code></pre> subset_sum_ii.rs<pre><code>/* 回溯演算法：子集和 II */\nfn backtrack(\n    state: &amp;mut Vec&lt;i32&gt;,\n    target: i32,\n    choices: &amp;[i32],\n    start: usize,\n    res: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;,\n) {\n    // 子集和等於 target 時，記錄解\n    if target == 0 {\n        res.push(state.clone());\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for i in start..choices.len() {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if target - choices[i] &lt; 0 {\n            break;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if i &gt; start &amp;&amp; choices[i] == choices[i - 1] {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.push(choices[i]);\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.pop();\n    }\n}\n\n/* 求解子集和 II */\nfn subset_sum_ii(nums: &amp;mut [i32], target: i32) -&gt; Vec&lt;Vec&lt;i32&gt;&gt; {\n    let mut state = Vec::new(); // 狀態（子集）\n    nums.sort(); // 對 nums 進行排序\n    let start = 0; // 走訪起始點\n    let mut res = Vec::new(); // 結果串列（子集串列）\n    backtrack(&amp;mut state, target, nums, start, &amp;mut res);\n    res\n}\n</code></pre> subset_sum_ii.c<pre><code>/* 回溯演算法：子集和 II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        for (int i = 0; i &lt; stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (int i = start; i &lt; choicesSize; i++) {\n        // 剪枝一：若子集和超過 target ，則直接跳過\n        if (target - choices[i] &lt; 0) {\n            continue;\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // 進行下一輪選擇\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // 回退：撤銷選擇，恢復到之前的狀態\n        stateSize--;\n    }\n}\n\n/* 求解子集和 II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // 對 nums 進行排序\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // 開始回溯\n    backtrack(target, nums, numsSize, 0);\n}\n</code></pre> subset_sum_ii.kt<pre><code>/* 回溯演算法：子集和 II */\nfun backtrack(\n    state: MutableList&lt;Int&gt;,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList&lt;MutableList&lt;Int&gt;?&gt;\n) {\n    // 子集和等於 target 時，記錄解\n    if (target == 0) {\n        res.add(state.toMutableList())\n        return\n    }\n    // 走訪所有選擇\n    // 剪枝二：從 start 開始走訪，避免生成重複子集\n    // 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n    for (i in start..&lt;choices.size) {\n        // 剪枝一：若子集和超過 target ，則直接結束迴圈\n        // 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n        if (target - choices[i] &lt; 0) {\n            break\n        }\n        // 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n        if (i &gt; start &amp;&amp; choices[i] == choices[i - 1]) {\n            continue\n        }\n        // 嘗試：做出選擇，更新 target, start\n        state.add(choices[i])\n        // 進行下一輪選擇\n        backtrack(state, target - choices[i], choices, i + 1, res)\n        // 回退：撤銷選擇，恢復到之前的狀態\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* 求解子集和 II */\nfun subsetSumII(nums: IntArray, target: Int): MutableList&lt;MutableList&lt;Int&gt;?&gt; {\n    val state = mutableListOf&lt;Int&gt;() // 狀態（子集）\n    nums.sort() // 對 nums 進行排序\n    val start = 0 // 走訪起始點\n    val res = mutableListOf&lt;MutableList&lt;Int&gt;?&gt;() // 結果串列（子集串列）\n    backtrack(state, target, nums, start, res)\n    return res\n}\n</code></pre> subset_sum_ii.rb<pre><code>### 回溯演算法：子集和 II ###\ndef backtrack(state, target, choices, start, res)\n  # 子集和等於 target 時，記錄解\n  if target.zero?\n    res &lt;&lt; state.dup\n    return\n  end\n\n  # 走訪所有選擇\n  # 剪枝二：從 start 開始走訪，避免生成重複子集\n  # 剪枝三：從 start 開始走訪，避免重複選擇同一元素\n  for i in start...choices.length\n    # 剪枝一：若子集和超過 target ，則直接結束迴圈\n    # 這是因為陣列已排序，後邊元素更大，子集和一定超過 target\n    break if target - choices[i] &lt; 0\n    # 剪枝四：如果該元素與左邊元素相等，說明該搜尋分支重複，直接跳過\n    next if i &gt; start &amp;&amp; choices[i] == choices[i - 1]\n    # 嘗試：做出選擇，更新 target, start\n    state &lt;&lt; choices[i]\n    # 進行下一輪選擇\n    backtrack(state, target - choices[i], choices, i + 1, res)\n    # 回退：撤銷選擇，恢復到之前的狀態\n    state.pop\n  end\nend\n\n### 求解子集和 II ###\ndef subset_sum_ii(nums, target)\n  state = [] # 狀態（子集）\n  nums.sort! # 對 nums 進行排序\n  start = 0 # 走訪起始點\n  res = [] # 結果串列（子集串列）\n  backtrack(state, target, nums, start, res)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 13-14 展示了陣列 \\([4, 4, 5]\\) 和目標元素 \\(9\\) 的回溯過程，共包含四種剪枝操作。請你將圖示與程式碼註釋相結合，理解整個搜尋過程，以及每種剪枝操作是如何工作的。</p> <p></p> <p> 圖 13-14   子集和 II 回溯過程 </p>","path":["第 13 章 &nbsp; 回溯","13.3 &nbsp; 子集和問題"],"tags":[]},{"location":"chapter_backtracking/summary/","level":1,"title":"13.5   小結","text":"","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>回溯演算法本質是窮舉法，透過對解空間進行深度優先走訪來尋找符合條件的解。在搜尋過程中，遇到滿足條件的解則記錄，直至找到所有解或走訪完成後結束。</li> <li>回溯演算法的搜尋過程包括嘗試與回退兩個部分。它透過深度優先搜尋來嘗試各種選擇，當遇到不滿足約束條件的情況時，則撤銷上一步的選擇，退回到之前的狀態，並繼續嘗試其他選擇。嘗試與回退是兩個方向相反的操作。</li> <li>回溯問題通常包含多個約束條件，它們可用於實現剪枝操作。剪枝可以提前結束不必要的搜尋分支，大幅提升搜尋效率。</li> <li>回溯演算法主要可用於解決搜尋問題和約束滿足問題。組合最佳化問題雖然可以用回溯演算法解決，但往往存在效率更高或效果更好的解法。</li> <li>全排列問題旨在搜尋給定集合元素的所有可能的排列。我們藉助一個陣列來記錄每個元素是否被選擇，剪掉重複選擇同一元素的搜尋分支，確保每個元素只被選擇一次。</li> <li>在全排列問題中，如果集合中存在重複元素，則最終結果會出現重複排列。我們需要約束相等元素在每輪中只能被選擇一次，這通常藉助一個雜湊集合來實現。</li> <li>子集和問題的目標是在給定集合中找到和為目標值的所有子集。集合不區分元素順序，而搜尋過程會輸出所有順序的結果，產生重複子集。我們在回溯前將資料進行排序，並設定一個變數來指示每一輪的走訪起始點，從而將生成重複子集的搜尋分支進行剪枝。</li> <li>對於子集和問題，陣列中的相等元素會產生重複集合。我們利用陣列已排序的前置條件，透過判斷相鄰元素是否相等實現剪枝，從而確保相等元素在每輪中只能被選中一次。</li> <li>\\(n\\) 皇后問題旨在尋找將 \\(n\\) 個皇后放置到 \\(n \\times n\\) 尺寸棋盤上的方案，要求所有皇后兩兩之間無法攻擊對方。該問題的約束條件有行約束、列約束、主對角線和次對角線約束。為滿足行約束，我們採用按行放置的策略，保證每一行放置一個皇后。</li> <li>列約束和對角線約束的處理方式類似。對於列約束，我們利用一個陣列來記錄每一列是否有皇后，從而指示選中的格子是否合法。對於對角線約束，我們藉助兩個陣列來分別記錄該主、次對角線上是否存在皇后；難點在於找出處在同一主（副）對角線上的格子所滿足的行列索引規律。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_backtracking/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：怎麼理解回溯和遞迴的關係？</p> <p>總的來看，回溯是一種“演算法策略”，而遞迴更像是一個“工具”。</p> <ul> <li>回溯演算法通常基於遞迴實現。然而，回溯是遞迴的應用場景之一，是遞迴在搜尋問題中的應用。</li> <li>遞迴的結構體現了“子問題分解”的解題範式，常用於解決分治、回溯、動態規劃（記憶化遞迴）等問題。</li> </ul>","path":["第 13 章 &nbsp; 回溯","13.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/","level":1,"title":"第 2 章   複雜度分析","text":"<p>Abstract</p> <p>複雜度分析猶如浩瀚的演算法宇宙中的時空嚮導。</p> <p>它帶領我們在時間與空間這兩個維度上深入探索，尋找更優雅的解決方案。</p>","path":["第 2 章 &nbsp; 複雜度分析"],"tags":[]},{"location":"chapter_computational_complexity/#_1","level":2,"title":"本章內容","text":"<ul> <li>2.1   演算法效率評估</li> <li>2.2   迭代與遞迴</li> <li>2.3   時間複雜度</li> <li>2.4   空間複雜度</li> <li>2.5   小結</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/","level":1,"title":"2.2   迭代與遞迴","text":"<p>在演算法中，重複執行某個任務是很常見的，它與複雜度分析息息相關。因此，在介紹時間複雜度和空間複雜度之前，我們先來了解如何在程式中實現重複執行任務，即兩種基本的程式控制結構：迭代、遞迴。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","level":2,"title":"2.2.1   迭代","text":"<p>迭代（iteration）是一種重複執行某個任務的控制結構。在迭代中，程式會在滿足一定的條件下重複執行某段程式碼，直到這個條件不再滿足。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","level":3,"title":"1.   for 迴圈","text":"<p><code>for</code> 迴圈是最常見的迭代形式之一，適合在預先知道迭代次數時使用。</p> <p>以下函式基於 <code>for</code> 迴圈實現了求和 \\(1 + 2 + \\dots + n\\) ，求和結果使用變數 <code>res</code> 記錄。需要注意的是，Python 中 <code>range(a, b)</code> 對應的區間是“左閉右開”的，對應的走訪範圍為 \\(a, a + 1, \\dots, b-1\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def for_loop(n: int) -&gt; int:\n    \"\"\"for 迴圈\"\"\"\n    res = 0\n    # 迴圈求和 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n</code></pre> iteration.cpp<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* for 迴圈 */\nint ForLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* for 迴圈 */\nfunc forLoop(n int) int {\n    res := 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* for 迴圈 */\nfunc forLoop(n: Int) -&gt; Int {\n    var res = 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* for 迴圈 */\nfunction forLoop(n) {\n    let res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* for 迴圈 */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n  int res = 0;\n  // 迴圈求和 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    res += i;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* for 迴圈 */\nfn for_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* for 迴圈 */\nint forLoop(int n) {\n    int res = 0;\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        res += i;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* for 迴圈 */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // 迴圈求和 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### for 迴圈 ###\ndef for_loop(n)\n  res = 0\n\n  # 迴圈求和 1, 2, ..., n-1, n\n  for i in 1..n\n    res += i\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-1 是該求和函式的流程框圖。</p> <p></p> <p> 圖 2-1   求和函式的流程框圖 </p> <p>此求和函式的操作數量與輸入資料大小 \\(n\\) 成正比，或者說成“線性關係”。實際上，時間複雜度描述的就是這個“線性關係”。相關內容將會在下一節中詳細介紹。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","level":3,"title":"2.   while 迴圈","text":"<p>與 <code>for</code> 迴圈類似，<code>while</code> 迴圈也是一種實現迭代的方法。在 <code>while</code> 迴圈中，程式每輪都會先檢查條件，如果條件為真，則繼續執行，否則就結束迴圈。</p> <p>下面我們用 <code>while</code> 迴圈來實現求和 \\(1 + 2 + \\dots + n\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop(n: int) -&gt; int:\n    \"\"\"while 迴圈\"\"\"\n    res = 0\n    i = 1  # 初始化條件變數\n    # 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n:\n        res += i\n        i += 1  # 更新條件變數\n    return res\n</code></pre> iteration.cpp<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while 迴圈 */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i += 1; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while 迴圈 */\nfunc whileLoop(n int) int {\n    res := 0\n    // 初始化條件變數\n    i := 1\n    // 迴圈求和 1, 2, ..., n-1, n\n    for i &lt;= n {\n        res += i\n        // 更新條件變數\n        i++\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while 迴圈 */\nfunc whileLoop(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i\n        i += 1 // 更新條件變數\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while 迴圈 */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while 迴圈 */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // 初始化條件變數\n  // 迴圈求和 1, 2, ..., n-1, n\n  while (i &lt;= n) {\n    res += i;\n    i++; // 更新條件變數\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while 迴圈 */\nfn while_loop(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 初始化條件變數\n\n    // 迴圈求和 1, 2, ..., n-1, n\n    while i &lt;= n {\n        res += i;\n        i += 1; // 更新條件變數\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while 迴圈 */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i;\n        i++; // 更新條件變數\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while 迴圈 */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 2, ..., n-1, n\n    while (i &lt;= n) {\n        res += i\n        i++ // 更新條件變數\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while 迴圈 ###\ndef while_loop(n)\n  res = 0\n  i = 1 # 初始化條件變數\n\n  # 迴圈求和 1, 2, ..., n-1, n\n  while i &lt;= n\n    res += i\n    i += 1 # 更新條件變數\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p><code>while</code> 迴圈比 <code>for</code> 迴圈的自由度更高。在 <code>while</code> 迴圈中，我們可以自由地設計條件變數的初始化和更新步驟。</p> <p>例如在以下程式碼中，條件變數 \\(i\\) 每輪進行兩次更新，這種情況就不太方便用 <code>for</code> 迴圈實現：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def while_loop_ii(n: int) -&gt; int:\n    \"\"\"while 迴圈（兩次更新）\"\"\"\n    res = 0\n    i = 1  # 初始化條件變數\n    # 迴圈求和 1, 4, 10, ...\n    while i &lt;= n:\n        res += i\n        # 更新條件變數\n        i += 1\n        i *= 2\n    return res\n</code></pre> iteration.cpp<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.java<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.cs<pre><code>/* while 迴圈（兩次更新） */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.go<pre><code>/* while 迴圈（兩次更新） */\nfunc whileLoopII(n int) int {\n    res := 0\n    // 初始化條件變數\n    i := 1\n    // 迴圈求和 1, 4, 10, ...\n    for i &lt;= n {\n        res += i\n        // 更新條件變數\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* while 迴圈（兩次更新） */\nfunc whileLoopII(n: Int) -&gt; Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while i &lt;= n {\n        res += i\n        // 更新條件變數\n        i += 1\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* while 迴圈（兩次更新） */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* while 迴圈（兩次更新） */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // 初始化條件變數\n  // 迴圈求和 1, 4, 10, ...\n  while (i &lt;= n) {\n    res += i;\n    // 更新條件變數\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* while 迴圈（兩次更新） */\nfn while_loop_ii(n: i32) -&gt; i32 {\n    let mut res = 0;\n    let mut i = 1; // 初始化條件變數\n\n    // 迴圈求和 1, 4, 10, ...\n    while i &lt;= n {\n        res += i;\n        // 更新條件變數\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n</code></pre> iteration.c<pre><code>/* while 迴圈（兩次更新） */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i;\n        // 更新條件變數\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* while 迴圈（兩次更新） */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // 初始化條件變數\n    // 迴圈求和 1, 4, 10, ...\n    while (i &lt;= n) {\n        res += i\n        // 更新條件變數\n        i++\n        i *= 2\n    }\n    return res\n}\n</code></pre> iteration.rb<pre><code>### while 迴圈（兩次更新）###\ndef while_loop_ii(n)\n  res = 0\n  i = 1 # 初始化條件變數\n\n  # 迴圈求和 1, 4, 10, ...\n  while i &lt;= n\n    res += i\n    # 更新條件變數\n    i += 1\n    i *= 2\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總的來說，<code>for</code> 迴圈的程式碼更加緊湊，<code>while</code> 迴圈更加靈活，兩者都可以實現迭代結構。選擇使用哪一個應該根據特定問題的需求來決定。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","level":3,"title":"3.   巢狀迴圈","text":"<p>我們可以在一個迴圈結構內巢狀另一個迴圈結構，下面以 <code>for</code> 迴圈為例：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby iteration.py<pre><code>def nested_for_loop(n: int) -&gt; str:\n    \"\"\"雙層 for 迴圈\"\"\"\n    res = \"\"\n    # 迴圈 i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # 迴圈 j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n</code></pre> iteration.cpp<pre><code>/* 雙層 for 迴圈 */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; ++i) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; ++j) {\n            res &lt;&lt; \"(\" &lt;&lt; i &lt;&lt; \", \" &lt;&lt; j &lt;&lt; \"), \";\n        }\n    }\n    return res.str();\n}\n</code></pre> iteration.java<pre><code>/* 雙層 for 迴圈 */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n</code></pre> iteration.cs<pre><code>/* 雙層 for 迴圈 */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n</code></pre> iteration.go<pre><code>/* 雙層 for 迴圈 */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= n; j++ {\n            // 迴圈 j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n</code></pre> iteration.swift<pre><code>/* 雙層 for 迴圈 */\nfunc nestedForLoop(n: Int) -&gt; String {\n    var res = \"\"\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n</code></pre> iteration.js<pre><code>/* 雙層 for 迴圈 */\nfunction nestedForLoop(n) {\n    let res = '';\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.ts<pre><code>/* 雙層 for 迴圈 */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (let i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (let j = 1; j &lt;= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n</code></pre> iteration.dart<pre><code>/* 雙層 for 迴圈 */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // 迴圈 i = 1, 2, ..., n-1, n\n  for (int i = 1; i &lt;= n; i++) {\n    // 迴圈 j = 1, 2, ..., n-1, n\n    for (int j = 1; j &lt;= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n</code></pre> iteration.rs<pre><code>/* 雙層 for 迴圈 */\nfn nested_for_loop(n: i32) -&gt; String {\n    let mut res = vec![];\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n</code></pre> iteration.c<pre><code>/* 雙層 for 迴圈 */\nchar *nestedForLoop(int n) {\n    // n * n 為對應點數量，\"(i, j), \" 對應字串長最大為 6+10*2，加上最後一個空字元 \\0 的額外空間\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (int i = 1; i &lt;= n; i++) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (int j = 1; j &lt;= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n</code></pre> iteration.kt<pre><code>/* 雙層 for 迴圈 */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // 迴圈 i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // 迴圈 j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n</code></pre> iteration.rb<pre><code>### 雙層 for 迴圈 ###\ndef nested_for_loop(n)\n  res = \"\"\n\n  # 迴圈 i = 1, 2, ..., n-1, n\n  for i in 1..n\n    # 迴圈 j = 1, 2, ..., n-1, n\n    for j in 1..n\n      res += \"(#{i}, #{j}), \"\n    end\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-2 是該巢狀迴圈的流程框圖。</p> <p></p> <p> 圖 2-2   巢狀迴圈的流程框圖 </p> <p>在這種情況下，函式的操作數量與 \\(n^2\\) 成正比，或者說演算法執行時間和輸入資料大小 \\(n\\) 成“平方關係”。</p> <p>我們可以繼續新增巢狀迴圈，每一次巢狀都是一次“升維”，將會使時間複雜度提高至“立方關係”“四次方關係”，以此類推。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","level":2,"title":"2.2.2   遞迴","text":"<p>遞迴（recursion）是一種演算法策略，透過函式呼叫自身來解決問題。它主要包含兩個階段。</p> <ol> <li>遞：程式不斷深入地呼叫自身，通常傳入更小或更簡化的參數，直到達到“終止條件”。</li> <li>迴：觸發“終止條件”後，程式從最深層的遞迴函式開始逐層返回，匯聚每一層的結果。</li> </ol> <p>而從實現的角度看，遞迴程式碼主要包含三個要素。</p> <ol> <li>終止條件：用於決定什麼時候由“遞”轉“迴”。</li> <li>遞迴呼叫：對應“遞”，函式呼叫自身，通常輸入更小或更簡化的參數。</li> <li>返回結果：對應“迴”，將當前遞迴層級的結果返回至上一層。</li> </ol> <p>觀察以下程式碼，我們只需呼叫函式 <code>recur(n)</code>  ，就可以完成 \\(1 + 2 + \\dots + n\\) 的計算：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def recur(n: int) -&gt; int:\n    \"\"\"遞迴\"\"\"\n    # 終止條件\n    if n == 1:\n        return 1\n    # 遞：遞迴呼叫\n    res = recur(n - 1)\n    # 迴：返回結果\n    return n + res\n</code></pre> recursion.cpp<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.java<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.cs<pre><code>/* 遞迴 */\nint Recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = Recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.go<pre><code>/* 遞迴 */\nfunc recur(n int) int {\n    // 終止條件\n    if n == 1 {\n        return 1\n    }\n    // 遞：遞迴呼叫\n    res := recur(n - 1)\n    // 迴：返回結果\n    return n + res\n}\n</code></pre> recursion.swift<pre><code>/* 遞迴 */\nfunc recur(n: Int) -&gt; Int {\n    // 終止條件\n    if n == 1 {\n        return 1\n    }\n    // 遞：遞迴呼叫\n    let res = recur(n: n - 1)\n    // 迴：返回結果\n    return n + res\n}\n</code></pre> recursion.js<pre><code>/* 遞迴 */\nfunction recur(n) {\n    // 終止條件\n    if (n === 1) return 1;\n    // 遞：遞迴呼叫\n    const res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.ts<pre><code>/* 遞迴 */\nfunction recur(n: number): number {\n    // 終止條件\n    if (n === 1) return 1;\n    // 遞：遞迴呼叫\n    const res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.dart<pre><code>/* 遞迴 */\nint recur(int n) {\n  // 終止條件\n  if (n == 1) return 1;\n  // 遞：遞迴呼叫\n  int res = recur(n - 1);\n  // 迴：返回結果\n  return n + res;\n}\n</code></pre> recursion.rs<pre><code>/* 遞迴 */\nfn recur(n: i32) -&gt; i32 {\n    // 終止條件\n    if n == 1 {\n        return 1;\n    }\n    // 遞：遞迴呼叫\n    let res = recur(n - 1);\n    // 迴：返回結果\n    n + res\n}\n</code></pre> recursion.c<pre><code>/* 遞迴 */\nint recur(int n) {\n    // 終止條件\n    if (n == 1)\n        return 1;\n    // 遞：遞迴呼叫\n    int res = recur(n - 1);\n    // 迴：返回結果\n    return n + res;\n}\n</code></pre> recursion.kt<pre><code>/* 遞迴 */\nfun recur(n: Int): Int {\n    // 終止條件\n    if (n == 1)\n        return 1\n    // 遞: 遞迴呼叫\n    val res = recur(n - 1)\n    // 迴: 返回結果\n    return n + res\n}\n</code></pre> recursion.rb<pre><code>### 遞迴 ###\ndef recur(n)\n  # 終止條件\n  return 1 if n == 1\n  # 遞：遞迴呼叫\n  res = recur(n - 1)\n  # 迴：返回結果\n  n + res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-3 展示了該函式的遞迴過程。</p> <p></p> <p> 圖 2-3   求和函式的遞迴過程 </p> <p>雖然從計算角度看，迭代與遞迴可以得到相同的結果，但它們代表了兩種完全不同的思考和解決問題的範式。</p> <ul> <li>迭代：“自下而上”地解決問題。從最基礎的步驟開始，然後不斷重複或累加這些步驟，直到任務完成。</li> <li>遞迴：“自上而下”地解決問題。將原問題分解為更小的子問題，這些子問題和原問題具有相同的形式。接下來將子問題繼續分解為更小的子問題，直到基本情況時停止（基本情況的解是已知的）。</li> </ul> <p>以上述求和函式為例，設問題 \\(f(n) = 1 + 2 + \\dots + n\\) 。</p> <ul> <li>迭代：在迴圈中模擬求和過程，從 \\(1\\) 走訪到 \\(n\\) ，每輪執行求和操作，即可求得 \\(f(n)\\) 。</li> <li>遞迴：將問題分解為子問題 \\(f(n) = n + f(n-1)\\) ，不斷（遞迴地）分解下去，直至基本情況 \\(f(1) = 1\\) 時終止。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","level":3,"title":"1.   呼叫堆疊","text":"<p>遞迴函式每次呼叫自身時，系統都會為新開啟的函式分配記憶體，以儲存區域性變數、呼叫位址和其他資訊等。這將導致兩方面的結果。</p> <ul> <li>函式的上下文資料都儲存在稱為“堆疊幀空間”的記憶體區域中，直至函式返回後才會被釋放。因此，遞迴通常比迭代更加耗費記憶體空間。</li> <li>遞迴呼叫函式會產生額外的開銷。因此遞迴通常比迴圈的時間效率更低。</li> </ul> <p>如圖 2-4 所示，在觸發終止條件前，同時存在 \\(n\\) 個未返回的遞迴函式，遞迴深度為 \\(n\\) 。</p> <p></p> <p> 圖 2-4   遞迴呼叫深度 </p> <p>在實際中，程式語言允許的遞迴深度通常是有限的，過深的遞迴可能導致堆疊溢位錯誤。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","level":3,"title":"2.   尾遞迴","text":"<p>有趣的是，如果函式在返回前的最後一步才進行遞迴呼叫，則該函式可以被編譯器或直譯器最佳化，使其在空間效率上與迭代相當。這種情況被稱為尾遞迴（tail recursion）。</p> <ul> <li>普通遞迴：當函式返回到上一層級的函式後，需要繼續執行程式碼，因此系統需要儲存上一層呼叫的上下文。</li> <li>尾遞迴：遞迴呼叫是函式返回前的最後一個操作，這意味著函式返回到上一層級後，無須繼續執行其他操作，因此系統無須儲存上一層函式的上下文。</li> </ul> <p>以計算 \\(1 + 2 + \\dots + n\\) 為例，我們可以將結果變數 <code>res</code> 設為函式參數，從而實現尾遞迴：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def tail_recur(n, res):\n    \"\"\"尾遞迴\"\"\"\n    # 終止條件\n    if n == 0:\n        return res\n    # 尾遞迴呼叫\n    return tail_recur(n - 1, res + n)\n</code></pre> recursion.cpp<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.java<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.cs<pre><code>/* 尾遞迴 */\nint TailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return TailRecur(n - 1, res + n);\n}\n</code></pre> recursion.go<pre><code>/* 尾遞迴 */\nfunc tailRecur(n int, res int) int {\n    // 終止條件\n    if n == 0 {\n        return res\n    }\n    // 尾遞迴呼叫\n    return tailRecur(n-1, res+n)\n}\n</code></pre> recursion.swift<pre><code>/* 尾遞迴 */\nfunc tailRecur(n: Int, res: Int) -&gt; Int {\n    // 終止條件\n    if n == 0 {\n        return res\n    }\n    // 尾遞迴呼叫\n    return tailRecur(n: n - 1, res: res + n)\n}\n</code></pre> recursion.js<pre><code>/* 尾遞迴 */\nfunction tailRecur(n, res) {\n    // 終止條件\n    if (n === 0) return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.ts<pre><code>/* 尾遞迴 */\nfunction tailRecur(n: number, res: number): number {\n    // 終止條件\n    if (n === 0) return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.dart<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n  // 終止條件\n  if (n == 0) return res;\n  // 尾遞迴呼叫\n  return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.rs<pre><code>/* 尾遞迴 */\nfn tail_recur(n: i32, res: i32) -&gt; i32 {\n    // 終止條件\n    if n == 0 {\n        return res;\n    }\n    // 尾遞迴呼叫\n    tail_recur(n - 1, res + n)\n}\n</code></pre> recursion.c<pre><code>/* 尾遞迴 */\nint tailRecur(int n, int res) {\n    // 終止條件\n    if (n == 0)\n        return res;\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n);\n}\n</code></pre> recursion.kt<pre><code>/* 尾遞迴 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // 新增 tailrec 關鍵詞，以開啟尾遞迴最佳化\n    // 終止條件\n    if (n == 0)\n        return res\n    // 尾遞迴呼叫\n    return tailRecur(n - 1, res + n)\n}\n</code></pre> recursion.rb<pre><code>### 尾遞迴 ###\ndef tail_recur(n, res)\n  # 終止條件\n  return res if n == 0\n  # 尾遞迴呼叫\n  tail_recur(n - 1, res + n)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>尾遞迴的執行過程如圖 2-5 所示。對比普通遞迴和尾遞迴，兩者的求和操作的執行點是不同的。</p> <ul> <li>普通遞迴：求和操作是在“迴”的過程中執行的，每層返回後都要再執行一次求和操作。</li> <li>尾遞迴：求和操作是在“遞”的過程中執行的，“迴”的過程只需層層返回。</li> </ul> <p></p> <p> 圖 2-5   尾遞迴過程 </p> <p>Tip</p> <p>請注意，許多編譯器或直譯器並不支持尾遞迴最佳化。例如，Python 預設不支持尾遞迴最佳化，因此即使函式是尾遞迴形式，仍然可能會遇到堆疊溢位問題。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","level":3,"title":"3.   遞迴樹","text":"<p>當處理與“分治”相關的演算法問題時，遞迴往往比迭代的思路更加直觀、程式碼更加易讀。以“費波那契數列”為例。</p> <p>Question</p> <p>給定一個費波那契數列 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) ，求該數列的第 \\(n\\) 個數字。</p> <p>設費波那契數列的第 \\(n\\) 個數字為 \\(f(n)\\) ，易得兩個結論。</p> <ul> <li>數列的前兩個數字為 \\(f(1) = 0\\) 和 \\(f(2) = 1\\) 。</li> <li>數列中的每個數字是前兩個數字的和，即 \\(f(n) = f(n - 1) + f(n - 2)\\) 。</li> </ul> <p>按照遞推關係進行遞迴呼叫，將前兩個數字作為終止條件，便可寫出遞迴程式碼。呼叫 <code>fib(n)</code> 即可得到費波那契數列的第 \\(n\\) 個數字：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def fib(n: int) -&gt; int:\n    \"\"\"費波那契數列：遞迴\"\"\"\n    # 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # 返回結果 f(n)\n    return res\n</code></pre> recursion.cpp<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 費波那契數列：遞迴 */\nint Fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 費波那契數列：遞迴 */\nfunc fib(n int) int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 費波那契數列：遞迴 */\nfunc fib(n: Int) -&gt; Int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 費波那契數列：遞迴 */\nfunction fib(n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 費波那契數列：遞迴 */\nfunction fib(n: number): number {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n  // 終止條件 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // 返回結果 f(n)\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 費波那契數列：遞迴 */\nfn fib(n: i32) -&gt; i32 {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // 返回結果\n    res\n}\n</code></pre> recursion.c<pre><code>/* 費波那契數列：遞迴 */\nint fib(int n) {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // 返回結果 f(n)\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 費波那契數列：遞迴 */\nfun fib(n: Int): Int {\n    // 終止條件 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // 返回結果 f(n)\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 費波那契數列：遞迴 ###\ndef fib(n)\n  # 終止條件 f(1) = 0, f(2) = 1\n  return n - 1 if n == 1 || n == 2\n  # 遞迴呼叫 f(n) = f(n-1) + f(n-2)\n  res = fib(n - 1) + fib(n - 2)\n  # 返回結果 f(n)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，我們在函式內遞迴呼叫了兩個函式，這意味著從一個呼叫產生了兩個呼叫分支。如圖 2-6 所示，這樣不斷遞迴呼叫下去，最終將產生一棵層數為 \\(n\\) 的遞迴樹（recursion tree）。</p> <p></p> <p> 圖 2-6   費波那契數列的遞迴樹 </p> <p>從本質上看，遞迴體現了“將問題分解為更小子問題”的思維範式，這種分治策略至關重要。</p> <ul> <li>從演算法角度看，搜尋、排序、回溯、分治、動態規劃等許多重要演算法策略直接或間接地應用了這種思維方式。</li> <li>從資料結構角度看，遞迴天然適合處理鏈結串列、樹和圖的相關問題，因為它們非常適合用分治思想進行分析。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","level":2,"title":"2.2.3   兩者對比","text":"<p>總結以上內容，如表 2-1 所示，迭代和遞迴在實現、效能和適用性上有所不同。</p> <p> 表 2-1   迭代與遞迴特點對比 </p> 迭代 遞迴 實現方式 迴圈結構 函式呼叫自身 時間效率 效率通常較高，無函式呼叫開銷 每次函式呼叫都會產生開銷 記憶體使用 通常使用固定大小的記憶體空間 累積函式呼叫可能使用大量的堆疊幀空間 適用問題 適用於簡單迴圈任務，程式碼直觀、可讀性好 適用於子問題分解，如樹、圖、分治、回溯等，程式碼結構簡潔、清晰 <p>Tip</p> <p>如果感覺以下內容理解困難，可以在讀完“堆疊”章節後再來複習。</p> <p>那麼，迭代和遞迴具有什麼內在關聯呢？以上述遞迴函式為例，求和操作在遞迴的“迴”階段進行。這意味著最初被呼叫的函式實際上是最後完成其求和操作的，這種工作機制與堆疊的“先入後出”原則異曲同工。</p> <p>事實上，“呼叫堆疊”和“堆疊幀空間”這類遞迴術語已經暗示了遞迴與堆疊之間的密切關係。</p> <ol> <li>遞：當函式被呼叫時，系統會在“呼叫堆疊”上為該函式分配新的堆疊幀，用於儲存函式的區域性變數、參數、返回位址等資料。</li> <li>迴：當函式完成執行並返回時，對應的堆疊幀會被從“呼叫堆疊”上移除，恢復之前函式的執行環境。</li> </ol> <p>因此，我們可以使用一個顯式的堆疊來模擬呼叫堆疊的行為，從而將遞迴轉化為迭代形式：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby recursion.py<pre><code>def for_loop_recur(n: int) -&gt; int:\n    \"\"\"使用迭代模擬遞迴\"\"\"\n    # 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack = []\n    res = 0\n    # 遞：遞迴呼叫\n    for i in range(n, 0, -1):\n        # 透過“入堆疊操作”模擬“遞”\n        stack.append(i)\n    # 迴：返回結果\n    while stack:\n        # 透過“出堆疊操作”模擬“迴”\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n</code></pre> recursion.cpp<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack&lt;int&gt; stack;\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (!stack.empty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.java<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    Stack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (!stack.isEmpty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.cs<pre><code>/* 使用迭代模擬遞迴 */\nint ForLoopRecur(int n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    Stack&lt;int&gt; stack = new();\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.Push(i);\n    }\n    // 迴：返回結果\n    while (stack.Count &gt; 0) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.go<pre><code>/* 使用迭代模擬遞迴 */\nfunc forLoopRecur(n int) int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    stack := list.New()\n    res := 0\n    // 遞：遞迴呼叫\n    for i := n; i &gt; 0; i-- {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.PushBack(i)\n    }\n    // 迴：返回結果\n    for stack.Len() != 0 {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.swift<pre><code>/* 使用迭代模擬遞迴 */\nfunc forLoopRecur(n: Int) -&gt; Int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    var stack: [Int] = []\n    var res = 0\n    // 遞：遞迴呼叫\n    for i in (1 ... n).reversed() {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.append(i)\n    }\n    // 迴：返回結果\n    while !stack.isEmpty {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.js<pre><code>/* 使用迭代模擬遞迴 */\nfunction forLoopRecur(n) {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    const stack = [];\n    let res = 0;\n    // 遞：遞迴呼叫\n    for (let i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (stack.length) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.ts<pre><code>/* 使用迭代模擬遞迴 */\nfunction forLoopRecur(n: number): number {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊 \n    const stack: number[] = [];\n    let res: number = 0;\n    // 遞：遞迴呼叫\n    for (let i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while (stack.length) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.dart<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n  // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n  List&lt;int&gt; stack = [];\n  int res = 0;\n  // 遞：遞迴呼叫\n  for (int i = n; i &gt; 0; i--) {\n    // 透過“入堆疊操作”模擬“遞”\n    stack.add(i);\n  }\n  // 迴：返回結果\n  while (!stack.isEmpty) {\n    // 透過“出堆疊操作”模擬“迴”\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n</code></pre> recursion.rs<pre><code>/* 使用迭代模擬遞迴 */\nfn for_loop_recur(n: i32) -&gt; i32 {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // 遞：遞迴呼叫\n    for i in (1..=n).rev() {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i);\n    }\n    // 迴：返回結果\n    while !stack.is_empty() {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n</code></pre> recursion.c<pre><code>/* 使用迭代模擬遞迴 */\nint forLoopRecur(int n) {\n    int stack[1000]; // 藉助一個大陣列來模擬堆疊\n    int top = -1;    // 堆疊頂索引\n    int res = 0;\n    // 遞：遞迴呼叫\n    for (int i = n; i &gt; 0; i--) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack[1 + top++] = i;\n    }\n    // 迴：返回結果\n    while (top &gt;= 0) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n</code></pre> recursion.kt<pre><code>/* 使用迭代模擬遞迴 */\nfun forLoopRecur(n: Int): Int {\n    // 使用一個顯式的堆疊來模擬系統呼叫堆疊\n    val stack = Stack&lt;Int&gt;()\n    var res = 0\n    // 遞: 遞迴呼叫\n    for (i in n downTo 0) {\n        // 透過“入堆疊操作”模擬“遞”\n        stack.push(i)\n    }\n    // 迴: 返回結果\n    while (stack.isNotEmpty()) {\n        // 透過“出堆疊操作”模擬“迴”\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n</code></pre> recursion.rb<pre><code>### 使用迭代模擬遞迴 ###\ndef for_loop_recur(n)\n  # 使用一個顯式的堆疊來模擬系統呼叫堆疊\n  stack = []\n  res = 0\n\n  # 遞：遞迴呼叫\n  for i in n.downto(0)\n    # 透過“入堆疊操作”模擬“遞”\n    stack &lt;&lt; i\n  end\n  # 迴：返回結果\n  while !stack.empty?\n    res += stack.pop\n  end\n\n  # res = 1+2+3+...+n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，當遞迴轉化為迭代後，程式碼變得更加複雜了。儘管迭代和遞迴在很多情況下可以互相轉化，但不一定值得這樣做，有以下兩點原因。</p> <ul> <li>轉化後的程式碼可能更加難以理解，可讀性更差。</li> <li>對於某些複雜問題，模擬系統呼叫堆疊的行為可能非常困難。</li> </ul> <p>總之，選擇迭代還是遞迴取決於特定問題的性質。在程式設計實踐中，權衡兩者的優劣並根據情境選擇合適的方法至關重要。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.2 &nbsp; 迭代與遞迴"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/","level":1,"title":"2.1   演算法效率評估","text":"<p>在演算法設計中，我們先後追求以下兩個層面的目標。</p> <ol> <li>找到問題解法：演算法需要在規定的輸入範圍內可靠地求得問題的正確解。</li> <li>尋求最優解法：同一個問題可能存在多種解法，我們希望找到儘可能高效的演算法。</li> </ol> <p>也就是說，在能夠解決問題的前提下，演算法效率已成為衡量演算法優劣的主要評價指標，它包括以下兩個維度。</p> <ul> <li>時間效率：演算法執行時間的長短。</li> <li>空間效率：演算法佔用記憶體空間的大小。</li> </ul> <p>簡而言之，我們的目標是設計“既快又省”的資料結構與演算法。而有效地評估演算法效率至關重要，因為只有這樣，我們才能將各種演算法進行對比，進而指導演算法設計與最佳化過程。</p> <p>效率評估方法主要分為兩種：實際測試、理論估算。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#211","level":2,"title":"2.1.1   實際測試","text":"<p>假設我們現在有演算法 <code>A</code> 和演算法 <code>B</code> ，它們都能解決同一問題，現在需要對比這兩個演算法的效率。最直接的方法是找一臺計算機，執行這兩個演算法，並監控記錄它們的執行時間和記憶體佔用情況。這種評估方式能夠反映真實情況，但也存在較大的侷限性。</p> <p>一方面，難以排除測試環境的干擾因素。硬體配置會影響演算法的效能表現。比如一個演算法的並行度較高，那麼它就更適合在多核 CPU 上執行，一個演算法的記憶體操作密集，那麼它在高效能記憶體上的表現就會更好。也就是說，演算法在不同的機器上的測試結果可能是不一致的。這意味著我們需要在各種機器上進行測試，統計平均效率，而這是不現實的。</p> <p>另一方面，展開完整測試非常耗費資源。隨著輸入資料量的變化，演算法會表現出不同的效率。例如，在輸入資料量較小時，演算法 <code>A</code> 的執行時間比演算法 <code>B</code> 短；而在輸入資料量較大時，測試結果可能恰恰相反。因此，為了得到有說服力的結論，我們需要測試各種規模的輸入資料，而這需要耗費大量的計算資源。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/performance_evaluation/#212","level":2,"title":"2.1.2   理論估算","text":"<p>由於實際測試具有較大的侷限性，我們可以考慮僅透過一些計算來評估演算法的效率。這種估算方法被稱為漸近複雜度分析（asymptotic complexity analysis），簡稱複雜度分析。</p> <p>複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料規模之間的關係。它描述了隨著輸入資料規模的增加，演算法執行所需時間和空間的增長趨勢。這個定義有些拗口，我們可以將其分為三個重點來理解。</p> <ul> <li>“時間和空間資源”分別對應時間複雜度（time complexity）和空間複雜度（space complexity）。</li> <li>“隨著輸入資料規模的增加”意味著複雜度反映了演算法執行效率與輸入資料規模之間的關係。</li> <li>“時間和空間的增長趨勢”表示複雜度分析關注的不是執行時間或佔用空間的具體值，而是時間或空間增長的“快慢”。</li> </ul> <p>複雜度分析克服了實際測試方法的弊端，體現在以下幾個方面。</p> <ul> <li>它無需實際執行程式碼，更加綠色節能。</li> <li>它獨立於測試環境，分析結果適用於所有執行平臺。</li> <li>它可以體現不同資料量下的演算法效率，尤其是在大資料量下的演算法效能。</li> </ul> <p>Tip</p> <p>如果你仍對複雜度的概念感到困惑，無須擔心，我們會在後續章節中詳細介紹。</p> <p>複雜度分析為我們提供了一把評估演算法效率的“標尺”，使我們可以衡量執行某個演算法所需的時間和空間資源，對比不同演算法之間的效率。</p> <p>複雜度是個數學概念，對於初學者可能比較抽象，學習難度相對較高。從這個角度看，複雜度分析可能不太適合作為最先介紹的內容。然而，當我們討論某個資料結構或演算法的特點時，難以避免要分析其執行速度和空間使用情況。</p> <p>綜上所述，建議你在深入學習資料結構與演算法之前，先對複雜度分析建立初步的瞭解，以便能夠完成簡單演算法的複雜度分析。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.1 &nbsp; 演算法效率評估"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/","level":1,"title":"2.4   空間複雜度","text":"<p>空間複雜度（space complexity）用於衡量演算法佔用記憶體空間隨著資料量變大時的增長趨勢。這個概念與時間複雜度非常類似，只需將“執行時間”替換為“佔用記憶體空間”。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#241","level":2,"title":"2.4.1   演算法相關空間","text":"<p>演算法在執行過程中使用的記憶體空間主要包括以下幾種。</p> <ul> <li>輸入空間：用於儲存演算法的輸入資料。</li> <li>暫存空間：用於儲存演算法在執行過程中的變數、物件、函式上下文等資料。</li> <li>輸出空間：用於儲存演算法的輸出資料。</li> </ul> <p>一般情況下，空間複雜度的統計範圍是“暫存空間”加上“輸出空間”。</p> <p>暫存空間可以進一步劃分為三個部分。</p> <ul> <li>暫存資料：用於儲存演算法執行過程中的各種常數、變數、物件等。</li> <li>堆疊幀空間：用於儲存呼叫函式的上下文資料。系統在每次呼叫函式時都會在堆疊頂部建立一個堆疊幀，函式返回後，堆疊幀空間會被釋放。</li> <li>指令空間：用於儲存編譯後的程式指令，在實際統計中通常忽略不計。</li> </ul> <p>在分析一段程式的空間複雜度時，我們通常統計暫存資料、堆疊幀空間和輸出資料三部分，如圖 2-15 所示。</p> <p></p> <p> 圖 2-15   演算法使用的相關空間 </p> <p>相關程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class Node:\n    \"\"\"類別\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # 節點值\n        self.next: Node | None = None  # 指向下一節點的引用\n\ndef function() -&gt; int:\n    \"\"\"函式\"\"\"\n    # 執行某些操作...\n    return 0\n\ndef algorithm(n) -&gt; int:  # 輸入資料\n    A = 0                 # 暫存資料（常數，一般用大寫字母表示）\n    b = 0                 # 暫存資料（變數）\n    node = Node(0)        # 暫存資料（物件）\n    c = function()        # 堆疊幀空間（呼叫函式）\n    return A + b + c      # 輸出資料\n</code></pre> <pre><code>/* 結構體 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* 函式 */\nint func() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) {        // 輸入資料\n    const int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node* node = new Node(0); // 暫存資料（物件）\n    int c = func();           // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* 函式 */\nint function() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) {        // 輸入資料\n    final int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node node = new Node(0);  // 暫存資料（物件）\n    int c = function();       // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* 函式 */\nint Function() {\n    // 執行某些操作...\n    return 0;\n}\n\nint Algorithm(int n) {        // 輸入資料\n    const int a = 0;          // 暫存資料（常數）\n    int b = 0;                // 暫存資料（變數）\n    Node node = new(0);       // 暫存資料（物件）\n    int c = Function();       // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 結構體 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* 建立 node 結構體  */\nfunc newNode(val int) *node {\n    return &amp;node{val: val}\n}\n\n/* 函式 */\nfunc function() int {\n    // 執行某些操作...\n    return 0\n}\n\nfunc algorithm(n int) int { // 輸入資料\n    const a = 0             // 暫存資料（常數）\n    b := 0                  // 暫存資料（變數）\n    newNode(0)              // 暫存資料（物件）\n    c := function()         // 堆疊幀空間（呼叫函式）\n    return a + b + c        // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* 函式 */\nfunc function() -&gt; Int {\n    // 執行某些操作...\n    return 0\n}\n\nfunc algorithm(n: Int) -&gt; Int { // 輸入資料\n    let a = 0             // 暫存資料（常數）\n    var b = 0             // 暫存資料（變數）\n    let node = Node(x: 0) // 暫存資料（物件）\n    let c = function()    // 堆疊幀空間（呼叫函式）\n    return a + b + c      // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.next = null;                       // 指向下一節點的引用\n    }\n}\n\n/* 函式 */\nfunction constFunc() {\n    // 執行某些操作\n    return 0;\n}\n\nfunction algorithm(n) {       // 輸入資料\n    const a = 0;              // 暫存資料（常數）\n    let b = 0;                // 暫存資料（變數）\n    const node = new Node(0); // 暫存資料（物件）\n    const c = constFunc();    // 堆疊幀空間（呼叫函式）\n    return a + b + c;         // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.next = null;                       // 指向下一節點的引用\n    }\n}\n\n/* 函式 */\nfunction constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n\nfunction algorithm(n: number): number { // 輸入資料\n    const a = 0;                        // 暫存資料（常數）\n    let b = 0;                          // 暫存資料（變數）\n    const node = new Node(0);           // 暫存資料（物件）\n    const c = constFunc();              // 堆疊幀空間（呼叫函式）\n    return a + b + c;                   // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* 函式 */\nint function() {\n  // 執行某些操作...\n  return 0;\n}\n\nint algorithm(int n) {  // 輸入資料\n  const int a = 0;      // 暫存資料（常數）\n  int b = 0;            // 暫存資料（變數）\n  Node node = Node(0);  // 暫存資料（物件）\n  int c = function();   // 堆疊幀空間（呼叫函式）\n  return a + b + c;     // 輸出資料\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 結構體 */\nstruct Node {\n    val: i32,\n    next: Option&lt;Rc&lt;RefCell&lt;Node&gt;&gt;&gt;,\n}\n\n/* 建立 Node 結構體 */\nimpl Node {\n    fn new(val: i32) -&gt; Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* 函式 */\nfn function() -&gt; i32 {      \n    // 執行某些操作...\n    return 0;\n}\n\nfn algorithm(n: i32) -&gt; i32 {       // 輸入資料\n    const a: i32 = 0;               // 暫存資料（常數）\n    let mut b = 0;                  // 暫存資料（變數）\n    let node = Node::new(0);        // 暫存資料（物件）\n    let c = function();             // 堆疊幀空間（呼叫函式）\n    return a + b + c;               // 輸出資料\n}\n</code></pre> <pre><code>/* 函式 */\nint func() {\n    // 執行某些操作...\n    return 0;\n}\n\nint algorithm(int n) { // 輸入資料\n    const int a = 0;   // 暫存資料（常數）\n    int b = 0;         // 暫存資料（變數）\n    int c = func();    // 堆疊幀空間（呼叫函式）\n    return a + b + c;  // 輸出資料\n}\n</code></pre> <pre><code>/* 類別 */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* 函式 */\nfun function(): Int {\n    // 執行某些操作...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // 輸入資料\n    val a = 0                // 暫存資料（常數）\n    var b = 0                // 暫存資料（變數）\n    val node = Node(0)       // 暫存資料（物件）\n    val c = function()       // 堆疊幀空間（呼叫函式）\n    return a + b + c         // 輸出資料\n}\n</code></pre> <pre><code>### 類別 ###\nclass Node\n    attr_accessor :val      # 節點值\n    attr_accessor :next     # 指向下一節點的引用\n\n    def initialize(x)\n        @val = x\n    end\nend\n\n### 函式 ###\ndef function\n    # 執行某些操作...\n    0\nend\n\n### 演算法 ###\ndef algorithm(n)        # 輸入資料\n    a = 0               # 暫存資料（常數）\n    b = 0               # 暫存資料（變數）\n    node = Node.new(0)  # 暫存資料（物件）\n    c = function        # 堆疊幀空間（呼叫函式）\n    a + b + c           # 輸出資料\nend\n</code></pre>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#242","level":2,"title":"2.4.2   推算方法","text":"<p>空間複雜度的推算方法與時間複雜度大致相同，只需將統計物件從“操作數量”轉為“使用空間大小”。</p> <p>而與時間複雜度不同的是，我們通常只關注最差空間複雜度。這是因為記憶體空間是一項硬性要求，我們必須確保在所有輸入資料下都有足夠的記憶體空間預留。</p> <p>觀察以下程式碼，最差空間複雜度中的“最差”有兩層含義。</p> <ol> <li>以最差輸入資料為準：當 \\(n &lt; 10\\) 時，空間複雜度為 \\(O(1)\\) ；但當 \\(n &gt; 10\\) 時，初始化的陣列 <code>nums</code> 佔用 \\(O(n)\\) 空間，因此最差空間複雜度為 \\(O(n)\\) 。</li> <li>以演算法執行中的峰值記憶體為準：例如，程式在執行最後一行之前，佔用 \\(O(1)\\) 空間；當初始化陣列 <code>nums</code> 時，程式佔用 \\(O(n)\\) 空間，因此最差空間複雜度為 \\(O(n)\\) 。</li> </ol> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n &gt; 10:\n        nums = [0] * n  # O(n)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector&lt;int&gt; b(10000);    // O(1)\n    if (n &gt; 10)\n        vector&lt;int&gt; nums(n); // O(n)\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10)\n        int[] nums = new int[n]; // O(n)\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n &gt; 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n &gt; 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n &gt; 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n &gt; 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List&lt;int&gt; b = List.filled(10000, 0);  // O(1)\n  if (n &gt; 10) {\n    List&lt;int&gt; nums = List.filled(n, 0); // O(n)\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n &gt; 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n &gt; 10)\n        int nums[n] = {0};   // O(n)\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n &gt; 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 0                           # O(1)\n    b = Array.new(10000)            # O(1)\n    nums = Array.new(n) if n &gt; 10   # O(n)\nend\n</code></pre> <p>在遞迴函式中，需要注意統計堆疊幀空間。觀察以下程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def function() -&gt; int:\n    # 執行某些操作\n    return 0\n\ndef loop(n: int):\n    \"\"\"迴圈的空間複雜度為 O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"遞迴的空間複雜度為 O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n</code></pre> <pre><code>int func() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>int Function() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n</code></pre> <pre><code>func function() int {\n    // 執行某些操作\n    return 0\n}\n\n/* 迴圈的空間複雜度為 O(1) */\nfunc loop(n int) {\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n}\n\n/* 遞迴的空間複雜度為 O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n</code></pre> <pre><code>@discardableResult\nfunc function() -&gt; Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 迴圈的空間複雜度為 O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n\n/* 遞迴的空間複雜度為 O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n</code></pre> <pre><code>function constFunc() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfunction loop(n) {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>function constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n</code></pre> <pre><code>int function() {\n  // 執行某些操作\n  return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  recur(n - 1);\n}\n</code></pre> <pre><code>fn function() -&gt; i32 {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n</code></pre> <pre><code>int func() {\n    // 執行某些操作\n    return 0;\n}\n/* 迴圈的空間複雜度為 O(1) */\nvoid loop(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    recur(n - 1);\n}\n</code></pre> <pre><code>fun function(): Int {\n    // 執行某些操作\n    return 0\n}\n/* 迴圈的空間複雜度為 O(1) */\nfun loop(n: Int) {\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n/* 遞迴的空間複雜度為 O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n</code></pre> <pre><code>def function\n    # 執行某些操作\n    0\nend\n\n### 迴圈的空間複雜度為 O(1) ###\ndef loop(n)\n    (0...n).each { function }\nend\n\n### 遞迴的空間複雜度為 O(n) ###\ndef recur(n)\n    return if n == 1\n    recur(n - 1)\nend\n</code></pre> <p>函式 <code>loop()</code> 和 <code>recur()</code> 的時間複雜度都為 \\(O(n)\\) ，但空間複雜度不同。</p> <ul> <li>函式 <code>loop()</code> 在迴圈中呼叫了 \\(n\\) 次 <code>function()</code> ，每輪中的 <code>function()</code> 都返回並釋放了堆疊幀空間，因此空間複雜度仍為 \\(O(1)\\) 。</li> <li>遞迴函式 <code>recur()</code> 在執行過程中會同時存在 \\(n\\) 個未返回的 <code>recur()</code> ，從而佔用 \\(O(n)\\) 的堆疊幀空間。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#243","level":2,"title":"2.4.3   常見型別","text":"<p>設輸入資料大小為 \\(n\\) ，圖 2-16 展示了常見的空間複雜度型別（從低到高排列）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \\newline \\text{常數階} &lt; \\text{對數階} &lt; \\text{線性階} &lt; \\text{平方階} &lt; \\text{指數階} \\end{aligned} \\] <p></p> <p> 圖 2-16   常見的空間複雜度型別 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#1-o1","level":3,"title":"1.   常數階 \\(O(1)\\)","text":"<p>常數階常見於數量與輸入資料大小 \\(n\\) 無關的常數、變數、物件。</p> <p>需要注意的是，在迴圈中初始化變數或呼叫函式而佔用的記憶體，在進入下一迴圈後就會被釋放，因此不會累積佔用空間，空間複雜度仍為 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def function() -&gt; int:\n    \"\"\"函式\"\"\"\n    # 執行某些操作\n    return 0\n\ndef constant(n: int):\n    \"\"\"常數階\"\"\"\n    # 常數、變數、物件佔用 O(1) 空間\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # 迴圈中的變數佔用 O(1) 空間\n    for _ in range(n):\n        c = 0\n    # 迴圈中的函式佔用 O(1) 空間\n    for _ in range(n):\n        function()\n</code></pre> space_complexity.cpp<pre><code>/* 函式 */\nint func() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const int a = 0;\n    int b = 0;\n    vector&lt;int&gt; nums(10000);\n    ListNode node(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 函式 */\nint function() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        function();\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 函式 */\nint Function() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid Constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        Function();\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 函式 */\nfunc function() int {\n    // 執行某些操作...\n    return 0\n}\n\n/* 常數階 */\nfunc spaceConstant(n int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // 迴圈中的變數佔用 O(1) 空間\n    var c int\n    for i := 0; i &lt; n; i++ {\n        c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for i := 0; i &lt; n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n</code></pre> space_complexity.swift<pre><code>/* 函式 */\n@discardableResult\nfunc function() -&gt; Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 常數階 */\nfunc constant(n: Int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // 迴圈中的變數佔用 O(1) 空間\n    for _ in 0 ..&lt; n {\n        let c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for _ in 0 ..&lt; n {\n        function()\n    }\n}\n</code></pre> space_complexity.js<pre><code>/* 函式 */\nfunction constFunc() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nfunction constant(n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 函式 */\nfunction constFunc(): number {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nfunction constant(n: number): void {\n    // 常數、變數、物件佔用 O(1) 空間\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        const c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (let i = 0; i &lt; n; i++) {\n        constFunc();\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 函式 */\nint function() {\n  // 執行某些操作\n  return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n  // 常數、變數、物件佔用 O(1) 空間\n  final int a = 0;\n  int b = 0;\n  List&lt;int&gt; nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // 迴圈中的變數佔用 O(1) 空間\n  for (var i = 0; i &lt; n; i++) {\n    int c = 0;\n  }\n  // 迴圈中的函式佔用 O(1) 空間\n  for (var i = 0; i &lt; n; i++) {\n    function();\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 函式 */\nfn function() -&gt; i32 {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // 迴圈中的變數佔用 O(1) 空間\n    for i in 0..n {\n        let c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for i in 0..n {\n        function();\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 函式 */\nint func() {\n    // 執行某些操作\n    return 0;\n}\n\n/* 常數階 */\nvoid constant(int n) {\n    // 常數、變數、物件佔用 O(1) 空間\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // 迴圈中的變數佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        int c = 0;\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (int i = 0; i &lt; n; i++) {\n        func();\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 函式 */\nfun function(): Int {\n    // 執行某些操作\n    return 0\n}\n\n/* 常數階 */\nfun constant(n: Int) {\n    // 常數、變數、物件佔用 O(1) 空間\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // 迴圈中的變數佔用 O(1) 空間\n    for (i in 0..&lt;n) {\n        val c = 0\n    }\n    // 迴圈中的函式佔用 O(1) 空間\n    for (i in 0..&lt;n) {\n        function()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 函式 ###\ndef function\n  # 執行某些操作\n  0\nend\n\n### 常數階 ###\ndef constant(n)\n  # 常數、變數、物件佔用 O(1) 空間\n  a = 0\n  nums = [0] * 10000\n  node = ListNode.new\n\n  # 迴圈中的變數佔用 O(1) 空間\n  (0...n).each { c = 0 }\n  # 迴圈中的函式佔用 O(1) 空間\n  (0...n).each { function }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#2-on","level":3,"title":"2.   線性階 \\(O(n)\\)","text":"<p>線性階常見於元素數量與 \\(n\\) 成正比的陣列、鏈結串列、堆疊、佇列等：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear(n: int):\n    \"\"\"線性階\"\"\"\n    # 長度為 n 的串列佔用 O(n) 空間\n    nums = [0] * n\n    # 長度為 n 的雜湊表佔用 O(n) 空間\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\n</code></pre> space_complexity.cpp<pre><code>/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    vector&lt;int&gt; nums(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    vector&lt;ListNode&gt; nodes;\n    for (int i = 0; i &lt; n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    unordered_map&lt;int, string&gt; map;\n    for (int i = 0; i &lt; n; i++) {\n        map[i] = to_string(i);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int[] nums = new int[n];\n    // 長度為 n 的串列佔用 O(n) 空間\n    List&lt;ListNode&gt; nodes = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    Map&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        map.put(i, String.valueOf(i));\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 線性階 */\nvoid Linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int[] nums = new int[n];\n    // 長度為 n 的串列佔用 O(n) 空間\n    List&lt;ListNode&gt; nodes = [];\n    for (int i = 0; i &lt; n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    Dictionary&lt;int, string&gt; map = [];\n    for (int i = 0; i &lt; n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 線性階 */\nfunc spaceLinear(n int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    _ = make([]int, n)\n    // 長度為 n 的串列佔用 O(n) 空間\n    var nodes []*node\n    for i := 0; i &lt; n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    m := make(map[int]string, n)\n    for i := 0; i &lt; n; i++ {\n        m[i] = strconv.Itoa(i)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 線性階 */\nfunc linear(n: Int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    let nums = Array(repeating: 0, count: n)\n    // 長度為 n 的串列佔用 O(n) 空間\n    let nodes = (0 ..&lt; n).map { ListNode(x: $0) }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    let map = Dictionary(uniqueKeysWithValues: (0 ..&lt; n).map { ($0, \"\\($0)\") })\n}\n</code></pre> space_complexity.js<pre><code>/* 線性階 */\nfunction linear(n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    const nums = new Array(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    const nodes = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 線性階 */\nfunction linear(n: number): void {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    const nums = new Array(n);\n    // 長度為 n 的串列佔用 O(n) 空間\n    const nodes: ListNode[] = [];\n    for (let i = 0; i &lt; n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    const map = new Map();\n    for (let i = 0; i &lt; n; i++) {\n        map.set(i, i.toString());\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 線性階 */\nvoid linear(int n) {\n  // 長度為 n 的陣列佔用 O(n) 空間\n  List&lt;int&gt; nums = List.filled(n, 0);\n  // 長度為 n 的串列佔用 O(n) 空間\n  List&lt;ListNode&gt; nodes = [];\n  for (var i = 0; i &lt; n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // 長度為 n 的雜湊表佔用 O(n) 空間\n  Map&lt;int, String&gt; map = HashMap();\n  for (var i = 0; i &lt; n; i++) {\n    map.putIfAbsent(i, () =&gt; i.toString());\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 線性階 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    let mut nums = vec![0; n as usize];\n    // 長度為 n 的串列佔用 O(n) 空間\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 雜湊表 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // 基於 uthash.h 實現\n} HashTable;\n\n/* 線性階 */\nvoid linear(int n) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // 長度為 n 的串列佔用 O(n) 空間\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // 記憶體釋放\n    for (int i = 0; i &lt; n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    HashTable *h = NULL;\n    for (int i = 0; i &lt; n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = i;\n        tmp-&gt;val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // 記憶體釋放\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n</code></pre> space_complexity.kt<pre><code>/* 線性階 */\nfun linear(n: Int) {\n    // 長度為 n 的陣列佔用 O(n) 空間\n    val nums = Array(n) { 0 }\n    // 長度為 n 的串列佔用 O(n) 空間\n    val nodes = mutableListOf&lt;ListNode&gt;()\n    for (i in 0..&lt;n) {\n        nodes.add(ListNode(i))\n    }\n    // 長度為 n 的雜湊表佔用 O(n) 空間\n    val map = mutableMapOf&lt;Int, String&gt;()\n    for (i in 0..&lt;n) {\n        map[i] = i.toString()\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 線性階 ###\ndef linear(n)\n  # 長度為 n 的串列佔用 O(n) 空間\n  nums = Array.new(n, 0)\n\n  # 長度為 n 的雜湊表佔用 O(n) 空間\n  hmap = {}\n  for i in 0...n\n    hmap[i] = i.to_s\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 2-17 所示，此函式的遞迴深度為 \\(n\\) ，即同時存在 \\(n\\) 個未返回的 <code>linear_recur()</code> 函式，使用 \\(O(n)\\) 大小的堆疊幀空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def linear_recur(n: int):\n    \"\"\"線性階（遞迴實現）\"\"\"\n    print(\"遞迴 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    cout &lt;&lt; \"遞迴 n = \" &lt;&lt; n &lt;&lt; endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    System.out.println(\"遞迴 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 線性階（遞迴實現） */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"遞迴 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 線性階（遞迴實現） */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"遞迴 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 線性階（遞迴實現） */\nfunc linearRecur(n: Int) {\n    print(\"遞迴 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 線性階（遞迴實現） */\nfunction linearRecur(n) {\n    console.log(`遞迴 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 線性階（遞迴實現） */\nfunction linearRecur(n: number): void {\n    console.log(`遞迴 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n  print('遞迴 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 線性階（遞迴實現） */\nfn linear_recur(n: i32) {\n    println!(\"遞迴 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 線性階（遞迴實現） */\nvoid linearRecur(int n) {\n    printf(\"遞迴 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n</code></pre> space_complexity.kt<pre><code>/* 線性階（遞迴實現） */\nfun linearRecur(n: Int) {\n    println(\"遞迴 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 線性階（遞迴實現）###\ndef linear_recur(n)\n  puts \"遞迴 n = #{n}\"\n  return if n == 1\n  linear_recur(n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-17   遞迴函式產生的線性階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階常見於矩陣和圖，元素數量與 \\(n\\) 成平方關係：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic(n: int):\n    \"\"\"平方階\"\"\"\n    # 二維串列佔用 O(n^2) 空間\n    num_matrix = [[0] * n for _ in range(n)]\n</code></pre> space_complexity.cpp<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 二維串列佔用 O(n^2) 空間\n    vector&lt;vector&lt;int&gt;&gt; numMatrix;\n    for (int i = 0; i &lt; n; i++) {\n        vector&lt;int&gt; tmp;\n        for (int j = 0; j &lt; n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n</code></pre> space_complexity.java<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 矩陣佔用 O(n^2) 空間\n    int[][] numMatrix = new int[n][n];\n    // 二維串列佔用 O(n^2) 空間\n    List&lt;List&lt;Integer&gt;&gt; numList = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n        for (int j = 0; j &lt; n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n</code></pre> space_complexity.cs<pre><code>/* 平方階 */\nvoid Quadratic(int n) {\n    // 矩陣佔用 O(n^2) 空間\n    int[,] numMatrix = new int[n, n];\n    // 二維串列佔用 O(n^2) 空間\n    List&lt;List&lt;int&gt;&gt; numList = [];\n    for (int i = 0; i &lt; n; i++) {\n        List&lt;int&gt; tmp = [];\n        for (int j = 0; j &lt; n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n</code></pre> space_complexity.go<pre><code>/* 平方階 */\nfunc spaceQuadratic(n int) {\n    // 矩陣佔用 O(n^2) 空間\n    numMatrix := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        numMatrix[i] = make([]int, n)\n    }\n}\n</code></pre> space_complexity.swift<pre><code>/* 平方階 */\nfunc quadratic(n: Int) {\n    // 二維串列佔用 O(n^2) 空間\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n</code></pre> space_complexity.js<pre><code>/* 平方階 */\nfunction quadratic(n) {\n    // 矩陣佔用 O(n^2) 空間\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二維串列佔用 O(n^2) 空間\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.ts<pre><code>/* 平方階 */\nfunction quadratic(n: number): void {\n    // 矩陣佔用 O(n^2) 空間\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() =&gt; Array(n).fill(null));\n    // 二維串列佔用 O(n^2) 空間\n    const numList = [];\n    for (let i = 0; i &lt; n; i++) {\n        const tmp = [];\n        for (let j = 0; j &lt; n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n</code></pre> space_complexity.dart<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n  // 矩陣佔用 O(n^2) 空間\n  List&lt;List&lt;int&gt;&gt; numMatrix = List.generate(n, (_) =&gt; List.filled(n, 0));\n  // 二維串列佔用 O(n^2) 空間\n  List&lt;List&lt;int&gt;&gt; numList = [];\n  for (var i = 0; i &lt; n; i++) {\n    List&lt;int&gt; tmp = [];\n    for (int j = 0; j &lt; n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n</code></pre> space_complexity.rs<pre><code>/* 平方階 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // 矩陣佔用 O(n^2) 空間\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // 二維串列佔用 O(n^2) 空間\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.push(tmp);\n    }\n}\n</code></pre> space_complexity.c<pre><code>/* 平方階 */\nvoid quadratic(int n) {\n    // 二維串列佔用 O(n^2) 空間\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i &lt; n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j &lt; n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // 記憶體釋放\n    for (int i = 0; i &lt; n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n</code></pre> space_complexity.kt<pre><code>/* 平方階 */\nfun quadratic(n: Int) {\n    // 矩陣佔用 O(n^2) 空間\n    val numMatrix = arrayOfNulls&lt;Array&lt;Int&gt;?&gt;(n)\n    // 二維串列佔用 O(n^2) 空間\n    val numList = mutableListOf&lt;MutableList&lt;Int&gt;&gt;()\n    for (i in 0..&lt;n) {\n        val tmp = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  # 二維串列佔用 O(n^2) 空間\n  Array.new(n) { Array.new(n, 0) }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 2-18 所示，該函式的遞迴深度為 \\(n\\) ，在每個遞迴函式中都初始化了一個陣列，長度分別為 \\(n\\)、\\(n-1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，平均長度為 \\(n / 2\\) ，因此總體佔用 \\(O(n^2)\\) 空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def quadratic_recur(n: int) -&gt; int:\n    \"\"\"平方階（遞迴實現）\"\"\"\n    if n &lt;= 0:\n        return 0\n    # 陣列 nums 長度為 n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n</code></pre> space_complexity.cpp<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    vector&lt;int&gt; nums(n);\n    cout &lt;&lt; \"遞迴 n = \" &lt;&lt; n &lt;&lt; \" 中的 nums 長度 = \" &lt;&lt; nums.size() &lt;&lt; endl;\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.java<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"遞迴 n = \" + n + \" 中的 nums 長度 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.cs<pre><code>/* 平方階（遞迴實現） */\nint QuadraticRecur(int n) {\n    if (n &lt;= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"遞迴 n = \" + n + \" 中的 nums 長度 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n</code></pre> space_complexity.go<pre><code>/* 平方階（遞迴實現） */\nfunc spaceQuadraticRecur(n int) int {\n    if n &lt;= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"遞迴 n = %d 中的 nums 長度 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n</code></pre> space_complexity.swift<pre><code>/* 平方階（遞迴實現） */\n@discardableResult\nfunc quadraticRecur(n: Int) -&gt; Int {\n    if n &lt;= 0 {\n        return 0\n    }\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"遞迴 n = \\(n) 中的 nums 長度 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n</code></pre> space_complexity.js<pre><code>/* 平方階（遞迴實現） */\nfunction quadraticRecur(n) {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`遞迴 n = ${n} 中的 nums 長度 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.ts<pre><code>/* 平方階（遞迴實現） */\nfunction quadraticRecur(n: number): number {\n    if (n &lt;= 0) return 0;\n    const nums = new Array(n);\n    console.log(`遞迴 n = ${n} 中的 nums 長度 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.dart<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n  if (n &lt;= 0) return 0;\n  List&lt;int&gt; nums = List.filled(n, 0);\n  print('遞迴 n = $n 中的 nums 長度 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n</code></pre> space_complexity.rs<pre><code>/* 平方階（遞迴實現） */\nfn quadratic_recur(n: i32) -&gt; i32 {\n    if n &lt;= 0 {\n        return 0;\n    };\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"遞迴 n = {} 中的 nums 長度 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n</code></pre> space_complexity.c<pre><code>/* 平方階（遞迴實現） */\nint quadraticRecur(int n) {\n    if (n &lt;= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"遞迴 n = %d 中的 nums 長度 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n</code></pre> space_complexity.kt<pre><code>/* 平方階（遞迴實現） */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n &lt;= 0)\n        return 0\n    // 陣列 nums 長度為 n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"遞迴 n = $n 中的 nums 長度 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n</code></pre> space_complexity.rb<pre><code>### 平方階（遞迴實現）###\ndef quadratic_recur(n)\n  return 0 unless n &gt; 0\n\n  # 陣列 nums 長度為 n, n-1, ..., 2, 1\n  nums = Array.new(n, 0)\n  quadratic_recur(n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-18   遞迴函式產生的平方階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#4-o2n","level":3,"title":"4.   指數階 \\(O(2^n)\\)","text":"<p>指數階常見於二元樹。觀察圖 2-19 ，層數為 \\(n\\) 的“滿二元樹”的節點數量為 \\(2^n - 1\\) ，佔用 \\(O(2^n)\\) 空間：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby space_complexity.py<pre><code>def build_tree(n: int) -&gt; TreeNode | None:\n    \"\"\"指數階（建立滿二元樹）\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n</code></pre> space_complexity.cpp<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.java<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.cs<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n</code></pre> space_complexity.go<pre><code>/* 指數階（建立滿二元樹） */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.swift<pre><code>/* 指數階（建立滿二元樹） */\nfunc buildTree(n: Int) -&gt; TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n</code></pre> space_complexity.js<pre><code>/* 指數階（建立滿二元樹） */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.ts<pre><code>/* 指數階（建立滿二元樹） */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.dart<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n</code></pre> space_complexity.rs<pre><code>/* 指數階（建立滿二元樹） */\nfn build_tree(n: i32) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n</code></pre> space_complexity.c<pre><code>/* 指數階（建立滿二元樹） */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root-&gt;left = buildTree(n - 1);\n    root-&gt;right = buildTree(n - 1);\n    return root;\n}\n</code></pre> space_complexity.kt<pre><code>/* 指數階（建立滿二元樹） */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n</code></pre> space_complexity.rb<pre><code>### 指數階（建立滿二元樹）###\ndef build_tree(n)\n  return if n == 0\n\n  TreeNode.new.tap do |root|\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-19   滿二元樹產生的指數階空間複雜度 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#5-olog-n","level":3,"title":"5.   對數階 \\(O(\\log n)\\)","text":"<p>對數階常見於分治演算法。例如合併排序，輸入長度為 \\(n\\) 的陣列，每輪遞迴將陣列從中點處劃分為兩半，形成高度為 \\(\\log n\\) 的遞迴樹，使用 \\(O(\\log n)\\) 堆疊幀空間。</p> <p>再例如將數字轉化為字串，輸入一個正整數 \\(n\\) ，它的位數為 \\(\\lfloor \\log_{10} n \\rfloor + 1\\) ，即對應字串長度為 \\(\\lfloor \\log_{10} n \\rfloor + 1\\) ，因此空間複雜度為 \\(O(\\log_{10} n + 1) = O(\\log n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/space_complexity/#244","level":2,"title":"2.4.4   權衡時間與空間","text":"<p>理想情況下，我們希望演算法的時間複雜度和空間複雜度都能達到最優。然而在實際情況中，同時最佳化時間複雜度和空間複雜度通常非常困難。</p> <p>降低時間複雜度通常需要以提升空間複雜度為代價，反之亦然。我們將犧牲記憶體空間來提升演算法執行速度的思路稱為“以空間換時間”；反之，則稱為“以時間換空間”。</p> <p>選擇哪種思路取決於我們更看重哪個方面。在大多數情況下，時間比空間更寶貴，因此“以空間換時間”通常是更常用的策略。當然，在資料量很大的情況下，控制空間複雜度也非常重要。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.4 &nbsp; 空間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/summary/","level":1,"title":"2.5   小結","text":"","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/summary/#1","level":3,"title":"1.   重點回顧","text":"<p>演算法效率評估</p> <ul> <li>時間效率和空間效率是衡量演算法優劣的兩個主要評價指標。</li> <li>我們可以透過實際測試來評估演算法效率，但難以消除測試環境的影響，且會耗費大量計算資源。</li> <li>複雜度分析可以消除實際測試的弊端，分析結果適用於所有執行平臺，並且能夠揭示演算法在不同資料規模下的效率。</li> </ul> <p>時間複雜度</p> <ul> <li>時間複雜度用於衡量演算法執行時間隨資料量增長的趨勢，可以有效評估演算法效率，但在某些情況下可能失效，如在輸入的資料量較小或時間複雜度相同時，無法精確對比演算法效率的優劣。</li> <li>最差時間複雜度使用大 \\(O\\) 符號表示，對應函式漸近上界，反映當 \\(n\\) 趨向正無窮時，操作數量 \\(T(n)\\) 的增長級別。</li> <li>推算時間複雜度分為兩步，首先統計操作數量，然後判斷漸近上界。</li> <li>常見時間複雜度從低到高排列有 \\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n \\log n)\\)、\\(O(n^2)\\)、\\(O(2^n)\\) 和 \\(O(n!)\\) 等。</li> <li>某些演算法的時間複雜度非固定，而是與輸入資料的分佈有關。時間複雜度分為最差、最佳、平均時間複雜度，最佳時間複雜度幾乎不用，因為輸入資料一般需要滿足嚴格條件才能達到最佳情況。</li> <li>平均時間複雜度反映演算法在隨機資料輸入下的執行效率，最接近實際應用中的演算法效能。計算平均時間複雜度需要統計輸入資料分佈以及綜合後的數學期望。</li> </ul> <p>空間複雜度</p> <ul> <li>空間複雜度的作用類似於時間複雜度，用於衡量演算法佔用記憶體空間隨資料量增長的趨勢。</li> <li>演算法執行過程中的相關記憶體空間可分為輸入空間、暫存空間、輸出空間。通常情況下，輸入空間不納入空間複雜度計算。暫存空間可分為暫存資料、堆疊幀空間和指令空間，其中堆疊幀空間通常僅在遞迴函式中影響空間複雜度。</li> <li>我們通常只關注最差空間複雜度，即統計演算法在最差輸入資料和最差執行時刻下的空間複雜度。</li> <li>常見空間複雜度從低到高排列有 \\(O(1)\\)、\\(O(\\log n)\\)、\\(O(n)\\)、\\(O(n^2)\\) 和 \\(O(2^n)\\) 等。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：尾遞迴的空間複雜度是 \\(O(1)\\) 嗎？</p> <p>理論上，尾遞迴函式的空間複雜度可以最佳化至 \\(O(1)\\) 。不過絕大多數程式語言（例如 Java、Python、C++、Go、C# 等）不支持自動最佳化尾遞迴，因此通常認為空間複雜度是 \\(O(n)\\) 。</p> <p>Q：函式和方法這兩個術語的區別是什麼？</p> <p>函式（function）可以被獨立執行，所有參數都以顯式傳遞。方法（method）與一個物件關聯，被隱式傳遞給呼叫它的物件，能夠對類別的例項中包含的資料進行操作。</p> <p>下面以幾種常見的程式語言為例來說明。</p> <ul> <li>C 語言是程序式程式設計語言，沒有物件導向的概念，所以只有函式。但我們可以透過建立結構體（struct）來模擬物件導向程式設計，與結構體相關聯的函式就相當於其他程式語言中的方法。</li> <li>Java 和 C# 是物件導向的程式語言，程式碼塊（方法）通常作為某個類別的一部分。靜態方法的行為類似於函式，因為它被繫結在類別上，不能訪問特定的例項變數。</li> <li>C++ 和 Python 既支持程序式程式設計（函式），也支持物件導向程式設計（方法）。</li> </ul> <p>Q：圖解“常見的空間複雜度型別”反映的是否是佔用空間的絕對大小？</p> <p>不是，該圖展示的是空間複雜度，其反映的是增長趨勢，而不是佔用空間的絕對大小。</p> <p>假設取 \\(n = 8\\) ，你可能會發現每條曲線的值與函式對應不上。這是因為每條曲線都包含一個常數項，用於將取值範圍壓縮到一個視覺舒適的範圍內。</p> <p>在實際中，因為我們通常不知道每個方法的“常數項”複雜度是多少，所以一般無法僅憑複雜度來選擇 \\(n = 8\\) 之下的最優解法。但對於 \\(n = 8^5\\) 就很好選了，這時增長趨勢已經佔主導了。</p> <p>Q 是否存在根據實際使用場景，選擇犧牲時間（或空間）來設計演算法的情況？</p> <p>在實際應用中，大部分情況會選擇犧牲空間換時間。例如資料庫索引，我們通常選擇建立 B+ 樹或雜湊索引，佔用大量記憶體空間，以換取 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 的高效查詢。</p> <p>在空間資源寶貴的場景，也會選擇犧牲時間換空間。例如在嵌入式開發中，裝置記憶體很寶貴，工程師可能會放棄使用雜湊表，選擇使用陣列順序查詢，以節省記憶體佔用，代價是查詢變慢。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/","level":1,"title":"2.3   時間複雜度","text":"<p>執行時間可以直觀且準確地反映演算法的效率。如果我們想準確預估一段程式碼的執行時間，應該如何操作呢？</p> <ol> <li>確定執行平臺，包括硬體配置、程式語言、系統環境等，這些因素都會影響程式碼的執行效率。</li> <li>評估各種計算操作所需的執行時間，例如加法操作 <code>+</code> 需要 1 ns ，乘法操作 <code>*</code> 需要 10 ns ，列印操作 <code>print()</code> 需要 5 ns 等。</li> <li>統計程式碼中所有的計算操作，並將所有操作的執行時間求和，從而得到執行時間。</li> </ol> <p>例如在以下程式碼中，輸入資料大小為 \\(n\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 在某執行平臺下\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # 迴圈 n 次\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        cout &lt;&lt; 0 &lt;&lt; endl;         // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        System.out.println(0);     // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {  // 1 ns\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // 迴圈 n 次\n    for i := 0; i &lt; n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // 迴圈 n 次\n    for _ in 0 ..&lt; n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++) { // 1 ns\n        console.log(0); // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // 迴圈 n 次\n  for (int i = 0; i &lt; n; i++) { // 1 ns\n    print(0); // 5 ns\n  }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // 迴圈 n 次\n    for _ in 0..n {     // 1 ns\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // 1 ns\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n</code></pre> <pre><code>// 在某執行平臺下\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // 迴圈 n 次\n    for (i in 0..&lt;n) {  // 1 ns\n        println(0)      // 5 ns\n    }\n}\n</code></pre> <pre><code># 在某執行平臺下\ndef algorithm(n)\n    a = 2       # 1 ns\n    a = a + 1   # 1 ns\n    a = a * 2   # 10 ns\n    # 迴圈 n 次\n    (0...n).each do # 1 ns\n        puts 0      # 5 ns\n    end\nend\n</code></pre> <p>根據以上方法，可以得到演算法的執行時間為 \\((6n + 12)\\) ns ：</p> \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] <p>但實際上，統計演算法的執行時間既不合理也不現實。首先，我們不希望將預估時間和執行平臺繫結，因為演算法需要在各種不同的平臺上執行。其次，我們很難獲知每種操作的執行時間，這給預估過程帶來了極大的難度。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#231","level":2,"title":"2.3.1   統計時間增長趨勢","text":"<p>時間複雜度分析統計的不是演算法執行時間，而是演算法執行時間隨著資料量變大時的增長趨勢。</p> <p>“時間增長趨勢”這個概念比較抽象，我們透過一個例子來加以理解。假設輸入資料大小為 \\(n\\) ，給定三個演算法 <code>A</code>、<code>B</code> 和 <code>C</code> ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 演算法 A 的時間複雜度：常數階\ndef algorithm_A(n: int):\n    print(0)\n# 演算法 B 的時間複雜度：線性階\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# 演算法 C 的時間複雜度：常數階\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    cout &lt;&lt; 0 &lt;&lt; endl;\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        System.out.println(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        System.out.println(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid AlgorithmB(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid AlgorithmC(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// 演算法 B 的時間複雜度：線性階\nfunc algorithm_B(n int) {\n    for i := 0; i &lt; n; i++ {\n        fmt.Println(0)\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunc algorithm_C(n int) {\n    for i := 0; i &lt; 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// 演算法 B 的時間複雜度：線性階\nfunc algorithmB(n: Int) {\n    for _ in 0 ..&lt; n {\n        print(0)\n    }\n}\n\n// 演算法 C 的時間複雜度：常數階\nfunc algorithmC(n: Int) {\n    for _ in 0 ..&lt; 1_000_000 {\n        print(0)\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// 演算法 B 的時間複雜度：線性階\nfunction algorithm_B(n) {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunction algorithm_C(n) {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// 演算法 B 的時間複雜度：線性階\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i &lt; n; i++) {\n        console.log(0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i &lt; 1000000; i++) {\n        console.log(0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithmA(int n) {\n  print(0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithmB(int n) {\n  for (int i = 0; i &lt; n; i++) {\n    print(0);\n  }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithmC(int n) {\n  for (int i = 0; i &lt; 1000000; i++) {\n    print(0);\n  }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// 演算法 B 的時間複雜度：線性階\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// 演算法 B 的時間複雜度：線性階\nvoid algorithm_B(int n) {\n    for (int i = 0; i &lt; n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nvoid algorithm_C(int n) {\n    for (int i = 0; i &lt; 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n</code></pre> <pre><code>// 演算法 A 的時間複雜度：常數階\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// 演算法 B 的時間複雜度：線性階\nfun algorithm_B(n: Int) {\n    for (i in 0..&lt;n){\n        println(0)\n    }\n}\n// 演算法 C 的時間複雜度：常數階\nfun algorithm_C(n: Int) {\n    for (i in 0..&lt;1000000) {\n        println(0)\n    }\n}\n</code></pre> <pre><code># 演算法 A 的時間複雜度：常數階\ndef algorithm_A(n)\n    puts 0\nend\n\n# 演算法 B 的時間複雜度：線性階\ndef algorithm_B(n)\n    (0...n).each { puts 0 }\nend\n\n# 演算法 C 的時間複雜度：常數階\ndef algorithm_C(n)\n    (0...1_000_000).each { puts 0 }\nend\n</code></pre> <p>圖 2-7 展示了以上三個演算法函式的時間複雜度。</p> <ul> <li>演算法 <code>A</code> 只有 \\(1\\) 個列印操作，演算法執行時間不隨著 \\(n\\) 增大而增長。我們稱此演算法的時間複雜度為“常數階”。</li> <li>演算法 <code>B</code> 中的列印操作需要迴圈 \\(n\\) 次，演算法執行時間隨著 \\(n\\) 增大呈線性增長。此演算法的時間複雜度被稱為“線性階”。</li> <li>演算法 <code>C</code> 中的列印操作需要迴圈 \\(1000000\\) 次，雖然執行時間很長，但它與輸入資料大小 \\(n\\) 無關。因此 <code>C</code> 的時間複雜度和 <code>A</code> 相同，仍為“常數階”。</li> </ul> <p></p> <p> 圖 2-7   演算法 A、B 和 C 的時間增長趨勢 </p> <p>相較於直接統計演算法的執行時間，時間複雜度分析有哪些特點呢？</p> <ul> <li>時間複雜度能夠有效評估演算法效率。例如，演算法 <code>B</code> 的執行時間呈線性增長，在 \\(n &gt; 1\\) 時比演算法 <code>A</code> 更慢，在 \\(n &gt; 1000000\\) 時比演算法 <code>C</code> 更慢。事實上，只要輸入資料大小 \\(n\\) 足夠大，複雜度為“常數階”的演算法一定優於“線性階”的演算法，這正是時間增長趨勢的含義。</li> <li>時間複雜度的推算方法更簡便。顯然，執行平臺和計算操作型別都與演算法執行時間的增長趨勢無關。因此在時間複雜度分析中，我們可以簡單地將所有計算操作的執行時間視為相同的“單位時間”，從而將“計算操作執行時間統計”簡化為“計算操作數量統計”，這樣一來估算難度就大大降低了。</li> <li>時間複雜度也存在一定的侷限性。例如，儘管演算法 <code>A</code> 和 <code>C</code> 的時間複雜度相同，但實際執行時間差別很大。同樣，儘管演算法 <code>B</code> 的時間複雜度比 <code>C</code> 高，但在輸入資料大小 \\(n\\) 較小時，演算法 <code>B</code> 明顯優於演算法 <code>C</code> 。對於此類情況，我們時常難以僅憑時間複雜度判斷演算法效率的高低。當然，儘管存在上述問題，複雜度分析仍然是評判演算法效率最有效且常用的方法。</li> </ul>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#232","level":2,"title":"2.3.2   函式漸近上界","text":"<p>給定一個輸入大小為 \\(n\\) 的函式：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # 迴圈 n 次\n    for i in range(n):  # +1\n        print(0)        # +1\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n        cout &lt;&lt; 0 &lt;&lt; endl;    // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n        System.out.println(0);    // +1\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // +1（每輪都執行 i ++）\n        Console.WriteLine(0);   // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // 迴圈 n 次\n    for i := 0; i &lt; n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // 迴圈 n 次\n    for _ in 0 ..&lt; n { // +1\n        print(0) // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++){ // +1（每輪都執行 i ++）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // 迴圈 n 次\n    for(let i = 0; i &lt; n; i++){ // +1（每輪都執行 i ++）\n        console.log(0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // 迴圈 n 次\n  for (int i = 0; i &lt; n; i++) { // +1（每輪都執行 i ++）\n    print(0); // +1\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // 迴圈 n 次\n    for _ in 0..n { // +1（每輪都執行 i ++）\n        println!(\"{}\", 0); // +1\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // 迴圈 n 次\n    for (int i = 0; i &lt; n; i++) {   // +1（每輪都執行 i ++）\n        printf(\"%d\", 0);            // +1\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // 迴圈 n 次\n    for (i in 0..&lt;n) { // +1（每輪都執行 i ++）\n        println(0) // +1\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +1\n    a = a + 1   # +1\n    a = a * 2   # +1\n    # 迴圈 n 次\n    (0...n).each do # +1\n        puts 0      # +1\n    end\nend\n</code></pre> <p>設演算法的操作數量是一個關於輸入資料大小 \\(n\\) 的函式，記為 \\(T(n)\\) ，則以上函式的操作數量為：</p> \\[ T(n) = 3 + 2n \\] <p>\\(T(n)\\) 是一次函式，說明其執行時間的增長趨勢是線性的，因此它的時間複雜度是線性階。</p> <p>我們將線性階的時間複雜度記為 \\(O(n)\\) ，這個數學符號稱為大 \\(O\\) 記號（big-\\(O\\) notation），表示函式 \\(T(n)\\) 的漸近上界（asymptotic upper bound）。</p> <p>時間複雜度分析本質上是計算“操作數量 \\(T(n)\\)”的漸近上界，它具有明確的數學定義。</p> <p>函式漸近上界</p> <p>若存在正實數 \\(c\\) 和實數 \\(n_0\\) ，使得對於所有的 \\(n &gt; n_0\\) ，均有 \\(T(n) \\leq c \\cdot f(n)\\) ，則可認為 \\(f(n)\\) 給出了 \\(T(n)\\) 的一個漸近上界，記為 \\(T(n) = O(f(n))\\) 。</p> <p>如圖 2-8 所示，計算漸近上界就是尋找一個函式 \\(f(n)\\) ，使得當 \\(n\\) 趨向於無窮大時，\\(T(n)\\) 和 \\(f(n)\\) 處於相同的增長級別，僅相差一個常數係數 \\(c\\)。</p> <p></p> <p> 圖 2-8   函式的漸近上界 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#233","level":2,"title":"2.3.3   推算方法","text":"<p>漸近上界的數學味兒有點重，如果你感覺沒有完全理解，也無須擔心。我們可以先掌握推算方法，在不斷的實踐中，就可以逐漸領悟其數學意義。</p> <p>根據定義，確定 \\(f(n)\\) 之後，我們便可得到時間複雜度 \\(O(f(n))\\) 。那麼如何確定漸近上界 \\(f(n)\\) 呢？總體分為兩步：首先統計操作數量，然後判斷漸近上界。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1","level":3,"title":"1.   第一步：統計操作數量","text":"<p>針對程式碼，逐行從上到下計算即可。然而，由於上述 \\(c \\cdot f(n)\\) 中的常數係數 \\(c\\) 可以取任意大小，因此操作數量 \\(T(n)\\) 中的各種係數、常數項都可以忽略。根據此原則，可以總結出以下計數簡化技巧。</p> <ol> <li>忽略 \\(T(n)\\) 中的常數。因為它們都與 \\(n\\) 無關，所以對時間複雜度不產生影響。</li> <li>省略所有係數。例如，迴圈 \\(2n\\) 次、\\(5n + 1\\) 次等，都可以簡化記為 \\(n\\) 次，因為 \\(n\\) 前面的係數對時間複雜度沒有影響。</li> <li>迴圈巢狀時使用乘法。總操作數量等於外層迴圈和內層迴圈操作數量之積，每一層迴圈依然可以分別套用第 <code>1.</code> 點和第 <code>2.</code> 點的技巧。</li> </ol> <p>給定一個函式，我們可以用上述技巧來統計操作數量：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>def algorithm(n: int):\n    a = 1      # +0（技巧 1）\n    a = a + n  # +0（技巧 1）\n    # +n（技巧 2）\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n（技巧 3）\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        cout &lt;&lt; 0 &lt;&lt; endl;\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            cout &lt;&lt; 0 &lt;&lt; endl;\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n</code></pre> <pre><code>void Algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n int) {\n    a := 1     // +0（技巧 1）\n    a = a + n  // +0（技巧 1）\n    // +n（技巧 2）\n    for i := 0; i &lt; 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n（技巧 3）\n    for i := 0; i &lt; 2 * n; i++ {\n        for j := 0; j &lt; n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n</code></pre> <pre><code>func algorithm(n: Int) {\n    var a = 1 // +0（技巧 1）\n    a = a + n // +0（技巧 1）\n    // +n（技巧 2）\n    for _ in 0 ..&lt; (5 * n + 1) {\n        print(0)\n    }\n    // +n*n（技巧 3）\n    for _ in 0 ..&lt; (2 * n) {\n        for _ in 0 ..&lt; (n + 1) {\n            print(0)\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n) {\n    let a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（技巧 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>function algorithm(n: number): void {\n    let a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (let i = 0; i &lt; 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n（技巧 3）\n    for (let i = 0; i &lt; 2 * n; i++) {\n        for (let j = 0; j &lt; n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n  int a = 1; // +0（技巧 1）\n  a = a + n; // +0（技巧 1）\n  // +n（技巧 2）\n  for (int i = 0; i &lt; 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n（技巧 3）\n  for (int i = 0; i &lt; 2 * n; i++) {\n    for (int j = 0; j &lt; n + 1; j++) {\n      print(0);\n    }\n  }\n}\n</code></pre> <pre><code>fn algorithm(n: i32) {\n    let mut a = 1;     // +0（技巧 1）\n    a = a + n;        // +0（技巧 1）\n\n    // +n（技巧 2）\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n（技巧 3）\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>void algorithm(int n) {\n    int a = 1;  // +0（技巧 1）\n    a = a + n;  // +0（技巧 1）\n    // +n（技巧 2）\n    for (int i = 0; i &lt; 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n（技巧 3）\n    for (int i = 0; i &lt; 2 * n; i++) {\n        for (int j = 0; j &lt; n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n</code></pre> <pre><code>fun algorithm(n: Int) {\n    var a = 1   // +0（技巧 1）\n    a = a + n   // +0（技巧 1）\n    // +n（技巧 2）\n    for (i in 0..&lt;5 * n + 1) {\n        println(0)\n    }\n    // +n*n（技巧 3）\n    for (i in 0..&lt;2 * n) {\n        for (j in 0..&lt;n + 1) {\n            println(0)\n        }\n    }\n}\n</code></pre> <pre><code>def algorithm(n)\n    a = 1       # +0（技巧 1）\n    a = a + n   # +0（技巧 1）\n    # +n（技巧 2）\n    (0...(5 * n + 1)).each do { puts 0 }\n    # +n*n（技巧 3）\n    (0...(2 * n)).each do\n        (0...(n + 1)).each do { puts 0 }\n    end\nend\n</code></pre> <p>以下公式展示了使用上述技巧前後的統計結果，兩者推算出的時間複雜度都為 \\(O(n^2)\\) 。</p> \\[ \\begin{aligned} T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \\text{完整統計 (-.-|||)} \\newline &amp; = 2n^2 + 7n + 3 \\newline T(n) &amp; = n^2 + n &amp; \\text{偷懶統計 (o.O)} \\end{aligned} \\]","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2","level":3,"title":"2.   第二步：判斷漸近上界","text":"<p>時間複雜度由 \\(T(n)\\) 中最高階的項來決定。這是因為在 \\(n\\) 趨於無窮大時，最高階的項將發揮主導作用，其他項的影響都可以忽略。</p> <p>表 2-2 展示了一些例子，其中一些誇張的值是為了強調“係數無法撼動階數”這一結論。當 \\(n\\) 趨於無窮大時，這些常數變得無足輕重。</p> <p> 表 2-2   不同操作數量對應的時間複雜度 </p> 操作數量 \\(T(n)\\) 時間複雜度 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#234","level":2,"title":"2.3.4   常見型別","text":"<p>設輸入資料大小為 \\(n\\) ，常見的時間複雜度型別如圖 2-9 所示（按照從低到高的順序排列）。</p> \\[ \\begin{aligned} O(1) &lt; O(\\log n) &lt; O(n) &lt; O(n \\log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \\newline \\text{常數階} &lt; \\text{對數階} &lt; \\text{線性階} &lt; \\text{線性對數階} &lt; \\text{平方階} &lt; \\text{指數階} &lt; \\text{階乘階} \\end{aligned} \\] <p></p> <p> 圖 2-9   常見的時間複雜度型別 </p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#1-o1","level":3,"title":"1.   常數階 \\(O(1)\\)","text":"<p>常數階的操作數量與輸入資料大小 \\(n\\) 無關，即不隨著 \\(n\\) 的變化而變化。</p> <p>在以下函式中，儘管操作數量 <code>size</code> 可能很大，但由於其與輸入資料大小 \\(n\\) 無關，因此時間複雜度仍為 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def constant(n: int) -&gt; int:\n    \"\"\"常數階\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 常數階 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i &lt; size; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 常數階 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i &lt; size; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 常數階 */\nfunc constant(n: Int) -&gt; Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..&lt; size {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 常數階 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 常數階 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i &lt; size; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 常數階 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i &lt; size; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 常數階 */\nfn constant(n: i32) -&gt; i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 常數階 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i &lt; size; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 常數階 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 100000\n    for (i in 0..&lt;size)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 常數階 ###\ndef constant(n)\n  count = 0\n  size = 100000\n\n  (0...size).each { count += 1 }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#2-on","level":3,"title":"2.   線性階 \\(O(n)\\)","text":"<p>線性階的操作數量相對於輸入資料大小 \\(n\\) 以線性級別增長。線性階通常出現在單層迴圈中：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear(n: int) -&gt; int:\n    \"\"\"線性階\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性階 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++)\n        count++;\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性階 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性階 */\nfunc linear(n: Int) -&gt; Int {\n    var count = 0\n    for _ in 0 ..&lt; n {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性階 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性階 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i &lt; n; i++) count++;\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性階 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性階 */\nfn linear(n: i32) -&gt; i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線性階 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性階 */\nfun linear(n: Int): Int {\n    var count = 0\n    for (i in 0..&lt;n)\n        count++\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性階 ###\ndef linear(n)\n  count = 0\n  (0...n).each { count += 1 }\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>走訪陣列和走訪鏈結串列等操作的時間複雜度均為 \\(O(n)\\) ，其中 \\(n\\) 為陣列或鏈結串列的長度：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def array_traversal(nums: list[int]) -&gt; int:\n    \"\"\"線性階（走訪陣列）\"\"\"\n    count = 0\n    # 迴圈次數與陣列長度成正比\n    for num in nums:\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(vector&lt;int&gt; &amp;nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性階（走訪陣列） */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性階（走訪陣列） */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // 迴圈次數與陣列長度成正比\n    for range nums {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性階（走訪陣列） */\nfunc arrayTraversal(nums: [Int]) -&gt; Int {\n    var count = 0\n    // 迴圈次數與陣列長度成正比\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性階（走訪陣列） */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性階（走訪陣列） */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (let i = 0; i &lt; nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(List&lt;int&gt; nums) {\n  int count = 0;\n  // 迴圈次數與陣列長度成正比\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性階（走訪陣列） */\nfn array_traversal(nums: &amp;[i32]) -&gt; i32 {\n    let mut count = 0;\n    // 迴圈次數與陣列長度成正比\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 線性階（走訪陣列） */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // 迴圈次數與陣列長度成正比\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性階（走訪陣列） */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // 迴圈次數與陣列長度成正比\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性階（走訪陣列）###\ndef array_traversal(nums)\n  count = 0\n\n  # 迴圈次數與陣列長度成正比\n  for num in nums\n    count += 1\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得注意的是，輸入資料大小 \\(n\\) 需根據輸入資料的型別來具體確定。比如在第一個示例中，變數 \\(n\\) 為輸入資料大小；在第二個示例中，陣列長度 \\(n\\) 為資料大小。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#3-on2","level":3,"title":"3.   平方階 \\(O(n^2)\\)","text":"<p>平方階的操作數量相對於輸入資料大小 \\(n\\) 以平方級別增長。平方階通常出現在巢狀迴圈中，外層迴圈和內層迴圈的時間複雜度都為 \\(O(n)\\) ，因此總體的時間複雜度為 \\(O(n^2)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def quadratic(n: int) -&gt; int:\n    \"\"\"平方階\"\"\"\n    count = 0\n    # 迴圈次數與資料大小 n 成平方關係\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 平方階 */\nint Quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 平方階 */\nfunc quadratic(n int) int {\n    count := 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; n; j++ {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 平方階 */\nfunc quadratic(n: Int) -&gt; Int {\n    var count = 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; n {\n            count += 1\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 平方階 */\nfunction quadratic(n) {\n    let count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 平方階 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 平方階 */\nint quadratic(int n) {\n  int count = 0;\n  // 迴圈次數與資料大小 n 成平方關係\n  for (int i = 0; i &lt; n; i++) {\n    for (int j = 0; j &lt; n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 平方階 */\nfn quadratic(n: i32) -&gt; i32 {\n    let mut count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 平方階 */\nint quadratic(int n) {\n    int count = 0;\n    // 迴圈次數與資料大小 n 成平方關係\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 平方階 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // 迴圈次數與資料大小 n 成平方關係\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;n) {\n            count++\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階 ###\ndef quadratic(n)\n  count = 0\n\n  # 迴圈次數與資料大小 n 成平方關係\n  for i in 0...n\n    for j in 0...n\n      count += 1\n    end\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-10 對比了常數階、線性階和平方階三種時間複雜度。</p> <p></p> <p> 圖 2-10   常數階、線性階和平方階的時間複雜度 </p> <p>以泡沫排序為例，外層迴圈執行 \\(n - 1\\) 次，內層迴圈執行 \\(n-1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 次，平均為 \\(n / 2\\) 次，因此時間複雜度為 \\(O((n - 1) n / 2) = O(n^2)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def bubble_sort(nums: list[int]) -&gt; int:\n    \"\"\"平方階（泡沫排序）\"\"\"\n    count = 0  # 計數器\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(len(nums) - 1, 0, -1):\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # 元素交換包含 3 個單元操作\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(vector&lt;int&gt; &amp;nums) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(int[] nums) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 平方階（泡沫排序） */\nint BubbleSort(int[] nums) {\n    int count = 0;  // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 平方階（泡沫排序） */\nfunc bubbleSort(nums []int) int {\n    count := 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 平方階（泡沫排序） */\nfunc bubbleSort(nums: inout [Int]) -&gt; Int {\n    var count = 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 平方階（泡沫排序） */\nfunction bubbleSort(nums) {\n    let count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 平方階（泡沫排序） */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(List&lt;int&gt; nums) {\n  int count = 0; // 計數器\n  // 外迴圈：未排序區間為 [0, i]\n  for (var i = nums.length - 1; i &gt; 0; i--) {\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (var j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // 元素交換包含 3 個單元操作\n      }\n    }\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 平方階（泡沫排序） */\nfn bubble_sort(nums: &amp;mut [i32]) -&gt; i32 {\n    let mut count = 0; // 計數器\n\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 平方階（泡沫排序） */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = n - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 平方階（泡沫排序） */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0 // 計數器\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                count += 3 // 元素交換包含 3 個單元操作\n            }\n        }\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 平方階（泡沫排序）###\ndef bubble_sort(nums)\n  count = 0  # 計數器\n\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (nums.length - 1).downto(0)\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        tmp = nums[j]\n        nums[j] = nums[j + 1]\n        nums[j + 1] = tmp\n        count += 3 # 元素交換包含 3 個單元操作\n      end\n    end\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","level":3,"title":"4.   指數階 \\(O(2^n)\\)","text":"<p>生物學的“細胞分裂”是指數階增長的典型例子：初始狀態為 \\(1\\) 個細胞，分裂一輪後變為 \\(2\\) 個，分裂兩輪後變為 \\(4\\) 個，以此類推，分裂 \\(n\\) 輪後有 \\(2^n\\) 個細胞。</p> <p>圖 2-11 和以下程式碼模擬了細胞分裂的過程，時間複雜度為 \\(O(2^n)\\) 。請注意，輸入 \\(n\\) 表示分裂輪數，返回值 <code>count</code> 表示總分裂次數。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exponential(n: int) -&gt; int:\n    \"\"\"指數階（迴圈實現）\"\"\"\n    count = 0\n    base = 1\n    # 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指數階（迴圈實現） */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 指數階（迴圈實現）*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i &lt; n; i++ {\n        for j := 0; j &lt; base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 指數階（迴圈實現） */\nfunc exponential(n: Int) -&gt; Int {\n    var count = 0\n    var base = 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..&lt; n {\n        for _ in 0 ..&lt; base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 指數階（迴圈實現） */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指數階（迴圈實現） */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = 0; j &lt; base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i &lt; n; i++) {\n    for (var j = 0; j &lt; base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指數階（迴圈實現） */\nfn exponential(n: i32) -&gt; i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 指數階（迴圈實現） */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i &lt; n; i++) {\n        for (int j = 0; j &lt; bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指數階（迴圈實現） */\nfun exponential(n: Int): Int {\n    var count = 0\n    var base = 1\n    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n    for (i in 0..&lt;n) {\n        for (j in 0..&lt;base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 指數階（迴圈實現）###\ndef exponential(n)\n  count, base = 0, 1\n\n  # 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)\n  (0...n).each do\n    (0...base).each { count += 1 }\n    base *= 2\n  end\n\n  # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-11   指數階的時間複雜度 </p> <p>在實際演算法中，指數階常出現於遞迴函式中。例如在以下程式碼中，其遞迴地一分為二，經過 \\(n\\) 次分裂後停止：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def exp_recur(n: int) -&gt; int:\n    \"\"\"指數階（遞迴實現）\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 指數階（遞迴實現） */\nint ExpRecur(int n) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 指數階（遞迴實現）*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n-1) + expRecur(n-1) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 指數階（遞迴實現） */\nfunc expRecur(n: Int) -&gt; Int {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 指數階（遞迴實現） */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 指數階（遞迴實現） */\nfunction expRecur(n: number): number {\n    if (n === 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 指數階（遞迴實現） */\nfn exp_recur(n: i32) -&gt; i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 指數階（遞迴實現） */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 指數階（遞迴實現） */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 指數階（遞迴實現）###\ndef exp_recur(n)\n  return 1 if n == 1\n  exp_recur(n - 1) + exp_recur(n - 1) + 1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>指數階增長非常迅速，在窮舉法（暴力搜尋、回溯等）中比較常見。對於資料規模較大的問題，指數階是不可接受的，通常需要使用動態規劃或貪婪演算法等來解決。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","level":3,"title":"5.   對數階 \\(O(\\log n)\\)","text":"<p>與指數階相反，對數階反映了“每輪縮減到一半”的情況。設輸入資料大小為 \\(n\\) ，由於每輪縮減到一半，因此迴圈次數是 \\(\\log_2 n\\) ，即 \\(2^n\\) 的反函式。</p> <p>圖 2-12 和以下程式碼模擬了“每輪縮減到一半”的過程，時間複雜度為 \\(O(\\log_2 n)\\) ，簡記為 \\(O(\\log n)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def logarithmic(n: int) -&gt; int:\n    \"\"\"對數階（迴圈實現）\"\"\"\n    count = 0\n    while n &gt; 1:\n        n = n / 2\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 對數階（迴圈實現） */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 對數階（迴圈實現）*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n &gt; 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 對數階（迴圈實現） */\nfunc logarithmic(n: Int) -&gt; Int {\n    var count = 0\n    var n = n\n    while n &gt; 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 對數階（迴圈實現） */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 對數階（迴圈實現） */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n  int count = 0;\n  while (n &gt; 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 對數階（迴圈實現） */\nfn logarithmic(mut n: i32) -&gt; i32 {\n    let mut count = 0;\n    while n &gt; 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 對數階（迴圈實現） */\nint logarithmic(int n) {\n    int count = 0;\n    while (n &gt; 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 對數階（迴圈實現） */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 &gt; 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 對數階（迴圈實現）###\ndef logarithmic(n)\n  count = 0\n\n  while n &gt; 1\n    n /= 2\n    count += 1\n  end\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-12   對數階的時間複雜度 </p> <p>與指數階類似，對數階也常出現於遞迴函式中。以下程式碼形成了一棵高度為 \\(\\log_2 n\\) 的遞迴樹：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def log_recur(n: int) -&gt; int:\n    \"\"\"對數階（遞迴實現）\"\"\"\n    if n &lt;= 1:\n        return 0\n    return log_recur(n / 2) + 1\n</code></pre> time_complexity.cpp<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.java<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.cs<pre><code>/* 對數階（遞迴實現） */\nint LogRecur(int n) {\n    if (n &lt;= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.go<pre><code>/* 對數階（遞迴實現）*/\nfunc logRecur(n int) int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n</code></pre> time_complexity.swift<pre><code>/* 對數階（遞迴實現） */\nfunc logRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n</code></pre> time_complexity.js<pre><code>/* 對數階（遞迴實現） */\nfunction logRecur(n) {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.ts<pre><code>/* 對數階（遞迴實現） */\nfunction logRecur(n: number): number {\n    if (n &lt;= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.dart<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n  if (n &lt;= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n</code></pre> time_complexity.rs<pre><code>/* 對數階（遞迴實現） */\nfn log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n</code></pre> time_complexity.c<pre><code>/* 對數階（遞迴實現） */\nint logRecur(int n) {\n    if (n &lt;= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n</code></pre> time_complexity.kt<pre><code>/* 對數階（遞迴實現） */\nfun logRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n</code></pre> time_complexity.rb<pre><code>### 對數階（遞迴實現）###\ndef log_recur(n)\n  return 0 unless n &gt; 1\n  log_recur(n / 2) + 1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>對數階常出現於基於分治策略的演算法中，體現了“一分為多”和“化繁為簡”的演算法思想。它增長緩慢，是僅次於常數階的理想的時間複雜度。</p> <p>\\(O(\\log n)\\) 的底數是多少？</p> <p>準確來說，“一分為 \\(m\\)”對應的時間複雜度是 \\(O(\\log_m n)\\) 。而透過對數換底公式，我們可以得到具有不同底數、相等的時間複雜度：</p> \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\] <p>也就是說，底數 \\(m\\) 可以在不影響複雜度的前提下轉換。因此我們通常會省略底數 \\(m\\) ，將對數階直接記為 \\(O(\\log n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","level":3,"title":"6.   線性對數階 \\(O(n \\log n)\\)","text":"<p>線性對數階常出現於巢狀迴圈中，兩層迴圈的時間複雜度分別為 \\(O(\\log n)\\) 和 \\(O(n)\\) 。相關程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def linear_log_recur(n: int) -&gt; int:\n    \"\"\"線性對數階\"\"\"\n    if n &lt;= 1:\n        return 1\n    # 一分為二，子問題的規模減小一半\n    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    # 當前子問題包含 n 個操作\n    for _ in range(n):\n        count += 1\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 線性對數階 */\nint LinearLogRecur(int n) {\n    if (n &lt;= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 線性對數階 */\nfunc linearLogRecur(n int) int {\n    if n &lt;= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i &lt; n; i++ {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 線性對數階 */\nfunc linearLogRecur(n: Int) -&gt; Int {\n    if n &lt;= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 線性對數階 */\nfunction linearLogRecur(n) {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 線性對數階 */\nfunction linearLogRecur(n: number): number {\n    if (n &lt;= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n  if (n &lt;= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i &lt; n; i++) {\n    count++;\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 線性對數階 */\nfn linear_log_recur(n: i32) -&gt; i32 {\n    if n &lt;= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n {\n        count += 1;\n    }\n    return count;\n}\n</code></pre> time_complexity.c<pre><code>/* 線性對數階 */\nint linearLogRecur(int n) {\n    if (n &lt;= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i &lt; n; i++) {\n        count++;\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 線性對數階 */\nfun linearLogRecur(n: Int): Int {\n    if (n &lt;= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..&lt;n) {\n        count++\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 線性對數階 ###\ndef linear_log_recur(n)\n  return 1 unless n &gt; 1\n\n  count = linear_log_recur(n / 2) + linear_log_recur(n / 2)\n  (0...n).each { count += 1 }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 2-13 展示了線性對數階的生成方式。二元樹的每一層的操作總數都為 \\(n\\) ，樹共有 \\(\\log_2 n + 1\\) 層，因此時間複雜度為 \\(O(n \\log n)\\) 。</p> <p></p> <p> 圖 2-13   線性對數階的時間複雜度 </p> <p>主流排序演算法的時間複雜度通常為 \\(O(n \\log n)\\) ，例如快速排序、合併排序、堆積排序等。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#7-on","level":3,"title":"7.   階乘階 \\(O(n!)\\)","text":"<p>階乘階對應數學上的“全排列”問題。給定 \\(n\\) 個互不重複的元素，求其所有可能的排列方案，方案數量為：</p> \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\dots \\times 2 \\times 1 \\] <p>階乘通常使用遞迴實現。如圖 2-14 和以下程式碼所示，第一層分裂出 \\(n\\) 個，第二層分裂出 \\(n - 1\\) 個，以此類推，直至第 \\(n\\) 層時停止分裂：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby time_complexity.py<pre><code>def factorial_recur(n: int) -&gt; int:\n    \"\"\"階乘階（遞迴實現）\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # 從 1 個分裂出 n 個\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n</code></pre> time_complexity.cpp<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.java<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.cs<pre><code>/* 階乘階（遞迴實現） */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // 從 1 個分裂出 n 個\n    for (int i = 0; i &lt; n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.go<pre><code>/* 階乘階（遞迴實現） */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // 從 1 個分裂出 n 個\n    for i := 0; i &lt; n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.swift<pre><code>/* 階乘階（遞迴實現） */\nfunc factorialRecur(n: Int) -&gt; Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // 從 1 個分裂出 n 個\n    for _ in 0 ..&lt; n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.js<pre><code>/* 階乘階（遞迴實現） */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // 從 1 個分裂出 n 個\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.ts<pre><code>/* 階乘階（遞迴實現） */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // 從 1 個分裂出 n 個\n    for (let i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.dart<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // 從 1 個分裂出 n 個\n  for (var i = 0; i &lt; n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n</code></pre> time_complexity.rs<pre><code>/* 階乘階（遞迴實現） */\nfn factorial_recur(n: i32) -&gt; i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // 從 1 個分裂出 n 個\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n</code></pre> time_complexity.c<pre><code>/* 階乘階（遞迴實現） */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i &lt; n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n</code></pre> time_complexity.kt<pre><code>/* 階乘階（遞迴實現） */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // 從 1 個分裂出 n 個\n    for (i in 0..&lt;n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n</code></pre> time_complexity.rb<pre><code>### 階乘階（遞迴實現）###\ndef factorial_recur(n)\n  return 1 if n == 0\n\n  count = 0\n  # 從 1 個分裂出 n 個\n  (0...n).each { count += factorial_recur(n - 1) }\n\n  count\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 2-14   階乘階的時間複雜度 </p> <p>請注意，因為當 \\(n \\geq 4\\) 時恆有 \\(n! &gt; 2^n\\) ，所以階乘階比指數階增長得更快，在 \\(n\\) 較大時也是不可接受的。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_computational_complexity/time_complexity/#235","level":2,"title":"2.3.5   最差、最佳、平均時間複雜度","text":"<p>演算法的時間效率往往不是固定的，而是與輸入資料的分佈有關。假設輸入一個長度為 \\(n\\) 的陣列 <code>nums</code> ，其中 <code>nums</code> 由從 \\(1\\) 至 \\(n\\) 的數字組成，每個數字只出現一次；但元素順序是隨機打亂的，任務目標是返回元素 \\(1\\) 的索引。我們可以得出以下結論。</p> <ul> <li>當 <code>nums = [?, ?, ..., 1]</code> ，即當末尾元素是 \\(1\\) 時，需要完整走訪陣列，達到最差時間複雜度 \\(O(n)\\) 。</li> <li>當 <code>nums = [1, ?, ?, ...]</code> ，即當首個元素為 \\(1\\) 時，無論陣列多長都不需要繼續走訪，達到最佳時間複雜度 \\(\\Omega(1)\\) 。</li> </ul> <p>“最差時間複雜度”對應函式漸近上界，使用大 \\(O\\) 記號表示。相應地，“最佳時間複雜度”對應函式漸近下界，用 \\(\\Omega\\) 記號表示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby worst_best_time_complexity.py<pre><code>def random_numbers(n: int) -&gt; list[int]:\n    \"\"\"生成一個陣列，元素為: 1, 2, ..., n ，順序被打亂\"\"\"\n    # 生成陣列 nums =: 1, 2, 3, ..., n\n    nums = [i for i in range(1, n + 1)]\n    # 隨機打亂陣列元素\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -&gt; int:\n    \"\"\"查詢陣列 nums 中數字 1 所在索引\"\"\"\n    for i in range(len(nums)):\n        # 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        # 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1:\n            return i\n    return -1\n</code></pre> worst_best_time_complexity.cpp<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nvector&lt;int&gt; randomNumbers(int n) {\n    vector&lt;int&gt; nums(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 使用系統時間生成隨機種子\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // 隨機打亂陣列元素\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(vector&lt;int&gt; &amp;nums) {\n    for (int i = 0; i &lt; nums.size(); i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.java<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint[] randomNumbers(int n) {\n    Integer[] nums = new Integer[n];\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -&gt; int[]\n    int[] res = new int[n];\n    for (int i = 0; i &lt; n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(int[] nums) {\n    for (int i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.cs<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint[] RandomNumbers(int n) {\n    int[] nums = new int[n];\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // 隨機打亂陣列元素\n    for (int i = 0; i &lt; nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint FindOne(int[] nums) {\n    for (int i = 0; i &lt; nums.Length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.go<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunc randomNumbers(n int) []int {\n    nums := make([]int, n)\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for i := 0; i &lt; n; i++ {\n        nums[i] = i + 1\n    }\n    // 隨機打亂陣列元素\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunc findOne(nums []int) int {\n    for i := 0; i &lt; len(nums); i++ {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.swift<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunc randomNumbers(n: Int) -&gt; [Int] {\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    var nums = Array(1 ... n)\n    // 隨機打亂陣列元素\n    nums.shuffle()\n    return nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunc findOne(nums: [Int]) -&gt; Int {\n    for i in nums.indices {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.js<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunction randomNumbers(n) {\n    const nums = Array(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunction findOne(nums) {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.ts<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfunction randomNumbers(n: number): number[] {\n    const nums = Array(n);\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (let i = 0; i &lt; n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfunction findOne(nums: number[]): number {\n    for (let i = 0; i &lt; nums.length; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.dart<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nList&lt;int&gt; randomNumbers(int n) {\n  final nums = List.filled(n, 0);\n  // 生成陣列 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i &lt; n; i++) {\n    nums[i] = i + 1;\n  }\n  // 隨機打亂陣列元素\n  nums.shuffle();\n\n  return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(List&lt;int&gt; nums) {\n  for (var i = 0; i &lt; nums.length; i++) {\n    // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n    // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n</code></pre> worst_best_time_complexity.rs<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfn random_numbers(n: i32) -&gt; Vec&lt;i32&gt; {\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::&lt;Vec&lt;i32&gt;&gt;();\n    // 隨機打亂陣列元素\n    nums.shuffle(&amp;mut thread_rng());\n    nums\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfn find_one(nums: &amp;[i32]) -&gt; Option&lt;usize&gt; {\n    for i in 0..nums.len() {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\n}\n</code></pre> worst_best_time_complexity.c<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nint *randomNumbers(int n) {\n    // 分配堆積區記憶體（建立一維可變長陣列：陣列中元素數量為 n ，元素型別為 int ）\n    int *nums = (int *)malloc(n * sizeof(int));\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = i + 1;\n    }\n    // 隨機打亂陣列元素\n    for (int i = n - 1; i &gt; 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nint findOne(int *nums, int n) {\n    for (int i = 0; i &lt; n; i++) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n</code></pre> worst_best_time_complexity.kt<pre><code>/* 生成一個陣列，元素為 { 1, 2, ..., n }，順序被打亂 */\nfun randomNumbers(n: Int): Array&lt;Int?&gt; {\n    val nums = IntArray(n)\n    // 生成陣列 nums = { 1, 2, 3, ..., n }\n    for (i in 0..&lt;n) {\n        nums[i] = i + 1\n    }\n    // 隨機打亂陣列元素\n    nums.shuffle()\n    val res = arrayOfNulls&lt;Int&gt;(n)\n    for (i in 0..&lt;n) {\n        res[i] = nums[i]\n    }\n    return res\n}\n\n/* 查詢陣列 nums 中數字 1 所在索引 */\nfun findOne(nums: Array&lt;Int?&gt;): Int {\n    for (i in nums.indices) {\n        // 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n        // 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n</code></pre> worst_best_time_complexity.rb<pre><code>### 生成一個陣列，元素為: 1, 2, ..., n ，順序被打亂 ###\ndef random_numbers(n)\n  # 生成陣列 nums =: 1, 2, 3, ..., n\n  nums = Array.new(n) { |i| i + 1 }\n  # 隨機打亂陣列元素\n  nums.shuffle!\nend\n\n### 查詢陣列 nums 中數字 1 所在索引 ###\ndef find_one(nums)\n  for i in 0...nums.length\n    # 當元素 1 在陣列頭部時，達到最佳時間複雜度 O(1)\n    # 當元素 1 在陣列尾部時，達到最差時間複雜度 O(n)\n    return i if nums[i] == 1\n  end\n\n  -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得說明的是，我們在實際中很少使用最佳時間複雜度，因為通常只有在很小機率下才能達到，可能會帶來一定的誤導性。而最差時間複雜度更為實用，因為它給出了一個效率安全值，讓我們可以放心地使用演算法。</p> <p>從上述示例可以看出，最差時間複雜度和最佳時間複雜度只出現於“特殊的資料分佈”，這些情況的出現機率可能很小，並不能真實地反映演算法執行效率。相比之下，平均時間複雜度可以體現演算法在隨機輸入資料下的執行效率，用 \\(\\Theta\\) 記號來表示。</p> <p>對於部分演算法，我們可以簡單地推算出隨機資料分佈下的平均情況。比如上述示例，由於輸入陣列是被打亂的，因此元素 \\(1\\) 出現在任意索引的機率都是相等的，那麼演算法的平均迴圈次數就是陣列長度的一半 \\(n / 2\\) ，平均時間複雜度為 \\(\\Theta(n / 2) = \\Theta(n)\\) 。</p> <p>但對於較為複雜的演算法，計算平均時間複雜度往往比較困難，因為很難分析出在資料分佈下的整體數學期望。在這種情況下，我們通常使用最差時間複雜度作為演算法效率的評判標準。</p> <p>為什麼很少看到 \\(\\Theta\\) 符號？</p> <p>可能由於 \\(O\\) 符號過於朗朗上口，因此我們常常使用它來表示平均時間複雜度。但從嚴格意義上講，這種做法並不規範。在本書和其他資料中，若遇到類似“平均時間複雜度 \\(O(n)\\)”的表述，請將其直接理解為 \\(\\Theta(n)\\) 。</p>","path":["第 2 章 &nbsp; 複雜度分析","2.3 &nbsp; 時間複雜度"],"tags":[]},{"location":"chapter_data_structure/","level":1,"title":"第 3 章   資料結構","text":"<p>Abstract</p> <p>資料結構如同一副穩固而多樣的框架。</p> <p>它為資料的有序組織提供了藍圖，演算法得以在此基礎上生動起來。</p>","path":["第 3 章 &nbsp; 資料結構"],"tags":[]},{"location":"chapter_data_structure/#_1","level":2,"title":"本章內容","text":"<ul> <li>3.1   資料結構分類</li> <li>3.2   基本資料型別</li> <li>3.3   數字編碼 *</li> <li>3.4   字元編碼 *</li> <li>3.5   小結</li> </ul>","path":["第 3 章 &nbsp; 資料結構"],"tags":[]},{"location":"chapter_data_structure/basic_data_types/","level":1,"title":"3.2   基本資料型別","text":"<p>當談及計算機中的資料時，我們會想到文字、圖片、影片、語音、3D 模型等各種形式。儘管這些資料的組織形式各異，但它們都由各種基本資料型別構成。</p> <p>基本資料型別是 CPU 可以直接進行運算的型別，在演算法中直接被使用，主要包括以下幾種。</p> <ul> <li>整數型別 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> 。</li> <li>浮點數型別 <code>float</code>、<code>double</code> ，用於表示小數。</li> <li>字元型別 <code>char</code> ，用於表示各種語言的字母、標點符號甚至表情符號等。</li> <li>布林型別 <code>bool</code> ，用於表示“是”與“否”判斷。</li> </ul> <p>基本資料型別以二進位制的形式儲存在計算機中。一個二進位制位即為 \\(1\\) 位元。在絕大多數現代作業系統中，\\(1\\) 位元組（byte）由 \\(8\\) 位元（bit）組成。</p> <p>基本資料型別的取值範圍取決於其佔用的空間大小。下面以 Java 為例。</p> <ul> <li>整數型別 <code>byte</code> 佔用 \\(1\\) 位元組 = \\(8\\) 位元 ，可以表示 \\(2^{8}\\) 個數字。</li> <li>整數型別 <code>int</code> 佔用 \\(4\\) 位元組 = \\(32\\) 位元 ，可以表示 \\(2^{32}\\) 個數字。</li> </ul> <p>表 3-1 列舉了 Java 中各種基本資料型別的佔用空間、取值範圍和預設值。此表格無須死記硬背，大致理解即可，需要時可以透過查表來回憶。</p> <p> 表 3-1   基本資料型別的佔用空間和取值範圍 </p> 型別 符號 佔用空間 最小值 最大值 預設值 整數 <code>byte</code> 1 位元組 \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) <code>short</code> 2 位元組 \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) <code>int</code> 4 位元組 \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) <code>long</code> 8 位元組 \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) 浮點數 <code>float</code> 4 位元組 \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) <code>double</code> 8 位元組 \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) 字元 <code>char</code> 2 位元組 \\(0\\) \\(2^{16} - 1\\) \\(0\\) 布林 <code>bool</code> 1 位元組 \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\) <p>請注意，表 3-1 針對的是 Java 的基本資料型別的情況。每種程式語言都有各自的資料型別定義，它們的佔用空間、取值範圍和預設值可能會有所不同。</p> <ul> <li>在 Python 中，整數型別 <code>int</code> 可以是任意大小，只受限於可用記憶體；浮點數 <code>float</code> 是雙精度 64 位；沒有 <code>char</code> 型別，單個字元實際上是長度為 1 的字串 <code>str</code> 。</li> <li>C 和 C++ 未明確規定基本資料型別的大小，而因實現和平臺各異。表 3-1 遵循 LP64 資料模型，其用於包括 Linux 和 macOS 在內的 Unix 64 位作業系統。</li> <li>字元 <code>char</code> 的大小在 C 和 C++ 中為 1 位元組，在大多數程式語言中取決於特定的字元編碼方法，詳見“字元編碼”章節。</li> <li>即使表示布林量僅需 1 位（\\(0\\) 或 \\(1\\)），它在記憶體中通常也儲存為 1 位元組。這是因為現代計算機 CPU 通常將 1 位元組作為最小定址記憶體單元。</li> </ul> <p>那麼，基本資料型別與資料結構之間有什麼關聯呢？我們知道，資料結構是在計算機中組織與儲存資料的方式。這句話的主語是“結構”而非“資料”。</p> <p>如果想表示“一排數字”，我們自然會想到使用陣列。這是因為陣列的線性結構可以表示數字的相鄰關係和順序關係，但至於儲存的內容是整數 <code>int</code>、小數 <code>float</code> 還是字元 <code>char</code> ，則與“資料結構”無關。</p> <p>換句話說，基本資料型別提供了資料的“內容型別”，而資料結構提供了資料的“組織方式”。例如以下程式碼，我們用相同的資料結構（陣列）來儲存與表示不同的基本資料型別，包括 <code>int</code>、<code>float</code>、<code>char</code>、<code>bool</code> 等。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 使用多種基本資料型別來初始化陣列\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python 的字元實際上是長度為 1 的字串\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python 的串列可以自由儲存各種基本資料型別和物件引用\ndata = [0, 0.0, 'a', False, ListNode(0)]\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n</code></pre> <pre><code>// JavaScript 的陣列可以自由儲存各種基本資料型別和物件\nconst array = [0, 0.0, 'a', false];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nList&lt;int&gt; numbers = List.filled(5, 0);\nList&lt;double&gt; decimals = List.filled(5, 0.0);\nList&lt;String&gt; characters = List.filled(5, 'a');\nList&lt;bool&gt; bools = List.filled(5, false);\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nlet numbers: Vec&lt;i32&gt; = vec![0; 5];\nlet decimals: Vec&lt;f32&gt; = vec![0.0; 5];\nlet characters: Vec&lt;char&gt; = vec!['0'; 5];\nlet bools: Vec&lt;bool&gt; = vec![false; 5];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n</code></pre> <pre><code>// 使用多種基本資料型別來初始化陣列\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n</code></pre> <pre><code># Ruby 的串列可以自由儲存各種基本資料型別和物件引用\ndata = [0, 0.0, 'a', false, ListNode(0)]\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 3 章 &nbsp; 資料結構","3.2 &nbsp; 基本資料型別"],"tags":[]},{"location":"chapter_data_structure/character_encoding/","level":1,"title":"3.4   字元編碼 *","text":"<p>在計算機中，所有資料都是以二進位制數的形式儲存的，字元 <code>char</code> 也不例外。為了表示字元，我們需要建立一套“字元集”，規定每個字元和二進位制數之間的一一對應關係。有了字元集之後，計算機就可以透過查表完成二進位制數到字元的轉換。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#341-ascii","level":2,"title":"3.4.1   ASCII 字元集","text":"<p>ASCII 碼是最早出現的字元集，其全稱為 American Standard Code for Information Interchange（美國標準資訊交換程式碼）。它使用 7 位二進位制數（一個位元組的低 7 位）表示一個字元，最多能夠表示 128 個不同的字元。如圖 3-6 所示，ASCII 碼包括英文字母的大小寫、數字 0 ~ 9、一些標點符號，以及一些控制字元（如換行符和製表符）。</p> <p></p> <p> 圖 3-6   ASCII 碼 </p> <p>然而，ASCII 碼僅能夠表示英文。隨著計算機的全球化，誕生了一種能夠表示更多語言的 EASCII 字元集。它在 ASCII 的 7 位基礎上擴展到 8 位，能夠表示 256 個不同的字元。</p> <p>在世界範圍內，陸續出現了一批適用於不同地區的 EASCII 字元集。這些字元集的前 128 個字元統一為 ASCII 碼，後 128 個字元定義不同，以適應不同語言的需求。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#342-gbk","level":2,"title":"3.4.2   GBK 字元集","text":"<p>後來人們發現，EASCII 碼仍然無法滿足許多語言的字元數量要求。比如漢字有近十萬個，光日常使用的就有幾千個。中國國家標準總局於 1980 年釋出了 GB2312 字元集，其收錄了 6763 個漢字，基本滿足了漢字的計算機處理需要。</p> <p>然而，GB2312 無法處理部分罕見字和繁體字。GBK 字元集是在 GB2312 的基礎上擴展得到的，它共收錄了 21886 個漢字。在 GBK 的編碼方案中，ASCII 字元使用一個位元組表示，漢字使用兩個位元組表示。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#343-unicode","level":2,"title":"3.4.3   Unicode 字元集","text":"<p>隨著計算機技術的蓬勃發展，字元集與編碼標準百花齊放，而這帶來了許多問題。一方面，這些字元集一般只定義了特定語言的字元，無法在多語言環境下正常工作。另一方面，同一種語言存在多種字元集標準，如果兩臺計算機使用的是不同的編碼標準，則在資訊傳遞時就會出現亂碼。</p> <p>那個時代的研究人員就在想：如果推出一個足夠完整的字元集，將世界範圍內的所有語言和符號都收錄其中，不就可以解決跨語言環境和亂碼問題了嗎？在這種想法的驅動下，一個大而全的字元集 Unicode 應運而生。</p> <p>Unicode 的中文名稱為“統一碼”，理論上能容納 100 多萬個字元。它致力於將全球範圍內的字元納入統一的字元集之中，提供一種通用的字元集來處理和顯示各種語言文字，減少因為編碼標準不同而產生的亂碼問題。</p> <p>自 1991 年釋出以來，Unicode 不斷擴充新的語言與字元。截至 2022 年 9 月，Unicode 已經包含 149186 個字元，包括各種語言的字元、符號甚至表情符號等。在龐大的 Unicode 字元集中，常用的字元佔用 2 位元組，有些生僻的字元佔用 3 位元組甚至 4 位元組。</p> <p>Unicode 是一種通用字元集，本質上是給每個字元分配一個編號（稱為“碼點”），但它並沒有規定在計算機中如何儲存這些字元碼點。我們不禁會問：當多種長度的 Unicode 碼點同時出現在一個文字中時，系統如何解析字元？例如給定一個長度為 2 位元組的編碼，系統如何確認它是一個 2 位元組的字元還是兩個 1 位元組的字元？</p> <p>對於以上問題，一種直接的解決方案是將所有字元儲存為等長的編碼。如圖 3-7 所示，“Hello”中的每個字元佔用 1 位元組，“演算法”中的每個字元佔用 2 位元組。我們可以透過高位填 0 將“Hello 演算法”中的所有字元都編碼為 2 位元組長度。這樣系統就可以每隔 2 位元組解析一個字元，恢復這個短語的內容了。</p> <p></p> <p> 圖 3-7   Unicode 編碼示例 </p> <p>然而 ASCII 碼已經向我們證明，編碼英文只需 1 位元組。若採用上述方案，英文文字佔用空間的大小將會是 ASCII 編碼下的兩倍，非常浪費記憶體空間。因此，我們需要一種更加高效的 Unicode 編碼方法。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#344-utf-8","level":2,"title":"3.4.4   UTF-8 編碼","text":"<p>目前，UTF-8 已成為國際上使用最廣泛的 Unicode 編碼方法。它是一種可變長度的編碼，使用 1 到 4 位元組來表示一個字元，根據字元的複雜性而變。ASCII 字元只需 1 位元組，拉丁字母和希臘字母需要 2 位元組，常用的中文字元需要 3 位元組，其他的一些生僻字元需要 4 位元組。</p> <p>UTF-8 的編碼規則並不複雜，分為以下兩種情況。</p> <ul> <li>對於長度為 1 位元組的字元，將最高位設定為 \\(0\\) ，其餘 7 位設定為 Unicode 碼點。值得注意的是，ASCII 字元在 Unicode 字元集中佔據了前 128 個碼點。也就是說，UTF-8 編碼可以向下相容 ASCII 碼。這意味著我們可以使用 UTF-8 來解析年代久遠的 ASCII 碼文字。</li> <li>對於長度為 \\(n\\) 位元組的字元（其中 \\(n &gt; 1\\)），將首個位元組的高 \\(n\\) 位都設定為 \\(1\\) ，第 \\(n + 1\\) 位設定為 \\(0\\) ；從第二個位元組開始，將每個位元組的高 2 位都設定為 \\(10\\) ；其餘所有位用於填充字元的 Unicode 碼點。</li> </ul> <p>圖 3-8 展示了“Hello演算法”對應的 UTF-8 編碼。觀察發現，由於最高 \\(n\\) 位都設定為 \\(1\\) ，因此系統可以透過讀取最高位 \\(1\\) 的個數來解析出字元的長度為 \\(n\\) 。</p> <p>但為什麼要將其餘所有位元組的高 2 位都設定為 \\(10\\) 呢？實際上，這個 \\(10\\) 能夠起到校驗符的作用。假設系統從一個錯誤的位元組開始解析文字，位元組頭部的 \\(10\\) 能夠幫助系統快速判斷出異常。</p> <p>之所以將 \\(10\\) 當作校驗符，是因為在 UTF-8 編碼規則下，不可能有字元的最高兩位是 \\(10\\) 。這個結論可以用反證法來證明：假設一個字元的最高兩位是 \\(10\\) ，說明該字元的長度為 \\(1\\) ，對應 ASCII 碼。而 ASCII 碼的最高位應該是 \\(0\\) ，與假設矛盾。</p> <p></p> <p> 圖 3-8   UTF-8 編碼示例 </p> <p>除了 UTF-8 之外，常見的編碼方式還包括以下兩種。</p> <ul> <li>UTF-16 編碼：使用 2 或 4 位元組來表示一個字元。所有的 ASCII 字元和常用的非英文字元，都用 2 位元組表示；少數字符需要用到 4 位元組表示。對於 2 位元組的字元，UTF-16 編碼與 Unicode 碼點相等。</li> <li>UTF-32 編碼：每個字元都使用 4 位元組。這意味著 UTF-32 比 UTF-8 和 UTF-16 更佔用空間，特別是對於 ASCII 字元佔比較高的文字。</li> </ul> <p>從儲存空間佔用的角度看，使用 UTF-8 表示英文字元非常高效，因為它僅需 1 位元組；使用 UTF-16 編碼某些非英文字元（例如中文）會更加高效，因為它僅需 2 位元組，而 UTF-8 可能需要 3 位元組。</p> <p>從相容性的角度看，UTF-8 的通用性最佳，許多工具和庫優先支持 UTF-8 。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/character_encoding/#345","level":2,"title":"3.4.5   程式語言的字元編碼","text":"<p>對於以往的大多數程式語言，程式執行中的字串都採用 UTF-16 或 UTF-32 這類等長編碼。在等長編碼下，我們可以將字串看作陣列來處理，這種做法具有以下優點。</p> <ul> <li>隨機訪問：UTF-16 編碼的字串可以很容易地進行隨機訪問。UTF-8 是一種變長編碼，要想找到第 \\(i\\) 個字元，我們需要從字串的開始處走訪到第 \\(i\\) 個字元，這需要 \\(O(n)\\) 的時間。</li> <li>字元計數：與隨機訪問類似，計算 UTF-16 編碼的字串的長度也是 \\(O(1)\\) 的操作。但是，計算 UTF-8 編碼的字串的長度需要走訪整個字串。</li> <li>字串操作：在 UTF-16 編碼的字串上，很多字串操作（如分割、連線、插入、刪除等）更容易進行。在 UTF-8 編碼的字串上，進行這些操作通常需要額外的計算，以確保不會產生無效的 UTF-8 編碼。</li> </ul> <p>實際上，程式語言的字元編碼方案設計是一個很有趣的話題，涉及許多因素。</p> <ul> <li>Java 的 <code>String</code> 型別使用 UTF-16 編碼，每個字元佔用 2 位元組。這是因為 Java 語言設計之初，人們認為 16 位足以表示所有可能的字元。然而，這是一個不正確的判斷。後來 Unicode 規範擴展到了超過 16 位，所以 Java 中的字元現在可能由一對 16 位的值（稱為“代理對”）表示。</li> <li>JavaScript 和 TypeScript 的字串使用 UTF-16 編碼的原因與 Java 類似。當 1995 年 Netscape 公司首次推出 JavaScript 語言時，Unicode 還處於發展早期，那時候使用 16 位的編碼就足以表示所有的 Unicode 字元了。</li> <li>C# 使用 UTF-16 編碼，主要是因為 .NET 平臺是由 Microsoft 設計的，而 Microsoft 的很多技術（包括 Windows 作業系統）都廣泛使用 UTF-16 編碼。</li> </ul> <p>由於以上程式語言對字元數量的低估，它們不得不採取“代理對”的方式來表示超過 16 位長度的 Unicode 字元。這是一個不得已為之的無奈之舉。一方面，包含代理對的字串中，一個字元可能佔用 2 位元組或 4 位元組，從而喪失了等長編碼的優勢。另一方面，處理代理對需要額外增加程式碼，這提高了程式設計的複雜性和除錯難度。</p> <p>出於以上原因，部分程式語言提出了一些不同的編碼方案。</p> <ul> <li>Python 中的 <code>str</code> 使用 Unicode 編碼，並採用一種靈活的字串表示，儲存的字元長度取決於字串中最大的 Unicode 碼點。若字串中全部是 ASCII 字元，則每個字元佔用 1 位元組；如果有字元超出了 ASCII 範圍，但全部在基本多語言平面（BMP）內，則每個字元佔用 2 位元組；如果有超出 BMP 的字元，則每個字元佔用 4 位元組。</li> <li>Go 語言的 <code>string</code> 型別在內部使用 UTF-8 編碼。Go 語言還提供了 <code>rune</code> 型別，它用於表示單個 Unicode 碼點。</li> <li>Rust 語言的 <code>str</code> 和 <code>String</code> 型別在內部使用 UTF-8 編碼。Rust 也提供了 <code>char</code> 型別，用於表示單個 Unicode 碼點。</li> </ul> <p>需要注意的是，以上討論的都是字串在程式語言中的儲存方式，這和字串如何在檔案中儲存或在網路中傳輸是不同的問題。在檔案儲存或網路傳輸中，我們通常會將字串編碼為 UTF-8 格式，以達到最優的相容性和空間效率。</p>","path":["第 3 章 &nbsp; 資料結構","3.4 &nbsp; 字元編碼 *"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/","level":1,"title":"3.1   資料結構分類","text":"<p>常見的資料結構包括陣列、鏈結串列、堆疊、佇列、雜湊表、樹、堆積、圖，它們可以從“邏輯結構”和“物理結構”兩個維度進行分類。</p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#311","level":2,"title":"3.1.1   邏輯結構：線性與非線性","text":"<p>邏輯結構揭示了資料元素之間的邏輯關係。在陣列和鏈結串列中，資料按照一定順序排列，體現了資料之間的線性關係；而在樹中，資料從頂部向下按層次排列，表現出“祖先”與“後代”之間的派生關係；圖則由節點和邊構成，反映了複雜的網路關係。</p> <p>如圖 3-1 所示，邏輯結構可分為“線性”和“非線性”兩大類。線性結構比較直觀，指資料在邏輯關係上呈線性排列；非線性結構則相反，呈非線性排列。</p> <ul> <li>線性資料結構：陣列、鏈結串列、堆疊、佇列、雜湊表，元素之間是一對一的順序關係。</li> <li>非線性資料結構：樹、堆積、圖、雜湊表。</li> </ul> <p>非線性資料結構可以進一步劃分為樹形結構和網狀結構。</p> <ul> <li>樹形結構：樹、堆積、雜湊表，元素之間是一對多的關係。</li> <li>網狀結構：圖，元素之間是多對多的關係。</li> </ul> <p></p> <p> 圖 3-1   線性資料結構與非線性資料結構 </p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/classification_of_data_structure/#312","level":2,"title":"3.1.2   物理結構：連續與分散","text":"<p>當演算法程式執行時，正在處理的資料主要儲存在記憶體中。圖 3-2 展示了一個計算機記憶體條，其中每個黑色方塊都包含一塊記憶體空間。我們可以將記憶體想象成一個巨大的 Excel 表格，其中每個單元格都可以儲存一定大小的資料。</p> <p>系統透過記憶體位址來訪問目標位置的資料。如圖 3-2 所示，計算機根據特定規則為表格中的每個單元格分配編號，確保每個記憶體空間都有唯一的記憶體位址。有了這些位址，程式便可以訪問記憶體中的資料。</p> <p></p> <p> 圖 3-2   記憶體條、記憶體空間、記憶體位址 </p> <p>Tip</p> <p>值得說明的是，將記憶體比作 Excel 表格是一個簡化的類比，實際記憶體的工作機制比較複雜，涉及位址空間、記憶體管理、快取機制、虛擬記憶體和物理記憶體等概念。</p> <p>記憶體是所有程式的共享資源，當某塊記憶體被某個程式佔用時，則通常無法被其他程式同時使用了。因此在資料結構與演算法的設計中，記憶體資源是一個重要的考慮因素。比如，演算法所佔用的記憶體峰值不應超過系統剩餘空閒記憶體；如果缺少連續大塊的記憶體空間，那麼所選用的資料結構必須能夠儲存在分散的記憶體空間內。</p> <p>如圖 3-3 所示，物理結構反映了資料在計算機記憶體中的儲存方式，可分為連續空間儲存（陣列）和分散空間儲存（鏈結串列）。物理結構從底層決定了資料的訪問、更新、增刪等操作方法，兩種物理結構在時間效率和空間效率方面呈現出互補的特點。</p> <p></p> <p> 圖 3-3   連續空間儲存與分散空間儲存 </p> <p>值得說明的是，所有資料結構都是基於陣列、鏈結串列或二者的組合實現的。例如，堆疊和佇列既可以使用陣列實現，也可以使用鏈結串列實現；而雜湊表的實現可能同時包含陣列和鏈結串列。</p> <ul> <li>基於陣列可實現：堆疊、佇列、雜湊表、樹、堆積、圖、矩陣、張量（維度 \\(\\geq 3\\) 的陣列）等。</li> <li>基於鏈結串列可實現：堆疊、佇列、雜湊表、樹、堆積、圖等。</li> </ul> <p>鏈結串列在初始化後，仍可以在程式執行過程中對其長度進行調整，因此也稱“動態資料結構”。陣列在初始化後長度不可變，因此也稱“靜態資料結構”。值得注意的是，陣列可透過重新分配記憶體實現長度變化，從而具備一定的“動態性”。</p> <p>Tip</p> <p>如果你感覺物理結構理解起來有困難，建議先閱讀下一章，然後再回顧本節內容。</p>","path":["第 3 章 &nbsp; 資料結構","3.1 &nbsp; 資料結構分類"],"tags":[]},{"location":"chapter_data_structure/number_encoding/","level":1,"title":"3.3   數字編碼 *","text":"<p>Tip</p> <p>在本書中，標題帶有 * 符號的是選讀章節。如果你時間有限或感到理解困難，可以先跳過，等學完必讀章節後再單獨攻克。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#331","level":2,"title":"3.3.1   原碼、一補數和二補數","text":"<p>在上一節的表格中我們發現，所有整數型別能夠表示的負數都比正數多一個，例如 <code>byte</code> 的取值範圍是 \\([-128, 127]\\) 。這個現象比較反直覺，它的內在原因涉及原碼、一補數、二補數的相關知識。</p> <p>首先需要指出，數字是以“二補數”的形式儲存在計算機中的。在分析這樣做的原因之前，首先給出三者的定義。</p> <ul> <li>原碼：我們將數字的二進位制表示的最高位視為符號位，其中 \\(0\\) 表示正數，\\(1\\) 表示負數，其餘位表示數字的值。</li> <li>一補數：正數的一補數與其原碼相同，負數的一補數是對其原碼除符號位外的所有位取反。</li> <li>二補數：正數的二補數與其原碼相同，負數的二補數是在其一補數的基礎上加 \\(1\\) 。</li> </ul> <p>圖 3-4 展示了原碼、一補數和二補數之間的轉換方法。</p> <p></p> <p> 圖 3-4   原碼、一補數與二補數之間的相互轉換 </p> <p>原碼（sign-magnitude）雖然最直觀，但存在一些侷限性。一方面，負數的原碼不能直接用於運算。例如在原碼下計算 \\(1 + (-2)\\) ，得到的結果是 \\(-3\\) ，這顯然是不對的。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline &amp; = 1000 \\; 0011 \\newline &amp; \\rightarrow -3 \\end{aligned} \\] <p>為了解決此問題，計算機引入了一補數（1's complement）。如果我們先將原碼轉換為一補數，並在一補數下計算 \\(1 + (-2)\\) ，最後將結果從一補數轉換回原碼，則可得到正確結果 \\(-1\\) 。</p> \\[ \\begin{aligned} &amp; 1 + (-2) \\newline &amp; \\rightarrow 0000 \\; 0001 \\; \\text{(原碼)} + 1000 \\; 0010 \\; \\text{(原碼)} \\newline &amp; = 0000 \\; 0001 \\; \\text{(一補數)} + 1111  \\; 1101 \\; \\text{(一補數)} \\newline &amp; = 1111 \\; 1110 \\; \\text{(一補數)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(原碼)} \\newline &amp; \\rightarrow -1 \\end{aligned} \\] <p>另一方面，數字零的原碼有 \\(+0\\) 和 \\(-0\\) 兩種表示方式。這意味著數字零對應兩個不同的二進位制編碼，這可能會帶來歧義。比如在條件判斷中，如果沒有區分正零和負零，則可能會導致判斷結果出錯。而如果我們想處理正零和負零歧義，則需要引入額外的判斷操作，這可能會降低計算機的運算效率。</p> \\[ \\begin{aligned} +0 &amp; \\rightarrow 0000 \\; 0000 \\newline -0 &amp; \\rightarrow 1000 \\; 0000 \\end{aligned} \\] <p>與原碼一樣，一補數也存在正負零歧義問題，因此計算機進一步引入了二補數（2's complement）。我們先來觀察一下負零的原碼、一補數、二補數的轉換過程：</p> \\[ \\begin{aligned} -0 \\rightarrow \\; &amp; 1000 \\; 0000 \\; \\text{(原碼)} \\newline = \\; &amp; 1111 \\; 1111 \\; \\text{(一補數)} \\newline = 1 \\; &amp; 0000 \\; 0000 \\; \\text{(二補數)} \\newline \\end{aligned} \\] <p>在負零的一補數基礎上加 \\(1\\) 會產生進位，但 <code>byte</code> 型別的長度只有 8 位，因此溢位到第 9 位的 \\(1\\) 會被捨棄。也就是說，負零的二補數為 \\(0000 \\; 0000\\) ，與正零的二補數相同。這意味著在二補數表示中只存在一個零，正負零歧義從而得到解決。</p> <p>還剩最後一個疑惑：<code>byte</code> 型別的取值範圍是 \\([-128, 127]\\) ，多出來的一個負數 \\(-128\\) 是如何得到的呢？我們注意到，區間 \\([-127, +127]\\) 內的所有整數都有對應的原碼、一補數和二補數，並且原碼和二補數之間可以互相轉換。</p> <p>然而，二補數 \\(1000 \\; 0000\\) 是一個例外，它並沒有對應的原碼。根據轉換方法，我們得到該二補數的原碼為 \\(0000 \\; 0000\\) 。這顯然是矛盾的，因為該原碼表示數字 \\(0\\) ，它的二補數應該是自身。計算機規定這個特殊的二補數 \\(1000 \\; 0000\\) 代表 \\(-128\\) 。實際上，\\((-1) + (-127)\\) 在二補數下的計算結果就是 \\(-128\\) 。</p> \\[ \\begin{aligned} &amp; (-127) + (-1) \\newline &amp; \\rightarrow 1111 \\; 1111 \\; \\text{(原碼)} + 1000 \\; 0001 \\; \\text{(原碼)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(一補數)} + 1111  \\; 1110 \\; \\text{(一補數)} \\newline &amp; = 1000 \\; 0001 \\; \\text{(二補數)} + 1111  \\; 1111 \\; \\text{(二補數)} \\newline &amp; = 1000 \\; 0000 \\; \\text{(二補數)} \\newline &amp; \\rightarrow -128 \\end{aligned} \\] <p>你可能已經發現了，上述所有計算都是加法運算。這暗示著一個重要事實：計算機內部的硬體電路主要是基於加法運算設計的。這是因為加法運算相對於其他運算（比如乘法、除法和減法）來說，硬體實現起來更簡單，更容易進行並行化處理，運算速度更快。</p> <p>請注意，這並不意味著計算機只能做加法。透過將加法與一些基本邏輯運算結合，計算機能夠實現各種其他的數學運算。例如，計算減法 \\(a - b\\) 可以轉換為計算加法 \\(a + (-b)\\) ；計算乘法和除法可以轉換為計算多次加法或減法。</p> <p>現在我們可以總結出計算機使用二補數的原因：基於二補數表示，計算機可以用同樣的電路和操作來處理正數和負數的加法，不需要設計特殊的硬體電路來處理減法，並且無須特別處理正負零的歧義問題。這大大簡化了硬體設計，提高了運算效率。</p> <p>二補數的設計非常精妙，因篇幅關係我們就先介紹到這裡，建議有興趣的讀者進一步深入瞭解。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/number_encoding/#332","level":2,"title":"3.3.2   浮點數編碼","text":"<p>細心的你可能會發現：<code>int</code> 和 <code>float</code> 長度相同，都是 4 位元組 ，但為什麼 <code>float</code> 的取值範圍遠大於 <code>int</code> ？這非常反直覺，因為按理說 <code>float</code> 需要表示小數，取值範圍應該變小才對。</p> <p>實際上，這是因為浮點數 <code>float</code> 採用了不同的表示方式。記一個 32 位元長度的二進位制數為：</p> \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\] <p>根據 IEEE 754 標準，32-bit 長度的 <code>float</code> 由以下三個部分構成。</p> <ul> <li>符號位 \\(\\mathrm{S}\\) ：佔 1 位 ，對應 \\(b_{31}\\) 。</li> <li>指數位 \\(\\mathrm{E}\\) ：佔 8 位 ，對應 \\(b_{30} b_{29} \\ldots b_{23}\\) 。</li> <li>分數位 \\(\\mathrm{N}\\) ：佔 23 位 ，對應 \\(b_{22} b_{21} \\ldots b_0\\) 。</li> </ul> <p>二進位制數 <code>float</code> 對應值的計算方法為：</p> \\[ \\text {val} = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\] <p>轉化到十進位制下的計算公式為：</p> \\[ \\text {val}=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\] <p>其中各項的取值範圍為：</p> \\[ \\begin{aligned} \\mathrm{S} \\in &amp; \\{ 0, 1\\}, \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = &amp; (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\] <p></p> <p> 圖 3-5   IEEE 754 標準下的 float 的計算示例 </p> <p>觀察圖 3-5 ，給定一個示例資料 \\(\\mathrm{S} = 0\\) ， \\(\\mathrm{E} = 124\\) ，\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) ，則有：</p> \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\] <p>現在我們可以回答最初的問題：<code>float</code> 的表示方式包含指數位，導致其取值範圍遠大於 <code>int</code> 。根據以上計算，<code>float</code> 可表示的最大正數為 \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) ，切換符號位便可得到最小負數。</p> <p>儘管浮點數 <code>float</code> 擴展了取值範圍，但其副作用是犧牲了精度。整數型別 <code>int</code> 將全部 32 位元用於表示數字，數字是均勻分佈的；而由於指數位的存在，浮點數 <code>float</code> 的數值越大，相鄰兩個數字之間的差值就會趨向越大。</p> <p>如表 3-2 所示，指數位 \\(\\mathrm{E} = 0\\) 和 \\(\\mathrm{E} = 255\\) 具有特殊含義，用於表示零、無窮大、\\(\\mathrm{NaN}\\) 等。</p> <p> 表 3-2   指數位含義 </p> 指數位 E 分數位 \\(\\mathrm{N} = 0\\) 分數位 \\(\\mathrm{N} \\ne 0\\) 計算公式 \\(0\\) \\(\\pm 0\\) 次正規數 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) 正規數 正規數 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\) <p>值得說明的是，次正規數顯著提升了浮點數的精度。最小正正規數為 \\(2^{-126}\\) ，最小正次正規數為 \\(2^{-126} \\times 2^{-23}\\) 。</p> <p>雙精度 <code>double</code> 也採用類似於 <code>float</code> 的表示方法，在此不做贅述。</p>","path":["第 3 章 &nbsp; 資料結構","3.3 &nbsp; 數字編碼 *"],"tags":[]},{"location":"chapter_data_structure/summary/","level":1,"title":"3.5   小結","text":"","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_data_structure/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>資料結構可以從邏輯結構和物理結構兩個角度進行分類。邏輯結構描述了資料元素之間的邏輯關係，而物理結構描述了資料在計算機記憶體中的儲存方式。</li> <li>常見的邏輯結構包括線性、樹狀和網狀等。通常我們根據邏輯結構將資料結構分為線性（陣列、鏈結串列、堆疊、佇列）和非線性（樹、圖、堆積）兩種。雜湊表的實現可能同時包含線性資料結構和非線性資料結構。</li> <li>當程式執行時，資料被儲存在計算機記憶體中。每個記憶體空間都擁有對應的記憶體位址，程式透過這些記憶體位址訪問資料。</li> <li>物理結構主要分為連續空間儲存（陣列）和分散空間儲存（鏈結串列）。所有資料結構都是由陣列、鏈結串列或兩者的組合實現的。</li> <li>計算機中的基本資料型別包括整數 <code>byte</code>、<code>short</code>、<code>int</code>、<code>long</code> ，浮點數 <code>float</code>、<code>double</code> ，字元 <code>char</code> 和布林 <code>bool</code> 。它們的取值範圍取決於佔用空間大小和表示方式。</li> <li>原碼、一補數和二補數是在計算機中編碼數字的三種方法，它們之間可以相互轉換。整數的原碼的最高位是符號位，其餘位是數字的值。</li> <li>整數在計算機中是以二補數的形式儲存的。在二補數表示下，計算機可以對正數和負數的加法一視同仁，不需要為減法操作單獨設計特殊的硬體電路，並且不存在正負零歧義的問題。</li> <li>浮點數的編碼由 1 位符號位、8 位指數位和 23 位分數位構成。由於存在指數位，因此浮點數的取值範圍遠大於整數，代價是犧牲了精度。</li> <li>ASCII 碼是最早出現的英文字元集，長度為 1 位元組，共收錄 127 個字元。GBK 字元集是常用的中文字元集，共收錄兩萬多個漢字。Unicode 致力於提供一個完整的字元集標準，收錄世界上各種語言的字元，從而解決由於字元編碼方法不一致而導致的亂碼問題。</li> <li>UTF-8 是最受歡迎的 Unicode 編碼方法，通用性非常好。它是一種變長的編碼方法，具有很好的擴展性，有效提升了儲存空間的使用效率。UTF-16 和 UTF-32 是等長的編碼方法。在編碼中文時，UTF-16 佔用的空間比 UTF-8 更小。Java 和 C# 等程式語言預設使用 UTF-16 編碼。</li> </ul>","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_data_structure/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：為什麼雜湊表同時包含線性資料結構和非線性資料結構？</p> <p>雜湊表底層是陣列，而為了解決雜湊衝突，我們可能會使用“鏈式位址”（後續“雜湊衝突”章節會講）：陣列中每個桶指向一個鏈結串列，當鏈結串列長度超過一定閾值時，又可能被轉化為樹（通常為紅黑樹）。</p> <p>從儲存的角度來看，雜湊表的底層是陣列，其中每一個桶槽位可能包含一個值，也可能包含一個鏈結串列或一棵樹。因此，雜湊表可能同時包含線性資料結構（陣列、鏈結串列）和非線性資料結構（樹）。</p> <p>Q：<code>char</code> 型別的長度是 1 位元組嗎？</p> <p><code>char</code> 型別的長度由程式語言採用的編碼方法決定。例如，Java、JavaScript、TypeScript、C# 都採用 UTF-16 編碼（儲存 Unicode 碼點），因此 <code>char</code> 型別的長度為 2 位元組。</p> <p>Q：基於陣列實現的資料結構也稱“靜態資料結構” 是否有歧義？堆疊也可以進行出堆疊和入堆疊等操作，這些操作都是“動態”的。</p> <p>堆疊確實可以實現動態的資料操作，但資料結構仍然是“靜態”（長度不可變）的。儘管基於陣列的資料結構可以動態地新增或刪除元素，但它們的容量是固定的。如果資料量超出了預分配的大小，就需要建立一個新的更大的陣列，並將舊陣列的內容複製到新陣列中。</p> <p>Q：在構建堆疊（佇列）的時候，未指定它的大小，為什麼它們是“靜態資料結構”呢？</p> <p>在高階程式語言中，我們無須人工指定堆疊（佇列）的初始容量，這個工作由類別內部自動完成。例如，Java 的 <code>ArrayList</code> 的初始容量通常為 10。另外，擴容操作也是自動實現的。詳見後續的“串列”章節。</p> <p>Q：原碼轉二補數的方法是“先取反後加 1”，那麼二補數轉原碼應該是逆運算“先減 1 後取反”，而二補數轉原碼也一樣可以透過“先取反後加 1”得到，這是為什麼呢？</p> <p>這是因為原碼和二補數的相互轉換實際上是計算“補數”的過程。我們先給出補數的定義：假設 \\(a + b = c\\) ，那麼我們稱 \\(a\\) 是 \\(b\\) 到 \\(c\\) 的補數，反之也稱 \\(b\\) 是 \\(a\\) 到 \\(c\\) 的補數。</p> <p>給定一個 \\(n = 4\\) 位長度的二進位制數 \\(0010\\) ，如果將這個數字看作原碼（不考慮符號位），那麼它的二補數需透過“先取反後加 1”得到：</p> \\[ 0010 \\rightarrow 1101 \\rightarrow 1110 \\] <p>我們會發現，原碼和二補數的和是 \\(0010 + 1110 = 10000\\) ，也就是說，二補數 \\(1110\\) 是原碼 \\(0010\\) 到 \\(10000\\) 的“補數”。這意味著上述“先取反後加 1”實際上是計算到 \\(10000\\) 的補數的過程。</p> <p>那麼，二補數 \\(1110\\) 到 \\(10000\\) 的“補數”是多少呢？我們依然可以用“先取反後加 1”得到它：</p> \\[ 1110 \\rightarrow 0001 \\rightarrow 0010 \\] <p>換句話說，原碼和二補數互為對方到 \\(10000\\) 的“補數”，因此“原碼轉二補數”和“二補數轉原碼”可以用相同的操作（先取反後加 1 ）實現。</p> <p>當然，我們也可以用逆運算來求二補數 \\(1110\\) 的原碼，即“先減 1 後取反”：</p> \\[ 1110 \\rightarrow 1101 \\rightarrow 0010 \\] <p>總結來看，“先取反後加 1”和“先減 1 後取反”這兩種運算都是在計算到 \\(10000\\) 的補數，它們是等價的。</p> <p>本質上看，“取反”操作實際上是求到 \\(1111\\) 的補數（因為恆有 <code>原碼 + 一補數 = 1111</code>）；而在一補數基礎上再加 1 得到的二補數，就是到 \\(10000\\) 的補數。</p> <p>上述以 \\(n = 4\\) 為例，其可被推廣至任意位數的二進位制數。</p>","path":["第 3 章 &nbsp; 資料結構","3.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_divide_and_conquer/","level":1,"title":"第 12 章   分治","text":"<p>Abstract</p> <p>難題被逐層拆解，每一次的拆解都使它變得更為簡單。</p> <p>分而治之揭示了一個重要的事實：從簡單做起，一切都不再複雜。</p>","path":["第 12 章 &nbsp; 分治"],"tags":[]},{"location":"chapter_divide_and_conquer/#_1","level":2,"title":"本章內容","text":"<ul> <li>12.1   分治演算法</li> <li>12.2   分治搜尋策略</li> <li>12.3   構建樹問題</li> <li>12.4   河內塔問題</li> <li>12.5   小結</li> </ul>","path":["第 12 章 &nbsp; 分治"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/","level":1,"title":"12.2   分治搜尋策略","text":"<p>我們已經學過，搜尋演算法分為兩大類。</p> <ul> <li>暴力搜尋：它透過走訪資料結構實現，時間複雜度為 \\(O(n)\\) 。</li> <li>自適應搜尋：它利用特有的資料組織形式或先驗資訊，時間複雜度可達到 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 。</li> </ul> <p>實際上，時間複雜度為 \\(O(\\log n)\\) 的搜尋演算法通常是基於分治策略實現的，例如二分搜尋和樹。</p> <ul> <li>二分搜尋的每一步都將問題（在陣列中搜索目標元素）分解為一個小問題（在陣列的一半中搜索目標元素），這個過程一直持續到陣列為空或找到目標元素為止。</li> <li>樹是分治思想的代表，在二元搜尋樹、AVL 樹、堆積等資料結構中，各種操作的時間複雜度皆為 \\(O(\\log n)\\) 。</li> </ul> <p>二分搜尋的分治策略如下所示。</p> <ul> <li>問題可以分解：二分搜尋遞迴地將原問題（在陣列中進行查詢）分解為子問題（在陣列的一半中進行查詢），這是透過比較中間元素和目標元素來實現的。</li> <li>子問題是獨立的：在二分搜尋中，每輪只處理一個子問題，它不受其他子問題的影響。</li> <li>子問題的解無須合併：二分搜尋旨在查詢一個特定元素，因此不需要將子問題的解進行合併。當子問題得到解決時，原問題也會同時得到解決。</li> </ul> <p>分治能夠提升搜尋效率，本質上是因為暴力搜尋每輪只能排除一個選項，而分治搜尋每輪可以排除一半選項。</p>","path":["第 12 章 &nbsp; 分治","12.2 &nbsp; 分治搜尋策略"],"tags":[]},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","level":3,"title":"1.   基於分治實現二分搜尋","text":"<p>在之前的章節中，二分搜尋是基於遞推（迭代）實現的。現在我們基於分治（遞迴）來實現它。</p> <p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> ，其中所有元素都是唯一的，請查詢元素 <code>target</code> 。</p> <p>從分治角度，我們將搜尋區間 \\([i, j]\\) 對應的子問題記為 \\(f(i, j)\\) 。</p> <p>以原問題 \\(f(0, n-1)\\) 為起始點，透過以下步驟進行二分搜尋。</p> <ol> <li>計算搜尋區間 \\([i, j]\\) 的中點 \\(m\\) ，根據它排除一半搜尋區間。</li> <li>遞迴求解規模減小一半的子問題，可能為 \\(f(i, m-1)\\) 或 \\(f(m+1, j)\\) 。</li> <li>迴圈第 <code>1.</code> 步和第 <code>2.</code> 步，直至找到 <code>target</code> 或區間為空時返回。</li> </ol> <p>圖 12-4 展示了在陣列中二分搜尋元素 \\(6\\) 的分治過程。</p> <p></p> <p> 圖 12-4   二分搜尋的分治過程 </p> <p>在實現程式碼中，我們宣告一個遞迴函式 <code>dfs()</code> 來求解問題 \\(f(i, j)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_recur.py<pre><code>def dfs(nums: list[int], target: int, i: int, j: int) -&gt; int:\n    \"\"\"二分搜尋：問題 f(i, j)\"\"\"\n    # 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j:\n        return -1\n    # 計算中點索引 m\n    m = (i + j) // 2\n    if nums[m] &lt; target:\n        # 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] &gt; target:\n        # 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # 找到目標元素，返回其索引\n        return m\n\ndef binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋\"\"\"\n    n = len(nums)\n    # 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n</code></pre> binary_search_recur.cpp<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(vector&lt;int&gt; &amp;nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    int n = nums.size();\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.java<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.cs<pre><code>/* 二分搜尋：問題 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // 求解問題 f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.go<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // 如果區間為空，代表沒有目標元素，則返回 -1\n    if i &gt; j {\n        return -1\n    }\n    //    計算索引中點\n    m := i + ((j - i) &gt;&gt; 1)\n    //判斷中點與目標元素大小\n    if nums[m] &lt; target {\n        // 小於則遞迴右半陣列\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] &gt; target {\n        // 大於則遞迴左半陣列\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // 找到目標元素，返回其索引\n        return m\n    }\n}\n\n/* 二分搜尋 */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n</code></pre> binary_search_recur.swift<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -&gt; Int {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j {\n        return -1\n    }\n    // 計算中點索引 m\n    let m = (i + j) / 2\n    if nums[m] &lt; target {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] &gt; target {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // 找到目標元素，返回其索引\n        return m\n    }\n}\n\n/* 二分搜尋 */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 求解問題 f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n</code></pre> binary_search_recur.js<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.ts<pre><code>/* 二分搜尋：問題 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    const m = i + ((j - i) &gt;&gt; 1);\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.dart<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(List&lt;int&gt; nums, int target, int i, int j) {\n  // 若區間為空，代表無目標元素，則返回 -1\n  if (i &gt; j) {\n    return -1;\n  }\n  // 計算中點索引 m\n  int m = (i + j) ~/ 2;\n  if (nums[m] &lt; target) {\n    // 遞迴子問題 f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] &gt; target) {\n    // 遞迴子問題 f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // 找到目標元素，返回其索引\n    return m;\n  }\n}\n\n/* 二分搜尋 */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  int n = nums.length;\n  // 求解問題 f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.rs<pre><code>/* 二分搜尋：問題 f(i, j) */\nfn dfs(nums: &amp;[i32], target: i32, i: i32, j: i32) -&gt; i32 {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if i &gt; j {\n        return -1;\n    }\n    let m: i32 = i + (j - i) / 2;\n    if nums[m as usize] &lt; target {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] &gt; target {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let n = nums.len() as i32;\n    // 求解問題 f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.c<pre><code>/* 二分搜尋：問題 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1;\n    }\n    // 計算中點索引 m\n    int m = (i + j) / 2;\n    if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // 找到目標元素，返回其索引\n        return m;\n    }\n}\n\n/* 二分搜尋 */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n</code></pre> binary_search_recur.kt<pre><code>/* 二分搜尋：問題 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // 若區間為空，代表無目標元素，則返回 -1\n    if (i &gt; j) {\n        return -1\n    }\n    // 計算中點索引 m\n    val m = (i + j) / 2\n    return if (nums[m] &lt; target) {\n        // 遞迴子問題 f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] &gt; target) {\n        // 遞迴子問題 f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // 找到目標元素，返回其索引\n        m\n    }\n}\n\n/* 二分搜尋 */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // 求解問題 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n</code></pre> binary_search_recur.rb<pre><code>### 二分搜尋：問題 f(i, j) ###\ndef dfs(nums, target, i, j)\n  # 若區間為空，代表無目標元素，則返回 -1\n  return -1 if i &gt; j\n\n  # 計算中點索引 m\n  m = (i + j) / 2\n\n  if nums[m] &lt; target\n    # 遞迴子問題 f(m+1, j)\n    return dfs(nums, target, m + 1, j)\n  elsif nums[m] &gt; target\n    # 遞迴子問題 f(i, m-1)\n    return dfs(nums, target, i, m - 1)\n  else\n    # 找到目標元素，返回其索引\n    return m\n  end\nend\n\n### 二分搜尋 ###\ndef binary_search(nums, target)\n  n = nums.length\n  # 求解問題 f(0, n-1)\n  dfs(nums, target, 0, n - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 12 章 &nbsp; 分治","12.2 &nbsp; 分治搜尋策略"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","level":1,"title":"12.3   構建二元樹問題","text":"<p>Question</p> <p>給定一棵二元樹的前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> ，請從中構建二元樹，返回二元樹的根節點。假設二元樹中沒有值重複的節點（如圖 12-5 所示）。</p> <p></p> <p> 圖 12-5   構建二元樹的示例資料 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","level":3,"title":"1.   判斷是否為分治問題","text":"<p>原問題定義為從 <code>preorder</code> 和 <code>inorder</code> 構建二元樹，是一個典型的分治問題。</p> <ul> <li>問題可以分解：從分治的角度切入，我們可以將原問題劃分為兩個子問題：構建左子樹、構建右子樹，加上一步操作：初始化根節點。而對於每棵子樹（子問題），我們仍然可以複用以上劃分方法，將其劃分為更小的子樹（子問題），直至達到最小子問題（空子樹）時終止。</li> <li>子問題是獨立的：左子樹和右子樹是相互獨立的，它們之間沒有交集。在構建左子樹時，我們只需關注中序走訪和前序走訪中與左子樹對應的部分。右子樹同理。</li> <li>子問題的解可以合併：一旦得到了左子樹和右子樹（子問題的解），我們就可以將它們連結到根節點上，得到原問題的解。</li> </ul>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","level":3,"title":"2.   如何劃分子樹","text":"<p>根據以上分析，這道題可以使用分治來求解，但如何透過前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> 來劃分左子樹和右子樹呢？</p> <p>根據定義，<code>preorder</code> 和 <code>inorder</code> 都可以劃分為三個部分。</p> <ul> <li>前序走訪：<code>[ 根節點 | 左子樹 | 右子樹 ]</code> ，例如圖 12-5 的樹對應 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li> <li>中序走訪：<code>[ 左子樹 | 根節點 ｜ 右子樹 ]</code> ，例如圖 12-5 的樹對應 <code>[ 9 | 3 | 1 2 7 ]</code> 。</li> </ul> <p>以上圖資料為例，我們可以透過圖 12-6 所示的步驟得到劃分結果。</p> <ol> <li>前序走訪的首元素 3 是根節點的值。</li> <li>查詢根節點 3 在 <code>inorder</code> 中的索引，利用該索引可將 <code>inorder</code> 劃分為 <code>[ 9 | 3 ｜ 1 2 7 ]</code> 。</li> <li>根據 <code>inorder</code> 的劃分結果，易得左子樹和右子樹的節點數量分別為 1 和 3 ，從而可將 <code>preorder</code> 劃分為 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li> </ol> <p></p> <p> 圖 12-6   在前序走訪和中序走訪中劃分子樹 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","level":3,"title":"3.   基於變數描述子樹區間","text":"<p>根據以上劃分方法，我們已經得到根節點、左子樹、右子樹在 <code>preorder</code> 和 <code>inorder</code> 中的索引區間。而為了描述這些索引區間，我們需要藉助幾個指標變數。</p> <ul> <li>將當前樹的根節點在 <code>preorder</code> 中的索引記為 \\(i\\) 。</li> <li>將當前樹的根節點在 <code>inorder</code> 中的索引記為 \\(m\\) 。</li> <li>將當前樹在 <code>inorder</code> 中的索引區間記為 \\([l, r]\\) 。</li> </ul> <p>如表 12-1 所示，透過以上變數即可表示根節點在 <code>preorder</code> 中的索引，以及子樹在 <code>inorder</code> 中的索引區間。</p> <p> 表 12-1   根節點和子樹在前序走訪和中序走訪中的索引 </p> 根節點在 <code>preorder</code> 中的索引 子樹在 <code>inorder</code> 中的索引區間 當前樹 \\(i\\) \\([l, r]\\) 左子樹 \\(i + 1\\) \\([l, m-1]\\) 右子樹 \\(i + 1 + (m - l)\\) \\([m+1, r]\\) <p>請注意，右子樹根節點索引中的 \\((m-l)\\) 的含義是“左子樹的節點數量”，建議結合圖 12-7 理解。</p> <p></p> <p> 圖 12-7   根節點和左右子樹的索引區間表示 </p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","level":3,"title":"4.   程式碼實現","text":"<p>為了提升查詢 \\(m\\) 的效率，我們藉助一個雜湊表 <code>hmap</code> 來儲存陣列 <code>inorder</code> 中元素到索引的對映：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby build_tree.py<pre><code>def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -&gt; TreeNode | None:\n    \"\"\"構建二元樹：分治\"\"\"\n    # 子樹區間為空時終止\n    if r - l &lt; 0:\n        return None\n    # 初始化根節點\n    root = TreeNode(preorder[i])\n    # 查詢 m ，從而劃分左右子樹\n    m = inorder_map[preorder[i]]\n    # 子問題：構建左子樹\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # 子問題：構建右子樹\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # 返回根節點\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -&gt; TreeNode | None:\n    \"\"\"構建二元樹\"\"\"\n    # 初始化雜湊表，儲存 inorder 元素到索引的對映\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n</code></pre> build_tree.cpp<pre><code>/* 構建二元樹：分治 */\nTreeNode *dfs(vector&lt;int&gt; &amp;preorder, unordered_map&lt;int, int&gt; &amp;inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return NULL;\n    // 初始化根節點\n    TreeNode *root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode *buildTree(vector&lt;int&gt; &amp;preorder, vector&lt;int&gt; &amp;inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    unordered_map&lt;int, int&gt; inorderMap;\n    for (int i = 0; i &lt; inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n</code></pre> build_tree.java<pre><code>/* 構建二元樹：分治 */\nTreeNode dfs(int[] preorder, Map&lt;Integer, Integer&gt; inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return null;\n    // 初始化根節點\n    TreeNode root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    Map&lt;Integer, Integer&gt; inorderMap = new HashMap&lt;&gt;();\n    for (int i = 0; i &lt; inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.cs<pre><code>/* 構建二元樹：分治 */\nTreeNode? DFS(int[] preorder, Dictionary&lt;int, int&gt; inorderMap, int i, int l, int r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return null;\n    // 初始化根節點\n    TreeNode root = new(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    Dictionary&lt;int, int&gt; inorderMap = [];\n    for (int i = 0; i &lt; inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n</code></pre> build_tree.go<pre><code>/* 構建二元樹：分治 */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // 子樹區間為空時終止\n    if r-l &lt; 0 {\n        return nil\n    }\n    // 初始化根節點\n    root := NewTreeNode(preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    m := inorderMap[preorder[i]]\n    // 子問題：構建左子樹\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // 子問題：構建右子樹\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i &lt; len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n</code></pre> build_tree.swift<pre><code>/* 構建二元樹：分治 */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -&gt; TreeNode? {\n    // 子樹區間為空時終止\n    if r - l &lt; 0 {\n        return nil\n    }\n    // 初始化根節點\n    let root = TreeNode(x: preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    let m = inorderMap[preorder[i]]!\n    // 子問題：構建左子樹\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // 子問題：構建右子樹\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -&gt; TreeNode? {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n</code></pre> build_tree.js<pre><code>/* 構建二元樹：分治 */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null;\n    // 初始化根節點\n    const root = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    const m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nfunction buildTree(preorder, inorder) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = new Map();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.ts<pre><code>/* 構建二元樹：分治 */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map&lt;number, number&gt;,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null;\n    // 初始化根節點\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // 查詢 m ，從而劃分左右子樹\n    const m = inorderMap.get(preorder[i]);\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let inorderMap = new Map&lt;number, number&gt;();\n    for (let i = 0; i &lt; inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n</code></pre> build_tree.dart<pre><code>/* 構建二元樹：分治 */\nTreeNode? dfs(\n  List&lt;int&gt; preorder,\n  Map&lt;int, int&gt; inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // 子樹區間為空時終止\n  if (r - l &lt; 0) {\n    return null;\n  }\n  // 初始化根節點\n  TreeNode? root = TreeNode(preorder[i]);\n  // 查詢 m ，從而劃分左右子樹\n  int m = inorderMap[preorder[i]]!;\n  // 子問題：構建左子樹\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // 子問題：構建右子樹\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // 返回根節點\n  return root;\n}\n\n/* 構建二元樹 */\nTreeNode? buildTree(List&lt;int&gt; preorder, List&lt;int&gt; inorder) {\n  // 初始化雜湊表，儲存 inorder 元素到索引的對映\n  Map&lt;int, int&gt; inorderMap = {};\n  for (int i = 0; i &lt; inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n</code></pre> build_tree.rs<pre><code>/* 構建二元樹：分治 */\nfn dfs(\n    preorder: &amp;[i32],\n    inorder_map: &amp;HashMap&lt;i32, i32&gt;,\n    i: i32,\n    l: i32,\n    r: i32,\n) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 子樹區間為空時終止\n    if r - l &lt; 0 {\n        return None;\n    }\n    // 初始化根節點\n    let root = TreeNode::new(preorder[i as usize]);\n    // 查詢 m ，從而劃分左右子樹\n    let m = inorder_map.get(&amp;preorder[i as usize]).unwrap();\n    // 子問題：構建左子樹\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // 子問題：構建右子樹\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // 返回根節點\n    Some(root)\n}\n\n/* 構建二元樹 */\nfn build_tree(preorder: &amp;[i32], inorder: &amp;[i32]) -&gt; Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt; {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    let mut inorder_map: HashMap&lt;i32, i32&gt; = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &amp;inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n</code></pre> build_tree.c<pre><code>/* 構建二元樹：分治 */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0)\n        return NULL;\n    // 初始化根節點\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root-&gt;val = preorder[i];\n    root-&gt;left = NULL;\n    root-&gt;right = NULL;\n    // 查詢 m ，從而劃分左右子樹\n    int m = inorderMap[preorder[i]];\n    // 子問題：構建左子樹\n    root-&gt;left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // 子問題：構建右子樹\n    root-&gt;right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // 返回根節點\n    return root;\n}\n\n/* 構建二元樹 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i &lt; inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n</code></pre> build_tree.kt<pre><code>/* 構建二元樹：分治 */\nfun dfs(\n    preorder: IntArray,\n    inorderMap: Map&lt;Int?, Int?&gt;,\n    i: Int,\n    l: Int,\n    r: Int\n): TreeNode? {\n    // 子樹區間為空時終止\n    if (r - l &lt; 0) return null\n    // 初始化根節點\n    val root = TreeNode(preorder[i])\n    // 查詢 m ，從而劃分左右子樹\n    val m = inorderMap[preorder[i]]!!\n    // 子問題：構建左子樹\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // 子問題：構建右子樹\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // 返回根節點\n    return root\n}\n\n/* 構建二元樹 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // 初始化雜湊表，儲存 inorder 元素到索引的對映\n    val inorderMap = HashMap&lt;Int?, Int?&gt;()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n</code></pre> build_tree.rb<pre><code>### 構建二元樹：分治 ###\ndef dfs(preorder, inorder_map, i, l, r)\n  # 子樹區間為空時終止\n  return if r - l &lt; 0\n\n  # 初始化根節點\n  root = TreeNode.new(preorder[i])\n  # 查詢 m ，從而劃分左右子樹\n  m = inorder_map[preorder[i]]\n  # 子問題：構建左子樹\n  root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n  # 子問題：構建右子樹\n  root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n\n  # 返回根節點\n  root\nend\n\n### 構建二元樹 ###\ndef build_tree(preorder, inorder)\n  # 初始化雜湊表，儲存 inorder 元素到索引的對映\n  inorder_map = {}\n  inorder.each_with_index { |val, i| inorder_map[val] = i }\n  dfs(preorder, inorder_map, 0, 0, inorder.length - 1)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 12-8 展示了構建二元樹的遞迴過程，各個節點是在向下“遞”的過程中建立的，而各條邊（引用）是在向上“迴”的過程中建立的。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 12-8   構建二元樹的遞迴過程 </p> <p>每個遞迴函式內的前序走訪 <code>preorder</code> 和中序走訪 <code>inorder</code> 的劃分結果如圖 12-9 所示。</p> <p></p> <p> 圖 12-9   每個遞迴函式中的劃分結果 </p> <p>設樹的節點數量為 \\(n\\) ，初始化每一個節點（執行一個遞迴函式 <code>dfs()</code> ）使用 \\(O(1)\\) 時間。因此總體時間複雜度為 \\(O(n)\\) 。</p> <p>雜湊表儲存 <code>inorder</code> 元素到索引的對映，空間複雜度為 \\(O(n)\\) 。在最差情況下，即二元樹退化為鏈結串列時，遞迴深度達到 \\(n\\) ，使用 \\(O(n)\\) 的堆疊幀空間。因此總體空間複雜度為 \\(O(n)\\) 。</p>","path":["第 12 章 &nbsp; 分治","12.3 &nbsp; 構建二元樹問題"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/","level":1,"title":"12.1   分治演算法","text":"<p>分治（divide and conquer），全稱分而治之，是一種非常重要且常見的演算法策略。分治通常基於遞迴實現，包括“分”和“治”兩個步驟。</p> <ol> <li>分（劃分階段）：遞迴地將原問題分解為兩個或多個子問題，直至到達最小子問題時終止。</li> <li>治（合併階段）：從已知解的最小子問題開始，從底至頂地將子問題的解進行合併，從而構建出原問題的解。</li> </ol> <p>如圖 12-1 所示，“合併排序”是分治策略的典型應用之一。</p> <ol> <li>分：遞迴地將原陣列（原問題）劃分為兩個子陣列（子問題），直到子陣列只剩一個元素（最小子問題）。</li> <li>治：從底至頂地將有序的子陣列（子問題的解）進行合併，從而得到有序的原陣列（原問題的解）。</li> </ol> <p></p> <p> 圖 12-1   合併排序的分治策略 </p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","level":2,"title":"12.1.1   如何判斷分治問題","text":"<p>一個問題是否適合使用分治解決，通常可以參考以下幾個判斷依據。</p> <ol> <li>問題可以分解：原問題可以分解成規模更小、類似的子問題，以及能夠以相同方式遞迴地進行劃分。</li> <li>子問題是獨立的：子問題之間沒有重疊，互不依賴，可以獨立解決。</li> <li>子問題的解可以合併：原問題的解透過合併子問題的解得來。</li> </ol> <p>顯然，合併排序滿足以上三個判斷依據。</p> <ol> <li>問題可以分解：遞迴地將陣列（原問題）劃分為兩個子陣列（子問題）。</li> <li>子問題是獨立的：每個子陣列都可以獨立地進行排序（子問題可以獨立進行求解）。</li> <li>子問題的解可以合併：兩個有序子陣列（子問題的解）可以合併為一個有序陣列（原問題的解）。</li> </ol>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","level":2,"title":"12.1.2   透過分治提升效率","text":"<p>分治不僅可以有效地解決演算法問題，往往還可以提升演算法效率。在排序演算法中，快速排序、合併排序、堆積排序相較於選擇、冒泡、插入排序更快，就是因為它們應用了分治策略。</p> <p>那麼，我們不禁發問：為什麼分治可以提升演算法效率，其底層邏輯是什麼？換句話說，將大問題分解為多個子問題、解決子問題、將子問題的解合併為原問題的解，這幾步的效率為什麼比直接解決原問題的效率更高？這個問題可以從操作數量和平行計算兩方面來討論。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","level":3,"title":"1.   操作數量最佳化","text":"<p>以“泡沫排序”為例，其處理一個長度為 \\(n\\) 的陣列需要 \\(O(n^2)\\) 時間。假設我們按照圖 12-2 所示的方式，將陣列從中點處分為兩個子陣列，則劃分需要 \\(O(n)\\) 時間，排序每個子陣列需要 \\(O((n / 2)^2)\\) 時間，合併兩個子陣列需要 \\(O(n)\\) 時間，總體時間複雜度為：</p> \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\] <p></p> <p> 圖 12-2   劃分陣列前後的泡沫排序 </p> <p>接下來，我們計算以下不等式，其左邊和右邊分別為劃分前和劃分後的操作總數：</p> \\[ \\begin{aligned} n^2 &amp; &gt; \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n &amp; &gt; 0 \\newline n(n - 4) &amp; &gt; 0 \\end{aligned} \\] <p>這意味著當 \\(n &gt; 4\\) 時，劃分後的操作數量更少，排序效率應該更高。請注意，劃分後的時間複雜度仍然是平方階 \\(O(n^2)\\) ，只是複雜度中的常數項變小了。</p> <p>進一步想，如果我們把子陣列不斷地再從中點處劃分為兩個子陣列，直至子陣列只剩一個元素時停止劃分呢？這種思路實際上就是“合併排序”，時間複雜度為 \\(O(n \\log n)\\) 。</p> <p>再思考，如果我們多設定幾個劃分點，將原陣列平均劃分為 \\(k\\) 個子陣列呢？這種情況與“桶排序”非常類似，它非常適合排序海量資料，理論上時間複雜度可以達到 \\(O(n + k)\\) 。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","level":3,"title":"2.   平行計算最佳化","text":"<p>我們知道，分治生成的子問題是相互獨立的，因此通常可以並行解決。也就是說，分治不僅可以降低演算法的時間複雜度，還有利於作業系統的並行最佳化。</p> <p>並行最佳化在多核或多處理器的環境中尤其有效，因為系統可以同時處理多個子問題，更加充分地利用計算資源，從而顯著減少總體的執行時間。</p> <p>比如在圖 12-3 所示的“桶排序”中，我們將海量的資料平均分配到各個桶中，則可將所有桶的排序任務分散到各個計算單元，完成後再合併結果。</p> <p></p> <p> 圖 12-3   桶排序的平行計算 </p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","level":2,"title":"12.1.3   分治常見應用","text":"<p>一方面，分治可以用來解決許多經典演算法問題。</p> <ul> <li>尋找最近點對：該演算法首先將點集分成兩部分，然後分別找出兩部分中的最近點對，最後找出跨越兩部分的最近點對。</li> <li>大整數乘法：例如 Karatsuba 演算法，它將大整數乘法分解為幾個較小的整數的乘法和加法。</li> <li>矩陣乘法：例如 Strassen 演算法，它將大矩陣乘法分解為多個小矩陣的乘法和加法。</li> <li>河內塔問題：河內塔問題可以透過遞迴解決，這是典型的分治策略應用。</li> <li>求解逆序對：在一個序列中，如果前面的數字大於後面的數字，那麼這兩個數字構成一個逆序對。求解逆序對問題可以利用分治的思想，藉助合併排序進行求解。</li> </ul> <p>另一方面，分治在演算法和資料結構的設計中應用得非常廣泛。</p> <ul> <li>二分搜尋：二分搜尋是將有序陣列從中點索引處分為兩部分，然後根據目標值與中間元素值比較結果，決定排除哪一半區間，並在剩餘區間執行相同的二分操作。</li> <li>合併排序：本節開頭已介紹，不再贅述。</li> <li>快速排序：快速排序是選取一個基準值，然後把陣列分為兩個子陣列，一個子陣列的元素比基準值小，另一子陣列的元素比基準值大，再對這兩部分進行相同的劃分操作，直至子陣列只剩下一個元素。</li> <li>桶排序：桶排序的基本思想是將資料分散到多個桶，然後對每個桶內的元素進行排序，最後將各個桶的元素依次取出，從而得到一個有序陣列。</li> <li>樹：例如二元搜尋樹、AVL 樹、紅黑樹、B 樹、B+ 樹等，它們的查詢、插入和刪除等操作都可以視為分治策略的應用。</li> <li>堆積：堆積是一種特殊的完全二元樹，其各種操作，如插入、刪除和堆積化，實際上都隱含了分治的思想。</li> <li>雜湊表：雖然雜湊表並不直接應用分治，但某些雜湊衝突解決方案間接應用了分治策略，例如，鏈式位址中的長鏈結串列會被轉化為紅黑樹，以提升查詢效率。</li> </ul> <p>可以看出，分治是一種“潤物細無聲”的演算法思想，隱含在各種演算法與資料結構之中。</p>","path":["第 12 章 &nbsp; 分治","12.1 &nbsp; 分治演算法"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/","level":1,"title":"12.4   河內塔問題","text":"<p>在合併排序和構建二元樹中，我們都是將原問題分解為兩個規模為原問題一半的子問題。然而對於河內塔問題，我們採用不同的分解策略。</p> <p>Question</p> <p>給定三根柱子，記為 <code>A</code>、<code>B</code> 和 <code>C</code> 。起始狀態下，柱子 <code>A</code> 上套著 \\(n\\) 個圓盤，它們從上到下按照從小到大的順序排列。我們的任務是要把這 \\(n\\) 個圓盤移到柱子 <code>C</code> 上，並保持它們的原有順序不變（如圖 12-10 所示）。在移動圓盤的過程中，需要遵守以下規則。</p> <ol> <li>圓盤只能從一根柱子頂部拿出，從另一根柱子頂部放入。</li> <li>每次只能移動一個圓盤。</li> <li>小圓盤必須時刻位於大圓盤之上。</li> </ol> <p></p> <p> 圖 12-10   河內塔問題示例 </p> <p>我們將規模為 \\(i\\) 的河內塔問題記作 \\(f(i)\\) 。例如 \\(f(3)\\) 代表將 \\(3\\) 個圓盤從 <code>A</code> 移動至 <code>C</code> 的河內塔問題。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#1","level":3,"title":"1.   考慮基本情況","text":"<p>如圖 12-11 所示，對於問題 \\(f(1)\\) ，即當只有一個圓盤時，我們將它直接從 <code>A</code> 移動至 <code>C</code> 即可。</p> &lt;1&gt;&lt;2&gt; <p></p> <p></p> <p> 圖 12-11   規模為 1 的問題的解 </p> <p>如圖 12-12 所示，對於問題 \\(f(2)\\) ，即當有兩個圓盤時，由於要時刻滿足小圓盤在大圓盤之上，因此需要藉助 <code>B</code> 來完成移動。</p> <ol> <li>先將上面的小圓盤從 <code>A</code> 移至 <code>B</code> 。</li> <li>再將大圓盤從 <code>A</code> 移至 <code>C</code> 。</li> <li>最後將小圓盤從 <code>B</code> 移至 <code>C</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 12-12   規模為 2 的問題的解 </p> <p>解決問題 \\(f(2)\\) 的過程可總結為：將兩個圓盤藉助 <code>B</code> 從 <code>A</code> 移至 <code>C</code> 。其中，<code>C</code> 稱為目標柱、<code>B</code> 稱為緩衝柱。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#2","level":3,"title":"2.   子問題分解","text":"<p>對於問題 \\(f(3)\\) ，即當有三個圓盤時，情況變得稍微複雜了一些。</p> <p>因為已知 \\(f(1)\\) 和 \\(f(2)\\) 的解，所以我們可從分治角度思考，將 <code>A</code> 頂部的兩個圓盤看作一個整體，執行圖 12-13 所示的步驟。這樣三個圓盤就被順利地從 <code>A</code> 移至 <code>C</code> 了。</p> <ol> <li>令 <code>B</code> 為目標柱、<code>C</code> 為緩衝柱，將兩個圓盤從 <code>A</code> 移至 <code>B</code> 。</li> <li>將 <code>A</code> 中剩餘的一個圓盤從 <code>A</code> 直接移動至 <code>C</code> 。</li> <li>令 <code>C</code> 為目標柱、<code>A</code> 為緩衝柱，將兩個圓盤從 <code>B</code> 移至 <code>C</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 12-13   規模為 3 的問題的解 </p> <p>從本質上看，我們將問題 \\(f(3)\\) 劃分為兩個子問題 \\(f(2)\\) 和一個子問題 \\(f(1)\\) 。按順序解決這三個子問題之後，原問題隨之得到解決。這說明子問題是獨立的，而且解可以合併。</p> <p>至此，我們可總結出圖 12-14 所示的解決河內塔問題的分治策略：將原問題 \\(f(n)\\) 劃分為兩個子問題 \\(f(n-1)\\) 和一個子問題 \\(f(1)\\) ，並按照以下順序解決這三個子問題。</p> <ol> <li>將 \\(n-1\\) 個圓盤藉助 <code>C</code> 從 <code>A</code> 移至 <code>B</code> 。</li> <li>將剩餘 \\(1\\) 個圓盤從 <code>A</code> 直接移至 <code>C</code> 。</li> <li>將 \\(n-1\\) 個圓盤藉助 <code>A</code> 從 <code>B</code> 移至 <code>C</code> 。</li> </ol> <p>對於這兩個子問題 \\(f(n-1)\\) ，可以透過相同的方式進行遞迴劃分，直至達到最小子問題 \\(f(1)\\) 。而 \\(f(1)\\) 的解是已知的，只需一次移動操作即可。</p> <p></p> <p> 圖 12-14   解決河內塔問題的分治策略 </p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/hanota_problem/#3","level":3,"title":"3.   程式碼實現","text":"<p>在程式碼中，我們宣告一個遞迴函式 <code>dfs(i, src, buf, tar)</code> ，它的作用是將柱 <code>src</code> 頂部的 \\(i\\) 個圓盤藉助緩衝柱 <code>buf</code> 移動至目標柱 <code>tar</code> ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hanota.py<pre><code>def move(src: list[int], tar: list[int]):\n    \"\"\"移動一個圓盤\"\"\"\n    # 從 src 頂部拿出一個圓盤\n    pan = src.pop()\n    # 將圓盤放入 tar 頂部\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"求解河內塔問題 f(i)\"\"\"\n    # 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1:\n        move(src, tar)\n        return\n    # 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf)\n    # 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    # 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"求解河內塔問題\"\"\"\n    n = len(A)\n    # 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C)\n</code></pre> hanota.cpp<pre><code>/* 移動一個圓盤 */\nvoid move(vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;tar) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src.back();\n    src.pop_back();\n    // 將圓盤放入 tar 頂部\n    tar.push_back(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, vector&lt;int&gt; &amp;src, vector&lt;int&gt; &amp;buf, vector&lt;int&gt; &amp;tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(vector&lt;int&gt; &amp;A, vector&lt;int&gt; &amp;B, vector&lt;int&gt; &amp;C) {\n    int n = A.size();\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.java<pre><code>/* 移動一個圓盤 */\nvoid move(List&lt;Integer&gt; src, List&lt;Integer&gt; tar) {\n    // 從 src 頂部拿出一個圓盤\n    Integer pan = src.remove(src.size() - 1);\n    // 將圓盤放入 tar 頂部\n    tar.add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, List&lt;Integer&gt; src, List&lt;Integer&gt; buf, List&lt;Integer&gt; tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(List&lt;Integer&gt; A, List&lt;Integer&gt; B, List&lt;Integer&gt; C) {\n    int n = A.size();\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.cs<pre><code>/* 移動一個圓盤 */\nvoid Move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // 將圓盤放入 tar 頂部\n    tar.Add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid DFS(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    DFS(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    Move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    DFS(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid SolveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n    int n = A.Count;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    DFS(n, A, B, C);\n}\n</code></pre> hanota.go<pre><code>/* 移動一個圓盤 */\nfunc move(src, tar *list.List) {\n    // 從 src 頂部拿出一個圓盤\n    pan := src.Back()\n    // 將圓盤放入 tar 頂部\n    tar.PushBack(pan.Value)\n    // 移除 src 頂部圓盤\n    src.Remove(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfsHanota(i-1, src, tar, buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* 求解河內塔問題 */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfsHanota(n, A, B, C)\n}\n</code></pre> hanota.swift<pre><code>/* 移動一個圓盤 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // 從 src 頂部拿出一個圓盤\n    let pan = src.popLast()!\n    // 將圓盤放入 tar 頂部\n    tar.append(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move(src: &amp;src, tar: &amp;tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i: i - 1, src: &amp;src, buf: &amp;tar, tar: &amp;buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src: &amp;src, tar: &amp;tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i: i - 1, src: &amp;buf, buf: &amp;src, tar: &amp;tar)\n}\n\n/* 求解河內塔問題 */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // 串列尾部是柱子頂部\n    // 將 src 頂部 n 個圓盤藉助 B 移到 C\n    dfs(i: n, src: &amp;A, buf: &amp;B, tar: &amp;C)\n}\n</code></pre> hanota.js<pre><code>/* 移動一個圓盤 */\nfunction move(src, tar) {\n    // 從 src 頂部拿出一個圓盤\n    const pan = src.pop();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfunction dfs(i, src, buf, tar) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.ts<pre><code>/* 移動一個圓盤 */\nfunction move(src: number[], tar: number[]): void {\n    // 從 src 頂部拿出一個圓盤\n    const pan = src.pop();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.dart<pre><code>/* 移動一個圓盤 */\nvoid move(List&lt;int&gt; src, List&lt;int&gt; tar) {\n  // 從 src 頂部拿出一個圓盤\n  int pan = src.removeLast();\n  // 將圓盤放入 tar 頂部\n  tar.add(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, List&lt;int&gt; src, List&lt;int&gt; buf, List&lt;int&gt; tar) {\n  // 若 src 只剩下一個圓盤，則直接將其移到 tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n  dfs(i - 1, src, tar, buf);\n  // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n  move(src, tar);\n  // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n  dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(List&lt;int&gt; A, List&lt;int&gt; B, List&lt;int&gt; C) {\n  int n = A.length;\n  // 將 A 頂部 n 個圓盤藉助 B 移到 C\n  dfs(n, A, B, C);\n}\n</code></pre> hanota.rs<pre><code>/* 移動一個圓盤 */\nfn move_pan(src: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // 從 src 頂部拿出一個圓盤\n    let pan = src.pop().unwrap();\n    // 將圓盤放入 tar 頂部\n    tar.push(pan);\n}\n\n/* 求解河內塔問題 f(i) */\nfn dfs(i: i32, src: &amp;mut Vec&lt;i32&gt;, buf: &amp;mut Vec&lt;i32&gt;, tar: &amp;mut Vec&lt;i32&gt;) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move_pan(src, tar);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* 求解河內塔問題 */\nfn solve_hanota(A: &amp;mut Vec&lt;i32&gt;, B: &amp;mut Vec&lt;i32&gt;, C: &amp;mut Vec&lt;i32&gt;) {\n    let n = A.len() as i32;\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C);\n}\n</code></pre> hanota.c<pre><code>/* 移動一個圓盤 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // 從 src 頂部拿出一個圓盤\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // 將圓盤放入 tar 頂部\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* 求解河內塔問題 f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, srcSize, tar, tarSize);\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* 求解河內塔問題 */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n</code></pre> hanota.kt<pre><code>/* 移動一個圓盤 */\nfun move(src: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // 從 src 頂部拿出一個圓盤\n    val pan = src.removeAt(src.size - 1)\n    // 將圓盤放入 tar 頂部\n    tar.add(pan)\n}\n\n/* 求解河內塔問題 f(i) */\nfun dfs(i: Int, src: MutableList&lt;Int&gt;, buf: MutableList&lt;Int&gt;, tar: MutableList&lt;Int&gt;) {\n    // 若 src 只剩下一個圓盤，則直接將其移到 tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n    dfs(i - 1, src, tar, buf)\n    // 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n    move(src, tar)\n    // 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n    dfs(i - 1, buf, src, tar)\n}\n\n/* 求解河內塔問題 */\nfun solveHanota(A: MutableList&lt;Int&gt;, B: MutableList&lt;Int&gt;, C: MutableList&lt;Int&gt;) {\n    val n = A.size\n    // 將 A 頂部 n 個圓盤藉助 B 移到 C\n    dfs(n, A, B, C)\n}\n</code></pre> hanota.rb<pre><code>### 移動一個圓盤 ###\ndef move(src, tar)\n  # 從 src 頂部拿出一個圓盤\n  pan = src.pop\n  # 將圓盤放入 tar 頂部\n  tar &lt;&lt; pan\nend\n\n### 求解河內塔問題 f(i) ###\ndef dfs(i, src, buf, tar)\n  # 若 src 只剩下一個圓盤，則直接將其移到 tar\n  if i == 1\n    move(src, tar)\n    return\n  end\n\n  # 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf\n  dfs(i - 1, src, tar, buf)\n  # 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar\n  move(src, tar)\n  # 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar\n  dfs(i - 1, buf, src, tar)\nend\n\n### 求解河內塔問題 ###\ndef solve_hanota(_A, _B, _C)\n  n = _A.length\n  # 將 A 頂部 n 個圓盤藉助 B 移到 C\n  dfs(n, _A, _B, _C)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 12-15 所示，河內塔問題形成一棵高度為 \\(n\\) 的遞迴樹，每個節點代表一個子問題，對應一個開啟的 <code>dfs()</code> 函式，因此時間複雜度為 \\(O(2^n)\\) ，空間複雜度為 \\(O(n)\\) 。</p> <p></p> <p> 圖 12-15   河內塔問題的遞迴樹 </p> <p>Quote</p> <p>河內塔問題源自一個古老的傳說。在古印度的一個寺廟裡，僧侶們有三根高大的鑽石柱子，以及 \\(64\\) 個大小不一的金圓盤。僧侶們不斷地移動圓盤，他們相信在最後一個圓盤被正確放置的那一刻，這個世界就會結束。</p> <p>然而，即使僧侶們每秒鐘移動一次，總共需要大約 \\(2^{64} \\approx 1.84×10^{19}\\) 秒，合約 \\(5850\\) 億年，遠遠超過了現在對宇宙年齡的估計。所以，倘若這個傳說是真的，我們應該不需要擔心世界末日的到來。</p>","path":["第 12 章 &nbsp; 分治","12.4 &nbsp; 河內塔問題"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/","level":1,"title":"12.5   小結","text":"","path":["第 12 章 &nbsp; 分治","12.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_divide_and_conquer/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>分治是一種常見的演算法設計策略，包括分（劃分）和治（合併）兩個階段，通常基於遞迴實現。</li> <li>判斷是否是分治演算法問題的依據包括：問題能否分解、子問題是否獨立、子問題能否合併。</li> <li>合併排序是分治策略的典型應用，其遞迴地將陣列劃分為等長的兩個子陣列，直到只剩一個元素時開始逐層合併，從而完成排序。</li> <li>引入分治策略往往可以提升演算法效率。一方面，分治策略減少了操作數量；另一方面，分治後有利於系統的並行最佳化。</li> <li>分治既可以解決許多演算法問題，也廣泛應用於資料結構與演算法設計中，處處可見其身影。</li> <li>相較於暴力搜尋，自適應搜尋效率更高。時間複雜度為 \\(O(\\log n)\\) 的搜尋演算法通常是基於分治策略實現的。</li> <li>二分搜尋是分治策略的另一個典型應用，它不包含將子問題的解進行合併的步驟。我們可以透過遞迴分治實現二分搜尋。</li> <li>在構建二元樹的問題中，構建樹（原問題）可以劃分為構建左子樹和右子樹（子問題），這可以透過劃分前序走訪和中序走訪的索引區間來實現。</li> <li>在河內塔問題中，一個規模為 \\(n\\) 的問題可以劃分為兩個規模為 \\(n-1\\) 的子問題和一個規模為 \\(1\\) 的子問題。按順序解決這三個子問題後，原問題隨之得到解決。</li> </ul>","path":["第 12 章 &nbsp; 分治","12.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/","level":1,"title":"第 14 章   動態規劃","text":"<p>Abstract</p> <p>小溪匯入河流，江河匯入大海。</p> <p>動態規劃將小問題的解彙集成大問題的答案，一步步引領我們走向解決問題的彼岸。</p>","path":["第 14 章 &nbsp; 動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/#_1","level":2,"title":"本章內容","text":"<ul> <li>14.1   初探動態規劃</li> <li>14.2   DP 問題特性</li> <li>14.3   DP 解題思路</li> <li>14.4   0-1 背包問題</li> <li>14.5   完全背包問題</li> <li>14.6   編輯距離問題</li> <li>14.7   小結</li> </ul>","path":["第 14 章 &nbsp; 動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/","level":1,"title":"14.2   動態規劃問題特性","text":"<p>在上一節中，我們學習了動態規劃是如何透過子問題分解來求解原問題的。實際上，子問題分解是一種通用的演算法思路，在分治、動態規劃、回溯中的側重點不同。</p> <ul> <li>分治演算法遞迴地將原問題劃分為多個相互獨立的子問題，直至最小子問題，並在回溯中合併子問題的解，最終得到原問題的解。</li> <li>動態規劃也對問題進行遞迴分解，但與分治演算法的主要區別是，動態規劃中的子問題是相互依賴的，在分解過程中會出現許多重疊子問題。</li> <li>回溯演算法在嘗試和回退中窮舉所有可能的解，並透過剪枝避免不必要的搜尋分支。原問題的解由一系列決策步驟構成，我們可以將每個決策步驟之前的子序列看作一個子問題。</li> </ul> <p>實際上，動態規劃常用來求解最最佳化問題，它們不僅包含重疊子問題，還具有另外兩大特性：最優子結構、無後效性。</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1421","level":2,"title":"14.2.1   最優子結構","text":"<p>我們對爬樓梯問題稍作改動，使之更加適合展示最優子結構概念。</p> <p>爬樓梯最小代價</p> <p>給定一個樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，每一階樓梯上都貼有一個非負整數，表示你在該臺階所需要付出的代價。給定一個非負整數陣列 \\(cost\\) ，其中 \\(cost[i]\\) 表示在第 \\(i\\) 個臺階需要付出的代價，\\(cost[0]\\) 為地面（起始點）。請計算最少需要付出多少代價才能到達頂部？</p> <p>如圖 14-6 所示，若第 \\(1\\)、\\(2\\)、\\(3\\) 階的代價分別為 \\(1\\)、\\(10\\)、\\(1\\) ，則從地面爬到第 \\(3\\) 階的最小代價為 \\(2\\) 。</p> <p></p> <p> 圖 14-6   爬到第 3 階的最小代價 </p> <p>設 \\(dp[i]\\) 為爬到第 \\(i\\) 階累計付出的代價，由於第 \\(i\\) 階只可能從 \\(i - 1\\) 階或 \\(i - 2\\) 階走來，因此 \\(dp[i]\\) 只可能等於 \\(dp[i - 1] + cost[i]\\) 或 \\(dp[i - 2] + cost[i]\\) 。為了儘可能減少代價，我們應該選擇兩者中較小的那一個：</p> \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\] <p>這便可以引出最優子結構的含義：原問題的最優解是從子問題的最優解構建得來的。</p> <p>本題顯然具有最優子結構：我們從兩個子問題最優解 \\(dp[i-1]\\) 和 \\(dp[i-2]\\) 中挑選出較優的那一個，並用它構建出原問題 \\(dp[i]\\) 的最優解。</p> <p>那麼，上一節的爬樓梯題目有沒有最優子結構呢？它的目標是求解方案數量，看似是一個計數問題，但如果換一種問法：“求解最大方案數量”。我們意外地發現，雖然題目修改前後是等價的，但最優子結構浮現出來了：第 \\(n\\) 階最大方案數量等於第 \\(n-1\\) 階和第 \\(n-2\\) 階最大方案數量之和。所以說，最優子結構的解釋方式比較靈活，在不同問題中會有不同的含義。</p> <p>根據狀態轉移方程，以及初始狀態 \\(dp[1] = cost[1]\\) 和 \\(dp[2] = cost[2]\\) ，我們就可以得到動態規劃程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp(cost: list[int]) -&gt; int:\n    \"\"\"爬樓梯最小代價：動態規劃\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [0] * (n + 1)\n    # 初始狀態：預設最小子問題的解\n    dp[1], dp[2] = cost[1], cost[2]\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[n]\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;int&gt; dp(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunc minCostClimbingStairsDP(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfunction minCostClimbingStairsDP(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初始狀態：預設最小子問題的解\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfn min_cost_climbing_stairs_dp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![-1; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 爬樓梯最小代價：動態規劃 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // 初始化 dp 表，用於儲存子問題的解\n    int *dp = calloc(n + 1, sizeof(int));\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 爬樓梯最小代價：動態規劃 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = IntArray(n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 爬樓梯最小代價：動態規劃 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = cost[1], cost[2]\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-7 展示了以上程式碼的動態規劃過程。</p> <p></p> <p> 圖 14-7   爬樓梯最小代價的動態規劃過程 </p> <p>本題也可以進行空間最佳化，將一維壓縮至零維，使得空間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_cost_climbing_stairs_dp.py<pre><code>def min_cost_climbing_stairs_dp_comp(cost: list[int]) -&gt; int:\n    \"\"\"爬樓梯最小代價：空間最佳化後的動態規劃\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n</code></pre> min_cost_climbing_stairs_dp.cpp<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(vector&lt;int&gt; &amp;cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.java<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.cs<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.go<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a &lt; b {\n            return a\n        }\n        return b\n    }\n    // 初始狀態：預設最小子問題的解\n    a, b := cost[1], cost[2]\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.swift<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -&gt; Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.js<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.ts<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfunction minCostClimbingStairsDPComp(cost: Array&lt;number&gt;): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.dart<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(List&lt;int&gt; cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.rs<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfn min_cost_climbing_stairs_dp_comp(cost: &amp;[i32]) -&gt; i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n</code></pre> min_cost_climbing_stairs_dp.c<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> min_cost_climbing_stairs_dp.kt<pre><code>/* 爬樓梯最小代價：空間最佳化後的動態規劃 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n</code></pre> min_cost_climbing_stairs_dp.rb<pre><code>### 爬樓梯最小代價：動態規劃 ###\ndef min_cost_climbing_stairs_dp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = cost[1], cost[2]\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = [dp[i - 1], dp[i - 2]].min + cost[i] }\n  dp[n]\nend\n\n# 爬樓梯最小代價：空間最佳化後的動態規劃\ndef min_cost_climbing_stairs_dp_comp(cost)\n  n = cost.length - 1\n  return cost[n] if n == 1 || n == 2\n  a, b = cost[1], cost[2]\n  (3...(n + 1)).each { |i| a, b = b, [a, b].min + cost[i] }\n  b\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","level":2,"title":"14.2.2   無後效性","text":"<p>無後效性是動態規劃能夠有效解決問題的重要特性之一，其定義為：給定一個確定的狀態，它的未來發展只與當前狀態有關，而與過去經歷的所有狀態無關。</p> <p>以爬樓梯問題為例，給定狀態 \\(i\\) ，它會發展出狀態 \\(i+1\\) 和狀態 \\(i+2\\) ，分別對應跳 \\(1\\) 步和跳 \\(2\\) 步。在做出這兩種選擇時，我們無須考慮狀態 \\(i\\) 之前的狀態，它們對狀態 \\(i\\) 的未來沒有影響。</p> <p>然而，如果我們給爬樓梯問題新增一個約束，情況就不一樣了。</p> <p>帶約束爬樓梯</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，但不能連續兩輪跳 \\(1\\) 階，請問有多少種方案可以爬到樓頂？</p> <p>如圖 14-8 所示，爬上第 \\(3\\) 階僅剩 \\(2\\) 種可行方案，其中連續三次跳 \\(1\\) 階的方案不滿足約束條件，因此被捨棄。</p> <p></p> <p> 圖 14-8   帶約束爬到第 3 階的方案數量 </p> <p>在該問題中，如果上一輪是跳 \\(1\\) 階上來的，那麼下一輪就必須跳 \\(2\\) 階。這意味著，下一步選擇不能由當前狀態（當前所在樓梯階數）獨立決定，還和前一個狀態（上一輪所在樓梯階數）有關。</p> <p>不難發現，此問題已不滿足無後效性，狀態轉移方程 \\(dp[i] = dp[i-1] + dp[i-2]\\) 也失效了，因為 \\(dp[i-1]\\) 代表本輪跳 \\(1\\) 階，但其中包含了許多“上一輪是跳 \\(1\\) 階上來的”方案，而為了滿足約束，我們就不能將 \\(dp[i-1]\\) 直接計入 \\(dp[i]\\) 中。</p> <p>為此，我們需要擴展狀態定義：狀態 \\([i, j]\\) 表示處在第 \\(i\\) 階並且上一輪跳了 \\(j\\) 階，其中 \\(j \\in \\{1, 2\\}\\) 。此狀態定義有效地區分了上一輪跳了 \\(1\\) 階還是 \\(2\\) 階，我們可以據此判斷當前狀態是從何而來的。</p> <ul> <li>當上一輪跳了 \\(1\\) 階時，上上一輪只能選擇跳 \\(2\\) 階，即 \\(dp[i, 1]\\) 只能從 \\(dp[i-1, 2]\\) 轉移過來。</li> <li>當上一輪跳了 \\(2\\) 階時，上上一輪可選擇跳 \\(1\\) 階或跳 \\(2\\) 階，即 \\(dp[i, 2]\\) 可以從 \\(dp[i-2, 1]\\) 或 \\(dp[i-2, 2]\\) 轉移過來。</li> </ul> <p>如圖 14-9 所示，在該定義下，\\(dp[i, j]\\) 表示狀態 \\([i, j]\\) 對應的方案數。此時狀態轉移方程為：</p> \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\] <p></p> <p> 圖 14-9   考慮約束下的遞推關係 </p> <p>最終，返回 \\(dp[n, 1] + dp[n, 2]\\) 即可，兩者之和代表爬到第 \\(n\\) 階的方案總數：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_constraint_dp.py<pre><code>def climbing_stairs_constraint_dp(n: int) -&gt; int:\n    \"\"\"帶約束爬樓梯：動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # 初始狀態：預設最小子問題的解\n    dp[1][1], dp[1][2] = 1, 0\n    dp[2][1], dp[2][2] = 0, 1\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n</code></pre> climbing_stairs_constraint_dp.cpp<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(3, 0));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.java<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int[][] dp = new int[n + 1][3];\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.cs<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int[,] dp = new int[n + 1, 3];\n    // 初始狀態：預設最小子問題的解\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n</code></pre> climbing_stairs_constraint_dp.go<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([][3]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.swift<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunc climbingStairsConstraintDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.js<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = Array.from(new Array(n + 1), () =&gt; new Array(3));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.ts<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(3));\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.dart<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(3, 0));\n  // 初始狀態：預設最小子問題的解\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n</code></pre> climbing_stairs_constraint_dp.rs<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfn climbing_stairs_constraint_dp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.c<pre><code>/* 帶約束爬樓梯：動態規劃 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> climbing_stairs_constraint_dp.kt<pre><code>/* 帶約束爬樓梯：動態規劃 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = Array(n + 1) { IntArray(3) }\n    // 初始狀態：預設最小子問題的解\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n</code></pre> climbing_stairs_constraint_dp.rb<pre><code>### 帶約束爬樓梯：動態規劃 ###\ndef climbing_stairs_constraint_dp(n)\n  return 1 if n == 1 || n == 2\n\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1) { Array.new(3, 0) }\n  # 初始狀態：預設最小子問題的解\n  dp[1][1], dp[1][2] = 1, 0\n  dp[2][1], dp[2][2] = 0, 1\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  for i in 3...(n + 1)\n    dp[i][1] = dp[i - 1][2]\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n  end\n\n  dp[n][1] + dp[n][2]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在上面的案例中，由於僅需多考慮前面一個狀態，因此我們仍然可以透過擴展狀態定義，使得問題重新滿足無後效性。然而，某些問題具有非常嚴重的“有後效性”。</p> <p>爬樓梯與障礙生成</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階。規定當爬到第 \\(i\\) 階時，系統自動會在第 \\(2i\\) 階上放上障礙物，之後所有輪都不允許跳到第 \\(2i\\) 階上。例如，前兩輪分別跳到了第 \\(2\\)、\\(3\\) 階上，則之後就不能跳到第 \\(4\\)、\\(6\\) 階上。請問有多少種方案可以爬到樓頂？</p> <p>在這個問題中，下次跳躍依賴過去所有的狀態，因為每一次跳躍都會在更高的階梯上設定障礙，並影響未來的跳躍。對於這類問題，動態規劃往往難以解決。</p> <p>實際上，許多複雜的組合最佳化問題（例如旅行商問題）不滿足無後效性。對於這類問題，我們通常會選擇使用其他方法，例如啟發式搜尋、遺傳演算法、強化學習等，從而在有限時間內得到可用的區域性最優解。</p>","path":["第 14 章 &nbsp; 動態規劃","14.2 &nbsp; 動態規劃問題特性"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","level":1,"title":"14.3   動態規劃解題思路","text":"<p>上兩節介紹了動態規劃問題的主要特徵，接下來我們一起探究兩個更加實用的問題。</p> <ol> <li>如何判斷一個問題是不是動態規劃問題？</li> <li>求解動態規劃問題該從何處入手，完整步驟是什麼？</li> </ol>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1431","level":2,"title":"14.3.1   問題判斷","text":"<p>總的來說，如果一個問題包含重疊子問題、最優子結構，並滿足無後效性，那麼它通常適合用動態規劃求解。然而，我們很難從問題描述中直接提取出這些特性。因此我們通常會放寬條件，先觀察問題是否適合使用回溯（窮舉）解決。</p> <p>適合用回溯解決的問題通常滿足“決策樹模型”，這種問題可以使用樹形結構來描述，其中每一個節點代表一個決策，每一條路徑代表一個決策序列。</p> <p>換句話說，如果問題包含明確的決策概念，並且解是透過一系列決策產生的，那麼它就滿足決策樹模型，通常可以使用回溯來解決。</p> <p>在此基礎上，動態規劃問題還有一些判斷的“加分項”。</p> <ul> <li>問題包含最大（小）或最多（少）等最最佳化描述。</li> <li>問題的狀態能夠使用一個串列、多維矩陣或樹來表示，並且一個狀態與其周圍的狀態存在遞推關係。</li> </ul> <p>相應地，也存在一些“減分項”。</p> <ul> <li>問題的目標是找出所有可能的解決方案，而不是找出最優解。</li> <li>問題描述中有明顯的排列組合的特徵，需要返回具體的多個方案。</li> </ul> <p>如果一個問題滿足決策樹模型，並具有較為明顯的“加分項”，我們就可以假設它是一個動態規劃問題，並在求解過程中驗證它。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","level":2,"title":"14.3.2   問題求解步驟","text":"<p>動態規劃的解題流程會因問題的性質和難度而有所不同，但通常遵循以下步驟：描述決策，定義狀態，建立 \\(dp\\) 表，推導狀態轉移方程，確定邊界條件等。</p> <p>為了更形象地展示解題步驟，我們使用一個經典問題“最小路徑和”來舉例。</p> <p>Question</p> <p>給定一個 \\(n \\times m\\) 的二維網格 <code>grid</code> ，網格中的每個單元格包含一個非負整數，表示該單元格的代價。機器人以左上角單元格為起始點，每次只能向下或者向右移動一步，直至到達右下角單元格。請返回從左上角到右下角的最小路徑和。</p> <p>圖 14-10 展示了一個例子，給定網格的最小路徑和為 \\(13\\) 。</p> <p></p> <p> 圖 14-10   最小路徑和示例資料 </p> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>本題的每一輪的決策就是從當前格子向下或向右走一步。設當前格子的行列索引為 \\([i, j]\\) ，則向下或向右走一步後，索引變為 \\([i+1, j]\\) 或 \\([i, j+1]\\) 。因此，狀態應包含行索引和列索引兩個變數，記為 \\([i, j]\\) 。</p> <p>狀態 \\([i, j]\\) 對應的子問題為：從起始點 \\([0, 0]\\) 走到 \\([i, j]\\) 的最小路徑和，解記為 \\(dp[i, j]\\) 。</p> <p>至此，我們就得到了圖 14-11 所示的二維 \\(dp\\) 矩陣，其尺寸與輸入網格 \\(grid\\) 相同。</p> <p></p> <p> 圖 14-11   狀態定義與 dp 表 </p> <p>Note</p> <p>動態規劃和回溯過程可以描述為一個決策序列，而狀態由所有決策變數構成。它應當包含描述解題進度的所有變數，其包含了足夠的資訊，能夠用來推導出下一個狀態。</p> <p>每個狀態都對應一個子問題，我們會定義一個 \\(dp\\) 表來儲存所有子問題的解，狀態的每個獨立變數都是 \\(dp\\) 表的一個維度。從本質上看，\\(dp\\) 表是狀態和子問題的解之間的對映。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>對於狀態 \\([i, j]\\) ，它只能從上邊格子 \\([i-1, j]\\) 和左邊格子 \\([i, j-1]\\) 轉移而來。因此最優子結構為：到達 \\([i, j]\\) 的最小路徑和由 \\([i, j-1]\\) 的最小路徑和與 \\([i-1, j]\\) 的最小路徑和中較小的那一個決定。</p> <p>根據以上分析，可推出圖 14-12 所示的狀態轉移方程：</p> \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\] <p></p> <p> 圖 14-12   最優子結構與狀態轉移方程 </p> <p>Note</p> <p>根據定義好的 \\(dp\\) 表，思考原問題和子問題的關係，找出透過子問題的最優解來構造原問題的最優解的方法，即最優子結構。</p> <p>一旦我們找到了最優子結構，就可以使用它來構建出狀態轉移方程。</p> <p>第三步：確定邊界條件和狀態轉移順序</p> <p>在本題中，處在首行的狀態只能從其左邊的狀態得來，處在首列的狀態只能從其上邊的狀態得來，因此首行 \\(i = 0\\) 和首列 \\(j = 0\\) 是邊界條件。</p> <p>如圖 14-13 所示，由於每個格子是由其左方格子和上方格子轉移而來，因此我們使用迴圈來走訪矩陣，外迴圈走訪各行，內迴圈走訪各列。</p> <p></p> <p> 圖 14-13   邊界條件與狀態轉移順序 </p> <p>Note</p> <p>邊界條件在動態規劃中用於初始化 \\(dp\\) 表，在搜尋中用於剪枝。</p> <p>狀態轉移順序的核心是要保證在計算當前問題的解時，所有它依賴的更小子問題的解都已經被正確地計算出來。</p> <p>根據以上分析，我們已經可以直接寫出動態規劃程式碼。然而子問題分解是一種從頂至底的思想，因此按照“暴力搜尋 \\(\\rightarrow\\) 記憶化搜尋 \\(\\rightarrow\\) 動態規劃”的順序實現更加符合思維習慣。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1","level":3,"title":"1.   方法一：暴力搜尋","text":"<p>從狀態 \\([i, j]\\) 開始搜尋，不斷分解為更小的狀態 \\([i-1, j]\\) 和 \\([i, j-1]\\) ，遞迴函式包括以下要素。</p> <ul> <li>遞迴參數：狀態 \\([i, j]\\) 。</li> <li>返回值：從 \\([0, 0]\\) 到 \\([i, j]\\) 的最小路徑和 \\(dp[i, j]\\) 。</li> <li>終止條件：當 \\(i = 0\\) 且 \\(j = 0\\) 時，返回代價 \\(grid[0, 0]\\) 。</li> <li>剪枝：當 \\(i &lt; 0\\) 時或 \\(j &lt; 0\\) 時索引越界，此時返回代價 \\(+\\infty\\) ，代表不可行。</li> </ul> <p>實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -&gt; int:\n    \"\"\"最小路徑和：暴力搜尋\"\"\"\n    # 若為左上角單元格，則終止搜尋\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = min_path_sum_dfs(grid, i, j - 1)\n    # 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(vector&lt;vector&lt;int&gt;&gt; &amp;grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：暴力搜尋 */\nint MinPathSumDFS(int[][] grid, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.Min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：暴力搜尋 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：暴力搜尋 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -&gt; Int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：暴力搜尋 */\nfunction minPathSumDFS(grid, i, j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：暴力搜尋 */\nfunction minPathSumDFS(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return Math.min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(List&lt;List&lt;int&gt;&gt; grid, int i, int j) {\n  // 若為左上角單元格，則終止搜尋\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 若行列索引越界，則返回 +∞ 代價\n  if (i &lt; 0 || j &lt; 0) {\n    // 在 Dart 中，int 型別是固定範圍的整數，不存在表示“無窮大”的值\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // 返回從左上角到 (i, j) 的最小路徑代價\n  return min(left, up) + grid[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：暴力搜尋 */\nfn min_path_sum_dfs(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = min_path_sum_dfs(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：暴力搜尋 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：暴力搜尋 */\nfun minPathSumDFS(grid: Array&lt;IntArray&gt;, i: Int, j: Int): Int {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // 返回從左上角到 (i, j) 的最小路徑代價\n    return min(left, up) + grid[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：暴力搜尋 ###\ndef min_path_sum_dfs(grid, i, j)\n  # 若為左上角單元格，則終止搜尋\n  return grid[i][j] if i == 0 &amp;&amp; j == 0\n  # 若行列索引越界，則返回 +∞ 代價\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 計算從左上角到 (i-1, j) 和 (i, j-1) 的最小路徑代價\n  up = min_path_sum_dfs(grid, i - 1, j)\n  left = min_path_sum_dfs(grid, i, j - 1)\n  # 返回從左上角到 (i, j) 的最小路徑代價\n  [left, up].min + grid[i][j]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-14 給出了以 \\(dp[2, 1]\\) 為根節點的遞迴樹，其中包含一些重疊子問題，其數量會隨著網格 <code>grid</code> 的尺寸變大而急劇增多。</p> <p>從本質上看，造成重疊子問題的原因為：存在多條路徑可以從左上角到達某一單元格。</p> <p></p> <p> 圖 14-14   暴力搜尋遞迴樹 </p> <p>每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 \\(m + n - 2\\) 步，所以最差時間複雜度為 \\(O(2^{m + n})\\) ，其中 \\(n\\) 和 \\(m\\) 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網格邊界時只剩下一種選擇，因此實際的路徑數量會少一些。</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#2","level":3,"title":"2.   方法二：記憶化搜尋","text":"<p>我們引入一個和網格 <code>grid</code> 相同尺寸的記憶串列 <code>mem</code> ，用於記錄各個子問題的解，並將重疊子問題進行剪枝：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dfs_mem(\n    grid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -&gt; int:\n    \"\"\"最小路徑和：記憶化搜尋\"\"\"\n    # 若為左上角單元格，則終止搜尋\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 or j &lt; 0:\n        return inf\n    # 若已有記錄，則直接返回\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # 左邊和上邊單元格的最小路徑代價\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n    # 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(vector&lt;vector&lt;int&gt;&gt; &amp;grid, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Integer.MAX_VALUE;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：記憶化搜尋 */\nint MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return int.MaxValue;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = MinPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return math.MaxInt\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := minPathSumDFSMem(grid, mem, i, j-1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -&gt; Int {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return .max\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    let up = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &amp;mem, i: i, j: j - 1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：記憶化搜尋 */\nfunction minPathSumDFSMem(\n    grid: Array&lt;Array&lt;number&gt;&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    j: number\n): number {\n    // 若為左上角單元格，則終止搜尋\n    if (i === 0 &amp;&amp; j === 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Infinity;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(List&lt;List&lt;int&gt;&gt; grid, List&lt;List&lt;int&gt;&gt; mem, int i, int j) {\n  // 若為左上角單元格，則終止搜尋\n  if (i == 0 &amp;&amp; j == 0) {\n    return grid[0][0];\n  }\n  // 若行列索引越界，則返回 +∞ 代價\n  if (i &lt; 0 || j &lt; 0) {\n    // 在 Dart 中，int 型別是固定範圍的整數，不存在表示“無窮大”的值\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // 若已有記錄，則直接返回\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // 左邊和上邊單元格的最小路徑代價\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = minPathSumDFSMem(grid, mem, i, j - 1);\n  // 記錄並返回左上角到 (i, j) 的最小路徑代價\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：記憶化搜尋 */\nfn min_path_sum_dfs_mem(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;, mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: i32, j: i32) -&gt; i32 {\n    // 若為左上角單元格，則終止搜尋\n    if i == 0 &amp;&amp; j == 0 {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if i &lt; 0 || j &lt; 0 {\n        return i32::MAX;\n    }\n    // 若已有記錄，則直接返回\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = min_path_sum_dfs_mem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：記憶化搜尋 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0];\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return INT_MAX;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：記憶化搜尋 */\nfun minPathSumDFSMem(\n    grid: Array&lt;IntArray&gt;,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    j: Int\n): Int {\n    // 若為左上角單元格，則終止搜尋\n    if (i == 0 &amp;&amp; j == 0) {\n        return grid[0][0]\n    }\n    // 若行列索引越界，則返回 +∞ 代價\n    if (i &lt; 0 || j &lt; 0) {\n        return Int.MAX_VALUE\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // 左邊和上邊單元格的最小路徑代價\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = minPathSumDFSMem(grid, mem, i, j - 1)\n    // 記錄並返回左上角到 (i, j) 的最小路徑代價\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：記憶化搜尋 ###\ndef min_path_sum_dfs_mem(grid, mem, i, j)\n  # 若為左上角單元格，則終止搜尋\n  return grid[0][0] if i == 0 &amp;&amp; j == 0\n  # 若行列索引越界，則返回 +∞ 代價\n  return Float::INFINITY if i &lt; 0 || j &lt; 0\n  # 若已有記錄，則直接返回\n  return mem[i][j] if mem[i][j] != -1\n  # 左邊和上邊單元格的最小路徑代價\n  up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n  left = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n  # 記錄並返回左上角到 (i, j) 的最小路徑代價\n  mem[i][j] = [left, up].min + grid[i][j]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-15 所示，在引入記憶化後，所有子問題的解只需計算一次，因此時間複雜度取決於狀態總數，即網格尺寸 \\(O(nm)\\) 。</p> <p></p> <p> 圖 14-15   記憶化搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#3","level":3,"title":"3.   方法三：動態規劃","text":"<p>基於迭代實現動態規劃解法，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小路徑和：動態規劃\"\"\"\n    n, m = len(grid), len(grid[0])\n    # 初始化 dp 表\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # 狀態轉移：首行\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # 狀態轉移：首列\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # 狀態轉移：其餘行和列\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n, vector&lt;int&gt;(m));\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // 初始化 dp 表\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：動態規劃 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：動態規劃 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // 初始化 dp 表\n    dp := make([][]int, n)\n    for i := 0; i &lt; n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for j := 1; j &lt; m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for i := 1; i &lt; n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt; n; i++ {\n        for j := 1; j &lt; m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：動態規劃 */\nfunc minPathSumDP(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for j in 1 ..&lt; m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for i in 1 ..&lt; n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ..&lt; n {\n        for j in 1 ..&lt; m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：動態規劃 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：動態規劃 */\nfunction minPathSumDP(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n }, () =&gt;\n        Array.from({ length: m }, () =&gt; 0)\n    );\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (let j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (let i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt; n; i++) {\n        for (let j: number = 1; j &lt; m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n, (i) =&gt; List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // 狀態轉移：首行\n  for (int j = 1; j &lt; m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // 狀態轉移：首列\n  for (int i = 1; i &lt; n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt; n; i++) {\n    for (int j = 1; j &lt; m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：動態規劃 */\nfn min_path_sum_dp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：動態規劃 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // 初始化 dp 表\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i &lt; n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // 狀態轉移：首列\n    for (int i = 1; i &lt; n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt; n; i++) {\n        for (int j = 1; j &lt; m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // 釋放記憶體\n    for (int i = 0; i &lt; n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：動態規劃 */\nfun minPathSumDP(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // 初始化 dp 表\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // 狀態轉移：首行\n    for (j in 1..&lt;m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // 狀態轉移：首列\n    for (i in 1..&lt;n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..&lt;n) {\n        for (j in 1..&lt;m) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：動態規劃 ###\ndef min_path_sum_dp(grid)\n  n, m = grid.length, grid.first.length\n  # 初始化 dp 表\n  dp = Array.new(n) { Array.new(m, 0) }\n  dp[0][0] = grid[0][0]\n  # 狀態轉移：首行\n  (1...m).each { |j| dp[0][j] = dp[0][j - 1] + grid[0][j] }\n  # 狀態轉移：首列\n  (1...n).each { |i| dp[i][0] = dp[i - 1][0] + grid[i][0] }\n  # 狀態轉移：其餘行和列\n  for i in 1...n\n    for j in 1...m\n      dp[i][j] = [dp[i][j - 1], dp[i - 1][j]].min + grid[i][j]\n    end\n  end\n  dp[n -1][m -1]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-16 展示了最小路徑和的狀態轉移過程，其走訪了整個網格，因此時間複雜度為 \\(O(nm)\\) 。</p> <p>陣列 <code>dp</code> 大小為 \\(n \\times m\\) ，因此空間複雜度為 \\(O(nm)\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-16   最小路徑和的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","level":3,"title":"4.   空間最佳化","text":"<p>由於每個格子只與其左邊和上邊的格子有關，因此我們可以只用一個單行陣列來實現 \\(dp\\) 表。</p> <p>請注意，因為陣列 <code>dp</code> 只能表示一行的狀態，所以我們無法提前初始化首列狀態，而是在走訪每行時更新它：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby min_path_sum.py<pre><code>def min_path_sum_dp_comp(grid: list[list[int]]) -&gt; int:\n    \"\"\"最小路徑和：空間最佳化後的動態規劃\"\"\"\n    n, m = len(grid), len(grid[0])\n    # 初始化 dp 表\n    dp = [0] * m\n    # 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # 狀態轉移：其餘行\n    for i in range(1, n):\n        # 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        # 狀態轉移：其餘列\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n</code></pre> min_path_sum.cpp<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(vector&lt;vector&lt;int&gt;&gt; &amp;grid) {\n    int n = grid.size(), m = grid[0].size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.java<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // 初始化 dp 表\n    int[] dp = new int[m];\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.cs<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // 初始化 dp 表\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.go<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // 初始化 dp 表\n    dp := make([]int, m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j := 1; j &lt; m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt; n; i++ {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for j := 1; j &lt; m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n</code></pre> min_path_sum.swift<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunc minPathSumDPComp(grid: [[Int]]) -&gt; Int {\n    let n = grid.count\n    let m = grid[0].count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for j in 1 ..&lt; m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行\n    for i in 1 ..&lt; n {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for j in 1 ..&lt; m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.js<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = new Array(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.ts<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfunction minPathSumDPComp(grid: Array&lt;Array&lt;number&gt;&gt;): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // 初始化 dp 表\n    const dp = new Array(m);\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (let j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt; m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n</code></pre> min_path_sum.dart<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(List&lt;List&lt;int&gt;&gt; grid) {\n  int n = grid.length, m = grid[0].length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j &lt; m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // 狀態轉移：其餘行\n  for (int i = 1; i &lt; n; i++) {\n    // 狀態轉移：首列\n    dp[0] = dp[0] + grid[i][0];\n    // 狀態轉移：其餘列\n    for (int j = 1; j &lt; m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n</code></pre> min_path_sum.rs<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfn min_path_sum_dp_comp(grid: &amp;Vec&lt;Vec&lt;i32&gt;&gt;) -&gt; i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // 初始化 dp 表\n    let mut dp = vec![0; m];\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for i in 1..n {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n</code></pre> min_path_sum.c<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // 初始化 dp 表\n    int *dp = calloc(m, sizeof(int));\n    // 狀態轉移：首行\n    dp[0] = grid[0][0];\n    for (int j = 1; j &lt; m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt; n; i++) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0];\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt; m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> min_path_sum.kt<pre><code>/* 最小路徑和：空間最佳化後的動態規劃 */\nfun minPathSumDPComp(grid: Array&lt;IntArray&gt;): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // 初始化 dp 表\n    val dp = IntArray(m)\n    // 狀態轉移：首行\n    dp[0] = grid[0][0]\n    for (j in 1..&lt;m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // 狀態轉移：其餘行\n    for (i in 1..&lt;n) {\n        // 狀態轉移：首列\n        dp[0] = dp[0] + grid[i][0]\n        // 狀態轉移：其餘列\n        for (j in 1..&lt;m) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n</code></pre> min_path_sum.rb<pre><code>### 最小路徑和：空間最佳化後的動態規劃 ###\ndef min_path_sum_dp_comp(grid)\n  n, m = grid.length, grid.first.length\n  # 初始化 dp 表\n  dp = Array.new(m, 0)\n  # 狀態轉移：首行\n  dp[0] = grid[0][0]\n  (1...m).each { |j| dp[j] = dp[j - 1] + grid[0][j] }\n  # 狀態轉移：其餘行\n  for i in 1...n\n    # 狀態轉移：首列\n    dp[0] = dp[0] + grid[i][0]\n    # 狀態轉移：其餘列\n    (1...m).each { |j| dp[j] = [dp[j - 1], dp[j]].min + grid[i][j] }\n  end\n  dp[m - 1]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.3 &nbsp; 動態規劃解題思路"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/","level":1,"title":"14.6   編輯距離問題","text":"<p>編輯距離，也稱 Levenshtein 距離，指兩個字串之間互相轉換的最少修改次數，通常用於在資訊檢索和自然語言處理中度量兩個序列的相似度。</p> <p>Question</p> <p>輸入兩個字串 \\(s\\) 和 \\(t\\) ，返回將 \\(s\\) 轉換為 \\(t\\) 所需的最少編輯步數。</p> <p>你可以在一個字串中進行三種編輯操作：插入一個字元、刪除一個字元、將字元替換為任意一個字元。</p> <p>如圖 14-27 所示，將 <code>kitten</code> 轉換為 <code>sitting</code> 需要編輯 3 步，包括 2 次替換操作與 1 次新增操作；將 <code>hello</code> 轉換為 <code>algo</code> 需要 3 步，包括 2 次替換操作和 1 次刪除操作。</p> <p></p> <p> 圖 14-27   編輯距離的示例資料 </p> <p>編輯距離問題可以很自然地用決策樹模型來解釋。字串對應樹節點，一輪決策（一次編輯操作）對應樹的一條邊。</p> <p>如圖 14-28 所示，在不限制操作的情況下，每個節點都可以派生出許多條邊，每條邊對應一種操作，這意味著從 <code>hello</code> 轉換到 <code>algo</code> 有許多種可能的路徑。</p> <p>從決策樹的角度看，本題的目標是求解節點 <code>hello</code> 和節點 <code>algo</code> 之間的最短路徑。</p> <p></p> <p> 圖 14-28   基於決策樹模型表示編輯距離問題 </p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","level":3,"title":"1.   動態規劃思路","text":"<p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>每一輪的決策是對字串 \\(s\\) 進行一次編輯操作。</p> <p>我們希望在編輯操作的過程中，問題的規模逐漸縮小，這樣才能構建子問題。設字串 \\(s\\) 和 \\(t\\) 的長度分別為 \\(n\\) 和 \\(m\\) ，我們先考慮兩字串尾部的字元 \\(s[n-1]\\) 和 \\(t[m-1]\\) 。</p> <ul> <li>若 \\(s[n-1]\\) 和 \\(t[m-1]\\) 相同，我們可以跳過它們，直接考慮 \\(s[n-2]\\) 和 \\(t[m-2]\\) 。</li> <li>若 \\(s[n-1]\\) 和 \\(t[m-1]\\) 不同，我們需要對 \\(s\\) 進行一次編輯（插入、刪除、替換），使得兩字串尾部的字元相同，從而可以跳過它們，考慮規模更小的問題。</li> </ul> <p>也就是說，我們在字串 \\(s\\) 中進行的每一輪決策（編輯操作），都會使得 \\(s\\) 和 \\(t\\) 中剩餘的待匹配字元發生變化。因此，狀態為當前在 \\(s\\) 和 \\(t\\) 中考慮的第 \\(i\\) 和第 \\(j\\) 個字元，記為 \\([i, j]\\) 。</p> <p>狀態 \\([i, j]\\) 對應的子問題：將 \\(s\\) 的前 \\(i\\) 個字元更改為 \\(t\\) 的前 \\(j\\) 個字元所需的最少編輯步數。</p> <p>至此，得到一個尺寸為 \\((i+1) \\times (j+1)\\) 的二維 \\(dp\\) 表。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>考慮子問題 \\(dp[i, j]\\) ，其對應的兩個字串的尾部字元為 \\(s[i-1]\\) 和 \\(t[j-1]\\) ，可根據不同編輯操作分為圖 14-29 所示的三種情況。</p> <ol> <li>在 \\(s[i-1]\\) 之後新增 \\(t[j-1]\\) ，則剩餘子問題 \\(dp[i, j-1]\\) 。</li> <li>刪除 \\(s[i-1]\\) ，則剩餘子問題 \\(dp[i-1, j]\\) 。</li> <li>將 \\(s[i-1]\\) 替換為 \\(t[j-1]\\) ，則剩餘子問題 \\(dp[i-1, j-1]\\) 。</li> </ol> <p></p> <p> 圖 14-29   編輯距離的狀態轉移 </p> <p>根據以上分析，可得最優子結構：\\(dp[i, j]\\) 的最少編輯步數等於 \\(dp[i, j-1]\\)、\\(dp[i-1, j]\\)、\\(dp[i-1, j-1]\\) 三者中的最少編輯步數，再加上本次的編輯步數 \\(1\\) 。對應的狀態轉移方程為：</p> \\[ dp[i, j] = \\min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1 \\] <p>請注意，當 \\(s[i-1]\\) 和 \\(t[j-1]\\) 相同時，無須編輯當前字元，這種情況下的狀態轉移方程為：</p> \\[ dp[i, j] = dp[i-1, j-1] \\] <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當兩字串都為空時，編輯步數為 \\(0\\) ，即 \\(dp[0, 0] = 0\\) 。當 \\(s\\) 為空但 \\(t\\) 不為空時，最少編輯步數等於 \\(t\\) 的長度，即首行 \\(dp[0, j] = j\\) 。當 \\(s\\) 不為空但 \\(t\\) 為空時，最少編輯步數等於 \\(s\\) 的長度，即首列 \\(dp[i, 0] = i\\) 。</p> <p>觀察狀態轉移方程，解 \\(dp[i, j]\\) 依賴左方、上方、左上方的解，因此透過兩層迴圈正序走訪整個 \\(dp\\) 表即可。</p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp(s: str, t: str) -&gt; int:\n    \"\"\"編輯距離：動態規劃\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # 狀態轉移：首行首列\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # 狀態轉移：其餘行和列\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n</code></pre> edit_distance.cpp<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(m + 1, 0));\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編輯距離：動態規劃 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0, j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編輯距離：動態規劃 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // 狀態轉移：首行首列\n    for i := 1; i &lt;= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j &lt;= m; j++ {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for j := 1; j &lt;= m; j++ {\n            if s[i-1] == t[j-1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編輯距離：動態規劃 */\nfunc editDistanceDP(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // 狀態轉移：首行首列\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編輯距離：動態規劃 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt; new Array(m + 1).fill(0));\n    // 狀態轉移：首行首列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編輯距離：動態規劃 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: m + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let j = 1; j &lt;= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (_) =&gt; List.filled(m + 1, 0));\n  // 狀態轉移：首行首列\n  for (int i = 1; i &lt;= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j &lt;= m; j++) {\n    dp[0][j] = j;\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int j = 1; j &lt;= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // 若兩字元相等，則直接跳過此兩字元\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編輯距離：動態規劃 */\nfn edit_distance_dp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // 狀態轉移：首行首列\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編輯距離：動態規劃 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // 狀態轉移：首行首列\n    for (int i = 1; i &lt;= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j &lt;= m; j++) {\n        dp[0][j] = j;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int j = 1; j &lt;= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編輯距離：動態規劃 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // 狀態轉移：首行首列\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編輯距離：動態規劃 ###\ndef edit_distance_dp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(n + 1) { Array.new(m + 1, 0) }\n  # 狀態轉移：首行首列\n  (1...(n + 1)).each { |i| dp[i][0] = i }\n  (1...(m + 1)).each { |j| dp[0][j] = j }\n  # 狀態轉移：其餘行和列\n  for i in 1...(n + 1)\n    for j in 1...(m +1)\n      if s[i - 1] == t[j - 1]\n        # 若兩字元相等，則直接跳過此兩字元\n        dp[i][j] = dp[i - 1][j - 1]\n      else\n        # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[i][j] = [dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]].min + 1\n      end\n    end\n  end\n  dp[n][m]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-30 所示，編輯距離問題的狀態轉移過程與背包問題非常類似，都可以看作填寫一個二維網格的過程。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-30   編輯距離的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","level":3,"title":"3.   空間最佳化","text":"<p>由於 \\(dp[i,j]\\) 是由上方 \\(dp[i-1, j]\\)、左方 \\(dp[i, j-1]\\)、左上方 \\(dp[i-1, j-1]\\) 轉移而來的，而正序走訪會丟失左上方 \\(dp[i-1, j-1]\\) ，倒序走訪無法提前構建 \\(dp[i, j-1]\\) ，因此兩種走訪順序都不可取。</p> <p>為此，我們可以使用一個變數 <code>leftup</code> 來暫存左上方的解 \\(dp[i-1, j-1]\\) ，從而只需考慮左方和上方的解。此時的情況與完全背包問題相同，可使用正序走訪。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby edit_distance.py<pre><code>def edit_distance_dp_comp(s: str, t: str) -&gt; int:\n    \"\"\"編輯距離：空間最佳化後的動態規劃\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # 狀態轉移：首行\n    for j in range(1, m + 1):\n        dp[j] = j\n    # 狀態轉移：其餘行\n    for i in range(1, n + 1):\n        # 狀態轉移：首列\n        leftup = dp[0]  # 暫存 dp[i-1, j-1]\n        dp[0] += 1\n        # 狀態轉移：其餘列\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            else:\n                # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # 更新為下一輪的 dp[i-1, j-1]\n    return dp[m]\n</code></pre> edit_distance.cpp<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector&lt;int&gt; dp(m + 1, 0);\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.java<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.cs<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.go<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // 狀態轉移：首行\n    for j := 1; j &lt;= m; j++ {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for i := 1; i &lt;= n; i++ {\n        // 狀態轉移：首列\n        leftUp := dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for j := 1; j &lt;= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftUp\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.swift<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunc editDistanceDPComp(s: String, t: String) -&gt; Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // 狀態轉移：首行\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for i in 1 ... n {\n        // 狀態轉移：首列\n        var leftup = dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.js<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 狀態轉移：首行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        let leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.ts<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // 狀態轉移：首行\n    for (let j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (let i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        let leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (let j = 1; j &lt;= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n</code></pre> edit_distance.dart<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List&lt;int&gt; dp = List.filled(m + 1, 0);\n  // 狀態轉移：首行\n  for (int j = 1; j &lt;= m; j++) {\n    dp[j] = j;\n  }\n  // 狀態轉移：其餘行\n  for (int i = 1; i &lt;= n; i++) {\n    // 狀態轉移：首列\n    int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n    dp[0] = i;\n    // 狀態轉移：其餘列\n    for (int j = 1; j &lt;= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // 若兩字元相等，則直接跳過此兩字元\n        dp[j] = leftup;\n      } else {\n        // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n</code></pre> edit_distance.rs<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfn edit_distance_dp_comp(s: &amp;str, t: &amp;str) -&gt; i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // 狀態轉移：首行\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // 狀態轉移：其餘行\n    for i in 1..=n {\n        // 狀態轉移：首列\n        let mut leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i as i32;\n        // 狀態轉移：其餘列\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n</code></pre> edit_distance.c<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // 狀態轉移：首行\n    for (int j = 1; j &lt;= m; j++) {\n        dp[j] = j;\n    }\n    // 狀態轉移：其餘行\n    for (int i = 1; i &lt;= n; i++) {\n        // 狀態轉移：首列\n        int leftup = dp[0]; // 暫存 dp[i-1, j-1]\n        dp[0] = i;\n        // 狀態轉移：其餘列\n        for (int j = 1; j &lt;= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup;\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> edit_distance.kt<pre><code>/* 編輯距離：空間最佳化後的動態規劃 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // 狀態轉移：首行\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // 狀態轉移：其餘行\n    for (i in 1..n) {\n        // 狀態轉移：首列\n        var leftup = dp[0] // 暫存 dp[i-1, j-1]\n        dp[0] = i\n        // 狀態轉移：其餘列\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // 若兩字元相等，則直接跳過此兩字元\n                dp[j] = leftup\n            } else {\n                // 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // 更新為下一輪的 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n</code></pre> edit_distance.rb<pre><code>### 編輯距離：空間最佳化後的動態規劃 ###\ndef edit_distance_dp_comp(s, t)\n  n, m = s.length, t.length\n  dp = Array.new(m + 1, 0)\n  # 狀態轉移：首行\n  (1...(m + 1)).each { |j| dp[j] = j }\n  # 狀態轉移：其餘行\n  for i in 1...(n + 1)\n    # 狀態轉移：首列\n    leftup = dp.first # 暫存 dp[i-1, j-1]\n    dp[0] += 1\n    # 狀態轉移：其餘列\n    for j in 1...(m + 1)\n      temp = dp[j]\n      if s[i - 1] == t[j - 1]\n        # 若兩字元相等，則直接跳過此兩字元\n        dp[j] = leftup\n      else\n        # 最少編輯步數 = 插入、刪除、替換這三種操作的最少編輯步數 + 1\n        dp[j] = [dp[j - 1], dp[j], leftup].min + 1\n      end\n      leftup = temp # 更新為下一輪的 dp[i-1, j-1]\n    end\n  end\n  dp[m]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.6 &nbsp; 編輯距離問題"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","level":1,"title":"14.1   初探動態規劃","text":"<p>動態規劃（dynamic programming）是一個重要的演算法範式，它將一個問題分解為一系列更小的子問題，並透過儲存子問題的解來避免重複計算，從而大幅提升時間效率。</p> <p>在本節中，我們從一個經典例題入手，先給出它的暴力回溯解法，觀察其中包含的重疊子問題，再逐步導出更高效的動態規劃解法。</p> <p>爬樓梯</p> <p>給定一個共有 \\(n\\) 階的樓梯，你每步可以上 \\(1\\) 階或者 \\(2\\) 階，請問有多少種方案可以爬到樓頂？</p> <p>如圖 14-1 所示，對於一個 \\(3\\) 階樓梯，共有 \\(3\\) 種方案可以爬到樓頂。</p> <p></p> <p> 圖 14-1   爬到第 3 階的方案數量 </p> <p>本題的目標是求解方案數量，我們可以考慮透過回溯來窮舉所有可能性。具體來說，將爬樓梯想象為一個多輪選擇的過程：從地面出發，每輪選擇上 \\(1\\) 階或 \\(2\\) 階，每當到達樓梯頂部時就將方案數量加 \\(1\\) ，當越過樓梯頂部時就將其剪枝。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_backtrack.py<pre><code>def backtrack(choices: list[int], state: int, n: int, res: list[int]) -&gt; int:\n    \"\"\"回溯\"\"\"\n    # 當爬到第 n 階時，方案數量加 1\n    if state == n:\n        res[0] += 1\n    # 走訪所有選擇\n    for choice in choices:\n        # 剪枝：不允許越過第 n 階\n        if state + choice &gt; n:\n            continue\n        # 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res)\n        # 回退\n\ndef climbing_stairs_backtrack(n: int) -&gt; int:\n    \"\"\"爬樓梯：回溯\"\"\"\n    choices = [1, 2]  # 可選擇向上爬 1 階或 2 階\n    state = 0  # 從第 0 階開始爬\n    res = [0]  # 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res)\n    return res[0]\n</code></pre> climbing_stairs_backtrack.cpp<pre><code>/* 回溯 */\nvoid backtrack(vector&lt;int&gt; &amp;choices, int state, int n, vector&lt;int&gt; &amp;res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    for (auto &amp;choice : choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    vector&lt;int&gt; choices = {1, 2}; // 可選擇向上爬 1 階或 2 階\n    int state = 0;                // 從第 0 階開始爬\n    vector&lt;int&gt; res = {0};        // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.java<pre><code>/* 回溯 */\nvoid backtrack(List&lt;Integer&gt; choices, int state, int n, List&lt;Integer&gt; res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (Integer choice : choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    List&lt;Integer&gt; choices = Arrays.asList(1, 2); // 可選擇向上爬 1 階或 2 階\n    int state = 0; // 從第 0 階開始爬\n    List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n    res.add(0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.cs<pre><code>/* 回溯 */\nvoid Backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    foreach (int choice in choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        Backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint ClimbingStairsBacktrack(int n) {\n    List&lt;int&gt; choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    int state = 0; // 從第 0 階開始爬\n    List&lt;int&gt; res = [0]; // 使用 res[0] 記錄方案數量\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n</code></pre> climbing_stairs_backtrack.go<pre><code>/* 回溯 */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // 走訪所有選擇\n    for _, choice := range choices {\n        // 剪枝：不允許越過第 n 階\n        if state+choice &gt; n {\n            continue\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state+choice, n, res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunc climbingStairsBacktrack(n int) int {\n    // 可選擇向上爬 1 階或 2 階\n    choices := []int{1, 2}\n    // 從第 0 階開始爬\n    state := 0\n    res := make([]int, 1)\n    // 使用 res[0] 記錄方案數量\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.swift<pre><code>/* 回溯 */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] += 1\n    }\n    // 走訪所有選擇\n    for choice in choices {\n        // 剪枝：不允許越過第 n 階\n        if state + choice &gt; n {\n            continue\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices: choices, state: state + choice, n: n, res: &amp;res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunc climbingStairsBacktrack(n: Int) -&gt; Int {\n    let choices = [1, 2] // 可選擇向上爬 1 階或 2 階\n    let state = 0 // 從第 0 階開始爬\n    var res: [Int] = []\n    res.append(0) // 使用 res[0] 記錄方案數量\n    backtrack(choices: choices, state: state, n: n, res: &amp;res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.js<pre><code>/* 回溯 */\nfunction backtrack(choices, state, n, res) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    const state = 0; // 從第 0 階開始爬\n    const res = new Map();\n    res.set(0, 0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.ts<pre><code>/* 回溯 */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map&lt;0, any&gt;\n): void {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // 走訪所有選擇\n    for (const choice of choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n    const state = 0; // 從第 0 階開始爬\n    const res = new Map();\n    res.set(0, 0); // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n</code></pre> climbing_stairs_backtrack.dart<pre><code>/* 回溯 */\nvoid backtrack(List&lt;int&gt; choices, int state, int n, List&lt;int&gt; res) {\n  // 當爬到第 n 階時，方案數量加 1\n  if (state == n) {\n    res[0]++;\n  }\n  // 走訪所有選擇\n  for (int choice in choices) {\n    // 剪枝：不允許越過第 n 階\n    if (state + choice &gt; n) continue;\n    // 嘗試：做出選擇，更新狀態\n    backtrack(choices, state + choice, n, res);\n    // 回退\n  }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n  List&lt;int&gt; choices = [1, 2]; // 可選擇向上爬 1 階或 2 階\n  int state = 0; // 從第 0 階開始爬\n  List&lt;int&gt; res = [];\n  res.add(0); // 使用 res[0] 記錄方案數量\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n</code></pre> climbing_stairs_backtrack.rs<pre><code>/* 回溯 */\nfn backtrack(choices: &amp;[i32], state: i32, n: i32, res: &amp;mut [i32]) {\n    // 當爬到第 n 階時，方案數量加 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // 走訪所有選擇\n    for &amp;choice in choices {\n        // 剪枝：不允許越過第 n 階\n        if state + choice &gt; n {\n            continue;\n        }\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfn climbing_stairs_backtrack(n: usize) -&gt; i32 {\n    let choices = vec![1, 2]; // 可選擇向上爬 1 階或 2 階\n    let state = 0; // 從第 0 階開始爬\n    let mut res = Vec::new();\n    res.push(0); // 使用 res[0] 記錄方案數量\n    backtrack(&amp;choices, state, n as i32, &amp;mut res);\n    res[0]\n}\n</code></pre> climbing_stairs_backtrack.c<pre><code>/* 回溯 */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0]++;\n    // 走訪所有選擇\n    for (int i = 0; i &lt; len; i++) {\n        int choice = choices[i];\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n)\n            continue;\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res, len);\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // 可選擇向上爬 1 階或 2 階\n    int state = 0;           // 從第 0 階開始爬\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // 使用 res[0] 記錄方案數量\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n</code></pre> climbing_stairs_backtrack.kt<pre><code>/* 回溯 */\nfun backtrack(\n    choices: MutableList&lt;Int&gt;,\n    state: Int,\n    n: Int,\n    res: MutableList&lt;Int&gt;\n) {\n    // 當爬到第 n 階時，方案數量加 1\n    if (state == n)\n        res[0] = res[0] + 1\n    // 走訪所有選擇\n    for (choice in choices) {\n        // 剪枝：不允許越過第 n 階\n        if (state + choice &gt; n) continue\n        // 嘗試：做出選擇，更新狀態\n        backtrack(choices, state + choice, n, res)\n        // 回退\n    }\n}\n\n/* 爬樓梯：回溯 */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // 可選擇向上爬 1 階或 2 階\n    val state = 0 // 從第 0 階開始爬\n    val res = mutableListOf&lt;Int&gt;()\n    res.add(0) // 使用 res[0] 記錄方案數量\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n</code></pre> climbing_stairs_backtrack.rb<pre><code>### 回溯 ###\ndef backtrack(choices, state, n, res)\n  # 當爬到第 n 階時，方案數量加 1\n  res[0] += 1 if state == n\n  # 走訪所有選擇\n  for choice in choices\n    # 剪枝：不允許越過第 n 階\n    next if state + choice &gt; n\n\n    # 嘗試：做出選擇，更新狀態\n    backtrack(choices, state + choice, n, res)\n  end\n  # 回退\nend\n\n### 爬樓梯：回溯 ###\ndef climbing_stairs_backtrack(n)\n  choices = [1, 2] # 可選擇向上爬 1 階或 2 階\n  state = 0 # 從第 0 階開始爬\n  res = [0] # 使用 res[0] 記錄方案數量\n  backtrack(choices, state, n, res)\n  res.first\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411","level":2,"title":"14.1.1   方法一：暴力搜尋","text":"<p>回溯演算法通常並不顯式地對問題進行拆解，而是將求解問題看作一系列決策步驟，透過試探和剪枝，搜尋所有可能的解。</p> <p>我們可以嘗試從問題分解的角度分析這道題。設爬到第 \\(i\\) 階共有 \\(dp[i]\\) 種方案，那麼 \\(dp[i]\\) 就是原問題，其子問題包括：</p> \\[ dp[i-1], dp[i-2], \\dots, dp[2], dp[1] \\] <p>由於每輪只能上 \\(1\\) 階或 \\(2\\) 階，因此當我們站在第 \\(i\\) 階樓梯上時，上一輪只可能站在第 \\(i - 1\\) 階或第 \\(i - 2\\) 階上。換句話說，我們只能從第 \\(i -1\\) 階或第 \\(i - 2\\) 階邁向第 \\(i\\) 階。</p> <p>由此便可得出一個重要推論：爬到第 \\(i - 1\\) 階的方案數加上爬到第 \\(i - 2\\) 階的方案數就等於爬到第 \\(i\\) 階的方案數。公式如下：</p> \\[ dp[i] = dp[i-1] + dp[i-2] \\] <p>這意味著在爬樓梯問題中，各個子問題之間存在遞推關係，原問題的解可以由子問題的解構建得來。圖 14-2 展示了該遞推關係。</p> <p></p> <p> 圖 14-2   方案數量遞推關係 </p> <p>我們可以根據遞推公式得到暴力搜尋解法。以 \\(dp[n]\\) 為起始點，遞迴地將一個較大問題拆解為兩個較小問題的和，直至到達最小子問題 \\(dp[1]\\) 和 \\(dp[2]\\) 時返回。其中，最小子問題的解是已知的，即 \\(dp[1] = 1\\)、\\(dp[2] = 2\\) ，表示爬到第 \\(1\\)、\\(2\\) 階分別有 \\(1\\)、\\(2\\) 種方案。</p> <p>觀察以下程式碼，它和標準回溯程式碼都屬於深度優先搜尋，但更加簡潔：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs.py<pre><code>def dfs(i: int) -&gt; int:\n    \"\"\"搜尋\"\"\"\n    # 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -&gt; int:\n    \"\"\"爬樓梯：搜尋\"\"\"\n    return dfs(n)\n</code></pre> climbing_stairs_dfs.cpp<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.java<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.cs<pre><code>/* 搜尋 */\nint DFS(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n</code></pre> climbing_stairs_dfs.go<pre><code>/* 搜尋 */\nfunc dfs(i int) int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.swift<pre><code>/* 搜尋 */\nfunc dfs(i: Int) -&gt; Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfunc climbingStairsDFS(n: Int) -&gt; Int {\n    dfs(i: n)\n}\n</code></pre> climbing_stairs_dfs.js<pre><code>/* 搜尋 */\nfunction dfs(i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.ts<pre><code>/* 搜尋 */\nfunction dfs(i: number): number {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.dart<pre><code>/* 搜尋 */\nint dfs(int i) {\n  // 已知 dp[1] 和 dp[2] ，返回之\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.rs<pre><code>/* 搜尋 */\nfn dfs(i: usize) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* 爬樓梯：搜尋 */\nfn climbing_stairs_dfs(n: usize) -&gt; i32 {\n    dfs(n)\n}\n</code></pre> climbing_stairs_dfs.c<pre><code>/* 搜尋 */\nint dfs(int i) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* 爬樓梯：搜尋 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n</code></pre> climbing_stairs_dfs.kt<pre><code>/* 搜尋 */\nfun dfs(i: Int): Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* 爬樓梯：搜尋 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n</code></pre> climbing_stairs_dfs.rb<pre><code>### 搜尋 ###\ndef dfs(i)\n  # 已知 dp[1] 和 dp[2] ，返回之\n  return i if i == 1 || i == 2\n  # dp[i] = dp[i-1] + dp[i-2]\n  dfs(i - 1) + dfs(i - 2)\nend\n\n### 爬樓梯：搜尋 ###\ndef climbing_stairs_dfs(n)\n  dfs(n)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-3 展示了暴力搜尋形成的遞迴樹。對於問題 \\(dp[n]\\) ，其遞迴樹的深度為 \\(n\\) ，時間複雜度為 \\(O(2^n)\\) 。指數階屬於爆炸式增長，如果我們輸入一個比較大的 \\(n\\) ，則會陷入漫長的等待之中。</p> <p></p> <p> 圖 14-3   爬樓梯對應遞迴樹 </p> <p>觀察圖 14-3 ，指數階的時間複雜度是“重疊子問題”導致的。例如 \\(dp[9]\\) 被分解為 \\(dp[8]\\) 和 \\(dp[7]\\) ，\\(dp[8]\\) 被分解為 \\(dp[7]\\) 和 \\(dp[6]\\) ，兩者都包含子問題 \\(dp[7]\\) 。</p> <p>以此類推，子問題中包含更小的重疊子問題，子子孫孫無窮盡也。絕大部分計算資源都浪費在這些重疊的子問題上。</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412","level":2,"title":"14.1.2   方法二：記憶化搜尋","text":"<p>為了提升演算法效率，我們希望所有的重疊子問題都只被計算一次。為此，我們宣告一個陣列 <code>mem</code> 來記錄每個子問題的解，並在搜尋過程中將重疊子問題剪枝。</p> <ol> <li>當首次計算 \\(dp[i]\\) 時，我們將其記錄至 <code>mem[i]</code> ，以便之後使用。</li> <li>當再次需要計算 \\(dp[i]\\) 時，我們便可直接從 <code>mem[i]</code> 中獲取結果，從而避免重複計算該子問題。</li> </ol> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dfs_mem.py<pre><code>def dfs(i: int, mem: list[int]) -&gt; int:\n    \"\"\"記憶化搜尋\"\"\"\n    # 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 or i == 2:\n        return i\n    # 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # 記錄 dp[i]\n    mem[i] = count\n    return count\n\ndef climbing_stairs_dfs_mem(n: int) -&gt; int:\n    \"\"\"爬樓梯：記憶化搜尋\"\"\"\n    # mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\n</code></pre> climbing_stairs_dfs_mem.cpp<pre><code>/* 記憶化搜尋 */\nint dfs(int i, vector&lt;int&gt; &amp;mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    vector&lt;int&gt; mem(n + 1, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.java<pre><code>/* 記憶化搜尋 */\nint dfs(int i, int[] mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.cs<pre><code>/* 記憶化搜尋 */\nint DFS(int i, int[] mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint ClimbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.go<pre><code>/* 記憶化搜尋 */\nfunc dfsMem(i int, mem []int) int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.swift<pre><code>/* 記憶化搜尋 */\nfunc dfs(i: Int, mem: inout [Int]) -&gt; Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &amp;mem) + dfs(i: i - 2, mem: &amp;mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunc climbingStairsDFSMem(n: Int) -&gt; Int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &amp;mem)\n}\n</code></pre> climbing_stairs_dfs_mem.js<pre><code>/* 記憶化搜尋 */\nfunction dfs(i, mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.ts<pre><code>/* 記憶化搜尋 */\nfunction dfs(i: number, mem: number[]): number {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i === 1 || i === 2) return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.dart<pre><code>/* 記憶化搜尋 */\nint dfs(int i, List&lt;int&gt; mem) {\n  // 已知 dp[1] 和 dp[2] ，返回之\n  if (i == 1 || i == 2) return i;\n  // 若存在記錄 dp[i] ，則直接返回之\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // 記錄 dp[i]\n  mem[i] = count;\n  return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n  // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n  List&lt;int&gt; mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n</code></pre> climbing_stairs_dfs_mem.rs<pre><code>/* 記憶化搜尋 */\nfn dfs(i: usize, mem: &amp;mut [i32]) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // 若存在記錄 dp[i] ，則直接返回之\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfn climbing_stairs_dfs_mem(n: usize) -&gt; i32 {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &amp;mut mem)\n}\n</code></pre> climbing_stairs_dfs_mem.c<pre><code>/* 記憶化搜尋 */\nint dfs(int i, int *mem) {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2)\n        return i;\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // 記錄 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* 爬樓梯：記憶化搜尋 */\nint climbingStairsDFSMem(int n) {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i &lt;= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n</code></pre> climbing_stairs_dfs_mem.kt<pre><code>/* 記憶化搜尋 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if (i == 1 || i == 2) return i\n    // 若存在記錄 dp[i] ，則直接返回之\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // 記錄 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* 爬樓梯：記憶化搜尋 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n    val mem = IntArray(n + 1)\n    mem.fill(-1)\n    return dfs(n, mem)\n}\n</code></pre> climbing_stairs_dfs_mem.rb<pre><code>### 記憶化搜尋 ###\ndef dfs(i, mem)\n  # 已知 dp[1] 和 dp[2] ，返回之\n  return i if i == 1 || i == 2\n  # 若存在記錄 dp[i] ，則直接返回之\n  return mem[i] if mem[i] != -1\n\n  # dp[i] = dp[i-1] + dp[i-2]\n  count = dfs(i - 1, mem) + dfs(i - 2, mem)\n  # 記錄 dp[i]\n  mem[i] = count\nend\n\n### 爬樓梯：記憶化搜尋 ###\ndef climbing_stairs_dfs_mem(n)\n  # mem[i] 記錄爬到第 i 階的方案總數，-1 代表無記錄\n  mem = Array.new(n + 1, -1)\n  dfs(n, mem)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察圖 14-4 ，經過記憶化處理後，所有重疊子問題都只需計算一次，時間複雜度最佳化至 \\(O(n)\\) ，這是一個巨大的飛躍。</p> <p></p> <p> 圖 14-4   記憶化搜尋對應遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413","level":2,"title":"14.1.3   方法三：動態規劃","text":"<p>記憶化搜尋是一種“從頂至底”的方法：我們從原問題（根節點）開始，遞迴地將較大子問題分解為較小子問題，直至解已知的最小子問題（葉節點）。之後，透過回溯逐層收集子問題的解，構建出原問題的解。</p> <p>與之相反，動態規劃是一種“從底至頂”的方法：從最小子問題的解開始，迭代地構建更大子問題的解，直至得到原問題的解。</p> <p>由於動態規劃不包含回溯過程，因此只需使用迴圈迭代實現，無須使用遞迴。在以下程式碼中，我們初始化一個陣列 <code>dp</code> 來儲存子問題的解，它起到了與記憶化搜尋中陣列 <code>mem</code> 相同的記錄作用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp(n: int) -&gt; int:\n    \"\"\"爬樓梯：動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # 初始化 dp 表，用於儲存子問題的解\n    dp = [0] * (n + 1)\n    # 初始狀態：預設最小子問題的解\n    dp[1], dp[2] = 1, 2\n    # 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    vector&lt;int&gt; dp(n + 1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 爬樓梯：動態規劃 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int[] dp = new int[n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 爬樓梯：動態規劃 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    dp := make([]int, n+1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 爬樓梯：動態規劃 */\nfunc climbingStairsDP(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    var dp = Array(repeating: 0, count: n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 爬樓梯：動態規劃 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1).fill(-1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 爬樓梯：動態規劃 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    const dp = new Array(n + 1).fill(-1);\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (let i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // 初始化 dp 表，用於儲存子問題的解\n  List&lt;int&gt; dp = List.filled(n + 1, 0);\n  // 初始狀態：預設最小子問題的解\n  dp[1] = 1;\n  dp[2] = 2;\n  // 狀態轉移：從較小子問題逐步求解較大子問題\n  for (int i = 3; i &lt;= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 爬樓梯：動態規劃 */\nfn climbing_stairs_dp(n: usize) -&gt; i32 {\n    // 已知 dp[1] 和 dp[2] ，返回之\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // 初始化 dp 表，用於儲存子問題的解\n    let mut dp = vec![-1; n + 1];\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 爬樓梯：動態規劃 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // 初始化 dp 表，用於儲存子問題的解\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1;\n    dp[2] = 2;\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (int i = 3; i &lt;= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 爬樓梯：動態規劃 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // 初始化 dp 表，用於儲存子問題的解\n    val dp = IntArray(n + 1)\n    // 初始狀態：預設最小子問題的解\n    dp[1] = 1\n    dp[2] = 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 爬樓梯：動態規劃 ###\ndef climbing_stairs_dp(n)\n  return n  if n == 1 || n == 2\n\n  # 初始化 dp 表，用於儲存子問題的解\n  dp = Array.new(n + 1, 0)\n  # 初始狀態：預設最小子問題的解\n  dp[1], dp[2] = 1, 2\n  # 狀態轉移：從較小子問題逐步求解較大子問題\n  (3...(n + 1)).each { |i| dp[i] = dp[i - 1] + dp[i - 2] }\n\n  dp[n]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-5 模擬了以上程式碼的執行過程。</p> <p></p> <p> 圖 14-5   爬樓梯的動態規劃過程 </p> <p>與回溯演算法一樣，動態規劃也使用“狀態”概念來表示問題求解的特定階段，每個狀態都對應一個子問題以及相應的區域性最優解。例如，爬樓梯問題的狀態定義為當前所在樓梯階數 \\(i\\) 。</p> <p>根據以上內容，我們可以總結出動態規劃的常用術語。</p> <ul> <li>將陣列 <code>dp</code> 稱為 dp 表，\\(dp[i]\\) 表示狀態 \\(i\\) 對應子問題的解。</li> <li>將最小子問題對應的狀態（第 \\(1\\) 階和第 \\(2\\) 階樓梯）稱為初始狀態。</li> <li>將遞推公式 \\(dp[i] = dp[i-1] + dp[i-2]\\) 稱為狀態轉移方程。</li> </ul>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","level":2,"title":"14.1.4   空間最佳化","text":"<p>細心的讀者可能發現了，由於 \\(dp[i]\\) 只與 \\(dp[i-1]\\) 和 \\(dp[i-2]\\) 有關，因此我們無須使用一個陣列 <code>dp</code> 來儲存所有子問題的解，而只需兩個變數滾動前進即可。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby climbing_stairs_dp.py<pre><code>def climbing_stairs_dp_comp(n: int) -&gt; int:\n    \"\"\"爬樓梯：空間最佳化後的動態規劃\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n</code></pre> climbing_stairs_dp.cpp<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.java<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.cs<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.go<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // 狀態轉移：從較小子問題逐步求解較大子問題\n    for i := 3; i &lt;= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.swift<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunc climbingStairsDPComp(n: Int) -&gt; Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.js<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.ts<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i &lt;= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.dart<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i &lt;= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n</code></pre> climbing_stairs_dp.rs<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfn climbing_stairs_dp_comp(n: usize) -&gt; i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n</code></pre> climbing_stairs_dp.c<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i &lt;= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n</code></pre> climbing_stairs_dp.kt<pre><code>/* 爬樓梯：空間最佳化後的動態規劃 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val temp = b\n        b += a\n        a = temp\n    }\n    return b\n}\n</code></pre> climbing_stairs_dp.rb<pre><code>### 爬樓梯：空間最佳化後的動態規劃 ###\ndef climbing_stairs_dp_comp(n)\n  return n if n == 1 || n == 2\n\n  a, b = 1, 2\n  (3...(n + 1)).each { a, b = b, a + b }\n\n  b\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察以上程式碼，由於省去了陣列 <code>dp</code> 佔用的空間，因此空間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) 。</p> <p>在動態規劃問題中，當前狀態往往僅與前面有限個狀態有關，這時我們可以只保留必要的狀態，透過“降維”來節省記憶體空間。這種空間最佳化技巧被稱為“滾動變數”或“滾動陣列”。</p>","path":["第 14 章 &nbsp; 動態規劃","14.1 &nbsp; 初探動態規劃"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/","level":1,"title":"14.4   0-1 背包問題","text":"<p>背包問題是一個非常好的動態規劃入門題目，是動態規劃中最常見的問題形式。其具有很多變種，例如 0-1 背包問題、完全背包問題、多重背包問題等。</p> <p>在本節中，我們先來求解最常見的 0-1 背包問題。</p> <p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品只能選擇一次，問在限定背包容量下能放入物品的最大價值。</p> <p>觀察圖 14-17 ，由於物品編號 \\(i\\) 從 \\(1\\) 開始計數，陣列索引從 \\(0\\) 開始計數，因此物品 \\(i\\) 對應重量 \\(wgt[i-1]\\) 和價值 \\(val[i-1]\\) 。</p> <p></p> <p> 圖 14-17   0-1 背包的示例資料 </p> <p>我們可以將 0-1 背包問題看作一個由 \\(n\\) 輪決策組成的過程，對於每個物體都有不放入和放入兩種決策，因此該問題滿足決策樹模型。</p> <p>該問題的目標是求解“在限定背包容量下能放入物品的最大價值”，因此較大機率是一個動態規劃問題。</p> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>對於每個物品來說，不放入背包，背包容量不變；放入背包，背包容量減小。由此可得狀態定義：當前物品編號 \\(i\\) 和背包容量 \\(c\\) ，記為 \\([i, c]\\) 。</p> <p>狀態 \\([i, c]\\) 對應的子問題為：前 \\(i\\) 個物品在容量為 \\(c\\) 的背包中的最大價值，記為 \\(dp[i, c]\\) 。</p> <p>待求解的是 \\(dp[n, cap]\\) ，因此需要一個尺寸為 \\((n+1) \\times (cap+1)\\) 的二維 \\(dp\\) 表。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>當我們做出物品 \\(i\\) 的決策後，剩餘的是前 \\(i-1\\) 個物品決策的子問題，可分為以下兩種情況。</p> <ul> <li>不放入物品 \\(i\\) ：背包容量不變，狀態變化為 \\([i-1, c]\\) 。</li> <li>放入物品 \\(i\\) ：背包容量減少 \\(wgt[i-1]\\) ，價值增加 \\(val[i-1]\\) ，狀態變化為 \\([i-1, c-wgt[i-1]]\\) 。</li> </ul> <p>上述分析向我們揭示了本題的最優子結構：最大價值 \\(dp[i, c]\\) 等於不放入物品 \\(i\\) 和放入物品 \\(i\\) 兩種方案中價值更大的那一個。由此可推導出狀態轉移方程：</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\] <p>需要注意的是，若當前物品重量 \\(wgt[i - 1]\\) 超出剩餘背包容量 \\(c\\) ，則只能選擇不放入背包。</p> <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當無物品或背包容量為 \\(0\\) 時最大價值為 \\(0\\) ，即首列 \\(dp[i, 0]\\) 和首行 \\(dp[0, c]\\) 都等於 \\(0\\) 。</p> <p>當前狀態 \\([i, c]\\) 從上方的狀態 \\([i-1, c]\\) 和左上方的狀態 \\([i-1, c-wgt[i-1]]\\) 轉移而來，因此透過兩層迴圈正序走訪整個 \\(dp\\) 表即可。</p> <p>根據以上分析，我們接下來按順序實現暴力搜尋、記憶化搜尋、動態規劃解法。</p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#1","level":3,"title":"1.   方法一：暴力搜尋","text":"<p>搜尋程式碼包含以下要素。</p> <ul> <li>遞迴參數：狀態 \\([i, c]\\) 。</li> <li>返回值：子問題的解 \\(dp[i, c]\\) 。</li> <li>終止條件：當物品編號越界 \\(i = 0\\) 或背包剩餘容量為 \\(0\\) 時，終止遞迴並返回價值 \\(0\\) 。</li> <li>剪枝：若當前物品重量超出背包剩餘容量，則只能選擇不放入背包。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -&gt; int:\n    \"\"\"0-1 背包：暴力搜尋\"\"\"\n    # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 or c == 0:\n        return 0\n    # 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # 計算不放入和放入物品 i 的最大價值\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes);\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：暴力搜尋 */\nint KnapsackDFS(int[] weight, int[] val, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.Max(no, yes);\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：暴力搜尋 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i-1] &gt; c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    no := knapsackDFS(wgt, val, i-1, c)\n    yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]\n    // 返回兩種方案中價值更大的那一個\n    return int(math.Max(float64(no), float64(yes)))\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：暴力搜尋 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -&gt; Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：暴力搜尋 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：暴力搜尋 */\nfunction knapsackDFS(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    i: number,\n    c: number\n): number {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return Math.max(no, yes);\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(List&lt;int&gt; wgt, List&lt;int&gt; val, int i, int c) {\n  // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 若超過背包容量，則只能選擇不放入背包\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // 計算不放入和放入物品 i 的最大價值\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 返回兩種方案中價值更大的那一個\n  return max(no, yes);\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：暴力搜尋 */\nfn knapsack_dfs(wgt: &amp;[i32], val: &amp;[i32], i: usize, c: usize) -&gt; i32 {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    std::cmp::max(no, yes)\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：暴力搜尋 */\nint knapsackDFS(int wgt[], int val[], int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 返回兩種方案中價值更大的那一個\n    return myMax(no, yes);\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：暴力搜尋 */\nfun knapsackDFS(\n    wgt: IntArray,\n    _val: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFS(wgt, _val, i - 1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    val no = knapsackDFS(wgt, _val, i - 1, c)\n    val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 返回兩種方案中價值更大的那一個\n    return max(no, yes)\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：暴力搜尋 ###\ndef knapsack_dfs(wgt, val, i, c)\n  # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  return 0 if i == 0 || c == 0\n  # 若超過背包容量，則只能選擇不放入背包\n  return knapsack_dfs(wgt, val, i - 1, c) if wgt[i - 1] &gt; c\n  # 計算不放入和放入物品 i 的最大價值\n  no = knapsack_dfs(wgt, val, i - 1, c)\n  yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 返回兩種方案中價值更大的那一個\n  [no, yes].max\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-18 所示，由於每個物品都會產生不選和選兩條搜尋分支，因此時間複雜度為 \\(O(2^n)\\) 。</p> <p>觀察遞迴樹，容易發現其中存在重疊子問題，例如 \\(dp[1, 10]\\) 等。而當物品較多、背包容量較大，尤其是相同重量的物品較多時，重疊子問題的數量將會大幅增多。</p> <p></p> <p> 圖 14-18   0-1 背包問題的暴力搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#2","level":3,"title":"2.   方法二：記憶化搜尋","text":"<p>為了保證重疊子問題只被計算一次，我們藉助記憶串列 <code>mem</code> 來記錄子問題的解，其中 <code>mem[i][c]</code> 對應 \\(dp[i, c]\\) 。</p> <p>引入記憶化之後，時間複雜度取決於子問題數量，也就是 \\(O(n \\times cap)\\) 。實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dfs_mem(\n    wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -&gt; int:\n    \"\"\"0-1 背包：記憶化搜尋\"\"\"\n    # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 or c == 0:\n        return 0\n    # 若已有記錄，則直接返回\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c:\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    # 計算不放入和放入物品 i 的最大價值\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n    # 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, vector&lt;vector&lt;int&gt;&gt; &amp;mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：記憶化搜尋 */\nint KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (weight[i - 1] &gt; c) {\n        return KnapsackDFSMem(weight, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i-1] &gt; c {\n        return knapsackDFSMem(wgt, val, mem, i-1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]\n    // 返回兩種方案中價值更大的那一個\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -&gt; Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &amp;mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：記憶化搜尋 */\nfunction knapsackDFSMem(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    mem: Array&lt;Array&lt;number&gt;&gt;,\n    i: number,\n    c: number\n): number {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(\n  List&lt;int&gt; wgt,\n  List&lt;int&gt; val,\n  List&lt;List&lt;int&gt;&gt; mem,\n  int i,\n  int c,\n) {\n  // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // 若已有記錄，則直接返回\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // 若超過背包容量，則只能選擇不放入背包\n  if (wgt[i - 1] &gt; c) {\n    return knapsackDFSMem(wgt, val, mem, i - 1, c);\n  }\n  // 計算不放入和放入物品 i 的最大價值\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n  // 記錄並返回兩種方案中價值更大的那一個\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：記憶化搜尋 */\nfn knapsack_dfs_mem(wgt: &amp;[i32], val: &amp;[i32], mem: &amp;mut Vec&lt;Vec&lt;i32&gt;&gt;, i: usize, c: usize) -&gt; i32 {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if wgt[i - 1] &gt; c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：記憶化搜尋 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：記憶化搜尋 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    _val: IntArray,\n    mem: Array&lt;IntArray&gt;,\n    i: Int,\n    c: Int\n): Int {\n    // 若已選完所有物品或背包無剩餘容量，則返回價值 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // 若已有記錄，則直接返回\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // 若超過背包容量，則只能選擇不放入背包\n    if (wgt[i - 1] &gt; c) {\n        return knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    }\n    // 計算不放入和放入物品 i 的最大價值\n    val no = knapsackDFSMem(wgt, _val, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1]\n    // 記錄並返回兩種方案中價值更大的那一個\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：記憶化搜尋 ###\ndef knapsack_dfs_mem(wgt, val, mem, i, c)\n  # 若已選完所有物品或背包無剩餘容量，則返回價值 0\n  return 0 if i == 0 || c == 0\n  # 若已有記錄，則直接返回\n  return mem[i][c] if mem[i][c] != -1\n  # 若超過背包容量，則只能選擇不放入背包\n  return knapsack_dfs_mem(wgt, val, mem, i - 1, c) if wgt[i - 1] &gt; c\n  # 計算不放入和放入物品 i 的最大價值\n  no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n  yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n  # 記錄並返回兩種方案中價值更大的那一個\n  mem[i][c] = [no, yes].max\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-19 展示了在記憶化搜尋中被剪掉的搜尋分支。</p> <p></p> <p> 圖 14-19   0-1 背包問題的記憶化搜尋遞迴樹 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#3","level":3,"title":"3.   方法三：動態規劃","text":"<p>動態規劃實質上就是在狀態轉移中填充 \\(dp\\) 表的過程，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 背包：動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：動態規劃 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (weight[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：動態規劃 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：動態規劃 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：動態規劃 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() =&gt; Array(cap + 1).fill(0));\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：動態規劃 */\nfunction knapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：動態規劃 */\nfn knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：動態規劃 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：動態規劃 */\nfun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：動態規劃 ###\ndef knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 14-20 所示，時間複雜度和空間複雜度都由陣列 <code>dp</code> 大小決定，即 \\(O(n \\times cap)\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-20   0-1 背包問題的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/knapsack_problem/#4","level":3,"title":"4.   空間最佳化","text":"<p>由於每個狀態都只與其上一行的狀態有關，因此我們可以使用兩個陣列滾動前進，將空間複雜度從 \\(O(n^2)\\) 降至 \\(O(n)\\) 。</p> <p>進一步思考，我們能否僅用一個陣列實現空間最佳化呢？觀察可知，每個狀態都是由正上方或左上方的格子轉移過來的。假設只有一個陣列，當開始走訪第 \\(i\\) 行時，該陣列儲存的仍然是第 \\(i-1\\) 行的狀態。</p> <ul> <li>如果採取正序走訪，那麼走訪到 \\(dp[i, j]\\) 時，左上方 \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) 值可能已經被覆蓋，此時就無法得到正確的狀態轉移結果。</li> <li>如果採取倒序走訪，則不會發生覆蓋問題，狀態轉移可以正確進行。</li> </ul> <p>圖 14-21 展示了在單個陣列下從第 \\(i = 1\\) 行轉換至第 \\(i = 2\\) 行的過程。請思考正序走訪和倒序走訪的區別。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-21   0-1 背包的空間最佳化後的動態規劃過程 </p> <p>在程式碼實現中，我們僅需將陣列 <code>dp</code> 的第一維 \\(i\\) 直接刪除，並且把內迴圈更改為倒序走訪即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby knapsack.py<pre><code>def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"0-1 背包：空間最佳化後的動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [0] * (cap + 1)\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 倒序走訪\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> knapsack.cpp<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.java<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.cs<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt; 0; c--) {\n            if (weight[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.go<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([]int, cap+1)\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 倒序走訪\n        for c := cap; c &gt;= 1; c-- {\n            if wgt[i-1] &lt;= c {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.swift<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        // 倒序走訪\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] &lt;= c {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.js<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(cap + 1).fill(0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.ts<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfunction knapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array(cap + 1).fill(0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (let c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> knapsack.dart<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    // 倒序走訪\n    for (int c = cap; c &gt;= 1; c--) {\n      if (wgt[i - 1] &lt;= c) {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> knapsack.rs<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfn knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; cap + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        // 倒序走訪\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] &lt;= c as i32 {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> knapsack.c<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        // 倒序走訪\n        for (int c = cap; c &gt;= 1; c--) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> knapsack.kt<pre><code>/* 0-1 背包：空間最佳化後的動態規劃 */\nfun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = IntArray(cap + 1)\n    // 狀態轉移\n    for (i in 1..n) {\n        // 倒序走訪\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] &lt;= c) {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> knapsack.rb<pre><code>### 0-1 背包：空間最佳化後的動態規劃 ###\ndef knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(cap + 1, 0)\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 倒序走訪\n    for c in cap.downto(1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[c] = dp[c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.4 &nbsp; 0-1 背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/summary/","level":1,"title":"14.7   小結","text":"","path":["第 14 章 &nbsp; 動態規劃","14.7 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>動態規劃對問題進行分解，並透過儲存子問題的解來規避重複計算，提高計算效率。</li> <li>不考慮時間的前提下，所有動態規劃問題都可以用回溯（暴力搜尋）進行求解，但遞迴樹中存在大量的重疊子問題，效率極低。透過引入記憶化串列，可以儲存所有計算過的子問題的解，從而保證重疊子問題只被計算一次。</li> <li>記憶化搜尋是一種從頂至底的遞迴式解法，而與之對應的動態規劃是一種從底至頂的遞推式解法，其如同“填寫表格”一樣。由於當前狀態僅依賴某些區域性狀態，因此我們可以消除 \\(dp\\) 表的一個維度，從而降低空間複雜度。</li> <li>子問題分解是一種通用的演算法思路，在分治、動態規劃、回溯中具有不同的性質。</li> <li>動態規劃問題有三大特性：重疊子問題、最優子結構、無後效性。</li> <li>如果原問題的最優解可以從子問題的最優解構建得來，則它就具有最優子結構。</li> <li>無後效性指對於一個狀態，其未來發展只與該狀態有關，而與過去經歷的所有狀態無關。許多組合最佳化問題不具有無後效性，無法使用動態規劃快速求解。</li> </ul> <p>背包問題</p> <ul> <li>背包問題是最典型的動態規劃問題之一，具有 0-1 背包、完全背包、多重背包等變種。</li> <li>0-1 背包的狀態定義為前 \\(i\\) 個物品在容量為 \\(c\\) 的背包中的最大價值。根據不放入背包和放入背包兩種決策，可得到最優子結構，並構建出狀態轉移方程。在空間最佳化中，由於每個狀態依賴正上方和左上方的狀態，因此需要倒序走訪串列，避免左上方狀態被覆蓋。</li> <li>完全背包問題的每種物品的選取數量無限制，因此選擇放入物品的狀態轉移與 0-1 背包問題不同。由於狀態依賴正上方和正左方的狀態，因此在空間最佳化中應當正序走訪。</li> <li>零錢兌換問題是完全背包問題的一個變種。它從求“最大”價值變為求“最小”硬幣數量，因此狀態轉移方程中的 \\(\\max()\\) 應改為 \\(\\min()\\) 。從追求“不超過”背包容量到追求“恰好”湊出目標金額，因此使用 \\(amt + 1\\) 來表示“無法湊出目標金額”的無效解。</li> <li>零錢兌換問題 II 從求“最少硬幣數量”改為求“硬幣組合數量”，狀態轉移方程相應地從 \\(\\min()\\) 改為求和運算子。</li> </ul> <p>編輯距離問題</p> <ul> <li>編輯距離（Levenshtein 距離）用於衡量兩個字串之間的相似度，其定義為從一個字串到另一個字串的最少編輯步數，編輯操作包括新增、刪除、替換。</li> <li>編輯距離問題的狀態定義為將 \\(s\\) 的前 \\(i\\) 個字元更改為 \\(t\\) 的前 \\(j\\) 個字元所需的最少編輯步數。當 \\(s[i] \\ne t[j]\\) 時，具有三種決策：新增、刪除、替換，它們都有相應的剩餘子問題。據此便可以找出最優子結構與構建狀態轉移方程。而當 \\(s[i] = t[j]\\) 時，無須編輯當前字元。</li> <li>在編輯距離中，狀態依賴其正上方、正左方、左上方的狀態，因此空間最佳化後正序或倒序走訪都無法正確地進行狀態轉移。為此，我們利用一個變數暫存左上方狀態，從而轉化到與完全背包問題等價的情況，可以在空間最佳化後進行正序走訪。</li> </ul>","path":["第 14 章 &nbsp; 動態規劃","14.7 &nbsp; 小結"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","level":1,"title":"14.5   完全背包問題","text":"<p>在本節中，我們先求解另一個常見的背包問題：完全背包，再瞭解它的一種特例：零錢兌換。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","level":2,"title":"14.5.1   完全背包問題","text":"<p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品可以重複選取，問在限定背包容量下能放入物品的最大價值。示例如圖 14-22 所示。</p> <p></p> <p> 圖 14-22   完全背包問題的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","level":3,"title":"1.   動態規劃思路","text":"<p>完全背包問題和 0-1 背包問題非常相似，區別僅在於不限制物品的選擇次數。</p> <ul> <li>在 0-1 背包問題中，每種物品只有一個，因此將物品 \\(i\\) 放入背包後，只能從前 \\(i-1\\) 個物品中選擇。</li> <li>在完全背包問題中，每種物品的數量是無限的，因此將物品 \\(i\\) 放入背包後，仍可以從前 \\(i\\) 個物品中選擇。</li> </ul> <p>在完全背包問題的規定下，狀態 \\([i, c]\\) 的變化分為兩種情況。</p> <ul> <li>不放入物品 \\(i\\) ：與 0-1 背包問題相同，轉移至 \\([i-1, c]\\) 。</li> <li>放入物品 \\(i\\) ：與 0-1 背包問題不同，轉移至 \\([i, c-wgt[i-1]]\\) 。</li> </ul> <p>從而狀態轉移方程變為：</p> \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>對比兩道題目的程式碼，狀態轉移中有一處從 \\(i-1\\) 變為 \\(i\\) ，其餘完全一致：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全背包：動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(cap + 1, 0));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全背包：動態規劃 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i, c] = dp[i - 1, c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全背包：動態規劃 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i-1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全背包：動態規劃 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全背包：動態規劃 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全背包：動態規劃 */\nfunction unboundedKnapsackDP(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: cap + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(cap + 1, 0));\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全背包：動態規劃 */\nfn unbounded_knapsack_dp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全背包：動態規劃 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全背包：動態規劃 */\nfun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[i][c] = dp[i - 1][c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全背包：動態規劃 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","level":3,"title":"3.   空間最佳化","text":"<p>由於當前狀態是從左邊和上邊的狀態轉移而來的，因此空間最佳化後應該對 \\(dp\\) 表中的每一行進行正序走訪。</p> <p>這個走訪順序與 0-1 背包正好相反。請藉助圖 14-23 來理解兩者的區別。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-23   完全背包問題在空間最佳化後的動態規劃過程 </p> <p>程式碼實現比較簡單，僅需將陣列 <code>dp</code> 的第一維刪除：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby unbounded_knapsack.py<pre><code>def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"完全背包：空間最佳化後的動態規劃\"\"\"\n    n = len(wgt)\n    # 初始化 dp 表\n    dp = [0] * (cap + 1)\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for c in range(1, cap + 1):\n            if wgt[i - 1] &gt; c:\n                # 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            else:\n                # 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n</code></pre> unbounded_knapsack.cpp<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    int n = wgt.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(cap + 1, 0);\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.java<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.cs<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // 初始化 dp 表\n    int[] dp = new int[cap + 1];\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.go<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // 初始化 dp 表\n    dp := make([]int, cap+1)\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        for c := 1; c &lt;= cap; c++ {\n            if wgt[i-1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.swift<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -&gt; Int {\n    let n = wgt.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: cap + 1)\n    // 狀態轉移\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] &gt; c {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.js<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.ts<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array&lt;number&gt;,\n    val: Array&lt;number&gt;,\n    cap: number\n): number {\n    const n = wgt.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: cap + 1 }, () =&gt; 0);\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n</code></pre> unbounded_knapsack.dart<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  int n = wgt.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(cap + 1, 0);\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int c = 1; c &lt;= cap; c++) {\n      if (wgt[i - 1] &gt; c) {\n        // 若超過背包容量，則不選物品 i\n        dp[c] = dp[c];\n      } else {\n        // 不選和選物品 i 這兩種方案的較大值\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n</code></pre> unbounded_knapsack.rs<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfn unbounded_knapsack_dp_comp(wgt: &amp;[i32], val: &amp;[i32], cap: usize) -&gt; i32 {\n    let n = wgt.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; cap + 1];\n    // 狀態轉移\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] &gt; c as i32 {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n</code></pre> unbounded_knapsack.c<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // 初始化 dp 表\n    int *dp = calloc(cap + 1, sizeof(int));\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int c = 1; c &lt;= cap; c++) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c];\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> unbounded_knapsack.kt<pre><code>/* 完全背包：空間最佳化後的動態規劃 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    _val: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // 初始化 dp 表\n    val dp = IntArray(cap + 1)\n    // 狀態轉移\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] &gt; c) {\n                // 若超過背包容量，則不選物品 i\n                dp[c] = dp[c]\n            } else {\n                // 不選和選物品 i 這兩種方案的較大值\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n</code></pre> unbounded_knapsack.rb<pre><code>### 完全背包：動態規劃 ###\ndef unbounded_knapsack_dp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(cap + 1, 0) }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for c in 1...(cap + 1)\n      if wgt[i - 1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[i][c] = dp[i - 1][c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[n][cap]\nend\n\n### 完全背包：空間最佳化後的動態規劃 ##3\ndef unbounded_knapsack_dp_comp(wgt, val, cap)\n  n = wgt.length\n  # 初始化 dp 表\n  dp = Array.new(cap + 1, 0)\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for c in 1...(cap + 1)\n      if wgt[i -1] &gt; c\n        # 若超過背包容量，則不選物品 i\n        dp[c] = dp[c]\n      else\n        # 不選和選物品 i 這兩種方案的較大值\n        dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max\n      end\n    end\n  end\n  dp[cap]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","level":2,"title":"14.5.2   零錢兌換問題","text":"<p>背包問題是一大類動態規劃問題的代表，其擁有很多變種，例如零錢兌換問題。</p> <p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 \\(-1\\) 。示例如圖 14-24 所示。</p> <p></p> <p> 圖 14-24   零錢兌換問題的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","level":3,"title":"1.   動態規劃思路","text":"<p>零錢兌換可以看作完全背包問題的一種特殊情況，兩者具有以下關聯與不同點。</p> <ul> <li>兩道題可以相互轉換，“物品”對應“硬幣”、“物品重量”對應“硬幣面值”、“背包容量”對應“目標金額”。</li> <li>最佳化目標相反，完全背包問題是要最大化物品價值，零錢兌換問題是要最小化硬幣數量。</li> <li>完全背包問題是求“不超過”背包容量下的解，零錢兌換是求“恰好”湊到目標金額的解。</li> </ul> <p>第一步：思考每輪的決策，定義狀態，從而得到 \\(dp\\) 表</p> <p>狀態 \\([i, a]\\) 對應的子問題為：前 \\(i\\) 種硬幣能夠湊出金額 \\(a\\) 的最少硬幣數量，記為 \\(dp[i, a]\\) 。</p> <p>二維 \\(dp\\) 表的尺寸為 \\((n+1) \\times (amt+1)\\) 。</p> <p>第二步：找出最優子結構，進而推導出狀態轉移方程</p> <p>本題與完全背包問題的狀態轉移方程存在以下兩點差異。</p> <ul> <li>本題要求最小值，因此需將運算子 \\(\\max()\\) 更改為 \\(\\min()\\) 。</li> <li>最佳化主體是硬幣數量而非商品價值，因此在選中硬幣時執行 \\(+1\\) 即可。</li> </ul> \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\] <p>第三步：確定邊界條件和狀態轉移順序</p> <p>當目標金額為 \\(0\\) 時，湊出它的最少硬幣數量為 \\(0\\) ，即首列所有 \\(dp[i, 0]\\) 都等於 \\(0\\) 。</p> <p>當無硬幣時，無法湊出任意 \\(&gt; 0\\) 的目標金額，即是無效解。為使狀態轉移方程中的 \\(\\min()\\) 函式能夠識別並過濾無效解，我們考慮使用 \\(+ \\infty\\) 來表示它們，即令首行所有 \\(dp[0, a]\\) 都等於 \\(+ \\infty\\) 。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","level":3,"title":"2.   程式碼實現","text":"<p>大多數程式語言並未提供 \\(+ \\infty\\) 變數，只能使用整型 <code>int</code> 的最大值來代替。而這又會導致大數越界：狀態轉移方程中的 \\(+ 1\\) 操作可能發生溢位。</p> <p>為此，我們採用數字 \\(amt + 1\\) 來表示無效解，因為湊出 \\(amt\\) 的硬幣數量最多為 \\(amt\\) 。最後返回前，判斷 \\(dp[n, amt]\\) 是否等於 \\(amt + 1\\) ，若是則返回 \\(-1\\) ，代表無法湊出目標金額。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：動態規劃\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # 初始化 dp 表\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 狀態轉移：首行首列\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # 狀態轉移：其餘行和列\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][amt + 1];\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* 零錢兌換：動態規劃 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, amt + 1];\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 狀態轉移：首行首列\n    for a := 1; a &lt;= amt; a++ {\n        dp[0][a] = max\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 狀態轉移：首行首列\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* 零錢兌換：動態規劃 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* 零錢兌換：動態規劃 */\nfunction coinChangeDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 狀態轉移：首行首列\n    for (let a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 狀態轉移：首行首列\n  for (int a = 1; a &lt;= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // 狀態轉移：其餘行和列\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案的較小值\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* 零錢兌換：動態規劃 */\nfn coin_change_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 狀態轉移：首行首列\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // 狀態轉移：其餘行和列\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* 零錢兌換：動態規劃 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 狀態轉移：首行首列\n    for (int a = 1; a &lt;= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // 狀態轉移：其餘行和列\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* 零錢兌換：動態規劃 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 狀態轉移：首行首列\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // 狀態轉移：其餘行和列\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### 零錢兌換：動態規劃 ###\ndef coin_change_dp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 狀態轉移：首行首列\n  (1...(amt + 1)).each { |a| dp[0][a] = _MAX }\n  # 狀態轉移：其餘行和列\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 不選和選硬幣 i 這兩種方案的較小值\n        dp[i][a] = [dp[i - 1][a], dp[i][a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[n][amt] != _MAX ? dp[n][amt] : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>圖 14-25 展示了零錢兌換的動態規劃過程，和完全背包問題非常相似。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt;&lt;13&gt;&lt;14&gt;&lt;15&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 14-25   零錢兌換問題的動態規劃過程 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","level":3,"title":"3.   空間最佳化","text":"<p>零錢兌換的空間最佳化的處理方式和完全背包問題一致：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change.py<pre><code>def coin_change_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：空間最佳化後的動態規劃\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # 初始化 dp 表\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            else:\n                # 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n</code></pre> coin_change.cpp<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(amt + 1, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.java<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.cs<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.go<pre><code>/* 零錢兌換：動態規劃 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // 初始化 dp 表\n    dp := make([]int, amt+1)\n    for i := 1; i &lt;= amt; i++ {\n        dp[i] = max\n    }\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 正序走訪\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n</code></pre> coin_change.swift<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // 初始化 dp 表\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n</code></pre> coin_change.js<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.ts<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfunction coinChangeDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; MAX);\n    dp[0] = 0;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.dart<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案的較小值\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n</code></pre> coin_change.rs<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfn coin_change_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // 初始化 dp 表\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change.c<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // 初始化 dp 表\n    int *dp = malloc((amt + 1) * sizeof(int));\n    for (int j = 1; j &lt;= amt; j++) {\n        dp[j] = MAX;\n    } \n    dp[0] = 0;\n\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> coin_change.kt<pre><code>/* 零錢兌換：空間最佳化後的動態規劃 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // 初始化 dp 表\n    val dp = IntArray(amt + 1)\n    dp.fill(MAX)\n    dp[0] = 0\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案的較小值\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n</code></pre> coin_change.rb<pre><code>### 零錢兌換：空間最佳化後的動態規劃 ###\ndef coin_change_dp_comp(coins, amt)\n  n = coins.length\n  _MAX = amt + 1\n  # 初始化 dp 表\n  dp = Array.new(amt + 1, _MAX)\n  dp[0] = 0\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a]\n      else\n        # 不選和選硬幣 i 這兩種方案的較小值\n        dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min\n      end\n    end\n  end\n  dp[amt] != _MAX ? dp[amt] : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","level":2,"title":"14.5.3   零錢兌換問題 II","text":"<p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問湊出目標金額的硬幣組合數量。示例如圖 14-26 所示。</p> <p></p> <p> 圖 14-26   零錢兌換問題 II 的示例資料 </p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","level":3,"title":"1.   動態規劃思路","text":"<p>相比於上一題，本題目標是求組合數量，因此子問題變為：前 \\(i\\) 種硬幣能夠湊出金額 \\(a\\) 的組合數量。而 \\(dp\\) 表仍然是尺寸為 \\((n+1) \\times (amt + 1)\\) 的二維矩陣。</p> <p>當前狀態的組合數量等於不選當前硬幣與選當前硬幣這兩種決策的組合數量之和。狀態轉移方程為：</p> \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\] <p>當目標金額為 \\(0\\) 時，無須選擇任何硬幣即可湊出目標金額，因此應將首列所有 \\(dp[i, 0]\\) 都初始化為 \\(1\\) 。當無硬幣時，無法湊出任何 \\(&gt;0\\) 的目標金額，因此首行所有 \\(dp[0, a]\\) 都等於 \\(0\\) 。</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","level":3,"title":"2.   程式碼實現","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換 II：動態規劃\"\"\"\n    n = len(coins)\n    # 初始化 dp 表\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # 初始化首列\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # 狀態轉移\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // 初始化 dp 表\n    vector&lt;vector&lt;int&gt;&gt; dp(n + 1, vector&lt;int&gt;(amt + 1, 0));\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // 初始化 dp 表\n    int[][] dp = new int[n + 1][amt + 1];\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* 零錢兌換 II：動態規劃 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // 初始化 dp 表\n    int[,] dp = new int[n + 1, amt + 1];\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* 零錢兌換 II：動態規劃 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // 初始化 dp 表\n    dp := make([][]int, n+1)\n    for i := 0; i &lt;= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // 初始化首列\n    for i := 0; i &lt;= n; i++ {\n        dp[i][0] = 1\n    }\n    // 狀態轉移：其餘行和列\n    for i := 1; i &lt;= n; i++ {\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* 零錢兌換 II：動態規劃 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // 初始化 dp 表\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // 初始化首列\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* 零錢兌換 II：動態規劃 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 初始化首列\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* 零錢兌換 II：動態規劃 */\nfunction coinChangeIIDP(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: n + 1 }, () =&gt;\n        Array.from({ length: amt + 1 }, () =&gt; 0)\n    );\n    // 初始化首列\n    for (let i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // 初始化 dp 表\n  List&lt;List&lt;int&gt;&gt; dp = List.generate(n + 1, (index) =&gt; List.filled(amt + 1, 0));\n  // 初始化首列\n  for (int i = 0; i &lt;= n; i++) {\n    dp[i][0] = 1;\n  }\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案之和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* 零錢兌換 II：動態規劃 */\nfn coin_change_ii_dp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // 初始化 dp 表\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // 初始化首列\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* 零錢兌換 II：動態規劃 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // 初始化 dp 表\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // 初始化首列\n    for (int i = 0; i &lt;= n; i++) {\n        dp[i][0] = 1;\n    }\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // 釋放記憶體\n    for (int i = 0; i &lt;= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* 零錢兌換 II：動態規劃 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // 初始化 dp 表\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // 初始化首列\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### 零錢兌換 II：動態規劃 ###\ndef coin_change_ii_dp(coins, amt)\n  n = coins.length\n  # 初始化 dp 表\n  dp = Array.new(n + 1) { Array.new(amt + 1, 0) }\n  # 初始化首列\n  (0...(n + 1)).each { |i| dp[i][0] = 1 }\n  # 狀態轉移\n  for i in 1...(n + 1)\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[i][a] = dp[i - 1][a]\n      else\n        # 不選和選硬幣 i 這兩種方案之和\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n      end\n    end\n  end\n  dp[n][amt]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","level":3,"title":"3.   空間最佳化","text":"<p>空間最佳化處理方式相同，刪除硬幣維度即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_ii.py<pre><code>def coin_change_ii_dp_comp(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換 II：空間最佳化後的動態規劃\"\"\"\n    n = len(coins)\n    # 初始化 dp 表\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # 狀態轉移\n    for i in range(1, n + 1):\n        # 正序走訪\n        for a in range(1, amt + 1):\n            if coins[i - 1] &gt; a:\n                # 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            else:\n                # 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n</code></pre> coin_change_ii.cpp<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(vector&lt;int&gt; &amp;coins, int amt) {\n    int n = coins.size();\n    // 初始化 dp 表\n    vector&lt;int&gt; dp(amt + 1, 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.java<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.cs<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // 初始化 dp 表\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.go<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // 初始化 dp 表\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // 狀態轉移\n    for i := 1; i &lt;= n; i++ {\n        // 正序走訪\n        for a := 1; a &lt;= amt; a++ {\n            if coins[i-1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.swift<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -&gt; Int {\n    let n = coins.count\n    // 初始化 dp 表\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // 狀態轉移\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] &gt; a {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.js<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.ts<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfunction coinChangeIIDPComp(coins: Array&lt;number&gt;, amt: number): number {\n    const n = coins.length;\n    // 初始化 dp 表\n    const dp = Array.from({ length: amt + 1 }, () =&gt; 0);\n    dp[0] = 1;\n    // 狀態轉移\n    for (let i = 1; i &lt;= n; i++) {\n        for (let a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n</code></pre> coin_change_ii.dart<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(List&lt;int&gt; coins, int amt) {\n  int n = coins.length;\n  // 初始化 dp 表\n  List&lt;int&gt; dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // 狀態轉移\n  for (int i = 1; i &lt;= n; i++) {\n    for (int a = 1; a &lt;= amt; a++) {\n      if (coins[i - 1] &gt; a) {\n        // 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a];\n      } else {\n        // 不選和選硬幣 i 這兩種方案之和\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n</code></pre> coin_change_ii.rs<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfn coin_change_ii_dp_comp(coins: &amp;[i32], amt: usize) -&gt; i32 {\n    let n = coins.len();\n    // 初始化 dp 表\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // 狀態轉移\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] &gt; a as i32 {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n</code></pre> coin_change_ii.c<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // 初始化 dp 表\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // 狀態轉移\n    for (int i = 1; i &lt;= n; i++) {\n        for (int a = 1; a &lt;= amt; a++) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a];\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // 釋放記憶體\n    free(dp);\n    return res;\n}\n</code></pre> coin_change_ii.kt<pre><code>/* 零錢兌換 II：空間最佳化後的動態規劃 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // 初始化 dp 表\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // 狀態轉移\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] &gt; a) {\n                // 若超過目標金額，則不選硬幣 i\n                dp[a] = dp[a]\n            } else {\n                // 不選和選硬幣 i 這兩種方案之和\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n</code></pre> coin_change_ii.rb<pre><code>### 零錢兌換 II：空間最佳化後的動態規劃 ###\ndef coin_change_ii_dp_comp(coins, amt)\n  n = coins.length\n  # 初始化 dp 表\n  dp = Array.new(amt + 1, 0)\n  dp[0] = 1\n  # 狀態轉移\n  for i in 1...(n + 1)\n    # 正序走訪\n    for a in 1...(amt + 1)\n      if coins[i - 1] &gt; a\n        # 若超過目標金額，則不選硬幣 i\n        dp[a] = dp[a]\n      else\n        # 不選和選硬幣 i 這兩種方案之和\n        dp[a] = dp[a] + dp[a - coins[i - 1]]\n      end\n    end\n  end\n  dp[amt]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 14 章 &nbsp; 動態規劃","14.5 &nbsp; 完全背包問題"],"tags":[]},{"location":"chapter_graph/","level":1,"title":"第 9 章   圖","text":"<p>Abstract</p> <p>在生命旅途中，我們就像是一個個節點，被無數看不見的邊相連。</p> <p>每一次的相識與相離，都在這張巨大的網路圖中留下獨特的印記。</p>","path":["第 9 章 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/#_1","level":2,"title":"本章內容","text":"<ul> <li>9.1   圖</li> <li>9.2   圖基礎操作</li> <li>9.3   圖的走訪</li> <li>9.4   小結</li> </ul>","path":["第 9 章 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/","level":1,"title":"9.1   圖","text":"<p>圖（graph）是一種非線性資料結構，由頂點（vertex）和邊（edge）組成。我們可以將圖 \\(G\\) 抽象地表示為一組頂點 \\(V\\) 和一組邊 \\(E\\) 的集合。以下示例展示了一個包含 5 個頂點和 7 條邊的圖。</p> \\[ \\begin{aligned} V &amp; = \\{ 1, 2, 3, 4, 5 \\} \\newline E &amp; = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G &amp; = \\{ V, E \\} \\newline \\end{aligned} \\] <p>如果將頂點看作節點，將邊看作連線各個節點的引用（指標），我們就可以將圖看作一種從鏈結串列拓展而來的資料結構。如圖 9-1 所示，相較於線性關係（鏈結串列）和分治關係（樹），網路關係（圖）的自由度更高，因而更為複雜。</p> <p></p> <p> 圖 9-1   鏈結串列、樹、圖之間的關係 </p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#911","level":2,"title":"9.1.1   圖的常見型別與術語","text":"<p>根據邊是否具有方向，可分為無向圖（undirected graph）和有向圖（directed graph），如圖 9-2 所示。</p> <ul> <li>在無向圖中，邊表示兩頂點之間的“雙向”連線關係，例如微信或 QQ 中的“好友關係”。</li> <li>在有向圖中，邊具有方向性，即 \\(A \\rightarrow B\\) 和 \\(A \\leftarrow B\\) 兩個方向的邊是相互獨立的，例如微博或抖音上的“關注”與“被關注”關係。</li> </ul> <p></p> <p> 圖 9-2   有向圖與無向圖 </p> <p>根據所有頂點是否連通，可分為連通圖（connected graph）和非連通圖（disconnected graph），如圖 9-3 所示。</p> <ul> <li>對於連通圖，從某個頂點出發，可以到達其餘任意頂點。</li> <li>對於非連通圖，從某個頂點出發，至少有一個頂點無法到達。</li> </ul> <p></p> <p> 圖 9-3   連通圖與非連通圖 </p> <p>我們還可以為邊新增“權重”變數，從而得到如圖 9-4 所示的有權圖（weighted graph）。例如在《王者榮耀》等手遊中，系統會根據共同遊戲時間來計算玩家之間的“親密度”，這種親密度網路就可以用有權圖來表示。</p> <p></p> <p> 圖 9-4   有權圖與無權圖 </p> <p>圖資料結構包含以下常用術語。</p> <ul> <li>鄰接（adjacency）：當兩頂點之間存在邊相連時，稱這兩頂點“鄰接”。在圖 9-4 中，頂點 1 的鄰接頂點為頂點 2、3、5。</li> <li>路徑（path）：從頂點 A 到頂點 B 經過的邊構成的序列被稱為從 A 到 B 的“路徑”。在圖 9-4 中，邊序列 1-5-2-4 是頂點 1 到頂點 4 的一條路徑。</li> <li>度（degree）：一個頂點擁有的邊數。對於有向圖，入度（in-degree）表示有多少條邊指向該頂點，出度（out-degree）表示有多少條邊從該頂點指出。</li> </ul>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#912","level":2,"title":"9.1.2   圖的表示","text":"<p>圖的常用表示方式包括“鄰接矩陣”和“鄰接表”。以下使用無向圖進行舉例。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#1","level":3,"title":"1.   鄰接矩陣","text":"<p>設圖的頂點數量為 \\(n\\) ，鄰接矩陣（adjacency matrix）使用一個 \\(n \\times n\\) 大小的矩陣來表示圖，每一行（列）代表一個頂點，矩陣元素代表邊，用 \\(1\\) 或 \\(0\\) 表示兩個頂點之間是否存在邊。</p> <p>如圖 9-5 所示，設鄰接矩陣為 \\(M\\)、頂點串列為 \\(V\\) ，那麼矩陣元素 \\(M[i, j] = 1\\) 表示頂點 \\(V[i]\\) 到頂點 \\(V[j]\\) 之間存在邊，反之 \\(M[i, j] = 0\\) 表示兩頂點之間無邊。</p> <p></p> <p> 圖 9-5   圖的鄰接矩陣表示 </p> <p>鄰接矩陣具有以下特性。</p> <ul> <li>在簡單圖中，頂點不能與自身相連，此時鄰接矩陣主對角線元素沒有意義。</li> <li>對於無向圖，兩個方向的邊等價，此時鄰接矩陣關於主對角線對稱。</li> <li>將鄰接矩陣的元素從 \\(1\\) 和 \\(0\\) 替換為權重，則可表示有權圖。</li> </ul> <p>使用鄰接矩陣表示圖時，我們可以直接訪問矩陣元素以獲取邊，因此增刪查改操作的效率很高，時間複雜度均為 \\(O(1)\\) 。然而，矩陣的空間複雜度為 \\(O(n^2)\\) ，記憶體佔用較多。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#2","level":3,"title":"2.   鄰接表","text":"<p>鄰接表（adjacency list）使用 \\(n\\) 個鏈結串列來表示圖，鏈結串列節點表示頂點。第 \\(i\\) 個鏈結串列對應頂點 \\(i\\) ，其中儲存了該頂點的所有鄰接頂點（與該頂點相連的頂點）。圖 9-6 展示了一個使用鄰接表儲存的圖的示例。</p> <p></p> <p> 圖 9-6   圖的鄰接表表示 </p> <p>鄰接表僅儲存實際存在的邊，而邊的總數通常遠小於 \\(n^2\\) ，因此它更加節省空間。然而，在鄰接表中需要透過走訪鏈結串列來查詢邊，因此其時間效率不如鄰接矩陣。</p> <p>觀察圖 9-6 ，鄰接表結構與雜湊表中的“鏈式位址”非常相似，因此我們也可以採用類似的方法來最佳化效率。比如當鏈結串列較長時，可以將鏈結串列轉化為 AVL 樹或紅黑樹，從而將時間效率從 \\(O(n)\\) 最佳化至 \\(O(\\log n)\\) ；還可以把鏈結串列轉換為雜湊表，從而將時間複雜度降至 \\(O(1)\\) 。</p>","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph/#913","level":2,"title":"9.1.3   圖的常見應用","text":"<p>如表 9-1 所示，許多現實系統可以用圖來建模，相應的問題也可以約化為圖計算問題。</p> <p> 表 9-1   現實生活中常見的圖 </p> 頂點 邊 圖計算問題 社交網路 使用者 好友關係 潛在好友推薦 地鐵線路 站點 站點間的連通性 最短路線推薦 太陽系 星體 星體間的萬有引力作用 行星軌道計算","path":["第 9 章 &nbsp; 圖","9.1 &nbsp; 圖"],"tags":[]},{"location":"chapter_graph/graph_operations/","level":1,"title":"9.2   圖的基礎操作","text":"<p>圖的基礎操作可分為對“邊”的操作和對“頂點”的操作。在“鄰接矩陣”和“鄰接表”兩種表示方法下，實現方式有所不同。</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#921","level":2,"title":"9.2.1   基於鄰接矩陣的實現","text":"<p>給定一個頂點數量為 \\(n\\) 的無向圖，則各種操作的實現方式如圖 9-7 所示。</p> <ul> <li>新增或刪除邊：直接在鄰接矩陣中修改指定的邊即可，使用 \\(O(1)\\) 時間。而由於是無向圖，因此需要同時更新兩個方向的邊。</li> <li>新增頂點：在鄰接矩陣的尾部新增一行一列，並全部填 \\(0\\) 即可，使用 \\(O(n)\\) 時間。</li> <li>刪除頂點：在鄰接矩陣中刪除一行一列。當刪除首行首列時達到最差情況，需要將 \\((n-1)^2\\) 個元素“向左上移動”，從而使用 \\(O(n^2)\\) 時間。</li> <li>初始化：傳入 \\(n\\) 個頂點，初始化長度為 \\(n\\) 的頂點串列 <code>vertices</code> ，使用 \\(O(n)\\) 時間；初始化 \\(n \\times n\\) 大小的鄰接矩陣 <code>adjMat</code> ，使用 \\(O(n^2)\\) 時間。</li> </ul> 初始化鄰接矩陣新增邊刪除邊新增頂點刪除頂點 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-7   鄰接矩陣的初始化、增刪邊、增刪頂點 </p> <p>以下是基於鄰接矩陣表示圖的實現程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_matrix.py<pre><code>class GraphAdjMat:\n    \"\"\"基於鄰接矩陣實現的無向圖類別\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"建構子\"\"\"\n        # 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n        self.vertices: list[int] = []\n        # 鄰接矩陣，行列索引對應“頂點索引”\n        self.adj_mat: list[list[int]] = []\n        # 新增頂點\n        for val in vertices:\n            self.add_vertex(val)\n        # 新增邊\n        # 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -&gt; int:\n        \"\"\"獲取頂點數量\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"新增頂點\"\"\"\n        n = self.size()\n        # 向頂點串列中新增新頂點的值\n        self.vertices.append(val)\n        # 在鄰接矩陣中新增一行\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # 在鄰接矩陣中新增一列\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"刪除頂點\"\"\"\n        if index &gt;= self.size():\n            raise IndexError()\n        # 在頂點串列中移除索引 index 的頂點\n        self.vertices.pop(index)\n        # 在鄰接矩陣中刪除索引 index 的行\n        self.adj_mat.pop(index)\n        # 在鄰接矩陣中刪除索引 index 的列\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\n        \"\"\"新增邊\"\"\"\n        # 參數 i, j 對應 vertices 元素索引\n        # 索引越界與相等處理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        # 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\n        \"\"\"刪除邊\"\"\"\n        # 參數 i, j 對應 vertices 元素索引\n        # 索引越界與相等處理\n        if i &lt; 0 or j &lt; 0 or i &gt;= self.size() or j &gt;= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"列印鄰接矩陣\"\"\"\n        print(\"頂點串列 =\", self.vertices)\n        print(\"鄰接矩陣 =\")\n        print_matrix(self.adj_mat)\n</code></pre> graph_adjacency_matrix.cpp<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vector&lt;int&gt; vertices;       // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    vector&lt;vector&lt;int&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n  public:\n    /* 建構子 */\n    GraphAdjMat(const vector&lt;int&gt; &amp;vertices, const vector&lt;vector&lt;int&gt;&gt; &amp;edges) {\n        // 新增頂點\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const vector&lt;int&gt; &amp;edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* 新增頂點 */\n    void addVertex(int val) {\n        int n = size();\n        // 向頂點串列中新增新頂點的值\n        vertices.push_back(val);\n        // 在鄰接矩陣中新增一行\n        adjMat.emplace_back(vector&lt;int&gt;(n, 0));\n        // 在鄰接矩陣中新增一列\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    void removeVertex(int index) {\n        if (index &gt;= size()) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.erase(vertices.begin() + index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.erase(adjMat.begin() + index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (vector&lt;int&gt; &amp;row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    void addEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    void removeEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n            throw out_of_range(\"頂點不存在\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    void print() {\n        cout &lt;&lt; \"頂點串列 = \";\n        printVector(vertices);\n        cout &lt;&lt; \"鄰接矩陣 =\" &lt;&lt; endl;\n        printVectorMatrix(adjMat);\n    }\n};\n</code></pre> graph_adjacency_matrix.java<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    List&lt;Integer&gt; vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    List&lt;List&lt;Integer&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList&lt;&gt;();\n        this.adjMat = new ArrayList&lt;&gt;();\n        // 新增頂點\n        for (int val : vertices) {\n            addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* 新增頂點 */\n    public void addVertex(int val) {\n        int n = size();\n        // 向頂點串列中新增新頂點的值\n        vertices.add(val);\n        // 在鄰接矩陣中新增一行\n        List&lt;Integer&gt; newRow = new ArrayList&lt;&gt;(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // 在鄰接矩陣中新增一列\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    public void removeVertex(int index) {\n        if (index &gt;= size())\n            throw new IndexOutOfBoundsException();\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (List&lt;Integer&gt; row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void addEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void removeEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* 列印鄰接矩陣 */\n    public void print() {\n        System.out.print(\"頂點串列 = \");\n        System.out.println(vertices);\n        System.out.println(\"鄰接矩陣 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.cs<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    List&lt;int&gt; vertices;     // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    List&lt;List&lt;int&gt;&gt; adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        foreach (int val in vertices) {\n            AddVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* 新增頂點 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // 向頂點串列中新增新頂點的值\n        vertices.Add(val);\n        // 在鄰接矩陣中新增一行\n        List&lt;int&gt; newRow = new(n);\n        for (int j = 0; j &lt; n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // 在鄰接矩陣中新增一列\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    public void RemoveVertex(int index) {\n        if (index &gt;= Size())\n            throw new IndexOutOfRangeException();\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.RemoveAt(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.RemoveAt(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        foreach (List&lt;int&gt; row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void AddEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    public void RemoveEdge(int i, int j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= Size() || j &gt;= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    public void Print() {\n        Console.Write(\"頂點串列 = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"鄰接矩陣 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.go<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\ntype graphAdjMat struct {\n    // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    vertices []int\n    // 鄰接矩陣，行列索引對應“頂點索引”\n    adjMat [][]int\n}\n\n/* 建構子 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // 新增頂點\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // 初始化圖\n    g := &amp;graphAdjMat{\n        vertices: vertices,\n        adjMat:   adjMat,\n    }\n    // 新增邊\n    // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* 獲取頂點數量 */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* 新增頂點 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // 向頂點串列中新增新頂點的值\n    g.vertices = append(g.vertices, val)\n    // 在鄰接矩陣中新增一行\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // 在鄰接矩陣中新增一列\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* 刪除頂點 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index &gt;= g.size() {\n        return\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // 在鄰接矩陣中刪除索引 index 的行\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // 在鄰接矩陣中刪除索引 index 的列\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\n}\n\n/* 新增邊 */\n// 參數 i, j 對應 vertices 元素索引\nfunc (g *graphAdjMat) addEdge(i, j int) {\n    // 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\n\n/* 刪除邊 */\n// 參數 i, j 對應 vertices 元素索引\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n    // 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= g.size() || j &gt;= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* 列印鄰接矩陣 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t頂點串列 = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t鄰接矩陣 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n</code></pre> graph_adjacency_matrix.swift<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    private var vertices: [Int] // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    private var adjMat: [[Int]] // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // 新增頂點\n        for val in vertices {\n            addVertex(val: val)\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    func size() -&gt; Int {\n        vertices.count\n    }\n\n    /* 新增頂點 */\n    func addVertex(val: Int) {\n        let n = size()\n        // 向頂點串列中新增新頂點的值\n        vertices.append(val)\n        // 在鄰接矩陣中新增一行\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // 在鄰接矩陣中新增一列\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* 刪除頂點 */\n    func removeVertex(index: Int) {\n        if index &gt;= size() {\n            fatalError(\"越界\")\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.remove(at: index)\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.remove(at: index)\n        // 在鄰接矩陣中刪除索引 index 的列\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    func addEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"越界\")\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    func removeEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j {\n            fatalError(\"越界\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 列印鄰接矩陣 */\n    func print() {\n        Swift.print(\"頂點串列 = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"鄰接矩陣 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.js<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vertices; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    adjMat; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* 新增頂點 */\n    addVertex(val) {\n        const n = this.size();\n        // 向頂點串列中新增新頂點的值\n        this.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        const newRow = [];\n        for (let j = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 在鄰接矩陣中新增一列\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    removeVertex(index) {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        this.vertices.splice(index, 1);\n\n        // 在鄰接矩陣中刪除索引 index 的行\n        this.adjMat.splice(index, 1);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    addEdge(i, j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    removeEdge(i, j) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    print() {\n        console.log('頂點串列 = ', this.vertices);\n        console.log('鄰接矩陣 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.ts<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n    vertices: number[]; // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    adjMat: number[][]; // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // 新增頂點\n        for (const val of vertices) {\n            this.addVertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* 新增頂點 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // 向頂點串列中新增新頂點的值\n        this.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        const newRow: number[] = [];\n        for (let j: number = 0; j &lt; n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // 在鄰接矩陣中新增一列\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    removeVertex(index: number): void {\n        if (index &gt;= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        this.vertices.splice(index, 1);\n\n        // 在鄰接矩陣中刪除索引 index 的行\n        this.adjMat.splice(index, 1);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    addEdge(i: number, j: number): void {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    removeEdge(i: number, j: number): void {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= this.size() || j &gt;= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    print(): void {\n        console.log('頂點串列 = ', this.vertices);\n        console.log('鄰接矩陣 =', this.adjMat);\n    }\n}\n</code></pre> graph_adjacency_matrix.dart<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat {\n  List&lt;int&gt; vertices = []; // 頂點元素，元素代表“頂點值”，索引代表“頂點索引”\n  List&lt;List&lt;int&gt;&gt; adjMat = []; //鄰接矩陣，行列索引對應“頂點索引”\n\n  /* 建構子 */\n  GraphAdjMat(List&lt;int&gt; vertices, List&lt;List&lt;int&gt;&gt; edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // 新增頂點\n    for (int val in vertices) {\n      addVertex(val);\n    }\n    // 新增邊\n    // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    for (List&lt;int&gt; e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* 獲取頂點數量 */\n  int size() {\n    return vertices.length;\n  }\n\n  /* 新增頂點 */\n  void addVertex(int val) {\n    int n = size();\n    // 向頂點串列中新增新頂點的值\n    vertices.add(val);\n    // 在鄰接矩陣中新增一行\n    List&lt;int&gt; newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // 在鄰接矩陣中新增一列\n    for (List&lt;int&gt; row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* 刪除頂點 */\n  void removeVertex(int index) {\n    if (index &gt;= size()) {\n      throw IndexError;\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    vertices.removeAt(index);\n    // 在鄰接矩陣中刪除索引 index 的行\n    adjMat.removeAt(index);\n    // 在鄰接矩陣中刪除索引 index 的列\n    for (List&lt;int&gt; row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* 新增邊 */\n  // 參數 i, j 對應 vertices 元素索引\n  void addEdge(int i, int j) {\n    // 索引越界與相等處理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* 刪除邊 */\n  // 參數 i, j 對應 vertices 元素索引\n  void removeEdge(int i, int j) {\n    // 索引越界與相等處理\n    if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* 列印鄰接矩陣 */\n  void printAdjMat() {\n    print(\"頂點串列 = $vertices\");\n    print(\"鄰接矩陣 = \");\n    printMatrix(adjMat);\n  }\n}\n</code></pre> graph_adjacency_matrix.rs<pre><code>/* 基於鄰接矩陣實現的無向圖型別 */\npub struct GraphAdjMat {\n    // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    pub vertices: Vec&lt;i32&gt;,\n    // 鄰接矩陣，行列索引對應“頂點索引”\n    pub adj_mat: Vec&lt;Vec&lt;i32&gt;&gt;,\n}\n\nimpl GraphAdjMat {\n    /* 建構子 */\n    pub fn new(vertices: Vec&lt;i32&gt;, edges: Vec&lt;[usize; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // 新增頂點\n        for val in vertices {\n            graph.add_vertex(val);\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* 獲取頂點數量 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.vertices.len()\n    }\n\n    /* 新增頂點 */\n    pub fn add_vertex(&amp;mut self, val: i32) {\n        let n = self.size();\n        // 向頂點串列中新增新頂點的值\n        self.vertices.push(val);\n        // 在鄰接矩陣中新增一行\n        self.adj_mat.push(vec![0; n]);\n        // 在鄰接矩陣中新增一列\n        for row in self.adj_mat.iter_mut() {\n            row.push(0);\n        }\n    }\n\n    /* 刪除頂點 */\n    pub fn remove_vertex(&amp;mut self, index: usize) {\n        if index &gt;= self.size() {\n            panic!(\"index error\")\n        }\n        // 在頂點串列中移除索引 index 的頂點\n        self.vertices.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的行\n        self.adj_mat.remove(index);\n        // 在鄰接矩陣中刪除索引 index 的列\n        for row in self.adj_mat.iter_mut() {\n            row.remove(index);\n        }\n    }\n\n    /* 新增邊 */\n    pub fn add_edge(&amp;mut self, i: usize, j: usize) {\n        // 參數 i, j 對應 vertices 元素索引\n        // 索引越界與相等處理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    pub fn remove_edge(&amp;mut self, i: usize, j: usize) {\n        // 參數 i, j 對應 vertices 元素索引\n        // 索引越界與相等處理\n        if i &gt;= self.size() || j &gt;= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* 列印鄰接矩陣 */\n    pub fn print(&amp;self) {\n        println!(\"頂點串列 = {:?}\", self.vertices);\n        println!(\"鄰接矩陣 =\");\n        println!(\"[\");\n        for row in &amp;self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n</code></pre> graph_adjacency_matrix.c<pre><code>/* 基於鄰接矩陣實現的無向圖結構體 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* 建構子 */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        for (int j = 0; j &lt; MAX_SIZE; j++) {\n            graph-&gt;adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* 析構函式 */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* 新增頂點 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph-&gt;size == MAX_SIZE) {\n        fprintf(stderr, \"圖的頂點數量已達最大值\\n\");\n        return;\n    }\n    // 新增第 n 個頂點，並將第 n 行和列置零\n    int n = graph-&gt;size;\n    graph-&gt;vertices[n] = val;\n    for (int i = 0; i &lt;= n; i++) {\n        graph-&gt;adjMat[n][i] = graph-&gt;adjMat[i][n] = 0;\n    }\n    graph-&gt;size++;\n}\n\n/* 刪除頂點 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index &lt; 0 || index &gt;= graph-&gt;size) {\n        fprintf(stderr, \"頂點索引越界\\n\");\n        return;\n    }\n    // 在頂點串列中移除索引 index 的頂點\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        graph-&gt;vertices[i] = graph-&gt;vertices[i + 1];\n    }\n    // 在鄰接矩陣中刪除索引 index 的行\n    for (int i = index; i &lt; graph-&gt;size - 1; i++) {\n        for (int j = 0; j &lt; graph-&gt;size; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i + 1][j];\n        }\n    }\n    // 在鄰接矩陣中刪除索引 index 的列\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        for (int j = index; j &lt; graph-&gt;size - 1; j++) {\n            graph-&gt;adjMat[i][j] = graph-&gt;adjMat[i][j + 1];\n        }\n    }\n    graph-&gt;size--;\n}\n\n/* 新增邊 */\n// 參數 i, j 對應 vertices 元素索引\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"邊索引越界或相等\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 1;\n    graph-&gt;adjMat[j][i] = 1;\n}\n\n/* 刪除邊 */\n// 參數 i, j 對應 vertices 元素索引\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i &lt; 0 || j &lt; 0 || i &gt;= graph-&gt;size || j &gt;= graph-&gt;size || i == j) {\n        fprintf(stderr, \"邊索引越界或相等\\n\");\n        return;\n    }\n    graph-&gt;adjMat[i][j] = 0;\n    graph-&gt;adjMat[j][i] = 0;\n}\n\n/* 列印鄰接矩陣 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"頂點串列 = \");\n    printArray(graph-&gt;vertices, graph-&gt;size);\n    printf(\"鄰接矩陣 =\\n\");\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        printArray(graph-&gt;adjMat[i], graph-&gt;size);\n    }\n}\n</code></pre> graph_adjacency_matrix.kt<pre><code>/* 基於鄰接矩陣實現的無向圖類別 */\nclass GraphAdjMat(vertices: IntArray, edges: Array&lt;IntArray&gt;) {\n    val vertices = mutableListOf&lt;Int&gt;() // 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    val adjMat = mutableListOf&lt;MutableList&lt;Int&gt;&gt;() // 鄰接矩陣，行列索引對應“頂點索引”\n\n    /* 建構子 */\n    init {\n        // 新增頂點\n        for (vertex in vertices) {\n            addVertex(vertex)\n        }\n        // 新增邊\n        // 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* 新增頂點 */\n    fun addVertex(_val: Int) {\n        val n = size()\n        // 向頂點串列中新增新頂點的值\n        vertices.add(_val)\n        // 在鄰接矩陣中新增一行\n        val newRow = mutableListOf&lt;Int&gt;()\n        for (j in 0..&lt;n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // 在鄰接矩陣中新增一列\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* 刪除頂點 */\n    fun removeVertex(index: Int) {\n        if (index &gt;= size())\n            throw IndexOutOfBoundsException()\n        // 在頂點串列中移除索引 index 的頂點\n        vertices.removeAt(index)\n        // 在鄰接矩陣中刪除索引 index 的行\n        adjMat.removeAt(index)\n        // 在鄰接矩陣中刪除索引 index 的列\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* 新增邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    fun addEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* 刪除邊 */\n    // 參數 i, j 對應 vertices 元素索引\n    fun removeEdge(i: Int, j: Int) {\n        // 索引越界與相等處理\n        if (i &lt; 0 || j &lt; 0 || i &gt;= size() || j &gt;= size() || i == j)\n            throw IndexOutOfBoundsException()\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* 列印鄰接矩陣 */\n    fun print() {\n        print(\"頂點串列 = \")\n        println(vertices)\n        println(\"鄰接矩陣 =\")\n        printMatrix(adjMat)\n    }\n}\n</code></pre> graph_adjacency_matrix.rb<pre><code>### 基於鄰接矩陣實現的無向圖類別 ###\nclass GraphAdjMat\n  def initialize(vertices, edges)\n    ### 建構子 ###\n    # 頂點串列，元素代表“頂點值”，索引代表“頂點索引”\n    @vertices = []\n    # 鄰接矩陣，行列索引對應“頂點索引”\n    @adj_mat = []\n    # 新增頂點\n    vertices.each { |val| add_vertex(val) }\n    # 新增邊\n    # 請注意，edges 元素代表頂點索引，即對應 vertices 元素索引\n    edges.each { |e| add_edge(e[0], e[1]) }\n  end\n\n  ### 獲取頂點數量 ###\n  def size\n    @vertices.length\n  end\n\n  ### 新增頂點 ###\n  def add_vertex(val)\n    n = size\n    # 向頂點串列中新增新頂點的值\n    @vertices &lt;&lt; val\n    # 在鄰接矩陣中新增一行\n    new_row = Array.new(n, 0)\n    @adj_mat &lt;&lt; new_row\n    # 在鄰接矩陣中新增一列\n    @adj_mat.each { |row| row &lt;&lt; 0 }\n  end\n\n  ### 刪除頂點 ###\n  def remove_vertex(index)\n    raise IndexError if index &gt;= size\n\n    # 在頂點串列中移除索引 index 的頂點\n    @vertices.delete_at(index)\n    # 在鄰接矩陣中刪除索引 index 的行\n    @adj_mat.delete_at(index)\n    # 在鄰接矩陣中刪除索引 index 的列\n    @adj_mat.each { |row| row.delete_at(index) }\n  end\n\n  ### 新增邊 ###\n  def add_edge(i, j)\n    # 參數 i, j 對應 vertices 元素索引\n    # 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    # 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)\n    @adj_mat[i][j] = 1\n    @adj_mat[j][i] = 1\n  end\n\n  ### 刪除邊 ###\n  def remove_edge(i, j)\n    # 參數 i, j 對應 vertices 元素索引\n    # 索引越界與相等處理\n    if i &lt; 0 || j &lt; 0 || i &gt;= size || j &gt;= size || i == j\n      raise IndexError\n    end\n    @adj_mat[i][j] = 0\n    @adj_mat[j][i] = 0\n  end\n\n  ### 列印鄰接矩陣 ###\n  def __print__\n    puts \"頂點串列 = #{@vertices}\"\n    puts '鄰接矩陣 ='\n    print_matrix(@adj_mat)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#922","level":2,"title":"9.2.2   基於鄰接表的實現","text":"<p>設無向圖的頂點總數為 \\(n\\)、邊總數為 \\(m\\) ，則可根據圖 9-8 所示的方法實現各種操作。</p> <ul> <li>新增邊：在頂點對應鏈結串列的末尾新增邊即可，使用 \\(O(1)\\) 時間。因為是無向圖，所以需要同時新增兩個方向的邊。</li> <li>刪除邊：在頂點對應鏈結串列中查詢並刪除指定邊，使用 \\(O(m)\\) 時間。在無向圖中，需要同時刪除兩個方向的邊。</li> <li>新增頂點：在鄰接表中新增一個鏈結串列，並將新增頂點作為鏈結串列頭節點，使用 \\(O(1)\\) 時間。</li> <li>刪除頂點：需走訪整個鄰接表，刪除包含指定頂點的所有邊，使用 \\(O(n + m)\\) 時間。</li> <li>初始化：在鄰接表中建立 \\(n\\) 個頂點和 \\(2m\\) 條邊，使用 \\(O(n + m)\\) 時間。</li> </ul> 初始化鄰接表新增邊刪除邊新增頂點刪除頂點 <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-8   鄰接表的初始化、增刪邊、增刪頂點 </p> <p>以下是鄰接表的程式碼實現。對比圖 9-8 ，實際程式碼有以下不同。</p> <ul> <li>為了方便新增與刪除頂點，以及簡化程式碼，我們使用串列（動態陣列）來代替鏈結串列。</li> <li>使用雜湊表來儲存鄰接表，<code>key</code> 為頂點例項，<code>value</code> 為該頂點的鄰接頂點串列（鏈結串列）。</li> </ul> <p>另外，我們在鄰接表中使用 <code>Vertex</code> 類別來表示頂點，這樣做的原因是：如果與鄰接矩陣一樣，用串列索引來區分不同頂點，那麼假設要刪除索引為 \\(i\\) 的頂點，則需走訪整個鄰接表，將所有大於 \\(i\\) 的索引全部減 \\(1\\) ，效率很低。而如果每個頂點都是唯一的 <code>Vertex</code> 例項，刪除某一頂點之後就無須改動其他頂點了。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_adjacency_list.py<pre><code>class GraphAdjList:\n    \"\"\"基於鄰接表實現的無向圖類別\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"建構子\"\"\"\n        # 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # 新增所有頂點和邊\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -&gt; int:\n        \"\"\"獲取頂點數量\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"新增邊\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 新增邊 vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"刪除邊\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # 刪除邊 vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"新增頂點\"\"\"\n        if vet in self.adj_list:\n            return\n        # 在鄰接表中新增一個新鏈結串列\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"刪除頂點\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        self.adj_list.pop(vet)\n        # 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"列印鄰接表\"\"\"\n        print(\"鄰接表 =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n</code></pre> graph_adjacency_list.cpp<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n  public:\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    unordered_map&lt;Vertex *, vector&lt;Vertex *&gt;&gt; adjList;\n\n    /* 在 vector 中刪除指定節點 */\n    void remove(vector&lt;Vertex *&gt; &amp;vec, Vertex *vet) {\n        for (int i = 0; i &lt; vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* 建構子 */\n    GraphAdjList(const vector&lt;vector&lt;Vertex *&gt;&gt; &amp;edges) {\n        // 新增所有頂點和邊\n        for (const vector&lt;Vertex *&gt; &amp;edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int size() {\n        return adjList.size();\n    }\n\n    /* 新增邊 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"不存在頂點\");\n        // 新增邊 vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* 刪除邊 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"不存在頂點\");\n        // 刪除邊 vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* 新增頂點 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = vector&lt;Vertex *&gt;();\n    }\n\n    /* 刪除頂點 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"不存在頂點\");\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.erase(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (auto &amp;adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    void print() {\n        cout &lt;&lt; \"鄰接表 =\" &lt;&lt; endl;\n        for (auto &amp;adj : adjList) {\n            const auto &amp;key = adj.first;\n            const auto &amp;vec = adj.second;\n            cout &lt;&lt; key-&gt;val &lt;&lt; \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n</code></pre> graph_adjacency_list.java<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* 建構子 */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap&lt;&gt;();\n        // 新增所有頂點和邊\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* 新增邊 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 新增邊 vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* 刪除邊 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // 刪除邊 vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* 新增頂點 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList.put(vet, new ArrayList&lt;&gt;());\n    }\n\n    /* 刪除頂點 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.remove(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (List&lt;Vertex&gt; list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    public void print() {\n        System.out.println(\"鄰接表 =\");\n        for (Map.Entry&lt;Vertex, List&lt;Vertex&gt;&gt; pair : adjList.entrySet()) {\n            List&lt;Integer&gt; tmp = new ArrayList&lt;&gt;();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.cs<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    public Dictionary&lt;Vertex, List&lt;Vertex&gt;&gt; adjList;\n\n    /* 建構子 */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // 新增所有頂點和邊\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* 新增邊 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 新增邊 vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* 刪除邊 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // 刪除邊 vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* 新增頂點 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // 在鄰接表中新增一個新鏈結串列\n        adjList.Add(vet, []);\n    }\n\n    /* 刪除頂點 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.Remove(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        foreach (List&lt;Vertex&gt; list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    public void Print() {\n        Console.WriteLine(\"鄰接表 =\");\n        foreach (KeyValuePair&lt;Vertex, List&lt;Vertex&gt;&gt; pair in adjList) {\n            List&lt;int&gt; tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\n</code></pre> graph_adjacency_list.go<pre><code>/* 基於鄰接表實現的無向圖類別 */\ntype graphAdjList struct {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList map[Vertex][]Vertex\n}\n\n/* 建構子 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &amp;graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // 新增所有頂點和邊\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* 獲取頂點數量 */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* 新增邊 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 新增邊 vet1 - vet2, 新增匿名 struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* 刪除邊 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // 刪除邊 vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* 新增頂點 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // 在鄰接表中新增一個新鏈結串列\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* 刪除頂點 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    delete(g.adjList, vet)\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* 列印鄰接表 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"鄰接表 = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> graph_adjacency_list.swift<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* 建構子 */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // 新增所有頂點和邊\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* 獲取頂點數量 */\n    public func size() -&gt; Int {\n        adjList.count\n    }\n\n    /* 新增邊 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"參數錯誤\")\n        }\n        // 新增邊 vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* 刪除邊 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"參數錯誤\")\n        }\n        // 刪除邊 vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* 新增頂點 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = []\n    }\n\n    /* 刪除頂點 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"參數錯誤\")\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.removeValue(forKey: vet)\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* 列印鄰接表 */\n    public func print() {\n        Swift.print(\"鄰接表 =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.js<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList;\n\n    /* 建構子 */\n    constructor(edges) {\n        this.adjList = new Map();\n        // 新增所有頂點和邊\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* 新增邊 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 新增邊 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 刪除邊 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 刪除邊 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 新增頂點 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // 在鄰接表中新增一個新鏈結串列\n        this.adjList.set(vet, []);\n    }\n\n    /* 刪除頂點 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        this.adjList.delete(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 列印鄰接表 */\n    print() {\n        console.log('鄰接表 =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.ts<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    adjList: Map&lt;Vertex, Vertex[]&gt;;\n\n    /* 建構子 */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // 新增所有頂點和邊\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* 獲取頂點數量 */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* 新增邊 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 新增邊 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* 刪除邊 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2 ||\n            this.adjList.get(vet1).indexOf(vet2) === -1\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 刪除邊 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* 新增頂點 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // 在鄰接表中新增一個新鏈結串列\n        this.adjList.set(vet, []);\n    }\n\n    /* 刪除頂點 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        this.adjList.delete(vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index &gt; -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* 列印鄰接表 */\n    print(): void {\n        console.log('鄰接表 =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n</code></pre> graph_adjacency_list.dart<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList {\n  // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n  Map&lt;Vertex, List&lt;Vertex&gt;&gt; adjList = {};\n\n  /* 建構子 */\n  GraphAdjList(List&lt;List&lt;Vertex&gt;&gt; edges) {\n    for (List&lt;Vertex&gt; edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* 獲取頂點數量 */\n  int size() {\n    return adjList.length;\n  }\n\n  /* 新增邊 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 新增邊 vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* 刪除邊 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // 刪除邊 vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* 新增頂點 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // 在鄰接表中新增一個新鏈結串列\n    adjList[vet] = [];\n  }\n\n  /* 刪除頂點 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    adjList.remove(vet);\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* 列印鄰接表 */\n  void printAdjList() {\n    print(\"鄰接表 =\");\n    adjList.forEach((key, value) {\n      List&lt;int&gt; tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n</code></pre> graph_adjacency_list.rs<pre><code>/* 基於鄰接表實現的無向圖型別 */\npub struct GraphAdjList {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    pub adj_list: HashMap&lt;Vertex, Vec&lt;Vertex&gt;&gt;, // maybe HashSet&lt;Vertex&gt; for value part is better?\n}\n\nimpl GraphAdjList {\n    /* 建構子 */\n    pub fn new(edges: Vec&lt;[Vertex; 2]&gt;) -&gt; Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // 新增所有頂點和邊\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* 獲取頂點數量 */\n    #[allow(unused)]\n    pub fn size(&amp;self) -&gt; usize {\n        self.adj_list.len()\n    }\n\n    /* 新增邊 */\n    pub fn add_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 新增邊 vet1 - vet2\n        self.adj_list.entry(vet1).or_default().push(vet2);\n        self.adj_list.entry(vet2).or_default().push(vet1);\n    }\n\n    /* 刪除邊 */\n    #[allow(unused)]\n    pub fn remove_edge(&amp;mut self, vet1: Vertex, vet2: Vertex) {\n        if vet1 == vet2 {\n            panic!(\"value error\");\n        }\n        // 刪除邊 vet1 - vet2\n        self.adj_list\n            .entry(vet1)\n            .and_modify(|v| v.retain(|&amp;e| e != vet2));\n        self.adj_list\n            .entry(vet2)\n            .and_modify(|v| v.retain(|&amp;e| e != vet1));\n    }\n\n    /* 新增頂點 */\n    pub fn add_vertex(&amp;mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&amp;vet) {\n            return;\n        }\n        // 在鄰接表中新增一個新鏈結串列\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* 刪除頂點 */\n    #[allow(unused)]\n    pub fn remove_vertex(&amp;mut self, vet: Vertex) {\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        self.adj_list.remove(&amp;vet);\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for list in self.adj_list.values_mut() {\n            list.retain(|&amp;v| v != vet);\n        }\n    }\n\n    /* 列印鄰接表 */\n    pub fn print(&amp;self) {\n        println!(\"鄰接表 =\");\n        for (vertex, list) in &amp;self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::&lt;Vec&lt;i32&gt;&gt;();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n</code></pre> graph_adjacency_list.c<pre><code>/* 節點結構體 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // 頂點\n    struct AdjListNode *next; // 後繼節點\n} AdjListNode;\n\n/* 查詢頂點對應的節點 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 新增邊輔助函式 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node-&gt;vertex = vet;\n    // 頭插法\n    node-&gt;next = head-&gt;next;\n    head-&gt;next = node;\n}\n\n/* 刪除邊輔助函式 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head-&gt;next;\n    // 在鏈結串列中搜索 vet 對應節點\n    while (cur != NULL &amp;&amp; cur-&gt;vertex != vet) {\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n    if (cur == NULL)\n        return;\n    // 將 vet 對應節點從鏈結串列中刪除\n    pre-&gt;next = cur-&gt;next;\n    // 釋放記憶體\n    free(cur);\n}\n\n/* 基於鄰接表實現的無向圖類別 */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // 節點陣列\n    int size;                     // 節點數量\n} GraphAdjList;\n\n/* 建構子 */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph-&gt;size = 0;\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        graph-&gt;heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* 析構函式 */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        AdjListNode *cur = graph-&gt;heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur-&gt;next;\n            if (cur != graph-&gt;heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph-&gt;heads[i]-&gt;vertex);\n        free(graph-&gt;heads[i]);\n    }\n    free(graph);\n}\n\n/* 查詢頂點對應的節點 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i]-&gt;vertex == vet) {\n            return graph-&gt;heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* 新增邊 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL &amp;&amp; head1 != head2);\n    // 新增邊 vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* 刪除邊 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL &amp;&amp; head2 != NULL);\n    // 刪除邊 vet1 - vet2\n    removeEdgeHelper(head1, head2-&gt;vertex);\n    removeEdgeHelper(head2, head1-&gt;vertex);\n}\n\n/* 新增頂點 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL &amp;&amp; graph-&gt;size &lt; MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head-&gt;vertex = vet;\n    head-&gt;next = NULL;\n    // 在鄰接表中新增一個新鏈結串列\n    graph-&gt;heads[graph-&gt;size++] = head;\n}\n\n/* 刪除頂點 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur-&gt;next;\n        free(pre);\n    }\n    // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for (int i = 0; i &lt; graph-&gt;size; i++) {\n        cur = graph-&gt;heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur-&gt;next;\n            if (cur &amp;&amp; cur-&gt;vertex == vet) {\n                pre-&gt;next = cur-&gt;next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // 將該頂點之後的頂點向前移動，以填補空缺\n    int i;\n    for (i = 0; i &lt; graph-&gt;size; i++) {\n        if (graph-&gt;heads[i] == node)\n            break;\n    }\n    for (int j = i; j &lt; graph-&gt;size - 1; j++) {\n        graph-&gt;heads[j] = graph-&gt;heads[j + 1];\n    }\n    graph-&gt;size--;\n    free(vet);\n}\n</code></pre> graph_adjacency_list.kt<pre><code>/* 基於鄰接表實現的無向圖類別 */\nclass GraphAdjList(edges: Array&lt;Array&lt;Vertex?&gt;&gt;) {\n    // 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    val adjList = HashMap&lt;Vertex, MutableList&lt;Vertex&gt;&gt;()\n\n    /* 建構子 */\n    init {\n        // 新增所有頂點和邊\n        for (edge in edges) {\n            addVertex(edge[0]!!)\n            addVertex(edge[1]!!)\n            addEdge(edge[0]!!, edge[1]!!)\n        }\n    }\n\n    /* 獲取頂點數量 */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* 新增邊 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 新增邊 vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1)\n    }\n\n    /* 刪除邊 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // 刪除邊 vet1 - vet2\n        adjList[vet1]?.remove(vet2)\n        adjList[vet2]?.remove(vet1)\n    }\n\n    /* 新增頂點 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // 在鄰接表中新增一個新鏈結串列\n        adjList[vet] = mutableListOf()\n    }\n\n    /* 刪除頂點 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // 在鄰接表中刪除頂點 vet 對應的鏈結串列\n        adjList.remove(vet)\n        // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* 列印鄰接表 */\n    fun print() {\n        println(\"鄰接表 =\")\n        for (pair in adjList.entries) {\n            val tmp = mutableListOf&lt;Int&gt;()\n            for (vertex in pair.value) {\n                tmp.add(vertex._val)\n            }\n            println(\"${pair.key._val}: $tmp,\")\n        }\n    }\n}\n</code></pre> graph_adjacency_list.rb<pre><code>### 基於鄰接表實現的無向圖類別 ###\nclass GraphAdjList\n  attr_reader :adj_list\n\n  ### 建構子 ###\n  def initialize(edges)\n    # 鄰接表，key：頂點，value：該頂點的所有鄰接頂點\n    @adj_list = {}\n    # 新增所有頂點和邊\n    for edge in edges\n      add_vertex(edge[0])\n      add_vertex(edge[1])\n      add_edge(edge[0], edge[1])\n    end\n  end\n\n  ### 獲取頂點數量 ###\n  def size\n    @adj_list.length\n  end\n\n  ### 新增邊 ###\n  def add_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    @adj_list[vet1] &lt;&lt; vet2\n    @adj_list[vet2] &lt;&lt; vet1\n  end\n\n  ### 刪除邊 ###\n  def remove_edge(vet1, vet2)\n    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)\n\n    # 刪除邊 vet1 - vet2\n    @adj_list[vet1].delete(vet2)\n    @adj_list[vet2].delete(vet1)\n  end\n\n  ### 新增頂點 ###\n  def add_vertex(vet)\n    return if @adj_list.include?(vet)\n\n    # 在鄰接表中新增一個新鏈結串列\n    @adj_list[vet] = []\n  end\n\n  ### 刪除頂點 ###\n  def remove_vertex(vet)\n    raise ArgumentError unless @adj_list.include?(vet)\n\n    # 在鄰接表中刪除頂點 vet 對應的鏈結串列\n    @adj_list.delete(vet)\n    # 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊\n    for vertex in @adj_list\n      @adj_list[vertex.first].delete(vet) if @adj_list[vertex.first].include?(vet)\n    end\n  end\n\n  ### 列印鄰接表 ###\n  def __print__\n    puts '鄰接表 ='\n    for vertex in @adj_list\n      tmp = @adj_list[vertex.first].map { |v| v.val }\n      puts \"#{vertex.first.val}: #{tmp},\"\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_operations/#923","level":2,"title":"9.2.3   效率對比","text":"<p>設圖中共有 \\(n\\) 個頂點和 \\(m\\) 條邊，表 9-2 對比了鄰接矩陣和鄰接表的時間效率和空間效率。請注意，鄰接表（鏈結串列）對應本文實現，而鄰接表（雜湊表）專指將所有鏈結串列替換為雜湊表後的實現。</p> <p> 表 9-2   鄰接矩陣與鄰接表對比 </p> 鄰接矩陣 鄰接表（鏈結串列） 鄰接表（雜湊表） 判斷是否鄰接 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 新增邊 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 刪除邊 \\(O(1)\\) \\(O(n)\\) \\(O(1)\\) 新增頂點 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) 刪除頂點 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) 記憶體空間佔用 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\) <p>觀察表 9-2 ，似乎鄰接表（雜湊表）的時間效率與空間效率最優。但實際上，在鄰接矩陣中操作邊的效率更高，只需一次陣列訪問或賦值操作即可。綜合來看，鄰接矩陣體現了“以空間換時間”的原則，而鄰接表體現了“以時間換空間”的原則。</p>","path":["第 9 章 &nbsp; 圖","9.2 &nbsp; 圖的基礎操作"],"tags":[]},{"location":"chapter_graph/graph_traversal/","level":1,"title":"9.3   圖的走訪","text":"<p>樹代表的是“一對多”的關係，而圖則具有更高的自由度，可以表示任意的“多對多”關係。因此，我們可以把樹看作圖的一種特例。顯然，樹的走訪操作也是圖的走訪操作的一種特例。</p> <p>圖和樹都需要應用搜索演算法來實現走訪操作。圖的走訪方式也可分為兩種：廣度優先走訪和深度優先走訪。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#931","level":2,"title":"9.3.1   廣度優先走訪","text":"<p>廣度優先走訪是一種由近及遠的走訪方式，從某個節點出發，始終優先訪問距離最近的頂點，並一層層向外擴張。如圖 9-9 所示，從左上角頂點出發，首先走訪該頂點的所有鄰接頂點，然後走訪下一個頂點的所有鄰接頂點，以此類推，直至所有頂點訪問完畢。</p> <p></p> <p> 圖 9-9   圖的廣度優先走訪 </p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1","level":3,"title":"1.   演算法實現","text":"<p>BFS 通常藉助佇列來實現，程式碼如下所示。佇列具有“先入先出”的性質，這與 BFS 的“由近及遠”的思想異曲同工。</p> <ol> <li>將走訪起始頂點 <code>startVet</code> 加入佇列，並開啟迴圈。</li> <li>在迴圈的每輪迭代中，彈出佇列首頂點並記錄訪問，然後將該頂點的所有鄰接頂點加入到佇列尾部。</li> <li>迴圈步驟 <code>2.</code> ，直到所有頂點被訪問完畢後結束。</li> </ol> <p>為了防止重複走訪頂點，我們需要藉助一個雜湊集合 <code>visited</code> 來記錄哪些節點已被訪問。</p> <p>Tip</p> <p>雜湊集合可以看作一個只儲存 <code>key</code> 而不儲存 <code>value</code> 的雜湊表，它可以在 \\(O(1)\\) 時間複雜度下進行 <code>key</code> 的增刪查改操作。根據 <code>key</code> 的唯一性，雜湊集合通常用於資料去重等場景。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_bfs.py<pre><code>def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"廣度優先走訪\"\"\"\n    # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n    # 頂點走訪序列\n    res = []\n    # 雜湊集合，用於記錄已被訪問過的頂點\n    visited = set[Vertex]([start_vet])\n    # 佇列用於實現 BFS\n    que = deque[Vertex]([start_vet])\n    # 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while len(que) &gt; 0:\n        vet = que.popleft()  # 佇列首頂點出隊\n        res.append(vet)  # 記錄訪問頂點\n        # 走訪該頂點的所有鄰接頂點\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # 跳過已被訪問的頂點\n            que.append(adj_vet)  # 只入列未訪問的頂點\n            visited.add(adj_vet)  # 標記該頂點已被訪問\n    # 返回頂點走訪序列\n    return res\n</code></pre> graph_bfs.cpp<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvector&lt;Vertex *&gt; graphBFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂點走訪序列\n    vector&lt;Vertex *&gt; res;\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    unordered_set&lt;Vertex *&gt; visited = {startVet};\n    // 佇列用於實現 BFS\n    queue&lt;Vertex *&gt; que;\n    que.push(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // 佇列首頂點出隊\n        res.push_back(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // 跳過已被訪問的頂點\n            que.push(adjVet);        // 只入列未訪問的頂點\n            visited.emplace(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.java<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    Queue&lt;Vertex&gt; que = new LinkedList&lt;&gt;();\n    que.offer(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // 佇列首頂點出隊\n        res.add(vet);            // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // 跳過已被訪問的頂點\n            que.offer(adjVet);   // 只入列未訪問的頂點\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.cs<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; GraphBFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    HashSet&lt;Vertex&gt; visited = [startVet];\n    // 佇列用於實現 BFS\n    Queue&lt;Vertex&gt; que = new();\n    que.Enqueue(startVet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.Count &gt; 0) {\n        Vertex vet = que.Dequeue(); // 佇列首頂點出隊\n        res.Add(vet);               // 記錄訪問頂點\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // 跳過已被訪問的頂點\n            }\n            que.Enqueue(adjVet);   // 只入列未訪問的頂點\n            visited.Add(adjVet);   // 標記該頂點已被訪問\n        }\n    }\n\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.go<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂點走訪序列\n    res := make([]Vertex, 0)\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // 佇列用於實現 BFS, 使用切片模擬佇列\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    for len(queue) &gt; 0 {\n        // 佇列首頂點出隊\n        vet := queue[0]\n        queue = queue[1:]\n        // 記錄訪問頂點\n        res = append(res, vet)\n        // 走訪該頂點的所有鄰接頂點\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // 只入列未訪問的頂點\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.swift<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂點走訪序列\n    var res: [Vertex] = []\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    var visited: Set&lt;Vertex&gt; = [startVet]\n    // 佇列用於實現 BFS\n    var que: [Vertex] = [startVet]\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while !que.isEmpty {\n        let vet = que.removeFirst() // 佇列首頂點出隊\n        res.append(vet) // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // 跳過已被訪問的頂點\n            }\n            que.append(adjVet) // 只入列未訪問的頂點\n            visited.insert(adjVet) // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.js<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphBFS(graph, startVet) {\n    // 頂點走訪序列\n    const res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited = new Set();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    const que = [startVet];\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.length) {\n        const vet = que.shift(); // 佇列首頂點出隊\n        res.push(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 跳過已被訪問的頂點\n            }\n            que.push(adjVet); // 只入列未訪問的頂點\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.ts<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂點走訪序列\n    const res: Vertex[] = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited: Set&lt;Vertex&gt; = new Set();\n    visited.add(startVet);\n    // 佇列用於實現 BFS\n    const que = [startVet];\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (que.length) {\n        const vet = que.shift(); // 佇列首頂點出隊\n        res.push(vet); // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // 跳過已被訪問的頂點\n            }\n            que.push(adjVet); // 只入列未訪問\n            visited.add(adjVet); // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res;\n}\n</code></pre> graph_bfs.dart<pre><code>/* 廣度優先走訪 */\nList&lt;Vertex&gt; graphBFS(GraphAdjList graph, Vertex startVet) {\n  // 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  // 頂點走訪序列\n  List&lt;Vertex&gt; res = [];\n  // 雜湊集合，用於記錄已被訪問過的頂點\n  Set&lt;Vertex&gt; visited = {};\n  visited.add(startVet);\n  // 佇列用於實現 BFS\n  Queue&lt;Vertex&gt; que = Queue();\n  que.add(startVet);\n  // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // 佇列首頂點出隊\n    res.add(vet); // 記錄訪問頂點\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // 跳過已被訪問的頂點\n      }\n      que.add(adjVet); // 只入列未訪問的頂點\n      visited.add(adjVet); // 標記該頂點已被訪問\n    }\n  }\n  // 返回頂點走訪序列\n  return res;\n}\n</code></pre> graph_bfs.rs<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂點走訪序列\n    let mut res = vec![];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // 佇列用於實現 BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while let Some(vet) = que.pop_front() {\n        res.push(vet); // 記錄訪問頂點\n\n        // 走訪該頂點的所有鄰接頂點\n        if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n            for &amp;adj_vet in adj_vets {\n                if visited.contains(&amp;adj_vet) {\n                    continue; // 跳過已被訪問的頂點\n                }\n                que.push_back(adj_vet); // 只入列未訪問的頂點\n                visited.insert(adj_vet); // 標記該頂點已被訪問\n            }\n        }\n    }\n    // 返回頂點走訪序列\n    res\n}\n</code></pre> graph_bfs.c<pre><code>/* 節點佇列結構體 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* 建構子 */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q-&gt;front = q-&gt;rear = q-&gt;size = 0;\n    return q;\n}\n\n/* 判斷佇列是否為空 */\nint isEmpty(Queue *q) {\n    return q-&gt;size == 0;\n}\n\n/* 入列操作 */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q-&gt;vertices[q-&gt;rear] = vet;\n    q-&gt;rear = (q-&gt;rear + 1) % MAX_SIZE;\n    q-&gt;size++;\n}\n\n/* 出列操作 */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q-&gt;vertices[q-&gt;front];\n    q-&gt;front = (q-&gt;front + 1) % MAX_SIZE;\n    q-&gt;size--;\n    return vet;\n}\n\n/* 檢查頂點是否已被訪問 */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // 走訪查詢節點，使用 O(n) 時間\n    for (int i = 0; i &lt; size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // 佇列用於實現 BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // 佇列首頂點出隊\n        res[(*resSize)++] = vet;      // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // 跳過已被訪問的頂點\n            if (!isVisited(visited, *visitedSize, node-&gt;vertex)) {\n                enqueue(queue, node-&gt;vertex);             // 只入列未訪問的頂點\n                visited[(*visitedSize)++] = node-&gt;vertex; // 標記該頂點已被訪問\n            }\n            node = node-&gt;next;\n        }\n    }\n    // 釋放記憶體\n    free(queue);\n}\n</code></pre> graph_bfs.kt<pre><code>/* 廣度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): MutableList&lt;Vertex?&gt; {\n    // 頂點走訪序列\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    val visited = HashSet&lt;Vertex&gt;()\n    visited.add(startVet)\n    // 佇列用於實現 BFS\n    val que = LinkedList&lt;Vertex&gt;()\n    que.offer(startVet)\n    // 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n    while (!que.isEmpty()) {\n        val vet = que.poll() // 佇列首頂點出隊\n        res.add(vet)         // 記錄訪問頂點\n        // 走訪該頂點的所有鄰接頂點\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet))\n                continue        // 跳過已被訪問的頂點\n            que.offer(adjVet)   // 只入列未訪問的頂點\n            visited.add(adjVet) // 標記該頂點已被訪問\n        }\n    }\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_bfs.rb<pre><code>### 廣度優先走訪 ###\ndef graph_bfs(graph, start_vet)\n  # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  # 頂點走訪序列\n  res = []\n  # 雜湊集合，用於記錄已被訪問過的頂點\n  visited = Set.new([start_vet])\n  # 佇列用於實現 BFS\n  que = [start_vet]\n  # 以頂點 vet 為起點，迴圈直至訪問完所有頂點\n  while que.length &gt; 0\n    vet = que.shift # 佇列首頂點出隊\n    res &lt;&lt; vet # 記錄訪問頂點\n    # 走訪該頂點的所有鄰接頂點\n    for adj_vet in graph.adj_list[vet]\n      next if visited.include?(adj_vet) # 跳過已被訪問的頂點\n      que &lt;&lt; adj_vet # 只入列未訪問的頂點\n      visited.add(adj_vet) # 標記該頂點已被訪問\n    end\n  end\n  # 返回頂點走訪序列\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>程式碼相對抽象，建議對照圖 9-10 來加深理解。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-10   圖的廣度優先走訪步驟 </p> <p>廣度優先走訪的序列是否唯一？</p> <p>不唯一。廣度優先走訪只要求按“由近及遠”的順序走訪，而多個相同距離的頂點的走訪順序允許被任意打亂。以圖 9-10 為例，頂點 \\(1\\)、\\(3\\) 的訪問順序可以交換，頂點 \\(2\\)、\\(4\\)、\\(6\\) 的訪問順序也可以任意交換。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2","level":3,"title":"2.   複雜度分析","text":"<p>時間複雜度：所有頂點都會入列並出隊一次，使用 \\(O(|V|)\\) 時間；在走訪鄰接頂點的過程中，由於是無向圖，因此所有邊都會被訪問 \\(2\\) 次，使用 \\(O(2|E|)\\) 時間；總體使用 \\(O(|V| + |E|)\\) 時間。</p> <p>空間複雜度：串列 <code>res</code> ，雜湊集合 <code>visited</code> ，佇列 <code>que</code> 中的頂點數量最多為 \\(|V|\\) ，使用 \\(O(|V|)\\) 空間。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#932","level":2,"title":"9.3.2   深度優先走訪","text":"<p>深度優先走訪是一種優先走到底、無路可走再回頭的走訪方式。如圖 9-11 所示，從左上角頂點出發，訪問當前頂點的某個鄰接頂點，直到走到盡頭時返回，再繼續走到盡頭並返回，以此類推，直至所有頂點走訪完成。</p> <p></p> <p> 圖 9-11   圖的深度優先走訪 </p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#1_1","level":3,"title":"1.   演算法實現","text":"<p>這種“走到盡頭再返回”的演算法範式通常基於遞迴來實現。與廣度優先走訪類似，在深度優先走訪中，我們也需要藉助一個雜湊集合 <code>visited</code> 來記錄已被訪問的頂點，以避免重複訪問頂點。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby graph_dfs.py<pre><code>def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"深度優先走訪輔助函式\"\"\"\n    res.append(vet)  # 記錄訪問頂點\n    visited.add(vet)  # 標記該頂點已被訪問\n    # 走訪該頂點的所有鄰接頂點\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # 跳過已被訪問的頂點\n        # 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; list[Vertex]:\n    \"\"\"深度優先走訪\"\"\"\n    # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n    # 頂點走訪序列\n    res = []\n    # 雜湊集合，用於記錄已被訪問過的頂點\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n</code></pre> graph_dfs.cpp<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList &amp;graph, unordered_set&lt;Vertex *&gt; &amp;visited, vector&lt;Vertex *&gt; &amp;res, Vertex *vet) {\n    res.push_back(vet);   // 記錄訪問頂點\n    visited.emplace(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvector&lt;Vertex *&gt; graphDFS(GraphAdjList &amp;graph, Vertex *startVet) {\n    // 頂點走訪序列\n    vector&lt;Vertex *&gt; res;\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    unordered_set&lt;Vertex *&gt; visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.java<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList graph, Set&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.add(vet);     // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = new ArrayList&lt;&gt;();\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    Set&lt;Vertex&gt; visited = new HashSet&lt;&gt;();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.cs<pre><code>/* 深度優先走訪輔助函式 */\nvoid DFS(GraphAdjList graph, HashSet&lt;Vertex&gt; visited, List&lt;Vertex&gt; res, Vertex vet) {\n    res.Add(vet);     // 記錄訪問頂點\n    visited.Add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // 跳過已被訪問的頂點                             \n        }\n        // 遞迴訪問鄰接頂點\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nList&lt;Vertex&gt; GraphDFS(GraphAdjList graph, Vertex startVet) {\n    // 頂點走訪序列\n    List&lt;Vertex&gt; res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    HashSet&lt;Vertex&gt; visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.go<pre><code>/* 深度優先走訪輔助函式 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n    // append 操作會返回新的的引用，必須讓原引用重新賦值為新slice的引用\n    *res = append(*res, vet)\n    visited[vet] = struct{}{}\n    // 走訪該頂點的所有鄰接頂點\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // 遞迴訪問鄰接頂點\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n    // 頂點走訪序列\n    res := make([]Vertex, 0)\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &amp;res, startVet)\n    // 返回頂點走訪序列\n    return res\n}\n</code></pre> graph_dfs.swift<pre><code>/* 深度優先走訪輔助函式 */\nfunc dfs(graph: GraphAdjList, visited: inout Set&lt;Vertex&gt;, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // 記錄訪問頂點\n    visited.insert(vet) // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: adjVet)\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -&gt; [Vertex] {\n    // 頂點走訪序列\n    var res: [Vertex] = []\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    var visited: Set&lt;Vertex&gt; = []\n    dfs(graph: graph, visited: &amp;visited, res: &amp;res, vet: startVet)\n    return res\n}\n</code></pre> graph_dfs.js<pre><code>/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction dfs(graph, visited, res, vet) {\n    res.push(vet); // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphDFS(graph, startVet) {\n    // 頂點走訪序列\n    const res = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.ts<pre><code>/* 深度優先走訪輔助函式 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set&lt;Vertex&gt;,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // 記錄訪問頂點\n    visited.add(vet); // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // 跳過已被訪問的頂點\n        }\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n    // 頂點走訪序列\n    const res: Vertex[] = [];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    const visited: Set&lt;Vertex&gt; = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n</code></pre> graph_dfs.dart<pre><code>/* 深度優先走訪輔助函式 */\nvoid dfs(\n  GraphAdjList graph,\n  Set&lt;Vertex&gt; visited,\n  List&lt;Vertex&gt; res,\n  Vertex vet,\n) {\n  res.add(vet); // 記錄訪問頂點\n  visited.add(vet); // 標記該頂點已被訪問\n  // 走訪該頂點的所有鄰接頂點\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // 跳過已被訪問的頂點\n    }\n    // 遞迴訪問鄰接頂點\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* 深度優先走訪 */\nList&lt;Vertex&gt; graphDFS(GraphAdjList graph, Vertex startVet) {\n  // 頂點走訪序列\n  List&lt;Vertex&gt; res = [];\n  // 雜湊集合，用於記錄已被訪問過的頂點\n  Set&lt;Vertex&gt; visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n</code></pre> graph_dfs.rs<pre><code>/* 深度優先走訪輔助函式 */\nfn dfs(graph: &amp;GraphAdjList, visited: &amp;mut HashSet&lt;Vertex&gt;, res: &amp;mut Vec&lt;Vertex&gt;, vet: Vertex) {\n    res.push(vet); // 記錄訪問頂點\n    visited.insert(vet); // 標記該頂點已被訪問\n                         // 走訪該頂點的所有鄰接頂點\n    if let Some(adj_vets) = graph.adj_list.get(&amp;vet) {\n        for &amp;adj_vet in adj_vets {\n            if visited.contains(&amp;adj_vet) {\n                continue; // 跳過已被訪問的頂點\n            }\n            // 遞迴訪問鄰接頂點\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -&gt; Vec&lt;Vertex&gt; {\n    // 頂點走訪序列\n    let mut res = vec![];\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    let mut visited = HashSet::new();\n    dfs(&amp;graph, &amp;mut visited, &amp;mut res, start_vet);\n\n    res\n}\n</code></pre> graph_dfs.c<pre><code>/* 檢查頂點是否已被訪問 */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // 走訪查詢節點，使用 O(n) 時間\n    for (int i = 0; i &lt; size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* 深度優先走訪輔助函式 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // 記錄訪問頂點\n    res[(*resSize)++] = vet;\n    // 走訪該頂點的所有鄰接頂點\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // 跳過已被訪問的頂點\n        if (!isVisited(res, *resSize, node-&gt;vertex)) {\n            // 遞迴訪問鄰接頂點\n            dfs(graph, res, resSize, node-&gt;vertex);\n        }\n        node = node-&gt;next;\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n</code></pre> graph_dfs.kt<pre><code>/* 深度優先走訪輔助函式 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet&lt;Vertex?&gt;,\n    res: MutableList&lt;Vertex?&gt;,\n    vet: Vertex?\n) {\n    res.add(vet)     // 記錄訪問頂點\n    visited.add(vet) // 標記該頂點已被訪問\n    // 走訪該頂點的所有鄰接頂點\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet))\n            continue  // 跳過已被訪問的頂點\n        // 遞迴訪問鄰接頂點\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* 深度優先走訪 */\n// 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\nfun graphDFS(graph: GraphAdjList, startVet: Vertex?): MutableList&lt;Vertex?&gt; {\n    // 頂點走訪序列\n    val res = mutableListOf&lt;Vertex?&gt;()\n    // 雜湊集合，用於記錄已被訪問過的頂點\n    val visited = HashSet&lt;Vertex?&gt;()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n</code></pre> graph_dfs.rb<pre><code>### 深度優先走訪輔助函式 ###\ndef dfs(graph, visited, res, vet)\n  res &lt;&lt; vet # 記錄訪問頂點\n  visited.add(vet) # 標記該頂點已被訪問\n  # 走訪該頂點的所有鄰接頂點\n  for adj_vet in graph.adj_list[vet]\n    next if visited.include?(adj_vet) # 跳過已被訪問的頂點\n    # 遞迴訪問鄰接頂點\n    dfs(graph, visited, res, adj_vet)\n  end\nend\n\n### 深度優先走訪 ###\ndef graph_dfs(graph, start_vet)\n  # 使用鄰接表來表示圖，以便獲取指定頂點的所有鄰接頂點\n  # 頂點走訪序列\n  res = []\n  # 雜湊集合，用於記錄已被訪問過的頂點\n  visited = Set.new\n  dfs(graph, visited, res, start_vet)\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>深度優先走訪的演算法流程如圖 9-12 所示。</p> <ul> <li>直虛線代表向下遞推，表示開啟了一個新的遞迴方法來訪問新頂點。</li> <li>曲虛線代表向上回溯，表示此遞迴方法已經返回，回溯到了開啟此方法的位置。</li> </ul> <p>為了加深理解，建議將圖 9-12 與程式碼結合起來，在腦中模擬（或者用筆畫下來）整個 DFS 過程，包括每個遞迴方法何時開啟、何時返回。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 9-12   圖的深度優先走訪步驟 </p> <p>深度優先走訪的序列是否唯一？</p> <p>與廣度優先走訪類似，深度優先走訪序列的順序也不是唯一的。給定某頂點，先往哪個方向探索都可以，即鄰接頂點的順序可以任意打亂，都是深度優先走訪。</p> <p>以樹的走訪為例，“根 \\(\\rightarrow\\) 左 \\(\\rightarrow\\) 右”“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”“左 \\(\\rightarrow\\) 右 \\(\\rightarrow\\) 根”分別對應前序、中序、後序走訪，它們展示了三種走訪優先順序，然而這三者都屬於深度優先走訪。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/graph_traversal/#2_1","level":3,"title":"2.   複雜度分析","text":"<p>時間複雜度：所有頂點都會被訪問 \\(1\\) 次，使用 \\(O(|V|)\\) 時間；所有邊都會被訪問 \\(2\\) 次，使用 \\(O(2|E|)\\) 時間；總體使用 \\(O(|V| + |E|)\\) 時間。</p> <p>空間複雜度：串列 <code>res</code> ，雜湊集合 <code>visited</code> 頂點數量最多為 \\(|V|\\) ，遞迴深度最大為 \\(|V|\\) ，因此使用 \\(O(|V|)\\) 空間。</p>","path":["第 9 章 &nbsp; 圖","9.3 &nbsp; 圖的走訪"],"tags":[]},{"location":"chapter_graph/summary/","level":1,"title":"9.4   小結","text":"","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_graph/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>圖由頂點和邊組成，可以表示為一組頂點和一組邊構成的集合。</li> <li>相較於線性關係（鏈結串列）和分治關係（樹），網路關係（圖）具有更高的自由度，因而更為複雜。</li> <li>有向圖的邊具有方向性，連通圖中的任意頂點均可達，有權圖的每條邊都包含權重變數。</li> <li>鄰接矩陣利用矩陣來表示圖，每一行（列）代表一個頂點，矩陣元素代表邊，用 \\(1\\) 或 \\(0\\) 表示兩個頂點之間有邊或無邊。鄰接矩陣在增刪查改操作上效率很高，但空間佔用較多。</li> <li>鄰接表使用多個鏈結串列來表示圖，第 \\(i\\) 個鏈結串列對應頂點 \\(i\\) ，其中儲存了該頂點的所有鄰接頂點。鄰接表相對於鄰接矩陣更加節省空間，但由於需要走訪鏈結串列來查詢邊，因此時間效率較低。</li> <li>當鄰接表中的鏈結串列過長時，可以將其轉換為紅黑樹或雜湊表，從而提升查詢效率。</li> <li>從演算法思想的角度分析，鄰接矩陣體現了“以空間換時間”，鄰接表體現了“以時間換空間”。</li> <li>圖可用於建模各類現實系統，如社交網路、地鐵線路等。</li> <li>樹是圖的一種特例，樹的走訪也是圖的走訪的一種特例。</li> <li>圖的廣度優先走訪是一種由近及遠、層層擴張的搜尋方式，通常藉助佇列實現。</li> <li>圖的深度優先走訪是一種優先走到底、無路可走時再回溯的搜尋方式，常基於遞迴來實現。</li> </ul>","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_graph/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：路徑的定義是頂點序列還是邊序列？</p> <p>維基百科上不同語言版本的定義不一致：英文版是“路徑是一個邊序列”，而中文版是“路徑是一個頂點序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.</p> <p>在本文中，路徑被視為一個邊序列，而不是一個頂點序列。這是因為兩個頂點之間可能存在多條邊連線，此時每條邊都對應一條路徑。</p> <p>Q：非連通圖中是否會有無法走訪到的點？</p> <p>在非連通圖中，從某個頂點出發，至少有一個頂點無法到達。走訪非連通圖需要設定多個起點，以走訪到圖的所有連通分量。</p> <p>Q：在鄰接表中，“與該頂點相連的所有頂點”的頂點順序是否有要求？</p> <p>可以是任意順序。但在實際應用中，可能需要按照指定規則來排序，比如按照頂點新增的次序，或者按照頂點值大小的順序等，這樣有助於快速查詢“帶有某種極值”的頂點。</p>","path":["第 9 章 &nbsp; 圖","9.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_greedy/","level":1,"title":"第 15 章   貪婪","text":"<p>Abstract</p> <p>向日葵朝著太陽轉動，時刻追求自身成長的最大可能。</p> <p>貪婪策略在一輪輪的簡單選擇中，逐步導向最佳答案。</p>","path":["第 15 章 &nbsp; 貪婪"],"tags":[]},{"location":"chapter_greedy/#_1","level":2,"title":"本章內容","text":"<ul> <li>15.1   貪婪演算法</li> <li>15.2   分數背包問題</li> <li>15.3   最大容量問題</li> <li>15.4   最大切分乘積問題</li> <li>15.5   小結</li> </ul>","path":["第 15 章 &nbsp; 貪婪"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/","level":1,"title":"15.2   分數背包問題","text":"<p>Question</p> <p>給定 \\(n\\) 個物品，第 \\(i\\) 個物品的重量為 \\(wgt[i-1]\\)、價值為 \\(val[i-1]\\) ，和一個容量為 \\(cap\\) 的背包。每個物品只能選擇一次，但可以選擇物品的一部分，價值根據選擇的重量比例計算，問在限定背包容量下背包中物品的最大價值。示例如圖 15-3 所示。</p> <p></p> <p> 圖 15-3   分數背包問題的示例資料 </p> <p>分數背包問題和 0-1 背包問題整體上非常相似，狀態包含當前物品 \\(i\\) 和容量 \\(c\\) ，目標是求限定背包容量下的最大價值。</p> <p>不同點在於，本題允許只選擇物品的一部分。如圖 15-4 所示，我們可以對物品任意地進行切分，並按照重量比例來計算相應價值。</p> <ol> <li>對於物品 \\(i\\) ，它在單位重量下的價值為 \\(val[i-1] / wgt[i-1]\\) ，簡稱單位價值。</li> <li>假設放入一部分物品 \\(i\\) ，重量為 \\(w\\) ，則背包增加的價值為 \\(w \\times val[i-1] / wgt[i-1]\\) 。</li> </ol> <p></p> <p> 圖 15-4   物品在單位重量下的價值 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>最大化背包內物品總價值，本質上是最大化單位重量下的物品價值。由此便可推理出圖 15-5 所示的貪婪策略。</p> <ol> <li>將物品按照單位價值從高到低進行排序。</li> <li>走訪所有物品，每輪貪婪地選擇單位價值最高的物品。</li> <li>若剩餘背包容量不足，則使用當前物品的一部分填滿背包。</li> </ol> <p></p> <p> 圖 15-5   分數背包問題的貪婪策略 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>我們建立了一個物品類別 <code>Item</code> ，以便將物品按照單位價值進行排序。迴圈進行貪婪選擇，當背包已滿時跳出並返回解：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby fractional_knapsack.py<pre><code>class Item:\n    \"\"\"物品\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # 物品重量\n        self.v = v  # 物品價值\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -&gt; int:\n    \"\"\"分數背包：貪婪\"\"\"\n    # 建立物品串列，包含兩個屬性：重量、價值\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # 迴圈貪婪選擇\n    res = 0\n    for item in items:\n        if item.w &lt;= cap:\n            # 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v\n            cap -= item.w\n        else:\n            # 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap\n            # 已無剩餘容量，因此跳出迴圈\n            break\n    return res\n</code></pre> fractional_knapsack.cpp<pre><code>/* 物品 */\nclass Item {\n  public:\n    int w; // 物品重量\n    int v; // 物品價值\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(vector&lt;int&gt; &amp;wgt, vector&lt;int&gt; &amp;val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    vector&lt;Item&gt; items;\n    for (int i = 0; i &lt; wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    sort(items.begin(), items.end(), [](Item &amp;a, Item &amp;b) { return (double)a.v / a.w &gt; (double)b.v / b.w; });\n    // 迴圈貪婪選擇\n    double res = 0;\n    for (auto &amp;item : items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double)item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.java<pre><code>/* 物品 */\nclass Item {\n    int w; // 物品重量\n    int v; // 物品價值\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i &lt; wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    Arrays.sort(items, Comparator.comparingDouble(item -&gt; -((double) item.v / item.w)));\n    // 迴圈貪婪選擇\n    double res = 0;\n    for (Item item : items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double) item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.cs<pre><code>/* 物品 */\nclass Item(int w, int v) {\n    public int w = w; // 物品重量\n    public int v = v; // 物品價值\n}\n\n/* 分數背包：貪婪 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i &lt; wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    Array.Sort(items, (x, y) =&gt; (y.v / y.w).CompareTo(x.v / x.w));\n    // 迴圈貪婪選擇\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (double)item.v / item.w * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.go<pre><code>/* 物品 */\ntype Item struct {\n    w int // 物品重量\n    v int // 物品價值\n}\n\n/* 分數背包：貪婪 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    items := make([]Item, len(wgt))\n    for i := 0; i &lt; len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) &gt; float64(items[j].v)/float64(items[j].w)\n    })\n    // 迴圈貪婪選擇\n    res := 0.0\n    for _, item := range items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.swift<pre><code>/* 物品 */\nclass Item {\n    var w: Int // 物品重量\n    var v: Int // 物品價值\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* 分數背包：貪婪 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -&gt; Double {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort { -(Double($0.v) / Double($0.w)) &lt; -(Double($1.v) / Double($1.w)) }\n    // 迴圈貪婪選擇\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.js<pre><code>/* 物品 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // 物品重量\n        this.v = v; // 物品價值\n    }\n}\n\n/* 分數背包：貪婪 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    const items = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 迴圈貪婪選擇\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.ts<pre><code>/* 物品 */\nclass Item {\n    w: number; // 物品重量\n    v: number; // 物品價值\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* 分數背包：貪婪 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    const items: Item[] = wgt.map((w, i) =&gt; new Item(w, val[i]));\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort((a, b) =&gt; b.v / b.w - a.v / a.w);\n    // 迴圈貪婪選擇\n    let res = 0;\n    for (const item of items) {\n        if (item.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (item.v / item.w) * cap;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    return res;\n}\n</code></pre> fractional_knapsack.dart<pre><code>/* 物品 */\nclass Item {\n  int w; // 物品重量\n  int v; // 物品價值\n\n  Item(this.w, this.v);\n}\n\n/* 分數背包：貪婪 */\ndouble fractionalKnapsack(List&lt;int&gt; wgt, List&lt;int&gt; val, int cap) {\n  // 建立物品串列，包含兩個屬性：重量、價值\n  List&lt;Item&gt; items = List.generate(wgt.length, (i) =&gt; Item(wgt[i], val[i]));\n  // 按照單位價值 item.v / item.w 從高到低進行排序\n  items.sort((a, b) =&gt; (b.v / b.w).compareTo(a.v / a.w));\n  // 迴圈貪婪選擇\n  double res = 0;\n  for (Item item in items) {\n    if (item.w &lt;= cap) {\n      // 若剩餘容量充足，則將當前物品整個裝進背包\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // 若剩餘容量不足，則將當前物品的一部分裝進背包\n      res += item.v / item.w * cap;\n      // 已無剩餘容量，因此跳出迴圈\n      break;\n    }\n  }\n  return res;\n}\n</code></pre> fractional_knapsack.rs<pre><code>/* 物品 */\nstruct Item {\n    w: i32, // 物品重量\n    v: i32, // 物品價值\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -&gt; Self {\n        Self { w, v }\n    }\n}\n\n/* 分數背包：貪婪 */\nfn fractional_knapsack(wgt: &amp;[i32], val: &amp;[i32], mut cap: i32) -&gt; f64 {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&amp;w, &amp;v)| Item::new(w, v))\n        .collect::&lt;Vec&lt;Item&gt;&gt;();\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&amp;(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // 迴圈貪婪選擇\n    let mut res = 0.0;\n    for item in &amp;items {\n        if item.w &lt;= cap {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // 已無剩餘容量，因此跳出迴圈\n            break;\n        }\n    }\n    res\n}\n</code></pre> fractional_knapsack.c<pre><code>/* 物品 */\ntypedef struct {\n    int w; // 物品重量\n    int v; // 物品價值\n} Item;\n\n/* 分數背包：貪婪 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i &lt; itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // 迴圈貪婪選擇\n    float res = 0.0;\n    for (int i = 0; i &lt; itemCount; i++) {\n        if (items[i].w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n</code></pre> fractional_knapsack.kt<pre><code>/* 物品 */\nclass Item(\n    val w: Int, // 物品\n    val v: Int  // 物品價值\n)\n\n/* 分數背包：貪婪 */\nfun fractionalKnapsack(wgt: IntArray, _val: IntArray, c: Int): Double {\n    // 建立物品串列，包含兩個屬性：重量、價值\n    var cap = c\n    val items = arrayOfNulls&lt;Item&gt;(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], _val[i])\n    }\n    // 按照單位價值 item.v / item.w 從高到低進行排序\n    items.sortBy { item: Item? -&gt; -(item!!.v.toDouble() / item.w) }\n    // 迴圈貪婪選擇\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w &lt;= cap) {\n            // 若剩餘容量充足，則將當前物品整個裝進背包\n            res += item.v\n            cap -= item.w\n        } else {\n            // 若剩餘容量不足，則將當前物品的一部分裝進背包\n            res += item.v.toDouble() / item.w * cap\n            // 已無剩餘容量，因此跳出迴圈\n            break\n        }\n    }\n    return res\n}\n</code></pre> fractional_knapsack.rb<pre><code>### 物品 ###\nclass Item\n  attr_accessor :w # 物品重量\n  attr_accessor :v # 物品價值\n\n  def initialize(w, v)\n    @w = w\n    @v = v\n  end\nend\n\n### 分數背包：貪婪 ###\ndef fractional_knapsack(wgt, val, cap)\n  # 建立物品串列，包含兩個屬性：重量，價值\n  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }\n  # 按照單位價值 item.v / item.w 從高到低進行排序\n  items.sort! { |a, b| (b.v.to_f / b.w) &lt;=&gt; (a.v.to_f / a.w) }\n  # 迴圈貪婪選擇\n  res = 0\n  for item in items\n    if item.w &lt;= cap\n      # 若剩餘容量充足，則將當前物品整個裝進背包\n      res += item.v\n      cap -= item.w\n    else\n      # 若剩餘容量不足，則將當前物品的一部分裝進背包\n      res += (item.v.to_f / item.w) * cap\n      # 已無剩餘容量，因此跳出迴圈\n      break\n    end\n  end\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>內建排序演算法的時間複雜度通常為 \\(O(\\log n)\\) ，空間複雜度通常為 \\(O(\\log n)\\) 或 \\(O(n)\\) ，取決於程式語言的具體實現。</p> <p>除排序之外，在最差情況下，需要走訪整個物品串列，因此時間複雜度為 \\(O(n)\\) ，其中 \\(n\\) 為物品數量。</p> <p>由於初始化了一個 <code>Item</code> 物件串列，因此空間複雜度為 \\(O(n)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/fractional_knapsack_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>採用反證法。假設物品 \\(x\\) 是單位價值最高的物品，使用某演算法求得最大價值為 <code>res</code> ，但該解中不包含物品 \\(x\\) 。</p> <p>現在從背包中拿出單位重量的任意物品，並替換為單位重量的物品 \\(x\\) 。由於物品 \\(x\\) 的單位價值最高，因此替換後的總價值一定大於 <code>res</code> 。這與 <code>res</code> 是最優解矛盾，說明最優解中必須包含物品 \\(x\\) 。</p> <p>對於該解中的其他物品，我們也可以構建出上述矛盾。總而言之，單位價值更大的物品總是更優選擇，這說明貪婪策略是有效的。</p> <p>如圖 15-6 所示，如果將物品重量和物品單位價值分別看作一張二維圖表的橫軸和縱軸，則分數背包問題可轉化為“求在有限橫軸區間下圍成的最大面積”。這個類比可以幫助我們從幾何角度理解貪婪策略的有效性。</p> <p></p> <p> 圖 15-6   分數背包問題的幾何表示 </p>","path":["第 15 章 &nbsp; 貪婪","15.2 &nbsp; 分數背包問題"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/","level":1,"title":"15.1   貪婪演算法","text":"<p>貪婪演算法（greedy algorithm）是一種常見的解決最佳化問題的演算法，其基本思想是在問題的每個決策階段，都選擇當前看起來最優的選擇，即貪婪地做出區域性最優的決策，以期獲得全域性最優解。貪婪演算法簡潔且高效，在許多實際問題中有著廣泛的應用。</p> <p>貪婪演算法和動態規劃都常用於解決最佳化問題。它們之間存在一些相似之處，比如都依賴最優子結構性質，但工作原理不同。</p> <ul> <li>動態規劃會根據之前階段的所有決策來考慮當前決策，並使用過去子問題的解來構建當前子問題的解。</li> <li>貪婪演算法不會考慮過去的決策，而是一路向前地進行貪婪選擇，不斷縮小問題範圍，直至問題被解決。</li> </ul> <p>我們先透過例題“零錢兌換”瞭解貪婪演算法的工作原理。這道題已經在“完全背包問題”章節中介紹過，相信你對它並不陌生。</p> <p>Question</p> <p>給定 \\(n\\) 種硬幣，第 \\(i\\) 種硬幣的面值為 \\(coins[i - 1]\\) ，目標金額為 \\(amt\\) ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 \\(-1\\) 。</p> <p>本題採取的貪婪策略如圖 15-1 所示。給定目標金額，我們貪婪地選擇不大於且最接近它的硬幣，不斷迴圈該步驟，直至湊出目標金額為止。</p> <p></p> <p> 圖 15-1   零錢兌換的貪婪策略 </p> <p>實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby coin_change_greedy.py<pre><code>def coin_change_greedy(coins: list[int], amt: int) -&gt; int:\n    \"\"\"零錢兌換：貪婪\"\"\"\n    # 假設 coins 串列有序\n    i = len(coins) - 1\n    count = 0\n    # 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0:\n        # 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 and coins[i] &gt; amt:\n            i -= 1\n        # 選擇 coins[i]\n        amt -= coins[i]\n        count += 1\n    # 若未找到可行方案，則返回 -1\n    return count if amt == 0 else -1\n</code></pre> coin_change_greedy.cpp<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(vector&lt;int&gt; &amp;coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.size() - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.java<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.length - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.cs<pre><code>/* 零錢兌換：貪婪 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // 假設 coins 串列有序\n    int i = coins.Length - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.go<pre><code>/* 零錢兌換：貪婪 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // 假設 coins 串列有序\n    i := len(coins) - 1\n    count := 0\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    for amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        for i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i--\n        }\n        // 選擇 coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // 若未找到可行方案，則返回 -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n</code></pre> coin_change_greedy.swift<pre><code>/* 零錢兌換：貪婪 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -&gt; Int {\n    // 假設 coins 串列有序\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1\n        }\n        // 選擇 coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1\n}\n</code></pre> coin_change_greedy.js<pre><code>/* 零錢兌換：貪婪 */\nfunction coinChangeGreedy(coins, amt) {\n    // 假設 coins 陣列有序\n    let i = coins.length - 1;\n    let count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.ts<pre><code>/* 零錢兌換：貪婪 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // 假設 coins 陣列有序\n    let i = coins.length - 1;\n    let count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt === 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.dart<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(List&lt;int&gt; coins, int amt) {\n  // 假設 coins 串列有序\n  int i = coins.length - 1;\n  int count = 0;\n  // 迴圈進行貪婪選擇，直到無剩餘金額\n  while (amt &gt; 0) {\n    // 找到小於且最接近剩餘金額的硬幣\n    while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n      i--;\n    }\n    // 選擇 coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // 若未找到可行方案，則返回 -1\n  return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.rs<pre><code>/* 零錢兌換：貪婪 */\nfn coin_change_greedy(coins: &amp;[i32], mut amt: i32) -&gt; i32 {\n    // 假設 coins 串列有序\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while amt &gt; 0 {\n        // 找到小於且最接近剩餘金額的硬幣\n        while i &gt; 0 &amp;&amp; coins[i] &gt; amt {\n            i -= 1;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // 若未找到可行方案，則返回 -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n</code></pre> coin_change_greedy.c<pre><code>/* 零錢兌換：貪婪 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // 假設 coins 串列有序\n    int i = size - 1;\n    int count = 0;\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (amt &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; amt) {\n            i--;\n        }\n        // 選擇 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // 若未找到可行方案，則返回 -1\n    return amt == 0 ? count : -1;\n}\n</code></pre> coin_change_greedy.kt<pre><code>/* 零錢兌換：貪婪 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // 假設 coins 串列有序\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // 迴圈進行貪婪選擇，直到無剩餘金額\n    while (am &gt; 0) {\n        // 找到小於且最接近剩餘金額的硬幣\n        while (i &gt; 0 &amp;&amp; coins[i] &gt; am) {\n            i--\n        }\n        // 選擇 coins[i]\n        am -= coins[i]\n        count++\n    }\n    // 若未找到可行方案，則返回 -1\n    return if (am == 0) count else -1\n}\n</code></pre> coin_change_greedy.rb<pre><code>### 零錢兌換：貪婪 ###\ndef coin_change_greedy(coins, amt)\n  # 假設 coins 串列有序\n  i = coins.length - 1\n  count = 0\n  # 迴圈進行貪婪選擇，直到無剩餘金額\n  while amt &gt; 0\n    # 找到小於且最接近剩餘金額的硬幣\n    while i &gt; 0 &amp;&amp; coins[i] &gt; amt\n      i -= 1\n    end\n    # 選擇 coins[i]\n    amt -= coins[i]\n    count += 1\n  end\n  # 若未找到可行方案， 則返回 -1\n  amt == 0 ? count : -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>你可能會不由地發出感嘆：So clean ！貪婪演算法僅用約十行程式碼就解決了零錢兌換問題。</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1511","level":2,"title":"15.1.1   貪婪演算法的優點與侷限性","text":"<p>貪婪演算法不僅操作直接、實現簡單，而且通常效率也很高。在以上程式碼中，記硬幣最小面值為 \\(\\min(coins)\\) ，則貪婪選擇最多迴圈 \\(amt / \\min(coins)\\) 次，時間複雜度為 \\(O(amt / \\min(coins))\\) 。這比動態規劃解法的時間複雜度 \\(O(n \\times amt)\\) 小了一個數量級。</p> <p>然而，對於某些硬幣面值組合，貪婪演算法並不能找到最優解。圖 15-2 給出了兩個示例。</p> <ul> <li>正例 \\(coins = [1, 5, 10, 20, 50, 100]\\)：在該硬幣組合下，給定任意 \\(amt\\) ，貪婪演算法都可以找到最優解。</li> <li>反例 \\(coins = [1, 20, 50]\\)：假設 \\(amt = 60\\) ，貪婪演算法只能找到 \\(50 + 1 \\times 10\\) 的兌換組合，共計 \\(11\\) 枚硬幣，但動態規劃可以找到最優解 \\(20 + 20 + 20\\) ，僅需 \\(3\\) 枚硬幣。</li> <li>反例 \\(coins = [1, 49, 50]\\)：假設 \\(amt = 98\\) ，貪婪演算法只能找到 \\(50 + 1 \\times 48\\) 的兌換組合，共計 \\(49\\) 枚硬幣，但動態規劃可以找到最優解 \\(49 + 49\\) ，僅需 \\(2\\) 枚硬幣。</li> </ul> <p></p> <p> 圖 15-2   貪婪演算法無法找出最優解的示例 </p> <p>也就是說，對於零錢兌換問題，貪婪演算法無法保證找到全域性最優解，並且有可能找到非常差的解。它更適合用動態規劃解決。</p> <p>一般情況下，貪婪演算法的適用情況分以下兩種。</p> <ol> <li>可以保證找到最優解：貪婪演算法在這種情況下往往是最優選擇，因為它往往比回溯、動態規劃更高效。</li> <li>可以找到近似最優解：貪婪演算法在這種情況下也是可用的。對於很多複雜問題來說，尋找全域性最優解非常困難，能以較高效率找到次優解也是非常不錯的。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1512","level":2,"title":"15.1.2   貪婪演算法特性","text":"<p>那麼問題來了，什麼樣的問題適合用貪婪演算法求解呢？或者說，貪婪演算法在什麼情況下可以保證找到最優解？</p> <p>相較於動態規劃，貪婪演算法的使用條件更加苛刻，其主要關注問題的兩個性質。</p> <ul> <li>貪婪選擇性質：只有當局部最優選擇始終可以導致全域性最優解時，貪婪演算法才能保證得到最優解。</li> <li>最優子結構：原問題的最優解包含子問題的最優解。</li> </ul> <p>最優子結構已經在“動態規劃”章節中介紹過，這裡不再贅述。值得注意的是，一些問題的最優子結構並不明顯，但仍然可使用貪婪演算法解決。</p> <p>我們主要探究貪婪選擇性質的判斷方法。雖然它的描述看上去比較簡單，但實際上對於許多問題，證明貪婪選擇性質並非易事。</p> <p>例如零錢兌換問題，我們雖然能夠容易地舉出反例，對貪婪選擇性質進行證偽，但證實的難度較大。如果問：滿足什麼條件的硬幣組合可以使用貪婪演算法求解？我們往往只能憑藉直覺或舉例子來給出一個模稜兩可的答案，而難以給出嚴謹的數學證明。</p> <p>Quote</p> <p>有一篇論文給出了一個 \\(O(n^3)\\) 時間複雜度的演算法，用於判斷一個硬幣組合能否使用貪婪演算法找出任意金額的最優解。</p> <p>Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1513","level":2,"title":"15.1.3   貪婪演算法解題步驟","text":"<p>貪婪問題的解決流程大體可分為以下三步。</p> <ol> <li>問題分析：梳理與理解問題特性，包括狀態定義、最佳化目標和約束條件等。這一步在回溯和動態規劃中都有涉及。</li> <li>確定貪婪策略：確定如何在每一步中做出貪婪選擇。這個策略能夠在每一步減小問題的規模，並最終解決整個問題。</li> <li>正確性證明：通常需要證明問題具有貪婪選擇性質和最優子結構。這個步驟可能需要用到數學證明，例如歸納法或反證法等。</li> </ol> <p>確定貪婪策略是求解問題的核心步驟，但實施起來可能並不容易，主要有以下原因。</p> <ul> <li>不同問題的貪婪策略的差異較大。對於許多問題來說，貪婪策略比較淺顯，我們透過一些大概的思考與嘗試就能得出。而對於一些複雜問題，貪婪策略可能非常隱蔽，這種情況就非常考驗個人的解題經驗與演算法能力了。</li> <li>某些貪婪策略具有較強的迷惑性。當我們滿懷信心設計好貪婪策略，寫出解題程式碼並提交執行，很可能發現部分測試樣例無法透過。這是因為設計的貪婪策略只是“部分正確”的，上文介紹的零錢兌換就是一個典型案例。</li> </ul> <p>為了保證正確性，我們應該對貪婪策略進行嚴謹的數學證明，通常需要用到反證法或數學歸納法。</p> <p>然而，正確性證明也很可能不是一件易事。如若沒有頭緒，我們通常會選擇面向測試用例進行程式碼除錯，一步步修改與驗證貪婪策略。</p>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/greedy_algorithm/#1514","level":2,"title":"15.1.4   貪婪演算法典型例題","text":"<p>貪婪演算法常常應用在滿足貪婪選擇性質和最優子結構的最佳化問題中，以下列舉了一些典型的貪婪演算法問題。</p> <ul> <li>硬幣找零問題：在某些硬幣組合下，貪婪演算法總是可以得到最優解。</li> <li>區間排程問題：假設你有一些任務，每個任務在一段時間內進行，你的目標是完成儘可能多的任務。如果每次都選擇結束時間最早的任務，那麼貪婪演算法就可以得到最優解。</li> <li>分數背包問題：給定一組物品和一個載重量，你的目標是選擇一組物品，使得總重量不超過載重量，且總價值最大。如果每次都選擇價效比最高（價值 / 重量）的物品，那麼貪婪演算法在一些情況下可以得到最優解。</li> <li>股票買賣問題：給定一組股票的歷史價格，你可以進行多次買賣，但如果你已經持有股票，那麼在賣出之前不能再買，目標是獲取最大利潤。</li> <li>霍夫曼編碼：霍夫曼編碼是一種用於無損資料壓縮的貪婪演算法。透過構建霍夫曼樹，每次選擇出現頻率最低的兩個節點合併，最後得到的霍夫曼樹的帶權路徑長度（編碼長度）最小。</li> <li>Dijkstra 演算法：它是一種解決給定源頂點到其餘各頂點的最短路徑問題的貪婪演算法。</li> </ul>","path":["第 15 章 &nbsp; 貪婪","15.1 &nbsp; 貪婪演算法"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/","level":1,"title":"15.3   最大容量問題","text":"<p>Question</p> <p>輸入一個陣列 \\(ht\\) ，其中的每個元素代表一個垂直隔板的高度。陣列中的任意兩個隔板，以及它們之間的空間可以組成一個容器。</p> <p>容器的容量等於高度和寬度的乘積（面積），其中高度由較短的隔板決定，寬度是兩個隔板的陣列索引之差。</p> <p>請在陣列中選擇兩個隔板，使得組成的容器的容量最大，返回最大容量。示例如圖 15-7 所示。</p> <p></p> <p> 圖 15-7   最大容量問題的示例資料 </p> <p>容器由任意兩個隔板圍成，因此本題的狀態為兩個隔板的索引，記為 \\([i, j]\\) 。</p> <p>根據題意，容量等於高度乘以寬度，其中高度由短板決定，寬度是兩隔板的陣列索引之差。設容量為 \\(cap[i, j]\\) ，則可得計算公式：</p> \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\] <p>設陣列長度為 \\(n\\) ，兩個隔板的組合數量（狀態總數）為 \\(C_n^2 = \\frac{n(n - 1)}{2}\\) 個。最直接地，我們可以窮舉所有狀態，從而求得最大容量，時間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>這道題還有更高效率的解法。如圖 15-8 所示，現選取一個狀態 \\([i, j]\\) ，其滿足索引 \\(i &lt; j\\) 且高度 \\(ht[i] &lt; ht[j]\\) ，即 \\(i\\) 為短板、\\(j\\) 為長板。</p> <p></p> <p> 圖 15-8   初始狀態 </p> <p>如圖 15-9 所示，若此時將長板 \\(j\\) 向短板 \\(i\\) 靠近，則容量一定變小。</p> <p>這是因為在移動長板 \\(j\\) 後，寬度 \\(j-i\\) 肯定變小；而高度由短板決定，因此高度只可能不變（ \\(i\\) 仍為短板）或變小（移動後的 \\(j\\) 成為短板）。</p> <p></p> <p> 圖 15-9   向內移動長板後的狀態 </p> <p>反向思考，我們只有向內收縮短板 \\(i\\) ，才有可能使容量變大。因為雖然寬度一定變小，但高度可能會變大（移動後的短板 \\(i\\) 可能會變長）。例如在圖 15-10 中，移動短板後面積變大。</p> <p></p> <p> 圖 15-10   向內移動短板後的狀態 </p> <p>由此便可推出本題的貪婪策略：初始化兩指標，使其分列容器兩端，每輪向內收縮短板對應的指標，直至兩指標相遇。</p> <p>圖 15-11 展示了貪婪策略的執行過程。</p> <ol> <li>初始狀態下，指標 \\(i\\) 和 \\(j\\) 分列陣列兩端。</li> <li>計算當前狀態的容量 \\(cap[i, j]\\) ，並更新最大容量。</li> <li>比較板 \\(i\\) 和板 \\(j\\) 的高度，並將短板向內移動一格。</li> <li>迴圈執行第 <code>2.</code> 步和第 <code>3.</code> 步，直至 \\(i\\) 和 \\(j\\) 相遇時結束。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 15-11   最大容量問題的貪婪過程 </p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>程式碼迴圈最多 \\(n\\) 輪，因此時間複雜度為 \\(O(n)\\) 。</p> <p>變數 \\(i\\)、\\(j\\)、\\(res\\) 使用常數大小的額外空間，因此空間複雜度為 \\(O(1)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_capacity.py<pre><code>def max_capacity(ht: list[int]) -&gt; int:\n    \"\"\"最大容量：貪婪\"\"\"\n    # 初始化 i, j，使其分列陣列兩端\n    i, j = 0, len(ht) - 1\n    # 初始最大容量為 0\n    res = 0\n    # 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j:\n        # 更新最大容量\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # 向內移動短板\n        if ht[i] &lt; ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n</code></pre> max_capacity.cpp<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(vector&lt;int&gt; &amp;ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.size() - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.java<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(int[] ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.length - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.cs<pre><code>/* 最大容量：貪婪 */\nint MaxCapacity(int[] ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0, j = ht.Length - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.go<pre><code>/* 最大容量：貪婪 */\nfunc maxCapacity(ht []int) int {\n    // 初始化 i, j，使其分列陣列兩端\n    i, j := 0, len(ht)-1\n    // 初始最大容量為 0\n    res := 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    for i &lt; j {\n        // 更新最大容量\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.swift<pre><code>/* 最大容量：貪婪 */\nfunc maxCapacity(ht: [Int]) -&gt; Int {\n    // 初始化 i, j，使其分列陣列兩端\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // 初始最大容量為 0\n    var res = 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j {\n        // 更新最大容量\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.js<pre><code>/* 最大容量：貪婪 */\nfunction maxCapacity(ht) {\n    // 初始化 i, j，使其分列陣列兩端\n    let i = 0,\n        j = ht.length - 1;\n    // 初始最大容量為 0\n    let res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.ts<pre><code>/* 最大容量：貪婪 */\nfunction maxCapacity(ht: number[]): number {\n    // 初始化 i, j，使其分列陣列兩端\n    let i = 0,\n        j = ht.length - 1;\n    // 初始最大容量為 0\n    let res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.dart<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(List&lt;int&gt; ht) {\n  // 初始化 i, j，使其分列陣列兩端\n  int i = 0, j = ht.length - 1;\n  // 初始最大容量為 0\n  int res = 0;\n  // 迴圈貪婪選擇，直至兩板相遇\n  while (i &lt; j) {\n    // 更新最大容量\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // 向內移動短板\n    if (ht[i] &lt; ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n</code></pre> max_capacity.rs<pre><code>/* 最大容量：貪婪 */\nfn max_capacity(ht: &amp;[i32]) -&gt; i32 {\n    // 初始化 i, j，使其分列陣列兩端\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // 初始最大容量為 0\n    let mut res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while i &lt; j {\n        // 更新最大容量\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // 向內移動短板\n        if ht[i] &lt; ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n</code></pre> max_capacity.c<pre><code>/* 最大容量：貪婪 */\nint maxCapacity(int ht[], int htLength) {\n    // 初始化 i, j，使其分列陣列兩端\n    int i = 0;\n    int j = htLength - 1;\n    // 初始最大容量為 0\n    int res = 0;\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n</code></pre> max_capacity.kt<pre><code>/* 最大容量：貪婪 */\nfun maxCapacity(ht: IntArray): Int {\n    // 初始化 i, j，使其分列陣列兩端\n    var i = 0\n    var j = ht.size - 1\n    // 初始最大容量為 0\n    var res = 0\n    // 迴圈貪婪選擇，直至兩板相遇\n    while (i &lt; j) {\n        // 更新最大容量\n        val cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // 向內移動短板\n        if (ht[i] &lt; ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n</code></pre> max_capacity.rb<pre><code>### 最大容量：貪婪 ###\ndef max_capacity(ht)\n  # 初始化 i, j，使其分列陣列兩端\n  i, j = 0, ht.length - 1\n  # 初始最大容量為 0\n  res = 0\n\n  # 迴圈貪婪選擇，直至兩板相遇\n  while i &lt; j\n    # 更新最大容量\n    cap = [ht[i], ht[j]].min * (j - i)\n    res = [res, cap].max\n    # 向內移動短板\n    if ht[i] &lt; ht[j]\n      i += 1\n    else\n      j -= 1\n    end\n  end\n\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_capacity_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>之所以貪婪比窮舉更快，是因為每輪的貪婪選擇都會“跳過”一些狀態。</p> <p>比如在狀態 \\(cap[i, j]\\) 下，\\(i\\) 為短板、\\(j\\) 為長板。若貪婪地將短板 \\(i\\) 向內移動一格，會導致圖 15-12 所示的狀態被“跳過”。這意味著之後無法驗證這些狀態的容量大小。</p> \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\] <p></p> <p> 圖 15-12   移動短板導致被跳過的狀態 </p> <p>觀察發現，這些被跳過的狀態實際上就是將長板 \\(j\\) 向內移動的所有狀態。前面我們已經證明內移長板一定會導致容量變小。也就是說，被跳過的狀態都不可能是最優解，跳過它們不會導致錯過最優解。</p> <p>以上分析說明，移動短板的操作是“安全”的，貪婪策略是有效的。</p>","path":["第 15 章 &nbsp; 貪婪","15.3 &nbsp; 最大容量問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/","level":1,"title":"15.4   最大切分乘積問題","text":"<p>Question</p> <p>給定一個正整數 \\(n\\) ，將其切分為至少兩個正整數的和，求切分後所有整數的乘積最大是多少，如圖 15-13 所示。</p> <p></p> <p> 圖 15-13   最大切分乘積的問題定義 </p> <p>假設我們將 \\(n\\) 切分為 \\(m\\) 個整數因子，其中第 \\(i\\) 個因子記為 \\(n_i\\) ，即</p> \\[ n = \\sum_{i=1}^{m}n_i \\] <p>本題的目標是求得所有整數因子的最大乘積，即</p> \\[ \\max(\\prod_{i=1}^{m}n_i) \\] <p>我們需要思考的是：切分數量 \\(m\\) 應該多大，每個 \\(n_i\\) 應該是多少？</p>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#1","level":3,"title":"1.   貪婪策略確定","text":"<p>根據經驗，兩個整數的乘積往往比它們的加和更大。假設從 \\(n\\) 中分出一個因子 \\(2\\) ，則它們的乘積為 \\(2(n-2)\\) 。我們將該乘積與 \\(n\\) 作比較：</p> \\[ \\begin{aligned} 2(n-2) &amp; \\geq n \\newline 2n - n - 4 &amp; \\geq 0 \\newline n &amp; \\geq 4 \\end{aligned} \\] <p>如圖 15-14 所示，當 \\(n \\geq 4\\) 時，切分出一個 \\(2\\) 後乘積會變大，這說明大於等於 \\(4\\) 的整數都應該被切分。</p> <p>貪婪策略一：如果切分方案中包含 \\(\\geq 4\\) 的因子，那麼它就應該被繼續切分。最終的切分方案只應出現 \\(1\\)、\\(2\\)、\\(3\\) 這三種因子。</p> <p></p> <p> 圖 15-14   切分導致乘積變大 </p> <p>接下來思考哪個因子是最優的。在 \\(1\\)、\\(2\\)、\\(3\\) 這三個因子中，顯然 \\(1\\) 是最差的，因為 \\(1 \\times (n-1) &lt; n\\) 恆成立，即切分出 \\(1\\) 反而會導致乘積減小。</p> <p>如圖 15-15 所示，當 \\(n = 6\\) 時，有 \\(3 \\times 3 &gt; 2 \\times 2 \\times 2\\) 。這意味著切分出 \\(3\\) 比切分出 \\(2\\) 更優。</p> <p>貪婪策略二：在切分方案中，最多隻應存在兩個 \\(2\\) 。因為三個 \\(2\\) 總是可以替換為兩個 \\(3\\) ，從而獲得更大的乘積。</p> <p></p> <p> 圖 15-15   最優切分因子 </p> <p>綜上所述，可推理出以下貪婪策略。</p> <ol> <li>輸入整數 \\(n\\) ，從其不斷地切分出因子 \\(3\\) ，直至餘數為 \\(0\\)、\\(1\\)、\\(2\\) 。</li> <li>當餘數為 \\(0\\) 時，代表 \\(n\\) 是 \\(3\\) 的倍數，因此不做任何處理。</li> <li>當餘數為 \\(2\\) 時，不繼續劃分，保留。</li> <li>當餘數為 \\(1\\) 時，由於 \\(2 \\times 2 &gt; 1 \\times 3\\) ，因此應將最後一個 \\(3\\) 替換為 \\(2\\) 。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#2","level":3,"title":"2.   程式碼實現","text":"<p>如圖 15-16 所示，我們無須透過迴圈來切分整數，而可以利用向下整除運算得到 \\(3\\) 的個數 \\(a\\) ，用取模運算得到餘數 \\(b\\) ，此時有：</p> \\[ n = 3 a + b \\] <p>請注意，對於 \\(n \\leq 3\\) 的邊界情況，必須拆分出一個 \\(1\\) ，乘積為 \\(1 \\times (n - 1)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby max_product_cutting.py<pre><code>def max_product_cutting(n: int) -&gt; int:\n    \"\"\"最大切分乘積：貪婪\"\"\"\n    # 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3:\n        return 1 * (n - 1)\n    # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    a, b = n // 3, n % 3\n    if b == 1:\n        # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # 當餘數為 2 時，不做處理\n        return int(math.pow(3, a)) * 2\n    # 當餘數為 0 時，不做處理\n    return int(math.pow(3, a))\n</code></pre> max_product_cutting.cpp<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int)pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int)pow(3, a);\n}\n</code></pre> max_product_cutting.java<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int) Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int) Math.pow(3, a);\n}\n</code></pre> max_product_cutting.cs<pre><code>/* 最大切分乘積：貪婪 */\nint MaxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return (int)Math.Pow(3, a);\n}\n</code></pre> max_product_cutting.go<pre><code>/* 最大切分乘積：貪婪 */\nfunc maxProductCutting(n int) int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // 當餘數為 2 時，不做處理\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return int(math.Pow(3, float64(a)))\n}\n</code></pre> max_product_cutting.swift<pre><code>/* 最大切分乘積：貪婪 */\nfunc maxProductCutting(n: Int) -&gt; Int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // 當餘數為 2 時，不做處理\n        return pow(3, a) * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return pow(3, a)\n}\n</code></pre> max_product_cutting.js<pre><code>/* 最大切分乘積：貪婪 */\nfunction maxProductCutting(n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 當餘數為 2 時，不做處理\n        return Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.ts<pre><code>/* 最大切分乘積：貪婪 */\nfunction maxProductCutting(n: number): number {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // 當餘數為 2 時，不做處理\n        return Math.pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return Math.pow(3, a);\n}\n</code></pre> max_product_cutting.dart<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n  // 當 n &lt;= 3 時，必須切分出一個 1\n  if (n &lt;= 3) {\n    return 1 * (n - 1);\n  }\n  // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // 當餘數為 2 時，不做處理\n    return (pow(3, a) * 2).toInt();\n  }\n  // 當餘數為 0 時，不做處理\n  return pow(3, a).toInt();\n}\n</code></pre> max_product_cutting.rs<pre><code>/* 最大切分乘積：貪婪 */\nfn max_product_cutting(n: i32) -&gt; i32 {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if n &lt;= 3 {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // 當餘數為 2 時，不做處理\n        3_i32.pow(a as u32) * 2\n    } else {\n        // 當餘數為 0 時，不做處理\n        3_i32.pow(a as u32)\n    }\n}\n</code></pre> max_product_cutting.c<pre><code>/* 最大切分乘積：貪婪 */\nint maxProductCutting(int n) {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1);\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return pow(3, a) * 2;\n    }\n    // 當餘數為 0 時，不做處理\n    return pow(3, a);\n}\n</code></pre> max_product_cutting.kt<pre><code>/* 最大切分乘積：貪婪 */\nfun maxProductCutting(n: Int): Int {\n    // 當 n &lt;= 3 時，必須切分出一個 1\n    if (n &lt;= 3) {\n        return 1 * (n - 1)\n    }\n    // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n        return 3.0.pow((a - 1)).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // 當餘數為 2 時，不做處理\n        return 3.0.pow(a).toInt() * 2 * 2\n    }\n    // 當餘數為 0 時，不做處理\n    return 3.0.pow(a).toInt()\n}\n</code></pre> max_product_cutting.rb<pre><code>### 最大切分乘積：貪婪 ###\ndef max_product_cutting(n)\n  # 當 n &lt;= 3 時，必須切分出一個 1\n  return 1 * (n - 1) if n &lt;= 3\n  # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數\n  a, b = n / 3, n % 3\n  # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2\n  return (3.pow(a - 1) * 2 * 2).to_i if b == 1\n  # 當餘數為 2 時，不做處理\n  return (3.pow(a) * 2).to_i if b == 2\n  # 當餘數為 0 時，不做處理\n  3.pow(a).to_i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p></p> <p> 圖 15-16   最大切分乘積的計算方法 </p> <p>時間複雜度取決於程式語言的冪運算的實現方法。以 Python 為例，常用的冪計算函式有三種。</p> <ul> <li>運算子 <code>**</code> 和函式 <code>pow()</code> 的時間複雜度均為 \\(O(\\log⁡ a)\\) 。</li> <li>函式 <code>math.pow()</code> 內部呼叫 C 語言庫的 <code>pow()</code> 函式，其執行浮點取冪，時間複雜度為 \\(O(1)\\) 。</li> </ul> <p>變數 \\(a\\) 和 \\(b\\) 使用常數大小的額外空間，因此空間複雜度為 \\(O(1)\\) 。</p>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/max_product_cutting_problem/#3","level":3,"title":"3.   正確性證明","text":"<p>使用反證法，只分析 \\(n \\geq 4\\) 的情況。</p> <ol> <li>所有因子 \\(\\leq 3\\) ：假設最優切分方案中存在 \\(\\geq 4\\) 的因子 \\(x\\) ，那麼一定可以將其繼續劃分為 \\(2(x-2)\\) ，從而獲得更大（或相等）的乘積。這與假設矛盾。</li> <li>切分方案不包含 \\(1\\) ：假設最優切分方案中存在一個因子 \\(1\\) ，那麼它一定可以合併入另外一個因子中，以獲得更大的乘積。這與假設矛盾。</li> <li>切分方案最多包含兩個 \\(2\\) ：假設最優切分方案中包含三個 \\(2\\) ，那麼一定可以替換為兩個 \\(3\\) ，乘積更大。這與假設矛盾。</li> </ol>","path":["第 15 章 &nbsp; 貪婪","15.4 &nbsp; 最大切分乘積問題"],"tags":[]},{"location":"chapter_greedy/summary/","level":1,"title":"15.5   小結","text":"","path":["第 15 章 &nbsp; 貪婪","15.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_greedy/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>貪婪演算法通常用於解決最最佳化問題，其原理是在每個決策階段都做出區域性最優的決策，以期獲得全域性最優解。</li> <li>貪婪演算法會迭代地做出一個又一個的貪婪選擇，每輪都將問題轉化成一個規模更小的子問題，直到問題被解決。</li> <li>貪婪演算法不僅實現簡單，還具有很高的解題效率。相比於動態規劃，貪婪演算法的時間複雜度通常更低。</li> <li>在零錢兌換問題中，對於某些硬幣組合，貪婪演算法可以保證找到最優解；對於另外一些硬幣組合則不然，貪婪演算法可能找到很差的解。</li> <li>適合用貪婪演算法求解的問題具有兩大性質：貪婪選擇性質和最優子結構。貪婪選擇性質代表貪婪策略的有效性。</li> <li>對於某些複雜問題，貪婪選擇性質的證明並不簡單。相對來說，證偽更加容易，例如零錢兌換問題。</li> <li>求解貪婪問題主要分為三步：問題分析、確定貪婪策略、正確性證明。其中，確定貪婪策略是核心步驟，正確性證明往往是難點。</li> <li>分數背包問題在 0-1 背包的基礎上，允許選擇物品的一部分，因此可使用貪婪演算法求解。貪婪策略的正確性可以使用反證法來證明。</li> <li>最大容量問題可使用窮舉法求解，時間複雜度為 \\(O(n^2)\\) 。透過設計貪婪策略，每輪向內移動短板，可將時間複雜度最佳化至 \\(O(n)\\) 。</li> <li>在最大切分乘積問題中，我們先後推理出兩個貪婪策略：\\(\\geq 4\\) 的整數都應該繼續切分，最優切分因子為 \\(3\\) 。程式碼中包含冪運算，時間複雜度取決於冪運算實現方法，通常為 \\(O(1)\\) 或 \\(O(\\log n)\\) 。</li> </ul>","path":["第 15 章 &nbsp; 貪婪","15.5 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/","level":1,"title":"第 6 章   雜湊表","text":"<p>Abstract</p> <p>在計算機世界中，雜湊表如同一位聰慧的圖書管理員。</p> <p>他知道如何計算索書號，從而可以快速找到目標圖書。</p>","path":["第 6 章 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/#_1","level":2,"title":"本章內容","text":"<ul> <li>6.1   雜湊表</li> <li>6.2   雜湊衝突</li> <li>6.3   雜湊演算法</li> <li>6.4   小結</li> </ul>","path":["第 6 章 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/","level":1,"title":"6.3   雜湊演算法","text":"<p>前兩節介紹了雜湊表的工作原理和雜湊衝突的處理方法。然而無論是開放定址還是鏈式位址，它們只能保證雜湊表可以在發生衝突時正常工作，而無法減少雜湊衝突的發生。</p> <p>如果雜湊衝突過於頻繁，雜湊表的效能則會急劇劣化。如圖 6-8 所示，對於鏈式位址雜湊表，理想情況下鍵值對均勻分佈在各個桶中，達到最佳查詢效率；最差情況下所有鍵值對都儲存到同一個桶中，時間複雜度退化至 \\(O(n)\\) 。</p> <p></p> <p> 圖 6-8   雜湊衝突的最佳情況與最差情況 </p> <p>鍵值對的分佈情況由雜湊函式決定。回憶雜湊函式的計算步驟，先計算雜湊值，再對陣列長度取模：</p> <pre><code>index = hash(key) % capacity\n</code></pre> <p>觀察以上公式，當雜湊表容量 <code>capacity</code> 固定時，雜湊演算法 <code>hash()</code> 決定了輸出值，進而決定了鍵值對在雜湊表中的分佈情況。</p> <p>這意味著，為了降低雜湊衝突的發生機率，我們應當將注意力集中在雜湊演算法 <code>hash()</code> 的設計上。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#631","level":2,"title":"6.3.1   雜湊演算法的目標","text":"<p>為了實現“既快又穩”的雜湊表資料結構，雜湊演算法應具備以下特點。</p> <ul> <li>確定性：對於相同的輸入，雜湊演算法應始終產生相同的輸出。這樣才能確保雜湊表是可靠的。</li> <li>效率高：計算雜湊值的過程應該足夠快。計算開銷越小，雜湊表的實用性越高。</li> <li>均勻分佈：雜湊演算法應使得鍵值對均勻分佈在雜湊表中。分佈越均勻，雜湊衝突的機率就越低。</li> </ul> <p>實際上，雜湊演算法除了可以用於實現雜湊表，還廣泛應用於其他領域中。</p> <ul> <li>密碼儲存：為了保護使用者密碼的安全，系統通常不會直接儲存使用者的明文密碼，而是儲存密碼的雜湊值。當用戶輸入密碼時，系統會對輸入的密碼計算雜湊值，然後與儲存的雜湊值進行比較。如果兩者匹配，那麼密碼就被視為正確。</li> <li>資料完整性檢查：資料傳送方可以計算資料的雜湊值並將其一同傳送；接收方可以重新計算接收到的資料的雜湊值，並與接收到的雜湊值進行比較。如果兩者匹配，那麼資料就被視為完整。</li> </ul> <p>對於密碼學的相關應用，為了防止從雜湊值推導出原始密碼等逆向工程，雜湊演算法需要具備更高等級的安全特性。</p> <ul> <li>單向性：無法透過雜湊值反推出關於輸入資料的任何資訊。</li> <li>抗碰撞性：應當極難找到兩個不同的輸入，使得它們的雜湊值相同。</li> <li>雪崩效應：輸入的微小變化應當導致輸出的顯著且不可預測的變化。</li> </ul> <p>請注意，“均勻分佈”與“抗碰撞性”是兩個獨立的概念，滿足均勻分佈不一定滿足抗碰撞性。例如，在隨機輸入 <code>key</code> 下，雜湊函式 <code>key % 100</code> 可以產生均勻分佈的輸出。然而該雜湊演算法過於簡單，所有後兩位相等的 <code>key</code> 的輸出都相同，因此我們可以很容易地從雜湊值反推出可用的 <code>key</code> ，從而破解密碼。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#632","level":2,"title":"6.3.2   雜湊演算法的設計","text":"<p>雜湊演算法的設計是一個需要考慮許多因素的複雜問題。然而對於某些要求不高的場景，我們也能設計一些簡單的雜湊演算法。</p> <ul> <li>加法雜湊：對輸入的每個字元的 ASCII 碼進行相加，將得到的總和作為雜湊值。</li> <li>乘法雜湊：利用乘法的不相關性，每輪乘以一個常數，將各個字元的 ASCII 碼累積到雜湊值中。</li> <li>互斥或雜湊：將輸入資料的每個元素透過互斥或操作累積到一個雜湊值中。</li> <li>旋轉雜湊：將每個字元的 ASCII 碼累積到一個雜湊值中，每次累積之前都會對雜湊值進行旋轉操作。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby simple_hash.py<pre><code>def add_hash(key: str) -&gt; int:\n    \"\"\"加法雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -&gt; int:\n    \"\"\"乘法雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -&gt; int:\n    \"\"\"互斥或雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -&gt; int:\n    \"\"\"旋轉雜湊\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ ord(c)\n    return hash % modulus\n</code></pre> simple_hash.cpp<pre><code>/* 加法雜湊 */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.java<pre><code>/* 加法雜湊 */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n</code></pre> simple_hash.cs<pre><code>/* 加法雜湊 */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n</code></pre> simple_hash.go<pre><code>/* 加法雜湊 */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 乘法雜湊 */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* 互斥或雜湊 */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash &amp; modulus\n}\n\n/* 旋轉雜湊 */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n</code></pre> simple_hash.swift<pre><code>/* 加法雜湊 */\nfunc addHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 乘法雜湊 */\nfunc mulHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* 互斥或雜湊 */\nfunc xorHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash &amp; MODULUS\n}\n\n/* 旋轉雜湊 */\nfunc rotHash(key: String) -&gt; Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n</code></pre> simple_hash.js<pre><code>/* 加法雜湊 */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乘法雜湊 */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 互斥或雜湊 */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 旋轉雜湊 */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.ts<pre><code>/* 加法雜湊 */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 乘法雜湊 */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* 互斥或雜湊 */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash % MODULUS;\n}\n\n/* 旋轉雜湊 */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n</code></pre> simple_hash.dart<pre><code>/* 加法雜湊 */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i &lt; key.length; i++) {\n    hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n</code></pre> simple_hash.rs<pre><code>/* 加法雜湊 */\nfn add_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 乘法雜湊 */\nfn mul_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* 互斥或雜湊 */\nfn xor_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash &amp; MODULUS) as i32\n}\n\n/* 旋轉雜湊 */\nfn rot_hash(key: &amp;str) -&gt; i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n</code></pre> simple_hash.c<pre><code>/* 加法雜湊 */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 乘法雜湊 */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* 互斥或雜湊 */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash &amp; MODULUS;\n}\n\n/* 旋轉雜湊 */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i &lt; strlen(key); i++) {\n        hash = ((hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n</code></pre> simple_hash.kt<pre><code>/* 加法雜湊 */\nfun addHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 乘法雜湊 */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* 互斥或雜湊 */\nfun xorHash(key: String): Int {\n    var hash = 0\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* 旋轉雜湊 */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    val MODULUS = 1000000007\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n</code></pre> simple_hash.rb<pre><code>### 加法雜湊 ###\ndef add_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash += c.ord }\n\n  hash % modulus\nend\n\n### 乘法雜湊 ###\ndef mul_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = 31 * hash + c.ord }\n\n  hash % modulus\nend\n\n### 互斥或雜湊 ###\ndef xor_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash ^= c.ord }\n\n  hash % modulus\nend\n\n### 旋轉雜湊 ###\ndef rot_hash(key)\n  hash = 0\n  modulus = 1_000_000_007\n\n  key.each_char { |c| hash = (hash &lt;&lt; 4) ^ (hash &gt;&gt; 28) ^ c.ord }\n\n  hash % modulus\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>觀察發現，每種雜湊演算法的最後一步都是對大質數 \\(1000000007\\) 取模，以確保雜湊值在合適的範圍內。值得思考的是，為什麼要強調對質數取模，或者說對合數取模的弊端是什麼？這是一個有趣的問題。</p> <p>先給出結論：使用大質數作為模數，可以最大化地保證雜湊值的均勻分佈。因為質數不與其他數字存在公約數，可以減少因取模操作而產生的週期性模式，從而避免雜湊衝突。</p> <p>舉個例子，假設我們選擇合數 \\(9\\) 作為模數，它可以被 \\(3\\) 整除，那麼所有可以被 \\(3\\) 整除的 <code>key</code> 都會被對映到 \\(0\\)、\\(3\\)、\\(6\\) 這三個雜湊值。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 9 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\] <p>如果輸入 <code>key</code> 恰好滿足這種等差數列的資料分佈，那麼雜湊值就會出現聚堆積，從而加重雜湊衝突。現在，假設將 <code>modulus</code> 替換為質數 \\(13\\) ，由於 <code>key</code> 和 <code>modulus</code> 之間不存在公約數，因此輸出的雜湊值的均勻性會明顯提升。</p> \\[ \\begin{aligned} \\text{modulus} &amp; = 13 \\newline \\text{key} &amp; = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} &amp; = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\] <p>值得說明的是，如果能夠保證 <code>key</code> 是隨機均勻分佈的，那麼選擇質數或者合數作為模數都可以，它們都能輸出均勻分佈的雜湊值。而當 <code>key</code> 的分佈存在某種週期性時，對合數取模更容易出現聚集現象。</p> <p>總而言之，我們通常選取質數作為模數，並且這個質數最好足夠大，以儘可能消除週期性模式，提升雜湊演算法的穩健性。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#633","level":2,"title":"6.3.3   常見雜湊演算法","text":"<p>不難發現，以上介紹的簡單雜湊演算法都比較“脆弱”，遠遠沒有達到雜湊演算法的設計目標。例如，由於加法和互斥或滿足交換律，因此加法雜湊和互斥或雜湊無法區分內容相同但順序不同的字串，這可能會加劇雜湊衝突，並引起一些安全問題。</p> <p>在實際中，我們通常會用一些標準雜湊演算法，例如 MD5、SHA-1、SHA-2 和 SHA-3 等。它們可以將任意長度的輸入資料對映到恆定長度的雜湊值。</p> <p>近一個世紀以來，雜湊演算法處在不斷升級與最佳化的過程中。一部分研究人員努力提升雜湊演算法的效能，另一部分研究人員和駭客則致力於尋找雜湊演算法的安全性問題。表 6-2 展示了在實際應用中常見的雜湊演算法。</p> <ul> <li>MD5 和 SHA-1 已多次被成功攻擊，因此它們被各類安全應用棄用。</li> <li>SHA-2 系列中的 SHA-256 是最安全的雜湊演算法之一，仍未出現成功的攻擊案例，因此常用在各類安全應用與協議中。</li> <li>SHA-3 相較 SHA-2 的實現開銷更低、計算效率更高，但目前使用覆蓋度不如 SHA-2 系列。</li> </ul> <p> 表 6-2   常見的雜湊演算法 </p> MD5 SHA-1 SHA-2 SHA-3 推出時間 1992 1995 2002 2008 輸出長度 128 bit 160 bit 256/512 bit 224/256/384/512 bit 雜湊衝突 較多 較多 很少 很少 安全等級 低，已被成功攻擊 低，已被成功攻擊 高 高 應用 已被棄用，仍用於資料完整性檢查 已被棄用 加密貨幣交易驗證、數字簽名等 可用於替代 SHA-2","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_algorithm/#634","level":2,"title":"6.3.4   資料結構的雜湊值","text":"<p>我們知道，雜湊表的 <code>key</code> 可以是整數、小數或字串等資料型別。程式語言通常會為這些資料型別提供內建的雜湊演算法，用於計算雜湊表中的桶索引。以 Python 為例，我們可以呼叫 <code>hash()</code> 函式來計算各種資料型別的雜湊值。</p> <ul> <li>整數和布林量的雜湊值就是其本身。</li> <li>浮點數和字串的雜湊值計算較為複雜，有興趣的讀者請自行學習。</li> <li>元組的雜湊值是對其中每一個元素進行雜湊，然後將這些雜湊值組合起來，得到單一的雜湊值。</li> <li>物件的雜湊值基於其記憶體位址生成。透過重寫物件的雜湊方法，可實現基於內容生成雜湊值。</li> </ul> <p>Tip</p> <p>請注意，不同程式語言的內建雜湊值計算函式的定義和方法不同。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby built_in_hash.py<pre><code>num = 3\nhash_num = hash(num)\n# 整數 3 的雜湊值為 3\n\nbol = True\nhash_bol = hash(bol)\n# 布林量 True 的雜湊值為 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# 小數 3.14159 的雜湊值為 326484311674566659\n\nstr = \"Hello 演算法\"\nhash_str = hash(str)\n# 字串“Hello 演算法”的雜湊值為 4617003410720528961\n\ntup = (12836, \"小哈\")\nhash_tup = hash(tup)\n# 元組 (12836, '小哈') 的雜湊值為 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# 節點物件 &lt;ListNode object at 0x1058fd810&gt; 的雜湊值為 274267521\n</code></pre> built_in_hash.cpp<pre><code>int num = 3;\nsize_t hashNum = hash&lt;int&gt;()(num);\n// 整數 3 的雜湊值為 3\n\nbool bol = true;\nsize_t hashBol = hash&lt;bool&gt;()(bol);\n// 布林量 1 的雜湊值為 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash&lt;double&gt;()(dec);\n// 小數 3.14159 的雜湊值為 4614256650576692846\n\nstring str = \"Hello 演算法\";\nsize_t hashStr = hash&lt;string&gt;()(str);\n// 字串“Hello 演算法”的雜湊值為 15466937326284535026\n\n// 在 C++ 中，內建 std:hash() 僅提供基本資料型別的雜湊值計算\n// 陣列、物件的雜湊值計算需要自行實現\n</code></pre> built_in_hash.java<pre><code>int num = 3;\nint hashNum = Integer.hashCode(num);\n// 整數 3 的雜湊值為 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// 布林量 true 的雜湊值為 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// 小數 3.14159 的雜湊值為 -1340954729\n\nString str = \"Hello 演算法\";\nint hashStr = str.hashCode();\n// 字串“Hello 演算法”的雜湊值為 -727081396\n\nObject[] arr = { 12836, \"小哈\" };\nint hashTup = Arrays.hashCode(arr);\n// 陣列 [12836, 小哈] 的雜湊值為 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// 節點物件 utils.ListNode@7dc5e7b4 的雜湊值為 2110121908\n</code></pre> built_in_hash.cs<pre><code>int num = 3;\nint hashNum = num.GetHashCode();\n// 整數 3 的雜湊值為 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// 布林量 true 的雜湊值為 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// 小數 3.14159 的雜湊值為 -1340954729;\n\nstring str = \"Hello 演算法\";\nint hashStr = str.GetHashCode();\n// 字串“Hello 演算法”的雜湊值為 -586107568;\n\nobject[] arr = [12836, \"小哈\"];\nint hashTup = arr.GetHashCode();\n// 陣列 [12836, 小哈] 的雜湊值為 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// 節點物件 0 的雜湊值為 39053774;\n</code></pre> built_in_hash.go<pre><code>// Go 未提供內建 hash code 函式\n</code></pre> built_in_hash.swift<pre><code>let num = 3\nlet hashNum = num.hashValue\n// 整數 3 的雜湊值為 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// 布林量 true 的雜湊值為 -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// 小數 3.14159 的雜湊值為 -2465384235396674631\n\nlet str = \"Hello 演算法\"\nlet hashStr = str.hashValue\n// 字串“Hello 演算法”的雜湊值為 -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"小哈\")]\nlet hashTup = arr.hashValue\n// 陣列 [AnyHashable(12836), AnyHashable(\"小哈\")] 的雜湊值為 -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// 節點物件 utils.ListNode 的雜湊值為 -2434780518035996159\n</code></pre> built_in_hash.js<pre><code>// JavaScript 未提供內建 hash code 函式\n</code></pre> built_in_hash.ts<pre><code>// TypeScript 未提供內建 hash code 函式\n</code></pre> built_in_hash.dart<pre><code>int num = 3;\nint hashNum = num.hashCode;\n// 整數 3 的雜湊值為 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// 布林值 true 的雜湊值為 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// 小數 3.14159 的雜湊值為 2570631074981783\n\nString str = \"Hello 演算法\";\nint hashStr = str.hashCode;\n// 字串“Hello 演算法”的雜湊值為 468167534\n\nList arr = [12836, \"小哈\"];\nint hashArr = arr.hashCode;\n// 陣列 [12836, 小哈] 的雜湊值為 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// 節點物件 Instance of 'ListNode' 的雜湊值為 1033450432\n</code></pre> built_in_hash.rs<pre><code>use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&amp;mut num_hasher);\nlet hash_num = num_hasher.finish();\n// 整數 3 的雜湊值為 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&amp;mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// 布林量 true 的雜湊值為 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&amp;mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// 小數 3.14159 的雜湊值為 2566941990314602357\n\nlet str = \"Hello 演算法\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&amp;mut str_hasher);\nlet hash_str = str_hasher.finish();\n// 字串“Hello 演算法”的雜湊值為 16092673739211250988\n\nlet arr = (&amp;12836, &amp;\"小哈\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&amp;mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// 元組 (12836, \"小哈\") 的雜湊值為 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&amp;mut hasher);\nlet hash = hasher.finish();\n// 節點物件 RefCell { value: ListNode { val: 42, next: None } } 的雜湊值為15387811073369036852\n</code></pre> built_in_hash.c<pre><code>// C 未提供內建 hash code 函式\n</code></pre> built_in_hash.kt<pre><code>val num = 3\nval hashNum = num.hashCode()\n// 整數 3 的雜湊值為 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// 布林量 true 的雜湊值為 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// 小數 3.14159 的雜湊值為 -1340954729\n\nval str = \"Hello 演算法\"\nval hashStr = str.hashCode()\n// 字串“Hello 演算法”的雜湊值為 -727081396\n\nval arr = arrayOf&lt;Any&gt;(12836, \"小哈\")\nval hashTup = arr.hashCode()\n// 陣列 [12836, 小哈] 的雜湊值為 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// 節點物件 utils.ListNode@1d81eb93 的雜湊值為 495053715\n</code></pre> built_in_hash.rb<pre><code>num = 3\nhash_num = num.hash\n# 整數 3 的雜湊值為 -4385856518450339636\n\nbol = true\nhash_bol = bol.hash\n# 布林量 true 的雜湊值為 -1617938112149317027\n\ndec = 3.14159\nhash_dec = dec.hash\n# 小數 3.14159 的雜湊值為 -1479186995943067893\n\nstr = \"Hello 演算法\"\nhash_str = str.hash\n# 字串“Hello 演算法”的雜湊值為 -4075943250025831763\n\ntup = [12836, '小哈']\nhash_tup = tup.hash\n# 元組 (12836, '小哈') 的雜湊值為 1999544809202288822\n\nobj = ListNode.new(0)\nhash_obj = obj.hash\n# 節點物件 #&lt;ListNode:0x000078133140ab70&gt; 的雜湊值為 4302940560806366381\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>在許多程式語言中，只有不可變物件才可作為雜湊表的 <code>key</code> 。假如我們將串列（動態陣列）作為 <code>key</code> ，當串列的內容發生變化時，它的雜湊值也隨之改變，我們就無法在雜湊表中查詢到原先的 <code>value</code> 了。</p> <p>雖然自定義物件（比如鏈結串列節點）的成員變數是可變的，但它是可雜湊的。這是因為物件的雜湊值通常是基於記憶體位址生成的，即使物件的內容發生了變化，但它的記憶體位址不變，雜湊值仍然是不變的。</p> <p>細心的你可能發現在不同控制檯中執行程式時，輸出的雜湊值是不同的。這是因為 Python 直譯器在每次啟動時，都會為字串雜湊函式加入一個隨機的鹽（salt）值。這種做法可以有效防止 HashDoS 攻擊，提升雜湊演算法的安全性。</p>","path":["第 6 章 &nbsp; 雜湊表","6.3 &nbsp; 雜湊演算法"],"tags":[]},{"location":"chapter_hashing/hash_collision/","level":1,"title":"6.2   雜湊衝突","text":"<p>上一節提到，通常情況下雜湊函式的輸入空間遠大於輸出空間，因此理論上雜湊衝突是不可避免的。比如，輸入空間為全體整數，輸出空間為陣列容量大小，則必然有多個整數對映至同一桶索引。</p> <p>雜湊衝突會導致查詢結果錯誤，嚴重影響雜湊表的可用性。為了解決該問題，每當遇到雜湊衝突時，我們就進行雜湊表擴容，直至衝突消失為止。此方法簡單粗暴且有效，但效率太低，因為雜湊表擴容需要進行大量的資料搬運與雜湊值計算。為了提升效率，我們可以採用以下策略。</p> <ol> <li>改良雜湊表資料結構，使得雜湊表可以在出現雜湊衝突時正常工作。</li> <li>僅在必要時，即當雜湊衝突比較嚴重時，才執行擴容操作。</li> </ol> <p>雜湊表的結構改良方法主要包括“鏈式位址”和“開放定址”。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#621","level":2,"title":"6.2.1   鏈式位址","text":"<p>在原始雜湊表中，每個桶僅能儲存一個鍵值對。鏈式位址（separate chaining）將單個元素轉換為鏈結串列，將鍵值對作為鏈結串列節點，將所有發生衝突的鍵值對都儲存在同一鏈結串列中。圖 6-5 展示了一個鏈式位址雜湊表的例子。</p> <p></p> <p> 圖 6-5   鏈式位址雜湊表 </p> <p>基於鏈式位址實現的雜湊表的操作方法發生了以下變化。</p> <ul> <li>查詢元素：輸入 <code>key</code> ，經過雜湊函式得到桶索引，即可訪問鏈結串列頭節點，然後走訪鏈結串列並對比 <code>key</code> 以查詢目標鍵值對。</li> <li>新增元素：首先透過雜湊函式訪問鏈結串列頭節點，然後將節點（鍵值對）新增到鏈結串列中。</li> <li>刪除元素：根據雜湊函式的結果訪問鏈結串列頭部，接著走訪鏈結串列以查詢目標節點並將其刪除。</li> </ul> <p>鏈式位址存在以下侷限性。</p> <ul> <li>佔用空間增大：鏈結串列包含節點指標，它相比陣列更加耗費記憶體空間。</li> <li>查詢效率降低：因為需要線性走訪鏈結串列來查詢對應元素。</li> </ul> <p>以下程式碼給出了鏈式位址雜湊表的簡單實現，需要注意兩點。</p> <ul> <li>使用串列（動態陣列）代替鏈結串列，從而簡化程式碼。在這種設定下，雜湊表（陣列）包含多個桶，每個桶都是一個串列。</li> <li>以下實現包含雜湊表擴容方法。當負載因子超過 \\(\\frac{2}{3}\\) 時，我們將雜湊表擴容至原先的 \\(2\\) 倍。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_chaining.py<pre><code>class HashMapChaining:\n    \"\"\"鏈式位址雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self.size = 0  # 鍵值對數量\n        self.capacity = 4  # 雜湊表容量\n        self.load_thres = 2.0 / 3.0  # 觸發擴容的負載因子閾值\n        self.extend_ratio = 2  # 擴容倍數\n        self.buckets = [[] for _ in range(self.capacity)]  # 桶陣列\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負載因子\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"查詢操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，若找到 key ，則返回對應 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # 若未找到 key ，則返回 None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"新增操作\"\"\"\n        # 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # 若無該 key ，則將鍵值對新增至尾部\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # 走訪桶，從中刪除鍵值對\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"擴容雜湊表\"\"\"\n        # 暫存原雜湊表\n        buckets = self.buckets\n        # 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -&gt; \" + pair.val)\n            print(res)\n</code></pre> hash_map_chaining.cpp<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n  private:\n    int size;                       // 鍵值對數量\n    int capacity;                   // 雜湊表容量\n    double loadThres;               // 觸發擴容的負載因子閾值\n    int extendRatio;                // 擴容倍數\n    vector&lt;vector&lt;Pair *&gt;&gt; buckets; // 桶陣列\n\n  public:\n    /* 建構子 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* 析構方法 */\n    ~HashMapChaining() {\n        for (auto &amp;bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // 釋放記憶體\n                delete pair;\n            }\n        }\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                return pair-&gt;val;\n            }\n        }\n        // 若未找到 key ，則返回空字串\n        return \"\";\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (Pair *pair : buckets[index]) {\n            if (pair-&gt;key == key) {\n                pair-&gt;val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &amp;bucket = buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (int i = 0; i &lt; bucket.size(); i++) {\n            if (bucket[i]-&gt;key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // 從中刪除鍵值對\n                delete tmp;                       // 釋放記憶體\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        vector&lt;vector&lt;Pair *&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (auto &amp;bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair-&gt;key, pair-&gt;val);\n                // 釋放記憶體\n                delete pair;\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (auto &amp;bucket : buckets) {\n            cout &lt;&lt; \"[\";\n            for (Pair *pair : bucket) {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; \", \";\n            }\n            cout &lt;&lt; \"]\\n\";\n        }\n    }\n};\n</code></pre> hash_map_chaining.java<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    int size; // 鍵值對數量\n    int capacity; // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio; // 擴容倍數\n    List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n    /* 建構子 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 查詢操作 */\n    String get(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    void put(int key, String val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List&lt;Pair&gt; bucket = buckets.get(index);\n        // 走訪桶，從中刪除鍵值對\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new ArrayList&lt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.add(new ArrayList&lt;&gt;());\n        }\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (List&lt;Pair&gt; bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (List&lt;Pair&gt; bucket : buckets) {\n            List&lt;String&gt; res = new ArrayList&lt;&gt;();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -&gt; \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.cs<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    int size; // 鍵值對數量\n    int capacity; // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio; // 擴容倍數\n    List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n    /* 建構子 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // 走訪桶，若找到 key ，則返回對應 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // 走訪桶，從中刪除鍵值對\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void Extend() {\n        // 暫存原雜湊表\n        List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new List&lt;List&lt;Pair&gt;&gt;(capacity);\n        for (int i = 0; i &lt; capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        foreach (List&lt;Pair&gt; bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (List&lt;Pair&gt; bucket in buckets) {\n            List&lt;string&gt; res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -&gt; \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n</code></pre> hash_map_chaining.go<pre><code>/* 鏈式位址雜湊表 */\ntype hashMapChaining struct {\n    size        int      // 鍵值對數量\n    capacity    int      // 雜湊表容量\n    loadThres   float64  // 觸發擴容的負載因子閾值\n    extendRatio int      // 擴容倍數\n    buckets     [][]pair // 桶陣列\n}\n\n/* 建構子 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i &lt; 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &amp;hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* 雜湊函式 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* 負載因子 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* 查詢操作 */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // 走訪桶，若找到 key ，則返回對應 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // 若未找到 key ，則返回空字串\n    return \"\"\n}\n\n/* 新增操作 */\nfunc (m *hashMapChaining) put(key int, val string) {\n    // 當負載因子超過閾值時，執行擴容\n    if m.loadFactor() &gt; m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // 若無該 key ，則將鍵值對新增至尾部\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* 刪除操作 */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // 走訪桶，從中刪除鍵值對\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // 切片刪除\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* 擴容雜湊表 */\nfunc (m *hashMapChaining) extend() {\n    // 暫存原雜湊表\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i &lt; len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // 初始化擴容後的新雜湊表\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i &lt; m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* 列印雜湊表 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -&gt; \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n</code></pre> hash_map_chaining.swift<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    var loadThres: Double // 觸發擴容的負載因子閾值\n    var extendRatio: Int // 擴容倍數\n    var buckets: [[Pair]] // 桶陣列\n\n    /* 建構子 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* 雜湊函式 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負載因子 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，若找到 key ，則返回對應 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // 若未找到 key ，則返回 nil\n        return nil\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // 走訪桶，從中刪除鍵值對\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    func extend() {\n        // 暫存原雜湊表\n        let bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -&gt; \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.js<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    #size; // 鍵值對數量\n    #capacity; // 雜湊表容量\n    #loadThres; // 觸發擴容的負載因子閾值\n    #extendRatio; // 擴容倍數\n    #buckets; // 桶陣列\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key, val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend() {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.ts<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    #size: number; // 鍵值對數量\n    #capacity: number; // 雜湊表容量\n    #loadThres: number; // 觸發擴容的負載因子閾值\n    #extendRatio: number; // 擴容倍數\n    #buckets: Pair[][]; // 桶陣列\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* 查詢操作 */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // 若未找到 key ，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key: number, val: string): void {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // 走訪桶，從中刪除鍵值對\n        for (let i = 0; i &lt; bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend(): void {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) =&gt; []);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -&gt; ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n</code></pre> hash_map_chaining.dart<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n  late int size; // 鍵值對數量\n  late int capacity; // 雜湊表容量\n  late double loadThres; // 觸發擴容的負載因子閾值\n  late int extendRatio; // 擴容倍數\n  late List&lt;List&lt;Pair&gt;&gt; buckets; // 桶陣列\n\n  /* 建構子 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) =&gt; []);\n  }\n\n  /* 雜湊函式 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* 負載因子 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，若找到 key ，則返回對應 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // 若未找到 key ，則返回 null\n    return null;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor() &gt; loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // 若無該 key ，則將鍵值對新增至尾部\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List&lt;Pair&gt; bucket = buckets[index];\n    // 走訪桶，從中刪除鍵值對\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* 擴容雜湊表 */\n  void extend() {\n    // 暫存原雜湊表\n    List&lt;List&lt;Pair&gt;&gt; bucketsTmp = buckets;\n    // 初始化擴容後的新雜湊表\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) =&gt; []);\n    size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (List&lt;Pair&gt; bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (List&lt;Pair&gt; bucket in buckets) {\n      List&lt;String&gt; res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -&gt; ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n</code></pre> hash_map_chaining.rs<pre><code>/* 鏈式位址雜湊表 */\nstruct HashMapChaining {\n    size: usize,\n    capacity: usize,\n    load_thres: f32,\n    extend_ratio: usize,\n    buckets: Vec&lt;Vec&lt;Pair&gt;&gt;,\n}\n\nimpl HashMapChaining {\n    /* 建構子 */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % self.capacity\n    }\n\n    /* 負載因子 */\n    fn load_factor(&amp;self) -&gt; f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* 刪除操作 */\n    fn remove(&amp;mut self, key: i32) -&gt; Option&lt;String&gt; {\n        let index = self.hash_func(key);\n\n        // 走訪桶，從中刪除鍵值對\n        for (i, p) in self.buckets[index].iter_mut().enumerate() {\n            if p.key == key {\n                let pair = self.buckets[index].remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // 若未找到 key ，則返回 None\n        None\n    }\n\n    /* 擴容雜湊表 */\n    fn extend(&amp;mut self) {\n        // 暫存原雜湊表\n        let buckets_tmp = std::mem::take(&amp;mut self.buckets);\n\n        // 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fn print(&amp;self) {\n        for bucket in &amp;self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -&gt; {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* 新增操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for pair in self.buckets[index].iter_mut() {\n            if pair.key == key {\n                pair.val = val;\n                return;\n            }\n        }\n\n        // 若無該 key ，則將鍵值對新增至尾部\n        let pair = Pair { key, val };\n        self.buckets[index].push(pair);\n        self.size += 1;\n    }\n\n    /* 查詢操作 */\n    fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        let index = self.hash_func(key);\n\n        // 走訪桶，若找到 key ，則返回對應 val\n        for pair in self.buckets[index].iter() {\n            if pair.key == key {\n                return Some(&amp;pair.val);\n            }\n        }\n\n        // 若未找到 key ，則返回 None\n        None\n    }\n}\n</code></pre> hash_map_chaining.c<pre><code>/* 鏈結串列節點 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* 鏈式位址雜湊表 */\ntypedef struct {\n    int size;         // 鍵值對數量\n    int capacity;     // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio;  // 擴容倍數\n    Node **buckets;   // 桶陣列\n} HashMapChaining;\n\n/* 建構子 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* 析構函式 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur-&gt;next;\n            free(tmp-&gt;pair);\n            free(tmp);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap);\n}\n\n/* 雜湊函式 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負載因子 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 查詢操作 */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // 走訪桶，若找到 key ，則返回對應 val\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            return cur-&gt;pair-&gt;val;\n        }\n        cur = cur-&gt;next;\n    }\n    return \"\"; // 若未找到 key ，則返回空字串\n}\n\n/* 新增操作 */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    Node *cur = hashMap-&gt;buckets[index];\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            strcpy(cur-&gt;pair-&gt;val, val); // 若遇到指定 key ，則更新對應 val 並返回\n            return;\n        }\n        cur = cur-&gt;next;\n    }\n    // 若無該 key ，則將鍵值對新增至鏈結串列頭部\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair-&gt;key = key;\n    strcpy(newPair-&gt;val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode-&gt;pair = newPair;\n    newNode-&gt;next = hashMap-&gt;buckets[index];\n    hashMap-&gt;buckets[index] = newNode;\n    hashMap-&gt;size++;\n}\n\n/* 擴容雜湊表 */\nvoid extend(HashMapChaining *hashMap) {\n    // 暫存原雜湊表\n    int oldCapacity = hashMap-&gt;capacity;\n    Node **oldBuckets = hashMap-&gt;buckets;\n    // 初始化擴容後的新雜湊表\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Node **)malloc(hashMap-&gt;capacity * sizeof(Node *));\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        hashMap-&gt;buckets[i] = NULL;\n    }\n    hashMap-&gt;size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            Node *temp = cur;\n            cur = cur-&gt;next;\n            // 釋放記憶體\n            free(temp-&gt;pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* 刪除操作 */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap-&gt;buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur-&gt;pair-&gt;key == key) {\n            // 從中刪除鍵值對\n            if (pre) {\n                pre-&gt;next = cur-&gt;next;\n            } else {\n                hashMap-&gt;buckets[index] = cur-&gt;next;\n            }\n            // 釋放記憶體\n            free(cur-&gt;pair);\n            free(cur);\n            hashMap-&gt;size--;\n            return;\n        }\n        pre = cur;\n        cur = cur-&gt;next;\n    }\n}\n\n/* 列印雜湊表 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Node *cur = hashMap-&gt;buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -&gt; %s, \", cur-&gt;pair-&gt;key, cur-&gt;pair-&gt;val);\n            cur = cur-&gt;next;\n        }\n        printf(\"]\\n\");\n    }\n}\n</code></pre> hash_map_chaining.kt<pre><code>/* 鏈式位址雜湊表 */\nclass HashMapChaining {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    val loadThres: Double // 觸發擴容的負載因子閾值\n    val extendRatio: Int // 擴容倍數\n    var buckets: MutableList&lt;MutableList&lt;Pair&gt;&gt; // 桶陣列\n\n    /* 建構子 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負載因子 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，若找到 key ，則返回對應 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair._val\n        }\n        // 若未找到 key ，則返回 null\n        return null\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair._val = _val\n                return\n            }\n        }\n        // 若無該 key ，則將鍵值對新增至尾部\n        val pair = Pair(key, _val)\n        bucket.add(pair)\n        size++\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // 走訪桶，從中刪除鍵值對\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fun extend() {\n        // 暫存原雜湊表\n        val bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        // mutablelist 無固定大小\n        buckets = mutableListOf()\n        for (i in 0..&lt;capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf&lt;String&gt;()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair._val\n                res.add(\"$k -&gt; $v\")\n            }\n            println(res)\n        }\n    }\n}\n</code></pre> hash_map_chaining.rb<pre><code>### 鍵式位址雜湊表 ###\nclass HashMapChaining\n  ### 建構子 ###\n  def initialize\n    @size = 0 # 鍵值對數量\n    @capacity = 4 # 雜湊表容量\n    @load_thres = 2.0 / 3.0 # 觸發擴容的負載因子閾值\n    @extend_ratio = 2 # 擴容倍數\n    @buckets = Array.new(@capacity) { [] } # 桶陣列\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負載因子 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，若找到 key ，則返回對應 val\n    for pair in bucket\n      return pair.val if pair.key == key\n    end\n    # 若未找到 key , 則返回 nil\n    nil\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    # 當負載因子超過閾值時，執行擴容\n    extend if load_factor &gt; @load_thres\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，若遇到指定 key ，則更新對應 val 並返回\n    for pair in bucket\n      if pair.key == key\n        pair.val = val\n        return\n      end\n    end\n    # 若無該 key ，則將鍵值對新增至尾部\n    pair = Pair.new(key, val)\n    bucket &lt;&lt; pair\n    @size += 1\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    bucket = @buckets[index]\n    # 走訪桶，從中刪除鍵值對\n    for pair in bucket\n      if pair.key == key\n        bucket.delete(pair)\n        @size -= 1\n        break\n      end\n    end\n  end\n\n  ### 擴容雜湊表 ###\n  def extend\n    # 暫存原雜湊表\n    buckets = @buckets\n    # 初始化擴容後的新雜湊表\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity) { [] }\n    @size = 0\n    # 將鍵值對從原雜湊表搬運至新雜湊表\n    for bucket in buckets\n      for pair in bucket\n        put(pair.key, pair.val)\n      end\n    end\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    for bucket in @buckets\n      res = []\n      for pair in bucket\n        res &lt;&lt; \"#{pair.key} -&gt; #{pair.val}\"\n      end\n      pp res\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>值得注意的是，當鏈結串列很長時，查詢效率 \\(O(n)\\) 很差。此時可以將鏈結串列轉換為“AVL 樹”或“紅黑樹”，從而將查詢操作的時間複雜度最佳化至 \\(O(\\log n)\\) 。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#622","level":2,"title":"6.2.2   開放定址","text":"<p>開放定址（open addressing）不引入額外的資料結構，而是透過“多次探測”來處理雜湊衝突，探測方式主要包括線性探查、平方探測和多次雜湊等。</p> <p>下面以線性探查為例，介紹開放定址雜湊表的工作機制。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#1","level":3,"title":"1.   線性探查","text":"<p>線性探查採用固定步長的線性搜尋來進行探測，其操作方法與普通雜湊表有所不同。</p> <ul> <li>插入元素：透過雜湊函式計算桶索引，若發現桶內已有元素，則從衝突位置向後線性走訪（步長通常為 \\(1\\) ），直至找到空桶，將元素插入其中。</li> <li>查詢元素：若發現雜湊衝突，則使用相同步長向後進行線性走訪，直到找到對應元素，返回 <code>value</code> 即可；如果遇到空桶，說明目標元素不在雜湊表中，返回 <code>None</code> 。</li> </ul> <p>圖 6-6 展示了開放定址（線性探查）雜湊表的鍵值對分佈。根據此雜湊函式，最後兩位相同的 <code>key</code> 都會被對映到相同的桶。而透過線性探查，它們被依次儲存在該桶以及之下的桶中。</p> <p></p> <p> 圖 6-6   開放定址（線性探查）雜湊表的鍵值對分佈 </p> <p>然而，線性探查容易產生“聚集現象”。具體來說，陣列中連續被佔用的位置越長，這些連續位置發生雜湊衝突的可能性越大，從而進一步促使該位置的聚堆積生長，形成惡性迴圈，最終導致增刪查改操作效率劣化。</p> <p>值得注意的是，我們不能在開放定址雜湊表中直接刪除元素。這是因為刪除元素會在陣列內產生一個空桶 <code>None</code> ，而當查詢元素時，線性探查到該空桶就會返回，因此在該空桶之下的元素都無法再被訪問到，程式可能誤判這些元素不存在，如圖 6-7 所示。</p> <p></p> <p> 圖 6-7   在開放定址中刪除元素導致的查詢問題 </p> <p>為了解決該問題，我們可以採用懶刪除（lazy deletion）機制：它不直接從雜湊表中移除元素，而是利用一個常數 <code>TOMBSTONE</code> 來標記這個桶。在該機制下，<code>None</code> 和 <code>TOMBSTONE</code> 都代表空桶，都可以放置鍵值對。但不同的是，線性探查到 <code>TOMBSTONE</code> 時應該繼續走訪，因為其之下可能還存在鍵值對。</p> <p>然而，懶刪除可能會加速雜湊表的效能退化。這是因為每次刪除操作都會產生一個刪除標記，隨著 <code>TOMBSTONE</code> 的增加，搜尋時間也會增加，因為線性探查可能需要跳過多個 <code>TOMBSTONE</code> 才能找到目標元素。</p> <p>為此，考慮在線性探查中記錄遇到的首個 <code>TOMBSTONE</code> 的索引，並將搜尋到的目標元素與該 <code>TOMBSTONE</code> 交換位置。這樣做的好處是當每次查詢或新增元素時，元素會被移動至距離理想位置（探測起始點）更近的桶，從而最佳化查詢效率。</p> <p>以下程式碼實現了一個包含懶刪除的開放定址（線性探查）雜湊表。為了更加充分地使用雜湊表的空間，我們將雜湊表看作一個“環形陣列”，當越過陣列尾部時，回到頭部繼續走訪。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map_open_addressing.py<pre><code>class HashMapOpenAddressing:\n    \"\"\"開放定址雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self.size = 0  # 鍵值對數量\n        self.capacity = 4  # 雜湊表容量\n        self.load_thres = 2.0 / 3.0  # 觸發擴容的負載因子閾值\n        self.extend_ratio = 2  # 擴容倍數\n        self.buckets: list[Pair | None] = [None] * self.capacity  # 桶陣列\n        self.TOMBSTONE = Pair(-1, \"-1\")  # 刪除標記\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -&gt; float:\n        \"\"\"負載因子\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -&gt; int:\n        \"\"\"搜尋 key 對應的桶索引\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # 線性探查，當遇到空桶時跳出\n        while self.buckets[index] is not None:\n            # 若遇到 key ，返回對應的桶索引\n            if self.buckets[index].key == key:\n                # 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # 返回移動後的桶索引\n                return index  # 返回桶索引\n            # 記錄遇到的首個刪除標記\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % self.capacity\n        # 若 key 不存在，則返回新增點的索引\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -&gt; str:\n        \"\"\"查詢操作\"\"\"\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則返回對應 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # 若鍵值對不存在，則返回 None\n        return None\n\n    def put(self, key: int, val: str):\n        \"\"\"新增操作\"\"\"\n        # 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres:\n            self.extend()\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則覆蓋 val 並返回\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # 若鍵值對不存在，則新增該鍵值對\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        # 搜尋 key 對應的桶索引\n        index = self.find_bucket(key)\n        # 若找到鍵值對，則用刪除標記覆蓋它\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"擴容雜湊表\"\"\"\n        # 暫存原雜湊表\n        buckets_tmp = self.buckets\n        # 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> hash_map_open_addressing.cpp<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // 鍵值對數量\n    int capacity = 4;                     // 雜湊表容量\n    const double loadThres = 2.0 / 3.0;     // 觸發擴容的負載因子閾值\n    const int extendRatio = 2;            // 擴容倍數\n    vector&lt;Pair *&gt; buckets;               // 桶陣列\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // 刪除標記\n\n  public:\n    /* 建構子 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* 析構方法 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != nullptr) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index]-&gt;key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]-&gt;val;\n        }\n        // 若鍵值對不存在，則返回空字串\n        return \"\";\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]-&gt;val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != nullptr &amp;&amp; buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void extend() {\n        // 暫存原雜湊表\n        vector&lt;Pair *&gt; bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = vector&lt;Pair *&gt;(capacity, nullptr);\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr &amp;&amp; pair != TOMBSTONE) {\n                put(pair-&gt;key, pair-&gt;val);\n                delete pair;\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout &lt;&lt; \"nullptr\" &lt;&lt; endl;\n            } else if (pair == TOMBSTONE) {\n                cout &lt;&lt; \"TOMBSTONE\" &lt;&lt; endl;\n            } else {\n                cout &lt;&lt; pair-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; pair-&gt;val &lt;&lt; endl;\n            }\n        }\n    }\n};\n</code></pre> hash_map_open_addressing.java<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private int size; // 鍵值對數量\n    private int capacity = 4; // 雜湊表容量\n    private final double loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n    private final int extendRatio = 2; // 擴容倍數\n    private Pair[] buckets; // 桶陣列\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // 刪除標記\n\n    /* 建構子 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* 雜湊函式 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index].key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    public String get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void put(int key, String val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    private void extend() {\n        // 暫存原雜湊表\n        Pair[] bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (Pair pair : bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.cs<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    int size; // 鍵值對數量\n    int capacity = 4; // 雜湊表容量\n    double loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n    int extendRatio = 2; // 擴容倍數\n    Pair[] buckets; // 桶陣列\n    Pair TOMBSTONE = new(-1, \"-1\"); // 刪除標記\n\n    /* 建構子 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* 負載因子 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index].key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (LoadFactor() &gt; loadThres) {\n            Extend();\n        }\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        // 搜尋 key 對應的桶索引\n        int index = FindBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    void Extend() {\n        // 暫存原雜湊表\n        Pair[] bucketsTmp = buckets;\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -&gt; \" + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.go<pre><code>/* 開放定址雜湊表 */\ntype hashMapOpenAddressing struct {\n    size        int     // 鍵值對數量\n    capacity    int     // 雜湊表容量\n    loadThres   float64 // 觸發擴容的負載因子閾值\n    extendRatio int     // 擴容倍數\n    buckets     []*pair // 桶陣列\n    TOMBSTONE   *pair   // 刪除標記\n}\n\n/* 建構子 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &amp;hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &amp;pair{-1, \"-1\"},\n    }\n}\n\n/* 雜湊函式 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // 根據鍵計算雜湊值\n}\n\n/* 負載因子 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // 計算當前負載因子\n}\n\n/* 搜尋 key 對應的桶索引 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // 獲取初始索引\n    firstTombstone := -1     // 記錄遇到的第一個TOMBSTONE的位置\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // 返回移動後的桶索引\n            }\n            return index // 返回找到的索引\n        }\n        if firstTombstone == -1 &amp;&amp; h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // 記錄遇到的首個刪除標記的位置\n        }\n        index = (index + 1) % h.capacity // 線性探查，越過尾部則返回頭部\n    }\n    // 若 key 不存在，則返回新增點的索引\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* 查詢操作 */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // 若找到鍵值對，則返回對應 val\n    }\n    return \"\" // 若鍵值對不存在，則返回 \"\"\n}\n\n/* 新增操作 */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() &gt; h.loadThres {\n        h.extend() // 當負載因子超過閾值時，執行擴容\n    }\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &amp;pair{key, val} // 若鍵值對不存在，則新增該鍵值對\n        h.size++\n    } else {\n        h.buckets[index].val = val // 若找到鍵值對，則覆蓋 val\n    }\n}\n\n/* 刪除操作 */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // 搜尋 key 對應的桶索引\n    if h.buckets[index] != nil &amp;&amp; h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // 若找到鍵值對，則用刪除標記覆蓋它\n        h.size--\n    }\n}\n\n/* 擴容雜湊表 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // 暫存原雜湊表\n    h.capacity *= h.extendRatio           // 更新容量\n    h.buckets = make([]*pair, h.capacity) // 初始化擴容後的新雜湊表\n    h.size = 0                            // 重置大小\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for _, pair := range oldBuckets {\n        if pair != nil &amp;&amp; pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* 列印雜湊表 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -&gt; %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.swift<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    var size: Int // 鍵值對數量\n    var capacity: Int // 雜湊表容量\n    var loadThres: Double // 觸發擴容的負載因子閾值\n    var extendRatio: Int // 擴容倍數\n    var buckets: [Pair?] // 桶陣列\n    var TOMBSTONE: Pair // 刪除標記\n\n    /* 建構子 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* 雜湊函式 */\n    func hashFunc(key: Int) -&gt; Int {\n        key % capacity\n    }\n\n    /* 負載因子 */\n    func loadFactor() -&gt; Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    func findBucket(key: Int) -&gt; Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // 線性探查，當遇到空桶時跳出\n        while buckets[index] != nil {\n            // 若遇到 key ，返回對應的桶索引\n            if buckets[index]!.key == key {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 返回移動後的桶索引\n                }\n                return index // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則返回對應 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // 若鍵值對不存在，則返回 null\n        return nil\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if loadFactor() &gt; loadThres {\n            extend()\n        }\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        // 搜尋 key 對應的桶索引\n        let index = findBucket(key: key)\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* 擴容雜湊表 */\n    func extend() {\n        // 暫存原雜湊表\n        let bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -&gt; \\(pair!.val)\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.js<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    #size; // 鍵值對數量\n    #capacity; // 雜湊表容量\n    #loadThres; // 觸發擴容的負載因子閾值\n    #extendRatio; // 擴容倍數\n    #buckets; // 桶陣列\n    #TOMBSTONE; // 刪除標記\n\n    /* 建構子 */\n    constructor() {\n        this.#size = 0; // 鍵值對數量\n        this.#capacity = 4; // 雜湊表容量\n        this.#loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n        this.#extendRatio = 2; // 擴容倍數\n        this.#buckets = Array(this.#capacity).fill(null); // 桶陣列\n        this.#TOMBSTONE = new Pair(-1, '-1'); // 刪除標記\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* 負載因子 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (this.#buckets[index] !== null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (this.#buckets[index].key === key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % this.#capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key, val) {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.#loadFactor() &gt; this.#loadThres) {\n            this.#extend();\n        }\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* 刪除操作 */\n    remove(key) {\n        // 搜尋 key 對應的桶索引\n        const index = this.#findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (\n            this.#buckets[index] !== null &amp;&amp;\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    #extend() {\n        // 暫存原雜湊表\n        const bucketsTmp = this.#buckets;\n        // 初始化擴容後的新雜湊表\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.ts<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private size: number; // 鍵值對數量\n    private capacity: number; // 雜湊表容量\n    private loadThres: number; // 觸發擴容的負載因子閾值\n    private extendRatio: number; // 擴容倍數\n    private buckets: Array&lt;Pair | null&gt;; // 桶陣列\n    private TOMBSTONE: Pair; // 刪除標記\n\n    /* 建構子 */\n    constructor() {\n        this.size = 0; // 鍵值對數量\n        this.capacity = 4; // 雜湊表容量\n        this.loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n        this.extendRatio = 2; // 擴容倍數\n        this.buckets = Array(this.capacity).fill(null); // 桶陣列\n        this.TOMBSTONE = new Pair(-1, '-1'); // 刪除標記\n    }\n\n    /* 雜湊函式 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* 負載因子 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while (this.buckets[index] !== null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (this.buckets[index]!.key === key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (\n                firstTombstone === -1 &amp;&amp;\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % this.capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* 查詢操作 */\n    get(key: number): string | null {\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // 若鍵值對不存在，則返回 null\n        return null;\n    }\n\n    /* 新增操作 */\n    put(key: number, val: string): void {\n        // 當負載因子超過閾值時，執行擴容\n        if (this.loadFactor() &gt; this.loadThres) {\n            this.extend();\n        }\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* 刪除操作 */\n    remove(key: number): void {\n        // 搜尋 key 對應的桶索引\n        const index = this.findBucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (\n            this.buckets[index] !== null &amp;&amp;\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    private extend(): void {\n        // 暫存原雜湊表\n        const bucketsTmp = this.buckets;\n        // 初始化擴容後的新雜湊表\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (const pair of bucketsTmp) {\n            if (pair !== null &amp;&amp; pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -&gt; ' + pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.dart<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n  late int _size; // 鍵值對數量\n  int _capacity = 4; // 雜湊表容量\n  double _loadThres = 2.0 / 3.0; // 觸發擴容的負載因子閾值\n  int _extendRatio = 2; // 擴容倍數\n  late List&lt;Pair?&gt; _buckets; // 桶陣列\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // 刪除標記\n\n  /* 建構子 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n  }\n\n  /* 雜湊函式 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* 負載因子 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* 搜尋 key 對應的桶索引 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // 線性探查，當遇到空桶時跳出\n    while (_buckets[index] != null) {\n      // 若遇到 key ，返回對應的桶索引\n      if (_buckets[index]!.key == key) {\n        // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // 返回移動後的桶索引\n        }\n        return index; // 返回桶索引\n      }\n      // 記錄遇到的首個刪除標記\n      if (firstTombstone == -1 &amp;&amp; _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // 計算桶索引，越過尾部則返回頭部\n      index = (index + 1) % _capacity;\n    }\n    // 若 key 不存在，則返回新增點的索引\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則返回對應 val\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // 若鍵值對不存在，則返回 null\n    return null;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor() &gt; _loadThres) {\n      extend();\n    }\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則覆蓋 val 並返回\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // 若鍵值對不存在，則新增該鍵值對\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(key);\n    // 若找到鍵值對，則用刪除標記覆蓋它\n    if (_buckets[index] != null &amp;&amp; _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* 擴容雜湊表 */\n  void extend() {\n    // 暫存原雜湊表\n    List&lt;Pair?&gt; bucketsTmp = _buckets;\n    // 初始化擴容後的新雜湊表\n    _capacity *= _extendRatio;\n    _buckets = List.generate(_capacity, (index) =&gt; null);\n    _size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null &amp;&amp; pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -&gt; ${pair.val}\");\n      }\n    }\n  }\n}\n</code></pre> hash_map_open_addressing.rs<pre><code>/* 開放定址雜湊表 */\nstruct HashMapOpenAddressing {\n    size: usize,                // 鍵值對數量\n    capacity: usize,            // 雜湊表容量\n    load_thres: f64,            // 觸發擴容的負載因子閾值\n    extend_ratio: usize,        // 擴容倍數\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;, // 桶陣列\n    TOMBSTONE: Option&lt;Pair&gt;,    // 刪除標記\n}\n\nimpl HashMapOpenAddressing {\n    /* 建構子 */\n    fn new() -&gt; Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* 負載因子 */\n    fn load_factor(&amp;self) -&gt; f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    fn find_bucket(&amp;mut self, key: i32) -&gt; usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // 線性探查，當遇到空桶時跳出\n        while self.buckets[index].is_some() {\n            // 若遇到 key，返回對應的桶索引\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // 若之前遇到了刪除標記，則將建值對移動至該索引\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // 返回移動後的桶索引\n                }\n                return index; // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if first_tombstone == -1 &amp;&amp; self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % self.capacity;\n        }\n        // 若 key 不存在，則返回新增點的索引\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* 查詢操作 */\n    fn get(&amp;mut self, key: i32) -&gt; Option&lt;&amp;str&gt; {\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則返回對應 val\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &amp;pair.val as &amp;str);\n        }\n        // 若鍵值對不存在，則返回 null\n        None\n    }\n\n    /* 新增操作 */\n    fn put(&amp;mut self, key: i32, val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if self.load_factor() &gt; self.load_thres {\n            self.extend();\n        }\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* 刪除操作 */\n    fn remove(&amp;mut self, key: i32) {\n        // 搜尋 key 對應的桶索引\n        let index = self.find_bucket(key);\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if self.buckets[index].is_some() &amp;&amp; self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fn extend(&amp;mut self) {\n        // 暫存原雜湊表\n        let buckets_tmp = self.buckets.clone();\n        // 初始化擴容後的新雜湊表\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* 列印雜湊表 */\n    fn print(&amp;self) {\n        for pair in &amp;self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &amp;self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -&gt; {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.c<pre><code>/* 開放定址雜湊表 */\ntypedef struct {\n    int size;         // 鍵值對數量\n    int capacity;     // 雜湊表容量\n    double loadThres; // 觸發擴容的負載因子閾值\n    int extendRatio;  // 擴容倍數\n    Pair **buckets;   // 桶陣列\n    Pair *TOMBSTONE;  // 刪除標記\n} HashMapOpenAddressing;\n\n/* 建構子 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap-&gt;size = 0;\n    hashMap-&gt;capacity = 4;\n    hashMap-&gt;loadThres = 2.0 / 3.0;\n    hashMap-&gt;extendRatio = 2;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap-&gt;TOMBSTONE-&gt;key = -1;\n    hashMap-&gt;TOMBSTONE-&gt;val = \"-1\";\n\n    return hashMap;\n}\n\n/* 析構函式 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(hashMap-&gt;buckets);\n    free(hashMap-&gt;TOMBSTONE);\n    free(hashMap);\n}\n\n/* 雜湊函式 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap-&gt;capacity;\n}\n\n/* 負載因子 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap-&gt;size / (double)hashMap-&gt;capacity;\n}\n\n/* 搜尋 key 對應的桶索引 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // 線性探查，當遇到空桶時跳出\n    while (hashMap-&gt;buckets[index] != NULL) {\n        // 若遇到 key ，返回對應的桶索引\n        if (hashMap-&gt;buckets[index]-&gt;key == key) {\n            // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n            if (firstTombstone != -1) {\n                hashMap-&gt;buckets[firstTombstone] = hashMap-&gt;buckets[index];\n                hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n                return firstTombstone; // 返回移動後的桶索引\n            }\n            return index; // 返回桶索引\n        }\n        // 記錄遇到的首個刪除標記\n        if (firstTombstone == -1 &amp;&amp; hashMap-&gt;buckets[index] == hashMap-&gt;TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // 計算桶索引，越過尾部則返回頭部\n        index = (index + 1) % hashMap-&gt;capacity;\n    }\n    // 若 key 不存在，則返回新增點的索引\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* 查詢操作 */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則返回對應 val\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        return hashMap-&gt;buckets[index]-&gt;val;\n    }\n    // 若鍵值對不存在，則返回空字串\n    return \"\";\n}\n\n/* 新增操作 */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // 當負載因子超過閾值時，執行擴容\n    if (loadFactor(hashMap) &gt; hashMap-&gt;loadThres) {\n        extend(hashMap);\n    }\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則覆蓋 val 並返回\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        free(hashMap-&gt;buckets[index]-&gt;val);\n        hashMap-&gt;buckets[index]-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap-&gt;buckets[index]-&gt;val, val);\n        hashMap-&gt;buckets[index]-&gt;val[strlen(val)] = '\\0';\n        return;\n    }\n    // 若鍵值對不存在，則新增該鍵值對\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair-&gt;key = key;\n    pair-&gt;val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair-&gt;val, val);\n    pair-&gt;val[strlen(val)] = '\\0';\n\n    hashMap-&gt;buckets[index] = pair;\n    hashMap-&gt;size++;\n}\n\n/* 刪除操作 */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // 搜尋 key 對應的桶索引\n    int index = findBucket(hashMap, key);\n    // 若找到鍵值對，則用刪除標記覆蓋它\n    if (hashMap-&gt;buckets[index] != NULL &amp;&amp; hashMap-&gt;buckets[index] != hashMap-&gt;TOMBSTONE) {\n        Pair *pair = hashMap-&gt;buckets[index];\n        free(pair-&gt;val);\n        free(pair);\n        hashMap-&gt;buckets[index] = hashMap-&gt;TOMBSTONE;\n        hashMap-&gt;size--;\n    }\n}\n\n/* 擴容雜湊表 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // 暫存原雜湊表\n    Pair **bucketsTmp = hashMap-&gt;buckets;\n    int oldCapacity = hashMap-&gt;capacity;\n    // 初始化擴容後的新雜湊表\n    hashMap-&gt;capacity *= hashMap-&gt;extendRatio;\n    hashMap-&gt;buckets = (Pair **)calloc(hashMap-&gt;capacity, sizeof(Pair *));\n    hashMap-&gt;size = 0;\n    // 將鍵值對從原雜湊表搬運至新雜湊表\n    for (int i = 0; i &lt; oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL &amp;&amp; pair != hashMap-&gt;TOMBSTONE) {\n            put(hashMap, pair-&gt;key, pair-&gt;val);\n            free(pair-&gt;val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* 列印雜湊表 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i &lt; hashMap-&gt;capacity; i++) {\n        Pair *pair = hashMap-&gt;buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap-&gt;TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -&gt; %s\\n\", pair-&gt;key, pair-&gt;val);\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.kt<pre><code>/* 開放定址雜湊表 */\nclass HashMapOpenAddressing {\n    private var size: Int               // 鍵值對數量\n    private var capacity: Int           // 雜湊表容量\n    private val loadThres: Double       // 觸發擴容的負載因子閾值\n    private val extendRatio: Int        // 擴容倍數\n    private var buckets: Array&lt;Pair?&gt;   // 桶陣列\n    private val TOMBSTONE: Pair         // 刪除標記\n\n    /* 建構子 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = arrayOfNulls(capacity)\n        TOMBSTONE = Pair(-1, \"-1\")\n    }\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* 負載因子 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* 搜尋 key 對應的桶索引 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // 線性探查，當遇到空桶時跳出\n        while (buckets[index] != null) {\n            // 若遇到 key ，返回對應的桶索引\n            if (buckets[index]?.key == key) {\n                // 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // 返回移動後的桶索引\n                }\n                return index // 返回桶索引\n            }\n            // 記錄遇到的首個刪除標記\n            if (firstTombstone == -1 &amp;&amp; buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // 計算桶索引，越過尾部則返回頭部\n            index = (index + 1) % capacity\n        }\n        // 若 key 不存在，則返回新增點的索引\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則返回對應 val\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            return buckets[index]?._val\n        }\n        // 若鍵值對不存在，則返回 null\n        return null\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        // 當負載因子超過閾值時，執行擴容\n        if (loadFactor() &gt; loadThres) {\n            extend()\n        }\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則覆蓋 val 並返回\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index]!!._val = _val\n            return\n        }\n        // 若鍵值對不存在，則新增該鍵值對\n        buckets[index] = Pair(key, _val)\n        size++\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        // 搜尋 key 對應的桶索引\n        val index = findBucket(key)\n        // 若找到鍵值對，則用刪除標記覆蓋它\n        if (buckets[index] != null &amp;&amp; buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* 擴容雜湊表 */\n    fun extend() {\n        // 暫存原雜湊表\n        val bucketsTmp = buckets\n        // 初始化擴容後的新雜湊表\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // 將鍵值對從原雜湊表搬運至新雜湊表\n        for (pair in bucketsTmp) {\n            if (pair != null &amp;&amp; pair != TOMBSTONE) {\n                put(pair.key, pair._val)\n            }\n        }\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -&gt; ${pair._val}\")\n            }\n        }\n    }\n}\n</code></pre> hash_map_open_addressing.rb<pre><code>### 開放定址雜湊表 ###\nclass HashMapOpenAddressing\n  TOMBSTONE = Pair.new(-1, '-1') # 刪除標記\n\n  ### 建構子 ###\n  def initialize\n    @size = 0 # 鍵值對數量\n    @capacity = 4 # 雜湊表容量\n    @load_thres = 2.0 / 3.0 # 觸發擴容的負載因子閾值\n    @extend_ratio = 2 # 擴容倍數\n    @buckets = Array.new(@capacity) # 桶陣列\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    key % @capacity\n  end\n\n  ### 負載因子 ###\n  def load_factor\n    @size / @capacity\n  end\n\n  ### 搜尋 key 對應的桶索引 ###\n  def find_bucket(key)\n    index = hash_func(key)\n    first_tombstone = -1\n    # 線性探查，當遇到空桶時跳出\n    while !@buckets[index].nil?\n      # 若遇到 key ，返回對應的桶索引\n      if @buckets[index].key == key\n        # 若之前遇到了刪除標記，則將鍵值對移動至該索引處\n        if first_tombstone != -1\n          @buckets[first_tombstone] = @buckets[index]\n          @buckets[index] = TOMBSTONE\n          return first_tombstone # 返回移動後的桶索引\n        end\n        return index # 返回桶索引\n      end\n      # 記錄遇到的首個刪除標記\n      first_tombstone = index if first_tombstone == -1 &amp;&amp; @buckets[index] == TOMBSTONE\n      # 計算桶索引，越過尾部則返回頭部\n      index = (index + 1) % @capacity\n    end\n    # 若 key 不存在，則返回新增點的索引\n    first_tombstone == -1 ? index : first_tombstone\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則返回對應 val\n    return @buckets[index].val unless [nil, TOMBSTONE].include?(@buckets[index])\n    # 若鍵值對不存在，則返回 nil\n    nil\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    # 當負載因子超過閾值時，執行擴容\n    extend if load_factor &gt; @load_thres\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則覆蓋 val 開返回\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index].val = val\n      return\n    end\n    # 若鍵值對不存在，則新增該鍵值對\n    @buckets[index] = Pair.new(key, val)\n    @size += 1\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    # 搜尋 key 對應的桶索引\n    index = find_bucket(key)\n    # 若找到鍵值對，則用刪除標記覆蓋它\n    unless [nil, TOMBSTONE].include?(@buckets[index])\n      @buckets[index] = TOMBSTONE\n      @size -= 1\n    end\n  end\n\n  ### 擴容雜湊表 ###\n  def extend\n    # 暫存原雜湊表\n    buckets_tmp = @buckets\n    # 初始化擴容後的新雜湊表\n    @capacity *= @extend_ratio\n    @buckets = Array.new(@capacity)\n    @size = 0\n    # 將鍵值對從原雜湊表搬運至新雜湊表\n    for pair in buckets_tmp\n      put(pair.key, pair.val) unless [nil, TOMBSTONE].include?(pair)\n    end\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    for pair in @buckets\n      if pair.nil?\n        puts \"Nil\"\n      elsif pair == TOMBSTONE\n        puts \"TOMBSTONE\"\n      else\n        puts \"#{pair.key} -&gt; #{pair.val}\"\n      end\n    end\n  end\nend\n</code></pre>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#2","level":3,"title":"2.   平方探測","text":"<p>平方探測與線性探查類似，都是開放定址的常見策略之一。當發生衝突時，平方探測不是簡單地跳過一個固定的步數，而是跳過“探測次數的平方”的步數，即 \\(1, 4, 9, \\dots\\) 步。</p> <p>平方探測主要具有以下優勢。</p> <ul> <li>平方探測透過跳過探測次數平方的距離，試圖緩解線性探查的聚集效應。</li> <li>平方探測會跳過更大的距離來尋找空位置，有助於資料分佈得更加均勻。</li> </ul> <p>然而，平方探測並不是完美的。</p> <ul> <li>仍然存在聚集現象，即某些位置比其他位置更容易被佔用。</li> <li>由於平方的增長，平方探測可能不會探測整個雜湊表，這意味著即使雜湊表中有空桶，平方探測也可能無法訪問到它。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#3","level":3,"title":"3.   多次雜湊","text":"<p>顧名思義，多次雜湊方法使用多個雜湊函式 \\(f_1(x)\\)、\\(f_2(x)\\)、\\(f_3(x)\\)、\\(\\dots\\) 進行探測。</p> <ul> <li>插入元素：若雜湊函式 \\(f_1(x)\\) 出現衝突，則嘗試 \\(f_2(x)\\) ，以此類推，直到找到空位後插入元素。</li> <li>查詢元素：在相同的雜湊函式順序下進行查詢，直到找到目標元素時返回；若遇到空位或已嘗試所有雜湊函式，說明雜湊表中不存在該元素，則返回 <code>None</code> 。</li> </ul> <p>與線性探查相比，多次雜湊方法不易產生聚集，但多個雜湊函式會帶來額外的計算量。</p> <p>Tip</p> <p>請注意，開放定址（線性探查、平方探測和多次雜湊）雜湊表都存在“不能直接刪除元素”的問題。</p>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_collision/#623","level":2,"title":"6.2.3   程式語言的選擇","text":"<p>各種程式語言採取了不同的雜湊表實現策略，下面舉幾個例子。</p> <ul> <li>Python 採用開放定址。字典 <code>dict</code> 使用偽隨機數進行探測。</li> <li>Java 採用鏈式位址。自 JDK 1.8 以來，當 <code>HashMap</code> 內陣列長度達到 64 且鏈結串列長度達到 8 時，鏈結串列會轉換為紅黑樹以提升查詢效能。</li> <li>Go 採用鏈式位址。Go 規定每個桶最多儲存 8 個鍵值對，超出容量則連線一個溢位桶；當溢位桶過多時，會執行一次特殊的等量擴容操作，以確保效能。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.2 &nbsp; 雜湊衝突"],"tags":[]},{"location":"chapter_hashing/hash_map/","level":1,"title":"6.1   雜湊表","text":"<p>雜湊表（hash table），又稱散列表，它透過建立鍵 <code>key</code> 與值 <code>value</code> 之間的對映，實現高效的元素查詢。具體而言，我們向雜湊表中輸入一個鍵 <code>key</code> ，則可以在 \\(O(1)\\) 時間內獲取對應的值 <code>value</code> 。</p> <p>如圖 6-1 所示，給定 \\(n\\) 個學生，每個學生都有“姓名”和“學號”兩項資料。假如我們希望實現“輸入一個學號，返回對應的姓名”的查詢功能，則可以採用圖 6-1 所示的雜湊表來實現。</p> <p></p> <p> 圖 6-1   雜湊表的抽象表示 </p> <p>除雜湊表外，陣列和鏈結串列也可以實現查詢功能，它們的效率對比如表 6-1 所示。</p> <ul> <li>新增元素：僅需將元素新增至陣列（鏈結串列）的尾部即可，使用 \\(O(1)\\) 時間。</li> <li>查詢元素：由於陣列（鏈結串列）是亂序的，因此需要走訪其中的所有元素，使用 \\(O(n)\\) 時間。</li> <li>刪除元素：需要先查詢到元素，再從陣列（鏈結串列）中刪除，使用 \\(O(n)\\) 時間。</li> </ul> <p> 表 6-1   元素查詢效率對比 </p> 陣列 鏈結串列 雜湊表 查詢元素 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) 新增元素 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) <p>觀察發現，在雜湊表中進行增刪查改的時間複雜度都是 \\(O(1)\\) ，非常高效。</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#611","level":2,"title":"6.1.1   雜湊表常用操作","text":"<p>雜湊表的常見操作包括：初始化、查詢操作、新增鍵值對和刪除鍵值對等，示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># 初始化雜湊表\nhmap: dict = {}\n\n# 新增操作\n# 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n# 查詢操作\n# 向雜湊表中輸入鍵 key ，得到值 value\nname: str = hmap[15937]\n\n# 刪除操作\n# 在雜湊表中刪除鍵值對 (key, value)\nhmap.pop(10583)\n</code></pre> hash_map.cpp<pre><code>/* 初始化雜湊表 */\nunordered_map&lt;int, string&gt; map;\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\";\nmap[15937] = \"小囉\";\nmap[16750] = \"小算\";\nmap[13276] = \"小法\";\nmap[10583] = \"小鴨\";\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nstring name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.erase(10583);\n</code></pre> hash_map.java<pre><code>/* 初始化雜湊表 */\nMap&lt;Integer, String&gt; map = new HashMap&lt;&gt;();\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.put(12836, \"小哈\");\nmap.put(15937, \"小囉\");\nmap.put(16750, \"小算\");\nmap.put(13276, \"小法\");\nmap.put(10583, \"小鴨\");\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nString name = map.get(15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583);\n</code></pre> hash_map.cs<pre><code>/* 初始化雜湊表 */\nDictionary&lt;int, string&gt; map = new() {\n    /* 新增操作 */\n    // 在雜湊表中新增鍵值對 (key, value)\n    { 12836, \"小哈\" },\n    { 15937, \"小囉\" },\n    { 16750, \"小算\" },\n    { 13276, \"小法\" },\n    { 10583, \"小鴨\" }\n};\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nstring name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.Remove(10583);\n</code></pre> hash_map_test.go<pre><code>/* 初始化雜湊表 */\nhmap := make(map[int]string)\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nname := hmap[15937]\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\ndelete(hmap, 10583)\n</code></pre> hash_map.swift<pre><code>/* 初始化雜湊表 */\nvar map: [Int: String] = [:]\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\"\nmap[15937] = \"小囉\"\nmap[16750] = \"小算\"\nmap[13276] = \"小法\"\nmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map[15937]!\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.removeValue(forKey: 10583)\n</code></pre> hash_map.js<pre><code>/* 初始化雜湊表 */\nconst map = new Map();\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.set(12836, '小哈');\nmap.set(15937, '小囉');\nmap.set(16750, '小算');\nmap.set(13276, '小法');\nmap.set(10583, '小鴨');\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map.get(15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.delete(10583);\n</code></pre> hash_map.ts<pre><code>/* 初始化雜湊表 */\nconst map = new Map&lt;number, string&gt;();\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.set(12836, '小哈');\nmap.set(15937, '小囉');\nmap.set(16750, '小算');\nmap.set(13276, '小法');\nmap.set(10583, '小鴨');\nconsole.info('\\n新增完成後，雜湊表為\\nKey -&gt; Value');\nconsole.info(map);\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet name = map.get(15937);\nconsole.info('\\n輸入學號 15937 ，查詢到姓名 ' + name);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.delete(10583);\nconsole.info('\\n刪除 10583 後，雜湊表為\\nKey -&gt; Value');\nconsole.info(map);\n</code></pre> hash_map.dart<pre><code>/* 初始化雜湊表 */\nMap&lt;int, String&gt; map = {};\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\";\nmap[15937] = \"小囉\";\nmap[16750] = \"小算\";\nmap[13276] = \"小法\";\nmap[10583] = \"小鴨\";\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nString name = map[15937];\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583);\n</code></pre> hash_map.rs<pre><code>use std::collections::HashMap;\n\n/* 初始化雜湊表 */\nlet mut map: HashMap&lt;i32, String&gt; = HashMap::new();\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap.insert(12836, \"小哈\".to_string());\nmap.insert(15937, \"小囉\".to_string());\nmap.insert(16750, \"小算\".to_string());\nmap.insert(13279, \"小法\".to_string());\nmap.insert(10583, \"小鴨\".to_string());\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nlet _name: Option&lt;&amp;String&gt; = map.get(&amp;15937);\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nlet _removed_value: Option&lt;String&gt; = map.remove(&amp;10583);\n</code></pre> hash_map.c<pre><code>// C 未提供內建雜湊表\n</code></pre> hash_map.kt<pre><code>/* 初始化雜湊表 */\nval map = HashMap&lt;Int,String&gt;()\n\n/* 新增操作 */\n// 在雜湊表中新增鍵值對 (key, value)\nmap[12836] = \"小哈\"\nmap[15937] = \"小囉\"\nmap[16750] = \"小算\"\nmap[13276] = \"小法\"\nmap[10583] = \"小鴨\"\n\n/* 查詢操作 */\n// 向雜湊表中輸入鍵 key ，得到值 value\nval name = map[15937]\n\n/* 刪除操作 */\n// 在雜湊表中刪除鍵值對 (key, value)\nmap.remove(10583)\n</code></pre> hash_map.rb<pre><code># 初始化雜湊表\nhmap = {}\n\n# 新增操作\n# 在雜湊表中新增鍵值對 (key, value)\nhmap[12836] = \"小哈\"\nhmap[15937] = \"小囉\"\nhmap[16750] = \"小算\"\nhmap[13276] = \"小法\"\nhmap[10583] = \"小鴨\"\n\n# 查詢操作\n# 向雜湊表中輸入鍵 key ，得到值 value\nname = hmap[15937]\n\n# 刪除操作\n# 在雜湊表中刪除鍵值對 (key, value)\nhmap.delete(10583)\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>雜湊表有三種常用的走訪方式：走訪鍵值對、走訪鍵和走訪值。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby hash_map.py<pre><code># 走訪雜湊表\n# 走訪鍵值對 key-&gt;value\nfor key, value in hmap.items():\n    print(key, \"-&gt;\", value)\n# 單獨走訪鍵 key\nfor key in hmap.keys():\n    print(key)\n# 單獨走訪值 value\nfor value in hmap.values():\n    print(value)\n</code></pre> hash_map.cpp<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor (auto kv: map) {\n    cout &lt;&lt; kv.first &lt;&lt; \" -&gt; \" &lt;&lt; kv.second &lt;&lt; endl;\n}\n// 使用迭代器走訪 key-&gt;value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout &lt;&lt; iter-&gt;first &lt;&lt; \"-&gt;\" &lt;&lt; iter-&gt;second &lt;&lt; endl;\n}\n</code></pre> hash_map.java<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor (Map.Entry &lt;Integer, String&gt; kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -&gt; \" + kv.getValue());\n}\n// 單獨走訪鍵 key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// 單獨走訪值 value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n</code></pre> hash_map.cs<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -&gt; \" + kv.Value);\n}\n// 單獨走訪鍵 key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// 單獨走訪值 value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n</code></pre> hash_map_test.go<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor key, value := range hmap {\n    fmt.Println(key, \"-&gt;\", value)\n}\n// 單獨走訪鍵 key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// 單獨走訪值 value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n</code></pre> hash_map.swift<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nfor (key, value) in map {\n    print(\"\\(key) -&gt; \\(value)\")\n}\n// 單獨走訪鍵 Key\nfor key in map.keys {\n    print(key)\n}\n// 單獨走訪值 Value\nfor value in map.values {\n    print(value)\n}\n</code></pre> hash_map.js<pre><code>/* 走訪雜湊表 */\nconsole.info('\\n走訪鍵值對 Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\n單獨走訪鍵 Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n單獨走訪值 Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.ts<pre><code>/* 走訪雜湊表 */\nconsole.info('\\n走訪鍵值對 Key-&gt;Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -&gt; ' + v);\n}\nconsole.info('\\n單獨走訪鍵 Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n單獨走訪值 Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n</code></pre> hash_map.dart<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nmap.forEach((key, value) {\n  print('$key -&gt; $value');\n});\n\n// 單獨走訪鍵 Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// 單獨走訪值 Value\nmap.values.forEach((value) {\n  print(value);\n});\n</code></pre> hash_map.rs<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 Key-&gt;Value\nfor (key, value) in &amp;map {\n    println!(\"{key} -&gt; {value}\");\n}\n\n// 單獨走訪鍵 Key\nfor key in map.keys() {\n    println!(\"{key}\");\n}\n\n// 單獨走訪值 Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n</code></pre> hash_map.c<pre><code>// C 未提供內建雜湊表\n</code></pre> hash_map.kt<pre><code>/* 走訪雜湊表 */\n// 走訪鍵值對 key-&gt;value\nfor ((key, value) in map) {\n    println(\"$key -&gt; $value\")\n}\n// 單獨走訪鍵 key\nfor (key in map.keys) {\n    println(key)\n}\n// 單獨走訪值 value\nfor (_val in map.values) {\n    println(_val)\n}\n</code></pre> hash_map.rb<pre><code># 走訪雜湊表\n# 走訪鍵值對 key-&gt;value\nhmap.entries.each { |key, value| puts \"#{key} -&gt; #{value}\" }\n\n# 單獨走訪鍵 key\nhmap.keys.each { |key| puts key }\n\n# 單獨走訪值 value\nhmap.values.each { |val| puts val }\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#612","level":2,"title":"6.1.2   雜湊表簡單實現","text":"<p>我們先考慮最簡單的情況，僅用一個陣列來實現雜湊表。在雜湊表中，我們將陣列中的每個空位稱為桶（bucket），每個桶可儲存一個鍵值對。因此，查詢操作就是找到 <code>key</code> 對應的桶，並在桶中獲取 <code>value</code> 。</p> <p>那麼，如何基於 <code>key</code> 定位對應的桶呢？這是透過雜湊函式（hash function）實現的。雜湊函式的作用是將一個較大的輸入空間對映到一個較小的輸出空間。在雜湊表中，輸入空間是所有 <code>key</code> ，輸出空間是所有桶（陣列索引）。換句話說，輸入一個 <code>key</code> ，我們可以透過雜湊函式得到該 <code>key</code> 對應的鍵值對在陣列中的儲存位置。</p> <p>輸入一個 <code>key</code> ，雜湊函式的計算過程分為以下兩步。</p> <ol> <li>透過某種雜湊演算法 <code>hash()</code> 計算得到雜湊值。</li> <li>將雜湊值對桶數量（陣列長度）<code>capacity</code> 取模，從而獲取該 <code>key</code> 對應的桶（陣列索引）<code>index</code> 。</li> </ol> <pre><code>index = hash(key) % capacity\n</code></pre> <p>隨後，我們就可以利用 <code>index</code> 在雜湊表中訪問對應的桶，從而獲取 <code>value</code> 。</p> <p>設陣列長度 <code>capacity = 100</code>、雜湊演算法 <code>hash(key) = key</code> ，易得雜湊函式為 <code>key % 100</code> 。圖 6-2 以 <code>key</code> 學號和 <code>value</code> 姓名為例，展示了雜湊函式的工作原理。</p> <p></p> <p> 圖 6-2   雜湊函式工作原理 </p> <p>以下程式碼實現了一個簡單雜湊表。其中，我們將 <code>key</code> 和 <code>value</code> 封裝成一個類別 <code>Pair</code> ，以表示鍵值對。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_hash_map.py<pre><code>class Pair:\n    \"\"\"鍵值對\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"基於陣列實現的雜湊表\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        # 初始化陣列，包含 100 個桶\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -&gt; int:\n        \"\"\"雜湊函式\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -&gt; str | None:\n        \"\"\"查詢操作\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"新增和更新操作\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"刪除操作\"\"\"\n        index: int = self.hash_func(key)\n        # 置為 None ，代表刪除\n        self.buckets[index] = None\n\n    def entry_set(self) -&gt; list[Pair]:\n        \"\"\"獲取所有鍵值對\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -&gt; list[int]:\n        \"\"\"獲取所有鍵\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -&gt; list[str]:\n        \"\"\"獲取所有值\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"列印雜湊表\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"-&gt;\", pair.val)\n</code></pre> array_hash_map.cpp<pre><code>/* 鍵值對 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this-&gt;key = key;\n        this-&gt;val = val;\n    }\n};\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n  private:\n    vector&lt;Pair *&gt; buckets;\n\n  public:\n    ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = vector&lt;Pair *&gt;(100);\n    }\n\n    ~ArrayHashMap() {\n        // 釋放記憶體\n        for (const auto &amp;bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* 雜湊函式 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair-&gt;val;\n    }\n\n    /* 新增操作 */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 刪除操作 */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // 釋放記憶體並置為 nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* 獲取所有鍵值對 */\n    vector&lt;Pair *&gt; pairSet() {\n        vector&lt;Pair *&gt; pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    vector&lt;int&gt; keySet() {\n        vector&lt;int&gt; keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair-&gt;key);\n            }\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    vector&lt;string&gt; valueSet() {\n        vector&lt;string&gt; valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair-&gt;val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout &lt;&lt; kv-&gt;key &lt;&lt; \" -&gt; \" &lt;&lt; kv-&gt;val &lt;&lt; endl;\n        }\n    }\n};\n</code></pre> array_hash_map.java<pre><code>/* 鍵值對 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private List&lt;Pair&gt; buckets;\n\n    public ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = new ArrayList&lt;&gt;();\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* 雜湊函式 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* 刪除操作 */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // 置為 null ，代表刪除\n        buckets.set(index, null);\n    }\n\n    /* 獲取所有鍵值對 */\n    public List&lt;Pair&gt; pairSet() {\n        List&lt;Pair&gt; pairSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    public List&lt;Integer&gt; keySet() {\n        List&lt;Integer&gt; keySet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    public List&lt;String&gt; valueSet() {\n        List&lt;String&gt; valueSet = new ArrayList&lt;&gt;();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.cs<pre><code>/* 鍵值對 int-&gt;string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    List&lt;Pair?&gt; buckets;\n    public ArrayHashMap() {\n        // 初始化陣列，包含 100 個桶\n        buckets = [];\n        for (int i = 0; i &lt; 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* 雜湊函式 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* 查詢操作 */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* 刪除操作 */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // 置為 null ，代表刪除\n        buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    public List&lt;Pair&gt; PairSet() {\n        List&lt;Pair&gt; pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* 獲取所有鍵 */\n    public List&lt;int&gt; KeySet() {\n        List&lt;int&gt; keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* 獲取所有值 */\n    public List&lt;string&gt; ValueSet() {\n        List&lt;string&gt; valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* 列印雜湊表 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -&gt; \" + kv.val);\n        }\n    }\n}\n</code></pre> array_hash_map.go<pre><code>/* 鍵值對 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* 基於陣列實現的雜湊表 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* 初始化雜湊表 */\nfunc newArrayHashMap() *arrayHashMap {\n    // 初始化陣列，包含 100 個桶\n    buckets := make([]*pair, 100)\n    return &amp;arrayHashMap{buckets: buckets}\n}\n\n/* 雜湊函式 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* 查詢操作 */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* 新增操作 */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &amp;pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* 刪除操作 */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // 置為 nil ，代表刪除\n    a.buckets[index] = nil\n}\n\n/* 獲取所有鍵對 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* 獲取所有鍵 */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* 獲取所有值 */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* 列印雜湊表 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"-&gt;\", pair.val)\n        }\n    }\n}\n</code></pre> array_hash_map.swift<pre><code>/* 鍵值對 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -&gt; Bool {\n        lhs.key == rhs.key &amp;&amp; lhs.val == rhs.val\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // 初始化陣列，包含 100 個桶\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* 雜湊函式 */\n    private func hashFunc(key: Int) -&gt; Int {\n        let index = key % 100\n        return index\n    }\n\n    /* 查詢操作 */\n    func get(key: Int) -&gt; String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* 新增操作 */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* 刪除操作 */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // 置為 nil ，代表刪除\n        buckets[index] = nil\n    }\n\n    /* 獲取所有鍵值對 */\n    func pairSet() -&gt; [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* 獲取所有鍵 */\n    func keySet() -&gt; [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* 獲取所有值 */\n    func valueSet() -&gt; [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* 列印雜湊表 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -&gt; \\(pair.val)\")\n        }\n    }\n}\n</code></pre> array_hash_map.js<pre><code>/* 鍵值對 Number -&gt; String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // 初始化陣列，包含 100 個桶\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* 雜湊函式 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* 查詢操作 */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* 刪除操作 */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // 置為 null ，代表刪除\n        this.#buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有鍵 */\n    keys() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有值 */\n    values() {\n        let arr = [];\n        for (let i = 0; i &lt; this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* 列印雜湊表 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.ts<pre><code>/* 鍵值對 Number -&gt; String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // 初始化陣列，包含 100 個桶\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* 雜湊函式 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* 查詢操作 */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* 新增操作 */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* 刪除操作 */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // 置為 null ，代表刪除\n        this.buckets[index] = null;\n    }\n\n    /* 獲取所有鍵值對 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有鍵 */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* 獲取所有值 */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i &lt; this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* 列印雜湊表 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -&gt; ${pair.val}`);\n        }\n    }\n}\n</code></pre> array_hash_map.dart<pre><code>/* 鍵值對 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n  late List&lt;Pair?&gt; _buckets;\n\n  ArrayHashMap() {\n    // 初始化陣列，包含 100 個桶\n    _buckets = List.filled(100, null);\n  }\n\n  /* 雜湊函式 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* 查詢操作 */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* 新增操作 */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* 刪除操作 */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* 獲取所有鍵值對 */\n  List&lt;Pair&gt; pairSet() {\n    List&lt;Pair&gt; pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* 獲取所有鍵 */\n  List&lt;int&gt; keySet() {\n    List&lt;int&gt; keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* 獲取所有值 */\n  List&lt;String&gt; values() {\n    List&lt;String&gt; valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* 列印雜湊表 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -&gt; ${kv.val}\");\n    }\n  }\n}\n</code></pre> array_hash_map.rs<pre><code>/* 鍵值對 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* 基於陣列實現的雜湊表 */\npub struct ArrayHashMap {\n    buckets: Vec&lt;Option&lt;Pair&gt;&gt;,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -&gt; ArrayHashMap {\n        // 初始化陣列，包含 100 個桶\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* 雜湊函式 */\n    fn hash_func(&amp;self, key: i32) -&gt; usize {\n        key as usize % 100\n    }\n\n    /* 查詢操作 */\n    pub fn get(&amp;self, key: i32) -&gt; Option&lt;&amp;String&gt; {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &amp;pair.val)\n    }\n\n    /* 新增操作 */\n    pub fn put(&amp;mut self, key: i32, val: &amp;str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* 刪除操作 */\n    pub fn remove(&amp;mut self, key: i32) {\n        let index = self.hash_func(key);\n        // 置為 None ，代表刪除\n        self.buckets[index] = None;\n    }\n\n    /* 獲取所有鍵值對 */\n    pub fn entry_set(&amp;self) -&gt; Vec&lt;&amp;Pair&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* 獲取所有鍵 */\n    pub fn key_set(&amp;self) -&gt; Vec&lt;&amp;i32&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.key))\n            .collect()\n    }\n\n    /* 獲取所有值 */\n    pub fn value_set(&amp;self) -&gt; Vec&lt;&amp;String&gt; {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &amp;pair.val))\n            .collect()\n    }\n\n    /* 列印雜湊表 */\n    pub fn print(&amp;self) {\n        for pair in self.entry_set() {\n            println!(\"{} -&gt; {}\", pair.key, pair.val);\n        }\n    }\n}\n</code></pre> array_hash_map.c<pre><code>/* 鍵值對 int-&gt;string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* 基於陣列實現的雜湊表 */\ntypedef struct {\n    Pair *buckets[MAX_SIZE];\n} ArrayHashMap;\n\n/* 建構子 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    for (int i=0; i &lt; MAX_SIZE; i++) {\n        hmap-&gt;buckets[i] = NULL;\n    }\n    return hmap;\n}\n\n/* 析構函式 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            free(hmap-&gt;buckets[i]-&gt;val);\n            free(hmap-&gt;buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* 新增操作 */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair-&gt;key = key;\n    Pair-&gt;val = malloc(strlen(val) + 1);\n    strcpy(Pair-&gt;val, val);\n\n    int index = hashFunc(key);\n    hmap-&gt;buckets[index] = Pair;\n}\n\n/* 刪除操作 */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap-&gt;buckets[index]-&gt;val);\n    free(hmap-&gt;buckets[index]);\n    hmap-&gt;buckets[index] = NULL;\n}\n\n/* 獲取所有鍵值對 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            entries[index].key = hmap-&gt;buckets[i]-&gt;key;\n            entries[index].val = malloc(strlen(hmap-&gt;buckets[i]-&gt;val) + 1);\n            strcpy(entries[index].val, hmap-&gt;buckets[i]-&gt;val);\n            index++;\n        }\n    }\n    set-&gt;set = entries;\n    set-&gt;len = total;\n}\n\n/* 獲取所有鍵 */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            keys[index] = hmap-&gt;buckets[i]-&gt;key;\n            index++;\n        }\n    }\n    set-&gt;set = keys;\n    set-&gt;len = total;\n}\n\n/* 獲取所有值 */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* 統計有效鍵值對數量 */\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i &lt; MAX_SIZE; i++) {\n        if (hmap-&gt;buckets[i] != NULL) {\n            vals[index] = hmap-&gt;buckets[i]-&gt;val;\n            index++;\n        }\n    }\n    set-&gt;set = vals;\n    set-&gt;len = total;\n}\n\n/* 列印雜湊表 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &amp;set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i &lt; set.len; i++) {\n        printf(\"%d -&gt; %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n</code></pre> array_hash_map.kt<pre><code>/* 鍵值對 */\nclass Pair(\n    var key: Int,\n    var _val: String\n)\n\n/* 基於陣列實現的雜湊表 */\nclass ArrayHashMap {\n    // 初始化陣列，包含 100 個桶\n    private val buckets = arrayOfNulls&lt;Pair&gt;(100)\n\n    /* 雜湊函式 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* 查詢操作 */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair._val\n    }\n\n    /* 新增操作 */\n    fun put(key: Int, _val: String) {\n        val pair = Pair(key, _val)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* 刪除操作 */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // 置為 null ，代表刪除\n        buckets[index] = null\n    }\n\n    /* 獲取所有鍵值對 */\n    fun pairSet(): MutableList&lt;Pair&gt; {\n        val pairSet = mutableListOf&lt;Pair&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* 獲取所有鍵 */\n    fun keySet(): MutableList&lt;Int&gt; {\n        val keySet = mutableListOf&lt;Int&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* 獲取所有值 */\n    fun valueSet(): MutableList&lt;String&gt; {\n        val valueSet = mutableListOf&lt;String&gt;()\n        for (pair in buckets) {\n            if (pair != null)\n                valueSet.add(pair._val)\n        }\n        return valueSet\n    }\n\n    /* 列印雜湊表 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val _val = kv._val\n            println(\"$key -&gt; $_val\")\n        }\n    }\n}\n</code></pre> array_hash_map.rb<pre><code>### 鍵值對 ###\nclass Pair\n  attr_accessor :key, :val\n\n  def initialize(key, val)\n    @key = key\n    @val = val\n  end\nend\n\n### 基於陣列實現的雜湊表 ###\nclass ArrayHashMap\n  ### 建構子 ###\n  def initialize\n    # 初始化陣列，包含 100 個桶\n    @buckets = Array.new(100)\n  end\n\n  ### 雜湊函式 ###\n  def hash_func(key)\n    index = key % 100\n  end\n\n  ### 查詢操作 ###\n  def get(key)\n    index = hash_func(key)\n    pair = @buckets[index]\n\n    return if pair.nil?\n    pair.val\n  end\n\n  ### 新增操作 ###\n  def put(key, val)\n    pair = Pair.new(key, val)\n    index = hash_func(key)\n    @buckets[index] = pair\n  end\n\n  ### 刪除操作 ###\n  def remove(key)\n    index = hash_func(key)\n    # 置為 nil ，代表刪除\n    @buckets[index] = nil\n  end\n\n  ### 獲取所有鍵值對 ###\n  def entry_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair unless pair.nil? }\n    result\n  end\n\n  ### 獲取所有鍵 ###\n  def key_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.key unless pair.nil? }\n    result\n  end\n\n  ### 獲取所有值 ###\n  def value_set\n    result = []\n    @buckets.each { |pair| result &lt;&lt; pair.val unless pair.nil? }\n    result\n  end\n\n  ### 列印雜湊表 ###\n  def print\n    @buckets.each { |pair| puts \"#{pair.key} -&gt; #{pair.val}\" unless pair.nil? }\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/hash_map/#613","level":2,"title":"6.1.3   雜湊衝突與擴容","text":"<p>從本質上看，雜湊函式的作用是將所有 <code>key</code> 構成的輸入空間對映到陣列所有索引構成的輸出空間，而輸入空間往往遠大於輸出空間。因此，理論上一定存在“多個輸入對應相同輸出”的情況。</p> <p>對於上述示例中的雜湊函式，當輸入的 <code>key</code> 後兩位相同時，雜湊函式的輸出結果也相同。例如，查詢學號為 12836 和 20336 的兩個學生時，我們得到：</p> <pre><code>12836 % 100 = 36\n20336 % 100 = 36\n</code></pre> <p>如圖 6-3 所示，兩個學號指向了同一個姓名，這顯然是不對的。我們將這種多個輸入對應同一輸出的情況稱為雜湊衝突（hash collision）。</p> <p></p> <p> 圖 6-3   雜湊衝突示例 </p> <p>容易想到，雜湊表容量 \\(n\\) 越大，多個 <code>key</code> 被分配到同一個桶中的機率就越低，衝突就越少。因此，我們可以透過擴容雜湊表來減少雜湊衝突。</p> <p>如圖 6-4 所示，擴容前鍵值對 <code>(136, A)</code> 和 <code>(236, D)</code> 發生衝突，擴容後衝突消失。</p> <p></p> <p> 圖 6-4   雜湊表擴容 </p> <p>類似於陣列擴容，雜湊表擴容需將所有鍵值對從原雜湊表遷移至新雜湊表，非常耗時；並且由於雜湊表容量 <code>capacity</code> 改變，我們需要透過雜湊函式來重新計算所有鍵值對的儲存位置，這進一步增加了擴容過程的計算開銷。為此，程式語言通常會預留足夠大的雜湊表容量，防止頻繁擴容。</p> <p>負載因子（load factor）是雜湊表的一個重要概念，其定義為雜湊表的元素數量除以桶數量，用於衡量雜湊衝突的嚴重程度，也常作為雜湊表擴容的觸發條件。例如在 Java 中，當負載因子超過 \\(0.75\\) 時，系統會將雜湊表擴容至原先的 \\(2\\) 倍。</p>","path":["第 6 章 &nbsp; 雜湊表","6.1 &nbsp; 雜湊表"],"tags":[]},{"location":"chapter_hashing/summary/","level":1,"title":"6.4   小結","text":"","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>輸入 <code>key</code> ，雜湊表能夠在 \\(O(1)\\) 時間內查詢到 <code>value</code> ，效率非常高。</li> <li>常見的雜湊表操作包括查詢、新增鍵值對、刪除鍵值對和走訪雜湊表等。</li> <li>雜湊函式將 <code>key</code> 對映為陣列索引，從而訪問對應桶並獲取 <code>value</code> 。</li> <li>兩個不同的 <code>key</code> 可能在經過雜湊函式後得到相同的陣列索引，導致查詢結果出錯，這種現象被稱為雜湊衝突。</li> <li>雜湊表容量越大，雜湊衝突的機率就越低。因此可以透過擴容雜湊表來緩解雜湊衝突。與陣列擴容類似，雜湊表擴容操作的開銷很大。</li> <li>負載因子定義為雜湊表中元素數量除以桶數量，反映了雜湊衝突的嚴重程度，常用作觸發雜湊表擴容的條件。</li> <li>鏈式位址透過將單個元素轉化為鏈結串列，將所有衝突元素儲存在同一個鏈結串列中。然而，鏈結串列過長會降低查詢效率，可以透過進一步將鏈結串列轉換為紅黑樹來提高效率。</li> <li>開放定址透過多次探測來處理雜湊衝突。線性探查使用固定步長，缺點是不能刪除元素，且容易產生聚集。多次雜湊使用多個雜湊函式進行探測，相較線性探查更不易產生聚集，但多個雜湊函式增加了計算量。</li> <li>不同程式語言採取了不同的雜湊表實現。例如，Java 的 <code>HashMap</code> 使用鏈式位址，而 Python 的 <code>Dict</code> 採用開放定址。</li> <li>在雜湊表中，我們希望雜湊演算法具有確定性、高效率和均勻分佈的特點。在密碼學中，雜湊演算法還應該具備抗碰撞性和雪崩效應。</li> <li>雜湊演算法通常採用大質數作為模數，以最大化地保證雜湊值均勻分佈，減少雜湊衝突。</li> <li>常見的雜湊演算法包括 MD5、SHA-1、SHA-2 和 SHA-3 等。MD5 常用於校驗檔案完整性，SHA-2 常用於安全應用與協議。</li> <li>程式語言通常會為資料型別提供內建雜湊演算法，用於計算雜湊表中的桶索引。通常情況下，只有不可變物件是可雜湊的。</li> </ul>","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_hashing/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：雜湊表的時間複雜度在什麼情況下是 \\(O(n)\\) ？</p> <p>當雜湊衝突比較嚴重時，雜湊表的時間複雜度會退化至 \\(O(n)\\) 。當雜湊函式設計得比較好、容量設定比較合理、衝突比較平均時，時間複雜度是 \\(O(1)\\) 。我們使用程式語言內建的雜湊表時，通常認為時間複雜度是 \\(O(1)\\) 。</p> <p>Q：為什麼不使用雜湊函式 \\(f(x) = x\\) 呢？這樣就不會有衝突了。</p> <p>在 \\(f(x) = x\\) 雜湊函式下，每個元素對應唯一的桶索引，這與陣列等價。然而，輸入空間通常遠大於輸出空間（陣列長度），因此雜湊函式的最後一步往往是對陣列長度取模。換句話說，雜湊表的目標是將一個較大的狀態空間對映到一個較小的空間，並提供 \\(O(1)\\) 的查詢效率。</p> <p>Q：雜湊表底層實現是陣列、鏈結串列、二元樹，但為什麼效率可以比它們更高呢？</p> <p>首先，雜湊表的時間效率變高，但空間效率變低了。雜湊表有相當一部分記憶體未使用。</p> <p>其次，只是在特定使用場景下時間效率變高了。如果一個功能能夠在相同的時間複雜度下使用陣列或鏈結串列實現，那麼通常比雜湊表更快。這是因為雜湊函式計算需要開銷，時間複雜度的常數項更大。</p> <p>最後，雜湊表的時間複雜度可能發生劣化。例如在鏈式位址中，我們採取在鏈結串列或紅黑樹中執行查詢操作，仍然有退化至 \\(O(n)\\) 時間的風險。</p> <p>Q：多次雜湊有不能直接刪除元素的缺陷嗎？標記為已刪除的空間還能再次使用嗎？</p> <p>多次雜湊是開放定址的一種，開放定址法都有不能直接刪除元素的缺陷，需要透過標記刪除。標記為已刪除的空間可以再次使用。當將新元素插入雜湊表，並且透過雜湊函式找到標記為已刪除的位置時，該位置可以被新元素使用。這樣做既能保持雜湊表的探測序列不變，又能保證雜湊表的空間使用率。</p> <p>Q：為什麼在線性探查中，查詢元素的時候會出現雜湊衝突呢？</p> <p>查詢的時候透過雜湊函式找到對應的桶和鍵值對，發現 <code>key</code> 不匹配，這就代表有雜湊衝突。因此，線性探查法會根據預先設定的步長依次向下查詢，直至找到正確的鍵值對或無法找到跳出為止。</p> <p>Q：為什麼雜湊表擴容能夠緩解雜湊衝突？</p> <p>雜湊函式的最後一步往往是對陣列長度 \\(n\\) 取模（取餘），讓輸出值落在陣列索引範圍內；在擴容後，陣列長度 \\(n\\) 發生變化，而 <code>key</code> 對應的索引也可能發生變化。原先落在同一個桶的多個 <code>key</code> ，在擴容後可能會被分配到多個桶中，從而實現雜湊衝突的緩解。</p> <p>Q：如果為了高效的存取，那麼直接使用陣列不就好了嗎？</p> <p>當資料的 <code>key</code> 是連續的小範圍整數時，直接用陣列即可，簡單高效。但當 <code>key</code> 是其他型別（例如字串）時，就需要藉助雜湊函式將 <code>key</code> 對映為陣列索引，再透過桶陣列儲存元素，這樣的結構就是雜湊表。</p>","path":["第 6 章 &nbsp; 雜湊表","6.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/","level":1,"title":"第 8 章   堆積","text":"<p>Abstract</p> <p>堆積就像是山嶽峰巒，層疊起伏、形態各異。</p> <p>座座山峰高低錯落，而最高的山峰總是最先映入眼簾。</p>","path":["第 8 章 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/#_1","level":2,"title":"本章內容","text":"<ul> <li>8.1   堆積</li> <li>8.2   建堆積操作</li> <li>8.3   Top-k 問題</li> <li>8.4   小結</li> </ul>","path":["第 8 章 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/build_heap/","level":1,"title":"8.2   建堆積操作","text":"<p>在某些情況下，我們希望使用一個串列的所有元素來構建一個堆積，這個過程被稱為“建堆積操作”。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#821","level":2,"title":"8.2.1   藉助入堆積操作實現","text":"<p>我們首先建立一個空堆積，然後走訪串列，依次對每個元素執行“入堆積操作”，即先將元素新增至堆積的尾部，再對該元素執行“從底至頂”堆積化。</p> <p>每當一個元素入堆積，堆積的長度就加一。由於節點是從頂到底依次被新增進二元樹的，因此堆積是“自上而下”構建的。</p> <p>設元素數量為 \\(n\\) ，每個元素的入堆積操作使用 \\(O(\\log{n})\\) 時間，因此該建堆積方法的時間複雜度為 \\(O(n \\log n)\\) 。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#822","level":2,"title":"8.2.2   透過走訪堆積化實現","text":"<p>實際上，我們可以實現一種更為高效的建堆積方法，共分為兩步。</p> <ol> <li>將串列所有元素原封不動地新增到堆積中，此時堆積的性質尚未得到滿足。</li> <li>倒序走訪堆積（層序走訪的倒序），依次對每個非葉節點執行“從頂至底堆積化”。</li> </ol> <p>每當堆積化一個節點後，以該節點為根節點的子樹就形成一個合法的子堆積。而由於是倒序走訪，因此堆積是“自下而上”構建的。</p> <p>之所以選擇倒序走訪，是因為這樣能夠保證當前節點之下的子樹已經是合法的子堆積，這樣堆積化當前節點才是有效的。</p> <p>值得說明的是，由於葉節點沒有子節點，因此它們天然就是合法的子堆積，無須堆積化。如以下程式碼所示，最後一個非葉節點是最後一個節點的父節點，我們從它開始倒序走訪並執行堆積化：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def __init__(self, nums: list[int]):\n    \"\"\"建構子，根據輸入串列建堆積\"\"\"\n    # 將串列元素原封不動新增進堆積\n    self.max_heap = nums\n    # 堆積化除葉節點以外的其他所有節點\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\n</code></pre> my_heap.cpp<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(vector&lt;int&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = nums;\n    // 堆積化除葉節點以外的其他所有節點\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(List&lt;Integer&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = new ArrayList&lt;&gt;(nums);\n    // 堆積化除葉節點以外的其他所有節點\n    for (int i = parent(size() - 1); i &gt;= 0; i--) {\n        siftDown(i);\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(IEnumerable&lt;int&gt; nums) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = new List&lt;int&gt;(nums);\n    // 堆積化除葉節點以外的其他所有節點\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i &gt;= 0; i--) {\n        SiftDown(i);\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 建構子，根據切片建堆積 */\nfunc newMaxHeap(nums []any) *maxHeap {\n    // 將串列元素原封不動新增進堆積\n    h := &amp;maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i &gt;= 0; i-- {\n        // 堆積化除葉節點以外的其他所有節點\n        h.siftDown(i)\n    }\n    return h\n}\n</code></pre> my_heap.swift<pre><code>/* 建構子，根據輸入串列建堆積 */\ninit(nums: [Int]) {\n    // 將串列元素原封不動新增進堆積\n    maxHeap = nums\n    // 堆積化除葉節點以外的其他所有節點\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 建構子，建立空堆積或根據輸入串列建堆積 */\nconstructor(nums) {\n    // 將串列元素原封不動新增進堆積\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // 堆積化除葉節點以外的其他所有節點\n    for (let i = this.#parent(this.size() - 1); i &gt;= 0; i--) {\n        this.#siftDown(i);\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 建構子，建立空堆積或根據輸入串列建堆積 */\nconstructor(nums?: number[]) {\n    // 將串列元素原封不動新增進堆積\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // 堆積化除葉節點以外的其他所有節點\n    for (let i = this.parent(this.size() - 1); i &gt;= 0; i--) {\n        this.siftDown(i);\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 建構子，根據輸入串列建堆積 */\nMaxHeap(List&lt;int&gt; nums) {\n  // 將串列元素原封不動新增進堆積\n  _maxHeap = nums;\n  // 堆積化除葉節點以外的其他所有節點\n  for (int i = _parent(size() - 1); i &gt;= 0; i--) {\n    siftDown(i);\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 建構子，根據輸入串列建堆積 */\nfn new(nums: Vec&lt;i32&gt;) -&gt; Self {\n    // 將串列元素原封不動新增進堆積\n    let mut heap = MaxHeap { max_heap: nums };\n    // 堆積化除葉節點以外的其他所有節點\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\n}\n</code></pre> my_heap.c<pre><code>/* 建構子，根據切片建堆積 */\nMaxHeap *newMaxHeap(int nums[], int size) {\n    // 所有元素入堆積\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap-&gt;size = size;\n    memcpy(maxHeap-&gt;data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i &gt;= 0; i--) {\n        // 堆積化除葉節點以外的其他所有節點\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n</code></pre> my_heap.kt<pre><code>/* 大頂堆積 */\nclass MaxHeap(nums: MutableList&lt;Int&gt;?) {\n    // 使用串列而非陣列，這樣無須考慮擴容問題\n    private val maxHeap = mutableListOf&lt;Int&gt;()\n\n    /* 建構子，根據輸入串列建堆積 */\n    init {\n        // 將串列元素原封不動新增進堆積\n        maxHeap.addAll(nums!!)\n        // 堆積化除葉節點以外的其他所有節點\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* 獲取左子節點的索引 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 獲取右子節點的索引 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 獲取父節點的索引 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // 向下整除\n    }\n\n    /* 交換元素 */\n    private fun swap(i: Int, j: Int) {\n        val temp = maxHeap[i]\n        maxHeap[i] = maxHeap[j]\n        maxHeap[j] = temp\n    }\n\n    /* 獲取堆積大小 */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* 判斷堆積是否為空 */\n    fun isEmpty(): Boolean {\n        /* 判斷堆積是否為空 */\n        return size() == 0\n    }\n\n    /* 訪問堆積頂元素 */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* 元素入堆積 */\n    fun push(_val: Int) {\n        // 新增節點\n        maxHeap.add(_val)\n        // 從底至頂堆積化\n        siftUp(size() - 1)\n    }\n\n    /* 從節點 i 開始，從底至頂堆積化 */\n    private fun siftUp(it: Int) {\n        // Kotlin的函式參數不可變，因此建立臨時變數\n        var i = it\n        while (true) {\n            // 獲取節點 i 的父節點\n            val p = parent(i)\n            // 當“越過根節點”或“節點無須修復”時，結束堆積化\n            if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n            // 交換兩節點\n            swap(i, p)\n            // 迴圈向上堆積化\n            i = p\n        }\n    }\n\n    /* 元素出堆積 */\n    fun pop(): Int {\n        // 判空處理\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        swap(0, size() - 1)\n        // 刪除節點\n        val _val = maxHeap.removeAt(size() - 1)\n        // 從頂至底堆積化\n        siftDown(0)\n        // 返回堆積頂元素\n        return _val\n    }\n\n    /* 從節點 i 開始，從頂至底堆積化 */\n    private fun siftDown(it: Int) {\n        // Kotlin的函式參數不可變，因此建立臨時變數\n        var i = it\n        while (true) {\n            // 判斷節點 i, l, r 中值最大的節點，記為 ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n            if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n            // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n            if (ma == i) break\n            // 交換兩節點\n            swap(i, ma)\n            // 迴圈向下堆積化\n            i = ma\n        }\n    }\n\n    /* 列印堆積（二元樹） */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -&gt; b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 建構子，根據輸入串列建堆積 ###\ndef initialize(nums)\n  # 將串列元素原封不動新增進堆積\n  @max_heap = nums\n  # 堆積化除葉節點以外的其他所有節點\n  parent(size - 1).downto(0) do |i|\n    sift_down(i)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/build_heap/#823","level":2,"title":"8.2.3   複雜度分析","text":"<p>下面，我們來嘗試推算第二種建堆積方法的時間複雜度。</p> <ul> <li>假設完全二元樹的節點數量為 \\(n\\) ，則葉節點數量為 \\((n + 1) / 2\\) ，其中 \\(/\\) 為向下整除。因此需要堆積化的節點數量為 \\((n - 1) / 2\\) 。</li> <li>在從頂至底堆積化的過程中，每個節點最多堆積化到葉節點，因此最大迭代次數為二元樹高度 \\(\\log n\\) 。</li> </ul> <p>將上述兩者相乘，可得到建堆積過程的時間複雜度為 \\(O(n \\log n)\\) 。但這個估算結果並不準確，因為我們沒有考慮到二元樹底層節點數量遠多於頂層節點的性質。</p> <p>接下來我們來進行更為準確的計算。為了降低計算難度，假設給定一個節點數量為 \\(n\\) 、高度為 \\(h\\) 的“完美二元樹”，該假設不會影響計算結果的正確性。</p> <p></p> <p> 圖 8-5   完美二元樹的各層節點數量 </p> <p>如圖 8-5 所示，節點“從頂至底堆積化”的最大迭代次數等於該節點到葉節點的距離，而該距離正是“節點高度”。因此，我們可以對各層的“節點數量 \\(\\times\\) 節點高度”求和，得到所有節點的堆積化迭代次數的總和。</p> \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\] <p>化簡上式需要藉助中學的數列知識，先將 \\(T(h)\\) 乘以 \\(2\\) ，得到：</p> \\[ \\begin{aligned} T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\] <p>使用錯位相減法，用下式 \\(2 T(h)\\) 減去上式 \\(T(h)\\) ，可得：</p> \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\] <p>觀察上式，發現 \\(T(h)\\) 是一個等比數列，可直接使用求和公式，得到時間複雜度為：</p> \\[ \\begin{aligned} T(h) &amp; = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline &amp; = 2^{h+1} - h - 2 \\newline &amp; = O(2^h) \\end{aligned} \\] <p>進一步，高度為 \\(h\\) 的完美二元樹的節點數量為 \\(n = 2^{h+1} - 1\\) ，易得複雜度為 \\(O(2^h) = O(n)\\) 。以上推算表明，輸入串列並建堆積的時間複雜度為 \\(O(n)\\) ，非常高效。</p>","path":["第 8 章 &nbsp; 堆積","8.2 &nbsp; 建堆積操作"],"tags":[]},{"location":"chapter_heap/heap/","level":1,"title":"8.1   堆積","text":"<p>堆積（heap）是一種滿足特定條件的完全二元樹，主要可分為兩種型別，如圖 8-1 所示。</p> <ul> <li>小頂堆積（min heap）：任意節點的值 \\(\\leq\\) 其子節點的值。</li> <li>大頂堆積（max heap）：任意節點的值 \\(\\geq\\) 其子節點的值。</li> </ul> <p></p> <p> 圖 8-1   小頂堆積與大頂堆積 </p> <p>堆積作為完全二元樹的一個特例，具有以下特性。</p> <ul> <li>最底層節點靠左填充，其他層的節點都被填滿。</li> <li>我們將二元樹的根節點稱為“堆積頂”，將底層最靠右的節點稱為“堆積底”。</li> <li>對於大頂堆積（小頂堆積），堆積頂元素（根節點）的值是最大（最小）的。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#811","level":2,"title":"8.1.1   堆積的常用操作","text":"<p>需要指出的是，許多程式語言提供的是優先佇列（priority queue），這是一種抽象的資料結構，定義為具有優先順序排序的佇列。</p> <p>實際上，堆積通常用於實現優先佇列，大頂堆積相當於元素按從大到小的順序出列的優先佇列。從使用角度來看，我們可以將“優先佇列”和“堆積”看作等價的資料結構。因此，本書對兩者不做特別區分，統一稱作“堆積”。</p> <p>堆積的常用操作見表 8-1 ，方法名需要根據程式語言來確定。</p> <p> 表 8-1   堆積的操作效率 </p> 方法名 描述 時間複雜度 <code>push()</code> 元素入堆積 \\(O(\\log n)\\) <code>pop()</code> 堆積頂元素出堆積 \\(O(\\log n)\\) <code>peek()</code> 訪問堆積頂元素（對於大 / 小頂堆積分別為最大 / 小值） \\(O(1)\\) <code>size()</code> 獲取堆積的元素數量 \\(O(1)\\) <code>isEmpty()</code> 判斷堆積是否為空 \\(O(1)\\) <p>在實際應用中，我們可以直接使用程式語言提供的堆積類別（或優先佇列類別）。</p> <p>類似於排序演算法中的“從小到大排列”和“從大到小排列”，我們可以透過設定一個 <code>flag</code> 或修改 <code>Comparator</code> 實現“小頂堆積”與“大頂堆積”之間的轉換。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap.py<pre><code># 初始化小頂堆積\nmin_heap, flag = [], 1\n# 初始化大頂堆積\nmax_heap, flag = [], -1\n\n# Python 的 heapq 模組預設實現小頂堆積\n# 考慮將“元素取負”後再入堆積，這樣就可以將大小關係顛倒，從而實現大頂堆積\n# 在本示例中，flag = 1 時對應小頂堆積，flag = -1 時對應大頂堆積\n\n# 元素入堆積\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n\n# 獲取堆積頂元素\npeek: int = flag * max_heap[0] # 5\n\n# 堆積頂元素出堆積\n# 出堆積元素會形成一個從大到小的序列\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n\n# 獲取堆積大小\nsize: int = len(max_heap)\n\n# 判斷堆積是否為空\nis_empty: bool = not max_heap\n\n# 輸入串列並建堆積\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n</code></pre> heap.cpp<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap;\n// 初始化大頂堆積\npriority_queue&lt;int, vector&lt;int&gt;, less&lt;int&gt;&gt; maxHeap;\n\n/* 元素入堆積 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.top(); // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.size();\n\n/* 判斷堆積是否為空 */\nbool isEmpty = maxHeap.empty();\n\n/* 輸入串列並建堆積 */\nvector&lt;int&gt; input{1, 3, 2, 5, 4};\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; minHeap(input.begin(), input.end());\n</code></pre> heap.java<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nQueue&lt;Integer&gt; minHeap = new PriorityQueue&lt;&gt;();\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparator 即可）\nQueue&lt;Integer&gt; maxHeap = new PriorityQueue&lt;&gt;((a, b) -&gt; b - a);\n\n/* 元素入堆積 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.peek(); // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.size();\n\n/* 判斷堆積是否為空 */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* 輸入串列並建堆積 */\nminHeap = new PriorityQueue&lt;&gt;(Arrays.asList(1, 3, 2, 5, 4));\n</code></pre> heap.cs<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nPriorityQueue&lt;int, int&gt; minHeap = new();\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparer 即可）\nPriorityQueue&lt;int, int&gt; maxHeap = new(Comparer&lt;int&gt;.Create((x, y) =&gt; y.CompareTo(x)));\n\n/* 元素入堆積 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n\n/* 獲取堆積頂元素 */\nint peek = maxHeap.Peek();//5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n\n/* 獲取堆積大小 */\nint size = maxHeap.Count;\n\n/* 判斷堆積是否為空 */\nbool isEmpty = maxHeap.Count == 0;\n\n/* 輸入串列並建堆積 */\nminHeap = new PriorityQueue&lt;int, int&gt;([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\n</code></pre> heap.go<pre><code>// Go 語言中可以透過實現 heap.Interface 來構建整數大頂堆積\n// 實現 heap.Interface 需要同時實現 sort.Interface\ntype intHeap []any\n\n// Push heap.Interface 的方法，實現推入元素到堆積\nfunc (h *intHeap) Push(x any) {\n    // Push 和 Pop 使用 pointer receiver 作為參數\n    // 因為它們不僅會對切片的內容進行調整，還會修改切片的長度。\n    *h = append(*h, x.(int))\n}\n\n// Pop heap.Interface 的方法，實現彈出堆積頂元素\nfunc (h *intHeap) Pop() any {\n    // 待出堆積元素存放在最後\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len sort.Interface 的方法\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\n\n// Less sort.Interface 的方法\nfunc (h *intHeap) Less(i, j int) bool {\n    // 如果實現小頂堆積，則需要調整為小於號\n    return (*h)[i].(int) &gt; (*h)[j].(int)\n}\n\n// Swap sort.Interface 的方法\nfunc (h *intHeap) Swap(i, j int) {\n    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n\n// Top 獲取堆積頂元素\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* 初始化堆積 */\n    // 初始化大頂堆積\n    maxHeap := &amp;intHeap{}\n    heap.Init(maxHeap)\n    /* 元素入堆積 */\n    // 呼叫 heap.Interface 的方法，來新增元素\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* 獲取堆積頂元素 */\n    top := maxHeap.Top()\n    fmt.Printf(\"堆積頂元素為 %d\\n\", top)\n\n    /* 堆積頂元素出堆積 */\n    // 呼叫 heap.Interface 的方法，來移除元素\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* 獲取堆積大小 */\n    size := len(*maxHeap)\n    fmt.Printf(\"堆積元素數量為 %d\\n\", size)\n\n    /* 判斷堆積是否為空 */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"堆積是否為空 %t\\n\", isEmpty)\n}\n</code></pre> heap.swift<pre><code>/* 初始化堆積 */\n// Swift 的 Heap 型別同時支持最大堆積和最小堆積，且需要引入 swift-collections\nvar heap = Heap&lt;Int&gt;()\n\n/* 元素入堆積 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* 獲取堆積頂元素 */\nvar peek = heap.max()!\n\n/* 堆積頂元素出堆積 */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* 獲取堆積大小 */\nlet size = heap.count\n\n/* 判斷堆積是否為空 */\nlet isEmpty = heap.isEmpty\n\n/* 輸入串列並建堆積 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n</code></pre> heap.js<pre><code>// JavaScript 未提供內建 Heap 類別\n</code></pre> heap.ts<pre><code>// TypeScript 未提供內建 Heap 類別\n</code></pre> heap.dart<pre><code>// Dart 未提供內建 Heap 類別\n</code></pre> heap.rs<pre><code>use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* 初始化堆積 */\n// 初始化小頂堆積\nlet mut min_heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n// 初始化大頂堆積\nlet mut max_heap = BinaryHeap::new();\n\n/* 元素入堆積 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* 獲取堆積頂元素 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* 獲取堆積大小 */\nlet size = max_heap.len();\n\n/* 判斷堆積是否為空 */\nlet is_empty = max_heap.is_empty();\n\n/* 輸入串列並建堆積 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n</code></pre> heap.c<pre><code>// C 未提供內建 Heap 類別\n</code></pre> heap.kt<pre><code>/* 初始化堆積 */\n// 初始化小頂堆積\nvar minHeap = PriorityQueue&lt;Int&gt;()\n// 初始化大頂堆積（使用 lambda 表示式修改 Comparator 即可）\nval maxHeap = PriorityQueue { a: Int, b: Int -&gt; b - a }\n\n/* 元素入堆積 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* 獲取堆積頂元素 */\nvar peek = maxHeap.peek() // 5\n\n/* 堆積頂元素出堆積 */\n// 出堆積元素會形成一個從大到小的序列\npeek = maxHeap.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* 獲取堆積大小 */\nval size = maxHeap.size\n\n/* 判斷堆積是否為空 */\nval isEmpty = maxHeap.isEmpty()\n\n/* 輸入串列並建堆積 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n</code></pre> heap.rb<pre><code># Ruby 未提供內建 Heap 類別\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#812","level":2,"title":"8.1.2   堆積的實現","text":"<p>下文實現的是大頂堆積。若要將其轉換為小頂堆積，只需將所有大小邏輯判斷進行逆轉（例如，將 \\(\\geq\\) 替換為 \\(\\leq\\) ）。感興趣的讀者可以自行實現。</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#1","level":3,"title":"1.   堆積的儲存與表示","text":"<p>“二元樹”章節講過，完全二元樹非常適合用陣列來表示。由於堆積正是一種完全二元樹，因此我們將採用陣列來儲存堆積。</p> <p>當使用陣列表示二元樹時，元素代表節點值，索引代表節點在二元樹中的位置。節點指標透過索引對映公式來實現。</p> <p>如圖 8-2 所示，給定索引 \\(i\\) ，其左子節點的索引為 \\(2i + 1\\) ，右子節點的索引為 \\(2i + 2\\) ，父節點的索引為 \\((i - 1) / 2\\)（向下整除）。當索引越界時，表示空節點或節點不存在。</p> <p></p> <p> 圖 8-2   堆積的表示與儲存 </p> <p>我們可以將索引對映公式封裝成函式，方便後續使用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def left(self, i: int) -&gt; int:\n    \"\"\"獲取左子節點的索引\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -&gt; int:\n    \"\"\"獲取右子節點的索引\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -&gt; int:\n    \"\"\"獲取父節點的索引\"\"\"\n    return (i - 1) // 2  # 向下整除\n</code></pre> my_heap.cpp<pre><code>/* 獲取左子節點的索引 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.java<pre><code>/* 獲取左子節點的索引 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.cs<pre><code>/* 獲取左子節點的索引 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint Parent(int i) {\n    return (i - 1) / 2; // 向下整除\n}\n</code></pre> my_heap.go<pre><code>/* 獲取左子節點的索引 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* 獲取右子節點的索引 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* 獲取父節點的索引 */\nfunc (h *maxHeap) parent(i int) int {\n    // 向下整除\n    return (i - 1) / 2\n}\n</code></pre> my_heap.swift<pre><code>/* 獲取左子節點的索引 */\nfunc left(i: Int) -&gt; Int {\n    2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfunc right(i: Int) -&gt; Int {\n    2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfunc parent(i: Int) -&gt; Int {\n    (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.js<pre><code>/* 獲取左子節點的索引 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // 向下整除\n}\n</code></pre> my_heap.ts<pre><code>/* 獲取左子節點的索引 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // 向下整除\n}\n</code></pre> my_heap.dart<pre><code>/* 獲取左子節點的索引 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // 向下整除\n}\n</code></pre> my_heap.rs<pre><code>/* 獲取左子節點的索引 */\nfn left(i: usize) -&gt; usize {\n    2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfn right(i: usize) -&gt; usize {\n    2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfn parent(i: usize) -&gt; usize {\n    (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.c<pre><code>/* 獲取左子節點的索引 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* 獲取右子節點的索引 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* 獲取父節點的索引 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2; // 向下取整\n}\n</code></pre> my_heap.kt<pre><code>/* 獲取左子節點的索引 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* 獲取右子節點的索引 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* 獲取父節點的索引 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // 向下整除\n}\n</code></pre> my_heap.rb<pre><code>### 獲取左子節點的索引 ###\ndef left(i)\n  2 * i + 1\nend\n\n### 獲取右子節點的索引 ###\ndef right(i)\n  2 * i + 2\nend\n\n### 獲取父節點的索引 ###\ndef parent(i)\n  (i - 1) / 2     # 向下整除\nend\n</code></pre>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#2","level":3,"title":"2.   訪問堆積頂元素","text":"<p>堆積頂元素即為二元樹的根節點，也就是串列的首個元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def peek(self) -&gt; int:\n    \"\"\"訪問堆積頂元素\"\"\"\n    return self.max_heap[0]\n</code></pre> my_heap.cpp<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.java<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n    return maxHeap.get(0);\n}\n</code></pre> my_heap.cs<pre><code>/* 訪問堆積頂元素 */\nint Peek() {\n    return maxHeap[0];\n}\n</code></pre> my_heap.go<pre><code>/* 訪問堆積頂元素 */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n</code></pre> my_heap.swift<pre><code>/* 訪問堆積頂元素 */\nfunc peek() -&gt; Int {\n    maxHeap[0]\n}\n</code></pre> my_heap.js<pre><code>/* 訪問堆積頂元素 */\npeek() {\n    return this.#maxHeap[0];\n}\n</code></pre> my_heap.ts<pre><code>/* 訪問堆積頂元素 */\npeek(): number {\n    return this.maxHeap[0];\n}\n</code></pre> my_heap.dart<pre><code>/* 訪問堆積頂元素 */\nint peek() {\n  return _maxHeap[0];\n}\n</code></pre> my_heap.rs<pre><code>/* 訪問堆積頂元素 */\nfn peek(&amp;self) -&gt; Option&lt;i32&gt; {\n    self.max_heap.first().copied()\n}\n</code></pre> my_heap.c<pre><code>/* 訪問堆積頂元素 */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap-&gt;data[0];\n}\n</code></pre> my_heap.kt<pre><code>/* 訪問堆積頂元素 */\nfun peek(): Int {\n    return maxHeap[0]\n}\n</code></pre> my_heap.rb<pre><code>### 訪問堆積頂元素 ###\ndef peek\n  @max_heap[0]\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#3","level":3,"title":"3.   元素入堆積","text":"<p>給定元素 <code>val</code> ，我們首先將其新增到堆積底。新增之後，由於 <code>val</code> 可能大於堆積中其他元素，堆積的成立條件可能已被破壞，因此需要修復從插入節點到根節點的路徑上的各個節點，這個操作被稱為堆積化（heapify）。</p> <p>考慮從入堆積節點開始，從底至頂執行堆積化。如圖 8-3 所示，我們比較插入節點與其父節點的值，如果插入節點更大，則將它們交換。然後繼續執行此操作，從底至頂修復堆積中的各個節點，直至越過根節點或遇到無須交換的節點時結束。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-3   元素入堆積步驟 </p> <p>設節點總數為 \\(n\\) ，則樹的高度為 \\(O(\\log n)\\) 。由此可知，堆積化操作的迴圈輪數最多為 \\(O(\\log n)\\) ，元素入堆積操作的時間複雜度為 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def push(self, val: int):\n    \"\"\"元素入堆積\"\"\"\n    # 新增節點\n    self.max_heap.append(val)\n    # 從底至頂堆積化\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"從節點 i 開始，從底至頂堆積化\"\"\"\n    while True:\n        # 獲取節點 i 的父節點\n        p = self.parent(i)\n        # 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 or self.max_heap[i] &lt;= self.max_heap[p]:\n            break\n        # 交換兩節點\n        self.swap(i, p)\n        # 迴圈向上堆積化\n        i = p\n</code></pre> my_heap.cpp<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n    // 新增節點\n    maxHeap.push_back(val);\n    // 從底至頂堆積化\n    siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 交換兩節點\n        swap(maxHeap[i], maxHeap[p]);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n    // 新增節點\n    maxHeap.add(val);\n    // 從底至頂堆積化\n    siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap.get(i) &lt;= maxHeap.get(p))\n            break;\n        // 交換兩節點\n        swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 元素入堆積 */\nvoid Push(int val) {\n    // 新增節點\n    maxHeap.Add(val);\n    // 從底至頂堆積化\n    SiftUp(Size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid SiftUp(int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = Parent(i);\n        // 若“越過根節點”或“節點無須修復”，則結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p])\n            break;\n        // 交換兩節點\n        Swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 元素入堆積 */\nfunc (h *maxHeap) push(val any) {\n    // 新增節點\n    h.data = append(h.data, val)\n    // 從底至頂堆積化\n    h.siftUp(len(h.data) - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // 獲取節點 i 的父節點\n        p := h.parent(i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 || h.data[i].(int) &lt;= h.data[p].(int) {\n            break\n        }\n        // 交換兩節點\n        h.swap(i, p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 元素入堆積 */\nfunc push(val: Int) {\n    // 新增節點\n    maxHeap.append(val)\n    // 從底至頂堆積化\n    siftUp(i: size() - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // 獲取節點 i 的父節點\n        let p = parent(i: i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if p &lt; 0 || maxHeap[i] &lt;= maxHeap[p] {\n            break\n        }\n        // 交換兩節點\n        swap(i: i, j: p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 元素入堆積 */\npush(val) {\n    // 新增節點\n    this.#maxHeap.push(val);\n    // 從底至頂堆積化\n    this.#siftUp(this.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\n#siftUp(i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        const p = this.#parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || this.#maxHeap[i] &lt;= this.#maxHeap[p]) break;\n        // 交換兩節點\n        this.#swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 元素入堆積 */\npush(val: number): void {\n    // 新增節點\n    this.maxHeap.push(val);\n    // 從底至頂堆積化\n    this.siftUp(this.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nsiftUp(i: number): void {\n    while (true) {\n        // 獲取節點 i 的父節點\n        const p = this.parent(i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || this.maxHeap[i] &lt;= this.maxHeap[p]) break;\n        // 交換兩節點\n        this.swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 元素入堆積 */\nvoid push(int val) {\n  // 新增節點\n  _maxHeap.add(val);\n  // 從底至頂堆積化\n  siftUp(size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(int i) {\n  while (true) {\n    // 獲取節點 i 的父節點\n    int p = _parent(i);\n    // 當“越過根節點”或“節點無須修復”時，結束堆積化\n    if (p &lt; 0 || _maxHeap[i] &lt;= _maxHeap[p]) {\n      break;\n    }\n    // 交換兩節點\n    _swap(i, p);\n    // 迴圈向上堆積化\n    i = p;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 元素入堆積 */\nfn push(&amp;mut self, val: i32) {\n    // 新增節點\n    self.max_heap.push(val);\n    // 從底至頂堆積化\n    self.sift_up(self.size() - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfn sift_up(&amp;mut self, mut i: usize) {\n    loop {\n        // 節點 i 已經是堆積頂節點了，結束堆積化\n        if i == 0 {\n            break;\n        }\n        // 獲取節點 i 的父節點\n        let p = Self::parent(i);\n        // 當“節點無須修復”時，結束堆積化\n        if self.max_heap[i] &lt;= self.max_heap[p] {\n            break;\n        }\n        // 交換兩節點\n        self.swap(i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 元素入堆積 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // 預設情況下，不應該新增這麼多節點\n    if (maxHeap-&gt;size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // 新增節點\n    maxHeap-&gt;data[maxHeap-&gt;size] = val;\n    maxHeap-&gt;size++;\n\n    // 從底至頂堆積化\n    siftUp(maxHeap, maxHeap-&gt;size - 1);\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // 獲取節點 i 的父節點\n        int p = parent(maxHeap, i);\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap-&gt;data[i] &lt;= maxHeap-&gt;data[p]) {\n            break;\n        }\n        // 交換兩節點\n        swap(maxHeap, i, p);\n        // 迴圈向上堆積化\n        i = p;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 元素入堆積 */\nfun push(_val: Int) {\n    // 新增節點\n    maxHeap.add(_val)\n    // 從底至頂堆積化\n    siftUp(size() - 1)\n}\n\n/* 從節點 i 開始，從底至頂堆積化 */\nfun siftUp(it: Int) {\n    // Kotlin的函式參數不可變，因此建立臨時變數\n    var i = it\n    while (true) {\n        // 獲取節點 i 的父節點\n        val p = parent(i)\n        // 當“越過根節點”或“節點無須修復”時，結束堆積化\n        if (p &lt; 0 || maxHeap[i] &lt;= maxHeap[p]) break\n        // 交換兩節點\n        swap(i, p)\n        // 迴圈向上堆積化\n        i = p\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 元素入堆積 ###\ndef push(val)\n  # 新增節點\n  @max_heap &lt;&lt; val\n  # 從底至頂堆積化\n  sift_up(size - 1)\nend\n\n### 從節點 i 開始，從底至頂堆積化 ###\ndef sift_up(i)\n  loop do\n    # 獲取節點 i 的父節點\n    p = parent(i)\n    # 當“越過根節點”或“節點無須修復”時，結束堆積化\n    break if p &lt; 0 || @max_heap[i] &lt;= @max_heap[p]\n    # 交換兩節點\n    swap(i, p)\n    # 迴圈向上堆積化\n    i = p\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#4","level":3,"title":"4.   堆積頂元素出堆積","text":"<p>堆積頂元素是二元樹的根節點，即串列首元素。如果我們直接從串列中刪除首元素，那麼二元樹中所有節點的索引都會發生變化，這將使得後續使用堆積化進行修復變得困難。為了儘量減少元素索引的變動，我們採用以下操作步驟。</p> <ol> <li>交換堆積頂元素與堆積底元素（交換根節點與最右葉節點）。</li> <li>交換完成後，將堆積底從串列中刪除（注意，由於已經交換，因此實際上刪除的是原來的堆積頂元素）。</li> <li>從根節點開始，從頂至底執行堆積化。</li> </ol> <p>如圖 8-4 所示，“從頂至底堆積化”的操作方向與“從底至頂堆積化”相反，我們將根節點的值與其兩個子節點的值進行比較，將最大的子節點與根節點交換。然後迴圈執行此操作，直到越過葉節點或遇到無須交換的節點時結束。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-4   堆積頂元素出堆積步驟 </p> <p>與元素入堆積操作相似，堆積頂元素出堆積操作的時間複雜度也為 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby my_heap.py<pre><code>def pop(self) -&gt; int:\n    \"\"\"元素出堆積\"\"\"\n    # 判空處理\n    if self.is_empty():\n        raise IndexError(\"堆積為空\")\n    # 交換根節點與最右葉節點（交換首元素與尾元素）\n    self.swap(0, self.size() - 1)\n    # 刪除節點\n    val = self.max_heap.pop()\n    # 從頂至底堆積化\n    self.sift_down(0)\n    # 返回堆積頂元素\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"從節點 i 開始，從頂至底堆積化\"\"\"\n    while True:\n        # 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l &lt; self.size() and self.max_heap[l] &gt; self.max_heap[ma]:\n            ma = l\n        if r &lt; self.size() and self.max_heap[r] &gt; self.max_heap[ma]:\n            ma = r\n        # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i:\n            break\n        # 交換兩節點\n        self.swap(i, ma)\n        # 迴圈向下堆積化\n        i = ma\n</code></pre> my_heap.cpp<pre><code>/* 元素出堆積 */\nvoid pop() {\n    // 判空處理\n    if (isEmpty()) {\n        throw out_of_range(\"堆積為空\");\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // 刪除節點\n    maxHeap.pop_back();\n    // 從頂至底堆積化\n    siftDown(0);\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.java<pre><code>/* 元素出堆積 */\nint pop() {\n    // 判空處理\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(0, size() - 1);\n    // 刪除節點\n    int val = maxHeap.remove(size() - 1);\n    // 從頂至底堆積化\n    siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = left(i), r = right(i), ma = i;\n        if (l &lt; size() &amp;&amp; maxHeap.get(l) &gt; maxHeap.get(ma))\n            ma = l;\n        if (r &lt; size() &amp;&amp; maxHeap.get(r) &gt; maxHeap.get(ma))\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.cs<pre><code>/* 元素出堆積 */\nint Pop() {\n    // 判空處理\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    Swap(0, Size() - 1);\n    // 刪除節點\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // 從頂至底堆積化\n    SiftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid SiftDown(int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l &lt; Size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma])\n            ma = l;\n        if (r &lt; Size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma])\n            ma = r;\n        // 若“節點 i 最大”或“越過葉節點”，則結束堆積化\n        if (ma == i) break;\n        // 交換兩節點\n        Swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.go<pre><code>/* 元素出堆積 */\nfunc (h *maxHeap) pop() any {\n    // 判空處理\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    h.swap(0, h.size()-1)\n    // 刪除節點\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // 從頂至底堆積化\n    h.siftDown(0)\n\n    // 返回堆積頂元素\n    return val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 max\n        l, r, max := h.left(i), h.right(i), i\n        if l &lt; h.size() &amp;&amp; h.data[l].(int) &gt; h.data[max].(int) {\n            max = l\n        }\n        if r &lt; h.size() &amp;&amp; h.data[r].(int) &gt; h.data[max].(int) {\n            max = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if max == i {\n            break\n        }\n        // 交換兩節點\n        h.swap(i, max)\n        // 迴圈向下堆積化\n        i = max\n    }\n}\n</code></pre> my_heap.swift<pre><code>/* 元素出堆積 */\nfunc pop() -&gt; Int {\n    // 判空處理\n    if isEmpty() {\n        fatalError(\"堆積為空\")\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(i: 0, j: size() - 1)\n    // 刪除節點\n    let val = maxHeap.remove(at: size() - 1)\n    // 從頂至底堆積化\n    siftDown(i: 0)\n    // 返回堆積頂元素\n    return val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l &lt; size(), maxHeap[l] &gt; maxHeap[ma] {\n            ma = l\n        }\n        if r &lt; size(), maxHeap[r] &gt; maxHeap[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        swap(i: i, j: ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n</code></pre> my_heap.js<pre><code>/* 元素出堆積 */\npop() {\n    // 判空處理\n    if (this.isEmpty()) throw new Error('堆積為空');\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    this.#swap(0, this.size() - 1);\n    // 刪除節點\n    const val = this.#maxHeap.pop();\n    // 從頂至底堆積化\n    this.#siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\n#siftDown(i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.#maxHeap[l] &gt; this.#maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.#maxHeap[r] &gt; this.#maxHeap[ma]) ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) break;\n        // 交換兩節點\n        this.#swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.ts<pre><code>/* 元素出堆積 */\npop(): number {\n    // 判空處理\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    this.swap(0, this.size() - 1);\n    // 刪除節點\n    const val = this.maxHeap.pop();\n    // 從頂至底堆積化\n    this.siftDown(0);\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nsiftDown(i: number): void {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l &lt; this.size() &amp;&amp; this.maxHeap[l] &gt; this.maxHeap[ma]) ma = l;\n        if (r &lt; this.size() &amp;&amp; this.maxHeap[r] &gt; this.maxHeap[ma]) ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) break;\n        // 交換兩節點\n        this.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.dart<pre><code>/* 元素出堆積 */\nint pop() {\n  // 判空處理\n  if (isEmpty()) throw Exception('堆積為空');\n  // 交換根節點與最右葉節點（交換首元素與尾元素）\n  _swap(0, size() - 1);\n  // 刪除節點\n  int val = _maxHeap.removeLast();\n  // 從頂至底堆積化\n  siftDown(0);\n  // 返回堆積頂元素\n  return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int i) {\n  while (true) {\n    // 判斷節點 i, l, r 中值最大的節點，記為 ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l &lt; size() &amp;&amp; _maxHeap[l] &gt; _maxHeap[ma]) ma = l;\n    if (r &lt; size() &amp;&amp; _maxHeap[r] &gt; _maxHeap[ma]) ma = r;\n    // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    if (ma == i) break;\n    // 交換兩節點\n    _swap(i, ma);\n    // 迴圈向下堆積化\n    i = ma;\n  }\n}\n</code></pre> my_heap.rs<pre><code>/* 元素出堆積 */\nfn pop(&amp;mut self) -&gt; i32 {\n    // 判空處理\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    self.swap(0, self.size() - 1);\n    // 刪除節點\n    let val = self.max_heap.pop().unwrap();\n    // 從頂至底堆積化\n    self.sift_down(0);\n    // 返回堆積頂元素\n    val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfn sift_down(&amp;mut self, mut i: usize) {\n    loop {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l &lt; self.size() &amp;&amp; self.max_heap[l] &gt; self.max_heap[ma] {\n            ma = l;\n        }\n        if r &lt; self.size() &amp;&amp; self.max_heap[r] &gt; self.max_heap[ma] {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break;\n        }\n        // 交換兩節點\n        self.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n</code></pre> my_heap.c<pre><code>/* 元素出堆積 */\nint pop(MaxHeap *maxHeap) {\n    // 判空處理\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // 刪除節點\n    int val = maxHeap-&gt;data[maxHeap-&gt;size - 1];\n    maxHeap-&gt;size--;\n    // 從頂至底堆積化\n    siftDown(maxHeap, 0);\n\n    // 返回堆積頂元素\n    return val;\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[l] &gt; maxHeap-&gt;data[max]) {\n            max = l;\n        }\n        if (r &lt; size(maxHeap) &amp;&amp; maxHeap-&gt;data[r] &gt; maxHeap-&gt;data[max]) {\n            max = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (max == i) {\n            break;\n        }\n        // 交換兩節點\n        swap(maxHeap, i, max);\n        // 迴圈向下堆積化\n        i = max;\n    }\n}\n</code></pre> my_heap.kt<pre><code>/* 元素出堆積 */\nfun pop(): Int {\n    // 判空處理\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    swap(0, size() - 1)\n    // 刪除節點\n    val _val = maxHeap.removeAt(size() - 1)\n    // 從頂至底堆積化\n    siftDown(0)\n    // 返回堆積頂元素\n    return _val\n}\n\n/* 從節點 i 開始，從頂至底堆積化 */\nfun siftDown(it: Int) {\n    // Kotlin的函式參數不可變，因此建立臨時變數\n    var i = it\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l &lt; size() &amp;&amp; maxHeap[l] &gt; maxHeap[ma]) ma = l\n        if (r &lt; size() &amp;&amp; maxHeap[r] &gt; maxHeap[ma]) ma = r\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) break\n        // 交換兩節點\n        swap(i, ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n</code></pre> my_heap.rb<pre><code>### 元素出堆積 ###\ndef pop\n  # 判空處理\n  raise IndexError, \"堆積為空\" if is_empty?\n  # 交換根節點與最右葉節點（交換首元素與尾元素）\n  swap(0, size - 1)\n  # 刪除節點\n  val = @max_heap.pop\n  # 從頂至底堆積化\n  sift_down(0)\n  # 返回堆積頂元素\n  val\nend\n\n### 從節點 i 開始，從頂至底堆積化 ###\ndef sift_down(i)\n  loop do\n    # 判斷節點 i, l, r 中值最大的節點，記為 ma\n    l, r, ma = left(i), right(i), i\n    ma = l if l &lt; size &amp;&amp; @max_heap[l] &gt; @max_heap[ma]\n    ma = r if r &lt; size &amp;&amp; @max_heap[r] &gt; @max_heap[ma]\n\n    # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    break if ma == i\n\n    # 交換兩節點\n    swap(i, ma)\n    # 迴圈向下堆積化\n    i = ma\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/heap/#813","level":2,"title":"8.1.3   堆積的常見應用","text":"<ul> <li>優先佇列：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 \\(O(\\log n)\\) ，而建堆積操作為 \\(O(n)\\) ，這些操作都非常高效。</li> <li>堆積排序：給定一組資料，我們可以用它們建立一個堆積，然後不斷地執行元素出堆積操作，從而得到有序資料。然而，我們通常會使用一種更優雅的方式實現堆積排序，詳見“堆積排序”章節。</li> <li>獲取最大的 \\(k\\) 個元素：這是一個經典的演算法問題，同時也是一種典型應用，例如選擇熱度前 10 的新聞作為微博熱搜，選取銷量前 10 的商品等。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.1 &nbsp; 堆積"],"tags":[]},{"location":"chapter_heap/summary/","level":1,"title":"8.4   小結","text":"","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>堆積是一棵完全二元樹，根據成立條件可分為大頂堆積和小頂堆積。大（小）頂堆積的堆積頂元素是最大（小）的。</li> <li>優先佇列的定義是具有出列優先順序的佇列，通常使用堆積來實現。</li> <li>堆積的常用操作及其對應的時間複雜度包括：元素入堆積 \\(O(\\log n)\\)、堆積頂元素出堆積 \\(O(\\log n)\\) 和訪問堆積頂元素 \\(O(1)\\) 等。</li> <li>完全二元樹非常適合用陣列表示，因此我們通常使用陣列來儲存堆積。</li> <li>堆積化操作用於維護堆積的性質，在入堆積和出堆積操作中都會用到。</li> <li>輸入 \\(n\\) 個元素並建堆積的時間複雜度可以最佳化至 \\(O(n)\\) ，非常高效。</li> <li>Top-k 是一個經典演算法問題，可以使用堆積資料結構高效解決，時間複雜度為 \\(O(n \\log k)\\) 。</li> </ul>","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：資料結構的“堆積”與記憶體管理的“堆積”是同一個概念嗎？</p> <p>兩者不是同一個概念，只是碰巧都叫“堆積”。計算機系統記憶體中的堆積是動態記憶體分配的一部分，程式在執行時可以使用它來儲存資料。程式可以請求一定量的堆積記憶體，用於儲存如物件和陣列等複雜結構。當這些資料不再需要時，程式需要釋放這些記憶體，以防止記憶體流失。相較於堆疊記憶體，堆積記憶體的管理和使用需要更謹慎，使用不當可能會導致記憶體流失和野指標等問題。</p>","path":["第 8 章 &nbsp; 堆積","8.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_heap/top_k/","level":1,"title":"8.3   Top-k 問題","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的無序陣列 <code>nums</code> ，請返回陣列中最大的 \\(k\\) 個元素。</p> <p>對於該問題，我們先介紹兩種思路比較直接的解法，再介紹效率更高的堆積解法。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#831","level":2,"title":"8.3.1   方法一：走訪選擇","text":"<p>我們可以進行圖 8-6 所示的 \\(k\\) 輪走訪，分別在每輪中提取第 \\(1\\)、\\(2\\)、\\(\\dots\\)、\\(k\\) 大的元素，時間複雜度為 \\(O(nk)\\) 。</p> <p>此方法只適用於 \\(k \\ll n\\) 的情況，因為當 \\(k\\) 與 \\(n\\) 比較接近時，其時間複雜度趨向於 \\(O(n^2)\\) ，非常耗時。</p> <p></p> <p> 圖 8-6   走訪尋找最大的 k 個元素 </p> <p>Tip</p> <p>當 \\(k = n\\) 時，我們可以得到完整的有序序列，此時等價於“選擇排序”演算法。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#832","level":2,"title":"8.3.2   方法二：排序","text":"<p>如圖 8-7 所示，我們可以先對陣列 <code>nums</code> 進行排序，再返回最右邊的 \\(k\\) 個元素，時間複雜度為 \\(O(n \\log n)\\) 。</p> <p>顯然，該方法“超額”完成任務了，因為我們只需找出最大的 \\(k\\) 個元素即可，而不需要排序其他元素。</p> <p></p> <p> 圖 8-7   排序尋找最大的 k 個元素 </p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_heap/top_k/#833","level":2,"title":"8.3.3   方法三：堆積","text":"<p>我們可以基於堆積更加高效地解決 Top-k 問題，流程如圖 8-8 所示。</p> <ol> <li>初始化一個小頂堆積，其堆積頂元素最小。</li> <li>先將陣列的前 \\(k\\) 個元素依次入堆積。</li> <li>從第 \\(k + 1\\) 個元素開始，若當前元素大於堆積頂元素，則將堆積頂元素出堆積，並將當前元素入堆積。</li> <li>走訪完成後，堆積中儲存的就是最大的 \\(k\\) 個元素。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 8-8   基於堆積尋找最大的 k 個元素 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby top_k.py<pre><code>def top_k_heap(nums: list[int], k: int) -&gt; list[int]:\n    \"\"\"基於堆積查詢陣列中最大的 k 個元素\"\"\"\n    # 初始化小頂堆積\n    heap = []\n    # 將陣列的前 k 個元素入堆積\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i in range(k, len(nums)):\n        # 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\n</code></pre> top_k.cpp<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\npriority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; topKHeap(vector&lt;int&gt; &amp;nums, int k) {\n    // 初始化小頂堆積\n    priority_queue&lt;int, vector&lt;int&gt;, greater&lt;int&gt;&gt; heap;\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.push(nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.size(); i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.java<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nQueue&lt;Integer&gt; topKHeap(int[] nums, int k) {\n    // 初始化小頂堆積\n    Queue&lt;Integer&gt; heap = new PriorityQueue&lt;Integer&gt;();\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.offer(nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.cs<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nPriorityQueue&lt;int, int&gt; TopKHeap(int[] nums, int k) {\n    // 初始化小頂堆積\n    PriorityQueue&lt;int, int&gt; heap = new();\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; nums.Length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n</code></pre> top_k.go<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // 初始化小頂堆積\n    h := &amp;minHeap{}\n    heap.Init(h)\n    // 將陣列的前 k 個元素入堆積\n    for i := 0; i &lt; k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i := k; i &lt; len(nums); i++ {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\n</code></pre> top_k.swift<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunc topKHeap(nums: [Int], k: Int) -&gt; [Int] {\n    // 初始化一個小頂堆積，並將前 k 個元素建堆積\n    var heap = Heap(nums.prefix(k))\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for i in nums.indices.dropFirst(k) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if nums[i] &gt; heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n</code></pre> top_k.js<pre><code>/* 元素入堆積 */\nfunction pushMinHeap(maxHeap, val) {\n    // 元素取反\n    maxHeap.push(-val);\n}\n\n/* 元素出堆積 */\nfunction popMinHeap(maxHeap) {\n    // 元素取反\n    return -maxHeap.pop();\n}\n\n/* 訪問堆積頂元素 */\nfunction peekMinHeap(maxHeap) {\n    // 元素取反\n    return -maxHeap.peek();\n}\n\n/* 取出堆積中元素 */\nfunction getMinHeap(maxHeap) {\n    // 元素取反\n    return maxHeap.getMaxHeap().map((num) =&gt; -num);\n}\n\n/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunction topKHeap(nums, k) {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    const maxHeap = new MaxHeap([]);\n    // 將陣列的前 k 個元素入堆積\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (let i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // 返回堆積中元素\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.ts<pre><code>/* 元素入堆積 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // 元素取反\n    maxHeap.push(-val);\n}\n\n/* 元素出堆積 */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // 元素取反\n    return -maxHeap.pop();\n}\n\n/* 訪問堆積頂元素 */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // 元素取反\n    return -maxHeap.peek();\n}\n\n/* 取出堆積中元素 */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // 元素取反\n    return maxHeap.getMaxHeap().map((num: number) =&gt; -num);\n}\n\n/* 基於堆積查詢陣列中最大的 k 個元素 */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    const maxHeap = new MaxHeap([]);\n    // 將陣列的前 k 個元素入堆積\n    for (let i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (let i = k; i &lt; nums.length; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // 返回堆積中元素\n    return getMinHeap(maxHeap);\n}\n</code></pre> top_k.dart<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nMinHeap topKHeap(List&lt;int&gt; nums, int k) {\n  // 初始化小頂堆積，將陣列的前 k 個元素入堆積\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // 從第 k+1 個元素開始，保持堆積的長度為 k\n  for (int i = k; i &lt; nums.length; i++) {\n    // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n    if (nums[i] &gt; heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n</code></pre> top_k.rs<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfn top_k_heap(nums: Vec&lt;i32&gt;, k: usize) -&gt; BinaryHeap&lt;Reverse&lt;i32&gt;&gt; {\n    // BinaryHeap 是大頂堆積，使用 Reverse 將元素取反，從而實現小頂堆積\n    let mut heap = BinaryHeap::&lt;Reverse&lt;i32&gt;&gt;::new();\n    // 將陣列的前 k 個元素入堆積\n    for &amp;num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for &amp;num in nums.iter().skip(k) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if num &gt; heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n</code></pre> top_k.c<pre><code>/* 元素入堆積 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // 元素取反\n    push(maxHeap, -val);\n}\n\n/* 元素出堆積 */\nint popMinHeap(MaxHeap *maxHeap) {\n    // 元素取反\n    return -pop(maxHeap);\n}\n\n/* 訪問堆積頂元素 */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // 元素取反\n    return -peek(maxHeap);\n}\n\n/* 取出堆積中元素 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // 將堆積中所有元素取反並存入 res 陣列\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n/* 取出堆積中元素 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // 將堆積中所有元素取反並存入 res 陣列\n    int *res = (int *)malloc(maxHeap-&gt;size * sizeof(int));\n    for (int i = 0; i &lt; maxHeap-&gt;size; i++) {\n        res[i] = -maxHeap-&gt;data[i];\n    }\n    return res;\n}\n\n// 基於堆積查詢陣列中最大的 k 個元素的函式\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // 初始化小頂堆積\n    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // 將陣列的前 k 個元素入堆積\n    for (int i = 0; i &lt; k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (int i = k; i &lt; sizeNums; i++) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // 釋放記憶體\n    delMaxHeap(maxHeap);\n    return res;\n}\n</code></pre> top_k.kt<pre><code>/* 基於堆積查詢陣列中最大的 k 個元素 */\nfun topKHeap(nums: IntArray, k: Int): Queue&lt;Int&gt; {\n    // 初始化小頂堆積\n    val heap = PriorityQueue&lt;Int&gt;()\n    // 將陣列的前 k 個元素入堆積\n    for (i in 0..&lt;k) {\n        heap.offer(nums[i])\n    }\n    // 從第 k+1 個元素開始，保持堆積的長度為 k\n    for (i in k..&lt;nums.size) {\n        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n        if (nums[i] &gt; heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n</code></pre> top_k.rb<pre><code>### 基於堆積查詢陣列中最大的 k 個元素 ###\ndef top_k_heap(nums, k)\n  # 初始化小頂堆積\n  # 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積\n  max_heap = MaxHeap.new([])\n\n  # 將陣列的前 k 個元素入堆積\n  for i in 0...k\n    push_min_heap(max_heap, nums[i])\n  end\n\n  # 從第 k+1 個元素開始，保持堆積的長度為 k\n  for i in k...nums.length\n    # 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積\n    if nums[i] &gt; peek_min_heap(max_heap)\n      pop_min_heap(max_heap)\n      push_min_heap(max_heap, nums[i])\n    end\n  end\n\n  get_min_heap(max_heap)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>總共執行了 \\(n\\) 輪入堆積和出堆積，堆積的最大長度為 \\(k\\) ，因此時間複雜度為 \\(O(n \\log k)\\) 。該方法的效率很高，當 \\(k\\) 較小時，時間複雜度趨向 \\(O(n)\\) ；當 \\(k\\) 較大時，時間複雜度不會超過 \\(O(n \\log n)\\) 。</p> <p>另外，該方法適用於動態資料流的使用場景。在不斷加入資料時，我們可以持續維護堆積內的元素，從而實現最大的 \\(k\\) 個元素的動態更新。</p>","path":["第 8 章 &nbsp; 堆積","8.3 &nbsp; Top-k 問題"],"tags":[]},{"location":"chapter_hello_algo/","level":1,"title":"序","text":"<p>幾年前，我在力扣上分享了“劍指 Offer”系列題解，受到了許多讀者的鼓勵和支持。在與讀者交流期間，我最常被問的一個問題是“如何入門演算法”。逐漸地，我對這個問題產生了濃厚的興趣。</p> <p>兩眼一抹黑地刷題似乎是最受歡迎的方法，簡單、直接且有效。然而刷題就如同玩“掃雷”遊戲，自學能力強的人能夠順利將地雷逐個排掉，而基礎不足的人很可能被炸得滿頭是包，並在挫折中步步退縮。通讀教材也是一種常見做法，但對於面向求職的人來說，畢業論文、投遞簡歷、準備筆試和面試已經消耗了大部分精力，啃厚重的書往往變成了一項艱鉅的挑戰。</p> <p>如果你也面臨類似的困擾，那麼很幸運這本書“找”到了你。本書是我對這個問題給出的答案，即使不是最優解，也至少是一次積極的嘗試。本書雖然不足以讓你直接拿到 Offer，但會引導你探索資料結構與演算法的“知識地圖”，帶你瞭解不同“地雷”的形狀、大小和分佈位置，讓你掌握各種“排雷方法”。有了這些本領，相信你可以更加自如地刷題和閱讀文獻，逐步構建起完整的知識體系。</p> <p>我深深贊同費曼教授所言：“Knowledge isn't free. You have to pay attention.”從這個意義上看，這本書並非完全“免費”。為了不辜負你為本書所付出的寶貴“注意力”，我會竭盡所能，投入最大的“注意力”來完成本書的創作。</p> <p>本人自知學疏才淺，書中內容雖然已經過一段時間的打磨，但一定仍有許多錯誤，懇請各位老師和同學批評指正。</p> <p></p> Hello，演算法！ <p>計算機的出現給世界帶來了巨大變革，它憑藉高速的計算能力和出色的可程式設計性，成為了執行演算法與處理資料的理想媒介。無論是電子遊戲的逼真畫面、自動駕駛的智慧決策，還是 AlphaGo 的精彩棋局、ChatGPT 的自然互動，這些應用都是演算法在計算機上的精妙演繹。</p> <p>事實上，在計算機問世之前，演算法和資料結構就已經存在於世界的各個角落。早期的演算法相對簡單，例如古代的計數方法和工具製作步驟等。隨著文明的進步，演算法逐漸變得更加精細和複雜。從巧奪天工的匠人技藝、到解放生產力的工業產品、再到宇宙執行的科學規律，幾乎每一件平凡或令人驚歎的事物背後，都隱藏著精妙的演算法思想。</p> <p>同樣，資料結構無處不在：大到社會網路，小到地鐵線路，許多系統都可以建模為“圖”；大到一個國家，小到一個家庭，社會的主要組織形式呈現出“樹”的特徵；冬天的衣服就像“堆疊”，最先穿上的最後才能脫下；羽毛球筒則如同“佇列”，一端放入、另一端取出；字典就像一個“雜湊表”，能夠快速查詢目標詞條。</p> <p>本書旨在透過清晰易懂的動畫圖解和可執行的程式碼示例，使讀者理解演算法和資料結構的核心概念，並能夠透過程式設計來實現它們。在此基礎上，本書致力於揭示演算法在複雜世界中的生動體現，展現演算法之美。希望本書能夠幫助到你！</p>","path":["序"],"tags":[]},{"location":"chapter_introduction/","level":1,"title":"第 1 章   初識演算法","text":"<p>Abstract</p> <p>一位少女翩翩起舞，與資料交織在一起，裙襬上飄揚著演算法的旋律。</p> <p>她邀請你共舞，請緊跟她的步伐，踏入充滿邏輯與美感的演算法世界。</p>","path":["第 1 章 &nbsp; 初識演算法"],"tags":[]},{"location":"chapter_introduction/#_1","level":2,"title":"本章內容","text":"<ul> <li>1.1   演算法無處不在</li> <li>1.2   演算法是什麼</li> <li>1.3   小結</li> </ul>","path":["第 1 章 &nbsp; 初識演算法"],"tags":[]},{"location":"chapter_introduction/algorithms_are_everywhere/","level":1,"title":"1.1   演算法無處不在","text":"<p>當我們聽到“演算法”這個詞時，很自然地會想到數學。然而實際上，許多演算法並不涉及複雜數學，而是更多地依賴基本邏輯，這些邏輯在我們的日常生活中處處可見。</p> <p>在正式探討演算法之前，有一個有趣的事實值得分享：你已經在不知不覺中學會了許多演算法，並習慣將它們應用到日常生活中了。下面我將舉幾個具體的例子來證實這一點。</p> <p>例一：查字典。在字典裡，每個漢字都對應一個拼音，而字典是按照拼音字母順序排列的。假設我們需要查詢一個拼音首字母為 \\(r\\) 的字，通常會按照圖 1-1 所示的方式實現。</p> <ol> <li>翻開字典約一半的頁數，檢視該頁的首字母是什麼，假設首字母為 \\(m\\) 。</li> <li>由於在拼音字母表中 \\(r\\) 位於 \\(m\\) 之後，所以排除字典前半部分，查詢範圍縮小到後半部分。</li> <li>不斷重複步驟 <code>1.</code> 和步驟 <code>2.</code> ，直至找到拼音首字母為 \\(r\\) 的頁碼為止。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 1-1   查字典步驟 </p> <p>查字典這個小學生必備技能，實際上就是著名的“二分搜尋”演算法。從資料結構的角度，我們可以把字典視為一個已排序的“陣列”；從演算法的角度，我們可以將上述查字典的一系列操作看作“二分搜尋”。</p> <p>例二：整理撲克。我們在打牌時，每局都需要整理手中的撲克牌，使其從小到大排列，實現流程如圖 1-2 所示。</p> <ol> <li>將撲克牌劃分為“有序”和“無序”兩部分，並假設初始狀態下最左 1 張撲克牌已經有序。</li> <li>在無序部分抽出一張撲克牌，插入至有序部分的正確位置；完成後最左 2 張撲克已經有序。</li> <li>不斷迴圈步驟 <code>2.</code> ，每一輪將一張撲克牌從無序部分插入至有序部分，直至所有撲克牌都有序。</li> </ol> <p></p> <p> 圖 1-2   撲克排序步驟 </p> <p>上述整理撲克牌的方法本質上是“插入排序”演算法，它在處理小型資料集時非常高效。許多程式語言的排序庫函式中都有插入排序的身影。</p> <p>例三：貨幣找零。假設我們在超市購買了 \\(69\\) 元的商品，給了收銀員 \\(100\\) 元，則收銀員需要找我們 \\(31\\) 元。他會很自然地完成如圖 1-3 所示的思考。</p> <ol> <li>可選項是比 \\(31\\) 元面值更小的貨幣，包括 \\(1\\) 元、\\(5\\) 元、\\(10\\) 元、\\(20\\) 元。</li> <li>從可選項中拿出最大的 \\(20\\) 元，剩餘 \\(31 - 20 = 11\\) 元。</li> <li>從剩餘可選項中拿出最大的 \\(10\\) 元，剩餘 \\(11 - 10 = 1\\) 元。</li> <li>從剩餘可選項中拿出最大的 \\(1\\) 元，剩餘 \\(1 - 1 = 0\\) 元。</li> <li>完成找零，方案為 \\(20 + 10 + 1 = 31\\) 元。</li> </ol> <p></p> <p> 圖 1-3   貨幣找零過程 </p> <p>在以上步驟中，我們每一步都採取當前看來最好的選擇（儘可能用大面額的貨幣），最終得到了可行的找零方案。從資料結構與演算法的角度看，這種方法本質上是“貪婪”演算法。</p> <p>小到烹飪一道菜，大到星際航行，幾乎所有問題的解決都離不開演算法。計算機的出現使得我們能夠透過程式設計將資料結構儲存在記憶體中，同時編寫程式碼呼叫 CPU 和 GPU 執行演算法。這樣一來，我們就能把生活中的問題轉移到計算機上，以更高效的方式解決各種複雜問題。</p> <p>Tip</p> <p>如果你對資料結構、演算法、陣列和二分搜尋等概念仍感到一知半解，請繼續往下閱讀，本書將引導你邁入資料結構與演算法的知識殿堂。</p>","path":["第 1 章 &nbsp; 初識演算法","1.1 &nbsp; 演算法無處不在"],"tags":[]},{"location":"chapter_introduction/summary/","level":1,"title":"1.3   小結","text":"","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>演算法在日常生活中無處不在，並不是遙不可及的高深知識。實際上，我們已經在不知不覺中學會了許多演算法，用以解決生活中的大小問題。</li> <li>查字典的原理與二分搜尋演算法相一致。二分搜尋演算法體現了分而治之的重要演算法思想。</li> <li>整理撲克的過程與插入排序演算法非常類似。插入排序演算法適合排序小型資料集。</li> <li>貨幣找零的步驟本質上是貪婪演算法，每一步都採取當前看來最好的選擇。</li> <li>演算法是在有限時間內解決特定問題的一組指令或操作步驟，而資料結構是計算機中組織和儲存資料的方式。</li> <li>資料結構與演算法緊密相連。資料結構是演算法的基石，而演算法為資料結構注入生命力。</li> <li>我們可以將資料結構與演算法類比為拼裝積木，積木代表資料，積木的形狀和連線方式等代表資料結構，拼裝積木的步驟則對應演算法。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：作為一名程式設計師，我在日常工作中從未用演算法解決過問題，常用演算法都被程式語言封裝好了，直接用就可以了；這是否意味著我們工作中的問題還沒有到達需要演算法的程度？</p> <p>如果把具體的工作技能比作是武功的“招式”的話，那麼基礎科目應該更像是“內功”。</p> <p>我認為學演算法（以及其他基礎科目）的意義不是在於在工作中從零實現它，而是基於學到的知識，在解決問題時能夠作出專業的反應和判斷，從而提升工作的整體質量。舉一個簡單例子，每種程式語言都內建了排序函式：</p> <ul> <li>如果我們沒有學過資料結構與演算法，那麼給定任何資料，我們可能都塞給這個排序函式去做了。執行順暢、效能不錯，看上去並沒有什麼問題。</li> <li>但如果學過演算法，我們就會知道內建排序函式的時間複雜度是 \\(O(n \\log n)\\) ；而如果給定的資料是固定位數的整數（例如學號），那麼我們就可以用效率更高的“基數排序”來做，將時間複雜度降為 \\(O(nk)\\) ，其中 \\(k\\) 為位數。當資料體量很大時，節省出來的執行時間就能創造較大價值（成本降低、體驗變好等）。</li> </ul> <p>在工程領域中，大量問題是難以達到最優解的，許多問題只是被“差不多”地解決了。問題的難易程度一方面取決於問題本身的性質，另一方面也取決於觀測問題的人的知識儲備。人的知識越完備、經驗越多，分析問題就會越深入，問題就能被解決得更優雅。</p>","path":["第 1 章 &nbsp; 初識演算法","1.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/","level":1,"title":"1.2   演算法是什麼","text":"","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#121","level":2,"title":"1.2.1   演算法定義","text":"<p>演算法（algorithm）是在有限時間內解決特定問題的一組指令或操作步驟，它具有以下特性。</p> <ul> <li>問題是明確的，包含清晰的輸入和輸出定義。</li> <li>具有可行性，能夠在有限步驟、時間和記憶體空間下完成。</li> <li>各步驟都有確定的含義，在相同的輸入和執行條件下，輸出始終相同。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#122","level":2,"title":"1.2.2   資料結構定義","text":"<p>資料結構（data structure）是組織和儲存資料的方式，涵蓋資料內容、資料之間關係和資料操作方法，它具有以下設計目標。</p> <ul> <li>空間佔用儘量少，以節省計算機記憶體。</li> <li>資料操作儘可能快速，涵蓋資料訪問、新增、刪除、更新等。</li> <li>提供簡潔的資料表示和邏輯資訊，以便演算法高效執行。</li> </ul> <p>資料結構設計是一個充滿權衡的過程。如果想在某方面取得提升，往往需要在另一方面作出妥協。下面舉兩個例子。</p> <ul> <li>鏈結串列相較於陣列，在資料新增和刪除操作上更加便捷，但犧牲了資料訪問速度。</li> <li>圖相較於鏈結串列，提供了更豐富的邏輯資訊，但需要佔用更大的記憶體空間。</li> </ul>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_introduction/what_is_dsa/#123","level":2,"title":"1.2.3   資料結構與演算法的關係","text":"<p>如圖 1-4 所示，資料結構與演算法高度相關、緊密結合，具體表現在以下三個方面。</p> <ul> <li>資料結構是演算法的基石。資料結構為演算法提供了結構化儲存的資料，以及操作資料的方法。</li> <li>演算法為資料結構注入生命力。資料結構本身僅儲存資料資訊，結合演算法才能解決特定問題。</li> <li>演算法通常可以基於不同的資料結構實現，但執行效率可能相差很大，選擇合適的資料結構是關鍵。</li> </ul> <p></p> <p> 圖 1-4   資料結構與演算法的關係 </p> <p>資料結構與演算法猶如圖 1-5 所示的拼裝積木。一套積木，除了包含許多零件之外，還附有詳細的組裝說明書。我們按照說明書一步步操作，就能組裝出精美的積木模型。</p> <p></p> <p> 圖 1-5   拼裝積木 </p> <p>兩者的詳細對應關係如表 1-1 所示。</p> <p> 表 1-1   將資料結構與演算法類比為拼裝積木 </p> 資料結構與演算法 拼裝積木 輸入資料 未拼裝的積木 資料結構 積木組織形式，包括形狀、大小、連線方式等 演算法 把積木拼成目標形態的一系列操作步驟 輸出資料 積木模型 <p>值得說明的是，資料結構與演算法是獨立於程式語言的。正因如此，本書得以提供基於多種程式語言的實現。</p> <p>約定俗成的簡稱</p> <p>在實際討論時，我們通常會將“資料結構與演算法”簡稱為“演算法”。比如眾所周知的 LeetCode 演算法題目，實際上同時考查資料結構和演算法兩方面的知識。</p>","path":["第 1 章 &nbsp; 初識演算法","1.2 &nbsp; 演算法是什麼"],"tags":[]},{"location":"chapter_preface/","level":1,"title":"第 0 章   前言","text":"<p>Abstract</p> <p>演算法猶如美妙的交響樂，每一行程式碼都像韻律般流淌。</p> <p>願這本書在你的腦海中輕輕響起，留下獨特而深刻的旋律。</p>","path":["第 0 章 &nbsp; 前言"],"tags":[]},{"location":"chapter_preface/#_1","level":2,"title":"本章內容","text":"<ul> <li>0.1   關於本書</li> <li>0.2   如何使用本書</li> <li>0.3   小結</li> </ul>","path":["第 0 章 &nbsp; 前言"],"tags":[]},{"location":"chapter_preface/about_the_book/","level":1,"title":"0.1   關於本書","text":"<p>本專案旨在建立一本開源、免費、對新手友好的資料結構與演算法入門教程。</p> <ul> <li>全書採用動畫圖解，內容清晰易懂、學習曲線平滑，引導初學者探索資料結構與演算法的知識地圖。</li> <li>源程式碼可一鍵執行，幫助讀者在練習中提升程式設計技能，瞭解演算法工作原理和資料結構底層實現。</li> <li>提倡讀者互助學習，歡迎大家在評論區提出問題與分享見解，在交流討論中共同進步。</li> </ul>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#011","level":2,"title":"0.1.1   目標讀者","text":"<p>若你是演算法初學者，從未接觸過演算法，或者已經有一些刷題經驗，對資料結構與演算法有模糊的認識，在會與不會之間反覆橫跳，那麼本書正是為你量身定製的！</p> <p>如果你已經積累一定的刷題量，熟悉大部分題型，那麼本書可助你回顧與梳理演算法知識體系，倉庫源程式碼可以當作“刷題工具庫”或“演算法字典”來使用。</p> <p>若你是演算法“大神”，我們期待收到你的寶貴建議，或者一起參與創作。</p> <p>前置條件</p> <p>你需要至少具備任一語言的程式設計基礎，能夠閱讀和編寫簡單程式碼。</p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#012","level":2,"title":"0.1.2   內容結構","text":"<p>本書的主要內容如圖 0-1 所示。</p> <ul> <li>複雜度分析：資料結構和演算法的評價維度與方法。時間複雜度和空間複雜度的推算方法、常見型別、示例等。</li> <li>資料結構：基本資料型別和資料結構的分類方法。陣列、鏈結串列、堆疊、佇列、雜湊表、樹、堆積、圖等資料結構的定義、優缺點、常用操作、常見型別、典型應用、實現方法等。</li> <li>演算法：搜尋、排序、分治、回溯、動態規劃、貪婪等演算法的定義、優缺點、效率、應用場景、解題步驟和示例問題等。</li> </ul> <p></p> <p> 圖 0-1   本書主要內容 </p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/about_the_book/#013","level":2,"title":"0.1.3   致謝","text":"<p>本書在開源社群眾多貢獻者的共同努力下不斷完善。感謝每一位投入時間與精力的撰稿人，他們是（按照 GitHub 自動生成的順序）：krahets、coderonion、Gonglja、nuomi1、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、rongyi、msk397、gvenusleo、khoaxuantu、rivertwilight、K3v123、gyt95、zhuoqinyue、yuelinxin、Zuoxun、mingXta、Phoenix0415、FangYuan33、GN-Yu、longsizhuo、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、pengchzn、QiLOL、magentaqin、hello-ikun、JoseHung、qualifier1024、thomasq0、sunshinesDL、L-Super、Guanngxu、Transmigration-zhou、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、Shyam-Chen、theNefelibatas、longranger2、codeberg-user、xiongsp、JeffersonHuang、prinpal、seven1240、Wonderdch、malone6、xiaomiusa87、gaofer、bluebean-cloud、a16su、SamJin98、hongyun-robot、nanlei、XiaChuerwu、yd-j、iron-irax、mgisr、steventimes、junminhong、heshuyue、danny900714、MolDuM、Nigh、Dr-XYZ、XC-Zero、reeswell、PXG-XPG、NI-SW、Horbin-Magician、Enlightenus、YangXuanyi、beatrix-chan、DullSword、xjr7670、jiaxianhua、qq909244296、iStig、boloboloda、hts0000、gledfish、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、linyejoe2、liuxjerry、llql1211、fbigm、echo1937、szu17dmy、dshlstarr、Yucao-cy、coderlef、czruby、bongbongbakudan、beintentional、ZongYangL、ZhongYuuu、ZhongGuanbin、hezhizhen、linzeyan、ZJKung、luluxia、xb534、ztkuaikuai、yw-1021、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yanedie、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、sslmj2020、smilelsb、siqyka、selear、sdshaoda、Xi-Row、popozhu、nuquist19、noobcodemaker、XiaoK29、chadyi、lyl625760、lucaswangdev、0130w、shanghai-Jerry、EJackYang、Javesun99、eltociear、lipusheng、KNChiu、BlindTerran、ShiMaRing、lovelock、FreddieLi、FloranceYeh、fanchenggang、gltianwen、goerll、nedchu、curly210102、CuB3y0nd、KraHsu、CarrotDLaw、youshaoXG、bubble9um、Asashishi、Asa0oo0o0o、fanenr、eagleanurag、akshiterate、52coder、foursevenlove、KorsChen、GaochaoZhu、hopkings2008、yang-le、realwujing、Evilrabbit520、Umer-Jahangir、Turing-1024-Lee、Suremotoo、paoxiaomooo、Chieko-Seren、Allen-Scai、ymmmas、Risuntsy、Richard-Zhang1019、RafaelCaso、qingpeng9802、primexiao、Urbaner3、zhongfq、nidhoggfgg、MwumLi、CreatorMetaSky、martinx、ZnYang2018、hugtyftg、logan-qiu、psychelzh、Keynman、KeiichiKasai 和 KawaiiAsh。</p> <p>本書的程式碼審閱工作由 coderonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、khoaxuantu、krahets、night-cruise、nuomi1、Reanon 和 rongyi 完成（按照首字母順序排列）。感謝他們付出的時間與精力，正是他們確保了各語言程式碼的規範與統一。</p> <p>本書的繁體中文版由 Shyam-Chen 和 Dr-XYZ 審閱，英文版由 yuelinxin、K3v123、QiLOL、Phoenix0415、SamJin98、yanedie、RafaelCaso、pengchzn、thomasq0 和 magentaqin 審閱，日文版由 eltociear 審閱。正是因為他們的持續貢獻，這本書才能夠服務於更廣泛的讀者群體，感謝他們。</p> <p>本書的 ePub 電子書生成工具由 zhongfq 開發。感謝他的貢獻，為讀者提供了更加自由的閱讀方式。</p> <p>在本書的創作過程中，我得到了許多人的幫助。</p> <ul> <li>感謝我在公司的導師李汐博士，在一次暢談中你鼓勵我“快行動起來”，堅定了我寫這本書的決心；</li> <li>感謝我的女朋友泡泡作為本書的首位讀者，從演算法小白的角度提出許多寶貴建議，使得本書更適合新手閱讀；</li> <li>感謝騰寶、琦寶、飛寶為本書起了一個富有創意的名字，喚起大家寫下第一行程式碼“Hello World!”的美好回憶；</li> <li>感謝校銓在智慧財產權方面提供的專業幫助，這對本開源書的完善起到了重要作用；</li> <li>感謝蘇潼為本書設計了精美的封面和 logo ，並在我的強迫症的驅使下多次耐心修改；</li> <li>感謝 @squidfunk 提供的排版建議，以及他開發的開源文件主題 Material-for-MkDocs 。</li> </ul> <p>在寫作過程中，我閱讀了許多關於資料結構與演算法的教材和文章。這些作品為本書提供了優秀的範本，確保了本書內容的準確性與品質。在此感謝所有老師和前輩的傑出貢獻！</p> <p>本書倡導手腦並用的學習方式，在這一點上我深受《動手學深度學習》的啟發。在此向各位讀者強烈推薦這本優秀的著作。</p> <p>衷心感謝我的父母，正是你們一直以來的支持與鼓勵，讓我有機會做這件富有趣味的事。</p>","path":["第 0 章 &nbsp; 前言","0.1 &nbsp; 關於本書"],"tags":[]},{"location":"chapter_preface/suggestions/","level":1,"title":"0.2   如何使用本書","text":"<p>Tip</p> <p>為了獲得最佳的閱讀體驗，建議你通讀本節內容。</p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#021","level":2,"title":"0.2.1   行文風格約定","text":"<ul> <li>標題後標註 <code>*</code> 的是選讀章節，內容相對困難。如果你的時間有限，可以先跳過。</li> <li>專業術語會使用黑體（紙質版和 PDF 版）或新增下劃線（網頁版），例如陣列（array）。建議記住它們，以便閱讀文獻。</li> <li>重點內容和總結性語句會 加粗，這類文字值得特別關注。</li> <li>有特指含義的詞句會使用“引號”標註，以避免歧義。</li> <li>當涉及程式語言之間不一致的名詞時，本書均以 Python 為準，例如使用 <code>None</code> 來表示“空”。</li> <li>本書部分放棄了程式語言的註釋規範，以換取更加緊湊的內容排版。註釋主要分為三種類型：標題註釋、內容註釋、多行註釋。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>\"\"\"標題註釋，用於標註函式、類別、測試樣例等\"\"\"\n\n# 內容註釋，用於詳解程式碼\n\n\"\"\"\n多行\n註釋\n\"\"\"\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n// 多行\n// 註釋\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>/* 標題註釋，用於標註函式、類別、測試樣例等 */\n\n// 內容註釋，用於詳解程式碼\n\n/**\n * 多行\n * 註釋\n */\n</code></pre> <pre><code>### 標題註釋，用於標註函式、類別、測試樣例等 ###\n\n# 內容註釋，用於詳解程式碼\n\n# 多行\n# 註釋\n</code></pre>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#022","level":2,"title":"0.2.2   在動畫圖解中高效學習","text":"<p>相較於文字，影片和圖片具有更高的資訊密度和結構化程度，更易於理解。在本書中，重點和難點知識將主要透過動畫以圖解形式展示，而文字則作為解釋與補充。</p> <p>如果你在閱讀本書時，發現某段內容提供瞭如圖 0-2 所示的動畫圖解，請以圖為主、以文字為輔，綜合兩者來理解內容。</p> <p></p> <p> 圖 0-2   動畫圖解示例 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#023","level":2,"title":"0.2.3   在程式碼實踐中加深理解","text":"<p>本書的配套程式碼託管在 GitHub 倉庫。如圖 0-3 所示，源程式碼附有測試樣例，可一鍵執行。</p> <p>如果時間允許，建議你參照程式碼自行敲一遍。如果學習時間有限，請至少通讀並執行所有程式碼。</p> <p>與閱讀程式碼相比，編寫程式碼的過程往往能帶來更多收穫。動手學，才是真的學。</p> <p></p> <p> 圖 0-3   執行程式碼示例 </p> <p>執行程式碼的前置工作主要分為三步。</p> <p>第一步：安裝本地程式設計環境。請參照附錄所示的教程進行安裝，如果已安裝，則可跳過此步驟。</p> <p>第二步：克隆或下載程式碼倉庫。前往 GitHub 倉庫。如果已經安裝 Git ，可以透過以下命令克隆本倉庫：</p> <pre><code>git clone https://github.com/krahets/hello-algo.git\n</code></pre> <p>當然，你也可以在圖 0-4 所示的位置，點選“Download ZIP”按鈕直接下載程式碼壓縮包，然後在本地解壓即可。</p> <p></p> <p> 圖 0-4   克隆倉庫與下載程式碼 </p> <p>第三步：執行源程式碼。如圖 0-5 所示，對於頂部標有檔案名稱的程式碼塊，我們可以在倉庫的 <code>codes</code> 檔案夾內找到對應的源程式碼檔案。源程式碼檔案可一鍵執行，將幫助你節省不必要的除錯時間，讓你能夠專注於學習內容。</p> <p></p> <p> 圖 0-5   程式碼塊與對應的源程式碼檔案 </p> <p>除了本地執行程式碼，網頁版還支持 Python 程式碼的視覺化執行（基於 pythontutor 實現）。如圖 0-6 所示，你可以點選程式碼塊下方的“視覺化執行”來展開檢視，觀察演算法程式碼的執行過程；也可以點選“全屏觀看”，以獲得更好的閱覽體驗。</p> <p></p> <p> 圖 0-6   Python 程式碼的視覺化執行 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#024","level":2,"title":"0.2.4   在提問討論中共同成長","text":"<p>在閱讀本書時，請不要輕易跳過那些沒學明白的知識點。歡迎在評論區提出你的問題，我和小夥伴們將竭誠為你解答，一般情況下可在兩天內回覆。</p> <p>如圖 0-7 所示，網頁版每個章節的底部都配有評論區。希望你能多關注評論區的內容。一方面，你可以瞭解大家遇到的問題，從而查漏補缺，激發更深入的思考。另一方面，期待你能慷慨地回答其他小夥伴的問題，分享你的見解，幫助他人進步。</p> <p></p> <p> 圖 0-7   評論區示例 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/suggestions/#025","level":2,"title":"0.2.5   演算法學習路線","text":"<p>從總體上看，我們可以將學習資料結構與演算法的過程劃分為三個階段。</p> <ol> <li>階段一：演算法入門。我們需要熟悉各種資料結構的特點和用法，學習不同演算法的原理、流程、用途和效率等方面的內容。</li> <li>階段二：刷演算法題。建議從熱門題目開刷，先積累至少 100 道題目，熟悉主流的演算法問題。初次刷題時，“知識遺忘”可能是一個挑戰，但請放心，這是很正常的。我們可以按照“艾賓浩斯遺忘曲線”來複習題目，通常在進行 3～5 輪的重複後，就能將其牢記在心。推薦的題單和刷題計劃請見此 GitHub 倉庫。</li> <li>階段三：搭建知識體系。在學習方面，我們可以閱讀演算法專欄文章、解題框架和演算法教材，以不斷豐富知識體系。在刷題方面，可以嘗試採用進階刷題策略，如按專題分類、一題多解、一解多題等，相關的刷題心得可以在各個社群找到。</li> </ol> <p>如圖 0-8 所示，本書內容主要涵蓋“階段一”，旨在幫助你更高效地展開階段二和階段三的學習。</p> <p></p> <p> 圖 0-8   演算法學習路線 </p>","path":["第 0 章 &nbsp; 前言","0.2 &nbsp; 如何使用本書"],"tags":[]},{"location":"chapter_preface/summary/","level":1,"title":"0.3   小結","text":"","path":["第 0 章 &nbsp; 前言","0.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_preface/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>本書的主要受眾是演算法初學者。如果你已有一定基礎，本書能幫助你系統回顧演算法知識，書中源程式碼也可作為“刷題工具庫”使用。</li> <li>書中內容主要包括複雜度分析、資料結構和演算法三部分，涵蓋了該領域的大部分主題。</li> <li>對於演算法新手，在初學階段閱讀一本入門書至關重要，可以少走許多彎路。</li> <li>書中的動畫圖解通常用於介紹重點和難點知識。閱讀本書時，應給予這些內容更多關注。</li> <li>實踐乃學習程式設計之最佳途徑。強烈建議執行源程式碼並親自敲程式碼。</li> <li>本書網頁版的每個章節都設有評論區，歡迎隨時分享你的疑惑與見解。</li> </ul>","path":["第 0 章 &nbsp; 前言","0.3 &nbsp; 小結"],"tags":[]},{"location":"chapter_reference/","level":1,"title":"參考文獻","text":"<p>[1] Thomas H. Cormen, et al. Introduction to Algorithms (3<sup>rd</sup> Edition).</p> <p>[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1<sup>st</sup> Edition).</p> <p>[3] Robert Sedgewick, et al. Algorithms (4<sup>th</sup> Edition).</p> <p>[4] 嚴蔚敏. 資料結構（C 語言版）.</p> <p>[5] 鄧俊輝. 資料結構（C++ 語言版，第三版）.</p> <p>[6] 馬克 艾倫 維斯著，陳越譯. 資料結構與演算法分析：Java語言描述（第三版）.</p> <p>[7] 程傑. 大話資料結構.</p> <p>[8] 王爭. 資料結構與演算法之美.</p> <p>[9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6<sup>th</sup> Edition).</p> <p>[10] Aston Zhang, et al. Dive into Deep Learning.</p>","path":["參考文獻"],"tags":[]},{"location":"chapter_searching/","level":1,"title":"第 10 章   搜尋","text":"<p>Abstract</p> <p>搜尋是一場未知的冒險，我們或許需要走遍神秘空間的每個角落，又或許可以快速鎖定目標。</p> <p>在這場尋覓之旅中，每一次探索都可能得到一個未曾料想的答案。</p>","path":["第 10 章 &nbsp; 搜尋"],"tags":[]},{"location":"chapter_searching/#_1","level":2,"title":"本章內容","text":"<ul> <li>10.1   二分搜尋</li> <li>10.2   二分搜尋插入點</li> <li>10.3   二分搜尋邊界</li> <li>10.4   雜湊最佳化策略</li> <li>10.5   重識搜尋演算法</li> <li>10.6   小結</li> </ul>","path":["第 10 章 &nbsp; 搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/","level":1,"title":"10.1   二分搜尋","text":"<p>二分搜尋（binary search）是一種基於分治策略的高效搜尋演算法。它利用資料的有序性，每輪縮小一半搜尋範圍，直至找到目標元素或搜尋區間為空為止。</p> <p>Question</p> <p>給定一個長度為 \\(n\\) 的陣列 <code>nums</code> ，元素按從小到大的順序排列且不重複。請查詢並返回元素 <code>target</code> 在該陣列中的索引。若陣列不包含該元素，則返回 \\(-1\\) 。示例如圖 10-1 所示。</p> <p></p> <p> 圖 10-1   二分搜尋示例資料 </p> <p>如圖 10-2 所示，我們先初始化指標 \\(i = 0\\) 和 \\(j = n - 1\\) ，分別指向陣列首元素和尾元素，代表搜尋區間 \\([0, n - 1]\\) 。請注意，中括號表示閉區間，其包含邊界值本身。</p> <p>接下來，迴圈執行以下兩步。</p> <ol> <li>計算中點索引 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) ，其中 \\(\\lfloor \\: \\rfloor\\) 表示向下取整操作。</li> <li>判斷 <code>nums[m]</code> 和 <code>target</code> 的大小關係，分為以下三種情況。<ol> <li>當 <code>nums[m] &lt; target</code> 時，說明 <code>target</code> 在區間 \\([m + 1, j]\\) 中，因此執行 \\(i = m + 1\\) 。</li> <li>當 <code>nums[m] &gt; target</code> 時，說明 <code>target</code> 在區間 \\([i, m - 1]\\) 中，因此執行 \\(j = m - 1\\) 。</li> <li>當 <code>nums[m] = target</code> 時，說明找到 <code>target</code> ，因此返回索引 \\(m\\) 。</li> </ol> </li> </ol> <p>若陣列不包含目標元素，搜尋區間最終會縮小為空。此時返回 \\(-1\\) 。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 10-2   二分搜尋流程 </p> <p>值得注意的是，由於 \\(i\\) 和 \\(j\\) 都是 <code>int</code> 型別，因此 \\(i + j\\) 可能會超出 <code>int</code> 型別的取值範圍。為了避免大數越界，我們通常採用公式 \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) 來計算中點。</p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋（雙閉區間）\"\"\"\n    # 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    i, j = 0, len(nums) - 1\n    # 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j:\n        # 理論上 Python 的數字可以無限大（取決於記憶體大小），無須考慮大數越界問題\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # 此情況說明 target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # 此情況說明 target 在區間 [i, m-1] 中\n        else:\n            return m  # 找到目標元素，返回其索引\n    return -1  # 未找到目標元素，返回 -1\n</code></pre> binary_search.cpp<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(vector&lt;int&gt; &amp;nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.size() - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(int[] nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分搜尋（雙閉區間） */\nint BinarySearch(int[] nums, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = nums.Length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2;   // 計算中點索引 m\n        if (nums[m] &lt; target)      // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else                       // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分搜尋（雙閉區間） */\nfunc binarySearch(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    i, j := 0, len(nums)-1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    for i &lt;= j {\n        m := i + (j-i)/2      // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分搜尋（雙閉區間） */\nfunc binarySearch(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分搜尋（雙閉區間） */\nfunction binarySearch(nums, target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let i = 0,\n        j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        // 計算中點索引 m ，使用 parseInt() 向下取整\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else return m; // 找到目標元素，返回其索引\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分搜尋（雙閉區間） */\nfunction binarySearch(nums: number[], target: number): number {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let i = 0,\n        j = nums.length - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        // 計算中點索引 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    return -1; // 未找到目標元素，返回 -1\n}\n</code></pre> binary_search.dart<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(List&lt;int&gt; nums, int target) {\n  // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n  int i = 0, j = nums.length - 1;\n  // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      // 此情況說明 target 在區間 [m+1, j] 中\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // 此情況說明 target 在區間 [i, m-1] 中\n      j = m - 1;\n    } else {\n      // 找到目標元素，返回其索引\n      return m;\n    }\n  }\n  // 未找到目標元素，返回 -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分搜尋（雙閉區間） */\nfn binary_search(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分搜尋（雙閉區間） */\nint binarySearch(int *nums, int len, int target) {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    int i = 0, j = len - 1;\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分搜尋（雙閉區間） */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    // 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n    var i = 0\n    var j = nums.size - 1\n    // 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j] 中\n            i = m + 1\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m-1] 中\n            j = m - 1\n        else  // 找到目標元素，返回其索引\n            return m\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分搜尋（雙閉區間） ###\ndef binary_search(nums, target)\n  # 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素\n  i, j = 0, nums.length - 1\n\n  # 迴圈，當搜尋區間為空時跳出（當 i &gt; j 時為空）\n  while i &lt;= j\n    # 理論上 Ruby 的數字可以無限大（取決於記憶體大小），無須考慮大數越界問題\n    m = (i + j) / 2   # 計算中點索引 m\n\n    if nums[m] &lt; target\n      i = m + 1 # 此情況說明 target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # 此情況說明 target 在區間 [i, m-1] 中\n    else\n      return m  # 找到目標元素，返回其索引\n    end\n  end\n\n  -1  # 未找到目標元素，返回 -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>時間複雜度為 \\(O(\\log n)\\) ：在二分迴圈中，區間每輪縮小一半，因此迴圈次數為 \\(\\log_2 n\\) 。</p> <p>空間複雜度為 \\(O(1)\\) ：指標 \\(i\\) 和 \\(j\\) 使用常數大小空間。</p>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/#1011","level":2,"title":"10.1.1   區間表示方法","text":"<p>除了上述雙閉區間外，常見的區間表示還有“左閉右開”區間，定義為 \\([0, n)\\) ，即左邊界包含自身，右邊界不包含自身。在該表示下，區間 \\([i, j)\\) 在 \\(i = j\\) 時為空。</p> <p>我們可以基於該表示實現具有相同功能的二分搜尋演算法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search.py<pre><code>def binary_search_lcro(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋（左閉右開區間）\"\"\"\n    # 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    i, j = 0, len(nums)\n    # 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # 此情況說明 target 在區間 [m+1, j) 中\n        elif nums[m] &gt; target:\n            j = m  # 此情況說明 target 在區間 [i, m) 中\n        else:\n            return m  # 找到目標元素，返回其索引\n    return -1  # 未找到目標元素，返回 -1\n</code></pre> binary_search.cpp<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(vector&lt;int&gt; &amp;nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.size();\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.java<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(int[] nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.cs<pre><code>/* 二分搜尋（左閉右開區間） */\nint BinarySearchLCRO(int[] nums, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = nums.Length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2;   // 計算中點索引 m\n        if (nums[m] &lt; target)      // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else                       // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.go<pre><code>/* 二分搜尋（左閉右開區間） */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    i, j := 0, len(nums)\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    for i &lt; j {\n        m := i + (j-i)/2      // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.swift<pre><code>/* 二分搜尋（左閉右開區間） */\nfunc binarySearchLCRO(nums: [Int], target: Int) -&gt; Int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target { // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        } else if nums[m] &gt; target { // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        } else { // 找到目標元素，返回其索引\n            return m\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.js<pre><code>/* 二分搜尋（左閉右開區間） */\nfunction binarySearchLCRO(nums, target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let i = 0,\n        j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        // 計算中點索引 m ，使用 parseInt() 向下取整\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] &lt; target)\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target)\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        // 找到目標元素，返回其索引\n        else return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.ts<pre><code>/* 二分搜尋（左閉右開區間） */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let i = 0,\n        j = nums.length;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        // 計算中點索引 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] &lt; target) {\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        } else if (nums[m] &gt; target) {\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    return -1; // 未找到目標元素，返回 -1\n}\n</code></pre> binary_search.dart<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(List&lt;int&gt; nums, int target) {\n  // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n  int i = 0, j = nums.length;\n  // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n  while (i &lt; j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      // 此情況說明 target 在區間 [m+1, j) 中\n      i = m + 1;\n    } else if (nums[m] &gt; target) {\n      // 此情況說明 target 在區間 [i, m) 中\n      j = m;\n    } else {\n      // 找到目標元素，返回其索引\n      return m;\n    }\n  }\n  // 未找到目標元素，返回 -1\n  return -1;\n}\n</code></pre> binary_search.rs<pre><code>/* 二分搜尋（左閉右開區間） */\nfn binary_search_lcro(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while i &lt; j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        } else if nums[m as usize] &gt; target {\n            // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        } else {\n            // 找到目標元素，返回其索引\n            return m;\n        }\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.c<pre><code>/* 二分搜尋（左閉右開區間） */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    int i = 0, j = len;\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target)    // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1;\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m;\n        else // 找到目標元素，返回其索引\n            return m;\n    }\n    // 未找到目標元素，返回 -1\n    return -1;\n}\n</code></pre> binary_search.kt<pre><code>/* 二分搜尋（左閉右開區間） */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n    var i = 0\n    var j = nums.size\n    // 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n    while (i &lt; j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) // 此情況說明 target 在區間 [m+1, j) 中\n            i = m + 1\n        else if (nums[m] &gt; target) // 此情況說明 target 在區間 [i, m) 中\n            j = m\n        else  // 找到目標元素，返回其索引\n            return m\n    }\n    // 未找到目標元素，返回 -1\n    return -1\n}\n</code></pre> binary_search.rb<pre><code>### 二分搜尋（左閉右開區間） ###\ndef binary_search_lcro(nums, target)\n  # 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1\n  i, j = 0, nums.length\n\n  # 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）\n  while i &lt; j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # 此情況說明 target 在區間 [m+1, j) 中\n    elsif nums[m] &gt; target\n      j = m - 1 # 此情況說明 target 在區間 [i, m) 中\n    else\n      return m  # 找到目標元素，返回其索引\n    end\n  end\n\n  -1  # 未找到目標元素，返回 -1\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>如圖 10-3 所示，在兩種區間表示下，二分搜尋演算法的初始化、迴圈條件和縮小區間操作皆有所不同。</p> <p>由於“雙閉區間”表示中的左右邊界都被定義為閉區間，因此透過指標 \\(i\\) 和指標 \\(j\\) 縮小區間的操作也是對稱的。這樣更不容易出錯，因此一般建議採用“雙閉區間”的寫法。</p> <p></p> <p> 圖 10-3   兩種區間定義 </p>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search/#1012","level":2,"title":"10.1.2   優點與侷限性","text":"<p>二分搜尋在時間和空間方面都有較好的效能。</p> <ul> <li>二分搜尋的時間效率高。在大資料量下，對數階的時間複雜度具有顯著優勢。例如，當資料大小 \\(n = 2^{20}\\) 時，線性查詢需要 \\(2^{20} = 1048576\\) 輪迴圈，而二分搜尋僅需 \\(\\log_2 2^{20} = 20\\) 輪迴圈。</li> <li>二分搜尋無須額外空間。相較於需要藉助額外空間的搜尋演算法（例如雜湊查詢），二分搜尋更加節省空間。</li> </ul> <p>然而，二分搜尋並非適用於所有情況，主要有以下原因。</p> <ul> <li>二分搜尋僅適用於有序資料。若輸入資料無序，為了使用二分搜尋而專門進行排序，得不償失。因為排序演算法的時間複雜度通常為 \\(O(n \\log n)\\) ，比線性查詢和二分搜尋都更高。對於頻繁插入元素的場景，為保持陣列有序性，需要將元素插入到特定位置，時間複雜度為 \\(O(n)\\) ，也是非常昂貴的。</li> <li>二分搜尋僅適用於陣列。二分搜尋需要跳躍式（非連續地）訪問元素，而在鏈結串列中執行跳躍式訪問的效率較低，因此不適合應用在鏈結串列或基於鏈結串列實現的資料結構。</li> <li>小資料量下，線性查詢效能更佳。在線性查詢中，每輪只需 1 次判斷操作；而在二分搜尋中，需要 1 次加法、1 次除法、1 ~ 3 次判斷操作、1 次加法（減法），共 4 ~ 6 個單元操作；因此，當資料量 \\(n\\) 較小時，線性查詢反而比二分搜尋更快。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.1 &nbsp; 二分搜尋"],"tags":[]},{"location":"chapter_searching/binary_search_edge/","level":1,"title":"10.3   二分搜尋邊界","text":"","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1031","level":2,"title":"10.3.1   查詢左邊界","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> ，其中可能包含重複元素。請返回陣列中最左一個元素 <code>target</code> 的索引。若陣列中不包含該元素，則返回 \\(-1\\) 。</p> <p>回憶二分搜尋插入點的方法，搜尋完成後 \\(i\\) 指向最左一個 <code>target</code> ，因此查詢插入點本質上是在查詢最左一個 <code>target</code> 的索引。</p> <p>考慮透過查詢插入點的函式實現查詢左邊界。請注意，陣列中可能不包含 <code>target</code> ，這種情況可能導致以下兩種結果。</p> <ul> <li>插入點的索引 \\(i\\) 越界。</li> <li>元素 <code>nums[i]</code> 與 <code>target</code> 不相等。</li> </ul> <p>當遇到以上兩種情況時，直接返回 \\(-1\\) 即可。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_left_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋最左一個 target\"\"\"\n    # 等價於查詢 target 的插入點\n    i = binary_search_insertion(nums, target)\n    # 未找到 target ，返回 -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # 找到 target ，返回索引 i\n    return i\n</code></pre> binary_search_edge.cpp<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 二分搜尋最左一個 target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 二分搜尋最左一個 target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // 等價於查詢 target 的插入點\n    i := binarySearchInsertion(nums, target)\n    // 未找到 target ，返回 -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 二分搜尋最左一個 target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -&gt; Int {\n    // 等價於查詢 target 的插入點\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // 未找到 target ，返回 -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.js<pre><code>/* 二分搜尋最左一個 target */\nfunction binarySearchLeftEdge(nums, target) {\n    // 等價於查詢 target 的插入點\n    const i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 二分搜尋最左一個 target */\nfunction binarySearchLeftEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 等價於查詢 target 的插入點\n    const i = binarySearchInsertion(nums, target);\n    // 未找到 target ，返回 -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(List&lt;int&gt; nums, int target) {\n  // 等價於查詢 target 的插入點\n  int i = binarySearchInsertion(nums, target);\n  // 未找到 target ，返回 -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // 找到 target ，返回索引 i\n  return i;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 二分搜尋最左一個 target */\nfn binary_search_left_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 等價於查詢 target 的插入點\n    let i = binary_search_insertion(nums, target);\n    // 未找到 target ，返回 -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    i\n}\n</code></pre> binary_search_edge.c<pre><code>/* 二分搜尋最左一個 target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // 等價於查詢 target 的插入點\n    int i = binarySearchInsertion(nums, numSize, target);\n    // 未找到 target ，返回 -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 i\n    return i;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 二分搜尋最左一個 target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // 等價於查詢 target 的插入點\n    val i = binarySearchInsertion(nums, target)\n    // 未找到 target ，返回 -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // 找到 target ，返回索引 i\n    return i\n}\n</code></pre> binary_search_edge.rb<pre><code>### 二分搜尋最左一個 target ###\ndef binary_search_left_edge(nums, target)\n  # 等價於查詢 target 的插入點\n  i = binary_search_insertion(nums, target)\n\n  # 未找到 target ，返回 -1\n  return -1 if i == nums.length || nums[i] != target\n\n  i # 找到 target ，返回索引 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1032","level":2,"title":"10.3.2   查詢右邊界","text":"<p>那麼如何查詢最右一個 <code>target</code> 呢？最直接的方式是修改程式碼，替換在 <code>nums[m] == target</code> 情況下的指標收縮操作。程式碼在此省略，有興趣的讀者可以自行實現。</p> <p>下面我們介紹兩種更加取巧的方法。</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#1","level":3,"title":"1.   複用查詢左邊界","text":"<p>實際上，我們可以利用查詢最左元素的函式來查詢最右元素，具體方法為：將查詢最右一個 <code>target</code> 轉化為查詢最左一個 <code>target + 1</code>。</p> <p>如圖 10-7 所示，查詢完成後，指標 \\(i\\) 指向最左一個 <code>target + 1</code>（如果存在），而 \\(j\\) 指向最右一個 <code>target</code> ，因此返回 \\(j\\) 即可。</p> <p></p> <p> 圖 10-7   將查詢右邊界轉化為查詢左邊界 </p> <p>請注意，返回的插入點是 \\(i\\) ，因此需要將其減 \\(1\\) ，從而獲得 \\(j\\) ：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_edge.py<pre><code>def binary_search_right_edge(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋最右一個 target\"\"\"\n    # 轉化為查詢最左一個 target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j 指向最右一個 target ，i 指向首個大於 target 的元素\n    j = i - 1\n    # 未找到 target ，返回 -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # 找到 target ，返回索引 j\n    return j\n</code></pre> binary_search_edge.cpp<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(vector&lt;int&gt; &amp;nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.java<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.cs<pre><code>/* 二分搜尋最右一個 target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.go<pre><code>/* 二分搜尋最右一個 target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // 轉化為查詢最左一個 target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    j := i - 1\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.swift<pre><code>/* 二分搜尋最右一個 target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -&gt; Int {\n    // 轉化為查詢最左一個 target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    let j = i - 1\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.js<pre><code>/* 二分搜尋最右一個 target */\nfunction binarySearchRightEdge(nums, target) {\n    // 轉化為查詢最左一個 target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    const j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.ts<pre><code>/* 二分搜尋最右一個 target */\nfunction binarySearchRightEdge(nums: Array&lt;number&gt;, target: number): number {\n    // 轉化為查詢最左一個 target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    const j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.dart<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(List&lt;int&gt; nums, int target) {\n  // 轉化為查詢最左一個 target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j 指向最右一個 target ，i 指向首個大於 target 的元素\n  int j = i - 1;\n  // 未找到 target ，返回 -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // 找到 target ，返回索引 j\n  return j;\n}\n</code></pre> binary_search_edge.rs<pre><code>/* 二分搜尋最右一個 target */\nfn binary_search_right_edge(nums: &amp;[i32], target: i32) -&gt; i32 {\n    // 轉化為查詢最左一個 target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    let j = i - 1;\n    // 未找到 target ，返回 -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    j\n}\n</code></pre> binary_search_edge.c<pre><code>/* 二分搜尋最右一個 target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // 轉化為查詢最左一個 target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    int j = i - 1;\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // 找到 target ，返回索引 j\n    return j;\n}\n</code></pre> binary_search_edge.kt<pre><code>/* 二分搜尋最右一個 target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // 轉化為查詢最左一個 target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j 指向最右一個 target ，i 指向首個大於 target 的元素\n    val j = i - 1\n    // 未找到 target ，返回 -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // 找到 target ，返回索引 j\n    return j\n}\n</code></pre> binary_search_edge.rb<pre><code>### 二分搜尋最右一個 target ###\ndef binary_search_right_edge(nums, target)\n  # 轉化為查詢最左一個 target + 1\n  i = binary_search_insertion(nums, target + 1)\n\n  # j 指向最右一個 target ，i 指向首個大於 target 的元素\n  j = i - 1\n\n  # 未找到 target ，返回 -1\n  return -1 if j == -1 || nums[j] != target\n\n  j # 找到 target ，返回索引 j\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_edge/#2","level":3,"title":"2.   轉化為查詢元素","text":"<p>我們知道，當陣列不包含 <code>target</code> 時，最終 \\(i\\) 和 \\(j\\) 會分別指向首個大於、小於 <code>target</code> 的元素。</p> <p>因此，如圖 10-8 所示，我們可以構造一個陣列中不存在的元素，用於查詢左右邊界。</p> <ul> <li>查詢最左一個 <code>target</code> ：可以轉化為查詢 <code>target - 0.5</code> ，並返回指標 \\(i\\) 。</li> <li>查詢最右一個 <code>target</code> ：可以轉化為查詢 <code>target + 0.5</code> ，並返回指標 \\(j\\) 。</li> </ul> <p></p> <p> 圖 10-8   將查詢邊界轉化為查詢元素 </p> <p>程式碼在此省略，以下兩點值得注意。</p> <ul> <li>給定陣列不包含小數，這意味著我們無須關心如何處理相等的情況。</li> <li>因為該方法引入了小數，所以需要將函式中的變數 <code>target</code> 改為浮點數型別（Python 無須改動）。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.3 &nbsp; 二分搜尋邊界"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/","level":1,"title":"10.2   二分搜尋插入點","text":"<p>二分搜尋不僅可用於搜尋目標元素，還可用於解決許多變種問題，比如搜尋目標元素的插入位置。</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1021","level":2,"title":"10.2.1   無重複元素的情況","text":"<p>Question</p> <p>給定一個長度為 \\(n\\) 的有序陣列 <code>nums</code> 和一個元素 <code>target</code> ，陣列不存在重複元素。現將 <code>target</code> 插入陣列 <code>nums</code> 中，並保持其有序性。若陣列中已存在元素 <code>target</code> ，則插入到其左方。請返回插入後 <code>target</code> 在陣列中的索引。示例如圖 10-4 所示。</p> <p></p> <p> 圖 10-4   二分搜尋插入點示例資料 </p> <p>如果想複用上一節的二分搜尋程式碼，則需要回答以下兩個問題。</p> <p>問題一：當陣列中包含 <code>target</code> 時，插入點的索引是否是該元素的索引？</p> <p>題目要求將 <code>target</code> 插入到相等元素的左邊，這意味著新插入的 <code>target</code> 替換了原來 <code>target</code> 的位置。也就是說，當陣列包含 <code>target</code> 時，插入點的索引就是該 <code>target</code> 的索引。</p> <p>問題二：當陣列中不存在 <code>target</code> 時，插入點是哪個元素的索引？</p> <p>進一步思考二分搜尋過程：當 <code>nums[m] &lt; target</code> 時 \\(i\\) 移動，這意味著指標 \\(i\\) 在向大於等於 <code>target</code> 的元素靠近。同理，指標 \\(j\\) 始終在向小於等於 <code>target</code> 的元素靠近。</p> <p>因此二分結束時一定有：\\(i\\) 指向首個大於 <code>target</code> 的元素，\\(j\\) 指向首個小於 <code>target</code> 的元素。易得當陣列不包含 <code>target</code> 時，插入索引為 \\(i\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion_simple(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋插入點（無重複元素）\"\"\"\n    i, j = 0, len(nums) - 1  # 初始化雙閉區間 [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # target 在區間 [i, m-1] 中\n        else:\n            return m  # 找到 target ，返回插入點 m\n    # 未找到 target ，返回插入點 i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分搜尋插入點（無重複元素） */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 計算中點索引 m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target 在區間 [i, m-1] 中\n            j = m - 1\n        } else {\n            // 找到 target ，返回插入點 m\n            return m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if nums[m] &gt; target {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            return m // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分搜尋插入點（無重複元素） */\nfunction binarySearchInsertionSimple(\n    nums: Array&lt;number&gt;,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target 在區間 [m+1, j] 中\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target 在區間 [i, m-1] 中\n    } else {\n      return m; // 找到 target ，返回插入點 m\n    }\n  }\n  // 未找到 target ，返回插入點 i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分搜尋插入點（無重複元素） */\nfn binary_search_insertion_simple(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化雙閉區間 [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m;\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分搜尋插入點（無重複元素） */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            return m; // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分搜尋插入點（無重複元素） */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            return m // 找到 target ，返回插入點 m\n        }\n    }\n    // 未找到 target ，返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分搜尋插入點（無重複元素） ###\ndef binary_search_insertion_simple(nums, target)\n  # 初始化雙閉區間 [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # target 在區間 [i, m-1] 中\n    else\n      return m  # 找到 target ，返回插入點 m\n    end\n  end\n\n  i # 未找到 target ，返回插入點 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/binary_search_insertion/#1022","level":2,"title":"10.2.2   存在重複元素的情況","text":"<p>Question</p> <p>在上一題的基礎上，規定陣列可能包含重複元素，其餘不變。</p> <p>假設陣列中存在多個 <code>target</code> ，則普通二分搜尋只能返回其中一個 <code>target</code> 的索引，而無法確定該元素的左邊和右邊還有多少 <code>target</code>。</p> <p>題目要求將目標元素插入到最左邊，所以我們需要查詢陣列中最左一個 <code>target</code> 的索引。初步考慮透過圖 10-5 所示的步驟實現。</p> <ol> <li>執行二分搜尋，得到任意一個 <code>target</code> 的索引，記為 \\(k\\) 。</li> <li>從索引 \\(k\\) 開始，向左進行線性走訪，當找到最左邊的 <code>target</code> 時返回。</li> </ol> <p></p> <p> 圖 10-5   線性查詢重複元素的插入點 </p> <p>此方法雖然可用，但其包含線性查詢，因此時間複雜度為 \\(O(n)\\) 。當陣列中存在很多重複的 <code>target</code> 時，該方法效率很低。</p> <p>現考慮拓展二分搜尋程式碼。如圖 10-6 所示，整體流程保持不變，每輪先計算中點索引 \\(m\\) ，再判斷 <code>target</code> 和 <code>nums[m]</code> 的大小關係，分為以下幾種情況。</p> <ul> <li>當 <code>nums[m] &lt; target</code> 或 <code>nums[m] &gt; target</code> 時，說明還沒有找到 <code>target</code> ，因此採用普通二分搜尋的縮小區間操作，從而使指標 \\(i\\) 和 \\(j\\) 向 <code>target</code> 靠近。</li> <li>當 <code>nums[m] == target</code> 時，說明小於 <code>target</code> 的元素在區間 \\([i, m - 1]\\) 中，因此採用 \\(j = m - 1\\) 來縮小區間，從而使指標 \\(j\\) 向小於 <code>target</code> 的元素靠近。</li> </ul> <p>迴圈完成後，\\(i\\) 指向最左邊的 <code>target</code> ，\\(j\\) 指向首個小於 <code>target</code> 的元素，因此索引 \\(i\\) 就是插入點。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 10-6   二分搜尋重複元素的插入點的步驟 </p> <p>觀察以下程式碼，判斷分支 <code>nums[m] &gt; target</code> 和 <code>nums[m] == target</code> 的操作相同，因此兩者可以合併。</p> <p>即便如此，我們仍然可以將判斷條件保持展開，因為其邏輯更加清晰、可讀性更好。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_insertion.py<pre><code>def binary_search_insertion(nums: list[int], target: int) -&gt; int:\n    \"\"\"二分搜尋插入點（存在重複元素）\"\"\"\n    i, j = 0, len(nums) - 1  # 初始化雙閉區間 [0, n-1]\n    while i &lt;= j:\n        m = (i + j) // 2  # 計算中點索引 m\n        if nums[m] &lt; target:\n            i = m + 1  # target 在區間 [m+1, j] 中\n        elif nums[m] &gt; target:\n            j = m - 1  # target 在區間 [i, m-1] 中\n        else:\n            j = m - 1  # 首個小於 target 的元素在區間 [i, m-1] 中\n    # 返回插入點 i\n    return i\n</code></pre> binary_search_insertion.cpp<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(vector&lt;int&gt; &amp;nums, int target) {\n    int i = 0, j = nums.size() - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.java<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.cs<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.go<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // 初始化雙閉區間 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i &lt;= j {\n        // 計算中點索引 m\n        m := i + (j-i)/2\n        if nums[m] &lt; target {\n            // target 在區間 [m+1, j] 中\n            i = m + 1\n        } else if nums[m] &gt; target {\n            // target 在區間 [i, m-1] 中\n            j = m - 1\n        } else {\n            // 首個小於 target 的元素在區間 [i, m-1] 中\n            j = m - 1\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.swift<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunc binarySearchInsertion(nums: [Int], target: Int) -&gt; Int {\n    // 初始化雙閉區間 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i &lt;= j {\n        let m = i + (j - i) / 2 // 計算中點索引 m\n        if nums[m] &lt; target {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if nums[m] &gt; target {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1 // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.js<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.ts<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfunction binarySearchInsertion(nums: Array&lt;number&gt;, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        const m = Math.floor(i + (j - i) / 2); // 計算中點索引 m, 使用 Math.floor() 向下取整\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.dart<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(List&lt;int&gt; nums, int target) {\n  int i = 0, j = nums.length - 1; // 初始化雙閉區間 [0, n-1]\n  while (i &lt;= j) {\n    int m = i + (j - i) ~/ 2; // 計算中點索引 m\n    if (nums[m] &lt; target) {\n      i = m + 1; // target 在區間 [m+1, j] 中\n    } else if (nums[m] &gt; target) {\n      j = m - 1; // target 在區間 [i, m-1] 中\n    } else {\n      j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n    }\n  }\n  // 返回插入點 i\n  return i;\n}\n</code></pre> binary_search_insertion.rs<pre><code>/* 二分搜尋插入點（存在重複元素） */\npub fn binary_search_insertion(nums: &amp;[i32], target: i32) -&gt; i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化雙閉區間 [0, n-1]\n    while i &lt;= j {\n        let m = i + (j - i) / 2; // 計算中點索引 m\n        if nums[m as usize] &lt; target {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if nums[m as usize] &gt; target {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    i\n}\n</code></pre> binary_search_insertion.c<pre><code>/* 二分搜尋插入點（存在重複元素） */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        int m = i + (j - i) / 2; // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1; // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1; // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1; // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i;\n}\n</code></pre> binary_search_insertion.kt<pre><code>/* 二分搜尋插入點（存在重複元素） */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // 初始化雙閉區間 [0, n-1]\n    while (i &lt;= j) {\n        val m = i + (j - i) / 2 // 計算中點索引 m\n        if (nums[m] &lt; target) {\n            i = m + 1 // target 在區間 [m+1, j] 中\n        } else if (nums[m] &gt; target) {\n            j = m - 1 // target 在區間 [i, m-1] 中\n        } else {\n            j = m - 1 // 首個小於 target 的元素在區間 [i, m-1] 中\n        }\n    }\n    // 返回插入點 i\n    return i\n}\n</code></pre> binary_search_insertion.rb<pre><code>### 二分搜尋插入點（存在重複元素） ###\ndef binary_search_insertion(nums, target)\n  # 初始化雙閉區間 [0, n-1]\n  i, j = 0, nums.length - 1\n\n  while i &lt;= j\n    # 計算中點索引 m\n    m = (i + j) / 2\n\n    if nums[m] &lt; target\n      i = m + 1 # target 在區間 [m+1, j] 中\n    elsif nums[m] &gt; target\n      j = m - 1 # target 在區間 [i, m-1] 中\n    else\n      j = m - 1 # 首個小於 target 的元素在區間 [i, m-1] 中\n    end\n  end\n\n  i # 返回插入點 i\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>本節的程式碼都是“雙閉區間”寫法。有興趣的讀者可以自行實現“左閉右開”寫法。</p> <p>總的來看，二分搜尋無非就是給指標 \\(i\\) 和 \\(j\\) 分別設定搜尋目標，目標可能是一個具體的元素（例如 <code>target</code> ），也可能是一個元素範圍（例如小於 <code>target</code> 的元素）。</p> <p>在不斷的迴圈二分中，指標 \\(i\\) 和 \\(j\\) 都逐漸逼近預先設定的目標。最終，它們或是成功找到答案，或是越過邊界後停止。</p>","path":["第 10 章 &nbsp; 搜尋","10.2 &nbsp; 二分搜尋插入點"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/","level":1,"title":"10.4   雜湊最佳化策略","text":"<p>在演算法題中，我們常透過將線性查詢替換為雜湊查詢來降低演算法的時間複雜度。我們藉助一個演算法題來加深理解。</p> <p>Question</p> <p>給定一個整數陣列 <code>nums</code> 和一個目標元素 <code>target</code> ，請在陣列中搜索“和”為 <code>target</code> 的兩個元素，並返回它們的陣列索引。返回任意一個解即可。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1041","level":2,"title":"10.4.1   線性查詢：以時間換空間","text":"<p>考慮直接走訪所有可能的組合。如圖 10-9 所示，我們開啟一個兩層迴圈，在每輪中判斷兩個整數的和是否為 <code>target</code> ，若是，則返回它們的索引。</p> <p></p> <p> 圖 10-9   線性查詢求解兩數之和 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_brute_force(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法一：暴力列舉\"\"\"\n    # 兩層迴圈，時間複雜度為 O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法一：暴力列舉 */\nvector&lt;int&gt; twoSumBruteForce(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法一：暴力列舉 */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法一：暴力列舉 */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (int i = 0; i &lt; size - 1; i++) {\n        for (int j = i + 1; j &lt; size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法一：暴力列舉 */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i := 0; i &lt; size-1; i++ {\n        for j := i + 1; j &lt; size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法一：暴力列舉 */\nfunc twoSumBruteForce(nums: [Int], target: Int) -&gt; [Int] {\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法一：暴力列舉 */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法一：暴力列舉 */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (let i = 0; i &lt; n; i++) {\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法一： 暴力列舉 */\nList&lt;int&gt; twoSumBruteForce(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 兩層迴圈，時間複雜度為 O(n^2)\n  for (var i = 0; i &lt; size - 1; i++) {\n    for (var j = i + 1; j &lt; size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法一：暴力列舉 */\npub fn two_sum_brute_force(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    let size = nums.len();\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 方法一：暴力列舉 */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i &lt; numsSize; ++i) {\n        for (int j = i + 1; j &lt; numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法一：暴力列舉 */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 兩層迴圈，時間複雜度為 O(n^2)\n    for (i in 0..&lt;size - 1) {\n        for (j in i + 1..&lt;size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法一：暴力列舉 ###\ndef two_sum_brute_force(nums, target)\n  # 兩層迴圈，時間複雜度為 O(n^2)\n  for i in 0...(nums.length - 1)\n    for j in (i + 1)...nums.length\n      return [i, j] if nums[i] + nums[j] == target\n    end\n  end\n\n  []\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>此方法的時間複雜度為 \\(O(n^2)\\) ，空間複雜度為 \\(O(1)\\) ，在大資料量下非常耗時。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/replace_linear_by_hashing/#1042","level":2,"title":"10.4.2   雜湊查詢：以空間換時間","text":"<p>考慮藉助一個雜湊表，鍵值對分別為陣列元素和元素索引。迴圈走訪陣列，每輪執行圖 10-10 所示的步驟。</p> <ol> <li>判斷數字 <code>target - nums[i]</code> 是否在雜湊表中，若是，則直接返回這兩個元素的索引。</li> <li>將鍵值對 <code>nums[i]</code> 和索引 <code>i</code> 新增進雜湊表。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt; <p></p> <p></p> <p></p> <p> 圖 10-10   輔助雜湊表求解兩數之和 </p> <p>實現程式碼如下所示，僅需單層迴圈即可：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby two_sum.py<pre><code>def two_sum_hash_table(nums: list[int], target: int) -&gt; list[int]:\n    \"\"\"方法二：輔助雜湊表\"\"\"\n    # 輔助雜湊表，空間複雜度為 O(n)\n    dic = {}\n    # 單層迴圈，時間複雜度為 O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n</code></pre> two_sum.cpp<pre><code>/* 方法二：輔助雜湊表 */\nvector&lt;int&gt; twoSumHashTable(vector&lt;int&gt; &amp;nums, int target) {\n    int size = nums.size();\n    // 輔助雜湊表，空間複雜度為 O(n)\n    unordered_map&lt;int, int&gt; dic;\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n</code></pre> two_sum.java<pre><code>/* 方法二：輔助雜湊表 */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // 輔助雜湊表，空間複雜度為 O(n)\n    Map&lt;Integer, Integer&gt; dic = new HashMap&lt;&gt;();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n</code></pre> two_sum.cs<pre><code>/* 方法二：輔助雜湊表 */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // 輔助雜湊表，空間複雜度為 O(n)\n    Dictionary&lt;int, int&gt; dic = [];\n    // 單層迴圈，時間複雜度為 O(n)\n    for (int i = 0; i &lt; size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\n</code></pre> two_sum.go<pre><code>/* 方法二：輔助雜湊表 */\nfunc twoSumHashTable(nums []int, target int) []int {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    hashTable := map[int]int{}\n    // 單層迴圈，時間複雜度為 O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\n}\n</code></pre> two_sum.swift<pre><code>/* 方法二：輔助雜湊表 */\nfunc twoSumHashTable(nums: [Int], target: Int) -&gt; [Int] {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    var dic: [Int: Int] = [:]\n    // 單層迴圈，時間複雜度為 O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\n}\n</code></pre> two_sum.js<pre><code>/* 方法二：輔助雜湊表 */\nfunction twoSumHashTable(nums, target) {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let m = {};\n    // 單層迴圈，時間複雜度為 O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.ts<pre><code>/* 方法二：輔助雜湊表 */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let m: Map&lt;number, number&gt; = new Map();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (let i = 0; i &lt; nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n</code></pre> two_sum.dart<pre><code>/* 方法二： 輔助雜湊表 */\nList&lt;int&gt; twoSumHashTable(List&lt;int&gt; nums, int target) {\n  int size = nums.length;\n  // 輔助雜湊表，空間複雜度為 O(n)\n  Map&lt;int, int&gt; dic = HashMap();\n  // 單層迴圈，時間複雜度為 O(n)\n  for (var i = 0; i &lt; size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () =&gt; i);\n  }\n  return [0];\n}\n</code></pre> two_sum.rs<pre><code>/* 方法二：輔助雜湊表 */\npub fn two_sum_hash_table(nums: &amp;Vec&lt;i32&gt;, target: i32) -&gt; Option&lt;Vec&lt;i32&gt;&gt; {\n    // 輔助雜湊表，空間複雜度為 O(n)\n    let mut dic = HashMap::new();\n    // 單層迴圈，時間複雜度為 O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&amp;(target - num)) {\n            Some(v) =&gt; return Some(vec![*v as i32, i as i32]),\n            None =&gt; dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n</code></pre> two_sum.c<pre><code>/* 雜湊表 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // 基於 uthash.h 實現\n} HashTable;\n\n/* 雜湊表查詢 */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &amp;key, tmp);\n    return tmp;\n}\n\n/* 雜湊表元素插入 */\nvoid insert(HashTable **h, int key, int val) {\n    HashTable *t = find(*h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp-&gt;key = key, tmp-&gt;val = val;\n        HASH_ADD_INT(*h, key, tmp);\n    } else {\n        t-&gt;val = val;\n    }\n}\n\n/* 方法二：輔助雜湊表 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i &lt; numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t-&gt;val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(&amp;hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n</code></pre> two_sum.kt<pre><code>/* 方法二：輔助雜湊表 */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // 輔助雜湊表，空間複雜度為 O(n)\n    val dic = HashMap&lt;Int, Int&gt;()\n    // 單層迴圈，時間複雜度為 O(n)\n    for (i in 0..&lt;size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n</code></pre> two_sum.rb<pre><code>### 方法二：輔助雜湊表 ###\ndef two_sum_hash_table(nums, target)\n  # 輔助雜湊表，空間複雜度為 O(n)\n  dic = {}\n  # 單層迴圈，時間複雜度為 O(n)\n  for i in 0...nums.length\n    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])\n\n    dic[nums[i]] = i\n  end\n\n  []\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>此方法透過雜湊查詢將時間複雜度從 \\(O(n^2)\\) 降至 \\(O(n)\\) ，大幅提升執行效率。</p> <p>由於需要維護一個額外的雜湊表，因此空間複雜度為 \\(O(n)\\) 。儘管如此，該方法的整體時空效率更為均衡，因此它是本題的最優解法。</p>","path":["第 10 章 &nbsp; 搜尋","10.4 &nbsp; 雜湊最佳化策略"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/","level":1,"title":"10.5   重識搜尋演算法","text":"<p>搜尋演算法（searching algorithm）用於在資料結構（例如陣列、鏈結串列、樹或圖）中搜索一個或一組滿足特定條件的元素。</p> <p>搜尋演算法可根據實現思路分為以下兩類。</p> <ul> <li>透過走訪資料結構來定位目標元素，例如陣列、鏈結串列、樹和圖的走訪等。</li> <li>利用資料組織結構或資料包含的先驗資訊，實現高效元素查詢，例如二分搜尋、雜湊查詢和二元搜尋樹查詢等。</li> </ul> <p>不難發現，這些知識點都已在前面的章節中介紹過，因此搜尋演算法對於我們來說並不陌生。在本節中，我們將從更加系統的視角切入，重新審視搜尋演算法。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1051","level":2,"title":"10.5.1   暴力搜尋","text":"<p>暴力搜尋透過走訪資料結構的每個元素來定位目標元素。</p> <ul> <li>“線性搜尋”適用於陣列和鏈結串列等線性資料結構。它從資料結構的一端開始，逐個訪問元素，直到找到目標元素或到達另一端仍沒有找到目標元素為止。</li> <li>“廣度優先搜尋”和“深度優先搜尋”是圖和樹的兩種走訪策略。廣度優先搜尋從初始節點開始逐層搜尋，由近及遠地訪問各個節點。深度優先搜尋從初始節點開始，沿著一條路徑走到頭，再回溯並嘗試其他路徑，直到走訪完整個資料結構。</li> </ul> <p>暴力搜尋的優點是簡單且通用性好，無須對資料做預處理和藉助額外的資料結構。</p> <p>然而，此類演算法的時間複雜度為 \\(O(n)\\) ，其中 \\(n\\) 為元素數量，因此在資料量較大的情況下效能較差。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1052","level":2,"title":"10.5.2   自適應搜尋","text":"<p>自適應搜尋利用資料的特有屬性（例如有序性）來最佳化搜尋過程，從而更高效地定位目標元素。</p> <ul> <li>“二分搜尋”利用資料的有序性實現高效查詢，僅適用於陣列。</li> <li>“雜湊查詢”利用雜湊表將搜尋資料和目標資料建立為鍵值對對映，從而實現查詢操作。</li> <li>“樹查詢”在特定的樹結構（例如二元搜尋樹）中，基於比較節點值來快速排除節點，從而定位目標元素。</li> </ul> <p>此類演算法的優點是效率高，時間複雜度可達到 \\(O(\\log n)\\) 甚至 \\(O(1)\\) 。</p> <p>然而，使用這些演算法往往需要對資料進行預處理。例如，二分搜尋需要預先對陣列進行排序，雜湊查詢和樹查詢都需要藉助額外的資料結構，維護這些資料結構也需要額外的時間和空間開銷。</p> <p>Tip</p> <p>自適應搜尋演算法常被稱為查詢演算法，主要用於在特定資料結構中快速檢索目標元素。</p>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/searching_algorithm_revisited/#1053","level":2,"title":"10.5.3   搜尋方法選取","text":"<p>給定大小為 \\(n\\) 的一組資料，我們可以使用線性搜尋、二分搜尋、樹查詢、雜湊查詢等多種方法從中搜索目標元素。各個方法的工作原理如圖 10-11 所示。</p> <p></p> <p> 圖 10-11   多種搜尋策略 </p> <p>上述幾種方法的操作效率與特性如表 10-1 所示。</p> <p> 表 10-1   查詢演算法效率對比 </p> 線性搜尋 二分搜尋 樹查詢 雜湊查詢 查詢元素 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) 插入元素 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 刪除元素 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) 額外空間 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) 資料預處理 / 排序 \\(O(n \\log n)\\) 建樹 \\(O(n \\log n)\\) 建雜湊表 \\(O(n)\\) 資料是否有序 無序 有序 有序 無序 <p>搜尋演算法的選擇還取決規模、搜尋效能要求、資料查詢與更新頻率等。</p> <p>線性搜尋</p> <ul> <li>通用性較好，無須任何資料預處理操作。假如我們僅需查詢一次資料，那麼其他三種方法的資料預處理的時間比線性搜尋的時間還要更長。</li> <li>適用於體量較小的資料，此情況下時間複雜度對效率影響較小。</li> <li>適用於資料更新頻率較高的場景，因為該方法不需要對資料進行任何額外維護。</li> </ul> <p>二分搜尋</p> <ul> <li>適用於大資料量的情況，效率表現穩定，最差時間複雜度為 \\(O(\\log n)\\) 。</li> <li>資料量不能過大，因為儲存陣列需要連續的記憶體空間。</li> <li>不適用於高頻增刪資料的場景，因為維護有序陣列的開銷較大。</li> </ul> <p>雜湊查詢</p> <ul> <li>適合對查詢效能要求很高的場景，平均時間複雜度為 \\(O(1)\\) 。</li> <li>不適合需要有序資料或範圍查詢的場景，因為雜湊表無法維護資料的有序性。</li> <li>對雜湊函式和雜湊衝突處理策略的依賴性較高，具有較大的效能劣化風險。</li> <li>不適合資料量過大的情況，因為雜湊表需要額外空間來最大程度地減少衝突，從而提供良好的查詢效能。</li> </ul> <p>樹查詢</p> <ul> <li>適用於海量資料，因為樹節點在記憶體中是分散儲存的。</li> <li>適合需要維護有序資料或範圍查詢的場景。</li> <li>在持續增刪節點的過程中，二元搜尋樹可能產生傾斜，時間複雜度劣化至 \\(O(n)\\) 。</li> <li>若使用 AVL 樹或紅黑樹，則各項操作可在 \\(O(\\log n)\\) 效率下穩定執行，但維護樹平衡的操作會增加額外的開銷。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.5 &nbsp; 重識搜尋演算法"],"tags":[]},{"location":"chapter_searching/summary/","level":1,"title":"10.6   小結","text":"","path":["第 10 章 &nbsp; 搜尋","10.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_searching/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>二分搜尋依賴資料的有序性，透過迴圈逐步縮減一半搜尋區間來進行查詢。它要求輸入資料有序，且僅適用於陣列或基於陣列實現的資料結構。</li> <li>暴力搜尋透過走訪資料結構來定位資料。線性搜尋適用於陣列和鏈結串列，廣度優先搜尋和深度優先搜尋適用於圖和樹。此類演算法通用性好，無須對資料進行預處理，但時間複雜度 \\(O(n)\\) 較高。</li> <li>雜湊查詢、樹查詢和二分搜尋屬於高效搜尋方法，可在特定資料結構中快速定位目標元素。此類演算法效率高，時間複雜度可達 \\(O(\\log n)\\) 甚至 \\(O(1)\\) ，但通常需要藉助額外資料結構。</li> <li>實際中，我們需要對資料規模、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。</li> <li>線性搜尋適用於小型或頻繁更新的資料；二分搜尋適用於大型、排序的資料；雜湊查詢適用於對查詢效率要求較高且無須範圍查詢的資料；樹查詢適用於需要維護順序和支持範圍查詢的大型動態資料。</li> <li>用雜湊查詢替換線性查詢是一種常用的最佳化執行時間的策略，可將時間複雜度從 \\(O(n)\\) 降至 \\(O(1)\\) 。</li> </ul>","path":["第 10 章 &nbsp; 搜尋","10.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/","level":1,"title":"第 11 章   排序","text":"<p>Abstract</p> <p>排序猶如一把將混亂變為秩序的魔法鑰匙，使我們能以更高效的方式理解與處理資料。</p> <p>無論是簡單的升序，還是複雜的分類排列，排序都向我們展示了資料的和諧美感。</p>","path":["第 11 章 &nbsp; 排序"],"tags":[]},{"location":"chapter_sorting/#_1","level":2,"title":"本章內容","text":"<ul> <li>11.1   排序演算法</li> <li>11.2   選擇排序</li> <li>11.3   泡沫排序</li> <li>11.4   插入排序</li> <li>11.5   快速排序</li> <li>11.6   合併排序</li> <li>11.7   堆積排序</li> <li>11.8   桶排序</li> <li>11.9   計數排序</li> <li>11.10   基數排序</li> <li>11.11   小結</li> </ul>","path":["第 11 章 &nbsp; 排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/","level":1,"title":"11.3   泡沫排序","text":"<p>泡沫排序（bubble sort）透過連續地比較與交換相鄰元素實現排序。這個過程就像氣泡從底部升到頂部一樣，因此得名泡沫排序。</p> <p>如圖 11-4 所示，冒泡過程可以利用元素交換操作來模擬：從陣列最左端開始向右走訪，依次比較相鄰元素大小，如果“左元素 &gt; 右元素”就交換二者。走訪完成後，最大的元素會被移動到陣列的最右端。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-4   利用元素交換操作模擬冒泡 </p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1131","level":2,"title":"11.3.1   演算法流程","text":"<p>設陣列的長度為 \\(n\\) ，泡沫排序的步驟如圖 11-5 所示。</p> <ol> <li>首先，對 \\(n\\) 個元素執行“冒泡”，將陣列的最大元素交換至正確位置。</li> <li>接下來，對剩餘 \\(n - 1\\) 個元素執行“冒泡”，將第二大元素交換至正確位置。</li> <li>以此類推，經過 \\(n - 1\\) 輪“冒泡”後，前 \\(n - 1\\) 大的元素都被交換至正確位置。</li> <li>僅剩的一個元素必定是最小元素，無須排序，因此陣列排序完成。</li> </ol> <p></p> <p> 圖 11-5   泡沫排序流程 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort(nums: list[int]):\n    \"\"\"泡沫排序\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(n - 1, 0, -1):\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n</code></pre> bubble_sort.cpp<pre><code>/* 泡沫排序 */\nvoid bubbleSort(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                // 這裡使用了 std::swap() 函式\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* 泡沫排序 */\nvoid bubbleSort(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* 泡沫排序 */\nvoid BubbleSort(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* 泡沫排序 */\nfunc bubbleSort(nums []int) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* 泡沫排序 */\nfunc bubbleSort(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swapAt(j, j + 1)\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* 泡沫排序 */\nfunction bubbleSort(nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* 泡沫排序 */\nfunction bubbleSort(nums: number[]): void {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* 泡沫排序 */\nvoid bubbleSort(List&lt;int&gt; nums) {\n  // 外迴圈：未排序區間為 [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* 泡沫排序 */\nfn bubble_sort(nums: &amp;mut [i32]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swap(j, j + 1);\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* 泡沫排序 */\nvoid bubbleSort(int nums[], int size) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* 泡沫排序 */\nfun bubbleSort(nums: IntArray) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n            }\n        }\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### 泡沫排序 ###\ndef bubble_sort(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (n - 1).downto(1)\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n      end\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1132","level":2,"title":"11.3.2   效率最佳化","text":"<p>我們發現，如果某輪“冒泡”中沒有執行任何交換操作，說明陣列已經完成排序，可直接返回結果。因此，可以增加一個標誌位 <code>flag</code> 來監測這種情況，一旦出現就立即返回。</p> <p>經過最佳化，泡沫排序的最差時間複雜度和平均時間複雜度仍為 \\(O(n^2)\\) ；但當輸入陣列完全有序時，可達到最佳時間複雜度 \\(O(n)\\) 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bubble_sort.py<pre><code>def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"泡沫排序（標誌最佳化）\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [0, i]\n    for i in range(n - 1, 0, -1):\n        flag = False  # 初始化標誌位\n        # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in range(i):\n            if nums[j] &gt; nums[j + 1]:\n                # 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # 記錄交換元素\n        if not flag:\n            break  # 此輪“冒泡”未交換任何元素，直接跳出\n</code></pre> bubble_sort.cpp<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.size() - 1; i &gt; 0; i--) {\n        bool flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                // 這裡使用了 std::swap() 函式\n                swap(nums[j], nums[j + 1]);\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag)\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.java<pre><code>/* 泡沫排序（標誌最佳化） */\nvoid bubbleSortWithFlag(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        boolean flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag)\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.cs<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid BubbleSortWithFlag(int[] nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        bool flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // 記錄交換元素\n            }\n        }\n        if (!flag) break;     // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.go<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunc bubbleSortWithFlag(nums []int) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i := len(nums) - 1; i &gt; 0; i-- {\n        flag := false // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j := 0; j &lt; i; j++ {\n            if nums[j] &gt; nums[j+1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // 記錄交換元素\n            }\n        }\n        if flag == false { // 此輪“冒泡”未交換任何元素，直接跳出\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.swift<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // 初始化標誌位\n        for j in 0 ..&lt; i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // 記錄交換元素\n            }\n        }\n        if !flag { // 此輪“冒泡”未交換任何元素，直接跳出\n            break\n        }\n    }\n}\n</code></pre> bubble_sort.js<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunction bubbleSortWithFlag(nums) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.ts<pre><code>/* 泡沫排序（標誌最佳化）*/\nfunction bubbleSortWithFlag(nums: number[]): void {\n    // 外迴圈：未排序區間為 [0, i]\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        let flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (let j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // 記錄交換元素\n            }\n        }\n        if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.dart<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(List&lt;int&gt; nums) {\n  // 外迴圈：未排序區間為 [0, i]\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    bool flag = false; // 初始化標誌位\n    // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for (int j = 0; j &lt; i; j++) {\n      if (nums[j] &gt; nums[j + 1]) {\n        // 交換 nums[j] 與 nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // 記錄交換元素\n      }\n    }\n    if (!flag) break; // 此輪“冒泡”未交換任何元素，直接跳出\n  }\n}\n</code></pre> bubble_sort.rs<pre><code>/* 泡沫排序（標誌最佳化） */\nfn bubble_sort_with_flag(nums: &amp;mut [i32]) {\n    // 外迴圈：未排序區間為 [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut flag = false; // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for j in 0..i {\n            if nums[j] &gt; nums[j + 1] {\n                // 交換 nums[j] 與 nums[j + 1]\n                nums.swap(j, j + 1);\n                flag = true; // 記錄交換元素\n            }\n        }\n        if !flag {\n            break; // 此輪“冒泡”未交換任何元素，直接跳出\n        };\n    }\n}\n</code></pre> bubble_sort.c<pre><code>/* 泡沫排序（標誌最佳化）*/\nvoid bubbleSortWithFlag(int nums[], int size) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (int i = size - 1; i &gt; 0; i--) {\n        bool flag = false;\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (int j = 0; j &lt; i; j++) {\n            if (nums[j] &gt; nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n</code></pre> bubble_sort.kt<pre><code>/* 泡沫排序（標誌最佳化） */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // 外迴圈：未排序區間為 [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var flag = false // 初始化標誌位\n        // 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n        for (j in 0..&lt;i) {\n            if (nums[j] &gt; nums[j + 1]) {\n                // 交換 nums[j] 與 nums[j + 1]\n                val temp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = temp\n                flag = true // 記錄交換元素\n            }\n        }\n        if (!flag) break // 此輪“冒泡”未交換任何元素，直接跳出\n    }\n}\n</code></pre> bubble_sort.rb<pre><code>### 泡沫排序（標誌最佳化）###\ndef bubble_sort_with_flag(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [0, i]\n  for i in (n - 1).downto(1)\n    flag = false # 初始化標誌位\n\n    # 內迴圈：將未排序區間 [0, i] 中的最大元素交換至該區間的最右端\n    for j in 0...i\n      if nums[j] &gt; nums[j + 1]\n        # 交換 nums[j] 與 nums[j + 1]\n        nums[j], nums[j + 1] = nums[j + 1], nums[j]\n        flag = true # 記錄交換元素\n      end\n    end\n\n    break unless flag # 此輪“冒泡”未交換任何元素，直接跳出\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bubble_sort/#1133","level":2,"title":"11.3.3   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、自適應排序：各輪“冒泡”走訪的陣列長度依次為 \\(n - 1\\)、\\(n - 2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，總和為 \\((n - 1) n / 2\\) 。在引入 <code>flag</code> 最佳化後，最佳時間複雜度可達到 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>穩定排序：由於在“冒泡”中遇到相等元素不交換。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.3 &nbsp; 泡沫排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/","level":1,"title":"11.8   桶排序","text":"<p>前述幾種排序演算法都屬於“基於比較的排序演算法”，它們透過比較元素間的大小來實現排序。此類排序演算法的時間複雜度無法超越 \\(O(n \\log n)\\) 。接下來，我們將探討幾種“非比較排序演算法”，它們的時間複雜度可以達到線性階。</p> <p>桶排序（bucket sort）是分治策略的一個典型應用。它透過設定一些具有大小順序的桶，每個桶對應一個數據範圍，將資料平均分配到各個桶中；然後，在每個桶內部分別執行排序；最終按照桶的順序將所有資料合併。</p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1181","level":2,"title":"11.8.1   演算法流程","text":"<p>考慮一個長度為 \\(n\\) 的陣列，其元素是範圍 \\([0, 1)\\) 內的浮點數。桶排序的流程如圖 11-13 所示。</p> <ol> <li>初始化 \\(k\\) 個桶，將 \\(n\\) 個元素分配到 \\(k\\) 個桶中。</li> <li>對每個桶分別執行排序（這裡採用程式語言的內建排序函式）。</li> <li>按照桶從小到大的順序合併結果。</li> </ol> <p></p> <p> 圖 11-13   桶排序演算法流程 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby bucket_sort.py<pre><code>def bucket_sort(nums: list[float]):\n    \"\"\"桶排序\"\"\"\n    # 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. 將陣列元素分配到各個桶中\n    for num in nums:\n        # 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        i = int(num * k)\n        # 將 num 新增進桶 i\n        buckets[i].append(num)\n    # 2. 對各個桶執行排序\n    for bucket in buckets:\n        # 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort()\n    # 3. 走訪桶合併結果\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\n</code></pre> bucket_sort.cpp<pre><code>/* 桶排序 */\nvoid bucketSort(vector&lt;float&gt; &amp;nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.size() / 2;\n    vector&lt;vector&lt;float&gt;&gt; buckets(k);\n    // 1. 將陣列元素分配到各個桶中\n    for (float num : nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = num * k;\n        // 將 num 新增進桶 bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. 對各個桶執行排序\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. 走訪桶合併結果\n    int i = 0;\n    for (vector&lt;float&gt; &amp;bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.java<pre><code>/* 桶排序 */\nvoid bucketSort(float[] nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.length / 2;\n    List&lt;List&lt;Float&gt;&gt; buckets = new ArrayList&lt;&gt;();\n    for (int i = 0; i &lt; k; i++) {\n        buckets.add(new ArrayList&lt;&gt;());\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (float num : nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = (int) (num * k);\n        // 將 num 新增進桶 i\n        buckets.get(i).add(num);\n    }\n    // 2. 對各個桶執行排序\n    for (List&lt;Float&gt; bucket : buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        Collections.sort(bucket);\n    }\n    // 3. 走訪桶合併結果\n    int i = 0;\n    for (List&lt;Float&gt; bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.cs<pre><code>/* 桶排序 */\nvoid BucketSort(float[] nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    int k = nums.Length / 2;\n    List&lt;List&lt;float&gt;&gt; buckets = [];\n    for (int i = 0; i &lt; k; i++) {\n        buckets.Add([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    foreach (float num in nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        int i = (int)(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].Add(num);\n    }\n    // 2. 對各個桶執行排序\n    foreach (List&lt;float&gt; bucket in buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.Sort();\n    }\n    // 3. 走訪桶合併結果\n    int j = 0;\n    foreach (List&lt;float&gt; bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.go<pre><code>/* 桶排序 */\nfunc bucketSort(nums []float64) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i &lt; k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for _, num := range nums {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        i := int(num * float64(k))\n        // 將 num 新增進桶 i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. 對各個桶執行排序\n    for i := 0; i &lt; k; i++ {\n        // 使用內建切片排序函式，也可以替換成其他排序演算法\n        sort.Float64s(buckets[i])\n    }\n    // 3. 走訪桶合併結果\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> bucket_sort.swift<pre><code>/* 桶排序 */\nfunc bucketSort(nums: inout [Double]) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    let k = nums.count / 2\n    var buckets = (0 ..&lt; k).map { _ in [Double]() }\n    // 1. 將陣列元素分配到各個桶中\n    for num in nums {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        let i = Int(num * Double(k))\n        // 將 num 新增進桶 i\n        buckets[i].append(num)\n    }\n    // 2. 對各個桶執行排序\n    for i in buckets.indices {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        buckets[i].sort()\n    }\n    // 3. 走訪桶合併結果\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> bucket_sort.js<pre><code>/* 桶排序 */\nfunction bucketSort(nums) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (const num of nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        const i = Math.floor(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for (const bucket of buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. 走訪桶合併結果\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.ts<pre><code>/* 桶排序 */\nfunction bucketSort(nums: number[]): void {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i &lt; k; i++) {\n        buckets.push([]);\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (const num of nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        const i = Math.floor(num * k);\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for (const bucket of buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort((a, b) =&gt; a - b);\n    }\n    // 3. 走訪桶合併結果\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n</code></pre> bucket_sort.dart<pre><code>/* 桶排序 */\nvoid bucketSort(List&lt;double&gt; nums) {\n  // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n  int k = nums.length ~/ 2;\n  List&lt;List&lt;double&gt;&gt; buckets = List.generate(k, (index) =&gt; []);\n\n  // 1. 將陣列元素分配到各個桶中\n  for (double _num in nums) {\n    // 輸入資料範圍為 [0, 1)，使用 _num * k 對映到索引範圍 [0, k-1]\n    int i = (_num * k).toInt();\n    // 將 _num 新增進桶 bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. 對各個桶執行排序\n  for (List&lt;double&gt; bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. 走訪桶合併結果\n  int i = 0;\n  for (List&lt;double&gt; bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n</code></pre> bucket_sort.rs<pre><code>/* 桶排序 */\nfn bucket_sort(nums: &amp;mut [f64]) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. 將陣列元素分配到各個桶中\n    for &amp;num in nums.iter() {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        let i = (num * k as f64) as usize;\n        // 將 num 新增進桶 i\n        buckets[i].push(num);\n    }\n    // 2. 對各個桶執行排序\n    for bucket in &amp;mut buckets {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. 走訪桶合併結果\n    let mut i = 0;\n    for bucket in buckets.iter() {\n        for &amp;num in bucket.iter() {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> bucket_sort.c<pre><code>/* 桶排序 */\nvoid bucketSort(float nums[], int n) {\n    int k = n / 2;                                 // 初始化 k = n/2 個桶\n    int *sizes = malloc(k * sizeof(int));          // 記錄每個桶的大小\n    float **buckets = malloc(k * sizeof(float *)); // 動態陣列的陣列（桶）\n    // 為每個桶預分配足夠的空間\n    for (int i = 0; i &lt; k; ++i) {\n        buckets[i] = (float *)malloc(n * sizeof(float));\n        sizes[i] = 0;\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (int i = 0; i &lt; n; ++i) {\n        int idx = (int)(nums[i] * k);\n        buckets[idx][sizes[idx]++] = nums[i];\n    }\n    // 2. 對各個桶執行排序\n    for (int i = 0; i &lt; k; ++i) {\n        qsort(buckets[i], sizes[i], sizeof(float), compare);\n    }\n    // 3. 合併排序後的桶\n    int idx = 0;\n    for (int i = 0; i &lt; k; ++i) {\n        for (int j = 0; j &lt; sizes[i]; ++j) {\n            nums[idx++] = buckets[i][j];\n        }\n        // 釋放記憶體\n        free(buckets[i]);\n    }\n}\n</code></pre> bucket_sort.kt<pre><code>/* 桶排序 */\nfun bucketSort(nums: FloatArray) {\n    // 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n    val k = nums.size / 2\n    val buckets = mutableListOf&lt;MutableList&lt;Float&gt;&gt;()\n    for (i in 0..&lt;k) {\n        buckets.add(mutableListOf())\n    }\n    // 1. 將陣列元素分配到各個桶中\n    for (num in nums) {\n        // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n        val i = (num * k).toInt()\n        // 將 num 新增進桶 i\n        buckets[i].add(num)\n    }\n    // 2. 對各個桶執行排序\n    for (bucket in buckets) {\n        // 使用內建排序函式，也可以替換成其他排序演算法\n        bucket.sort()\n    }\n    // 3. 走訪桶合併結果\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n</code></pre> bucket_sort.rb<pre><code>### 桶排序 ###\ndef bucket_sort(nums)\n  # 初始化 k = n/2 個桶，預期向每個桶分配 2 個元素\n  k = nums.length / 2\n  buckets = Array.new(k) { [] }\n\n  # 1. 將陣列元素分配到各個桶中\n  nums.each do |num|\n    # 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]\n    i = (num * k).to_i\n    # 將 num 新增進桶 i\n    buckets[i] &lt;&lt; num\n  end\n\n  # 2. 對各個桶執行排序\n  buckets.each do |bucket|\n    # 使用內建排序函式，也可以替換成其他排序演算法\n    bucket.sort!\n  end\n\n  # 3. 走訪桶合併結果\n  i = 0\n  buckets.each do |bucket|\n    bucket.each do |num|\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1182","level":2,"title":"11.8.2   演算法特性","text":"<p>桶排序適用於處理體量很大的資料。例如，輸入資料包含 100 萬個元素，由於空間限制，系統記憶體無法一次性載入所有資料。此時，可以將資料分成 1000 個桶，然後分別對每個桶進行排序，最後將結果合併。</p> <ul> <li>時間複雜度為 \\(O(n + k)\\) ：假設元素在各個桶內平均分佈，那麼每個桶內的元素數量為 \\(\\frac{n}{k}\\) 。假設排序單個桶使用 \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) 時間，則排序所有桶使用 \\(O(n \\log\\frac{n}{k})\\) 時間。當桶數量 \\(k\\) 比較大時，時間複雜度則趨向於 \\(O(n)\\) 。合併結果時需要走訪所有桶和元素，花費 \\(O(n + k)\\) 時間。在最差情況下，所有資料被分配到一個桶中，且排序該桶使用 \\(O(n^2)\\) 時間。</li> <li>空間複雜度為 \\(O(n + k)\\)、非原地排序：需要藉助 \\(k\\) 個桶和總共 \\(n\\) 個元素的額外空間。</li> <li>桶排序是否穩定取決於排序桶內元素的演算法是否穩定。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/bucket_sort/#1183","level":2,"title":"11.8.3   如何實現平均分配","text":"<p>桶排序的時間複雜度理論上可以達到 \\(O(n)\\) ，關鍵在於將元素均勻分配到各個桶中，因為實際資料往往不是均勻分佈的。例如，我們想要將淘寶上的所有商品按價格範圍平均分配到 10 個桶中，但商品價格分佈不均，低於 100 元的非常多，高於 1000 元的非常少。若將價格區間平均劃分為 10 個，各個桶中的商品數量差距會非常大。</p> <p>為實現平均分配，我們可以先設定一條大致的分界線，將資料粗略地分到 3 個桶中。分配完畢後，再將商品較多的桶繼續劃分為 3 個桶，直至所有桶中的元素數量大致相等。</p> <p>如圖 11-14 所示，這種方法本質上是建立一棵遞迴樹，目標是讓葉節點的值儘可能平均。當然，不一定要每輪將資料劃分為 3 個桶，具體劃分方式可根據資料特點靈活選擇。</p> <p></p> <p> 圖 11-14   遞迴劃分桶 </p> <p>如果我們提前知道商品價格的機率分佈，則可以根據資料機率分佈設定每個桶的價格分界線。值得注意的是，資料分佈並不一定需要特意統計，也可以根據資料特點採用某種機率模型進行近似。</p> <p>如圖 11-15 所示，我們假設商品價格服從正態分佈，這樣就可以合理地設定價格區間，從而將商品平均分配到各個桶中。</p> <p></p> <p> 圖 11-15   根據機率分佈劃分桶 </p>","path":["第 11 章 &nbsp; 排序","11.8 &nbsp; 桶排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/","level":1,"title":"11.9   計數排序","text":"<p>計數排序（counting sort）透過統計元素數量來實現排序，通常應用於整數陣列。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1191","level":2,"title":"11.9.1   簡單實現","text":"<p>先來看一個簡單的例子。給定一個長度為 \\(n\\) 的陣列 <code>nums</code> ，其中的元素都是“非負整數”，計數排序的整體流程如圖 11-16 所示。</p> <ol> <li>走訪陣列，找出其中的最大數字，記為 \\(m\\) ，然後建立一個長度為 \\(m + 1\\) 的輔助陣列 <code>counter</code> 。</li> <li>藉助 <code>counter</code> 統計 <code>nums</code> 中各數字的出現次數，其中 <code>counter[num]</code> 對應數字 <code>num</code> 的出現次數。統計方法很簡單，只需走訪 <code>nums</code>（設當前數字為 <code>num</code>），每輪將 <code>counter[num]</code> 增加 \\(1\\) 即可。</li> <li>由於 <code>counter</code> 的各個索引天然有序，因此相當於所有數字已經排序好了。接下來，我們走訪 <code>counter</code> ，根據各數字出現次數從小到大的順序填入 <code>nums</code> 即可。</li> </ol> <p></p> <p> 圖 11-16   計數排序流程 </p> <p>程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort_naive(nums: list[int]):\n    \"\"\"計數排序\"\"\"\n    # 簡單實現，無法用於排序物件\n    # 1. 統計陣列最大元素 m\n    m = max(nums)\n    # 2. 統計各數字的出現次數\n    # counter[num] 代表 num 的出現次數\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. 走訪 counter ，將各元素填入原陣列 nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\n</code></pre> counting_sort.cpp<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(vector&lt;int&gt; &amp;nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.java<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid CountingSortNaive(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunc countingSortNaive(nums []int) {\n    // 1. 統計陣列最大元素 m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    for i, num := 0, 0; num &lt; m+1; num++ {\n        for j := 0; j &lt; counter[num]; j++ {\n            nums[i] = num\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.swift<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunc countingSortNaive(nums: inout [Int]) {\n    // 1. 統計陣列最大元素 m\n    let m = nums.max()!\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    var i = 0\n    for num in 0 ..&lt; m + 1 {\n        for _ in 0 ..&lt; counter[num] {\n            nums[i] = num\n            i += 1\n        }\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunction countingSortNaive(nums) {\n    // 1. 統計陣列最大元素 m\n    let m = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfunction countingSortNaive(nums: number[]): void {\n    // 1. 統計陣列最大元素 m\n    let m: number = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let i = 0;\n    for (let num = 0; num &lt; m + 1; num++) {\n        for (let j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(List&lt;int&gt; nums) {\n  // 1. 統計陣列最大元素 m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 統計各數字的出現次數\n  // counter[_num] 代表 _num 的出現次數\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. 走訪 counter ，將各元素填入原陣列 nums\n  int i = 0;\n  for (int _num = 0; _num &lt; m + 1; _num++) {\n    for (int j = 0; j &lt; counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n</code></pre> counting_sort.rs<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfn counting_sort_naive(nums: &amp;mut [i32]) {\n    // 1. 統計陣列最大元素 m\n    let m = *nums.iter().max().unwrap();\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    let mut counter = vec![0; m as usize + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\n        }\n    }\n}\n</code></pre> counting_sort.c<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nvoid countingSortNaive(int nums[], int size) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    int i = 0;\n    for (int num = 0; num &lt; m + 1; num++) {\n        for (int j = 0; j &lt; counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. 釋放記憶體\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計數排序 */\n// 簡單實現，無法用於排序物件\nfun countingSortNaive(nums: IntArray) {\n    // 1. 統計陣列最大元素 m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. 走訪 counter ，將各元素填入原陣列 nums\n    var i = 0\n    for (num in 0..&lt;m + 1) {\n        var j = 0\n        while (j &lt; counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計數排序 ###\ndef counting_sort_naive(nums)\n  # 簡單實現，無法用於排序物件\n  # 1. 統計陣列最大元素 m\n  m = 0\n  nums.each { |num| m = [m, num].max }\n  # 2. 統計各數字的出現次數\n  # counter[num] 代表 num 的出現次數\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. 走訪 counter ，將各元素填入原陣列 nums\n  i = 0\n  for num in 0...(m + 1)\n    (0...counter[num]).each do\n      nums[i] = num\n      i += 1\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>計數排序與桶排序的關聯</p> <p>從桶排序的角度看，我們可以將計數排序中的計數陣列 <code>counter</code> 的每個索引視為一個桶，將統計數量的過程看作將各個元素分配到對應的桶中。本質上，計數排序是桶排序在整型資料下的一個特例。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1192","level":2,"title":"11.9.2   完整實現","text":"<p>細心的讀者可能發現了，如果輸入資料是物件，上述步驟 <code>3.</code> 就失效了。假設輸入資料是商品物件，我們想按照商品價格（類別的成員變數）對商品進行排序，而上述演算法只能給出價格的排序結果。</p> <p>那麼如何才能得到原資料的排序結果呢？我們首先計算 <code>counter</code> 的“前綴和”。顧名思義，索引 <code>i</code> 處的前綴和 <code>prefix[i]</code> 等於陣列前 <code>i</code> 個元素之和：</p> \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\] <p>前綴和具有明確的意義，<code>prefix[num] - 1</code> 代表元素 <code>num</code> 在結果陣列 <code>res</code> 中最後一次出現的索引。這個資訊非常關鍵，因為它告訴我們各個元素應該出現在結果陣列的哪個位置。接下來，我們倒序走訪原陣列 <code>nums</code> 的每個元素 <code>num</code> ，在每輪迭代中執行以下兩步。</p> <ol> <li>將 <code>num</code> 填入陣列 <code>res</code> 的索引 <code>prefix[num] - 1</code> 處。</li> <li>令前綴和 <code>prefix[num]</code> 減小 \\(1\\) ，從而得到下次放置 <code>num</code> 的索引。</li> </ol> <p>走訪完成後，陣列 <code>res</code> 中就是排序好的結果，最後使用 <code>res</code> 覆蓋原陣列 <code>nums</code> 即可。圖 11-17 展示了完整的計數排序流程。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-17   計數排序步驟 </p> <p>計數排序的實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby counting_sort.py<pre><code>def counting_sort(nums: list[int]):\n    \"\"\"計數排序\"\"\"\n    # 完整實現，可排序物件，並且是穩定排序\n    # 1. 統計陣列最大元素 m\n    m = max(nums)\n    # 2. 統計各數字的出現次數\n    # counter[num] 代表 num 的出現次數\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    # 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in range(m):\n        counter[i + 1] += counter[i]\n    # 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    # 初始化陣列 res 用於記錄結果\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # 將 num 放置到對應索引處\n        counter[num] -= 1  # 令前綴和自減 1 ，得到下次放置 num 的索引\n    # 使用結果陣列 res 覆蓋原陣列 nums\n    for i in range(n):\n        nums[i] = res[i]\n</code></pre> counting_sort.cpp<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(vector&lt;int&gt; &amp;nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    vector&lt;int&gt; counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.size();\n    vector&lt;int&gt; res(n);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--;              // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    nums = res;\n}\n</code></pre> counting_sort.java<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int num : nums) {\n        m = Math.max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.cs<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid CountingSort(int[] nums) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    foreach (int num in nums) {\n        m = Math.Max(m, num);\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.go<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunc countingSort(nums []int) {\n    // 1. 統計陣列最大元素 m\n    m := 0\n    for _, num := range nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i := 0; i &lt; m; i++ {\n        counter[i+1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        num := nums[i]\n        // 將 num 放置到對應索引處\n        res[counter[num]-1] = num\n        // 令前綴和自減 1 ，得到下次放置 num 的索引\n        counter[num]--\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    copy(nums, res)\n}\n</code></pre> counting_sort.swift<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunc countingSort(nums: inout [Int]) {\n    // 1. 統計陣列最大元素 m\n    let m = nums.max()!\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in 0 ..&lt; m {\n        counter[i + 1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // 將 num 放置到對應索引處\n        counter[num] -= 1 // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.js<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunction countingSort(nums) {\n    // 1. 統計陣列最大元素 m\n    let m = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.ts<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfunction countingSort(nums: number[]): void {\n    // 1. 統計陣列最大元素 m\n    let m: number = Math.max(...nums);\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    const counter: number[] = new Array&lt;number&gt;(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (let i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    const n = nums.length;\n    const res: number[] = new Array&lt;number&gt;(n);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n</code></pre> counting_sort.dart<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(List&lt;int&gt; nums) {\n  // 1. 統計陣列最大元素 m\n  int m = 0;\n  for (int _num in nums) {\n    m = max(m, _num);\n  }\n  // 2. 統計各數字的出現次數\n  // counter[_num] 代表 _num 的出現次數\n  List&lt;int&gt; counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n  // 即 counter[_num]-1 是 _num 在 res 中最後一次出現的索引\n  for (int i = 0; i &lt; m; i++) {\n    counter[i + 1] += counter[i];\n  }\n  // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n  // 初始化陣列 res 用於記錄結果\n  int n = nums.length;\n  List&lt;int&gt; res = List.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // 將 _num 放置到對應索引處\n    counter[_num]--; // 令前綴和自減 1 ，得到下次放置 _num 的索引\n  }\n  // 使用結果陣列 res 覆蓋原陣列 nums\n  nums.setAll(0, res);\n}\n</code></pre> counting_sort.rs<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfn counting_sort(nums: &amp;mut [i32]) {\n    // 1. 統計陣列最大元素 m\n    let m = *nums.iter().max().unwrap() as usize;\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    let mut counter = vec![0; m + 1];\n    for &amp;num in nums.iter() {\n        counter[num as usize] += 1;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for i in 0..m {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // 將 num 放置到對應索引處\n        counter[num as usize] -= 1; // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    nums.copy_from_slice(&amp;res)\n}\n</code></pre> counting_sort.c<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nvoid countingSort(int nums[], int size) {\n    // 1. 統計陣列最大元素 m\n    int m = 0;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; m) {\n            m = nums[i];\n        }\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i &lt; size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (int i = 0; i &lt; m; i++) {\n        counter[i + 1] += counter[i];\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // 將 num 放置到對應索引處\n        counter[num]--;              // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    memcpy(nums, res, size * sizeof(int));\n    // 5. 釋放記憶體\n    free(res);\n    free(counter);\n}\n</code></pre> counting_sort.kt<pre><code>/* 計數排序 */\n// 完整實現，可排序物件，並且是穩定排序\nfun countingSort(nums: IntArray) {\n    // 1. 統計陣列最大元素 m\n    var m = 0\n    for (num in nums) {\n        m = max(m, num)\n    }\n    // 2. 統計各數字的出現次數\n    // counter[num] 代表 num 的出現次數\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n    // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n    for (i in 0..&lt;m) {\n        counter[i + 1] += counter[i]\n    }\n    // 4. 倒序走訪 nums ，將各元素填入結果陣列 res\n    // 初始化陣列 res 用於記錄結果\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // 將 num 放置到對應索引處\n        counter[num]-- // 令前綴和自減 1 ，得到下次放置 num 的索引\n    }\n    // 使用結果陣列 res 覆蓋原陣列 nums\n    for (i in 0..&lt;n) {\n        nums[i] = res[i]\n    }\n}\n</code></pre> counting_sort.rb<pre><code>### 計數排序 ###\ndef counting_sort(nums)\n  # 完整實現，可排序物件，並且是穩定排序\n  # 1. 統計陣列最大元素 m\n  m = nums.max\n  # 2. 統計各數字的出現次數\n  # counter[num] 代表 num 的出現次數\n  counter = Array.new(m + 1, 0)\n  nums.each { |num| counter[num] += 1 }\n  # 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”\n  # 即 counter[num]-1 是 num 在 res 中最後一次出現的索引\n  (0...m).each { |i| counter[i + 1] += counter[i] }\n  # 4. 倒序走訪 nums, 將各元素填入結果陣列 res\n  # 初始化陣列 res 用於記錄結果\n  n = nums.length\n  res = Array.new(n, 0)\n  (n - 1).downto(0).each do |i|\n    num = nums[i]\n    res[counter[num] - 1] = num # 將 num 放置到對應索引處\n    counter[num] -= 1 # 令前綴和自減 1 ，得到下次放置 num 的索引\n  end\n  # 使用結果陣列 res 覆蓋原陣列 nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1193","level":2,"title":"11.9.3   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n + m)\\)、非自適應排序 ：涉及走訪 <code>nums</code> 和走訪 <code>counter</code> ，都使用線性時間。一般情況下 \\(n \\gg m\\) ，時間複雜度趨於 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(n + m)\\)、非原地排序：藉助了長度分別為 \\(n\\) 和 \\(m\\) 的陣列 <code>res</code> 和 <code>counter</code> 。</li> <li>穩定排序：由於向 <code>res</code> 中填充元素的順序是“從右向左”的，因此倒序走訪 <code>nums</code> 可以避免改變相等元素之間的相對位置，從而實現穩定排序。實際上，正序走訪 <code>nums</code> 也可以得到正確的排序結果，但結果是非穩定的。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/counting_sort/#1194","level":2,"title":"11.9.4   侷限性","text":"<p>看到這裡，你也許會覺得計數排序非常巧妙，僅透過統計數量就可以實現高效的排序。然而，使用計數排序的前置條件相對較為嚴格。</p> <p>計數排序只適用於非負整數。若想將其用於其他型別的資料，需要確保這些資料可以轉換為非負整數，並且在轉換過程中不能改變各個元素之間的相對大小關係。例如，對於包含負數的整數陣列，可以先給所有數字加上一個常數，將全部數字轉化為正數，排序完成後再轉換回去。</p> <p>計數排序適用於資料量大但資料範圍較小的情況。比如，在上述示例中 \\(m\\) 不能太大，否則會佔用過多空間。而當 \\(n \\ll m\\) 時，計數排序使用 \\(O(m)\\) 時間，可能比 \\(O(n \\log n)\\) 的排序演算法還要慢。</p>","path":["第 11 章 &nbsp; 排序","11.9 &nbsp; 計數排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/","level":1,"title":"11.7   堆積排序","text":"<p>Tip</p> <p>閱讀本節前，請確保已學完“堆積”章節。</p> <p>堆積排序（heap sort）是一種基於堆積資料結構實現的高效排序演算法。我們可以利用已經學過的“建堆積操作”和“元素出堆積操作”實現堆積排序。</p> <ol> <li>輸入陣列並建立小頂堆積，此時最小元素位於堆積頂。</li> <li>不斷執行出堆積操作，依次記錄出堆積元素，即可得到從小到大排序的序列。</li> </ol> <p>以上方法雖然可行，但需要藉助一個額外陣列來儲存彈出的元素，比較浪費空間。在實際中，我們通常使用一種更加優雅的實現方式。</p>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1171","level":2,"title":"11.7.1   演算法流程","text":"<p>設陣列的長度為 \\(n\\) ，堆積排序的流程如圖 11-12 所示。</p> <ol> <li>輸入陣列並建立大頂堆積。完成後，最大元素位於堆積頂。</li> <li>將堆積頂元素（第一個元素）與堆積底元素（最後一個元素）交換。完成交換後，堆積的長度減 \\(1\\) ，已排序元素數量加 \\(1\\) 。</li> <li>從堆積頂元素開始，從頂到底執行堆積化操作（sift down）。完成堆積化後，堆積的性質得到修復。</li> <li>迴圈執行第 <code>2.</code> 步和第 <code>3.</code> 步。迴圈 \\(n - 1\\) 輪後，即可完成陣列排序。</li> </ol> <p>Tip</p> <p>實際上，元素出堆積操作中也包含第 <code>2.</code> 步和第 <code>3.</code> 步，只是多了一個彈出元素的步驟。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt;&lt;12&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-12   堆積排序步驟 </p> <p>在程式碼實現中，我們使用了與“堆積”章節相同的從頂至底堆積化 <code>sift_down()</code> 函式。值得注意的是，由於堆積的長度會隨著提取最大元素而減小，因此我們需要給 <code>sift_down()</code> 函式新增一個長度參數 \\(n\\) ，用於指定堆積的當前有效長度。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby heap_sort.py<pre><code>def sift_down(nums: list[int], n: int, i: int):\n    \"\"\"堆積的長度為 n ，從節點 i 開始，從頂至底堆積化\"\"\"\n    while True:\n        # 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l &lt; n and nums[l] &gt; nums[ma]:\n            ma = l\n        if r &lt; n and nums[r] &gt; nums[ma]:\n            ma = r\n        # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i:\n            break\n        # 交換兩節點\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # 迴圈向下堆積化\n        i = ma\n\ndef heap_sort(nums: list[int]):\n    \"\"\"堆積排序\"\"\"\n    # 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in range(len(nums) - 1, 0, -1):\n        # 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums[0], nums[i] = nums[i], nums[0]\n        # 以根節點為起點，從頂至底進行堆積化\n        sift_down(nums, i, 0)\n</code></pre> heap_sort.cpp<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(vector&lt;int&gt; &amp;nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) {\n            break;\n        }\n        // 交換兩節點\n        swap(nums[i], nums[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(vector&lt;int&gt; &amp;nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.size() / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.size() - 1; i &gt; 0; --i) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        swap(nums[0], nums[i]);\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.java<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int[] nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(int[] nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.length / 2 - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.cs<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid SiftDown(int[] nums, int n, int i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i)\n            break;\n        // 交換兩節點\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid HeapSort(int[] nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = nums.Length / 2 - 1; i &gt;= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = nums.Length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        (nums[i], nums[0]) = (nums[0], nums[i]);\n        // 以根節點為起點，從頂至底進行堆積化\n        SiftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.go<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(nums *[]int, n, i int) {\n    for true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l &lt; n &amp;&amp; (*nums)[l] &gt; (*nums)[ma] {\n            ma = l\n        }\n        if r &lt; n &amp;&amp; (*nums)[r] &gt; (*nums)[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfunc heapSort(nums *[]int) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i := len(*nums)/2 - 1; i &gt;= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i := len(*nums) - 1; i &gt; 0; i-- {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.swift<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\n    var i = i\n    while true {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l &lt; n, nums[l] &gt; nums[ma] {\n            ma = l\n        }\n        if r &lt; n, nums[r] &gt; nums[ma] {\n            ma = r\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break\n        }\n        // 交換兩節點\n        nums.swapAt(i, ma)\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfunc heapSort(nums: inout [Int]) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &amp;nums, n: nums.count, i: i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in nums.indices.dropFirst().reversed() {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums.swapAt(0, i)\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums: &amp;nums, n: i, i: 0)\n    }\n}\n</code></pre> heap_sort.js<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunction siftDown(nums, n, i) {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) {\n            break;\n        }\n        // 交換兩節點\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfunction heapSort(nums) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.ts<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfunction siftDown(nums: number[], n: number, i: number): void {\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) {\n            ma = l;\n        }\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma === i) {\n            break;\n        }\n        // 交換兩節點\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfunction heapSort(nums: number[]): void {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (let i = Math.floor(nums.length / 2) - 1; i &gt;= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (let i = nums.length - 1; i &gt; 0; i--) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        [nums[0], nums[i]] = [nums[i], nums[0]];\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.dart<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(List&lt;int&gt; nums, int n, int i) {\n  while (true) {\n    // 判斷節點 i, l, r 中值最大的節點，記為 ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) ma = l;\n    if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) ma = r;\n    // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    if (ma == i) break;\n    // 交換兩節點\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // 迴圈向下堆積化\n    i = ma;\n  }\n}\n\n/* 堆積排序 */\nvoid heapSort(List&lt;int&gt; nums) {\n  // 建堆積操作：堆積化除葉節點以外的其他所有節點\n  for (int i = nums.length ~/ 2 - 1; i &gt;= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // 從堆積中提取最大元素，迴圈 n-1 輪\n  for (int i = nums.length - 1; i &gt; 0; i--) {\n    // 交換根節點與最右葉節點（交換首元素與尾元素）\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // 以根節點為起點，從頂至底進行堆積化\n    siftDown(nums, i, 0);\n  }\n}\n</code></pre> heap_sort.rs<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfn sift_down(nums: &amp;mut [i32], n: usize, mut i: usize) {\n    loop {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l &lt; n &amp;&amp; nums[l] &gt; nums[ma] {\n            ma = l;\n        }\n        if r &lt; n &amp;&amp; nums[r] &gt; nums[ma] {\n            ma = r;\n        }\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if ma == i {\n            break;\n        }\n        // 交換兩節點\n        nums.swap(i, ma);\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nfn heap_sort(nums: &amp;mut [i32]) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for i in (0..nums.len() / 2).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for i in (1..nums.len()).rev() {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        nums.swap(0, i);\n        // 以根節點為起點，從頂至底進行堆積化\n        sift_down(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.c<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nvoid siftDown(int nums[], int n, int i) {\n    while (1) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma])\n            ma = l;\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma])\n            ma = r;\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) {\n            break;\n        }\n        // 交換兩節點\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // 迴圈向下堆積化\n        i = ma;\n    }\n}\n\n/* 堆積排序 */\nvoid heapSort(int nums[], int n) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (int i = n / 2 - 1; i &gt;= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (int i = n - 1; i &gt; 0; --i) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0);\n    }\n}\n</code></pre> heap_sort.kt<pre><code>/* 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // 判斷節點 i, l, r 中值最大的節點，記為 ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l &lt; n &amp;&amp; nums[l] &gt; nums[ma]) \n            ma = l\n        if (r &lt; n &amp;&amp; nums[r] &gt; nums[ma]) \n            ma = r\n        // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n        if (ma == i) \n            break\n        // 交換兩節點\n        val temp = nums[i]\n        nums[i] = nums[ma]\n        nums[ma] = temp\n        // 迴圈向下堆積化\n        i = ma\n    }\n}\n\n/* 堆積排序 */\nfun heapSort(nums: IntArray) {\n    // 建堆積操作：堆積化除葉節點以外的其他所有節點\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // 從堆積中提取最大元素，迴圈 n-1 輪\n    for (i in nums.size - 1 downTo 1) {\n        // 交換根節點與最右葉節點（交換首元素與尾元素）\n        val temp = nums[0]\n        nums[0] = nums[i]\n        nums[i] = temp\n        // 以根節點為起點，從頂至底進行堆積化\n        siftDown(nums, i, 0)\n    }\n}\n</code></pre> heap_sort.rb<pre><code>### 堆積的長度為 n ，從節點 i 開始，從頂至底堆積化 ###\ndef sift_down(nums, n, i)\n  while true\n    # 判斷節點 i, l, r 中值最大的節點，記為 ma\n    l = 2 * i + 1\n    r = 2 * i + 2\n    ma = i\n    ma = l if l &lt; n &amp;&amp; nums[l] &gt; nums[ma]\n    ma = r if r &lt; n &amp;&amp; nums[r] &gt; nums[ma]\n    # 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出\n    break if ma == i\n    # 交換兩節點\n    nums[i], nums[ma] = nums[ma], nums[i]\n    # 迴圈向下堆積化\n    i = ma\n  end\nend\n\n### 堆積排序 ###\ndef heap_sort(nums)\n  # 建堆積操作：堆積化除葉節點以外的其他所有節點\n  (nums.length / 2 - 1).downto(0) do |i|\n    sift_down(nums, nums.length, i)\n  end\n  # 從堆積中提取最大元素，迴圈 n-1 輪\n  (nums.length - 1).downto(1) do |i|\n    # 交換根節點與最右葉節點（交換首元素與尾元素）\n    nums[0], nums[i] = nums[i], nums[0]\n    # 以根節點為起點，從頂至底進行堆積化\n    sift_down(nums, i, 0)\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/heap_sort/#1172","level":2,"title":"11.7.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：建堆積操作使用 \\(O(n)\\) 時間。從堆積中提取最大元素的時間複雜度為 \\(O(\\log n)\\) ，共迴圈 \\(n - 1\\) 輪。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：幾個指標變數使用 \\(O(1)\\) 空間。元素交換和堆積化操作都是在原陣列上進行的。</li> <li>非穩定排序：在交換堆積頂元素和堆積底元素時，相等元素的相對位置可能發生變化。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.7 &nbsp; 堆積排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/","level":1,"title":"11.4   插入排序","text":"<p>插入排序（insertion sort）是一種簡單的排序演算法，它的工作原理與手動整理一副牌的過程非常相似。</p> <p>具體來說，我們在未排序區間選擇一個基準元素，將該元素與其左側已排序區間的元素逐一比較大小，並將該元素插入到正確的位置。</p> <p>圖 11-6 展示了陣列插入元素的操作流程。設基準元素為 <code>base</code> ，我們需要將從目標索引到 <code>base</code> 之間的所有元素向右移動一位，然後將 <code>base</code> 賦值給目標索引。</p> <p></p> <p> 圖 11-6   單次插入操作 </p>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1141","level":2,"title":"11.4.1   演算法流程","text":"<p>插入排序的整體流程如圖 11-7 所示。</p> <ol> <li>初始狀態下，陣列的第 1 個元素已完成排序。</li> <li>選取陣列的第 2 個元素作為 <code>base</code> ，將其插入到正確位置後，陣列的前 2 個元素已排序。</li> <li>選取第 3 個元素作為 <code>base</code> ，將其插入到正確位置後，陣列的前 3 個元素已排序。</li> <li>以此類推，在最後一輪中，選取最後一個元素作為 <code>base</code> ，將其插入到正確位置後，所有元素均已排序。</li> </ol> <p></p> <p> 圖 11-7   插入排序流程 </p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby insertion_sort.py<pre><code>def insertion_sort(nums: list[int]):\n    \"\"\"插入排序\"\"\"\n    # 外迴圈：已排序區間為 [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = i - 1\n        # 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0 and nums[j] &gt; base:\n            nums[j + 1] = nums[j]  # 將 nums[j] 向右移動一位\n            j -= 1\n        nums[j + 1] = base  # 將 base 賦值到正確位置\n</code></pre> insertion_sort.cpp<pre><code>/* 插入排序 */\nvoid insertionSort(vector&lt;int&gt; &amp;nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.size(); i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.java<pre><code>/* 插入排序 */\nvoid insertionSort(int[] nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.length; i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base;        // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.cs<pre><code>/* 插入排序 */\nvoid InsertionSort(int[] nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; nums.Length; i++) {\n        int bas = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; bas) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = bas;         // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.go<pre><code>/* 插入排序 */\nfunc insertionSort(nums []int) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i := 1; i &lt; len(nums); i++ {\n        base := nums[i]\n        j := i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        for j &gt;= 0 &amp;&amp; nums[j] &gt; base {\n            nums[j+1] = nums[j] // 將 nums[j] 向右移動一位\n            j--\n        }\n        nums[j+1] = base // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.swift<pre><code>/* 插入排序 */\nfunc insertionSort(nums: inout [Int]) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0, nums[j] &gt; base {\n            nums[j + 1] = nums[j] // 將 nums[j] 向右移動一位\n            j -= 1\n        }\n        nums[j + 1] = base // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.js<pre><code>/* 插入排序 */\nfunction insertionSort(nums) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        let base = nums[i],\n            j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.ts<pre><code>/* 插入排序 */\nfunction insertionSort(nums: number[]): void {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (let i = 1; i &lt; nums.length; i++) {\n        const base = nums[i];\n        let j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n            j--;\n        }\n        nums[j + 1] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.dart<pre><code>/* 插入排序 */\nvoid insertionSort(List&lt;int&gt; nums) {\n  // 外迴圈：已排序區間為 [0, i-1]\n  for (int i = 1; i &lt; nums.length; i++) {\n    int base = nums[i], j = i - 1;\n    // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n    while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n      nums[j + 1] = nums[j]; // 將 nums[j] 向右移動一位\n      j--;\n    }\n    nums[j + 1] = base; // 將 base 賦值到正確位置\n  }\n}\n</code></pre> insertion_sort.rs<pre><code>/* 插入排序 */\nfn insertion_sort(nums: &amp;mut [i32]) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while j &gt;= 0 &amp;&amp; nums[j as usize] &gt; base {\n            nums[(j + 1) as usize] = nums[j as usize]; // 將 nums[j] 向右移動一位\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = base; // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.c<pre><code>/* 插入排序 */\nvoid insertionSort(int nums[], int size) {\n    // 外迴圈：已排序區間為 [0, i-1]\n    for (int i = 1; i &lt; size; i++) {\n        int base = nums[i], j = i - 1;\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            // 將 nums[j] 向右移動一位\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // 將 base 賦值到正確位置\n        nums[j + 1] = base;\n    }\n}\n</code></pre> insertion_sort.kt<pre><code>/* 插入排序 */\nfun insertionSort(nums: IntArray) {\n    //外迴圈: 已排序元素為 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n        while (j &gt;= 0 &amp;&amp; nums[j] &gt; base) {\n            nums[j + 1] = nums[j] // 將 nums[j] 向右移動一位\n            j--\n        }\n        nums[j + 1] = base        // 將 base 賦值到正確位置\n    }\n}\n</code></pre> insertion_sort.rb<pre><code>### 插入排序 ###\ndef insertion_sort(nums)\n  n = nums.length\n  # 外迴圈：已排序區間為 [0, i-1]\n  for i in 1...n\n    base = nums[i]\n    j = i - 1\n    # 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置\n    while j &gt;= 0 &amp;&amp; nums[j] &gt; base\n      nums[j + 1] = nums[j] # 將 nums[j] 向右移動一位\n      j -= 1\n    end\n    nums[j + 1] = base # 將 base 賦值到正確位置\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1142","level":2,"title":"11.4.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、自適應排序：在最差情況下，每次插入操作分別需要迴圈 \\(n - 1\\)、\\(n-2\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) 次，求和得到 \\((n - 1) n / 2\\) ，因此時間複雜度為 \\(O(n^2)\\) 。在遇到有序資料時，插入操作會提前終止。當輸入陣列完全有序時，插入排序達到最佳時間複雜度 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>穩定排序：在插入操作過程中，我們會將元素插入到相等元素的右側，不會改變它們的順序。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/insertion_sort/#1143","level":2,"title":"11.4.3   插入排序的優勢","text":"<p>插入排序的時間複雜度為 \\(O(n^2)\\) ，而我們即將學習的快速排序的時間複雜度為 \\(O(n \\log n)\\) 。儘管插入排序的時間複雜度更高，但在資料量較小的情況下，插入排序通常更快。</p> <p>這個結論與線性查詢和二分搜尋的適用情況的結論類似。快速排序這類 \\(O(n \\log n)\\) 的演算法屬於基於分治策略的排序演算法，往往包含更多單元計算操作。而在資料量較小時，\\(n^2\\) 和 \\(n \\log n\\) 的數值比較接近，複雜度不佔主導地位，每輪中的單元操作數量起到決定性作用。</p> <p>實際上，許多程式語言（例如 Java）的內建排序函式採用了插入排序，大致思路為：對於長陣列，採用基於分治策略的排序演算法，例如快速排序；對於短陣列，直接使用插入排序。</p> <p>雖然泡沫排序、選擇排序和插入排序的時間複雜度都為 \\(O(n^2)\\) ，但在實際情況中，插入排序的使用頻率顯著高於泡沫排序和選擇排序，主要有以下原因。</p> <ul> <li>泡沫排序基於元素交換實現，需要藉助一個臨時變數，共涉及 3 個單元操作；插入排序基於元素賦值實現，僅需 1 個單元操作。因此，泡沫排序的計算開銷通常比插入排序更高。</li> <li>選擇排序在任何情況下的時間複雜度都為 \\(O(n^2)\\) 。如果給定一組部分有序的資料，插入排序通常比選擇排序效率更高。</li> <li>選擇排序不穩定，無法應用於多級排序。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.4 &nbsp; 插入排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/","level":1,"title":"11.6   合併排序","text":"<p>合併排序（merge sort）是一種基於分治策略的排序演算法，包含圖 11-10 所示的“劃分”和“合併”階段。</p> <ol> <li>劃分階段：透過遞迴不斷地將陣列從中點處分開，將長陣列的排序問題轉換為短陣列的排序問題。</li> <li>合併階段：當子陣列長度為 1 時終止劃分，開始合併，持續地將左右兩個較短的有序陣列合併為一個較長的有序陣列，直至結束。</li> </ol> <p></p> <p> 圖 11-10   合併排序的劃分與合併階段 </p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1161","level":2,"title":"11.6.1   演算法流程","text":"<p>如圖 11-11 所示，“劃分階段”從頂至底遞迴地將陣列從中點切分為兩個子陣列。</p> <ol> <li>計算陣列中點 <code>mid</code> ，遞迴劃分左子陣列（區間 <code>[left, mid]</code> ）和右子陣列（區間 <code>[mid + 1, right]</code> ）。</li> <li>遞迴執行步驟 <code>1.</code> ，直至子陣列區間長度為 1 時終止。</li> </ol> <p>“合併階段”從底至頂地將左子陣列和右子陣列合併為一個有序陣列。需要注意的是，從長度為 1 的子陣列開始合併，合併階段中的每個子陣列都是有序的。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-11   合併排序步驟 </p> <p>觀察發現，合併排序與二元樹後序走訪的遞迴順序是一致的。</p> <ul> <li>後序走訪：先遞迴左子樹，再遞迴右子樹，最後處理根節點。</li> <li>合併排序：先遞迴左子陣列，再遞迴右子陣列，最後處理合併。</li> </ul> <p>合併排序的實現如以下程式碼所示。請注意，<code>nums</code> 的待合併區間為 <code>[left, right]</code> ，而 <code>tmp</code> 的對應區間為 <code>[0, right - left]</code> 。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby merge_sort.py<pre><code>def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"合併左子陣列和右子陣列\"\"\"\n    # 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    # 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    tmp = [0] * (right - left + 1)\n    # 初始化左子陣列和右子陣列的起始索引\n    i, j, k = left, mid + 1, 0\n    # 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid and j &lt;= right:\n        if nums[i] &lt;= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j &lt;= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"合併排序\"\"\"\n    # 終止條件\n    if left &gt;= right:\n        return  # 當子陣列長度為 1 時終止遞迴\n    # 劃分階段\n    mid = (left + right) // 2 # 計算中點\n    merge_sort(nums, left, mid)  # 遞迴左子陣列\n    merge_sort(nums, mid + 1, right)  # 遞迴右子陣列\n    # 合併階段\n    merge(nums, left, mid, right)\n</code></pre> merge_sort.cpp<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    vector&lt;int&gt; tmp(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid mergeSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    mergeSort(nums, left, mid);      // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.java<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int[] tmp = new int[right - left + 1];\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid mergeSort(int[] nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2; // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.cs<pre><code>/* 合併左子陣列和右子陣列 */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int[] tmp = new int[right - left + 1];\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nvoid MergeSort(int[] nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right) return;       // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    MergeSort(nums, left, mid);      // 遞迴左子陣列\n    MergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    Merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.go<pre><code>/* 合併左子陣列和右子陣列 */\nfunc merge(nums []int, left, mid, right int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    tmp := make([]int, right-left+1)\n    // 初始化左子陣列和右子陣列的起始索引\n    i, j, k := left, mid+1, 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    for i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    for i &lt;= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j &lt;= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k := 0; k &lt; len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* 合併排序 */\nfunc mergeSort(nums []int, left, right int) {\n    // 終止條件\n    if left &gt;= right {\n        return\n    }\n    // 劃分階段\n    mid := left + (right - left) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // 合併階段\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.swift<pre><code>/* 合併左子陣列和右子陣列 */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // 初始化左子陣列和右子陣列的起始索引\n    var i = left, j = mid + 1, k = 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid, j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* 合併排序 */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // 終止條件\n    if left &gt;= right { // 當子陣列長度為 1 時終止遞迴\n        return\n    }\n    // 劃分階段\n    let mid = left + (right - left) / 2 // 計算中點\n    mergeSort(nums: &amp;nums, left: left, right: mid) // 遞迴左子陣列\n    mergeSort(nums: &amp;nums, left: mid + 1, right: right) // 遞迴右子陣列\n    // 合併階段\n    merge(nums: &amp;nums, left: left, mid: mid, right: right)\n}\n</code></pre> merge_sort.js<pre><code>/* 合併左子陣列和右子陣列 */\nfunction merge(nums, left, mid, right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    const tmp = new Array(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfunction mergeSort(nums, left, right) {\n    // 終止條件\n    if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    let mid = Math.floor(left + (right - left) / 2); // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.ts<pre><code>/* 合併左子陣列和右子陣列 */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    const tmp = new Array(right - left + 1);\n    // 初始化左子陣列和右子陣列的起始索引\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // 終止條件\n    if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    let mid = Math.floor(left + (right - left) / 2); // 計算中點\n    mergeSort(nums, left, mid); // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.dart<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(List&lt;int&gt; nums, int left, int mid, int right) {\n  // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n  // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n  List&lt;int&gt; tmp = List.filled(right - left + 1, 0);\n  // 初始化左子陣列和右子陣列的起始索引\n  int i = left, j = mid + 1, k = 0;\n  // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n  while (i &lt;= mid &amp;&amp; j &lt;= right) {\n    if (nums[i] &lt;= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n  while (i &lt;= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j &lt;= right) {\n    tmp[k++] = nums[j++];\n  }\n  // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n  for (k = 0; k &lt; tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* 合併排序 */\nvoid mergeSort(List&lt;int&gt; nums, int left, int right) {\n  // 終止條件\n  if (left &gt;= right) return; // 當子陣列長度為 1 時終止遞迴\n  // 劃分階段\n  int mid = left + (right - left) ~/ 2; // 計算中點\n  mergeSort(nums, left, mid); // 遞迴左子陣列\n  mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n  // 合併階段\n  merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.rs<pre><code>/* 合併左子陣列和右子陣列 */\nfn merge(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // 初始化左子陣列和右子陣列的起始索引\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while i &lt;= mid &amp;&amp; j &lt;= right {\n        if nums[i] &lt;= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while i &lt;= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j &lt;= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* 合併排序 */\nfn merge_sort(nums: &amp;mut [i32], left: usize, right: usize) {\n    // 終止條件\n    if left &gt;= right {\n        return; // 當子陣列長度為 1 時終止遞迴\n    }\n\n    // 劃分階段\n    let mid = left + (right - left) / 2; // 計算中點\n    merge_sort(nums, left, mid); // 遞迴左子陣列\n    merge_sort(nums, mid + 1, right); // 遞迴右子陣列\n\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.c<pre><code>/* 合併左子陣列和右子陣列 */\nvoid merge(int *nums, int left, int mid, int right) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // 初始化左子陣列和右子陣列的起始索引\n    int i = left, j = mid + 1, k = 0;\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++];\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (k = 0; k &lt; tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // 釋放記憶體\n    free(tmp);\n}\n\n/* 合併排序 */\nvoid mergeSort(int *nums, int left, int right) {\n    // 終止條件\n    if (left &gt;= right)\n        return; // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    int mid = left + (right - left) / 2;    // 計算中點\n    mergeSort(nums, left, mid);      // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right); // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right);\n}\n</code></pre> merge_sort.kt<pre><code>/* 合併左子陣列和右子陣列 */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n    // 建立一個臨時陣列 tmp ，用於存放合併後的結果\n    val tmp = IntArray(right - left + 1)\n    // 初始化左子陣列和右子陣列的起始索引\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n    while (i &lt;= mid &amp;&amp; j &lt;= right) {\n        if (nums[i] &lt;= nums[j])\n            tmp[k++] = nums[i++]\n        else\n            tmp[k++] = nums[j++]\n    }\n    // 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n    while (i &lt;= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j &lt;= right) {\n        tmp[k++] = nums[j++]\n    }\n    // 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* 合併排序 */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // 終止條件\n    if (left &gt;= right) return  // 當子陣列長度為 1 時終止遞迴\n    // 劃分階段\n    val mid = left + (right - left) / 2 // 計算中點\n    mergeSort(nums, left, mid) // 遞迴左子陣列\n    mergeSort(nums, mid + 1, right) // 遞迴右子陣列\n    // 合併階段\n    merge(nums, left, mid, right)\n}\n</code></pre> merge_sort.rb<pre><code>### 合併左子陣列和右子陣列 ###\ndef merge(nums, left, mid, right)\n  # 左子陣列區間為 [left, mid], 右子陣列區間為 [mid+1, right]\n  # 建立一個臨時陣列 tmp，用於存放合併後的結果\n  tmp = Array.new(right - left + 1, 0)\n  # 初始化左子陣列和右子陣列的起始索引\n  i, j, k = left, mid + 1, 0\n  # 當左右子陣列都還有元素時，進行比較並將較小的元素複製到臨時陣列中\n  while i &lt;= mid &amp;&amp; j &lt;= right\n    if nums[i] &lt;= nums[j]\n      tmp[k] = nums[i]\n      i += 1\n    else\n      tmp[k] = nums[j]\n      j += 1\n    end\n    k += 1\n  end\n  # 將左子陣列和右子陣列的剩餘元素複製到臨時陣列中\n  while i &lt;= mid\n    tmp[k] = nums[i]\n    i += 1\n    k += 1\n  end\n  while j &lt;= right\n    tmp[k] = nums[j]\n    j += 1\n    k += 1\n  end\n  # 將臨時陣列 tmp 中的元素複製回原陣列 nums 的對應區間\n  (0...tmp.length).each do |k|\n    nums[left + k] = tmp[k]\n  end\nend\n\n### 合併排序 ###\ndef merge_sort(nums, left, right)\n  # 終止條件\n  # 當子陣列長度為 1 時終止遞迴\n  return if left &gt;= right\n  # 劃分階段\n  mid = left + (right - left) / 2 # 計算中點\n  merge_sort(nums, left, mid) # 遞迴左子陣列\n  merge_sort(nums, mid + 1, right) # 遞迴右子陣列\n  # 合併階段\n  merge(nums, left, mid, right)\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1162","level":2,"title":"11.6.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：劃分產生高度為 \\(\\log n\\) 的遞迴樹，每層合併的總操作數量為 \\(n\\) ，因此總體時間複雜度為 \\(O(n \\log n)\\) 。</li> <li>空間複雜度為 \\(O(n)\\)、非原地排序：遞迴深度為 \\(\\log n\\) ，使用 \\(O(\\log n)\\) 大小的堆疊幀空間。合併操作需要藉助輔助陣列實現，使用 \\(O(n)\\) 大小的額外空間。</li> <li>穩定排序：在合併過程中，相等元素的次序保持不變。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/merge_sort/#1163","level":2,"title":"11.6.3   鏈結串列排序","text":"<p>對於鏈結串列，合併排序相較於其他排序演算法具有顯著優勢，可以將鏈結串列排序任務的空間複雜度最佳化至 \\(O(1)\\) 。</p> <ul> <li>劃分階段：可以使用“迭代”替代“遞迴”來實現鏈結串列劃分工作，從而省去遞迴使用的堆疊幀空間。</li> <li>合併階段：在鏈結串列中，節點增刪操作僅需改變引用（指標）即可實現，因此合併階段（將兩個短有序鏈結串列合併為一個長有序鏈結串列）無須建立額外鏈結串列。</li> </ul> <p>具體實現細節比較複雜，有興趣的讀者可以查閱相關資料進行學習。</p>","path":["第 11 章 &nbsp; 排序","11.6 &nbsp; 合併排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/","level":1,"title":"11.5   快速排序","text":"<p>快速排序（quick sort）是一種基於分治策略的排序演算法，執行高效，應用廣泛。</p> <p>快速排序的核心操作是“哨兵劃分”，其目標是：選擇陣列中的某個元素作為“基準數”，將所有小於基準數的元素移到其左側，而大於基準數的元素移到其右側。具體來說，哨兵劃分的流程如圖 11-8 所示。</p> <ol> <li>選取陣列最左端元素作為基準數，初始化兩個指標 <code>i</code> 和 <code>j</code> 分別指向陣列的兩端。</li> <li>設定一個迴圈，在每輪中使用 <code>i</code>（<code>j</code>）分別尋找第一個比基準數大（小）的元素，然後交換這兩個元素。</li> <li>迴圈執行步驟 <code>2.</code> ，直到 <code>i</code> 和 <code>j</code> 相遇時停止，最後將基準數交換至兩個子陣列的分界線。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-8   哨兵劃分步驟 </p> <p>哨兵劃分完成後，原陣列被劃分成三部分：左子陣列、基準數、右子陣列，且滿足“左子陣列任意元素 \\(\\leq\\) 基準數 \\(\\leq\\) 右子陣列任意元素”。因此，我們接下來只需對這兩個子陣列進行排序。</p> <p>快速排序的分治策略</p> <p>哨兵劃分的實質是將一個較長陣列的排序問題簡化為兩個較短陣列的排序問題。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"哨兵劃分\"\"\"\n    # 以 nums[left] 為基準數\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 從右向左找首個小於基準數的元素\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 從左向右找首個大於基準數的元素\n        # 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 返回基準數的索引\n</code></pre> quick_sort.cpp<pre><code>/* 哨兵劃分 */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 從左向右找首個大於基準數的元素\n        swap(nums[i], nums[j]); // 交換這兩個元素\n    }\n    swap(nums[i], nums[left]);  // 將基準數交換至兩子陣列的分界線\n    return i;                   // 返回基準數的索引\n}\n</code></pre> quick_sort.java<pre><code>/* 元素交換 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint partition(int[] nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.cs<pre><code>/* 元素交換 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* 哨兵劃分 */\nint Partition(int[] nums, int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        Swap(nums, i, j); // 交換這兩個元素\n    }\n    Swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.go<pre><code>/* 哨兵劃分 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // 以 nums[left] 為基準數\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- // 從右向左找首個小於基準數的元素\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // 返回基準數的索引\n}\n</code></pre> quick_sort.swift<pre><code>/* 哨兵劃分 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while i &lt; j {\n        while i &lt; j, nums[j] &gt;= nums[left] {\n            j -= 1 // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j, nums[i] &lt;= nums[left] {\n            i += 1 // 從左向右找首個大於基準數的元素\n        }\n        nums.swapAt(i, j) // 交換這兩個元素\n    }\n    nums.swapAt(i, left) // 將基準數交換至兩子陣列的分界線\n    return i // 返回基準數的索引\n}\n</code></pre> quick_sort.js<pre><code>/* 元素交換 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\npartition(nums, left, right) {\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.ts<pre><code>/* 元素交換 */\nswap(nums: number[], i: number, j: number): void {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\npartition(nums: number[], left: number, right: number): number {\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        // 元素交換\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.dart<pre><code>/* 元素交換 */\nvoid _swap(List&lt;int&gt; nums, int i, int j) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 以 nums[left] 為基準數\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n    _swap(nums, i, j); // 交換這兩個元素\n  }\n  _swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n  return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.rs<pre><code>/* 哨兵劃分 */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 以 nums[left] 為基準數\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        nums.swap(i, j); // 交換這兩個元素\n    }\n    nums.swap(i, left); // 將基準數交換至兩子陣列的分界線\n    i // 返回基準數的索引\n}\n</code></pre> quick_sort.c<pre><code>/* 元素交換 */\nvoid swap(int nums[], int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* 哨兵劃分 */\nint partition(int nums[], int left, int right) {\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 從左向右找首個大於基準數的元素\n        }\n        // 交換這兩個元素\n        swap(nums, i, j);\n    }\n    // 將基準數交換至兩子陣列的分界線\n    swap(nums, i, left);\n    // 返回基準數的索引\n    return i;\n}\n</code></pre> quick_sort.kt<pre><code>/* 元素交換 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    val temp = nums[i]\n    nums[i] = nums[j]\n    nums[j] = temp\n}\n\n/* 哨兵劃分 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--           // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++           // 從左向右找首個大於基準數的元素\n        swap(nums, i, j)  // 交換這兩個元素\n    }\n    swap(nums, i, left)   // 將基準數交換至兩子陣列的分界線\n    return i              // 返回基準數的索引\n}\n</code></pre> quick_sort.rb<pre><code>### 哨兵劃分 ###\ndef partition(nums, left, right)\n  # 以 nums[left] 為基準數\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 從右向左找首個小於基準數的元素\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 從左向右找首個大於基準數的元素\n    end\n    # 元素交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 將基準數交換至兩子陣列的分界線\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 返回基準數的索引\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1151","level":2,"title":"11.5.1   演算法流程","text":"<p>快速排序的整體流程如圖 11-9 所示。</p> <ol> <li>首先，對原陣列執行一次“哨兵劃分”，得到未排序的左子陣列和右子陣列。</li> <li>然後，對左子陣列和右子陣列分別遞迴執行“哨兵劃分”。</li> <li>持續遞迴，直至子陣列長度為 1 時終止，從而完成整個陣列的排序。</li> </ol> <p></p> <p> 圖 11-9   快速排序流程 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"快速排序\"\"\"\n    # 子陣列長度為 1 時終止遞迴\n    if left &gt;= right:\n        return\n    # 哨兵劃分\n    pivot = self.partition(nums, left, right)\n    # 遞迴左子陣列、右子陣列\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\n</code></pre> quick_sort.cpp<pre><code>/* 快速排序 */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.java<pre><code>/* 快速排序 */\nvoid quickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.cs<pre><code>/* 快速排序 */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right)\n        return;\n    // 哨兵劃分\n    int pivot = Partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.go<pre><code>/* 快速排序 */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return\n    }\n    // 哨兵劃分\n    pivot := q.partition(nums, left, right)\n    // 遞迴左子陣列、右子陣列\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(nums, pivot+1, right)\n}\n</code></pre> quick_sort.swift<pre><code>/* 快速排序 */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return\n    }\n    // 哨兵劃分\n    let pivot = partition(nums: &amp;nums, left: left, right: right)\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums: &amp;nums, left: left, right: pivot - 1)\n    quickSort(nums: &amp;nums, left: pivot + 1, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 快速排序 */\nquickSort(nums, left, right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) return;\n    // 哨兵劃分\n    const pivot = this.partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.ts<pre><code>/* 快速排序 */\nquickSort(nums: number[], left: number, right: number): void {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) {\n        return;\n    }\n    // 哨兵劃分\n    const pivot = this.partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.dart<pre><code>/* 快速排序 */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 子陣列長度為 1 時終止遞迴\n  if (left &gt;= right) return;\n  // 哨兵劃分\n  int pivot = _partition(nums, left, right);\n  // 遞迴左子陣列、右子陣列\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.rs<pre><code>/* 快速排序 */\npub fn quick_sort(left: i32, right: i32, nums: &amp;mut [i32]) {\n    // 子陣列長度為 1 時終止遞迴\n    if left &gt;= right {\n        return;\n    }\n    // 哨兵劃分\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // 遞迴左子陣列、右子陣列\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\n}\n</code></pre> quick_sort.c<pre><code>/* 快速排序 */\nvoid quickSort(int nums[], int left, int right) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) {\n        return;\n    }\n    // 哨兵劃分\n    int pivot = partition(nums, left, right);\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n</code></pre> quick_sort.kt<pre><code>/* 快速排序 */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // 子陣列長度為 1 時終止遞迴\n    if (left &gt;= right) return\n    // 哨兵劃分\n    val pivot = partition(nums, left, right)\n    // 遞迴左子陣列、右子陣列\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n</code></pre> quick_sort.rb<pre><code>### 快速排序類別 ###\ndef quick_sort(nums, left, right)\n  # 子陣列長度不為 1 時遞迴\n  if left &lt; right\n    # 哨兵劃分\n    pivot = partition(nums, left, right)\n    # 遞迴左子陣列、右子陣列\n    quick_sort(nums, left, pivot - 1)\n    quick_sort(nums, pivot + 1, right)\n  end\n  nums\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1152","level":2,"title":"11.5.2   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n \\log n)\\)、非自適應排序：在平均情況下，哨兵劃分的遞迴層數為 \\(\\log n\\) ，每層中的總迴圈數為 \\(n\\) ，總體使用 \\(O(n \\log n)\\) 時間。在最差情況下，每輪哨兵劃分操作都將長度為 \\(n\\) 的陣列劃分為長度為 \\(0\\) 和 \\(n - 1\\) 的兩個子陣列，此時遞迴層數達到 \\(n\\) ，每層中的迴圈數為 \\(n\\) ，總體使用 \\(O(n^2)\\) 時間。</li> <li>空間複雜度為 \\(O(n)\\)、原地排序：在輸入陣列完全倒序的情況下，達到最差遞迴深度 \\(n\\) ，使用 \\(O(n)\\) 堆疊幀空間。排序操作是在原陣列上進行的，未藉助額外陣列。</li> <li>非穩定排序：在哨兵劃分的最後一步，基準數可能會被交換至相等元素的右側。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1153","level":2,"title":"11.5.3   快速排序為什麼快","text":"<p>從名稱上就能看出，快速排序在效率方面應該具有一定的優勢。儘管快速排序的平均時間複雜度與“合併排序”和“堆積排序”相同，但通常快速排序的效率更高，主要有以下原因。</p> <ul> <li>出現最差情況的機率很低：雖然快速排序的最差時間複雜度為 \\(O(n^2)\\) ，沒有合併排序穩定，但在絕大多數情況下，快速排序能在 \\(O(n \\log n)\\) 的時間複雜度下執行。</li> <li>快取使用效率高：在執行哨兵劃分操作時，系統可將整個子陣列載入到快取，因此訪問元素的效率較高。而像“堆積排序”這類演算法需要跳躍式訪問元素，從而缺乏這一特性。</li> <li>複雜度的常數係數小：在上述三種演算法中，快速排序的比較、賦值、交換等操作的總數量最少。這與“插入排序”比“泡沫排序”更快的原因類似。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1154","level":2,"title":"11.5.4   基準數最佳化","text":"<p>快速排序在某些輸入下的時間效率可能降低。舉一個極端例子，假設輸入陣列是完全倒序的，由於我們選擇最左端元素作為基準數，那麼在哨兵劃分完成後，基準數被交換至陣列最右端，導致左子陣列長度為 \\(n - 1\\)、右子陣列長度為 \\(0\\) 。如此遞迴下去，每輪哨兵劃分後都有一個子陣列的長度為 \\(0\\) ，分治策略失效，快速排序退化為“泡沫排序”的近似形式。</p> <p>為了儘量避免這種情況發生，我們可以最佳化哨兵劃分中的基準數的選取策略。例如，我們可以隨機選取一個元素作為基準數。然而，如果運氣不佳，每次都選到不理想的基準數，效率仍然不盡如人意。</p> <p>需要注意的是，程式語言通常生成的是“偽隨機數”。如果我們針對偽隨機數序列構建一個特定的測試樣例，那麼快速排序的效率仍然可能劣化。</p> <p>為了進一步改進，我們可以在陣列中選取三個候選元素（通常為陣列的首、尾、中點元素），並將這三個候選元素的中位數作為基準數。這樣一來，基準數“既不太小也不太大”的機率將大幅提升。當然，我們還可以選取更多候選元素，以進一步提高演算法的穩健性。採用這種方法後，時間複雜度劣化至 \\(O(n^2)\\) 的機率大大降低。</p> <p>示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def median_three(self, nums: list[int], left: int, mid: int, right: int) -&gt; int:\n    \"\"\"選取三個候選元素的中位數\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l &lt;= m &lt;= r) or (r &lt;= m &lt;= l):\n        return mid  # m 在 l 和 r 之間\n    if (m &lt;= l &lt;= r) or (r &lt;= l &lt;= m):\n        return left  # l 在 m 和 r 之間\n    return right\n\ndef partition(self, nums: list[int], left: int, right: int) -&gt; int:\n    \"\"\"哨兵劃分（三數取中值）\"\"\"\n    # 以 nums[left] 為基準數\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # 將中位數交換至陣列最左端\n    nums[left], nums[med] = nums[med], nums[left]\n    # 以 nums[left] 為基準數\n    i, j = left, right\n    while i &lt; j:\n        while i &lt; j and nums[j] &gt;= nums[left]:\n            j -= 1  # 從右向左找首個小於基準數的元素\n        while i &lt; j and nums[i] &lt;= nums[left]:\n            i += 1  # 從左向右找首個大於基準數的元素\n        # 元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    # 將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # 返回基準數的索引\n</code></pre> quick_sort.cpp<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(vector&lt;int&gt; &amp;nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partition(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums[left], nums[med]);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;                // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;                // 從左向右找首個大於基準數的元素\n        swap(nums[i], nums[j]); // 交換這兩個元素\n    }\n    swap(nums[i], nums[left]);  // 將基準數交換至兩子陣列的分界線\n    return i;                   // 返回基準數的索引\n}\n</code></pre> quick_sort.java<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partition(int[] nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.cs<pre><code>/* 選取三個候選元素的中位數 */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint Partition(int[] nums, int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = MedianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    Swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--;          // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        Swap(nums, i, j); // 交換這兩個元素\n    }\n    Swap(nums, i, left);  // 將基準數交換至兩子陣列的分界線\n    return i;             // 返回基準數的索引\n}\n</code></pre> quick_sort.go<pre><code>/* 選取三個候選元素的中位數 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l 在 m 和 r 之間\n    }\n    return right\n}\n\n/* 哨兵劃分（三數取中值）*/\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n    // 以 nums[left] 為基準數\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // 將中位數交換至陣列最左端\n    nums[left], nums[med] = nums[med], nums[left]\n    // 以 nums[left] 為基準數\n    i, j := left, right\n    for i &lt; j {\n        for i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j-- //從右向左找首個小於基準數的元素\n        }\n        for i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i++ //從左向右找首個大於基準數的元素\n        }\n        //元素交換\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    //將基準數交換至兩子陣列的分界線\n    nums[i], nums[left] = nums[left], nums[i]\n    return i //返回基準數的索引\n}\n</code></pre> quick_sort.swift<pre><code>/* 選取三個候選元素的中位數 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -&gt; Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left // l 在 m 和 r 之間\n    }\n    return right\n}\n\n/* 哨兵劃分（三數取中值） */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -&gt; Int {\n    // 選取三個候選元素的中位數\n    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)\n    // 將中位數交換至陣列最左端\n    nums.swapAt(left, med)\n    return partition(nums: &amp;nums, left: left, right: right)\n}\n</code></pre> quick_sort.js<pre><code>/* 選取三個候選元素的中位數 */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m 在 l 和 r 之間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l 在 m 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\npartition(nums, left, right) {\n    // 選取三個候選元素的中位數\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 將中位數交換至陣列最左端\n    this.swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.ts<pre><code>/* 選取三個候選元素的中位數 */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m 在 l 和 r 之間\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l)) return mid;\n    // l 在 m 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m)) return left;\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\npartition(nums: number[], left: number, right: number): number {\n    // 選取三個候選元素的中位數\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // 將中位數交換至陣列最左端\n    this.swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    let i = left,\n        j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) {\n            j--; // 從右向左找首個小於基準數的元素\n        }\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) {\n            i++; // 從左向右找首個大於基準數的元素\n        }\n        this.swap(nums, i, j); // 交換這兩個元素\n    }\n    this.swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.dart<pre><code>/* 選取三個候選元素的中位數 */\nint _medianThree(List&lt;int&gt; nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n    return mid; // m 在 l 和 r 之間\n  if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n    return left; // l 在 m 和 r 之間\n  return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint _partition(List&lt;int&gt; nums, int left, int right) {\n  // 選取三個候選元素的中位數\n  int med = _medianThree(nums, left, (left + right) ~/ 2, right);\n  // 將中位數交換至陣列最左端\n  _swap(nums, left, med);\n  // 以 nums[left] 為基準數\n  int i = left, j = right;\n  while (i &lt; j) {\n    while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left]) j--; // 從右向左找首個小於基準數的元素\n    while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left]) i++; // 從左向右找首個大於基準數的元素\n    _swap(nums, i, j); // 交換這兩個元素\n  }\n  _swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n  return i; // 返回基準數的索引\n}\n</code></pre> quick_sort.rs<pre><code>/* 選取三個候選元素的中位數 */\nfn median_three(nums: &amp;mut [i32], left: usize, mid: usize, right: usize) -&gt; usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l) {\n        return mid; // m 在 l 和 r 之間\n    }\n    if (m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m) {\n        return left; // l 在 m 和 r 之間\n    }\n    right\n}\n\n/* 哨兵劃分（三數取中值） */\nfn partition(nums: &amp;mut [i32], left: usize, right: usize) -&gt; usize {\n    // 選取三個候選元素的中位數\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    nums.swap(left, med);\n    // 以 nums[left] 為基準數\n    let (mut i, mut j) = (left, right);\n    while i &lt; j {\n        while i &lt; j &amp;&amp; nums[j] &gt;= nums[left] {\n            j -= 1; // 從右向左找首個小於基準數的元素\n        }\n        while i &lt; j &amp;&amp; nums[i] &lt;= nums[left] {\n            i += 1; // 從左向右找首個大於基準數的元素\n        }\n        nums.swap(i, j); // 交換這兩個元素\n    }\n    nums.swap(i, left); // 將基準數交換至兩子陣列的分界線\n    i // 返回基準數的索引\n}\n</code></pre> quick_sort.c<pre><code>/* 選取三個候選元素的中位數 */\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l &lt;= m &amp;&amp; m &lt;= r) || (r &lt;= m &amp;&amp; m &lt;= l))\n        return mid; // m 在 l 和 r 之間\n    if ((m &lt;= l &amp;&amp; l &lt;= r) || (r &lt;= l &amp;&amp; l &lt;= m))\n        return left; // l 在 m 和 r 之間\n    return right;\n}\n\n/* 哨兵劃分（三數取中值） */\nint partitionMedian(int nums[], int left, int right) {\n    // 選取三個候選元素的中位數\n    int med = medianThree(nums, left, (left + right) / 2, right);\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med);\n    // 以 nums[left] 為基準數\n    int i = left, j = right;\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--; // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++;          // 從左向右找首個大於基準數的元素\n        swap(nums, i, j); // 交換這兩個元素\n    }\n    swap(nums, i, left); // 將基準數交換至兩子陣列的分界線\n    return i;            // 返回基準數的索引\n}\n</code></pre> quick_sort.kt<pre><code>/* 選取三個候選元素的中位數 */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m 在 l 和 r 之間\n    if ((l in m..r) || (l in r..m))\n        return left // l 在 m 和 r 之間\n    return right\n}\n\n/* 哨兵劃分（三數取中值） */\nfun partitionMedian(nums: IntArray, left: Int, right: Int): Int {\n    // 選取三個候選元素的中位數\n    val med = medianThree(nums, left, (left + right) / 2, right)\n    // 將中位數交換至陣列最左端\n    swap(nums, left, med)\n    // 以 nums[left] 為基準數\n    var i = left\n    var j = right\n    while (i &lt; j) {\n        while (i &lt; j &amp;&amp; nums[j] &gt;= nums[left])\n            j--                      // 從右向左找首個小於基準數的元素\n        while (i &lt; j &amp;&amp; nums[i] &lt;= nums[left])\n            i++                      // 從左向右找首個大於基準數的元素\n        swap(nums, i, j)             // 交換這兩個元素\n    }\n    swap(nums, i, left)              // 將基準數交換至兩子陣列的分界線\n    return i                         // 返回基準數的索引\n}\n</code></pre> quick_sort.rb<pre><code>### 選取三個候選元素的中位數 ###\ndef median_three(nums, left, mid, right)\n  # 選取三個候選元素的中位數\n  _l, _m, _r = nums[left], nums[mid], nums[right]\n  # m 在 l 和 r 之間\n  return mid if (_l &lt;= _m &amp;&amp; _m &lt;= _r) || (_r &lt;= _m &amp;&amp; _m &lt;= _l)\n  # l 在 m 和 r 之間\n  return left if (_m &lt;= _l &amp;&amp; _l &lt;= _r) || (_r &lt;= _l &amp;&amp; _l &lt;= _m)\n  return right\nend\n\n### 哨兵劃分（三數取中值）###\ndef partition(nums, left, right)\n  ### 以 nums[left] 為基準數\n  med = median_three(nums, left, (left + right) / 2, right)\n  # 將中位數交換至陣列最左斷\n  nums[left], nums[med] = nums[med], nums[left]\n  i, j = left, right\n  while i &lt; j\n    while i &lt; j &amp;&amp; nums[j] &gt;= nums[left]\n      j -= 1 # 從右向左找首個小於基準數的元素\n    end\n    while i &lt; j &amp;&amp; nums[i] &lt;= nums[left]\n      i += 1 # 從左向右找首個大於基準數的元素\n    end\n    # 元素交換\n    nums[i], nums[j] = nums[j], nums[i]\n  end\n  # 將基準數交換至兩子陣列的分界線\n  nums[i], nums[left] = nums[left], nums[i]\n  i # 返回基準數的索引\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/quick_sort/#1155","level":2,"title":"11.5.5   遞迴深度最佳化","text":"<p>在某些輸入下，快速排序可能佔用空間較多。以完全有序的輸入陣列為例，設遞迴中的子陣列長度為 \\(m\\) ，每輪哨兵劃分操作都將產生長度為 \\(0\\) 的左子陣列和長度為 \\(m - 1\\) 的右子陣列，這意味著每一層遞迴呼叫減少的問題規模非常小（只減少一個元素），遞迴樹的高度會達到 \\(n - 1\\) ，此時需要佔用 \\(O(n)\\) 大小的堆疊幀空間。</p> <p>為了防止堆疊幀空間的累積，我們可以在每輪哨兵排序完成後，比較兩個子陣列的長度，僅對較短的子陣列進行遞迴。由於較短子陣列的長度不會超過 \\(n / 2\\) ，因此這種方法能確保遞迴深度不超過 \\(\\log n\\) ，從而將最差空間複雜度最佳化至 \\(O(\\log n)\\) 。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby quick_sort.py<pre><code>def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"快速排序（遞迴深度最佳化）\"\"\"\n    # 子陣列長度為 1 時終止\n    while left &lt; right:\n        # 哨兵劃分操作\n        pivot = self.partition(nums, left, right)\n        # 對兩個子陣列中較短的那個執行快速排序\n        if pivot - left &lt; right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # 遞迴排序左子陣列\n            left = pivot + 1  # 剩餘未排序區間為 [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # 遞迴排序右子陣列\n            right = pivot - 1  # 剩餘未排序區間為 [left, pivot - 1]\n</code></pre> quick_sort.cpp<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(vector&lt;int&gt; &amp;nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1;                 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1;                 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.java<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.cs<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid QuickSort(int[] nums, int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = Partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // 遞迴排序左子陣列\n            left = pivot + 1;  // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.go<pre><code>/* 快速排序（遞迴深度最佳化）*/\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n    // 子陣列長度為 1 時終止\n    for left &lt; right {\n        // 哨兵劃分操作\n        pivot := q.partition(nums, left, right)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if pivot-left &lt; right-pivot {\n            q.quickSort(nums, left, pivot-1) // 遞迴排序左子陣列\n            left = pivot + 1                 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // 遞迴排序右子陣列\n            right = pivot - 1                 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.swift<pre><code>/* 快速排序（遞迴深度最佳化） */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\n    var left = left\n    var right = right\n    // 子陣列長度為 1 時終止\n    while left &lt; right {\n        // 哨兵劃分操作\n        let pivot = partition(nums: &amp;nums, left: left, right: right)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left) &lt; (right - pivot) {\n            quickSortTailCall(nums: &amp;nums, left: left, right: pivot - 1) // 遞迴排序左子陣列\n            left = pivot + 1 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &amp;nums, left: pivot + 1, right: right) // 遞迴排序右子陣列\n            right = pivot - 1 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.js<pre><code>/* 快速排序（遞迴深度最佳化） */\nquickSort(nums, left, right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        let pivot = this.partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.ts<pre><code>/* 快速排序（遞迴深度最佳化） */\nquickSort(nums: number[], left: number, right: number): void {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        let pivot = this.partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.dart<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSort(List&lt;int&gt; nums, int left, int right) {\n  // 子陣列長度為 1 時終止\n  while (left &lt; right) {\n    // 哨兵劃分操作\n    int pivot = _partition(nums, left, right);\n    // 對兩個子陣列中較短的那個執行快速排序\n    if (pivot - left &lt; right - pivot) {\n      quickSort(nums, left, pivot - 1); // 遞迴排序左子陣列\n      left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // 遞迴排序右子陣列\n      right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n    }\n  }\n}\n</code></pre> quick_sort.rs<pre><code>/* 快速排序（遞迴深度最佳化） */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &amp;mut [i32]) {\n    // 子陣列長度為 1 時終止\n    while left &lt; right {\n        // 哨兵劃分操作\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // 對兩個子陣列中較短的那個執行快速排序\n        if pivot - left &lt; right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // 遞迴排序左子陣列\n            left = pivot + 1; // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // 遞迴排序右子陣列\n            right = pivot - 1; // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.c<pre><code>/* 快速排序（遞迴深度最佳化） */\nvoid quickSortTailCall(int nums[], int left, int right) {\n    // 子陣列長度為 1 時終止\n    while (left &lt; right) {\n        // 哨兵劃分操作\n        int pivot = partition(nums, left, right);\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - left &lt; right - pivot) {\n            // 遞迴排序左子陣列\n            quickSortTailCall(nums, left, pivot - 1);\n            // 剩餘未排序區間為 [pivot + 1, right]\n            left = pivot + 1;\n        } else {\n            // 遞迴排序右子陣列\n            quickSortTailCall(nums, pivot + 1, right);\n            // 剩餘未排序區間為 [left, pivot - 1]\n            right = pivot - 1;\n        }\n    }\n}\n</code></pre> quick_sort.kt<pre><code>/* 快速排序（遞迴深度最佳化） */\nfun quickSortTailCall(nums: IntArray, left: Int, right: Int) {\n    // 子陣列長度為 1 時終止\n    var l = left\n    var r = right\n    while (l &lt; r) {\n        // 哨兵劃分操作\n        val pivot = partition(nums, l, r)\n        // 對兩個子陣列中較短的那個執行快速排序\n        if (pivot - l &lt; r - pivot) {\n            quickSort(nums, l, pivot - 1) // 遞迴排序左子陣列\n            l = pivot + 1 // 剩餘未排序區間為 [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, r) // 遞迴排序右子陣列\n            r = pivot - 1 // 剩餘未排序區間為 [left, pivot - 1]\n        }\n    }\n}\n</code></pre> quick_sort.rb<pre><code>### 快速排序（遞迴深度最佳化）###\ndef quick_sort(nums, left, right)\n  # 子陣列長度不為 1 時遞迴\n  while left &lt; right\n    # 哨兵劃分\n    pivot = partition(nums, left, right)\n    # 對兩個子陣列中較短的那個執行快速排序\n    if pivot - left &lt; right - pivot\n      quick_sort(nums, left, pivot - 1)\n      left = pivot + 1 # 剩餘未排序區間為 [pivot + 1, right]\n    else\n      quick_sort(nums, pivot + 1, right)\n      right = pivot - 1 # 剩餘未排序區間為 [left, pivot - 1]\n    end\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.5 &nbsp; 快速排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/","level":1,"title":"11.10   基數排序","text":"<p>上一節介紹了計數排序，它適用於資料量 \\(n\\) 較大但資料範圍 \\(m\\) 較小的情況。假設我們需要對 \\(n = 10^6\\) 個學號進行排序，而學號是一個 \\(8\\) 位數字，這意味著資料範圍 \\(m = 10^8\\) 非常大，使用計數排序需要分配大量記憶體空間，而基數排序可以避免這種情況。</p> <p>基數排序（radix sort）的核心思想與計數排序一致，也透過統計個數來實現排序。在此基礎上，基數排序利用數字各位之間的遞進關係，依次對每一位進行排序，從而得到最終的排序結果。</p>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11101","level":2,"title":"11.10.1   演算法流程","text":"<p>以學號資料為例，假設數字的最低位是第 \\(1\\) 位，最高位是第 \\(8\\) 位，基數排序的流程如圖 11-18 所示。</p> <ol> <li>初始化位數 \\(k = 1\\) 。</li> <li>對學號的第 \\(k\\) 位執行“計數排序”。完成後，資料會根據第 \\(k\\) 位從小到大排序。</li> <li>將 \\(k\\) 增加 \\(1\\) ，然後返回步驟 <code>2.</code> 繼續迭代，直到所有位都排序完成後結束。</li> </ol> <p></p> <p> 圖 11-18   基數排序演算法流程 </p> <p>下面剖析程式碼實現。對於一個 \\(d\\) 進位制的數字 \\(x\\) ，要獲取其第 \\(k\\) 位 \\(x_k\\) ，可以使用以下計算公式：</p> \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\] <p>其中 \\(\\lfloor a \\rfloor\\) 表示對浮點數 \\(a\\) 向下取整，而 \\(\\bmod \\: d\\) 表示對 \\(d\\) 取模（取餘）。對於學號資料，\\(d = 10\\) 且 \\(k \\in [1, 8]\\) 。</p> <p>此外，我們需要小幅改動計數排序程式碼，使之可以根據數字的第 \\(k\\) 位進行排序：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby radix_sort.py<pre><code>def digit(num: int, exp: int) -&gt; int:\n    \"\"\"獲取元素 num 的第 k 位，其中 exp = 10^(k-1)\"\"\"\n    # 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\n    \"\"\"計數排序（根據 nums 第 k 位排序）\"\"\"\n    # 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    counter = [0] * 10\n    n = len(nums)\n    # 統計 0~9 各數字的出現次數\n    for i in range(n):\n        d = digit(nums[i], exp)  # 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1  # 統計數字 d 的出現次數\n    # 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in range(1, 10):\n        counter[i] += counter[i - 1]\n    # 倒序走訪，根據桶內統計結果，將各元素填入 res\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]  # 將當前元素填入索引 j\n        counter[d] -= 1  # 將 d 的數量減 1\n    # 使用結果覆蓋原陣列 nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"基數排序\"\"\"\n    # 獲取陣列的最大元素，用於判斷最大位數\n    m = max(nums)\n    # 按照從低位到高位的順序走訪\n    exp = 1\n    while exp &lt;= m:\n        # 對陣列元素的第 k 位執行計數排序\n        # k = 1 -&gt; exp = 1\n        # k = 2 -&gt; exp = 10\n        # 即 exp = 10^(k-1)\n        counting_sort_digit(nums, exp)\n        exp *= 10\n</code></pre> radix_sort.cpp<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(vector&lt;int&gt; &amp;nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    vector&lt;int&gt; counter(10, 0);\n    int n = nums.size();\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    vector&lt;int&gt; res(n, 0);\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(vector&lt;int&gt; &amp;nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = *max_element(nums.begin(), nums.end());\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10)\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.java<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(int[] nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int[] counter = new int[10];\n    int n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++)\n        nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(int[] nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num &gt; m)\n            m = num;\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.cs<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint Digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid CountingSortDigit(int[] nums, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; n; i++) {\n        int d = Digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++;                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int[] res = new int[n];\n    for (int i = n - 1; i &gt;= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nvoid RadixSort(int[] nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num &gt; m) m = num;\n    }\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        CountingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.go<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunc countingSortDigit(nums []int, exp int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    counter := make([]int, 10)\n    n := len(nums)\n    // 統計 0~9 各數字的出現次數\n    for i := 0; i &lt; n; i++ {\n        d := digit(nums[i], exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++             // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i := 1; i &lt; 10; i++ {\n        counter[i] += counter[i-1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    res := make([]int, n)\n    for i := n - 1; i &gt;= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]    // 將當前元素填入索引 j\n        counter[d]--        // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for i := 0; i &lt; n; i++ {\n        nums[i] = res[i]\n    }\n}\n\n/* 基數排序 */\nfunc radixSort(nums []int) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    max := math.MinInt\n    for _, num := range nums {\n        if num &gt; max {\n            max = num\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for exp := 1; max &gt;= exp; exp *= 10 {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n    }\n}\n</code></pre> radix_sort.swift<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -&gt; Int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    var counter = Array(repeating: 0, count: 10)\n    // 統計 0~9 各數字的出現次數\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1 // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in 1 ..&lt; 10 {\n        counter[i] += counter[i - 1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i] // 將當前元素填入索引 j\n        counter[d] -= 1 // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\n}\n\n/* 基數排序 */\nfunc radixSort(nums: inout [Int]) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    var m = Int.min\n    for num in nums {\n        if num &gt; m {\n            m = num\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for exp in sequence(first: 1, next: { m &gt;= ($0 * 10) ? $0 * 10 : nil }) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums: &amp;nums, exp: exp)\n    }\n}\n</code></pre> radix_sort.js<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunction digit(num, exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunction countingSortDigit(nums, exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d]--; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nfunction radixSort(nums) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m = Math.max(... nums);\n    // 按照從低位到高位的順序走訪\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.ts<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return Math.floor(num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfunction countingSortDigit(nums: number[], exp: number): void {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // 統計 0~9 各數字的出現次數\n    for (let i = 0; i &lt; n; i++) {\n        const d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (let i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i &gt;= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d]--; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (let i = 0; i &lt; n; i++) {\n        nums[i] = res[i];\n    }\n}\n\n/* 基數排序 */\nfunction radixSort(nums: number[]): void {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m: number = Math.max(... nums);\n    // 按照從低位到高位的順序走訪\n    for (let exp = 1; exp &lt;= m; exp *= 10) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp);\n    }\n}\n</code></pre> radix_sort.dart<pre><code>/* 獲取元素 _num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int _num, int exp) {\n  // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n  return (_num ~/ exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(List&lt;int&gt; nums, int exp) {\n  // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n  List&lt;int&gt; counter = List&lt;int&gt;.filled(10, 0);\n  int n = nums.length;\n  // 統計 0~9 各數字的出現次數\n  for (int i = 0; i &lt; n; i++) {\n    int d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n    counter[d]++; // 統計數字 d 的出現次數\n  }\n  // 求前綴和，將“出現個數”轉換為“陣列索引”\n  for (int i = 1; i &lt; 10; i++) {\n    counter[i] += counter[i - 1];\n  }\n  // 倒序走訪，根據桶內統計結果，將各元素填入 res\n  List&lt;int&gt; res = List&lt;int&gt;.filled(n, 0);\n  for (int i = n - 1; i &gt;= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n    res[j] = nums[i]; // 將當前元素填入索引 j\n    counter[d]--; // 將 d 的數量減 1\n  }\n  // 使用結果覆蓋原陣列 nums\n  for (int i = 0; i &lt; n; i++) nums[i] = res[i];\n}\n\n/* 基數排序 */\nvoid radixSort(List&lt;int&gt; nums) {\n  // 獲取陣列的最大元素，用於判斷最大位數\n  // dart 中 int 的長度是 64 位的\n  int m = -1 &lt;&lt; 63;\n  for (int _num in nums) if (_num &gt; m) m = _num;\n  // 按照從低位到高位的順序走訪\n  for (int exp = 1; exp &lt;= m; exp *= 10)\n    // 對陣列元素的第 k 位執行計數排序\n    // k = 1 -&gt; exp = 1\n    // k = 2 -&gt; exp = 10\n    // 即 exp = 10^(k-1)\n    countingSortDigit(nums, exp);\n}\n</code></pre> radix_sort.rs<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -&gt; usize {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return ((num / exp) % 10) as usize;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfn counting_sort_digit(nums: &amp;mut [i32], exp: i32) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // 統計 0~9 各數字的出現次數\n    for i in 0..n {\n        let d = digit(nums[i], exp); // 獲取 nums[i] 第 k 位，記為 d\n        counter[d] += 1; // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for i in 1..10 {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]; // 將當前元素填入索引 j\n        counter[d] -= 1; // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    nums.copy_from_slice(&amp;res);\n}\n\n/* 基數排序 */\nfn radix_sort(nums: &amp;mut [i32]) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    let m = *nums.into_iter().max().unwrap();\n    // 按照從低位到高位的順序走訪\n    let mut exp = 1;\n    while exp &lt;= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\n    }\n}\n</code></pre> radix_sort.c<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nint digit(int num, int exp) {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10;\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nvoid countingSortDigit(int nums[], int size, int exp) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    memset(counter, 0, sizeof(int) * 10); // 初始化為 0 以支持後續記憶體釋放\n    // 統計 0~9 各數字的出現次數\n    for (int i = 0; i &lt; size; i++) {\n        // 獲取 nums[i] 第 k 位，記為 d\n        int d = digit(nums[i], exp);\n        // 統計數字 d 的出現次數\n        counter[d]++;\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (int i = 1; i &lt; 10; i++) {\n        counter[i] += counter[i - 1];\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i &gt;= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i];       // 將當前元素填入索引 j\n        counter[d]--;           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (int i = 0; i &lt; size; i++) {\n        nums[i] = res[i];\n    }\n    // 釋放記憶體\n    free(res);\n    free(counter);\n}\n\n/* 基數排序 */\nvoid radixSort(int nums[], int size) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    int max = INT32_MIN;\n    for (int i = 0; i &lt; size; i++) {\n        if (nums[i] &gt; max) {\n            max = nums[i];\n        }\n    }\n    // 按照從低位到高位的順序走訪\n    for (int exp = 1; max &gt;= exp; exp *= 10)\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, size, exp);\n}\n</code></pre> radix_sort.kt<pre><code>/* 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) */\nfun digit(num: Int, exp: Int): Int {\n    // 傳入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n    return (num / exp) % 10\n}\n\n/* 計數排序（根據 nums 第 k 位排序） */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n    val counter = IntArray(10)\n    val n = nums.size\n    // 統計 0~9 各數字的出現次數\n    for (i in 0..&lt;n) {\n        val d = digit(nums[i], exp) // 獲取 nums[i] 第 k 位，記為 d\n        counter[d]++                // 統計數字 d 的出現次數\n    }\n    // 求前綴和，將“出現個數”轉換為“陣列索引”\n    for (i in 1..9) {\n        counter[i] += counter[i - 1]\n    }\n    // 倒序走訪，根據桶內統計結果，將各元素填入 res\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // 獲取 d 在陣列中的索引 j\n        res[j] = nums[i]       // 將當前元素填入索引 j\n        counter[d]--           // 將 d 的數量減 1\n    }\n    // 使用結果覆蓋原陣列 nums\n    for (i in 0..&lt;n)\n        nums[i] = res[i]\n}\n\n/* 基數排序 */\nfun radixSort(nums: IntArray) {\n    // 獲取陣列的最大元素，用於判斷最大位數\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num &gt; m) m = num\n    var exp = 1\n    // 按照從低位到高位的順序走訪\n    while (exp &lt;= m) {\n        // 對陣列元素的第 k 位執行計數排序\n        // k = 1 -&gt; exp = 1\n        // k = 2 -&gt; exp = 10\n        // 即 exp = 10^(k-1)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n</code></pre> radix_sort.rb<pre><code>### 獲取元素 num 的第 k 位，其中 exp = 10^(k-1) ###\ndef digit(num, exp)\n  # 轉入 exp 而非 k 可以避免在此重複執行昂貴的次方計算\n  (num / exp) % 10\nend\n\n### 計數排序（根據 nums 第 k 位排序）###\ndef counting_sort_digit(nums, exp)\n  # 十進位制的位範圍為 0~9 ，因此需要長度為 10 的桶陣列\n  counter = Array.new(10, 0)\n  n = nums.length\n  # 統計 0~9 各數字的出現次數\n  for i in 0...n\n    d = digit(nums[i], exp) # 獲取 nums[i] 第 k 位，記為 d\n    counter[d] += 1 # 統計數字 d 的出現次數\n  end\n  # 求前綴和，將“出現個數”轉換為“陣列索引”\n  (1...10).each { |i| counter[i] += counter[i - 1] }\n  # 倒序走訪，根據桶內統計結果，將各元素填入 res\n  res = Array.new(n, 0)\n  for i in (n - 1).downto(0)\n    d = digit(nums[i], exp)\n    j = counter[d] - 1 # 獲取 d 在陣列中的索引 j\n    res[j] = nums[i] # 將當前元素填入索引 j\n    counter[d] -= 1 # 將 d 的數量減 1\n  end\n  # 使用結果覆蓋原陣列 nums\n  (0...n).each { |i| nums[i] = res[i] }\nend\n\n### 基數排序 ###\ndef radix_sort(nums)\n  # 獲取陣列的最大元素，用於判斷最大位數\n  m = nums.max\n  # 按照從低位到高位的順序走訪\n  exp = 1\n  while exp &lt;= m\n    # 對陣列元素的第 k 位執行計數排序\n    # k = 1 -&gt; exp = 1\n    # k = 2 -&gt; exp = 10\n    # 即 exp = 10^(k-1)\n    counting_sort_digit(nums, exp)\n    exp *= 10\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>為什麼從最低位開始排序？</p> <p>在連續的排序輪次中，後一輪排序會覆蓋前一輪排序的結果。舉例來說，如果第一輪排序結果 \\(a &lt; b\\) ，而第二輪排序結果 \\(a &gt; b\\) ，那麼第二輪的結果將取代第一輪的結果。由於數字的高位優先順序高於低位，因此應該先排序低位再排序高位。</p>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/radix_sort/#11102","level":2,"title":"11.10.2   演算法特性","text":"<p>相較於計數排序，基數排序適用於數值範圍較大的情況，但前提是資料必須可以表示為固定位數的格式，且位數不能過大。例如，浮點數不適合使用基數排序，因為其位數 \\(k\\) 過大，可能導致時間複雜度 \\(O(nk) \\gg O(n^2)\\) 。</p> <ul> <li>時間複雜度為 \\(O(nk)\\)、非自適應排序：設資料量為 \\(n\\)、資料為 \\(d\\) 進位制、最大位數為 \\(k\\) ，則對某一位執行計數排序使用 \\(O(n + d)\\) 時間，排序所有 \\(k\\) 位使用 \\(O((n + d)k)\\) 時間。通常情況下，\\(d\\) 和 \\(k\\) 都相對較小，時間複雜度趨向 \\(O(n)\\) 。</li> <li>空間複雜度為 \\(O(n + d)\\)、非原地排序：與計數排序相同，基數排序需要藉助長度為 \\(n\\) 和 \\(d\\) 的陣列 <code>res</code> 和 <code>counter</code> 。</li> <li>穩定排序：當計數排序穩定時，基數排序也穩定；當計數排序不穩定時，基數排序無法保證得到正確的排序結果。</li> </ul>","path":["第 11 章 &nbsp; 排序","11.10 &nbsp; 基數排序"],"tags":[]},{"location":"chapter_sorting/selection_sort/","level":1,"title":"11.2   選擇排序","text":"<p>選擇排序（selection sort）的工作原理非常簡單：開啟一個迴圈，每輪從未排序區間選擇最小的元素，將其放到已排序區間的末尾。</p> <p>設陣列的長度為 \\(n\\) ，選擇排序的演算法流程如圖 11-2 所示。</p> <ol> <li>初始狀態下，所有元素未排序，即未排序（索引）區間為 \\([0, n-1]\\) 。</li> <li>選取區間 \\([0, n-1]\\) 中的最小元素，將其與索引 \\(0\\) 處的元素交換。完成後，陣列前 1 個元素已排序。</li> <li>選取區間 \\([1, n-1]\\) 中的最小元素，將其與索引 \\(1\\) 處的元素交換。完成後，陣列前 2 個元素已排序。</li> <li>以此類推。經過 \\(n - 1\\) 輪選擇與交換後，陣列前 \\(n - 1\\) 個元素已排序。</li> <li>僅剩的一個元素必定是最大元素，無須排序，因此陣列排序完成。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 11-2   選擇排序步驟 </p> <p>在程式碼中，我們用 \\(k\\) 來記錄未排序區間內的最小元素：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby selection_sort.py<pre><code>def selection_sort(nums: list[int]):\n    \"\"\"選擇排序\"\"\"\n    n = len(nums)\n    # 外迴圈：未排序區間為 [i, n-1]\n    for i in range(n - 1):\n        # 內迴圈：找到未排序區間內的最小元素\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] &lt; nums[k]:\n                k = j  # 記錄最小元素的索引\n        # 將該最小元素與未排序區間的首個元素交換\n        nums[i], nums[k] = nums[k], nums[i]\n</code></pre> selection_sort.cpp<pre><code>/* 選擇排序 */\nvoid selectionSort(vector&lt;int&gt; &amp;nums) {\n    int n = nums.size();\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        swap(nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.java<pre><code>/* 選擇排序 */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.cs<pre><code>/* 選擇排序 */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n</code></pre> selection_sort.go<pre><code>/* 選擇排序 */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i := 0; i &lt; n-1; i++ {\n        // 內迴圈：找到未排序區間內的最小元素\n        k := i\n        for j := i + 1; j &lt; n; j++ {\n            if nums[j] &lt; nums[k] {\n                // 記錄最小元素的索引\n                k = j\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums[i], nums[k] = nums[k], nums[i]\n\n    }\n}\n</code></pre> selection_sort.swift<pre><code>/* 選擇排序 */\nfunc selectionSort(nums: inout [Int]) {\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i in nums.indices.dropLast() {\n        // 內迴圈：找到未排序區間內的最小元素\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] &lt; nums[k] {\n                k = j // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums.swapAt(i, k)\n    }\n}\n</code></pre> selection_sort.js<pre><code>/* 選擇排序 */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.ts<pre><code>/* 選擇排序 */\nfunction selectionSort(nums: number[]): void {\n    let n = nums.length;\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (let i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        let k = i;\n        for (let j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k]) {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        [nums[i], nums[k]] = [nums[k], nums[i]];\n    }\n}\n</code></pre> selection_sort.dart<pre><code>/* 選擇排序 */\nvoid selectionSort(List&lt;int&gt; nums) {\n  int n = nums.length;\n  // 外迴圈：未排序區間為 [i, n-1]\n  for (int i = 0; i &lt; n - 1; i++) {\n    // 內迴圈：找到未排序區間內的最小元素\n    int k = i;\n    for (int j = i + 1; j &lt; n; j++) {\n      if (nums[j] &lt; nums[k]) k = j; // 記錄最小元素的索引\n    }\n    // 將該最小元素與未排序區間的首個元素交換\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n</code></pre> selection_sort.rs<pre><code>/* 選擇排序 */\nfn selection_sort(nums: &amp;mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // 外迴圈：未排序區間為 [i, n-1]\n    for i in 0..n - 1 {\n        // 內迴圈：找到未排序區間內的最小元素\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] &lt; nums[k] {\n                k = j; // 記錄最小元素的索引\n            }\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        nums.swap(i, k);\n    }\n}\n</code></pre> selection_sort.c<pre><code>/* 選擇排序 */\nvoid selectionSort(int nums[], int n) {\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (int i = 0; i &lt; n - 1; i++) {\n        // 內迴圈：找到未排序區間內的最小元素\n        int k = i;\n        for (int j = i + 1; j &lt; n; j++) {\n            if (nums[j] &lt; nums[k])\n                k = j; // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n</code></pre> selection_sort.kt<pre><code>/* 選擇排序 */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // 外迴圈：未排序區間為 [i, n-1]\n    for (i in 0..&lt;n - 1) {\n        var k = i\n        // 內迴圈：找到未排序區間內的最小元素\n        for (j in i + 1..&lt;n) {\n            if (nums[j] &lt; nums[k])\n                k = j // 記錄最小元素的索引\n        }\n        // 將該最小元素與未排序區間的首個元素交換\n        val temp = nums[i]\n        nums[i] = nums[k]\n        nums[k] = temp\n    }\n}\n</code></pre> selection_sort.rb<pre><code>### 選擇排序 ###\ndef selection_sort(nums)\n  n = nums.length\n  # 外迴圈：未排序區間為 [i, n-1]\n  for i in 0...(n - 1)\n    # 內迴圈：找到未排序區間內的最小元素\n    k = i\n    for j in (i + 1)...n\n      if nums[j] &lt; nums[k]\n        k = j # 記錄最小元素的索引\n      end\n    end\n    # 將該最小元素與未排序區間的首個元素交換\n    nums[i], nums[k] = nums[k], nums[i]\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 11 章 &nbsp; 排序","11.2 &nbsp; 選擇排序"],"tags":[]},{"location":"chapter_sorting/selection_sort/#1121","level":2,"title":"11.2.1   演算法特性","text":"<ul> <li>時間複雜度為 \\(O(n^2)\\)、非自適應排序：外迴圈共 \\(n - 1\\) 輪，第一輪的未排序區間長度為 \\(n\\) ，最後一輪的未排序區間長度為 \\(2\\) ，即各輪外迴圈分別包含 \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(3\\)、\\(2\\) 輪內迴圈，求和為 \\(\\frac{(n - 1)(n + 2)}{2}\\) 。</li> <li>空間複雜度為 \\(O(1)\\)、原地排序：指標 \\(i\\) 和 \\(j\\) 使用常數大小的額外空間。</li> <li>非穩定排序：如圖 11-3 所示，元素 <code>nums[i]</code> 有可能被交換至與其相等的元素的右邊，導致兩者的相對順序發生改變。</li> </ul> <p> 圖 11-3   選擇排序非穩定示例 </p>","path":["第 11 章 &nbsp; 排序","11.2 &nbsp; 選擇排序"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/","level":1,"title":"11.1   排序演算法","text":"<p>排序演算法（sorting algorithm）用於對一組資料按照特定順序進行排列。排序演算法有著廣泛的應用，因為有序資料通常能夠被更高效地查詢、分析和處理。</p> <p>如圖 11-1 所示，排序演算法中的資料型別可以是整數、浮點數、字元或字串等。排序的判斷規則可根據需求設定，如數字大小、字元 ASCII 碼順序或自定義規則。</p> <p></p> <p> 圖 11-1   資料型別和判斷規則示例 </p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1111","level":2,"title":"11.1.1   評價維度","text":"<p>執行效率：我們期望排序演算法的時間複雜度儘量低，且總體操作數量較少（時間複雜度中的常數項變小）。對於大資料量的情況，執行效率顯得尤為重要。</p> <p>就地性：顧名思義，原地排序透過在原陣列上直接操作實現排序，無須藉助額外的輔助陣列，從而節省記憶體。通常情況下，原地排序的資料搬運操作較少，執行速度也更快。</p> <p>穩定性：穩定排序在完成排序後，相等元素在陣列中的相對順序不發生改變。</p> <p>穩定排序是多級排序場景的必要條件。假設我們有一個儲存學生資訊的表格，第 1 列和第 2 列分別是姓名和年齡。在這種情況下，非穩定排序可能導致輸入資料的有序性喪失：</p> <pre><code># 輸入資料是按照姓名排序好的\n# (name, age)\n  ('A', 19)\n  ('B', 18)\n  ('C', 21)\n  ('D', 19)\n  ('E', 23)\n\n# 假設使用非穩定排序演算法按年齡排序串列，\n# 結果中 ('D', 19) 和 ('A', 19) 的相對位置改變，\n# 輸入資料按姓名排序的性質丟失\n  ('B', 18)\n  ('D', 19)\n  ('A', 19)\n  ('C', 21)\n  ('E', 23)\n</code></pre> <p>自適應性：自適應排序能夠利用輸入資料已有的順序資訊來減少計算量，達到更優的時間效率。自適應排序演算法的最佳時間複雜度通常優於平均時間複雜度。</p> <p>是否基於比較：基於比較的排序依賴比較運算子（\\(&lt;\\)、\\(=\\)、\\(&gt;\\)）來判斷元素的相對順序，從而排序整個陣列，理論最優時間複雜度為 \\(O(n \\log n)\\) 。而非比較排序不使用比較運算子，時間複雜度可達 \\(O(n)\\) ，但其通用性相對較差。</p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/sorting_algorithm/#1112","level":2,"title":"11.1.2   理想排序演算法","text":"<p>執行快、原地、穩定、自適應、通用性好。顯然，迄今為止尚未發現兼具以上所有特性的排序演算法。因此，在選擇排序演算法時，需要根據具體的資料特點和問題需求來決定。</p> <p>接下來，我們將共同學習各種排序演算法，並基於上述評價維度對各個排序演算法的優缺點進行分析。</p>","path":["第 11 章 &nbsp; 排序","11.1 &nbsp; 排序演算法"],"tags":[]},{"location":"chapter_sorting/summary/","level":1,"title":"11.11   小結","text":"","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>泡沫排序透過交換相鄰元素來實現排序。透過新增一個標誌位來實現提前返回，我們可以將泡沫排序的最佳時間複雜度最佳化到 \\(O(n)\\) 。</li> <li>插入排序每輪將未排序區間內的元素插入到已排序區間的正確位置，從而完成排序。雖然插入排序的時間複雜度為 \\(O(n^2)\\) ，但由於單元操作相對較少，因此在小資料量的排序任務中非常受歡迎。</li> <li>快速排序基於哨兵劃分操作實現排序。在哨兵劃分中，有可能每次都選取到最差的基準數，導致時間複雜度劣化至 \\(O(n^2)\\) 。引入中位數基準數或隨機基準數可以降低這種劣化的機率。透過優先遞迴較短子區間，可有效減小遞迴深度，將空間複雜度最佳化到 \\(O(\\log n)\\) 。</li> <li>合併排序包括劃分和合並兩個階段，典型地體現了分治策略。在合併排序中，排序陣列需要建立輔助陣列，空間複雜度為 \\(O(n)\\) ；然而排序鏈結串列的空間複雜度可以最佳化至 \\(O(1)\\) 。</li> <li>桶排序包含三個步驟：資料分桶、桶內排序和合並結果。它同樣體現了分治策略，適用於資料體量很大的情況。桶排序的關鍵在於對資料進行平均分配。</li> <li>計數排序是桶排序的一個特例，它透過統計資料出現的次數來實現排序。計數排序適用於資料量大但資料範圍有限的情況，並且要求資料能夠轉換為正整數。</li> <li>基數排序透過逐位排序來實現資料排序，要求資料能夠表示為固定位數的數字。</li> <li>總的來說，我們希望找到一種排序演算法，具有高效率、穩定、原地以及自適應性等優點。然而，正如其他資料結構和演算法一樣，沒有一種排序演算法能夠同時滿足所有這些條件。在實際應用中，我們需要根據資料的特性來選擇合適的排序演算法。</li> <li>圖 11-19 對比了主流排序演算法的效率、穩定性、就地性和自適應性等。</li> </ul> <p> 圖 11-19   排序演算法對比 </p>","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_sorting/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：排序演算法穩定性在什麼情況下是必需的？</p> <p>在現實中，我們有可能基於物件的某個屬性進行排序。例如，學生有姓名和身高兩個屬性，我們希望實現一個多級排序：先按照姓名進行排序，得到 <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> ；再對身高進行排序。由於排序演算法不穩定，因此可能得到 <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> 。</p> <p>可以發現，學生 D 和 C 的位置發生了交換，姓名的有序性被破壞了，而這是我們不希望看到的。</p> <p>Q：哨兵劃分中“從右往左查詢”與“從左往右查詢”的順序可以交換嗎？</p> <p>不行，當我們以最左端元素為基準數時，必須先“從右往左查詢”再“從左往右查詢”。這個結論有些反直覺，我們來剖析一下原因。</p> <p>哨兵劃分 <code>partition()</code> 的最後一步是交換 <code>nums[left]</code> 和 <code>nums[i]</code> 。完成交換後，基準數左邊的元素都 <code>&lt;=</code> 基準數，這就要求最後一步交換前 <code>nums[left] &gt;= nums[i]</code> 必須成立。假設我們先“從左往右查詢”，那麼如果找不到比基準數更大的元素，則會在 <code>i == j</code> 時跳出迴圈，此時可能 <code>nums[j] == nums[i] &gt; nums[left]</code>。也就是說，此時最後一步交換操作會把一個比基準數更大的元素交換至陣列最左端，導致哨兵劃分失敗。</p> <p>舉個例子，給定陣列 <code>[0, 0, 0, 0, 1]</code> ，如果先“從左向右查詢”，哨兵劃分後陣列為 <code>[1, 0, 0, 0, 0]</code> ，這個結果是不正確的。</p> <p>再深入思考一下，如果我們選擇 <code>nums[right]</code> 為基準數，那麼正好反過來，必須先“從左往右查詢”。</p> <p>Q：關於快速排序的遞迴深度最佳化，為什麼選短的陣列能保證遞迴深度不超過 \\(\\log n\\) ？</p> <p>遞迴深度就是當前未返回的遞迴方法的數量。每輪哨兵劃分我們將原陣列劃分為兩個子陣列。在遞迴深度最佳化後，向下遞迴的子陣列長度最大為原陣列長度的一半。假設最差情況，一直為一半長度，那麼最終的遞迴深度就是 \\(\\log n\\) 。</p> <p>回顧原始的快速排序，我們有可能會連續地遞迴長度較大的陣列，最差情況下為 \\(n\\)、\\(n - 1\\)、\\(\\dots\\)、\\(2\\)、\\(1\\) ，遞迴深度為 \\(n\\) 。遞迴深度最佳化可以避免這種情況出現。</p> <p>Q：當陣列中所有元素都相等時，快速排序的時間複雜度是 \\(O(n^2)\\) 嗎？該如何處理這種退化情況？</p> <p>是的。對於這種情況，可以考慮透過哨兵劃分將陣列劃分為三個部分：小於、等於、大於基準數。僅向下遞迴小於和大於的兩部分。在該方法下，輸入元素全部相等的陣列，僅一輪哨兵劃分即可完成排序。</p> <p>Q：桶排序的最差時間複雜度為什麼是 \\(O(n^2)\\) ？</p> <p>最差情況下，所有元素被分至同一個桶中。如果我們採用一個 \\(O(n^2)\\) 演算法來排序這些元素，則時間複雜度為 \\(O(n^2)\\) 。</p>","path":["第 11 章 &nbsp; 排序","11.11 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/","level":1,"title":"第 5 章   堆疊與佇列","text":"<p>Abstract</p> <p>堆疊如同疊貓貓，而佇列就像貓貓排隊。</p> <p>兩者分別代表先入後出和先入先出的邏輯關係。</p>","path":["第 5 章 &nbsp; 堆疊與佇列"],"tags":[]},{"location":"chapter_stack_and_queue/#_1","level":2,"title":"本章內容","text":"<ul> <li>5.1   堆疊</li> <li>5.2   佇列</li> <li>5.3   雙向佇列</li> <li>5.4   小結</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/","level":1,"title":"5.3   雙向佇列","text":"<p>在佇列中，我們僅能刪除頭部元素或在尾部新增元素。如圖 5-7 所示，雙向佇列（double-ended queue）提供了更高的靈活性，允許在頭部和尾部執行元素的新增或刪除操作。</p> <p></p> <p> 圖 5-7   雙向佇列的操作 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#531","level":2,"title":"5.3.1   雙向佇列常用操作","text":"<p>雙向佇列的常用操作如表 5-3 所示，具體的方法名稱需要根據所使用的程式語言來確定。</p> <p> 表 5-3   雙向佇列操作效率 </p> 方法名 描述 時間複雜度 <code>push_first()</code> 將元素新增至佇列首 \\(O(1)\\) <code>push_last()</code> 將元素新增至佇列尾 \\(O(1)\\) <code>pop_first()</code> 刪除佇列首元素 \\(O(1)\\) <code>pop_last()</code> 刪除佇列尾元素 \\(O(1)\\) <code>peek_first()</code> 訪問佇列首元素 \\(O(1)\\) <code>peek_last()</code> 訪問佇列尾元素 \\(O(1)\\) <p>同樣地，我們可以直接使用程式語言中已實現的雙向佇列類別：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby deque.py<pre><code>from collections import deque\n\n# 初始化雙向佇列\ndeq: deque[int] = deque()\n\n# 元素入列\ndeq.append(2)      # 新增至佇列尾\ndeq.append(5)\ndeq.append(4)\ndeq.appendleft(3)  # 新增至佇列首\ndeq.appendleft(1)\n\n# 訪問元素\nfront: int = deq[0]  # 佇列首元素\nrear: int = deq[-1]  # 佇列尾元素\n\n# 元素出列\npop_front: int = deq.popleft()  # 佇列首元素出列\npop_rear: int = deq.pop()       # 佇列尾元素出列\n\n# 獲取雙向佇列的長度\nsize: int = len(deq)\n\n# 判斷雙向佇列是否為空\nis_empty: bool = len(deq) == 0\n</code></pre> deque.cpp<pre><code>/* 初始化雙向佇列 */\ndeque&lt;int&gt; deque;\n\n/* 元素入列 */\ndeque.push_back(2);   // 新增至佇列尾\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // 新增至佇列首\ndeque.push_front(1);\n\n/* 訪問元素 */\nint front = deque.front(); // 佇列首元素\nint back = deque.back();   // 佇列尾元素\n\n/* 元素出列 */\ndeque.pop_front();  // 佇列首元素出列\ndeque.pop_back();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.size();\n\n/* 判斷雙向佇列是否為空 */\nbool empty = deque.empty();\n</code></pre> deque.java<pre><code>/* 初始化雙向佇列 */\nDeque&lt;Integer&gt; deque = new LinkedList&lt;&gt;();\n\n/* 元素入列 */\ndeque.offerLast(2);   // 新增至佇列尾\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // 新增至佇列首\ndeque.offerFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.peekFirst();  // 佇列首元素\nint peekLast = deque.peekLast();    // 佇列尾元素\n\n/* 元素出列 */\nint popFirst = deque.pollFirst();  // 佇列首元素出列\nint popLast = deque.pollLast();    // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.size();\n\n/* 判斷雙向佇列是否為空 */\nboolean isEmpty = deque.isEmpty();\n</code></pre> deque.cs<pre><code>/* 初始化雙向佇列 */\n// 在 C# 中，將鏈結串列 LinkedList 看作雙向佇列來使用\nLinkedList&lt;int&gt; deque = new();\n\n/* 元素入列 */\ndeque.AddLast(2);   // 新增至佇列尾\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // 新增至佇列首\ndeque.AddFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.First.Value;  // 佇列首元素\nint peekLast = deque.Last.Value;    // 佇列尾元素\n\n/* 元素出列 */\ndeque.RemoveFirst();  // 佇列首元素出列\ndeque.RemoveLast();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.Count;\n\n/* 判斷雙向佇列是否為空 */\nbool isEmpty = deque.Count == 0;\n</code></pre> deque_test.go<pre><code>/* 初始化雙向佇列 */\n// 在 Go 中，將 list 作為雙向佇列使用\ndeque := list.New()\n\n/* 元素入列 */\ndeque.PushBack(2)      // 新增至佇列尾\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // 新增至佇列首\ndeque.PushFront(1)\n\n/* 訪問元素 */\nfront := deque.Front() // 佇列首元素\nrear := deque.Back()   // 佇列尾元素\n\n/* 元素出列 */\ndeque.Remove(front)    // 佇列首元素出列\ndeque.Remove(rear)     // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nsize := deque.Len()\n\n/* 判斷雙向佇列是否為空 */\nisEmpty := deque.Len() == 0\n</code></pre> deque.swift<pre><code>/* 初始化雙向佇列 */\n// Swift 沒有內建的雙向佇列類別，可以把 Array 當作雙向佇列來使用\nvar deque: [Int] = []\n\n/* 元素入列 */\ndeque.append(2) // 新增至佇列尾\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // 新增至佇列首\ndeque.insert(1, at: 0)\n\n/* 訪問元素 */\nlet peekFirst = deque.first! // 佇列首元素\nlet peekLast = deque.last! // 佇列尾元素\n\n/* 元素出列 */\n// 使用 Array 模擬時 popFirst 的複雜度為 O(n)\nlet popFirst = deque.removeFirst() // 佇列首元素出列\nlet popLast = deque.removeLast() // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nlet size = deque.count\n\n/* 判斷雙向佇列是否為空 */\nlet isEmpty = deque.isEmpty\n</code></pre> deque.js<pre><code>/* 初始化雙向佇列 */\n// JavaScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用\nconst deque = [];\n\n/* 元素入列 */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 訪問元素 */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\n/* 元素出列 */\n// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)\nconst popFront = deque.shift();\nconst popBack = deque.pop();\n\n/* 獲取雙向佇列的長度 */\nconst size = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nconst isEmpty = size === 0;\n</code></pre> deque.ts<pre><code>/* 初始化雙向佇列 */\n// TypeScript 沒有內建的雙端佇列，只能把 Array 當作雙端佇列來使用\nconst deque: number[] = [];\n\n/* 元素入列 */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// 請注意，由於是陣列，unshift() 方法的時間複雜度為 O(n)\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* 訪問元素 */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\n/* 元素出列 */\n// 請注意，由於是陣列，shift() 方法的時間複雜度為 O(n)\nconst popFront: number = deque.shift() as number;\nconst popBack: number = deque.pop() as number;\n\n/* 獲取雙向佇列的長度 */\nconst size: number = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nconst isEmpty: boolean = size === 0;\n</code></pre> deque.dart<pre><code>/* 初始化雙向佇列 */\n// 在 Dart 中，Queue 被定義為雙向佇列\nQueue&lt;int&gt; deque = Queue&lt;int&gt;();\n\n/* 元素入列 */\ndeque.addLast(2);  // 新增至佇列尾\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // 新增至佇列首\ndeque.addFirst(1);\n\n/* 訪問元素 */\nint peekFirst = deque.first; // 佇列首元素\nint peekLast = deque.last;   // 佇列尾元素\n\n/* 元素出列 */\nint popFirst = deque.removeFirst(); // 佇列首元素出列\nint popLast = deque.removeLast();   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nint size = deque.length;\n\n/* 判斷雙向佇列是否為空 */\nbool isEmpty = deque.isEmpty;\n</code></pre> deque.rs<pre><code>/* 初始化雙向佇列 */\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 元素入列 */\ndeque.push_back(2);  // 新增至佇列尾\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // 新增至佇列首\ndeque.push_front(1);\n\n/* 訪問元素 */\nif let Some(front) = deque.front() { // 佇列首元素\n}\nif let Some(rear) = deque.back() {   // 佇列尾元素\n}\n\n/* 元素出列 */\nif let Some(pop_front) = deque.pop_front() { // 佇列首元素出列\n}\nif let Some(pop_rear) = deque.pop_back() {   // 佇列尾元素出列\n}\n\n/* 獲取雙向佇列的長度 */\nlet size = deque.len();\n\n/* 判斷雙向佇列是否為空 */\nlet is_empty = deque.is_empty();\n</code></pre> deque.c<pre><code>// C 未提供內建雙向佇列\n</code></pre> deque.kt<pre><code>/* 初始化雙向佇列 */\nval deque = LinkedList&lt;Int&gt;()\n\n/* 元素入列 */\ndeque.offerLast(2)  // 新增至佇列尾\ndeque.offerLast(5)\ndeque.offerLast(4)\ndeque.offerFirst(3) // 新增至佇列首\ndeque.offerFirst(1)\n\n/* 訪問元素 */\nval peekFirst = deque.peekFirst() // 佇列首元素\nval peekLast = deque.peekLast()   // 佇列尾元素\n\n/* 元素出列 */\nval popFirst = deque.pollFirst() // 佇列首元素出列\nval popLast = deque.pollLast()   // 佇列尾元素出列\n\n/* 獲取雙向佇列的長度 */\nval size = deque.size\n\n/* 判斷雙向佇列是否為空 */\nval isEmpty = deque.isEmpty()\n</code></pre> deque.rb<pre><code># 初始化雙向佇列\n# Ruby 沒有內直的雙端佇列，只能把 Array 當作雙端佇列來使用\ndeque = []\n\n# 元素如隊\ndeque &lt;&lt; 2\ndeque &lt;&lt; 5\ndeque &lt;&lt; 4\n# 請注意，由於是陣列，Array#unshift 方法的時間複雜度為 O(n)\ndeque.unshift(3)\ndeque.unshift(1)\n\n# 訪問元素\npeek_first = deque.first\npeek_last = deque.last\n\n# 元素出列\n# 請注意，由於是陣列， Array#shift 方法的時間複雜度為 O(n)\npop_front = deque.shift\npop_back = deque.pop\n\n# 獲取雙向佇列的長度\nsize = deque.length\n\n# 判斷雙向佇列是否為空\nis_empty = size.zero?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#532","level":2,"title":"5.3.2   雙向佇列實現 *","text":"<p>雙向佇列的實現與佇列類似，可以選擇鏈結串列或陣列作為底層資料結構。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#1","level":3,"title":"1.   基於雙向鏈結串列的實現","text":"<p>回顧上一節內容，我們使用普通單向鏈結串列來實現佇列，因為它可以方便地刪除頭節點（對應出列操作）和在尾節點後新增新節點（對應入列操作）。</p> <p>對於雙向佇列而言，頭部和尾部都可以執行入列和出列操作。換句話說，雙向佇列需要實現另一個對稱方向的操作。為此，我們採用“雙向鏈結串列”作為雙向佇列的底層資料結構。</p> <p>如圖 5-8 所示，我們將雙向鏈結串列的頭節點和尾節點視為雙向佇列的佇列首和佇列尾，同時實現在兩端新增和刪除節點的功能。</p> LinkedListDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 5-8   基於鏈結串列實現雙向佇列的入列出列操作 </p> <p>實現程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_deque.py<pre><code>class ListNode:\n    \"\"\"雙向鏈結串列節點\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"建構子\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # 後繼節點引用\n        self.prev: ListNode | None = None  # 前驅節點引用\n\nclass LinkedListDeque:\n    \"\"\"基於雙向鏈結串列實現的雙向佇列\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._front: ListNode | None = None  # 頭節點 front\n        self._rear: ListNode | None = None  # 尾節點 rear\n        self._size: int = 0  # 雙向佇列的長度\n\n    def size(self) -&gt; int:\n        \"\"\"獲取雙向佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷雙向佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"入列操作\"\"\"\n        node = ListNode(num)\n        # 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # 佇列首入列操作\n        elif is_front:\n            # 將 node 新增至鏈結串列頭部\n            self._front.prev = node\n            node.next = self._front\n            self._front = node  # 更新頭節點\n        # 佇列尾入列操作\n        else:\n            # 將 node 新增至鏈結串列尾部\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # 更新尾節點\n        self._size += 1  # 更新佇列長度\n\n    def push_first(self, num: int):\n        \"\"\"佇列首入列\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"佇列尾入列\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -&gt; int:\n        \"\"\"出列操作\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        # 佇列首出列操作\n        if is_front:\n            val: int = self._front.val  # 暫存頭節點值\n            # 刪除頭節點\n            fnext: ListNode | None = self._front.next\n            if fnext is not None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # 更新頭節點\n        # 佇列尾出列操作\n        else:\n            val: int = self._rear.val  # 暫存尾節點值\n            # 刪除尾節點\n            rprev: ListNode | None = self._rear.prev\n            if rprev is not None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # 更新尾節點\n        self._size -= 1  # 更新佇列長度\n        return val\n\n    def pop_first(self) -&gt; int:\n        \"\"\"佇列首出列\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -&gt; int:\n        \"\"\"佇列尾出列\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._front.val\n\n    def peek_last(self) -&gt; int:\n        \"\"\"訪問佇列尾元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._rear.val\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回陣列用於列印\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n</code></pre> linkedlist_deque.cpp<pre><code>/* 雙向鏈結串列節點 */\nstruct DoublyListNode {\n    int val;              // 節點值\n    DoublyListNode *next; // 後繼節點指標\n    DoublyListNode *prev; // 前驅節點指標\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize = 0;              // 雙向佇列的長度\n\n  public:\n    /* 建構子 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* 析構方法 */\n    ~LinkedListDeque() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur-&gt;next;\n            delete pre;\n        }\n    }\n\n    /* 獲取雙向佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列操作 */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty())\n            front = rear = node;\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front-&gt;prev = node;\n            node-&gt;next = front;\n            front = node; // 更新頭節點\n        // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear-&gt;next = node;\n            node-&gt;prev = rear;\n            rear = node; // 更新尾節點\n        }\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* 出列操作 */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"佇列為空\");\n        int val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front-&gt;val; // 暫存頭節點值\n            // 刪除頭節點\n            DoublyListNode *fNext = front-&gt;next;\n            if (fNext != nullptr) {\n                fNext-&gt;prev = nullptr;\n                front-&gt;next = nullptr;\n            }\n            delete front;\n            front = fNext; // 更新頭節點\n        // 佇列尾出列操作\n        } else {\n            val = rear-&gt;val; // 暫存尾節點值\n            // 刪除尾節點\n            DoublyListNode *rPrev = rear-&gt;prev;\n            if (rPrev != nullptr) {\n                rPrev-&gt;next = nullptr;\n                rear-&gt;prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // 更新尾節點\n        }\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* 佇列尾出列 */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return front-&gt;val;\n    }\n\n    /* 訪問佇列尾元素 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return rear-&gt;val;\n    }\n\n    /* 返回陣列用於列印 */\n    vector&lt;int&gt; toVector() {\n        DoublyListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_deque.java<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    int val; // 節點值\n    ListNode next; // 後繼節點引用\n    ListNode prev; // 前驅節點引用\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private ListNode front, rear; // 頭節點 front ，尾節點 rear\n    private int queSize = 0; // 雙向佇列的長度\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列操作 */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty())\n            front = rear = node;\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front.prev = node;\n            node.next = front;\n            front = node; // 更新頭節點\n        // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // 更新尾節點\n        }\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* 出列操作 */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front.val; // 暫存頭節點值\n            // 刪除頭節點\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // 更新頭節點\n        // 佇列尾出列操作\n        } else {\n            val = rear.val; // 暫存尾節點值\n            // 刪除尾節點\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // 更新尾節點\n        }\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* 佇列尾出列 */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 訪問佇列尾元素 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.cs<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode(int val) {\n    public int val = val;       // 節點值\n    public ListNode? next = null; // 後繼節點引用\n    public ListNode? prev = null; // 前驅節點引用\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    ListNode? front, rear; // 頭節點 front, 尾節點 rear\n    int queSize = 0;      // 雙向佇列的長度\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入列操作 */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // 佇列首入列操作\n        else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front!.prev = node;\n            node.next = front;\n            front = node; // 更新頭節點                           \n        }\n        // 佇列尾入列操作\n        else {\n            // 將 node 新增至鏈結串列尾部\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // 更新尾節點\n        }\n\n        queSize++; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* 出列操作 */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // 佇列首出列操作\n        if (isFront) {\n            val = front?.val; // 暫存頭節點值\n            // 刪除頭節點\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // 更新頭節點\n        }\n        // 佇列尾出列操作\n        else {\n            val = rear?.val;  // 暫存尾節點值\n            // 刪除尾節點\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // 更新尾節點\n        }\n\n        queSize--; // 更新佇列長度\n        return val;\n    }\n\n    /* 佇列首出列 */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* 佇列尾出列 */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* 訪問佇列尾元素 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* 返回陣列用於列印 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\n</code></pre> linkedlist_deque.go<pre><code>/* 基於雙向鏈結串列實現的雙向佇列 */\ntype linkedListDeque struct {\n    // 使用內建包 list\n    data *list.List\n}\n\n/* 初始化雙端佇列 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &amp;linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* 佇列首元素入列 */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* 佇列尾元素入列 */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* 佇列首元素出列 */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 佇列尾元素出列 */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問佇列首元素 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* 訪問佇列尾元素 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* 獲取佇列的長度 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* 判斷佇列是否為空 */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_deque.swift<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    var val: Int // 節點值\n    var next: ListNode? // 後繼節點引用\n    weak var prev: ListNode? // 前驅節點引用\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private var front: ListNode? // 頭節點 front\n    private var rear: ListNode? // 尾節點 rear\n    private var _size: Int // 雙向佇列的長度\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取雙向佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列操作 */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // 佇列首入列操作\n        else if isFront {\n            // 將 node 新增至鏈結串列頭部\n            front?.prev = node\n            node.next = front\n            front = node // 更新頭節點\n        }\n        // 佇列尾入列操作\n        else {\n            // 將 node 新增至鏈結串列尾部\n            rear?.next = node\n            node.prev = rear\n            rear = node // 更新尾節點\n        }\n        _size += 1 // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* 佇列尾入列 */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* 出列操作 */\n    private func pop(isFront: Bool) -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        let val: Int\n        // 佇列首出列操作\n        if isFront {\n            val = front!.val // 暫存頭節點值\n            // 刪除頭節點\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // 更新頭節點\n        }\n        // 佇列尾出列操作\n        else {\n            val = rear!.val // 暫存尾節點值\n            // 刪除尾節點\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // 更新尾節點\n        }\n        _size -= 1 // 更新佇列長度\n        return val\n    }\n\n    /* 佇列首出列 */\n    func popFirst() -&gt; Int {\n        pop(isFront: true)\n    }\n\n    /* 佇列尾出列 */\n    func popLast() -&gt; Int {\n        pop(isFront: false)\n    }\n\n    /* 訪問佇列首元素 */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return front!.val\n    }\n\n    /* 訪問佇列尾元素 */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return rear!.val\n    }\n\n    /* 返回陣列用於列印 */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.js<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    prev; // 前驅節點引用 (指標)\n    next; // 後繼節點引用 (指標)\n    val; // 節點值\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    #front; // 頭節點 front\n    #rear; // 尾節點 rear\n    #queSize; // 雙向佇列的長度\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* 佇列尾入列操作 */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // 更新尾節點\n        }\n        this.#queSize++;\n    }\n\n    /* 佇列首入列操作 */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // 將 node 新增至鏈結串列頭部\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // 更新頭節點\n        }\n        this.#queSize++;\n    }\n\n    /* 佇列尾出列操作 */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // 儲存尾節點值\n        // 刪除尾節點\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // 更新尾節點\n        this.#queSize--;\n        return value;\n    }\n\n    /* 佇列首出列操作 */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // 儲存尾節點值\n        // 刪除頭節點\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // 更新頭節點\n        this.#queSize--;\n        return value;\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 列印雙向佇列 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.ts<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n    prev: ListNode; // 前驅節點引用 (指標)\n    next: ListNode; // 後繼節點引用 (指標)\n    val: number; // 節點值\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private front: ListNode; // 頭節點 front\n    private rear: ListNode; // 尾節點 rear\n    private queSize: number; // 雙向佇列的長度\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* 佇列尾入列操作 */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // 更新尾節點\n        }\n        this.queSize++;\n    }\n\n    /* 佇列首入列操作 */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // 將 node 新增至鏈結串列頭部\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // 更新頭節點\n        }\n        this.queSize++;\n    }\n\n    /* 佇列尾出列操作 */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // 儲存尾節點值\n        // 刪除尾節點\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // 更新尾節點\n        this.queSize--;\n        return value;\n    }\n\n    /* 佇列首出列操作 */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // 儲存尾節點值\n        // 刪除頭節點\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // 更新頭節點\n        this.queSize--;\n        return value;\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 列印雙向佇列 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n</code></pre> linkedlist_deque.dart<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode {\n  int val; // 節點值\n  ListNode? next; // 後繼節點引用\n  ListNode? prev; // 前驅節點引用\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* 基於雙向鏈結串列實現的雙向對列 */\nclass LinkedListDeque {\n  late ListNode? _front; // 頭節點 _front\n  late ListNode? _rear; // 尾節點 _rear\n  int _queSize = 0; // 雙向佇列的長度\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* 獲取雙向佇列長度 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* 判斷雙向佇列是否為空 */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* 入列操作 */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // 若鏈結串列為空，則令 _front 和 _rear 都指向 node\n      _front = _rear = node;\n    } else if (isFront) {\n      // 佇列首入列操作\n      // 將 node 新增至鏈結串列頭部\n      _front!.prev = node;\n      node.next = _front;\n      _front = node; // 更新頭節點\n    } else {\n      // 佇列尾入列操作\n      // 將 node 新增至鏈結串列尾部\n      _rear!.next = node;\n      node.prev = _rear;\n      _rear = node; // 更新尾節點\n    }\n    _queSize++; // 更新佇列長度\n  }\n\n  /* 佇列首入列 */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* 佇列尾入列 */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* 出列操作 */\n  int? pop(bool isFront) {\n    // 若佇列為空，直接返回 null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // 佇列首出列操作\n      val = _front!.val; // 暫存頭節點值\n      // 刪除頭節點\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // 更新頭節點\n    } else {\n      // 佇列尾出列操作\n      val = _rear!.val; // 暫存尾節點值\n      // 刪除尾節點\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // 更新尾節點\n    }\n    _queSize--; // 更新佇列長度\n    return val;\n  }\n\n  /* 佇列首出列 */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* 佇列尾出列 */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* 訪問佇列首元素 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* 訪問佇列尾元素 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* 返回陣列用於列印 */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n</code></pre> linkedlist_deque.rs<pre><code>/* 雙向鏈結串列節點 */\npub struct ListNode&lt;T&gt; {\n    pub val: T,                                 // 節點值\n    pub next: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 後繼節點指標\n    pub prev: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 前驅節點指標\n}\n\nimpl&lt;T&gt; ListNode&lt;T&gt; {\n    pub fn new(val: T) -&gt; Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt; {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\n#[allow(dead_code)]\npub struct LinkedListDeque&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 頭節點 front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 尾節點 rear\n    que_size: usize,                         // 雙向佇列的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListDeque&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取雙向佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* 入列操作 */\n    fn push(&amp;mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // 佇列首入列操作\n        if is_front {\n            match self.front.take() {\n                // 若鏈結串列為空，則令 front 和 rear 都指向 node\n                None =&gt; {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // 將 node 新增至鏈結串列頭部\n                Some(old_front) =&gt; {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // 更新頭節點\n                }\n            }\n        }\n        // 佇列尾入列操作\n        else {\n            match self.rear.take() {\n                // 若鏈結串列為空，則令 front 和 rear 都指向 node\n                None =&gt; {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // 將 node 新增至鏈結串列尾部\n                Some(old_rear) =&gt; {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // 更新尾節點\n                }\n            }\n        }\n        self.que_size += 1; // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    pub fn push_first(&amp;mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* 佇列尾入列 */\n    pub fn push_last(&amp;mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* 出列操作 */\n    fn pop(&amp;mut self, is_front: bool) -&gt; Option&lt;T&gt; {\n        // 若佇列為空，直接返回 None\n        if self.is_empty() {\n            return None;\n        };\n        // 佇列首出列操作\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) =&gt; {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // 更新頭節點\n                    }\n                    None =&gt; {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // 更新佇列長度\n                old_front.borrow().val\n            })\n        }\n        // 佇列尾出列操作\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) =&gt; {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // 更新尾節點\n                    }\n                    None =&gt; {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // 更新佇列長度\n                old_rear.borrow().val\n            })\n        }\n    }\n\n    /* 佇列首出列 */\n    pub fn pop_first(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(true);\n    }\n\n    /* 佇列尾出列 */\n    pub fn pop_last(&amp;mut self) -&gt; Option&lt;T&gt; {\n        return self.pop(false);\n    }\n\n    /* 訪問佇列首元素 */\n    pub fn peek_first(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 訪問佇列尾元素 */\n    pub fn peek_last(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.rear.as_ref()\n    }\n\n    /* 返回陣列用於列印 */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n        res\n    }\n}\n</code></pre> linkedlist_deque.c<pre><code>/* 雙向鏈結串列節點 */\ntypedef struct DoublyListNode {\n    int val;                     // 節點值\n    struct DoublyListNode *next; // 後繼節點\n    struct DoublyListNode *prev; // 前驅節點\n} DoublyListNode;\n\n/* 建構子 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new-&gt;val = num;\n    new-&gt;next = NULL;\n    new-&gt;prev = NULL;\n    return new;\n}\n\n/* 析構函式 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\ntypedef struct {\n    DoublyListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize;                  // 雙向佇列的長度\n} LinkedListDeque;\n\n/* 建構子 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque-&gt;front = NULL;\n    deque-&gt;rear = NULL;\n    deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* 析構函式 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // 釋放所有節點\n    for (int i = 0; i &lt; deque-&gt;queSize &amp;&amp; deque-&gt;front != NULL; i++) {\n        DoublyListNode *tmp = deque-&gt;front;\n        deque-&gt;front = deque-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // 釋放 deque 結構體\n    free(deque);\n}\n\n/* 獲取佇列的長度 */\nint size(LinkedListDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* 入列 */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // 若鏈結串列為空，則令 front 和 rear 都指向node\n    if (empty(deque)) {\n        deque-&gt;front = deque-&gt;rear = node;\n    }\n    // 佇列首入列操作\n    else if (isFront) {\n        // 將 node 新增至鏈結串列頭部\n        deque-&gt;front-&gt;prev = node;\n        node-&gt;next = deque-&gt;front;\n        deque-&gt;front = node; // 更新頭節點\n    }\n    // 佇列尾入列操作\n    else {\n        // 將 node 新增至鏈結串列尾部\n        deque-&gt;rear-&gt;next = node;\n        node-&gt;prev = deque-&gt;rear;\n        deque-&gt;rear = node;\n    }\n    deque-&gt;queSize++; // 更新佇列長度\n}\n\n/* 佇列首入列 */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* 佇列尾入列 */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* 訪問佇列首元素 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;front);\n    return deque-&gt;front-&gt;val;\n}\n\n/* 訪問佇列尾元素 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) &amp;&amp; deque-&gt;rear);\n    return deque-&gt;rear-&gt;val;\n}\n\n/* 出列 */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // 佇列首出列操作\n    if (isFront) {\n        val = peekFirst(deque); // 暫存頭節點值\n        DoublyListNode *fNext = deque-&gt;front-&gt;next;\n        if (fNext) {\n            fNext-&gt;prev = NULL;\n            deque-&gt;front-&gt;next = NULL;\n        }\n        delDoublyListNode(deque-&gt;front);\n        deque-&gt;front = fNext; // 更新頭節點\n    }\n    // 佇列尾出列操作\n    else {\n        val = peekLast(deque); // 暫存尾節點值\n        DoublyListNode *rPrev = deque-&gt;rear-&gt;prev;\n        if (rPrev) {\n            rPrev-&gt;next = NULL;\n            deque-&gt;rear-&gt;prev = NULL;\n        }\n        delDoublyListNode(deque-&gt;rear);\n        deque-&gt;rear = rPrev; // 更新尾節點\n    }\n    deque-&gt;queSize--; // 更新佇列長度\n    return val;\n}\n\n/* 佇列首出列 */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* 佇列尾出列 */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* 列印佇列 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque-&gt;queSize);\n    // 複製鏈結串列中的資料到陣列\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque-&gt;front; i &lt; deque-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, deque-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_deque.kt<pre><code>/* 雙向鏈結串列節點 */\nclass ListNode(var _val: Int) {\n    // 節點值\n    var next: ListNode? = null // 後繼節點引用\n    var prev: ListNode? = null // 前驅節點引用\n}\n\n/* 基於雙向鏈結串列實現的雙向佇列 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // 頭節點 front\n    private var rear: ListNode? = null // 尾節點 rear\n    private var queSize: Int = 0 // 雙向佇列的長度\n\n    /* 獲取雙向佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入列操作 */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // 若鏈結串列為空，則令 front 和 rear 都指向 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // 佇列首入列操作\n        } else if (isFront) {\n            // 將 node 新增至鏈結串列頭部\n            front?.prev = node\n            node.next = front\n            front = node // 更新頭節點\n            // 佇列尾入列操作\n        } else {\n            // 將 node 新增至鏈結串列尾部\n            rear?.next = node\n            node.prev = rear\n            rear = node // 更新尾節點\n        }\n        queSize++ // 更新佇列長度\n    }\n\n    /* 佇列首入列 */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* 佇列尾入列 */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* 出列操作 */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) \n            throw IndexOutOfBoundsException()\n        val _val: Int\n        // 佇列首出列操作\n        if (isFront) {\n            _val = front!!._val // 暫存頭節點值\n            // 刪除頭節點\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // 更新頭節點\n            // 佇列尾出列操作\n        } else {\n            _val = rear!!._val // 暫存尾節點值\n            // 刪除尾節點\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // 更新尾節點\n        }\n        queSize-- // 更新佇列長度\n        return _val\n    }\n\n    /* 佇列首出列 */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* 佇列尾出列 */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* 訪問佇列首元素 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 訪問佇列尾元素 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!._val\n    }\n\n    /* 返回陣列用於列印 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_deque.rb<pre><code>=begin\nFile: linkedlist_deque.rb\nCreated Time: 2024-04-06\nAuthor: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)\n=end\n\n### 雙向鏈結串列節點\nclass ListNode\n  attr_accessor :val\n  attr_accessor :next # 後繼節點引用\n  attr_accessor :prev # 前軀節點引用\n\n  ### 建構子 ###\n  def initialize(val)\n    @val = val\n  end\nend\n\n### 基於雙向鏈結串列實現的雙向佇列 ###\nclass LinkedListDeque\n  ### 獲取雙向佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @front = nil  # 頭節點 front\n    @rear = nil   # 尾節點 rear\n    @size = 0     # 雙向佇列的長度\n  end\n\n  ### 判斷雙向佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 入列操作 ###\n  def push(num, is_front)\n    node = ListNode.new(num)\n    # 若鏈結串列為空， 則令 front 和 rear 都指向 node\n    if is_empty?\n      @front = @rear = node\n    # 佇列首入列操作\n    elsif is_front\n      # 將 node 新增至鏈結串列頭部\n      @front.prev = node\n      node.next = @front\n      @front = node # 更新頭節點\n    # 佇列尾入列操作\n    else\n      # 將 node 新增至鏈結串列尾部\n      @rear.next = node\n      node.prev = @rear\n      @rear = node # 更新尾節點\n    end\n    @size += 1 # 更新佇列長度\n  end\n\n  ### 佇列首入列 ###\n  def push_first(num)\n    push(num, true)\n  end\n\n  ### 佇列尾入列 ###\n  def push_last(num)\n    push(num, false)\n  end\n\n  ### 出列操作 ###\n  def pop(is_front)\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    # 佇列首出列操作\n    if is_front\n      val = @front.val # 暫存頭節點值\n      # 刪除頭節點\n      fnext = @front.next\n      unless fnext.nil?\n        fnext.prev = nil\n        @front.next = nil\n      end\n      @front = fnext # 更新頭節點\n    # 佇列尾出列操作\n    else\n      val = @rear.val # 暫存尾節點值\n      # 刪除尾節點\n      rprev = @rear.prev\n      unless rprev.nil?\n        rprev.next = nil\n        @rear.prev = nil\n      end\n      @rear = rprev # 更新尾節點\n    end\n    @size -= 1 # 更新佇列長度\n\n    val\n  end\n\n  ### 佇列首出列 ###\n  def pop_first\n    pop(true)\n  end\n\n  ### 佇列首出列 ###\n  def pop_last\n    pop(false)\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek_first\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @front.val\n  end\n\n  ### 訪問佇列尾元素 ###\n  def peek_last\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @rear.val\n  end\n\n  ### 返回陣列用於列印 ###\n  def to_array\n    node = @front\n    res = Array.new(size, 0)\n    for i in 0...size\n      res[i] = node.val\n      node = node.next\n    end\n    res\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>如圖 5-9 所示，與基於陣列實現佇列類似，我們也可以使用環形陣列來實現雙向佇列。</p> ArrayDequepush_last()push_first()pop_last()pop_first() <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 5-9   基於陣列實現雙向佇列的入列出列操作 </p> <p>在佇列的實現基礎上，僅需增加“佇列首入列”和“佇列尾出列”的方法：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_deque.py<pre><code>class ArrayDeque:\n    \"\"\"基於環形陣列實現的雙向佇列\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"建構子\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取雙向佇列的容量\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"獲取雙向佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷雙向佇列是否為空\"\"\"\n        return self._size == 0\n\n    def index(self, i: int) -&gt; int:\n        \"\"\"計算環形陣列索引\"\"\"\n        # 透過取餘操作實現陣列首尾相連\n        # 當 i 越過陣列尾部後，回到頭部\n        # 當 i 越過陣列頭部後，回到尾部\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"佇列首入列\"\"\"\n        if self._size == self.capacity():\n            print(\"雙向佇列已滿\")\n            return\n        # 佇列首指標向左移動一位\n        # 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        self._front = self.index(self._front - 1)\n        # 將 num 新增至佇列首\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"佇列尾入列\"\"\"\n        if self._size == self.capacity():\n            print(\"雙向佇列已滿\")\n            return\n        # 計算佇列尾指標，指向佇列尾索引 + 1\n        rear = self.index(self._front + self._size)\n        # 將 num 新增至佇列尾\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -&gt; int:\n        \"\"\"佇列首出列\"\"\"\n        num = self.peek_first()\n        # 佇列首指標向後移動一位\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -&gt; int:\n        \"\"\"佇列尾出列\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        return self._nums[self._front]\n\n    def peek_last(self) -&gt; int:\n        \"\"\"訪問佇列尾元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"雙向佇列為空\")\n        # 計算尾元素索引\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def to_array(self) -&gt; list[int]:\n        \"\"\"返回陣列用於列印\"\"\"\n        # 僅轉換有效長度範圍內的串列元素\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n</code></pre> array_deque.cpp<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n  private:\n    vector&lt;int&gt; nums; // 用於儲存雙向佇列元素的陣列\n    int front;        // 佇列首指標，指向佇列首元素\n    int queSize;      // 雙向佇列長度\n\n  public:\n    /* 建構子 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* 獲取雙向佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    int index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity();\n    }\n\n    /* 佇列首入列 */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"雙向佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout &lt;&lt; \"雙向佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    int popFirst() {\n        int num = peekFirst();\n        // 佇列首指標向後移動一位\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"雙向佇列為空\");\n        // 計算尾元素索引\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; res(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n</code></pre> array_deque.java<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private int[] nums; // 用於儲存雙向佇列元素的陣列\n    private int front; // 佇列首指標，指向佇列首元素\n    private int queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    private int index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity();\n    }\n\n    /* 佇列首入列 */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    public int popFirst() {\n        int num = peekFirst();\n        // 佇列首指標向後移動一位\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // 計算尾元素索引\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.cs<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    int[] nums;  // 用於儲存雙向佇列元素的陣列\n    int front;   // 佇列首指標，指向佇列首元素\n    int queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 計算環形陣列索引 */\n    int Index(int i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* 佇列首入列 */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = Index(front - 1);\n        // 將 num 新增至佇列首\n        nums[front] = num;\n        queSize++;\n    }\n\n    /* 佇列尾入列 */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        int rear = Index(front + queSize);\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 佇列首出列 */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // 佇列首指標向後移動一位\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* 訪問佇列尾元素 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // 計算尾元素索引\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.go<pre><code>/* 基於環形陣列實現的雙向佇列 */\ntype arrayDeque struct {\n    nums        []int // 用於儲存雙向佇列元素的陣列\n    front       int   // 佇列首指標，指向佇列首元素\n    queSize     int   // 雙向佇列長度\n    queCapacity int   // 佇列容量（即最大容納元素數量）\n}\n\n/* 初始化佇列 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &amp;arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 獲取雙向佇列的長度 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* 判斷雙向佇列是否為空 */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 計算環形陣列索引 */\nfunc (q *arrayDeque) index(i int) int {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部後，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* 佇列首入列 */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"雙向佇列已滿\")\n        return\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n    q.front = q.index(q.front - 1)\n    // 將 num 新增至佇列首\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* 佇列尾入列 */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"雙向佇列已滿\")\n        return\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    rear := q.index(q.front + q.queSize)\n    // 將 num 新增至佇列尾\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* 佇列首出列 */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    if num == nil {\n        return nil\n    }\n    // 佇列首指標向後移動一位\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* 佇列尾出列 */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    if num == nil {\n        return nil\n    }\n    q.queSize--\n    return num\n}\n\n/* 訪問佇列首元素 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 訪問佇列尾元素 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // 計算尾元素索引\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (q *arrayDeque) toSlice() []int {\n    // 僅轉換有效長度範圍內的串列元素\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i &lt; q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n</code></pre> array_deque.swift<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private var nums: [Int] // 用於儲存雙向佇列元素的陣列\n    private var front: Int // 佇列首指標，指向佇列首元素\n    private var _size: Int // 雙向佇列長度\n\n    /* 建構子 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 獲取雙向佇列的容量 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 獲取雙向佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 計算環形陣列索引 */\n    private func index(i: Int) -&gt; Int {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        (i + capacity()) % capacity()\n    }\n\n    /* 佇列首入列 */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"雙向佇列已滿\")\n            return\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(i: front - 1)\n        // 將 num 新增至佇列首\n        nums[front] = num\n        _size += 1\n    }\n\n    /* 佇列尾入列 */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"雙向佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        let rear = index(i: front + size())\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* 佇列首出列 */\n    func popFirst() -&gt; Int {\n        let num = peekFirst()\n        // 佇列首指標向後移動一位\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* 佇列尾出列 */\n    func popLast() -&gt; Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peekFirst() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        return nums[front]\n    }\n\n    /* 訪問佇列尾元素 */\n    func peekLast() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"雙向佇列為空\")\n        }\n        // 計算尾元素索引\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    func toArray() -&gt; [Int] {\n        // 僅轉換有效長度範圍內的串列元素\n        (front ..&lt; front + size()).map { nums[index(i: $0)] }\n    }\n}\n</code></pre> array_deque.js<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    #nums; // 用於儲存雙向佇列元素的陣列\n    #front; // 佇列首指標，指向佇列首元素\n    #queSize; // 雙向佇列長度\n\n    /* 建構子 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 計算環形陣列索引 */\n    index(i) {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* 佇列首入列 */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        this.#front = this.index(this.#front - 1);\n        // 將 num 新增至佇列首\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* 佇列尾入列 */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // 將 num 新增至佇列尾\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* 佇列首出列 */\n    popFirst() {\n        const num = this.peekFirst();\n        // 佇列首指標向後移動一位\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 計算尾元素索引\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        const res = [];\n        for (let i = 0, j = this.#front; i &lt; this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.ts<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n    private nums: number[]; // 用於儲存雙向佇列元素的陣列\n    private front: number; // 佇列首指標，指向佇列首元素\n    private queSize: number; // 雙向佇列長度\n\n    /* 建構子 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* 獲取雙向佇列的容量 */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 獲取雙向佇列的長度 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 計算環形陣列索引 */\n    index(i: number): number {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* 佇列首入列 */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        this.front = this.index(this.front - 1);\n        // 將 num 新增至佇列首\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* 佇列尾入列 */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('雙向佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // 將 num 新增至佇列尾\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* 佇列首出列 */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // 佇列首指標向後移動一位\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* 佇列尾出列 */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* 訪問佇列尾元素 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // 計算尾元素索引\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* 返回陣列用於列印 */\n    toArray(): number[] {\n        // 僅轉換有效長度範圍內的串列元素\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i &lt; this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n</code></pre> array_deque.dart<pre><code>/* 基於環形陣列實現的雙向佇列 */\nclass ArrayDeque {\n  late List&lt;int&gt; _nums; // 用於儲存雙向佇列元素的陣列\n  late int _front; // 佇列首指標，指向佇列首元素\n  late int _queSize; // 雙向佇列長度\n\n  /* 建構子 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* 獲取雙向佇列的容量 */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* 獲取雙向佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷雙向佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 計算環形陣列索引 */\n  int index(int i) {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部後，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return (i + capacity()) % capacity();\n  }\n\n  /* 佇列首入列 */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"雙向佇列已滿\");\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 _front 越過陣列頭部後回到尾部\n    _front = index(_front - 1);\n    // 將 _num 新增至佇列首\n    _nums[_front] = _num;\n    _queSize++;\n  }\n\n  /* 佇列尾入列 */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"雙向佇列已滿\");\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    int rear = index(_front + _queSize);\n    // 將 _num 新增至佇列尾\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* 佇列首出列 */\n  int popFirst() {\n    int _num = peekFirst();\n    // 佇列首指標向右移動一位\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* 佇列尾出列 */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"雙向佇列為空\");\n    }\n    return _nums[_front];\n  }\n\n  /* 訪問佇列尾元素 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"雙向佇列為空\");\n    }\n    // 計算尾元素索引\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* 返回陣列用於列印 */\n  List&lt;int&gt; toArray() {\n    // 僅轉換有效長度範圍內的串列元素\n    List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n</code></pre> array_deque.rs<pre><code>/* 基於環形陣列實現的雙向佇列 */\nstruct ArrayDeque&lt;T&gt; {\n    nums: Vec&lt;T&gt;,    // 用於儲存雙向佇列元素的陣列\n    front: usize,    // 佇列首指標，指向佇列首元素\n    que_size: usize, // 雙向佇列長度\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayDeque&lt;T&gt; {\n    /* 建構子 */\n    pub fn new(capacity: usize) -&gt; Self {\n        Self {\n            nums: vec![T::default(); capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取雙向佇列的容量 */\n    pub fn capacity(&amp;self) -&gt; usize {\n        self.nums.len()\n    }\n\n    /* 獲取雙向佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        self.que_size\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 計算環形陣列索引 */\n    fn index(&amp;self, i: i32) -&gt; usize {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        ((i + self.capacity() as i32) % self.capacity() as i32) as usize\n    }\n\n    /* 佇列首入列 */\n    pub fn push_first(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"雙向佇列已滿\");\n            return;\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        self.front = self.index(self.front as i32 - 1);\n        // 將 num 新增至佇列首\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* 佇列尾入列 */\n    pub fn push_last(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"雙向佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // 將 num 新增至佇列尾\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* 佇列首出列 */\n    fn pop_first(&amp;mut self) -&gt; T {\n        let num = self.peek_first();\n        // 佇列首指標向後移動一位\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* 佇列尾出列 */\n    fn pop_last(&amp;mut self) -&gt; T {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* 訪問佇列首元素 */\n    fn peek_first(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"雙向佇列為空\")\n        };\n        self.nums[self.front]\n    }\n\n    /* 訪問佇列尾元素 */\n    fn peek_last(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"雙向佇列為空\")\n        };\n        // 計算尾元素索引\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        // 僅轉換有效長度範圍內的串列元素\n        let mut res = vec![T::default(); self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n</code></pre> array_deque.c<pre><code>/* 基於環形陣列實現的雙向佇列 */\ntypedef struct {\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 尾指標，指向佇列尾 + 1\n    int queCapacity; // 佇列容量\n} ArrayDeque;\n\n/* 建構子 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // 初始化陣列\n    deque-&gt;queCapacity = capacity;\n    deque-&gt;nums = (int *)malloc(sizeof(int) * deque-&gt;queCapacity);\n    deque-&gt;front = deque-&gt;queSize = 0;\n    return deque;\n}\n\n/* 析構函式 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque-&gt;nums);\n    free(deque);\n}\n\n/* 獲取雙向佇列的容量 */\nint capacity(ArrayDeque *deque) {\n    return deque-&gt;queCapacity;\n}\n\n/* 獲取雙向佇列的長度 */\nint size(ArrayDeque *deque) {\n    return deque-&gt;queSize;\n}\n\n/* 判斷雙向佇列是否為空 */\nbool empty(ArrayDeque *deque) {\n    return deque-&gt;queSize == 0;\n}\n\n/* 計算環形陣列索引 */\nint dequeIndex(ArrayDeque *deque, int i) {\n    // 透過取餘操作實現陣列首尾相連\n    // 當 i 越過陣列尾部時，回到頭部\n    // 當 i 越過陣列頭部後，回到尾部\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* 佇列首入列 */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"雙向佇列已滿\\r\\n\");\n        return;\n    }\n    // 佇列首指標向左移動一位\n    // 透過取餘操作實現 front 越過陣列頭部回到尾部\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front - 1);\n    // 將 num 新增到佇列首\n    deque-&gt;nums[deque-&gt;front] = num;\n    deque-&gt;queSize++;\n}\n\n/* 佇列尾入列 */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque-&gt;queSize == capacity(deque)) {\n        printf(\"雙向佇列已滿\\r\\n\");\n        return;\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    int rear = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize);\n    // 將 num 新增至佇列尾\n    deque-&gt;nums[rear] = num;\n    deque-&gt;queSize++;\n}\n\n/* 訪問佇列首元素 */\nint peekFirst(ArrayDeque *deque) {\n    // 訪問異常：雙向佇列為空\n    assert(empty(deque) == 0);\n    return deque-&gt;nums[deque-&gt;front];\n}\n\n/* 訪問佇列尾元素 */\nint peekLast(ArrayDeque *deque) {\n    // 訪問異常：雙向佇列為空\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque-&gt;front + deque-&gt;queSize - 1);\n    return deque-&gt;nums[last];\n}\n\n/* 佇列首出列 */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // 佇列首指標向後移動一位\n    deque-&gt;front = dequeIndex(deque, deque-&gt;front + 1);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 佇列尾出列 */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque-&gt;queSize--;\n    return num;\n}\n\n/* 返回陣列用於列印 */\nint *toArray(ArrayDeque *deque, int *queSize) {\n    *queSize = deque-&gt;queSize;\n    int *res = (int *)calloc(deque-&gt;queSize, sizeof(int));\n    int j = deque-&gt;front;\n    for (int i = 0; i &lt; deque-&gt;queSize; i++) {\n        res[i] = deque-&gt;nums[j % deque-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_deque.kt<pre><code>/* 建構子 */\nclass ArrayDeque(capacity: Int) {\n    private var nums: IntArray = IntArray(capacity) // 用於儲存雙向佇列元素的陣列\n    private var front: Int = 0 // 佇列首指標，指向佇列首元素\n    private var queSize: Int = 0 // 雙向佇列長度\n\n    /* 獲取雙向佇列的容量 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 獲取雙向佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷雙向佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 計算環形陣列索引 */\n    private fun index(i: Int): Int {\n        // 透過取餘操作實現陣列首尾相連\n        // 當 i 越過陣列尾部後，回到頭部\n        // 當 i 越過陣列頭部後，回到尾部\n        return (i + capacity()) % capacity()\n    }\n\n    /* 佇列首入列 */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"雙向佇列已滿\")\n            return\n        }\n        // 佇列首指標向左移動一位\n        // 透過取餘操作實現 front 越過陣列頭部後回到尾部\n        front = index(front - 1)\n        // 將 num 新增至佇列首\n        nums[front] = num\n        queSize++\n    }\n\n    /* 佇列尾入列 */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"雙向佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        val rear = index(front + queSize)\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        queSize++\n    }\n\n    /* 佇列首出列 */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // 佇列首指標向後移動一位\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* 佇列尾出列 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 訪問佇列尾元素 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // 計算尾元素索引\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* 返回陣列用於列印 */\n    fun toArray(): IntArray {\n        // 僅轉換有效長度範圍內的串列元素\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_deque.rb<pre><code>### 基於環形陣列實現的雙向佇列 ###\nclass ArrayDeque\n  ### 獲取雙向佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize(capacity)\n    @nums = Array.new(capacity, 0)\n    @front = 0\n    @size = 0\n  end\n\n  ### 獲取雙向佇列的容量 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 判斷雙向佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 佇列首入列 ###\n  def push_first(num)\n    if size == capacity\n      puts '雙向佇列已滿'\n      return\n    end\n\n    # 佇列首指標向左移動一位\n    # 透過取餘操作實現 front 越過陣列頭部後回到尾部\n    @front = index(@front - 1)\n    # 將 num 新增至佇列首\n    @nums[@front] = num\n    @size += 1\n  end\n\n  ### 佇列尾入列 ###\n  def push_last(num)\n    if size == capacity\n      puts '雙向佇列已滿'\n      return\n    end\n\n    # 計算佇列尾指標，指向佇列尾索引 + 1\n    rear = index(@front + size)\n    # 將 num 新增至佇列尾\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### 佇列首出列 ###\n  def pop_first\n    num = peek_first\n    # 佇列首指標向後移動一位\n    @front = index(@front + 1)\n    @size -= 1\n    num\n  end\n\n  ### 佇列尾出列 ###\n  def pop_last\n    num = peek_last\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek_first\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 訪問佇列尾元素 ###\n  def peek_last\n    raise IndexError, '雙向佇列為空' if is_empty?\n\n    # 計算尾元素索引\n    last = index(@front + size - 1)\n    @nums[last]\n  end\n\n  ### 返回陣列用於列印 ###\n  def to_array\n    # 僅轉換有效長度範圍內的串列元素\n    res = []\n    for i in 0...size\n      res &lt;&lt; @nums[index(@front + i)]\n    end\n    res\n  end\n\n  private\n\n  ### 計算環形陣列索引 ###\n  def index(i)\n    # 透過取餘操作實現陣列首尾相連\n    # 當 i 越過陣列尾部後，回到頭部\n    # 當 i 越過陣列頭部後，回到尾部\n    (i + capacity) % capacity\n  end\nend\n</code></pre>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/deque/#533","level":2,"title":"5.3.3   雙向佇列應用","text":"<p>雙向佇列兼具堆疊與佇列的邏輯，因此它可以實現這兩者的所有應用場景，同時提供更高的自由度。</p> <p>我們知道，軟體的“撤銷”功能通常使用堆疊來實現：系統將每次更改操作 <code>push</code> 到堆疊中，然後透過 <code>pop</code> 實現撤銷。然而，考慮到系統資源的限制，軟體通常會限制撤銷的步數（例如僅允許儲存 \\(50\\) 步）。當堆疊的長度超過 \\(50\\) 時，軟體需要在堆疊底（佇列首）執行刪除操作。但堆疊無法實現該功能，此時就需要使用雙向佇列來替代堆疊。請注意，“撤銷”的核心邏輯仍然遵循堆疊的先入後出原則，只是雙向佇列能夠更加靈活地實現一些額外邏輯。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.3 &nbsp; 雙向佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/","level":1,"title":"5.2   佇列","text":"<p>佇列（queue）是一種遵循先入先出規則的線性資料結構。顧名思義，佇列模擬了排隊現象，即新來的人不斷加入佇列尾部，而位於佇列頭部的人逐個離開。</p> <p>如圖 5-4 所示，我們將佇列頭部稱為“佇列首”，尾部稱為“佇列尾”，將把元素加入列尾的操作稱為“入列”，刪除佇列首元素的操作稱為“出列”。</p> <p></p> <p> 圖 5-4   佇列的先入先出規則 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#521","level":2,"title":"5.2.1   佇列常用操作","text":"<p>佇列的常見操作如表 5-2 所示。需要注意的是，不同程式語言的方法名稱可能會有所不同。我們在此採用與堆疊相同的方法命名。</p> <p> 表 5-2   佇列操作效率 </p> 方法名 描述 時間複雜度 <code>push()</code> 元素入列，即將元素新增至佇列尾 \\(O(1)\\) <code>pop()</code> 佇列首元素出列 \\(O(1)\\) <code>peek()</code> 訪問佇列首元素 \\(O(1)\\) <p>我們可以直接使用程式語言中現成的佇列類別：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby queue.py<pre><code>from collections import deque\n\n# 初始化佇列\n# 在 Python 中，我們一般將雙向佇列類別 deque 當作佇列使用\n# 雖然 queue.Queue() 是純正的佇列類別，但不太好用，因此不推薦\nque: deque[int] = deque()\n\n# 元素入列\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# 訪問佇列首元素\nfront: int = que[0]\n\n# 元素出列\npop: int = que.popleft()\n\n# 獲取佇列的長度\nsize: int = len(que)\n\n# 判斷佇列是否為空\nis_empty: bool = len(que) == 0\n</code></pre> queue.cpp<pre><code>/* 初始化佇列 */\nqueue&lt;int&gt; queue;\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nint front = queue.front();\n\n/* 元素出列 */\nqueue.pop();\n\n/* 獲取佇列的長度 */\nint size = queue.size();\n\n/* 判斷佇列是否為空 */\nbool empty = queue.empty();\n</code></pre> queue.java<pre><code>/* 初始化佇列 */\nQueue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();\n\n/* 元素入列 */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.peek();\n\n/* 元素出列 */\nint pop = queue.poll();\n\n/* 獲取佇列的長度 */\nint size = queue.size();\n\n/* 判斷佇列是否為空 */\nboolean isEmpty = queue.isEmpty();\n</code></pre> queue.cs<pre><code>/* 初始化佇列 */\nQueue&lt;int&gt; queue = new();\n\n/* 元素入列 */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.Peek();\n\n/* 元素出列 */\nint pop = queue.Dequeue();\n\n/* 獲取佇列的長度 */\nint size = queue.Count;\n\n/* 判斷佇列是否為空 */\nbool isEmpty = queue.Count == 0;\n</code></pre> queue_test.go<pre><code>/* 初始化佇列 */\n// 在 Go 中，將 list 作為佇列來使用\nqueue := list.New()\n\n/* 元素入列 */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* 訪問佇列首元素 */\npeek := queue.Front()\n\n/* 元素出列 */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* 獲取佇列的長度 */\nsize := queue.Len()\n\n/* 判斷佇列是否為空 */\nisEmpty := queue.Len() == 0\n</code></pre> queue.swift<pre><code>/* 初始化佇列 */\n// Swift 沒有內建的佇列類別，可以把 Array 當作佇列來使用\nvar queue: [Int] = []\n\n/* 元素入列 */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* 訪問佇列首元素 */\nlet peek = queue.first!\n\n/* 元素出列 */\n// 由於是陣列，因此 removeFirst 的複雜度為 O(n)\nlet pool = queue.removeFirst()\n\n/* 獲取佇列的長度 */\nlet size = queue.count\n\n/* 判斷佇列是否為空 */\nlet isEmpty = queue.isEmpty\n</code></pre> queue.js<pre><code>/* 初始化佇列 */\n// JavaScript 沒有內建的佇列，可以把 Array 當作佇列來使用\nconst queue = [];\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nconst peek = queue[0];\n\n/* 元素出列 */\n// 底層是陣列，因此 shift() 方法的時間複雜度為 O(n)\nconst pop = queue.shift();\n\n/* 獲取佇列的長度 */\nconst size = queue.length;\n\n/* 判斷佇列是否為空 */\nconst empty = queue.length === 0;\n</code></pre> queue.ts<pre><code>/* 初始化佇列 */\n// TypeScript 沒有內建的佇列，可以把 Array 當作佇列來使用\nconst queue: number[] = [];\n\n/* 元素入列 */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* 訪問佇列首元素 */\nconst peek = queue[0];\n\n/* 元素出列 */\n// 底層是陣列，因此 shift() 方法的時間複雜度為 O(n)\nconst pop = queue.shift();\n\n/* 獲取佇列的長度 */\nconst size = queue.length;\n\n/* 判斷佇列是否為空 */\nconst empty = queue.length === 0;\n</code></pre> queue.dart<pre><code>/* 初始化佇列 */\n// 在 Dart 中，佇列類別 Qeque 是雙向佇列，也可作為佇列使用\nQueue&lt;int&gt; queue = Queue();\n\n/* 元素入列 */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* 訪問佇列首元素 */\nint peek = queue.first;\n\n/* 元素出列 */\nint pop = queue.removeFirst();\n\n/* 獲取佇列的長度 */\nint size = queue.length;\n\n/* 判斷佇列是否為空 */\nbool isEmpty = queue.isEmpty;\n</code></pre> queue.rs<pre><code>/* 初始化雙向佇列 */\n// 在 Rust 中使用雙向佇列作為普通佇列來使用\nlet mut deque: VecDeque&lt;u32&gt; = VecDeque::new();\n\n/* 元素入列 */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* 訪問佇列首元素 */\nif let Some(front) = deque.front() {\n}\n\n/* 元素出列 */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* 獲取佇列的長度 */\nlet size = deque.len();\n\n/* 判斷佇列是否為空 */\nlet is_empty = deque.is_empty();\n</code></pre> queue.c<pre><code>// C 未提供內建佇列\n</code></pre> queue.kt<pre><code>/* 初始化佇列 */\nval queue = LinkedList&lt;Int&gt;()\n\n/* 元素入列 */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* 訪問佇列首元素 */\nval peek = queue.peek()\n\n/* 元素出列 */\nval pop = queue.poll()\n\n/* 獲取佇列的長度 */\nval size = queue.size\n\n/* 判斷佇列是否為空 */\nval isEmpty = queue.isEmpty()\n</code></pre> queue.rb<pre><code># 初始化佇列\n# Ruby 內建的佇列（Thread::Queue) 沒有 peek 和走訪方法，可以把 Array 當作佇列來使用\nqueue = []\n\n# 元素入列\nqueue.push(1)\nqueue.push(3)\nqueue.push(2)\nqueue.push(5)\nqueue.push(4)\n\n# 訪問佇列元素\npeek = queue.first\n\n# 元素出列\n# 清注意，由於是陣列，Array#shift 方法時間複雜度為 O(n)\npop = queue.shift\n\n# 獲取佇列的長度\nsize = queue.length\n\n# 判斷佇列是否為空\nis_empty = queue.empty?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#522","level":2,"title":"5.2.2   佇列實現","text":"<p>為了實現佇列，我們需要一種資料結構，可以在一端新增元素，並在另一端刪除元素，鏈結串列和陣列都符合要求。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#1","level":3,"title":"1.   基於鏈結串列的實現","text":"<p>如圖 5-5 所示，我們可以將鏈結串列的“頭節點”和“尾節點”分別視為“佇列首”和“佇列尾”，規定佇列尾僅可新增節點，佇列首僅可刪除節點。</p> LinkedListQueuepush()pop() <p></p> <p></p> <p></p> <p> 圖 5-5   基於鏈結串列實現佇列的入列出列操作 </p> <p>以下是用鏈結串列實現佇列的程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_queue.py<pre><code>class LinkedListQueue:\n    \"\"\"基於鏈結串列實現的佇列\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._front: ListNode | None = None  # 頭節點 front\n        self._rear: ListNode | None = None  # 尾節點 rear\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"獲取佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"入列\"\"\"\n        # 在尾節點後新增 num\n        node = ListNode(num)\n        # 如果佇列為空，則令頭、尾節點都指向該節點\n        if self._front is None:\n            self._front = node\n            self._rear = node\n        # 如果佇列不為空，則將該節點新增到尾節點後\n        else:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出列\"\"\"\n        num = self.peek()\n        # 刪除頭節點\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"佇列為空\")\n        return self._front.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"轉化為串列用於列印\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n</code></pre> linkedlist_queue.cpp<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // 頭節點 front ，尾節點 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        freeMemoryLinkedList(front);\n    }\n\n    /* 獲取佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    void push(int num) {\n        // 在尾節點後新增 num\n        ListNode *node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        else {\n            rear-&gt;next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    int pop() {\n        int num = peek();\n        // 刪除頭節點\n        ListNode *tmp = front;\n        front = front-&gt;next;\n        // 釋放記憶體\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"佇列為空\");\n        return front-&gt;val;\n    }\n\n    /* 將鏈結串列轉化為 Vector 並返回 */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = front;\n        vector&lt;int&gt; res(size());\n        for (int i = 0; i &lt; res.size(); i++) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_queue.java<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private ListNode front, rear; // 頭節點 front ，尾節點 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列 */\n    public void push(int num) {\n        // 在尾節點後新增 num\n        ListNode node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node;\n            rear = node;\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    public int pop() {\n        int num = peek();\n        // 刪除頭節點\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.cs<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // 頭節點 front ，尾節點 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入列 */\n    public void Push(int num) {\n        // 在尾節點後新增 num\n        ListNode node = new(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node;\n            rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* 出列 */\n    public int Pop() {\n        int num = Peek();\n        // 刪除頭節點\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i &lt; res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.go<pre><code>/* 基於鏈結串列實現的佇列 */\ntype linkedListQueue struct {\n    // 使用內建包 list 來實現佇列\n    data *list.List\n}\n\n/* 初始化佇列 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &amp;linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* 入列 */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* 出列 */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問佇列首元素 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* 獲取佇列的長度 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* 判斷佇列是否為空 */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_queue.swift<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private var front: ListNode? // 頭節點\n    private var rear: ListNode? // 尾節點\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列 */\n    func push(num: Int) {\n        // 在尾節點後新增 num\n        let node = ListNode(x: num)\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // 如果佇列不為空，則將該節點新增到尾節點後\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* 出列 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 刪除頭節點\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"佇列為空\")\n        }\n        return front!.val\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.js<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    #front; // 頭節點 #front\n    #rear; // 尾節點 #rear\n    #queSize = 0;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* 入列 */\n    push(num) {\n        // 在尾節點後新增 num\n        const node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (!this.#front) {\n            this.#front = node;\n            this.#rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* 出列 */\n    pop() {\n        const num = this.peek();\n        // 刪除頭節點\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek() {\n        if (this.size === 0) throw new Error('佇列為空');\n        return this.#front.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.ts<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n    private front: ListNode | null; // 頭節點 front\n    private rear: ListNode | null; // 尾節點 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* 獲取佇列的長度 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* 入列 */\n    push(num: number): void {\n        // 在尾節點後新增 num\n        const node = new ListNode(num);\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (!this.front) {\n            this.front = node;\n            this.rear = node;\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* 出列 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('佇列為空');\n        // 刪除頭節點\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek(): number {\n        if (this.size === 0) throw new Error('佇列為空');\n        return this.front!.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = 0; i &lt; res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_queue.dart<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue {\n  ListNode? _front; // 頭節點 _front\n  ListNode? _rear; // 尾節點 _rear\n  int _queSize = 0; // 佇列長度\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* 獲取佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 入列 */\n  void push(int _num) {\n    // 在尾節點後新增 _num\n    final node = ListNode(_num);\n    // 如果佇列為空，則令頭、尾節點都指向該節點\n    if (_front == null) {\n      _front = node;\n      _rear = node;\n    } else {\n      // 如果佇列不為空，則將該節點新增到尾節點後\n      _rear!.next = node;\n      _rear = node;\n    }\n    _queSize++;\n  }\n\n  /* 出列 */\n  int pop() {\n    final int _num = peek();\n    // 刪除頭節點\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('佇列為空');\n    }\n    return _front!.val;\n  }\n\n  /* 將鏈結串列轉化為 Array 並返回 */\n  List&lt;int&gt; toArray() {\n    ListNode? node = _front;\n    final List&lt;int&gt; queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n</code></pre> linkedlist_queue.rs<pre><code>/* 基於鏈結串列實現的佇列 */\n#[allow(dead_code)]\npub struct LinkedListQueue&lt;T&gt; {\n    front: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 頭節點 front\n    rear: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;,  // 尾節點 rear\n    que_size: usize,                         // 佇列的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListQueue&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* 獲取佇列的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.que_size;\n    }\n\n    /* 判斷佇列是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.que_size == 0;\n    }\n\n    /* 入列 */\n    pub fn push(&amp;mut self, num: T) {\n        // 在尾節點後新增 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // 如果佇列不為空，則將該節點新增到尾節點後\n            Some(old_rear) =&gt; {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // 如果佇列為空，則令頭、尾節點都指向該節點\n            None =&gt; {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* 出列 */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) =&gt; {\n                    self.front = Some(new_front);\n                }\n                None =&gt; {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            old_front.borrow().val\n        })\n    }\n\n    /* 訪問佇列首元素 */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.front.as_ref()\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    pub fn to_array(&amp;self, head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n        let mut res: Vec&lt;T&gt; = Vec::new();\n\n        fn recur&lt;T: Copy&gt;(cur: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, res: &amp;mut Vec&lt;T&gt;) {\n            if let Some(cur) = cur {\n                res.push(cur.borrow().val);\n                recur(cur.borrow().next.as_ref(), res);\n            }\n        }\n\n        recur(head, &amp;mut res);\n\n        res\n    }\n}\n</code></pre> linkedlist_queue.c<pre><code>/* 基於鏈結串列實現的佇列 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* 建構子 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue-&gt;front = NULL;\n    queue-&gt;rear = NULL;\n    queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* 析構函式 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // 釋放所有節點\n    while (queue-&gt;front != NULL) {\n        ListNode *tmp = queue-&gt;front;\n        queue-&gt;front = queue-&gt;front-&gt;next;\n        free(tmp);\n    }\n    // 釋放 queue 結構體\n    free(queue);\n}\n\n/* 獲取佇列的長度 */\nint size(LinkedListQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* 入列 */\nvoid push(LinkedListQueue *queue, int num) {\n    // 尾節點處新增 node\n    ListNode *node = newListNode(num);\n    // 如果佇列為空，則令頭、尾節點都指向該節點\n    if (queue-&gt;front == NULL) {\n        queue-&gt;front = node;\n        queue-&gt;rear = node;\n    }\n    // 如果佇列不為空，則將該節點新增到尾節點後\n    else {\n        queue-&gt;rear-&gt;next = node;\n        queue-&gt;rear = node;\n    }\n    queue-&gt;queSize++;\n}\n\n/* 訪問佇列首元素 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) &amp;&amp; queue-&gt;front);\n    return queue-&gt;front-&gt;val;\n}\n\n/* 出列 */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue-&gt;front;\n    queue-&gt;front = queue-&gt;front-&gt;next;\n    free(tmp);\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 列印佇列 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue-&gt;queSize);\n    // 複製鏈結串列中的資料到陣列\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue-&gt;front; i &lt; queue-&gt;queSize; i++) {\n        arr[i] = node-&gt;val;\n        node = node-&gt;next;\n    }\n    printArray(arr, queue-&gt;queSize);\n    free(arr);\n}\n</code></pre> linkedlist_queue.kt<pre><code>/* 基於鏈結串列實現的佇列 */\nclass LinkedListQueue(\n    // 頭節點 front ，尾節點 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* 獲取佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入列 */\n    fun push(num: Int) {\n        // 在尾節點後新增 num\n        val node = ListNode(num)\n        // 如果佇列為空，則令頭、尾節點都指向該節點\n        if (front == null) {\n            front = node\n            rear = node\n            // 如果佇列不為空，則將該節點新增到尾節點後\n        } else {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* 出列 */\n    fun pop(): Int {\n        val num = peek()\n        // 刪除頭節點\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!._val\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!._val\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_queue.rb<pre><code>### 基於鏈結串列頭現的佇列 ###\nclass LinkedListQueue\n  ### 獲取佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @front = nil  # 頭節點 front\n    @rear = nil   # 尾節點 rear\n    @size = 0\n  end\n\n  ### 判斷佇列是否為空 ###\n  def is_empty?\n    @front.nil?\n  end\n\n  ### 入列 ###\n  def push(num)\n    # 在尾節點後新增 num\n    node = ListNode.new(num)\n\n    # 如果佇列為空，則令頭，尾節點都指向該節點\n    if @front.nil?\n      @front = node\n      @rear = node\n    # 如果佇列不為空，則令該節點新增到尾節點後\n    else\n      @rear.next = node\n      @rear = node\n    end\n\n    @size += 1\n  end\n\n  ### 出列 ###\n  def pop\n    num = peek\n    # 刪除頭節點\n    @front = @front.next\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek\n    raise IndexError, '佇列為空' if is_empty?\n\n    @front.val\n  end\n\n  ### 將鏈結串列為 Array 並返回 ###\n  def to_array\n    queue = []\n    temp = @front\n    while temp\n      queue &lt;&lt; temp.val\n      temp = temp.next\n    end\n    queue\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>在陣列中刪除首元素的時間複雜度為 \\(O(n)\\) ，這會導致出列操作效率較低。然而，我們可以採用以下巧妙方法來避免這個問題。</p> <p>我們可以使用一個變數 <code>front</code> 指向佇列首元素的索引，並維護一個變數 <code>size</code> 用於記錄佇列長度。定義 <code>rear = front + size</code> ，這個公式計算出的 <code>rear</code> 指向佇列尾元素之後的下一個位置。</p> <p>基於此設計，陣列中包含元素的有效區間為 <code>[front, rear - 1]</code>，各種操作的實現方法如圖 5-6 所示。</p> <ul> <li>入列操作：將輸入元素賦值給 <code>rear</code> 索引處，並將 <code>size</code> 增加 1 。</li> <li>出列操作：只需將 <code>front</code> 增加 1 ，並將 <code>size</code> 減少 1 。</li> </ul> <p>可以看到，入列和出列操作都只需進行一次操作，時間複雜度均為 \\(O(1)\\) 。</p> ArrayQueuepush()pop() <p></p> <p></p> <p></p> <p> 圖 5-6   基於陣列實現佇列的入列出列操作 </p> <p>你可能會發現一個問題：在不斷進行入列和出列的過程中，<code>front</code> 和 <code>rear</code> 都在向右移動，當它們到達陣列尾部時就無法繼續移動了。為了解決此問題，我們可以將陣列視為首尾相接的“環形陣列”。</p> <p>對於環形陣列，我們需要讓 <code>front</code> 或 <code>rear</code> 在越過陣列尾部時，直接回到陣列頭部繼續走訪。這種週期性規律可以透過“取餘操作”來實現，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_queue.py<pre><code>class ArrayQueue:\n    \"\"\"基於環形陣列實現的佇列\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"建構子\"\"\"\n        self._nums: list[int] = [0] * size  # 用於儲存佇列元素的陣列\n        self._front: int = 0  # 佇列首指標，指向佇列首元素\n        self._size: int = 0  # 佇列長度\n\n    def capacity(self) -&gt; int:\n        \"\"\"獲取佇列的容量\"\"\"\n        return len(self._nums)\n\n    def size(self) -&gt; int:\n        \"\"\"獲取佇列的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷佇列是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"入列\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"佇列已滿\")\n        # 計算佇列尾指標，指向佇列尾索引 + 1\n        # 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        rear: int = (self._front + self._size) % self.capacity()\n        # 將 num 新增至佇列尾\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出列\"\"\"\n        num: int = self.peek()\n        # 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問佇列首元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"佇列為空\")\n        return self._nums[self._front]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"返回串列用於列印\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n</code></pre> array_queue.cpp<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n  private:\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 佇列長度\n    int queCapacity; // 佇列容量\n\n  public:\n    ArrayQueue(int capacity) {\n        // 初始化陣列\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* 獲取佇列的容量 */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* 獲取佇列的長度 */\n    int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入列 */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout &lt;&lt; \"佇列已滿\" &lt;&lt; endl;\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % queCapacity;\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    int pop() {\n        int num = peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"佇列為空\");\n        return nums[front];\n    }\n\n    /* 將陣列轉化為 Vector 並返回 */\n    vector&lt;int&gt; toVector() {\n        // 僅轉換有效長度範圍內的串列元素\n        vector&lt;int&gt; arr(queSize);\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n</code></pre> array_queue.java<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private int[] nums; // 用於儲存佇列元素的陣列\n    private int front; // 佇列首指標，指向佇列首元素\n    private int queSize; // 佇列長度\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    public int size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % capacity();\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    public int pop() {\n        int num = peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* 返回陣列 */\n    public int[] toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.cs<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    int[] nums;  // 用於儲存佇列元素的陣列\n    int front;   // 佇列首指標，指向佇列首元素\n    int queSize; // 佇列長度\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* 獲取佇列的長度 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* 入列 */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        int rear = (front + queSize) % Capacity();\n        // 將 num 新增至佇列尾\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* 出列 */\n    public int Pop() {\n        int num = Peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* 返回陣列 */\n    public int[] ToArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i &lt; queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n</code></pre> array_queue.go<pre><code>/* 基於環形陣列實現的佇列 */\ntype arrayQueue struct {\n    nums        []int // 用於儲存佇列元素的陣列\n    front       int   // 佇列首指標，指向佇列首元素\n    queSize     int   // 佇列長度\n    queCapacity int   // 佇列容量（即最大容納元素數量）\n}\n\n/* 初始化佇列 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &amp;arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* 獲取佇列的長度 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* 判斷佇列是否為空 */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* 入列 */\nfunc (q *arrayQueue) push(num int) {\n    // 當 rear == queCapacity 表示佇列已滿\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    rear := (q.front + q.queSize) % q.queCapacity\n    // 將 num 新增至佇列尾\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* 出列 */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    if num == nil {\n        return nil\n    }\n\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* 訪問佇列首元素 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear &gt;= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n</code></pre> array_queue.swift<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private var nums: [Int] // 用於儲存佇列元素的陣列\n    private var front: Int // 佇列首指標，指向佇列首元素\n    private var _size: Int // 佇列長度\n\n    init(capacity: Int) {\n        // 初始化陣列\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* 獲取佇列的容量 */\n    func capacity() -&gt; Int {\n        nums.count\n    }\n\n    /* 獲取佇列的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷佇列是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入列 */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        let rear = (front + size()) % capacity()\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* 出列 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"佇列為空\")\n        }\n        return nums[front]\n    }\n\n    /* 返回陣列 */\n    func toArray() -&gt; [Int] {\n        // 僅轉換有效長度範圍內的串列元素\n        (front ..&lt; front + size()).map { nums[$0 % capacity()] }\n    }\n}\n</code></pre> array_queue.js<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    #nums; // 用於儲存佇列元素的陣列\n    #front = 0; // 佇列首指標，指向佇列首元素\n    #queSize = 0; // 佇列長度\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* 獲取佇列的容量 */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* 入列 */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        const rear = (this.#front + this.size) % this.capacity;\n        // 將 num 新增至佇列尾\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* 出列 */\n    pop() {\n        const num = this.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek() {\n        if (this.isEmpty()) throw new Error('佇列為空');\n        return this.#nums[this.#front];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i &lt; this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.ts<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n    private nums: number[]; // 用於儲存佇列元素的陣列\n    private front: number; // 佇列首指標，指向佇列首元素\n    private queSize: number; // 佇列長度\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* 獲取佇列的容量 */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* 獲取佇列的長度 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* 判斷佇列是否為空 */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* 入列 */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('佇列已滿');\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        const rear = (this.front + this.queSize) % this.capacity;\n        // 將 num 新增至佇列尾\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* 出列 */\n    pop(): number {\n        const num = this.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* 訪問佇列首元素 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('佇列為空');\n        return this.nums[this.front];\n    }\n\n    /* 返回 Array */\n    toArray(): number[] {\n        // 僅轉換有效長度範圍內的串列元素\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i &lt; this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n</code></pre> array_queue.dart<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue {\n  late List&lt;int&gt; _nums; // 用於儲存佇列元素的陣列\n  late int _front; // 佇列首指標，指向佇列首元素\n  late int _queSize; // 佇列長度\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* 獲取佇列的容量 */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* 獲取佇列的長度 */\n  int size() {\n    return _queSize;\n  }\n\n  /* 判斷佇列是否為空 */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* 入列 */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"佇列已滿\");\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    int rear = (_front + _queSize) % capaCity();\n    // 將 _num 新增至佇列尾\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* 出列 */\n  int pop() {\n    int _num = peek();\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* 訪問佇列首元素 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"佇列為空\");\n    }\n    return _nums[_front];\n  }\n\n  /* 返回 Array */\n  List&lt;int&gt; toArray() {\n    // 僅轉換有效長度範圍內的串列元素\n    final List&lt;int&gt; res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i &lt; _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n</code></pre> array_queue.rs<pre><code>/* 基於環形陣列實現的佇列 */\nstruct ArrayQueue&lt;T&gt; {\n    nums: Vec&lt;T&gt;,      // 用於儲存佇列元素的陣列\n    front: i32,        // 佇列首指標，指向佇列首元素\n    que_size: i32,     // 佇列長度\n    que_capacity: i32, // 佇列容量\n}\n\nimpl&lt;T: Copy + Default&gt; ArrayQueue&lt;T&gt; {\n    /* 建構子 */\n    fn new(capacity: i32) -&gt; ArrayQueue&lt;T&gt; {\n        ArrayQueue {\n            nums: vec![T::default(); capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* 獲取佇列的容量 */\n    fn capacity(&amp;self) -&gt; i32 {\n        self.que_capacity\n    }\n\n    /* 獲取佇列的長度 */\n    fn size(&amp;self) -&gt; i32 {\n        self.que_size\n    }\n\n    /* 判斷佇列是否為空 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.que_size == 0\n    }\n\n    /* 入列 */\n    fn push(&amp;mut self, num: T) {\n        if self.que_size == self.capacity() {\n            println!(\"佇列已滿\");\n            return;\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // 將 num 新增至佇列尾\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* 出列 */\n    fn pop(&amp;mut self) -&gt; T {\n        let num = self.peek();\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* 訪問佇列首元素 */\n    fn peek(&amp;self) -&gt; T {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* 返回陣列 */\n    fn to_vector(&amp;self) -&gt; Vec&lt;T&gt; {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![T::default(); cap as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n</code></pre> array_queue.c<pre><code>/* 基於環形陣列實現的佇列 */\ntypedef struct {\n    int *nums;       // 用於儲存佇列元素的陣列\n    int front;       // 佇列首指標，指向佇列首元素\n    int queSize;     // 當前佇列的元素數量\n    int queCapacity; // 佇列容量\n} ArrayQueue;\n\n/* 建構子 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // 初始化陣列\n    queue-&gt;queCapacity = capacity;\n    queue-&gt;nums = (int *)malloc(sizeof(int) * queue-&gt;queCapacity);\n    queue-&gt;front = queue-&gt;queSize = 0;\n    return queue;\n}\n\n/* 析構函式 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue-&gt;nums);\n    free(queue);\n}\n\n/* 獲取佇列的容量 */\nint capacity(ArrayQueue *queue) {\n    return queue-&gt;queCapacity;\n}\n\n/* 獲取佇列的長度 */\nint size(ArrayQueue *queue) {\n    return queue-&gt;queSize;\n}\n\n/* 判斷佇列是否為空 */\nbool empty(ArrayQueue *queue) {\n    return queue-&gt;queSize == 0;\n}\n\n/* 訪問佇列首元素 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue-&gt;nums[queue-&gt;front];\n}\n\n/* 入列 */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"佇列已滿\\r\\n\");\n        return;\n    }\n    // 計算佇列尾指標，指向佇列尾索引 + 1\n    // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    int rear = (queue-&gt;front + queue-&gt;queSize) % queue-&gt;queCapacity;\n    // 將 num 新增至佇列尾\n    queue-&gt;nums[rear] = num;\n    queue-&gt;queSize++;\n}\n\n/* 出列 */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    queue-&gt;front = (queue-&gt;front + 1) % queue-&gt;queCapacity;\n    queue-&gt;queSize--;\n    return num;\n}\n\n/* 返回陣列用於列印 */\nint *toArray(ArrayQueue *queue, int *queSize) {\n    *queSize = queue-&gt;queSize;\n    int *res = (int *)calloc(queue-&gt;queSize, sizeof(int));\n    int j = queue-&gt;front;\n    for (int i = 0; i &lt; queue-&gt;queSize; i++) {\n        res[i] = queue-&gt;nums[j % queue-&gt;queCapacity];\n        j++;\n    }\n    return res;\n}\n</code></pre> array_queue.kt<pre><code>/* 基於環形陣列實現的佇列 */\nclass ArrayQueue(capacity: Int) {\n    private val nums: IntArray = IntArray(capacity) // 用於儲存佇列元素的陣列\n    private var front: Int = 0 // 佇列首指標，指向佇列首元素\n    private var queSize: Int = 0 // 佇列長度\n\n    /* 獲取佇列的容量 */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* 獲取佇列的長度 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* 判斷佇列是否為空 */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* 入列 */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"佇列已滿\")\n            return\n        }\n        // 計算佇列尾指標，指向佇列尾索引 + 1\n        // 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n        val rear = (front + queSize) % capacity()\n        // 將 num 新增至佇列尾\n        nums[rear] = num\n        queSize++\n    }\n\n    /* 出列 */\n    fun pop(): Int {\n        val num = peek()\n        // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* 訪問佇列首元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* 返回陣列 */\n    fun toArray(): IntArray {\n        // 僅轉換有效長度範圍內的串列元素\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i &lt; queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n</code></pre> array_queue.rb<pre><code>### 基於環形陣列實現的佇列 ###\nclass ArrayQueue\n  ### 獲取佇列的長度 ###\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize(size)\n    @nums = Array.new(size, 0) # 用於儲存佇列元素的陣列\n    @front = 0 # 佇列首指標，指向佇列首元素\n    @size = 0 # 佇列長度\n  end\n\n  ### 獲取佇列的容量 ###\n  def capacity\n    @nums.length\n  end\n\n  ### 判斷佇列是否為空 ###\n  def is_empty?\n    size.zero?\n  end\n\n  ### 入列 ###\n  def push(num)\n    raise IndexError, '佇列已滿' if size == capacity\n\n    # 計算佇列尾指標，指向佇列尾索引 + 1\n    # 透過取餘操作實現 rear 越過陣列尾部後回到頭部\n    rear = (@front + size) % capacity\n    # 將 num 新增至佇列尾\n    @nums[rear] = num\n    @size += 1\n  end\n\n  ### 出列 ###\n  def pop\n    num = peek\n    # 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部\n    @front = (@front + 1) % capacity\n    @size -= 1\n    num\n  end\n\n  ### 訪問佇列首元素 ###\n  def peek\n    raise IndexError, '佇列為空' if is_empty?\n\n    @nums[@front]\n  end\n\n  ### 返回串列用於列印 ###\n  def to_array\n    res = Array.new(size, 0)\n    j = @front\n\n    for i in 0...size\n      res[i] = @nums[j % capacity]\n      j += 1\n    end\n\n    res\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>以上實現的佇列仍然具有侷限性：其長度不可變。然而，這個問題不難解決，我們可以將陣列替換為動態陣列，從而引入擴容機制。有興趣的讀者可以嘗試自行實現。</p> <p>兩種實現的對比結論與堆疊一致，在此不再贅述。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/queue/#523","level":2,"title":"5.2.3   佇列典型應用","text":"<ul> <li>淘寶訂單。購物者下單後，訂單將加入佇列中，系統隨後會根據順序處理佇列中的訂單。在雙十一期間，短時間內會產生海量訂單，高併發成為工程師們需要重點攻克的問題。</li> <li>各類待辦事項。任何需要實現“先來後到”功能的場景，例如印表機的任務佇列、餐廳的出餐佇列等，佇列在這些場景中可以有效地維護處理順序。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.2 &nbsp; 佇列"],"tags":[]},{"location":"chapter_stack_and_queue/stack/","level":1,"title":"5.1   堆疊","text":"<p>堆疊（stack）是一種遵循先入後出邏輯的線性資料結構。</p> <p>我們可以將堆疊類比為桌面上的一疊盤子，規定每次只能移動一個盤子，那麼想取出底部的盤子，則需要先將上面的盤子依次移走。我們將盤子替換為各種型別的元素（如整數、字元、物件等），就得到了堆疊這種資料結構。</p> <p>如圖 5-1 所示，我們把堆積疊元素的頂部稱為“堆疊頂”，底部稱為“堆疊底”。將把元素新增到堆疊頂的操作叫作“入堆疊”，刪除堆疊頂元素的操作叫作“出堆疊”。</p> <p></p> <p> 圖 5-1   堆疊的先入後出規則 </p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#511","level":2,"title":"5.1.1   堆疊的常用操作","text":"<p>堆疊的常用操作如表 5-1 所示，具體的方法名需要根據所使用的程式語言來確定。在此，我們以常見的 <code>push()</code>、<code>pop()</code>、<code>peek()</code> 命名為例。</p> <p> 表 5-1   堆疊的操作效率 </p> 方法 描述 時間複雜度 <code>push()</code> 元素入堆疊（新增至堆疊頂） \\(O(1)\\) <code>pop()</code> 堆疊頂元素出堆疊 \\(O(1)\\) <code>peek()</code> 訪問堆疊頂元素 \\(O(1)\\) <p>通常情況下，我們可以直接使用程式語言內建的堆疊類別。然而，某些語言可能沒有專門提供堆疊類別，這時我們可以將該語言的“陣列”或“鏈結串列”當作堆疊來使用，並在程式邏輯上忽略與堆疊無關的操作。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby stack.py<pre><code># 初始化堆疊\n# Python 沒有內建的堆疊類別，可以把 list 當作堆疊來使用\nstack: list[int] = []\n\n# 元素入堆疊\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# 訪問堆疊頂元素\npeek: int = stack[-1]\n\n# 元素出堆疊\npop: int = stack.pop()\n\n# 獲取堆疊的長度\nsize: int = len(stack)\n\n# 判斷是否為空\nis_empty: bool = len(stack) == 0\n</code></pre> stack.cpp<pre><code>/* 初始化堆疊 */\nstack&lt;int&gt; stack;\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nint top = stack.top();\n\n/* 元素出堆疊 */\nstack.pop(); // 無返回值\n\n/* 獲取堆疊的長度 */\nint size = stack.size();\n\n/* 判斷是否為空 */\nbool empty = stack.empty();\n</code></pre> stack.java<pre><code>/* 初始化堆疊 */\nStack&lt;Integer&gt; stack = new Stack&lt;&gt;();\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.peek();\n\n/* 元素出堆疊 */\nint pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nint size = stack.size();\n\n/* 判斷是否為空 */\nboolean isEmpty = stack.isEmpty();\n</code></pre> stack.cs<pre><code>/* 初始化堆疊 */\nStack&lt;int&gt; stack = new();\n\n/* 元素入堆疊 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.Peek();\n\n/* 元素出堆疊 */\nint pop = stack.Pop();\n\n/* 獲取堆疊的長度 */\nint size = stack.Count;\n\n/* 判斷是否為空 */\nbool isEmpty = stack.Count == 0;\n</code></pre> stack_test.go<pre><code>/* 初始化堆疊 */\n// 在 Go 中，推薦將 Slice 當作堆疊來使用\nvar stack []int\n\n/* 元素入堆疊 */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* 訪問堆疊頂元素 */\npeek := stack[len(stack)-1]\n\n/* 元素出堆疊 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* 獲取堆疊的長度 */\nsize := len(stack)\n\n/* 判斷是否為空 */\nisEmpty := len(stack) == 0\n</code></pre> stack.swift<pre><code>/* 初始化堆疊 */\n// Swift 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nvar stack: [Int] = []\n\n/* 元素入堆疊 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* 訪問堆疊頂元素 */\nlet peek = stack.last!\n\n/* 元素出堆疊 */\nlet pop = stack.removeLast()\n\n/* 獲取堆疊的長度 */\nlet size = stack.count\n\n/* 判斷是否為空 */\nlet isEmpty = stack.isEmpty\n</code></pre> stack.js<pre><code>/* 初始化堆疊 */\n// JavaScript 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nconst stack = [];\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nconst peek = stack[stack.length-1];\n\n/* 元素出堆疊 */\nconst pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nconst size = stack.length;\n\n/* 判斷是否為空 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.ts<pre><code>/* 初始化堆疊 */\n// TypeScript 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nconst stack: number[] = [];\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nconst peek = stack[stack.length - 1];\n\n/* 元素出堆疊 */\nconst pop = stack.pop();\n\n/* 獲取堆疊的長度 */\nconst size = stack.length;\n\n/* 判斷是否為空 */\nconst is_empty = stack.length === 0;\n</code></pre> stack.dart<pre><code>/* 初始化堆疊 */\n// Dart 沒有內建的堆疊類別，可以把 List 當作堆疊來使用\nList&lt;int&gt; stack = [];\n\n/* 元素入堆疊 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* 訪問堆疊頂元素 */\nint peek = stack.last;\n\n/* 元素出堆疊 */\nint pop = stack.removeLast();\n\n/* 獲取堆疊的長度 */\nint size = stack.length;\n\n/* 判斷是否為空 */\nbool isEmpty = stack.isEmpty;\n</code></pre> stack.rs<pre><code>/* 初始化堆疊 */\n// 把 Vec 當作堆疊來使用\nlet mut stack: Vec&lt;i32&gt; = Vec::new();\n\n/* 元素入堆疊 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* 訪問堆疊頂元素 */\nlet top = stack.last().unwrap();\n\n/* 元素出堆疊 */\nlet pop = stack.pop().unwrap();\n\n/* 獲取堆疊的長度 */\nlet size = stack.len();\n\n/* 判斷是否為空 */\nlet is_empty = stack.is_empty();\n</code></pre> stack.c<pre><code>// C 未提供內建堆疊\n</code></pre> stack.kt<pre><code>/* 初始化堆疊 */\nval stack = Stack&lt;Int&gt;()\n\n/* 元素入堆疊 */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* 訪問堆疊頂元素 */\nval peek = stack.peek()\n\n/* 元素出堆疊 */\nval pop = stack.pop()\n\n/* 獲取堆疊的長度 */\nval size = stack.size\n\n/* 判斷是否為空 */\nval isEmpty = stack.isEmpty()\n</code></pre> stack.rb<pre><code># 初始化堆疊\n# Ruby 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用\nstack = []\n\n# 元素入堆疊\nstack &lt;&lt; 1\nstack &lt;&lt; 3\nstack &lt;&lt; 2\nstack &lt;&lt; 5\nstack &lt;&lt; 4\n\n# 訪問堆疊頂元素\npeek = stack.last\n\n# 元素出堆疊\npop = stack.pop\n\n# 獲取堆疊的長度\nsize = stack.length\n\n# 判斷是否為空\nis_empty = stack.empty?\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#512","level":2,"title":"5.1.2   堆疊的實現","text":"<p>為了深入瞭解堆疊的執行機制，我們來嘗試自己實現一個堆疊類別。</p> <p>堆疊遵循先入後出的原則，因此我們只能在堆疊頂新增或刪除元素。然而，陣列和鏈結串列都可以在任意位置新增和刪除元素，因此堆疊可以視為一種受限制的陣列或鏈結串列。換句話說，我們可以“遮蔽”陣列或鏈結串列的部分無關操作，使其對外表現的邏輯符合堆疊的特性。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#1","level":3,"title":"1.   基於鏈結串列的實現","text":"<p>使用鏈結串列實現堆疊時，我們可以將鏈結串列的頭節點視為堆疊頂，尾節點視為堆疊底。</p> <p>如圖 5-2 所示，對於入堆疊操作，我們只需將元素插入鏈結串列頭部，這種節點插入方法被稱為“頭插法”。而對於出堆疊操作，只需將頭節點從鏈結串列中刪除即可。</p> LinkedListStackpush()pop() <p></p> <p></p> <p></p> <p> 圖 5-2   基於鏈結串列實現堆疊的入堆疊出堆疊操作 </p> <p>以下是基於鏈結串列實現堆疊的示例程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby linkedlist_stack.py<pre><code>class LinkedListStack:\n    \"\"\"基於鏈結串列實現的堆疊\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -&gt; int:\n        \"\"\"獲取堆疊的長度\"\"\"\n        return self._size\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷堆疊是否為空\"\"\"\n        return self._size == 0\n\n    def push(self, val: int):\n        \"\"\"入堆疊\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -&gt; int:\n        \"\"\"出堆疊\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問堆疊頂元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._peek.val\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"轉化為串列用於列印\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n</code></pre> linkedlist_stack.cpp<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // 將頭節點作為堆疊頂\n    int stkSize;        // 堆疊的長度\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // 走訪鏈結串列刪除節點，釋放記憶體\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* 獲取堆疊的長度 */\n    int size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node-&gt;next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop-&gt;next;\n        // 釋放記憶體\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"堆疊為空\");\n        return stackTop-&gt;val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    vector&lt;int&gt; toVector() {\n        ListNode *node = stackTop;\n        vector&lt;int&gt; res(size());\n        for (int i = res.size() - 1; i &gt;= 0; i--) {\n            res[i] = node-&gt;val;\n            node = node-&gt;next;\n        }\n        return res;\n    }\n};\n</code></pre> linkedlist_stack.java<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private ListNode stackPeek; // 將頭節點作為堆疊頂\n    private int stkSize = 0; // 堆疊的長度\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.cs<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // 將頭節點作為堆疊頂\n    int stkSize = 0;   // 堆疊的長度\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* 出堆疊 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.go<pre><code>/* 基於鏈結串列實現的堆疊 */\ntype linkedListStack struct {\n    // 使用內建包 list 來實現堆疊\n    data *list.List\n}\n\n/* 初始化堆疊 */\nfunc newLinkedListStack() *linkedListStack {\n    return &amp;linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* 入堆疊 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* 出堆疊 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* 訪問堆疊頂元素 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* 獲取堆疊的長度 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* 判斷堆疊是否為空 */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* 獲取 List 用於列印 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n</code></pre> linkedlist_stack.swift<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private var _peek: ListNode? // 將頭節點作為堆疊頂\n    private var _size: Int // 堆疊的長度\n\n    init() {\n        _size = 0\n    }\n\n    /* 獲取堆疊的長度 */\n    func size() -&gt; Int {\n        _size\n    }\n\n    /* 判斷堆疊是否為空 */\n    func isEmpty() -&gt; Bool {\n        size() == 0\n    }\n\n    /* 入堆疊 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* 出堆疊 */\n    @discardableResult\n    func pop() -&gt; Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* 訪問堆疊頂元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return _peek!.val\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.js<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    #stackPeek; // 將頭節點作為堆疊頂\n    #stkSize = 0; // 堆疊的長度\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* 入堆疊 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* 出堆疊 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('堆疊為空');\n        return this.#stackPeek.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.ts<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // 將頭節點作為堆疊頂\n    private stkSize: number = 0; // 堆疊的長度\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* 獲取堆疊的長度 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* 入堆疊 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* 出堆疊 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('堆疊為空');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('堆疊為空');\n        return this.stackPeek.val;\n    }\n\n    /* 將鏈結串列轉化為 Array 並返回 */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array&lt;number&gt;(this.size);\n        for (let i = res.length - 1; i &gt;= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n</code></pre> linkedlist_stack.dart<pre><code>/* 基於鏈結串列類別實現的堆疊 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // 將頭節點作為堆疊頂\n  int _stkSize = 0; // 堆疊的長度\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* 獲取堆疊的長度 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* 判斷堆疊是否為空 */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* 入堆疊 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* 出堆疊 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* 訪問堆疊頂元素 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* 將鏈結串列轉化為 List 並返回 */\n  List&lt;int&gt; toList() {\n    ListNode? node = _stackPeek;\n    List&lt;int&gt; list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n</code></pre> linkedlist_stack.rs<pre><code>/* 基於鏈結串列實現的堆疊 */\n#[allow(dead_code)]\npub struct LinkedListStack&lt;T&gt; {\n    stack_peek: Option&lt;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;, // 將頭節點作為堆疊頂\n    stk_size: usize,                              // 堆疊的長度\n}\n\nimpl&lt;T: Copy&gt; LinkedListStack&lt;T&gt; {\n    pub fn new() -&gt; Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* 獲取堆疊的長度 */\n    pub fn size(&amp;self) -&gt; usize {\n        return self.stk_size;\n    }\n\n    /* 判斷堆疊是否為空 */\n    pub fn is_empty(&amp;self) -&gt; bool {\n        return self.size() == 0;\n    }\n\n    /* 入堆疊 */\n    pub fn push(&amp;mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* 出堆疊 */\n    pub fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack_peek.take().map(|old_head| {\n            self.stack_peek = old_head.borrow_mut().next.take();\n            self.stk_size -= 1;\n\n            old_head.borrow().val\n        })\n    }\n\n    /* 訪問堆疊頂元素 */\n    pub fn peek(&amp;self) -&gt; Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt; {\n        self.stack_peek.as_ref()\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    pub fn to_array(&amp;self) -&gt; Vec&lt;T&gt; {\n        fn _to_array&lt;T: Sized + Copy&gt;(head: Option&lt;&amp;Rc&lt;RefCell&lt;ListNode&lt;T&gt;&gt;&gt;&gt;) -&gt; Vec&lt;T&gt; {\n            if let Some(node) = head {\n                let mut nums = _to_array(node.borrow().next.as_ref());\n                nums.push(node.borrow().val);\n                return nums;\n            }\n            return Vec::new();\n        }\n\n        _to_array(self.peek())\n    }\n}\n</code></pre> linkedlist_stack.c<pre><code>/* 基於鏈結串列實現的堆疊 */\ntypedef struct {\n    ListNode *top; // 將頭節點作為堆疊頂\n    int size;      // 堆疊的長度\n} LinkedListStack;\n\n/* 建構子 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s-&gt;top = NULL;\n    s-&gt;size = 0;\n    return s;\n}\n\n/* 析構函式 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s-&gt;top) {\n        ListNode *n = s-&gt;top-&gt;next;\n        free(s-&gt;top);\n        s-&gt;top = n;\n    }\n    free(s);\n}\n\n/* 獲取堆疊的長度 */\nint size(LinkedListStack *s) {\n    return s-&gt;size;\n}\n\n/* 判斷堆疊是否為空 */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* 入堆疊 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node-&gt;next = s-&gt;top; // 更新新加節點指標域\n    node-&gt;val = num;     // 更新新加節點資料域\n    s-&gt;top = node;       // 更新堆疊頂\n    s-&gt;size++;           // 更新堆疊大小\n}\n\n/* 訪問堆疊頂元素 */\nint peek(LinkedListStack *s) {\n    if (s-&gt;size == 0) {\n        printf(\"堆疊為空\\n\");\n        return INT_MAX;\n    }\n    return s-&gt;top-&gt;val;\n}\n\n/* 出堆疊 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s-&gt;top;\n    s-&gt;top = s-&gt;top-&gt;next;\n    // 釋放記憶體\n    free(tmp);\n    s-&gt;size--;\n    return val;\n}\n</code></pre> linkedlist_stack.kt<pre><code>/* 基於鏈結串列實現的堆疊 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // 將頭節點作為堆疊頂\n    private var stkSize: Int = 0 // 堆疊的長度\n) {\n\n    /* 獲取堆疊的長度 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* 判斷堆疊是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入堆疊 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* 出堆疊 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--\n        return num\n    }\n\n    /* 訪問堆疊頂元素 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?._val\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?._val!!\n            node = node.next\n        }\n        return res\n    }\n}\n</code></pre> linkedlist_stack.rb<pre><code>### 基於鏈結串列實現的堆疊 ###\nclass LinkedListStack\n  attr_reader :size\n\n  ### 建構子 ###\n  def initialize\n    @size = 0\n  end\n\n  ### 判斷堆疊是否為空 ###\n  def is_empty?\n    @peek.nil?\n  end\n\n  ### 入堆疊 ###\n  def push(val)\n    node = ListNode.new(val)\n    node.next = @peek\n    @peek = node\n    @size += 1\n  end\n\n  ### 出堆疊 ###\n  def pop\n    num = peek\n    @peek = @peek.next\n    @size -= 1\n    num\n  end\n\n  ### 訪問堆疊頂元素 ###\n  def peek\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @peek.val\n  end\n\n  ### 將鏈結串列轉化為 Array 並反回 ###\n  def to_array\n    arr = []\n    node = @peek\n    while node\n      arr &lt;&lt; node.val\n      node = node.next\n    end\n    arr.reverse\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#2","level":3,"title":"2.   基於陣列的實現","text":"<p>使用陣列實現堆疊時，我們可以將陣列的尾部作為堆疊頂。如圖 5-3 所示，入堆疊與出堆疊操作分別對應在陣列尾部新增元素與刪除元素，時間複雜度都為 \\(O(1)\\) 。</p> ArrayStackpush()pop() <p></p> <p></p> <p></p> <p> 圖 5-3   基於陣列實現堆疊的入堆疊出堆疊操作 </p> <p>由於入堆疊的元素可能會源源不斷地增加，因此我們可以使用動態陣列，這樣就無須自行處理陣列擴容問題。以下為示例程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_stack.py<pre><code>class ArrayStack:\n    \"\"\"基於陣列實現的堆疊\"\"\"\n\n    def __init__(self):\n        \"\"\"建構子\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -&gt; int:\n        \"\"\"獲取堆疊的長度\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"判斷堆疊是否為空\"\"\"\n        return self.size() == 0\n\n    def push(self, item: int):\n        \"\"\"入堆疊\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -&gt; int:\n        \"\"\"出堆疊\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._stack.pop()\n\n    def peek(self) -&gt; int:\n        \"\"\"訪問堆疊頂元素\"\"\"\n        if self.is_empty():\n            raise IndexError(\"堆疊為空\")\n        return self._stack[-1]\n\n    def to_list(self) -&gt; list[int]:\n        \"\"\"返回串列用於列印\"\"\"\n        return self._stack\n</code></pre> array_stack.cpp<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n  private:\n    vector&lt;int&gt; stack;\n\n  public:\n    /* 獲取堆疊的長度 */\n    int size() {\n        return stack.size();\n    }\n\n    /* 判斷堆疊是否為空 */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* 入堆疊 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* 出堆疊 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* 訪問堆疊頂元素 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"堆疊為空\");\n        return stack.back();\n    }\n\n    /* 返回 Vector */\n    vector&lt;int&gt; toVector() {\n        return stack;\n    }\n};\n</code></pre> array_stack.java<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private ArrayList&lt;Integer&gt; stack;\n\n    public ArrayStack() {\n        // 初始化串列（動態陣列）\n        stack = new ArrayList&lt;&gt;();\n    }\n\n    /* 獲取堆疊的長度 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* 判斷堆疊是否為空 */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* 出堆疊 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n</code></pre> array_stack.cs<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    List&lt;int&gt; stack;\n    public ArrayStack() {\n        // 初始化串列（動態陣列）\n        stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* 判斷堆疊是否為空 */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* 入堆疊 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* 出堆疊 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* 訪問堆疊頂元素 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n</code></pre> array_stack.go<pre><code>/* 基於陣列實現的堆疊 */\ntype arrayStack struct {\n    data []int // 資料\n}\n\n/* 初始化堆疊 */\nfunc newArrayStack() *arrayStack {\n    return &amp;arrayStack{\n        // 設定堆疊的長度為 0，容量為 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* 堆疊的長度 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* 堆疊是否為空 */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* 入堆疊 */\nfunc (s *arrayStack) push(v int) {\n    // 切片會自動擴容\n    s.data = append(s.data, v)\n}\n\n/* 出堆疊 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* 獲取堆疊頂元素 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* 獲取 Slice 用於列印 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n</code></pre> array_stack.swift<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // 初始化串列（動態陣列）\n        stack = []\n    }\n\n    /* 獲取堆疊的長度 */\n    func size() -&gt; Int {\n        stack.count\n    }\n\n    /* 判斷堆疊是否為空 */\n    func isEmpty() -&gt; Bool {\n        stack.isEmpty\n    }\n\n    /* 入堆疊 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* 出堆疊 */\n    @discardableResult\n    func pop() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return stack.removeLast()\n    }\n\n    /* 訪問堆疊頂元素 */\n    func peek() -&gt; Int {\n        if isEmpty() {\n            fatalError(\"堆疊為空\")\n        }\n        return stack.last!\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    func toArray() -&gt; [Int] {\n        stack\n    }\n}\n</code></pre> array_stack.js<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* 入堆疊 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* 出堆疊 */\n    pop() {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.#stack.pop();\n    }\n\n    /* 訪問堆疊頂元素 */\n    top() {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n</code></pre> array_stack.ts<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* 獲取堆疊的長度 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* 判斷堆疊是否為空 */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* 入堆疊 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* 出堆疊 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.stack.pop();\n    }\n\n    /* 訪問堆疊頂元素 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('堆疊為空');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* 返回 Array */\n    toArray() {\n        return this.stack;\n    }\n}\n</code></pre> array_stack.dart<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n  late List&lt;int&gt; _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* 獲取堆疊的長度 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* 判斷堆疊是否為空 */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* 入堆疊 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* 出堆疊 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* 訪問堆疊頂元素 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"堆疊為空\");\n    }\n    return _stack.last;\n  }\n\n  /* 將堆疊轉化為 Array 並返回 */\n  List&lt;int&gt; toArray() =&gt; _stack;\n}\n</code></pre> array_stack.rs<pre><code>/* 基於陣列實現的堆疊 */\nstruct ArrayStack&lt;T&gt; {\n    stack: Vec&lt;T&gt;,\n}\n\nimpl&lt;T&gt; ArrayStack&lt;T&gt; {\n    /* 初始化堆疊 */\n    fn new() -&gt; ArrayStack&lt;T&gt; {\n        ArrayStack::&lt;T&gt; {\n            stack: Vec::&lt;T&gt;::new(),\n        }\n    }\n\n    /* 獲取堆疊的長度 */\n    fn size(&amp;self) -&gt; usize {\n        self.stack.len()\n    }\n\n    /* 判斷堆疊是否為空 */\n    fn is_empty(&amp;self) -&gt; bool {\n        self.size() == 0\n    }\n\n    /* 入堆疊 */\n    fn push(&amp;mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* 出堆疊 */\n    fn pop(&amp;mut self) -&gt; Option&lt;T&gt; {\n        self.stack.pop()\n    }\n\n    /* 訪問堆疊頂元素 */\n    fn peek(&amp;self) -&gt; Option&lt;&amp;T&gt; {\n        if self.is_empty() {\n            panic!(\"堆疊為空\")\n        };\n        self.stack.last()\n    }\n\n    /* 返回 &amp;Vec */\n    fn to_array(&amp;self) -&gt; &amp;Vec&lt;T&gt; {\n        &amp;self.stack\n    }\n}\n</code></pre> array_stack.c<pre><code>/* 基於陣列實現的堆疊 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* 建構子 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // 初始化一個大容量，避免擴容\n    stack-&gt;data = malloc(sizeof(int) * MAX_SIZE);\n    stack-&gt;size = 0;\n    return stack;\n}\n\n/* 析構函式 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack-&gt;data);\n    free(stack);\n}\n\n/* 獲取堆疊的長度 */\nint size(ArrayStack *stack) {\n    return stack-&gt;size;\n}\n\n/* 判斷堆疊是否為空 */\nbool isEmpty(ArrayStack *stack) {\n    return stack-&gt;size == 0;\n}\n\n/* 入堆疊 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack-&gt;size == MAX_SIZE) {\n        printf(\"堆疊已滿\\n\");\n        return;\n    }\n    stack-&gt;data[stack-&gt;size] = num;\n    stack-&gt;size++;\n}\n\n/* 訪問堆疊頂元素 */\nint peek(ArrayStack *stack) {\n    if (stack-&gt;size == 0) {\n        printf(\"堆疊為空\\n\");\n        return INT_MAX;\n    }\n    return stack-&gt;data[stack-&gt;size - 1];\n}\n\n/* 出堆疊 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack-&gt;size--;\n    return val;\n}\n</code></pre> array_stack.kt<pre><code>/* 基於陣列實現的堆疊 */\nclass ArrayStack {\n    // 初始化串列（動態陣列）\n    private val stack = mutableListOf&lt;Int&gt;()\n\n    /* 獲取堆疊的長度 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* 判斷堆疊是否為空 */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* 入堆疊 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* 出堆疊 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* 訪問堆疊頂元素 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* 將 List 轉化為 Array 並返回 */\n    fun toArray(): Array&lt;Any&gt; {\n        return stack.toTypedArray()\n    }\n}\n</code></pre> array_stack.rb<pre><code>### 基於陣列實現的堆疊 ###\nclass ArrayStack\n  ### 建構子 ###\n  def initialize\n    @stack = []\n  end\n\n  ### 獲取堆疊的長度 ###\n  def size\n    @stack.length\n  end\n\n  ### 判斷堆疊是否為空 ###\n  def is_empty?\n    @stack.empty?\n  end\n\n  ### 入堆疊 ###\n  def push(item)\n    @stack &lt;&lt; item\n  end\n\n  ### 出堆疊 ###\n  def pop\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @stack.pop\n  end\n\n  ### 訪問堆疊頂元素 ###\n  def peek\n    raise IndexError, '堆疊為空' if is_empty?\n\n    @stack.last\n  end\n\n  ### 返回串列用於列印 ###\n  def to_array\n    @stack\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#513","level":2,"title":"5.1.3   兩種實現對比","text":"<p>支持操作</p> <p>兩種實現都支持堆疊定義中的各項操作。陣列實現額外支持隨機訪問，但這已超出了堆疊的定義範疇，因此一般不會用到。</p> <p>時間效率</p> <p>在基於陣列的實現中，入堆疊和出堆疊操作都在預先分配好的連續記憶體中進行，具有很好的快取本地性，因此效率較高。然而，如果入堆疊時超出陣列容量，會觸發擴容機制，導致該次入堆疊操作的時間複雜度變為 \\(O(n)\\) 。</p> <p>在基於鏈結串列的實現中，鏈結串列的擴容非常靈活，不存在上述陣列擴容時效率降低的問題。但是，入堆疊操作需要初始化節點物件並修改指標，因此效率相對較低。不過，如果入堆疊元素本身就是節點物件，那麼可以省去初始化步驟，從而提高效率。</p> <p>綜上所述，當入堆疊與出堆疊操作的元素是基本資料型別時，例如 <code>int</code> 或 <code>double</code> ，我們可以得出以下結論。</p> <ul> <li>基於陣列實現的堆疊在觸發擴容時效率會降低，但由於擴容是低頻操作，因此平均效率更高。</li> <li>基於鏈結串列實現的堆疊可以提供更加穩定的效率表現。</li> </ul> <p>空間效率</p> <p>在初始化串列時，系統會為串列分配“初始容量”，該容量可能超出實際需求；並且，擴容機制通常是按照特定倍率（例如 2 倍）進行擴容的，擴容後的容量也可能超出實際需求。因此，基於陣列實現的堆疊可能造成一定的空間浪費。</p> <p>然而，由於鏈結串列節點需要額外儲存指標，因此鏈結串列節點佔用的空間相對較大。</p> <p>綜上，我們不能簡單地確定哪種實現更加節省記憶體，需要針對具體情況進行分析。</p>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/stack/#514","level":2,"title":"5.1.4   堆疊的典型應用","text":"<ul> <li>瀏覽器中的後退與前進、軟體中的撤銷與反撤銷。每當我們開啟新的網頁，瀏覽器就會對上一個網頁執行入堆疊，這樣我們就可以通過後退操作回到上一個網頁。後退操作實際上是在執行出堆疊。如果要同時支持後退和前進，那麼需要兩個堆疊來配合實現。</li> <li>程式記憶體管理。每次呼叫函式時，系統都會在堆疊頂新增一個堆疊幀，用於記錄函式的上下文資訊。在遞迴函式中，向下遞推階段會不斷執行入堆疊操作，而向上回溯階段則會不斷執行出堆疊操作。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.1 &nbsp; 堆疊"],"tags":[]},{"location":"chapter_stack_and_queue/summary/","level":1,"title":"5.4   小結","text":"","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>堆疊是一種遵循先入後出原則的資料結構，可透過陣列或鏈結串列來實現。</li> <li>在時間效率方面，堆疊的陣列實現具有較高的平均效率，但在擴容過程中，單次入堆疊操作的時間複雜度會劣化至 \\(O(n)\\) 。相比之下，堆疊的鏈結串列實現具有更為穩定的效率表現。</li> <li>在空間效率方面，堆疊的陣列實現可能導致一定程度的空間浪費。但需要注意的是，鏈結串列節點所佔用的記憶體空間比陣列元素更大。</li> <li>佇列是一種遵循先入先出原則的資料結構，同樣可以透過陣列或鏈結串列來實現。在時間效率和空間效率的對比上，佇列的結論與前述堆疊的結論相似。</li> <li>雙向佇列是一種具有更高自由度的佇列，它允許在兩端進行元素的新增和刪除操作。</li> </ul>","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_stack_and_queue/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：瀏覽器的前進後退是否是雙向鏈結串列實現？</p> <p>瀏覽器的前進後退功能本質上是“堆疊”的體現。當用戶訪問一個新頁面時，該頁面會被新增到堆疊頂；當用戶點選後退按鈕時，該頁面會從堆疊頂彈出。使用雙向佇列可以方便地實現一些額外操作，這個在“雙向佇列”章節有提到。</p> <p>Q：在出堆疊後，是否需要釋放出堆疊節點的記憶體？</p> <p>如果後續仍需要使用彈出節點，則不需要釋放記憶體。若之後不需要用到，<code>Java</code> 和 <code>Python</code> 等語言擁有自動垃圾回收機制，因此不需要手動釋放記憶體；在 <code>C</code> 和 <code>C++</code> 中需要手動釋放記憶體。</p> <p>Q：雙向佇列像是兩個堆疊拼接在了一起，它的用途是什麼？</p> <p>雙向佇列就像是堆疊和佇列的組合或兩個堆疊拼在了一起。它表現的是堆疊 + 佇列的邏輯，因此可以實現堆疊與佇列的所有應用，並且更加靈活。</p> <p>Q：撤銷（undo）和反撤銷（redo）具體是如何實現的？</p> <p>使用兩個堆疊，堆疊 <code>A</code> 用於撤銷，堆疊 <code>B</code> 用於反撤銷。</p> <ol> <li>每當使用者執行一個操作，將這個操作壓入堆疊 <code>A</code> ，並清空堆疊 <code>B</code> 。</li> <li>當用戶執行“撤銷”時，從堆疊 <code>A</code> 中彈出最近的操作，並將其壓入堆疊 <code>B</code> 。</li> <li>當用戶執行“反撤銷”時，從堆疊 <code>B</code> 中彈出最近的操作，並將其壓入堆疊 <code>A</code> 。</li> </ol>","path":["第 5 章 &nbsp; 堆疊與佇列","5.4 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/","level":1,"title":"第 7 章   樹","text":"<p>Abstract</p> <p>參天大樹充滿生命力，根深葉茂，分枝扶疏。</p> <p>它為我們展現了資料分治的生動形態。</p>","path":["第 7 章 &nbsp; 樹"],"tags":[]},{"location":"chapter_tree/#_1","level":2,"title":"本章內容","text":"<ul> <li>7.1   二元樹</li> <li>7.2   二元樹走訪</li> <li>7.3   二元樹陣列表示</li> <li>7.4   二元搜尋樹</li> <li>7.5   AVL *</li> <li>7.6   小結</li> </ul>","path":["第 7 章 &nbsp; 樹"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/","level":1,"title":"7.3   二元樹陣列表示","text":"<p>在鏈結串列表示下，二元樹的儲存單元為節點 <code>TreeNode</code> ，節點之間透過指標相連線。上一節介紹了鏈結串列表示下的二元樹的各項基本操作。</p> <p>那麼，我們能否用陣列來表示二元樹呢？答案是肯定的。</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#731","level":2,"title":"7.3.1   表示完美二元樹","text":"<p>先分析一個簡單案例。給定一棵完美二元樹，我們將所有節點按照層序走訪的順序儲存在一個陣列中，則每個節點都對應唯一的陣列索引。</p> <p>根據層序走訪的特性，我們可以推導出父節點索引與子節點索引之間的“對映公式”：若某節點的索引為 \\(i\\) ，則該節點的左子節點索引為 \\(2i + 1\\) ，右子節點索引為 \\(2i + 2\\) 。圖 7-12 展示了各個節點索引之間的對映關係。</p> <p></p> <p> 圖 7-12   完美二元樹的陣列表示 </p> <p>對映公式的角色相當於鏈結串列中的節點引用（指標）。給定陣列中的任意一個節點，我們都可以透過對映公式來訪問它的左（右）子節點。</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#732","level":2,"title":"7.3.2   表示任意二元樹","text":"<p>完美二元樹是一個特例，在二元樹的中間層通常存在許多 <code>None</code> 。由於層序走訪序列並不包含這些 <code>None</code> ，因此我們無法僅憑該序列來推測 <code>None</code> 的數量和分佈位置。這意味著存在多種二元樹結構都符合該層序走訪序列。</p> <p>如圖 7-13 所示，給定一棵非完美二元樹，上述陣列表示方法已經失效。</p> <p></p> <p> 圖 7-13   層序走訪序列對應多種二元樹可能性 </p> <p>為了解決此問題，我們可以考慮在層序走訪序列中顯式地寫出所有 <code>None</code> 。如圖 7-14 所示，這樣處理後，層序走訪序列就可以唯一表示二元樹了。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code># 二元樹的陣列表示\n# 使用 None 來表示空位\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 最大值 INT_MAX 標記空位\nvector&lt;int&gt; tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 的包裝類別 Integer ，就可以使用 null 來標記空位\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int? 可空型別 ，就可以使用 null 來標記空位\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 any 型別的切片, 就可以使用 nil 來標記空位\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 Int? 可空型別 ，就可以使用 nil 來標記空位\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int? 可空型別 ，就可以使用 null 來標記空位\nList&lt;int?&gt; tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 None 來標記空位\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 int 最大值標記空位，因此要求節點值不能為 INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n</code></pre> <pre><code>/* 二元樹的陣列表示 */\n// 使用 null 來表示空位\nval tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n</code></pre> <pre><code>### 二元樹的陣列表示 ###\n# 使用 nil 來表示空位\ntree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n</code></pre> <p></p> <p> 圖 7-14   任意型別二元樹的陣列表示 </p> <p>值得說明的是，完全二元樹非常適合使用陣列來表示。回顧完全二元樹的定義，<code>None</code> 只出現在最底層且靠右的位置，因此所有 <code>None</code> 一定出現在層序走訪序列的末尾。</p> <p>這意味著使用陣列表示完全二元樹時，可以省略儲存所有 <code>None</code> ，非常方便。圖 7-15 給出了一個例子。</p> <p></p> <p> 圖 7-15   完全二元樹的陣列表示 </p> <p>以下程式碼實現了一棵基於陣列表示的二元樹，包括以下幾種操作。</p> <ul> <li>給定某節點，獲取它的值、左（右）子節點、父節點。</li> <li>獲取前序走訪、中序走訪、後序走訪、層序走訪序列。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby array_binary_tree.py<pre><code>class ArrayBinaryTree:\n    \"\"\"陣列表示下的二元樹類別\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"建構子\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"串列容量\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的值\"\"\"\n        # 若索引越界，則返回 None ，代表空位\n        if i &lt; 0 or i &gt;= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的左子節點的索引\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的右子節點的索引\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -&gt; int | None:\n        \"\"\"獲取索引為 i 節點的父節點的索引\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -&gt; list[int]:\n        \"\"\"層序走訪\"\"\"\n        self.res = []\n        # 直接走訪陣列\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"深度優先走訪\"\"\"\n        if self.val(i) is None:\n            return\n        # 前序走訪\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # 中序走訪\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # 後序走訪\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -&gt; list[int]:\n        \"\"\"前序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -&gt; list[int]:\n        \"\"\"中序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -&gt; list[int]:\n        \"\"\"後序走訪\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n</code></pre> array_binary_tree.cpp<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n  public:\n    /* 建構子 */\n    ArrayBinaryTree(vector&lt;int&gt; arr) {\n        tree = arr;\n    }\n\n    /* 串列容量 */\n    int size() {\n        return tree.size();\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    int val(int i) {\n        // 若索引越界，則返回 INT_MAX ，代表空位\n        if (i &lt; 0 || i &gt;= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    vector&lt;int&gt; levelOrder() {\n        vector&lt;int&gt; res;\n        // 直接走訪陣列\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* 前序走訪 */\n    vector&lt;int&gt; preOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    vector&lt;int&gt; inOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    vector&lt;int&gt; postOrder() {\n        vector&lt;int&gt; res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector&lt;int&gt; tree;\n\n    /* 深度優先走訪 */\n    void dfs(int i, string order, vector&lt;int&gt; &amp;res) {\n        // 若為空位，則返回\n        if (val(i) == INT_MAX)\n            return;\n        // 前序走訪\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // 中序走訪\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // 後序走訪\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n</code></pre> array_binary_tree.java<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    private List&lt;Integer&gt; tree;\n\n    /* 建構子 */\n    public ArrayBinaryTree(List&lt;Integer&gt; arr) {\n        tree = new ArrayList&lt;&gt;(arr);\n    }\n\n    /* 串列容量 */\n    public int size() {\n        return tree.size();\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    public Integer val(int i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    public List&lt;Integer&gt; levelOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        // 直接走訪陣列\n        for (int i = 0; i &lt; size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    private void dfs(Integer i, String order, List&lt;Integer&gt; res) {\n        // 若為空位，則返回\n        if (val(i) == null)\n            return;\n        // 前序走訪\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // 中序走訪\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // 後序走訪\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* 前序走訪 */\n    public List&lt;Integer&gt; preOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    public List&lt;Integer&gt; inOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    public List&lt;Integer&gt; postOrder() {\n        List&lt;Integer&gt; res = new ArrayList&lt;&gt;();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.cs<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree(List&lt;int?&gt; arr) {\n    List&lt;int?&gt; tree = new(arr);\n\n    /* 串列容量 */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    public int? Val(int i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* 層序走訪 */\n    public List&lt;int&gt; LevelOrder() {\n        List&lt;int&gt; res = [];\n        // 直接走訪陣列\n        for (int i = 0; i &lt; Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    void DFS(int i, string order, List&lt;int&gt; res) {\n        // 若為空位，則返回\n        if (!Val(i).HasValue)\n            return;\n        // 前序走訪\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // 中序走訪\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // 後序走訪\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* 前序走訪 */\n    public List&lt;int&gt; PreOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    public List&lt;int&gt; InOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    public List&lt;int&gt; PostOrder() {\n        List&lt;int&gt; res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.go<pre><code>/* 陣列表示下的二元樹類別 */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* 建構子 */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &amp;arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* 串列容量 */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* 獲取索引為 i 節點的值 */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // 若索引越界，則返回 null ，代表空位\n    if i &lt; 0 || i &gt;= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* 獲取索引為 i 節點的左子節點的索引 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* 獲取索引為 i 節點的右子節點的索引 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* 獲取索引為 i 節點的父節點的索引 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* 層序走訪 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // 直接走訪陣列\n    for i := 0; i &lt; abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* 深度優先走訪 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // 若為空位，則返回\n    if abt.val(i) == nil {\n        return\n    }\n    // 前序走訪\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // 中序走訪\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // 後序走訪\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* 前序走訪 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &amp;res)\n    return res\n}\n\n/* 中序走訪 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &amp;res)\n    return res\n}\n\n/* 後序走訪 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &amp;res)\n    return res\n}\n</code></pre> array_binary_tree.swift<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* 建構子 */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* 串列容量 */\n    func size() -&gt; Int {\n        tree.count\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    func val(i: Int) -&gt; Int? {\n        // 若索引越界，則返回 null ，代表空位\n        if i &lt; 0 || i &gt;= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    func left(i: Int) -&gt; Int {\n        2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    func right(i: Int) -&gt; Int {\n        2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    func parent(i: Int) -&gt; Int {\n        (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    func levelOrder() -&gt; [Int] {\n        var res: [Int] = []\n        // 直接走訪陣列\n        for i in 0 ..&lt; size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* 深度優先走訪 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // 若為空位，則返回\n        guard let val = val(i: i) else {\n            return\n        }\n        // 前序走訪\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &amp;res)\n        // 中序走訪\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &amp;res)\n        // 後序走訪\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* 前序走訪 */\n    func preOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &amp;res)\n        return res\n    }\n\n    /* 中序走訪 */\n    func inOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &amp;res)\n        return res\n    }\n\n    /* 後序走訪 */\n    func postOrder() -&gt; [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &amp;res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.js<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* 建構子 */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* 串列容量 */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    val(i) {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // 向下整除\n    }\n\n    /* 層序走訪 */\n    levelOrder() {\n        let res = [];\n        // 直接走訪陣列\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    #dfs(i, order, res) {\n        // 若為空位，則返回\n        if (this.val(i) === null) return;\n        // 前序走訪\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中序走訪\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後序走訪\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 前序走訪 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.ts<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* 建構子 */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* 串列容量 */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    val(i: number): number | null {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // 向下整除\n    }\n\n    /* 層序走訪 */\n    levelOrder(): number[] {\n        let res = [];\n        // 直接走訪陣列\n        for (let i = 0; i &lt; this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* 深度優先走訪 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // 若為空位，則返回\n        if (this.val(i) === null) return;\n        // 前序走訪\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // 中序走訪\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // 後序走訪\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* 前序走訪 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* 中序走訪 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* 後序走訪 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n</code></pre> array_binary_tree.dart<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree {\n  late List&lt;int?&gt; _tree;\n\n  /* 建構子 */\n  ArrayBinaryTree(this._tree);\n\n  /* 串列容量 */\n  int size() {\n    return _tree.length;\n  }\n\n  /* 獲取索引為 i 節點的值 */\n  int? val(int i) {\n    // 若索引越界，則返回 null ，代表空位\n    if (i &lt; 0 || i &gt;= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* 獲取索引為 i 節點的左子節點的索引 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* 獲取索引為 i 節點的右子節點的索引 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* 獲取索引為 i 節點的父節點的索引 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* 層序走訪 */\n  List&lt;int&gt; levelOrder() {\n    List&lt;int&gt; res = [];\n    for (int i = 0; i &lt; size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* 深度優先走訪 */\n  void dfs(int i, String order, List&lt;int?&gt; res) {\n    // 若為空位，則返回\n    if (val(i) == null) {\n      return;\n    }\n    // 前序走訪\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // 中序走訪\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // 後序走訪\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* 前序走訪 */\n  List&lt;int?&gt; preOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* 中序走訪 */\n  List&lt;int?&gt; inOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* 後序走訪 */\n  List&lt;int?&gt; postOrder() {\n    List&lt;int?&gt; res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n</code></pre> array_binary_tree.rs<pre><code>/* 陣列表示下的二元樹類別 */\nstruct ArrayBinaryTree {\n    tree: Vec&lt;Option&lt;i32&gt;&gt;,\n}\n\nimpl ArrayBinaryTree {\n    /* 建構子 */\n    fn new(arr: Vec&lt;Option&lt;i32&gt;&gt;) -&gt; Self {\n        Self { tree: arr }\n    }\n\n    /* 串列容量 */\n    fn size(&amp;self) -&gt; i32 {\n        self.tree.len() as i32\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    fn val(&amp;self, i: i32) -&gt; Option&lt;i32&gt; {\n        // 若索引越界，則返回 None ，代表空位\n        if i &lt; 0 || i &gt;= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    fn left(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    fn right(&amp;self, i: i32) -&gt; i32 {\n        2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    fn parent(&amp;self, i: i32) -&gt; i32 {\n        (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    fn level_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        self.tree.iter().filter_map(|&amp;x| x).collect()\n    }\n\n    /* 深度優先走訪 */\n    fn dfs(&amp;self, i: i32, order: &amp;'static str, res: &amp;mut Vec&lt;i32&gt;) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // 前序走訪\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // 中序走訪\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // 後序走訪\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* 前序走訪 */\n    fn pre_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &amp;mut res);\n        res\n    }\n\n    /* 中序走訪 */\n    fn in_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &amp;mut res);\n        res\n    }\n\n    /* 後序走訪 */\n    fn post_order(&amp;self) -&gt; Vec&lt;i32&gt; {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &amp;mut res);\n        res\n    }\n}\n</code></pre> array_binary_tree.c<pre><code>/* 陣列表示下的二元樹結構體 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* 建構子 */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt-&gt;tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt-&gt;tree, arr, sizeof(int) * arrSize);\n    abt-&gt;size = arrSize;\n    return abt;\n}\n\n/* 析構函式 */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt-&gt;tree);\n    free(abt);\n}\n\n/* 串列容量 */\nint size(ArrayBinaryTree *abt) {\n    return abt-&gt;size;\n}\n\n/* 獲取索引為 i 節點的值 */\nint val(ArrayBinaryTree *abt, int i) {\n    // 若索引越界，則返回 INT_MAX ，代表空位\n    if (i &lt; 0 || i &gt;= size(abt))\n        return INT_MAX;\n    return abt-&gt;tree[i];\n}\n\n/* 層序走訪 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // 直接走訪陣列\n    for (int i = 0; i &lt; size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* 深度優先走訪 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // 若為空位，則返回\n    if (val(abt, i) == INT_MAX)\n        return;\n    // 前序走訪\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // 中序走訪\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // 後序走訪\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* 前序走訪 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 中序走訪 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n\n/* 後序走訪 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &amp;index);\n    *returnSize = index;\n    return res;\n}\n</code></pre> array_binary_tree.kt<pre><code>/* 陣列表示下的二元樹類別 */\nclass ArrayBinaryTree(val tree: MutableList&lt;Int?&gt;) {\n    /* 串列容量 */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* 獲取索引為 i 節點的值 */\n    fun _val(i: Int): Int? {\n        // 若索引越界，則返回 null ，代表空位\n        if (i &lt; 0 || i &gt;= size()) return null\n        return tree[i]\n    }\n\n    /* 獲取索引為 i 節點的左子節點的索引 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* 獲取索引為 i 節點的右子節點的索引 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* 獲取索引為 i 節點的父節點的索引 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* 層序走訪 */\n    fun levelOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        // 直接走訪陣列\n        for (i in 0..&lt;size()) {\n            if (_val(i) != null)\n                res.add(_val(i))\n        }\n        return res\n    }\n\n    /* 深度優先走訪 */\n    fun dfs(i: Int, order: String, res: MutableList&lt;Int?&gt;) {\n        // 若為空位，則返回\n        if (_val(i) == null)\n            return\n        // 前序走訪\n        if (\"pre\" == order)\n            res.add(_val(i))\n        dfs(left(i), order, res)\n        // 中序走訪\n        if (\"in\" == order)\n            res.add(_val(i))\n        dfs(right(i), order, res)\n        // 後序走訪\n        if (\"post\" == order)\n            res.add(_val(i))\n    }\n\n    /* 前序走訪 */\n    fun preOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* 中序走訪 */\n    fun inOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* 後序走訪 */\n    fun postOrder(): MutableList&lt;Int?&gt; {\n        val res = mutableListOf&lt;Int?&gt;()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n</code></pre> array_binary_tree.rb<pre><code>### 陣列表示下的二元樹類別 ###\nclass ArrayBinaryTree\n  ### 建構子 ###\n  def initialize(arr)\n    @tree = arr.to_a\n  end\n\n  ### 串列容量 ###\n  def size\n    @tree.length\n  end\n\n  ### 獲取索引為 i 節點的值 ###\n  def val(i)\n    # 若索引越界，則返回 nil ，代表空位\n    return if i &lt; 0 || i &gt;= size\n\n    @tree[i]\n  end\n\n  ### 獲取索引為 i 節點的左子節點的索引 ###\n  def left(i)\n    2 * i + 1\n  end\n\n  ### 獲取索引為 i 節點的右子節點的索引 ###\n  def right(i)\n    2 * i + 2\n  end\n\n  ### 獲取索引為 i 節點的父節點的索引 ###\n  def parent(i)\n    (i - 1) / 2\n  end\n\n  ### 層序走訪 ###\n  def level_order\n    @res = []\n\n    # 直接走訪陣列\n    for i in 0...size\n      @res &lt;&lt; val(i) unless val(i).nil?\n    end\n\n    @res\n  end\n\n  ### 深度優先走訪 ###\n  def dfs(i, order)\n    return if val(i).nil?\n    # 前序走訪\n    @res &lt;&lt; val(i) if order == :pre\n    dfs(left(i), order)\n    # 中序走訪\n    @res &lt;&lt; val(i) if order == :in\n    dfs(right(i), order)\n    # 後序走訪\n    @res &lt;&lt; val(i) if order == :post\n  end\n\n  ### 前序走訪 ###\n  def pre_order\n    @res = []\n    dfs(0, :pre)\n    @res\n  end\n\n  ### 中序走訪 ###\n  def in_order\n    @res = []\n    dfs(0, :in)\n    @res\n  end\n\n  ### 後序走訪 ###\n  def post_order\n    @res = []\n    dfs(0, :post)\n    @res\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/array_representation_of_tree/#733","level":2,"title":"7.3.3   優點與侷限性","text":"<p>二元樹的陣列表示主要有以下優點。</p> <ul> <li>陣列儲存在連續的記憶體空間中，對快取友好，訪問與走訪速度較快。</li> <li>不需要儲存指標，比較節省空間。</li> <li>允許隨機訪問節點。</li> </ul> <p>然而，陣列表示也存在一些侷限性。</p> <ul> <li>陣列儲存需要連續記憶體空間，因此不適合儲存資料量過大的樹。</li> <li>增刪節點需要透過陣列插入與刪除操作實現，效率較低。</li> <li>當二元樹中存在大量 <code>None</code> 時，陣列中包含的節點資料比重較低，空間利用率較低。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.3 &nbsp; 二元樹陣列表示"],"tags":[]},{"location":"chapter_tree/avl_tree/","level":1,"title":"7.5   AVL 樹 *","text":"<p>在“二元搜尋樹”章節中我們提到，在多次插入和刪除操作後，二元搜尋樹可能退化為鏈結串列。在這種情況下，所有操作的時間複雜度將從 \\(O(\\log n)\\) 劣化為 \\(O(n)\\) 。</p> <p>如圖 7-24 所示，經過兩次刪除節點操作，這棵二元搜尋樹便會退化為鏈結串列。</p> <p></p> <p> 圖 7-24   AVL 樹在刪除節點後發生退化 </p> <p>再例如，在圖 7-25 所示的完美二元樹中插入兩個節點後，樹將嚴重向左傾斜，查詢操作的時間複雜度也隨之劣化。</p> <p></p> <p> 圖 7-25   AVL 樹在插入節點後發生退化 </p> <p>1962 年 G. M. Adelson-Velsky 和 E. M. Landis 在論文“An algorithm for the organization of information”中提出了 AVL 樹。論文中詳細描述了一系列操作，確保在持續新增和刪除節點後，AVL 樹不會退化，從而使得各種操作的時間複雜度保持在 \\(O(\\log n)\\) 級別。換句話說，在需要頻繁進行增刪查改操作的場景中，AVL 樹能始終保持高效的資料操作效能，具有很好的應用價值。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#751-avl","level":2,"title":"7.5.1   AVL 樹常見術語","text":"<p>AVL 樹既是二元搜尋樹，也是平衡二元樹，同時滿足這兩類二元樹的所有性質，因此是一種平衡二元搜尋樹（balanced binary search tree）。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1","level":3,"title":"1.   節點高度","text":"<p>由於 AVL 樹的相關操作需要獲取節點高度，因此我們需要為節點類別新增 <code>height</code> 變數：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"AVL 樹節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # 節點值\n        self.height: int = 0                # 節點高度\n        self.left: TreeNode | None = None   # 左子節點引用\n        self.right: TreeNode | None = None  # 右子節點引用\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nstruct TreeNode {\n    int val{};          // 節點值\n    int height = 0;     // 節點高度\n    TreeNode *left{};   // 左子節點\n    TreeNode *right{};  // 右子節點\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    public int val;        // 節點值\n    public int height;     // 節點高度\n    public TreeNode left;  // 左子節點\n    public TreeNode right; // 右子節點\n    public TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode(int? x) {\n    public int? val = x;    // 節點值\n    public int height;      // 節點高度\n    public TreeNode? left;  // 左子節點引用\n    public TreeNode? right; // 右子節點引用\n}\n</code></pre> <pre><code>/* AVL 樹節點結構體 */\ntype TreeNode struct {\n    Val    int       // 節點值\n    Height int       // 節點高度\n    Left   *TreeNode // 左子節點引用\n    Right  *TreeNode // 右子節點引用\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    var val: Int // 節點值\n    var height: Int // 節點高度\n    var left: TreeNode? // 左子節點\n    var right: TreeNode? // 右子節點\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    val; // 節點值\n    height; //節點高度\n    left; // 左子節點指標\n    right; // 右子節點指標\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n    val: number;            // 節點值\n    height: number;         // 節點高度\n    left: TreeNode | null;  // 左子節點指標\n    right: TreeNode | null; // 右子節點指標\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode {\n  int val;         // 節點值\n  int height;      // 節點高度\n  TreeNode? left;  // 左子節點\n  TreeNode? right; // 右子節點\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL 樹節點結構體 */\nstruct TreeNode {\n    val: i32,                               // 節點值\n    height: i32,                            // 節點高度\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子節點\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子節點\n}\n\nimpl TreeNode {\n    /* 建構子 */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* AVL 樹節點結構體 */\ntypedef struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* 建構子 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* AVL 樹節點類別 */\nclass TreeNode(val _val: Int) {  // 節點值\n    val height: Int = 0          // 節點高度\n    val left: TreeNode? = null   // 左子節點\n    val right: TreeNode? = null  // 右子節點\n}\n</code></pre> <pre><code>### AVL 樹節點類別 ###\nclass TreeNode\n  attr_accessor :val    # 節點值\n  attr_accessor :height # 節點高度\n  attr_accessor :left   # 左子節點引用\n  attr_accessor :right  # 右子節點引用\n\n  def initialize(val)\n    @val = val\n    @height = 0\n  end\nend\n</code></pre> <p>“節點高度”是指從該節點到它的最遠葉節點的距離，即所經過的“邊”的數量。需要特別注意的是，葉節點的高度為 \\(0\\) ，而空節點的高度為 \\(-1\\) 。我們將建立兩個工具函式，分別用於獲取和更新節點的高度：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def height(self, node: TreeNode | None) -&gt; int:\n    \"\"\"獲取節點高度\"\"\"\n    # 空節點高度為 -1 ，葉節點高度為 0\n    if node is not None:\n        return node.height\n    return -1\n\ndef update_height(self, node: TreeNode | None):\n    \"\"\"更新節點高度\"\"\"\n    # 節點高度等於最高子樹高度 + 1\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\n</code></pre> avl_tree.cpp<pre><code>/* 獲取節點高度 */\nint height(TreeNode *node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == nullptr ? -1 : node-&gt;height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode *node) {\n    // 節點高度等於最高子樹高度 + 1\n    node-&gt;height = max(height(node-&gt;left), height(node-&gt;right)) + 1;\n}\n</code></pre> avl_tree.java<pre><code>/* 獲取節點高度 */\nint height(TreeNode node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.cs<pre><code>/* 獲取節點高度 */\nint Height(TreeNode? node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid UpdateHeight(TreeNode node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\n</code></pre> avl_tree.go<pre><code>/* 獲取節點高度 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* 更新節點高度 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // 節點高度等於最高子樹高度 + 1\n    if lh &gt; rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\n}\n</code></pre> avl_tree.swift<pre><code>/* 獲取節點高度 */\nfunc height(node: TreeNode?) -&gt; Int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    node?.height ?? -1\n}\n\n/* 更新節點高度 */\nfunc updateHeight(node: TreeNode?) {\n    // 節點高度等於最高子樹高度 + 1\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n</code></pre> avl_tree.js<pre><code>/* 獲取節點高度 */\nheight(node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node === null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\n#updateHeight(node) {\n    // 節點高度等於最高子樹高度 + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.ts<pre><code>/* 獲取節點高度 */\nheight(node: TreeNode): number {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node === null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nupdateHeight(node: TreeNode): void {\n    // 節點高度等於最高子樹高度 + 1\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n</code></pre> avl_tree.dart<pre><code>/* 獲取節點高度 */\nint height(TreeNode? node) {\n  // 空節點高度為 -1 ，葉節點高度為 0\n  return node == null ? -1 : node.height;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode? node) {\n  // 節點高度等於最高子樹高度 + 1\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n</code></pre> avl_tree.rs<pre><code>/* 獲取節點高度 */\nfn height(node: OptionTreeNodeRc) -&gt; i32 {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    match node {\n        Some(node) =&gt; node.borrow().height,\n        None =&gt; -1,\n    }\n}\n\n/* 更新節點高度 */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // 節點高度等於最高子樹高度 + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 獲取節點高度 */\nint height(TreeNode *node) {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    if (node != NULL) {\n        return node-&gt;height;\n    }\n    return -1;\n}\n\n/* 更新節點高度 */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node-&gt;left);\n    int rh = height(node-&gt;right);\n    // 節點高度等於最高子樹高度 + 1\n    if (lh &gt; rh) {\n        node-&gt;height = lh + 1;\n    } else {\n        node-&gt;height = rh + 1;\n    }\n}\n</code></pre> avl_tree.kt<pre><code>/* 獲取節點高度 */\nfun height(node: TreeNode?): Int {\n    // 空節點高度為 -1 ，葉節點高度為 0\n    return node?.height ?: -1\n}\n\n/* 更新節點高度 */\nfun updateHeight(node: TreeNode?) {\n    // 節點高度等於最高子樹高度 + 1\n    node?.height = max(height(node?.left), height(node?.right)) + 1\n}\n</code></pre> avl_tree.rb<pre><code>### 獲取節點高度 ###\ndef height(node)\n  # 空節點高度為 -1 ，葉節點高度為 0\n  return node.height unless node.nil?\n\n  -1\nend\n\n### 更新節點高度 ###\ndef update_height(node)\n  # 節點高度等於最高子樹高度 + 1\n  node.height = [height(node.left), height(node.right)].max + 1\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2","level":3,"title":"2.   節點平衡因子","text":"<p>節點的平衡因子（balance factor）定義為節點左子樹的高度減去右子樹的高度，同時規定空節點的平衡因子為 \\(0\\) 。我們同樣將獲取節點平衡因子的功能封裝成函式，方便後續使用：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def balance_factor(self, node: TreeNode | None) -&gt; int:\n    \"\"\"獲取平衡因子\"\"\"\n    # 空節點平衡因子為 0\n    if node is None:\n        return 0\n    # 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return self.height(node.left) - self.height(node.right)\n</code></pre> avl_tree.cpp<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode *node) {\n    // 空節點平衡因子為 0\n    if (node == nullptr)\n        return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.java<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode node) {\n    // 空節點平衡因子為 0\n    if (node == null)\n        return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.cs<pre><code>/* 獲取平衡因子 */\nint BalanceFactor(TreeNode? node) {\n    // 空節點平衡因子為 0\n    if (node == null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return Height(node.left) - Height(node.right);\n}\n</code></pre> avl_tree.go<pre><code>/* 獲取平衡因子 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n    // 空節點平衡因子為 0\n    if node == nil {\n        return 0\n    }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return t.height(node.Left) - t.height(node.Right)\n}\n</code></pre> avl_tree.swift<pre><code>/* 獲取平衡因子 */\nfunc balanceFactor(node: TreeNode?) -&gt; Int {\n    // 空節點平衡因子為 0\n    guard let node = node else { return 0 }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node: node.left) - height(node: node.right)\n}\n</code></pre> avl_tree.js<pre><code>/* 獲取平衡因子 */\nbalanceFactor(node) {\n    // 空節點平衡因子為 0\n    if (node === null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.ts<pre><code>/* 獲取平衡因子 */\nbalanceFactor(node: TreeNode): number {\n    // 空節點平衡因子為 0\n    if (node === null) return 0;\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return this.height(node.left) - this.height(node.right);\n}\n</code></pre> avl_tree.dart<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode? node) {\n  // 空節點平衡因子為 0\n  if (node == null) return 0;\n  // 節點平衡因子 = 左子樹高度 - 右子樹高度\n  return height(node.left) - height(node.right);\n}\n</code></pre> avl_tree.rs<pre><code>/* 獲取平衡因子 */\nfn balance_factor(node: OptionTreeNodeRc) -&gt; i32 {\n    match node {\n        // 空節點平衡因子為 0\n        None =&gt; 0,\n        // 節點平衡因子 = 左子樹高度 - 右子樹高度\n        Some(node) =&gt; {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 獲取平衡因子 */\nint balanceFactor(TreeNode *node) {\n    // 空節點平衡因子為 0\n    if (node == NULL) {\n        return 0;\n    }\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node-&gt;left) - height(node-&gt;right);\n}\n</code></pre> avl_tree.kt<pre><code>/* 獲取平衡因子 */\nfun balanceFactor(node: TreeNode?): Int {\n    // 空節點平衡因子為 0\n    if (node == null) return 0\n    // 節點平衡因子 = 左子樹高度 - 右子樹高度\n    return height(node.left) - height(node.right)\n}\n</code></pre> avl_tree.rb<pre><code>### 獲取平衡因子 ###\ndef balance_factor(node)\n  # 空節點平衡因子為 0\n  return 0 if node.nil?\n\n  # 節點平衡因子 = 左子樹高度 - 右子樹高度\n  height(node.left) - height(node.right)\nend\n</code></pre> <p>Tip</p> <p>設平衡因子為 \\(f\\) ，則一棵 AVL 樹的任意節點的平衡因子皆滿足 \\(-1 \\le f \\le 1\\) 。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#752-avl","level":2,"title":"7.5.2   AVL 樹旋轉","text":"<p>AVL 樹的特點在於“旋轉”操作，它能夠在不影響二元樹的中序走訪序列的前提下，使失衡節點重新恢復平衡。換句話說，旋轉操作既能保持“二元搜尋樹”的性質，也能使樹重新變為“平衡二元樹”。</p> <p>我們將平衡因子絕對值 \\(&gt; 1\\) 的節點稱為“失衡節點”。根據節點失衡情況的不同，旋轉操作分為四種：右旋、左旋、先右旋後左旋、先左旋後右旋。下面詳細介紹這些旋轉操作。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_1","level":3,"title":"1.   右旋","text":"<p>如圖 7-26 所示，節點下方為平衡因子。從底至頂看，二元樹中首個失衡節點是“節點 3”。我們關注以該失衡節點為根節點的子樹，將該節點記為 <code>node</code> ，其左子節點記為 <code>child</code> ，執行“右旋”操作。完成右旋後，子樹恢復平衡，並且仍然保持二元搜尋樹的性質。</p> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-26   右旋操作步驟 </p> <p>如圖 7-27 所示，當節點 <code>child</code> 有右子節點（記為 <code>grand_child</code> ）時，需要在右旋中新增一步：將 <code>grand_child</code> 作為 <code>node</code> 的左子節點。</p> <p></p> <p> 圖 7-27   有 grand_child 的右旋操作 </p> <p>“向右旋轉”是一種形象化的說法，實際上需要透過修改節點指標來實現，程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def right_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"右旋操作\"\"\"\n    child = node.left\n    grand_child = child.right\n    # 以 child 為原點，將 node 向右旋轉\n    child.right = node\n    node.left = grand_child\n    # 更新節點高度\n    self.update_height(node)\n    self.update_height(child)\n    # 返回旋轉後子樹的根節點\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 右旋操作 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;left;\n    TreeNode *grandChild = child-&gt;right;\n    // 以 child 為原點，將 node 向右旋轉\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 右旋操作 */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 右旋操作 */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 右旋操作 */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // 以 child 為原點，將 node 向右旋轉\n    child.Right = node\n    node.Left = grandChild\n    // 更新節點高度\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 右旋操作 */\nfunc rightRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // 以 child 為原點，將 node 向右旋轉\n    child?.right = node\n    node?.left = grandChild\n    // 更新節點高度\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 右旋操作 */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 右旋操作 */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node;\n    node.left = grandChild;\n    // 更新節點高度\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 右旋操作 */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // 以 child 為原點，將 node 向右旋轉\n  child.right = node;\n  node.left = grandChild;\n  // 更新節點高度\n  updateHeight(node);\n  updateHeight(child);\n  // 返回旋轉後子樹的根節點\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 右旋操作 */\nfn right_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // 以 child 為原點，將 node 向右旋轉\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // 更新節點高度\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 返回旋轉後子樹的根節點\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 右旋操作 */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;left;\n    grandChild = child-&gt;right;\n    // 以 child 為原點，將 node 向右旋轉\n    child-&gt;right = node;\n    node-&gt;left = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 右旋操作 */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // 以 child 為原點，將 node 向右旋轉\n    child.right = node\n    node.left = grandChild\n    // 更新節點高度\n    updateHeight(node)\n    updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 右旋操作 ###\ndef right_rotate(node)\n  child = node.left\n  grand_child = child.right\n  # 以 child 為原點，將 node 向右旋轉\n  child.right = node\n  node.left = grand_child\n  # 更新節點高度\n  update_height(node)\n  update_height(child)\n  # 返回旋轉後子樹的根節點\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_1","level":3,"title":"2.   左旋","text":"<p>相應地，如果考慮上述失衡二元樹的“映象”，則需要執行圖 7-28 所示的“左旋”操作。</p> <p></p> <p> 圖 7-28   左旋操作 </p> <p>同理，如圖 7-29 所示，當節點 <code>child</code> 有左子節點（記為 <code>grand_child</code> ）時，需要在左旋中新增一步：將 <code>grand_child</code> 作為 <code>node</code> 的右子節點。</p> <p></p> <p> 圖 7-29   有 grand_child 的左旋操作 </p> <p>可以觀察到，右旋和左旋操作在邏輯上是映象對稱的，它們分別解決的兩種失衡情況也是對稱的。基於對稱性，我們只需將右旋的實現程式碼中的所有的 <code>left</code> 替換為 <code>right</code> ，將所有的 <code>right</code> 替換為 <code>left</code> ，即可得到左旋的實現程式碼：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def left_rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"左旋操作\"\"\"\n    child = node.right\n    grand_child = child.left\n    # 以 child 為原點，將 node 向左旋轉\n    child.left = node\n    node.right = grand_child\n    # 更新節點高度\n    self.update_height(node)\n    self.update_height(child)\n    # 返回旋轉後子樹的根節點\n    return child\n</code></pre> avl_tree.cpp<pre><code>/* 左旋操作 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node-&gt;right;\n    TreeNode *grandChild = child-&gt;left;\n    // 以 child 為原點，將 node 向左旋轉\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.java<pre><code>/* 左旋操作 */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.cs<pre><code>/* 左旋操作 */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.go<pre><code>/* 左旋操作 */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // 以 child 為原點，將 node 向左旋轉\n    child.Left = node\n    node.Right = grandChild\n    // 更新節點高度\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.swift<pre><code>/* 左旋操作 */\nfunc leftRotate(node: TreeNode?) -&gt; TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // 以 child 為原點，將 node 向左旋轉\n    child?.left = node\n    node?.right = grandChild\n    // 更新節點高度\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.js<pre><code>/* 左旋操作 */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.ts<pre><code>/* 左旋操作 */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node;\n    node.right = grandChild;\n    // 更新節點高度\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.dart<pre><code>/* 左旋操作 */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // 以 child 為原點，將 node 向左旋轉\n  child.left = node;\n  node.right = grandChild;\n  // 更新節點高度\n  updateHeight(node);\n  updateHeight(child);\n  // 返回旋轉後子樹的根節點\n  return child;\n}\n</code></pre> avl_tree.rs<pre><code>/* 左旋操作 */\nfn left_rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(node) =&gt; {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // 以 child 為原點，將 node 向左旋轉\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // 更新節點高度\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // 返回旋轉後子樹的根節點\n            Some(child)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 左旋操作 */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node-&gt;right;\n    grandChild = child-&gt;left;\n    // 以 child 為原點，將 node 向左旋轉\n    child-&gt;left = node;\n    node-&gt;right = grandChild;\n    // 更新節點高度\n    updateHeight(node);\n    updateHeight(child);\n    // 返回旋轉後子樹的根節點\n    return child;\n}\n</code></pre> avl_tree.kt<pre><code>/* 左旋操作 */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // 以 child 為原點，將 node 向左旋轉\n    child.left = node\n    node.right = grandChild\n    // 更新節點高度\n    updateHeight(node)\n    updateHeight(child)\n    // 返回旋轉後子樹的根節點\n    return child\n}\n</code></pre> avl_tree.rb<pre><code>### 左旋操作 ###\ndef left_rotate(node)\n  child = node.right\n  grand_child = child.left\n  # 以 child 為原點，將 node 向左旋轉\n  child.left = node\n  node.right = grand_child\n  # 更新節點高度\n  update_height(node)\n  update_height(child)\n  # 返回旋轉後子樹的根節點\n  child\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3","level":3,"title":"3.   先左旋後右旋","text":"<p>對於圖 7-30 中的失衡節點 3 ，僅使用左旋或右旋都無法使子樹恢復平衡。此時需要先對 <code>child</code> 執行“左旋”，再對 <code>node</code> 執行“右旋”。</p> <p></p> <p> 圖 7-30   先左旋後右旋 </p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#4","level":3,"title":"4.   先右旋後左旋","text":"<p>如圖 7-31 所示，對於上述失衡二元樹的映象情況，需要先對 <code>child</code> 執行“右旋”，再對 <code>node</code> 執行“左旋”。</p> <p></p> <p> 圖 7-31   先右旋後左旋 </p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#5","level":3,"title":"5.   旋轉的選擇","text":"<p>圖 7-32 展示的四種失衡情況與上述案例逐個對應，分別需要採用右旋、先左旋後右旋、先右旋後左旋、左旋的操作。</p> <p></p> <p> 圖 7-32   AVL 樹的四種旋轉情況 </p> <p>如下表所示，我們透過判斷失衡節點的平衡因子以及較高一側子節點的平衡因子的正負號，來確定失衡節點屬於圖 7-32 中的哪種情況。</p> <p> 表 7-3   四種旋轉情況的選擇條件 </p> 失衡節點的平衡因子 子節點的平衡因子 應採用的旋轉方法 \\(&gt; 1\\) （左偏樹） \\(\\geq 0\\) 右旋 \\(&gt; 1\\) （左偏樹） \\(&lt;0\\) 先左旋後右旋 \\(&lt; -1\\) （右偏樹） \\(\\leq 0\\) 左旋 \\(&lt; -1\\) （右偏樹） \\(&gt;0\\) 先右旋後左旋 <p>為了便於使用，我們將旋轉操作封裝成一個函式。有了這個函式，我們就能對各種失衡情況進行旋轉，使失衡節點重新恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def rotate(self, node: TreeNode | None) -&gt; TreeNode | None:\n    \"\"\"執行旋轉操作，使該子樹重新恢復平衡\"\"\"\n    # 獲取節點 node 的平衡因子\n    balance_factor = self.balance_factor(node)\n    # 左偏樹\n    if balance_factor &gt; 1:\n        if self.balance_factor(node.left) &gt;= 0:\n            # 右旋\n            return self.right_rotate(node)\n        else:\n            # 先左旋後右旋\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # 右偏樹\n    elif balance_factor &lt; -1:\n        if self.balance_factor(node.right) &lt;= 0:\n            # 左旋\n            return self.left_rotate(node)\n        else:\n            # 先右旋後左旋\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # 平衡樹，無須旋轉，直接返回\n    return node\n</code></pre> avl_tree.cpp<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode *rotate(TreeNode *node) {\n    // 獲取節點 node 的平衡因子\n    int _balanceFactor = balanceFactor(node);\n    // 左偏樹\n    if (_balanceFactor &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (_balanceFactor &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode rotate(TreeNode node) {\n    // 獲取節點 node 的平衡因子\n    int balanceFactor = balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode? Rotate(TreeNode? node) {\n    // 獲取節點 node 的平衡因子\n    int balanceFactorInt = BalanceFactor(node);\n    // 左偏樹\n    if (balanceFactorInt &gt; 1) {\n        if (BalanceFactor(node?.left) &gt;= 0) {\n            // 右旋\n            return RightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactorInt &lt; -1) {\n        if (BalanceFactor(node?.right) &lt;= 0) {\n            // 左旋\n            return LeftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n    // 獲取節點 node 的平衡因子\n    // Go 推薦短變數，這裡 bf 指代 t.balanceFactor\n    bf := t.balanceFactor(node)\n    // 左偏樹\n    if bf &gt; 1 {\n        if t.balanceFactor(node.Left) &gt;= 0 {\n            // 右旋\n            return t.rightRotate(node)\n        } else {\n            // 先左旋後右旋\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // 右偏樹\n    if bf &lt; -1 {\n        if t.balanceFactor(node.Right) &lt;= 0 {\n            // 左旋\n            return t.leftRotate(node)\n        } else {\n            // 先右旋後左旋\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfunc rotate(node: TreeNode?) -&gt; TreeNode? {\n    // 獲取節點 node 的平衡因子\n    let balanceFactor = balanceFactor(node: node)\n    // 左偏樹\n    if balanceFactor &gt; 1 {\n        if self.balanceFactor(node: node?.left) &gt;= 0 {\n            // 右旋\n            return rightRotate(node: node)\n        } else {\n            // 先左旋後右旋\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // 右偏樹\n    if balanceFactor &lt; -1 {\n        if self.balanceFactor(node: node?.right) &lt;= 0 {\n            // 左旋\n            return leftRotate(node: node)\n        } else {\n            // 先右旋後左旋\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\n#rotate(node) {\n    // 獲取節點 node 的平衡因子\n    const balanceFactor = this.balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return this.#rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return this.#leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nrotate(node: TreeNode): TreeNode {\n    // 獲取節點 node 的平衡因子\n    const balanceFactor = this.balanceFactor(node);\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (this.balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return this.rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (this.balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return this.leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode? rotate(TreeNode? node) {\n  // 獲取節點 node 的平衡因子\n  int factor = balanceFactor(node);\n  // 左偏樹\n  if (factor &gt; 1) {\n    if (balanceFactor(node!.left) &gt;= 0) {\n      // 右旋\n      return rightRotate(node);\n    } else {\n      // 先左旋後右旋\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // 右偏樹\n  if (factor &lt; -1) {\n    if (balanceFactor(node!.right) &lt;= 0) {\n      // 左旋\n      return leftRotate(node);\n    } else {\n      // 先右旋後左旋\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // 平衡樹，無須旋轉，直接返回\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfn rotate(node: OptionTreeNodeRc) -&gt; OptionTreeNodeRc {\n    // 獲取節點 node 的平衡因子\n    let balance_factor = Self::balance_factor(node.clone());\n    // 左偏樹\n    if balance_factor &gt; 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) &gt;= 0 {\n            // 右旋\n            Self::right_rotate(Some(node))\n        } else {\n            // 先左旋後右旋\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // 右偏樹\n    else if balance_factor &lt; -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) &lt;= 0 {\n            // 左旋\n            Self::left_rotate(Some(node))\n        } else {\n            // 先右旋後左旋\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // 平衡樹，無須旋轉，直接返回\n        node\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nTreeNode *rotate(TreeNode *node) {\n    // 獲取節點 node 的平衡因子\n    int bf = balanceFactor(node);\n    // 左偏樹\n    if (bf &gt; 1) {\n        if (balanceFactor(node-&gt;left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node);\n        } else {\n            // 先左旋後右旋\n            node-&gt;left = leftRotate(node-&gt;left);\n            return rightRotate(node);\n        }\n    }\n    // 右偏樹\n    if (bf &lt; -1) {\n        if (balanceFactor(node-&gt;right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node);\n        } else {\n            // 先右旋後左旋\n            node-&gt;right = rightRotate(node-&gt;right);\n            return leftRotate(node);\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 執行旋轉操作，使該子樹重新恢復平衡 */\nfun rotate(node: TreeNode): TreeNode {\n    // 獲取節點 node 的平衡因子\n    val balanceFactor = balanceFactor(node)\n    // 左偏樹\n    if (balanceFactor &gt; 1) {\n        if (balanceFactor(node.left) &gt;= 0) {\n            // 右旋\n            return rightRotate(node)\n        } else {\n            // 先左旋後右旋\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // 右偏樹\n    if (balanceFactor &lt; -1) {\n        if (balanceFactor(node.right) &lt;= 0) {\n            // 左旋\n            return leftRotate(node)\n        } else {\n            // 先右旋後左旋\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // 平衡樹，無須旋轉，直接返回\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 執行旋轉操作，使該子樹重新恢復平衡 ###\ndef rotate(node)\n  # 獲取節點 node 的平衡因子\n  balance_factor = balance_factor(node)\n  # 左遍樹\n  if balance_factor &gt; 1\n    if balance_factor(node.left) &gt;= 0\n      # 右旋\n      return right_rotate(node)\n    else\n      # 先左旋後右旋\n      node.left = left_rotate(node.left)\n      return right_rotate(node)\n    end\n  # 右遍樹\n  elsif balance_factor &lt; -1\n    if balance_factor(node.right) &lt;= 0\n      # 左旋\n      return left_rotate(node)\n    else\n      # 先右旋後左旋\n      node.right = right_rotate(node.right)\n      return left_rotate(node)\n    end\n  end\n  # 平衡樹，無須旋轉，直接返回\n  node\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#753-avl","level":2,"title":"7.5.3   AVL 樹常用操作","text":"","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#1_2","level":3,"title":"1.   插入節點","text":"<p>AVL 樹的節點插入操作與二元搜尋樹在主體上類似。唯一的區別在於，在 AVL 樹中插入節點後，從該節點到根節點的路徑上可能會出現一系列失衡節點。因此，我們需要從這個節點開始，自底向上執行旋轉操作，使所有失衡節點恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def insert(self, val):\n    \"\"\"插入節點\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode:\n    \"\"\"遞迴插入節點（輔助方法）\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. 查詢插入位置並插入節點\n    if val &lt; node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # 重複節點不插入，直接返回\n        return node\n    # 更新節點高度\n    self.update_height(node)\n    # 2. 執行旋轉操作，使該子樹重新恢復平衡\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* 插入節點 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    else\n        return node;    // 重複節點不插入，直接返回\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 插入節點 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // 重複節點不插入，直接返回\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 插入節點 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // 重複節點不插入，直接返回\n    UpdateHeight(node);  // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = Rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 插入節點 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* 遞迴插入節點（輔助函式） */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // 重複節點不插入，直接返回\n        return node\n    }\n    // 更新節點高度\n    t.updateHeight(node)\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = t.rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 插入節點 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* 遞迴插入節點（輔助方法） */\nfunc insertHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if val &lt; node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // 重複節點不插入，直接返回\n    }\n    updateHeight(node: node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node: node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 插入節點 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // 重複節點不插入，直接返回\n    this.#updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.#rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 插入節點 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // 重複節點不插入，直接返回\n    }\n    this.updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 插入節點 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. 查詢插入位置並插入節點 */\n  if (val &lt; node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // 重複節點不插入，直接返回\n  updateHeight(node); // 更新節點高度\n  /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n  node = rotate(node);\n  // 返回子樹的根節點\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 插入節點 */\nfn insert(&amp;mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* 遞迴插入節點（輔助方法） */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 查詢插入位置並插入節點 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&amp;val)\n            {\n                Ordering::Greater =&gt; {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less =&gt; {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal =&gt; {\n                    return Some(node); // 重複節點不插入，直接返回\n                }\n            }\n            Self::update_height(Some(node.clone())); // 更新節點高度\n\n            /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n            node = Self::rotate(Some(node)).unwrap();\n            // 返回子樹的根節點\n            Some(node)\n        }\n        None =&gt; Some(TreeNode::new(val)),\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 插入節點 */\nvoid insert(AVLTree *tree, int val) {\n    tree-&gt;root = insertHelper(tree-&gt;root, val);\n}\n\n/* 遞迴插入節點（輔助函式） */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. 查詢插入位置並插入節點 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = insertHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = insertHelper(node-&gt;right, val);\n    } else {\n        // 重複節點不插入，直接返回\n        return node;\n    }\n    // 更新節點高度\n    updateHeight(node);\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 插入節點 */\nfun insert(_val: Int) {\n    root = insertHelper(root, _val)\n}\n\n/* 遞迴插入節點（輔助方法） */\nfun insertHelper(n: TreeNode?, _val: Int): TreeNode {\n    if (n == null)\n        return TreeNode(_val)\n    var node = n\n    /* 1. 查詢插入位置並插入節點 */\n    if (_val &lt; node._val)\n        node.left = insertHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = insertHelper(node.right, _val)\n    else\n        return node // 重複節點不插入，直接返回\n    updateHeight(node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 插入節點 ###\ndef insert(val)\n  @root = insert_helper(@root, val)\nend\n\n### 遞迴插入節點（輔助方法）###\ndef insert_helper(node, val)\n  return TreeNode.new(val) if node.nil?\n  # 1. 查詢插入位置並插入節點\n  if val &lt; node.val\n    node.left = insert_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = insert_helper(node.right, val)\n  else\n    # 重複節點不插入，直接返回\n    return node\n  end\n  # 更新節點高度\n  update_height(node)\n  # 2. 執行旋轉操作，使該子樹重新恢復平衡\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#2_2","level":3,"title":"2.   刪除節點","text":"<p>類似地，在二元搜尋樹的刪除節點方法的基礎上，需要從底至頂執行旋轉操作，使所有失衡節點恢復平衡。程式碼如下所示：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby avl_tree.py<pre><code>def remove(self, val: int):\n    \"\"\"刪除節點\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -&gt; TreeNode | None:\n    \"\"\"遞迴刪除節點（輔助方法）\"\"\"\n    if node is None:\n        return None\n    # 1. 查詢節點並刪除\n    if val &lt; node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val &gt; node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # 子節點數量 = 0 ，直接刪除 node 並返回\n            if child is None:\n                return None\n            # 子節點數量 = 1 ，直接刪除 node\n            else:\n                node = child\n        else:\n            # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # 更新節點高度\n    self.update_height(node)\n    # 2. 執行旋轉操作，使該子樹重新恢復平衡\n    return self.rotate(node)\n</code></pre> avl_tree.cpp<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node-&gt;val)\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    else if (val &gt; node-&gt;val)\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    else {\n        if (node-&gt;left == nullptr || node-&gt;right == nullptr) {\n            TreeNode *child = node-&gt;left != nullptr ? node-&gt;left : node-&gt;right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // 子節點數量 = 1 ，直接刪除 node\n            else {\n                delete node;\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != nullptr) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.java<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.cs<pre><code>/* 刪除節點 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    UpdateHeight(node);  // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = Rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.go<pre><code>/* 刪除節點 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* 遞迴刪除節點（輔助函式） */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. 查詢節點並刪除 */\n    if val &lt; node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val &gt; node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // 子節點數量 = 0 ，直接刪除 node 並返回\n                return nil\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // 更新節點高度\n    t.updateHeight(node)\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = t.rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.swift<pre><code>/* 刪除節點 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfunc removeHelper(node: TreeNode?, val: Int) -&gt; TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. 查詢節點並刪除 */\n    if val &lt; node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val &gt; node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if child == nil {\n                return nil\n            }\n            // 子節點數量 = 1 ，直接刪除 node\n            else {\n                node = child\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(node: node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node: node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.js<pre><code>/* 刪除節點 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val &gt; node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child === null) return null;\n            // 子節點數量 = 1 ，直接刪除 node\n            else node = child;\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.#rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.ts<pre><code>/* 刪除節點 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val &gt; node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child === null) {\n                return null;\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.updateHeight(node); // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = this.rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.dart<pre><code>/* 刪除節點 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. 查詢節點並刪除 */\n  if (val &lt; node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val &gt; node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // 子節點數量 = 0 ，直接刪除 node 並返回\n      if (child == null)\n        return null;\n      // 子節點數量 = 1 ，直接刪除 node\n      else\n        node = child;\n    } else {\n      // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  updateHeight(node); // 更新節點高度\n  /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n  node = rotate(node);\n  // 返回子樹的根節點\n  return node;\n}\n</code></pre> avl_tree.rs<pre><code>/* 刪除節點 */\nfn remove(&amp;self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -&gt; OptionTreeNodeRc {\n    match node {\n        Some(mut node) =&gt; {\n            /* 1. 查詢節點並刪除 */\n            if val &lt; node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val &gt; node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // 子節點數量 = 0 ，直接刪除 node 並返回\n                    None =&gt; {\n                        return None;\n                    }\n                    // 子節點數量 = 1 ，直接刪除 node\n                    Some(child) =&gt; node = child,\n                }\n            } else {\n                // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // 更新節點高度\n\n            /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n            node = Self::rotate(Some(node)).unwrap();\n            // 返回子樹的根節點\n            Some(node)\n        }\n        None =&gt; None,\n    }\n}\n</code></pre> avl_tree.c<pre><code>/* 刪除節點 */\n// 由於引入了 stdio.h ，此處無法使用 remove 關鍵詞\nvoid removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree-&gt;root, val);\n}\n\n/* 遞迴刪除節點（輔助函式） */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. 查詢節點並刪除 */\n    if (val &lt; node-&gt;val) {\n        node-&gt;left = removeHelper(node-&gt;left, val);\n    } else if (val &gt; node-&gt;val) {\n        node-&gt;right = removeHelper(node-&gt;right, val);\n    } else {\n        if (node-&gt;left == NULL || node-&gt;right == NULL) {\n            child = node-&gt;left;\n            if (node-&gt;right != NULL) {\n                child = node-&gt;right;\n            }\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // 子節點數量 = 1 ，直接刪除 node\n                node = child;\n            }\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            TreeNode *temp = node-&gt;right;\n            while (temp-&gt;left != NULL) {\n                temp = temp-&gt;left;\n            }\n            int tempVal = temp-&gt;val;\n            node-&gt;right = removeHelper(node-&gt;right, temp-&gt;val);\n            node-&gt;val = tempVal;\n        }\n    }\n    // 更新節點高度\n    updateHeight(node);\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node);\n    // 返回子樹的根節點\n    return node;\n}\n</code></pre> avl_tree.kt<pre><code>/* 刪除節點 */\nfun remove(_val: Int) {\n    root = removeHelper(root, _val)\n}\n\n/* 遞迴刪除節點（輔助方法） */\nfun removeHelper(n: TreeNode?, _val: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. 查詢節點並刪除 */\n    if (_val &lt; node._val)\n        node.left = removeHelper(node.left, _val)\n    else if (_val &gt; node._val)\n        node.right = removeHelper(node.right, _val)\n    else {\n        if (node.left == null || node.right == null) {\n            val child = if (node.left != null)\n                node.left\n            else\n                node.right\n            // 子節點數量 = 0 ，直接刪除 node 並返回\n            if (child == null)\n                return null\n            // 子節點數量 = 1 ，直接刪除 node\n            else\n                node = child\n        } else {\n            // 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp._val)\n            node._val = temp._val\n        }\n    }\n    updateHeight(node) // 更新節點高度\n    /* 2. 執行旋轉操作，使該子樹重新恢復平衡 */\n    node = rotate(node)\n    // 返回子樹的根節點\n    return node\n}\n</code></pre> avl_tree.rb<pre><code>### 刪除節點 ###\ndef remove(val)\n  @root = remove_helper(@root, val)\nend\n\n### 遞迴刪除節點（輔助方法）###\ndef remove_helper(node, val)\n  return if node.nil?\n  # 1. 查詢節點並刪除\n  if val &lt; node.val\n    node.left = remove_helper(node.left, val)\n  elsif val &gt; node.val\n    node.right = remove_helper(node.right, val)\n  else\n    if node.left.nil? || node.right.nil?\n      child = node.left || node.right\n      # 子節點數量 = 0 ，直接刪除 node 並返回\n      return if child.nil?\n      # 子節點數量 = 1 ，直接刪除 node\n      node = child\n    else\n      # 子節點數量 = 2 ，則將中序走訪的下個節點刪除，並用該節點替換當前節點\n      temp = node.right\n      while !temp.left.nil?\n        temp = temp.left\n      end\n      node.right = remove_helper(node.right, temp.val)\n      node.val = temp.val\n    end\n  end\n  # 更新節點高度\n  update_height(node)\n  # 2. 執行旋轉操作，使該子樹重新恢復平衡\n  rotate(node)\nend\n</code></pre>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#3_1","level":3,"title":"3.   查詢節點","text":"<p>AVL 樹的節點查詢操作與二元搜尋樹一致，在此不再贅述。</p>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/avl_tree/#754-avl","level":2,"title":"7.5.4   AVL 樹典型應用","text":"<ul> <li>組織和儲存大型資料，適用於高頻查詢、低頻增刪的場景。</li> <li>用於構建資料庫中的索引系統。</li> <li>紅黑樹也是一種常見的平衡二元搜尋樹。相較於 AVL 樹，紅黑樹的平衡條件更寬鬆，插入與刪除節點所需的旋轉操作更少，節點增刪操作的平均效率更高。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.5 &nbsp; AVL 樹 *"],"tags":[]},{"location":"chapter_tree/binary_search_tree/","level":1,"title":"7.4   二元搜尋樹","text":"<p>如圖 7-16 所示，二元搜尋樹（binary search tree）滿足以下條件。</p> <ol> <li>對於根節點，左子樹中所有節點的值 \\(&lt;\\) 根節點的值 \\(&lt;\\) 右子樹中所有節點的值。</li> <li>任意節點的左、右子樹也是二元搜尋樹，即同樣滿足條件 <code>1.</code> 。</li> </ol> <p></p> <p> 圖 7-16   二元搜尋樹 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#741","level":2,"title":"7.4.1   二元搜尋樹的操作","text":"<p>我們將二元搜尋樹封裝為一個類別 <code>BinarySearchTree</code> ，並宣告一個成員變數 <code>root</code> ，指向樹的根節點。</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#1","level":3,"title":"1.   查詢節點","text":"<p>給定目標節點值 <code>num</code> ，可以根據二元搜尋樹的性質來查詢。如圖 7-17 所示，我們宣告一個節點 <code>cur</code> ，從二元樹的根節點 <code>root</code> 出發，迴圈比較節點值 <code>cur.val</code> 和 <code>num</code> 之間的大小關係。</p> <ul> <li>若 <code>cur.val &lt; num</code> ，說明目標節點在 <code>cur</code> 的右子樹中，因此執行 <code>cur = cur.right</code> 。</li> <li>若 <code>cur.val &gt; num</code> ，說明目標節點在 <code>cur</code> 的左子樹中，因此執行 <code>cur = cur.left</code> 。</li> <li>若 <code>cur.val = num</code> ，說明找到目標節點，跳出迴圈並返回該節點。</li> </ul> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-17   二元搜尋樹查詢節點示例 </p> <p>二元搜尋樹的查詢操作與二分搜尋演算法的工作原理一致，都是每輪排除一半情況。迴圈次數最多為二元樹的高度，當二元樹平衡時，使用 \\(O(\\log n)\\) 時間。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def search(self, num: int) -&gt; TreeNode | None:\n    \"\"\"查詢節點\"\"\"\n    cur = self._root\n    # 迴圈查詢，越過葉節點後跳出\n    while cur is not None:\n        # 目標節點在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 目標節點在 cur 的左子樹中\n        elif cur.val &gt; num:\n            cur = cur.left\n        # 找到目標節點，跳出迴圈\n        else:\n            break\n    return cur\n</code></pre> binary_search_tree.cpp<pre><code>/* 查詢節點 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 目標節點在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur-&gt;val &gt; num)\n            cur = cur-&gt;left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.java<pre><code>/* 查詢節點 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 查詢節點 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur =\n            cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num)\n            cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else\n            break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.go<pre><code>/* 查詢節點 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // 迴圈查詢，越過葉節點後跳出\n    for node != nil {\n        if node.Val.(int) &lt; num {\n            // 目標節點在 cur 的右子樹中\n            node = node.Right\n        } else if node.Val.(int) &gt; num {\n            // 目標節點在 cur 的左子樹中\n            node = node.Left\n        } else {\n            // 找到目標節點，跳出迴圈\n            break\n        }\n    }\n    // 返回目標節點\n    return node\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 查詢節點 */\nfunc search(num: Int) -&gt; TreeNode? {\n    var cur = root\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 目標節點在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 目標節點在 cur 的左子樹中\n        else if cur!.val &gt; num {\n            cur = cur?.left\n        }\n        // 找到目標節點，跳出迴圈\n        else {\n            break\n        }\n    }\n    // 返回目標節點\n    return cur\n}\n</code></pre> binary_search_tree.js<pre><code>/* 查詢節點 */\nsearch(num) {\n    let cur = this.root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num) cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 查詢節點 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 目標節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 目標節點在 cur 的左子樹中\n        else if (cur.val &gt; num) cur = cur.left;\n        // 找到目標節點，跳出迴圈\n        else break;\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 查詢節點 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 目標節點在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 目標節點在 cur 的左子樹中\n    else if (cur.val &gt; _num)\n      cur = cur.left;\n    // 找到目標節點，跳出迴圈\n    else\n      break;\n  }\n  // 返回目標節點\n  return cur;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 查詢節點 */\npub fn search(&amp;self, num: i32) -&gt; OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 目標節點在 cur 的右子樹中\n            Ordering::Greater =&gt; cur = node.borrow().right.clone(),\n            // 目標節點在 cur 的左子樹中\n            Ordering::Less =&gt; cur = node.borrow().left.clone(),\n            // 找到目標節點，跳出迴圈\n            Ordering::Equal =&gt; break,\n        }\n    }\n\n    // 返回目標節點\n    cur\n}\n</code></pre> binary_search_tree.c<pre><code>/* 查詢節點 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst-&gt;root;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        if (cur-&gt;val &lt; num) {\n            // 目標節點在 cur 的右子樹中\n            cur = cur-&gt;right;\n        } else if (cur-&gt;val &gt; num) {\n            // 目標節點在 cur 的左子樹中\n            cur = cur-&gt;left;\n        } else {\n            // 找到目標節點，跳出迴圈\n            break;\n        }\n    }\n    // 返回目標節點\n    return cur;\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 查詢節點 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 目標節點在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 目標節點在 cur 的左子樹中\n        else if (cur._val &gt; num)\n            cur.left\n        // 找到目標節點，跳出迴圈\n        else\n            break\n    }\n    // 返回目標節點\n    return cur\n}\n</code></pre> binary_search_tree.rb<pre><code>### 查詢節點 ###\ndef search(num)\n  cur = @root\n\n  # 迴圈查詢，越過葉節點後跳出\n  while !cur.nil?\n    # 目標節點在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 目標節點在 cur 的左子樹中\n    elsif cur.val &gt; num\n      cur = cur.left\n    # 找到目標節點，跳出迴圈\n    else\n      break\n    end\n  end\n\n  cur\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#2","level":3,"title":"2.   插入節點","text":"<p>給定一個待插入元素 <code>num</code> ，為了保持二元搜尋樹“左子樹 &lt; 根節點 &lt; 右子樹”的性質，插入操作流程如圖 7-18 所示。</p> <ol> <li>查詢插入位置：與查詢操作相似，從根節點出發，根據當前節點值和 <code>num</code> 的大小關係迴圈向下搜尋，直到越過葉節點（走訪至 <code>None</code> ）時跳出迴圈。</li> <li>在該位置插入節點：初始化節點 <code>num</code> ，將該節點置於 <code>None</code> 的位置。</li> </ol> <p></p> <p> 圖 7-18   在二元搜尋樹中插入節點 </p> <p>在程式碼實現中，需要注意以下兩點。</p> <ul> <li>二元搜尋樹不允許存在重複節點，否則將違反其定義。因此，若待插入節點在樹中已存在，則不執行插入，直接返回。</li> <li>為了實現插入節點，我們需要藉助節點 <code>pre</code> 儲存上一輪迴圈的節點。這樣在走訪至 <code>None</code> 時，我們可以獲取到其父節點，從而完成節點插入操作。</li> </ul> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def insert(self, num: int):\n    \"\"\"插入節點\"\"\"\n    # 若樹為空，則初始化根節點\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # 迴圈查詢，越過葉節點後跳出\n    cur, pre = self._root, None\n    while cur is not None:\n        # 找到重複節點，直接返回\n        if cur.val == num:\n            return\n        pre = cur\n        # 插入位置在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 插入位置在 cur 的左子樹中\n        else:\n            cur = cur.left\n    # 插入節點\n    node = TreeNode(num)\n    if pre.val &lt; num:\n        pre.right = node\n    else:\n        pre.left = node\n</code></pre> binary_search_tree.cpp<pre><code>/* 插入節點 */\nvoid insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 找到重複節點，直接返回\n        if (cur-&gt;val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur-&gt;left;\n    }\n    // 插入節點\n    TreeNode *node = new TreeNode(num);\n    if (pre-&gt;val &lt; num)\n        pre-&gt;right = node;\n    else\n        pre-&gt;left = node;\n}\n</code></pre> binary_search_tree.java<pre><code>/* 插入節點 */\nvoid insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 插入節點\n    TreeNode node = new TreeNode(num);\n    if (pre.val &lt; num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 插入節點 */\nvoid Insert(int num) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n\n    // 插入節點\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val &lt; num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* 插入節點 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // 若樹為空，則初始化根節點\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // 待插入節點之前的節點位置\n    var pre *TreeNode = nil\n    // 迴圈查詢，越過葉節點後跳出\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // 插入節點\n    node := NewTreeNode(num)\n    if pre.Val.(int) &lt; num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 插入節點 */\nfunc insert(num: Int) {\n    // 若樹為空，則初始化根節點\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 找到重複節點，直接返回\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // 插入位置在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 插入位置在 cur 的左子樹中\n        else {\n            cur = cur?.left\n        }\n    }\n    // 插入節點\n    let node = TreeNode(x: num)\n    if pre!.val &lt; num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* 插入節點 */\ninsert(num) {\n    // 若樹為空，則初始化根節點\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到重複節點，直接返回\n        if (cur.val === num) return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 插入節點\n    const node = new TreeNode(num);\n    if (pre.val &lt; num) pre.right = node;\n    else pre.left = node;\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 插入節點 */\ninsert(num: number): void {\n    // 若樹為空，則初始化根節點\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到重複節點，直接返回\n        if (cur.val === num) return;\n        pre = cur;\n        // 插入位置在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 插入位置在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 插入節點\n    const node = new TreeNode(num);\n    if (pre!.val &lt; num) pre!.right = node;\n    else pre!.left = node;\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 插入節點 */\nvoid insert(int _num) {\n  // 若樹為空，則初始化根節點\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 找到重複節點，直接返回\n    if (cur.val == _num) return;\n    pre = cur;\n    // 插入位置在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 插入位置在 cur 的左子樹中\n    else\n      cur = cur.left;\n  }\n  // 插入節點\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val &lt; _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 插入節點 */\npub fn insert(&amp;mut self, num: i32) {\n    // 若樹為空，則初始化根節點\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 找到重複節點，直接返回\n            Ordering::Equal =&gt; return,\n            // 插入位置在 cur 的右子樹中\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 插入位置在 cur 的左子樹中\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 插入節點\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num &gt; pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().left = node;\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* 插入節點 */\nvoid insert(BinarySearchTree *bst, int num) {\n    // 若樹為空，則初始化根節點\n    if (bst-&gt;root == NULL) {\n        bst-&gt;root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        // 找到重複節點，直接返回\n        if (cur-&gt;val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 插入位置在 cur 的右子樹中\n            cur = cur-&gt;right;\n        } else {\n            // 插入位置在 cur 的左子樹中\n            cur = cur-&gt;left;\n        }\n    }\n    // 插入節點\n    TreeNode *node = newTreeNode(num);\n    if (pre-&gt;val &lt; num) {\n        pre-&gt;right = node;\n    } else {\n        pre-&gt;left = node;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 插入節點 */\nfun insert(num: Int) {\n    // 若樹為空，則初始化根節點\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到重複節點，直接返回\n        if (cur._val == num)\n            return\n        pre = cur\n        // 插入位置在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 插入位置在 cur 的左子樹中\n        else\n            cur.left\n    }\n    // 插入節點\n    val node = TreeNode(num)\n    if (pre?._val!! &lt; num)\n        pre.right = node\n    else\n        pre.left = node\n}\n</code></pre> binary_search_tree.rb<pre><code>### 插入節點 ###\ndef insert(num)\n  # 若樹為空，則初始化根節點\n  if @root.nil?\n    @root = TreeNode.new(num)\n    return\n  end\n\n  # 迴圈查詢，越過葉節點後跳出\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 找到重複節點，直接返回\n    return if cur.val == num\n\n    pre = cur\n    # 插入位置在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 插入位置在 cur 的左子樹中\n    else\n      cur = cur.left\n    end\n  end\n\n  # 插入節點\n  node = TreeNode.new(num)\n  if pre.val &lt; num\n    pre.right = node\n  else\n    pre.left = node\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>與查詢節點相同，插入節點使用 \\(O(\\log n)\\) 時間。</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#3","level":3,"title":"3.   刪除節點","text":"<p>先在二元樹中查詢到目標節點，再將其刪除。與插入節點類似，我們需要保證在刪除操作完成後，二元搜尋樹的“左子樹 &lt; 根節點 &lt; 右子樹”的性質仍然滿足。因此，我們根據目標節點的子節點數量，分 0、1 和 2 三種情況，執行對應的刪除節點操作。</p> <p>如圖 7-19 所示，當待刪除節點的度為 \\(0\\) 時，表示該節點是葉節點，可以直接刪除。</p> <p></p> <p> 圖 7-19   在二元搜尋樹中刪除節點（度為 0 ） </p> <p>如圖 7-20 所示，當待刪除節點的度為 \\(1\\) 時，將待刪除節點替換為其子節點即可。</p> <p></p> <p> 圖 7-20   在二元搜尋樹中刪除節點（度為 1 ） </p> <p>當待刪除節點的度為 \\(2\\) 時，我們無法直接刪除它，而需要使用一個節點替換該節點。由於要保持二元搜尋樹“左子樹 \\(&lt;\\) 根節點 \\(&lt;\\) 右子樹”的性質，因此這個節點可以是右子樹的最小節點或左子樹的最大節點。</p> <p>假設我們選擇右子樹的最小節點（中序走訪的下一個節點），則刪除操作流程如圖 7-21 所示。</p> <ol> <li>找到待刪除節點在“中序走訪序列”中的下一個節點，記為 <code>tmp</code> 。</li> <li>用 <code>tmp</code> 的值覆蓋待刪除節點的值，並在樹中遞迴刪除節點 <code>tmp</code> 。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt; <p></p> <p></p> <p></p> <p></p> <p> 圖 7-21   在二元搜尋樹中刪除節點（度為 2 ） </p> <p>刪除節點操作同樣使用 \\(O(\\log n)\\) 時間，其中查詢待刪除節點需要 \\(O(\\log n)\\) 時間，獲取中序走訪後繼節點需要 \\(O(\\log n)\\) 時間。示例程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_search_tree.py<pre><code>def remove(self, num: int):\n    \"\"\"刪除節點\"\"\"\n    # 若樹為空，直接提前返回\n    if self._root is None:\n        return\n    # 迴圈查詢，越過葉節點後跳出\n    cur, pre = self._root, None\n    while cur is not None:\n        # 找到待刪除節點，跳出迴圈\n        if cur.val == num:\n            break\n        pre = cur\n        # 待刪除節點在 cur 的右子樹中\n        if cur.val &lt; num:\n            cur = cur.right\n        # 待刪除節點在 cur 的左子樹中\n        else:\n            cur = cur.left\n    # 若無待刪除節點，則直接返回\n    if cur is None:\n        return\n\n    # 子節點數量 = 0 or 1\n    if cur.left is None or cur.right is None:\n        # 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        child = cur.left or cur.right\n        # 刪除節點 cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # 若刪除節點為根節點，則重新指定根節點\n            self._root = child\n    # 子節點數量 = 2\n    else:\n        # 獲取中序走訪中 cur 的下一個節點\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # 遞迴刪除節點 tmp\n        self.remove(tmp.val)\n        # 用 tmp 覆蓋 cur\n        cur.val = tmp.val\n</code></pre> binary_search_tree.cpp<pre><code>/* 刪除節點 */\nvoid remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != nullptr) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur-&gt;val &lt; num)\n            cur = cur-&gt;right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur-&gt;left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == nullptr)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur-&gt;left == nullptr || cur-&gt;right == nullptr) {\n        // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n        TreeNode *child = cur-&gt;left != nullptr ? cur-&gt;left : cur-&gt;right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre-&gt;left == cur)\n                pre-&gt;left = child;\n            else\n                pre-&gt;right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n        // 釋放記憶體\n        delete cur;\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != nullptr) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // 遞迴刪除節點 tmp\n        remove(tmp-&gt;val);\n        // 用 tmp 覆蓋 cur\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.java<pre><code>/* 刪除節點 */\nvoid remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        remove(tmp.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.cs<pre><code>/* 刪除節點 */\nvoid Remove(int num) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num)\n            cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return;\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        TreeNode? child = cur.left ?? cur.right;\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        Remove(tmp.val!.Value);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.go<pre><code>/* 刪除節點 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // 若樹為空，直接提前返回\n    if cur == nil {\n        return\n    }\n    // 待刪除節點之前的節點位置\n    var pre *TreeNode = nil\n    // 迴圈查詢，越過葉節點後跳出\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) &lt; num {\n            // 待刪除節點在右子樹中\n            cur = cur.Right\n        } else {\n            // 待刪除節點在左子樹中\n            cur = cur.Left\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur == nil {\n        return\n    }\n    // 子節點數為 0 或 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // 取出待刪除節點的子節點\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // 刪除節點 cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            bst.root = child\n        }\n        // 子節點數為 2\n    } else {\n        // 獲取中序走訪中待刪除節點 cur 的下一個節點\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // 遞迴刪除節點 tmp\n        bst.remove(tmp.Val.(int))\n        // 用 tmp 覆蓋 cur\n        cur.Val = tmp.Val\n    }\n}\n</code></pre> binary_search_tree.swift<pre><code>/* 刪除節點 */\nfunc remove(num: Int) {\n    // 若樹為空，直接提前返回\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // 迴圈查詢，越過葉節點後跳出\n    while cur != nil {\n        // 找到待刪除節點，跳出迴圈\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // 待刪除節點在 cur 的右子樹中\n        if cur!.val &lt; num {\n            cur = cur?.right\n        }\n        // 待刪除節點在 cur 的左子樹中\n        else {\n            cur = cur?.left\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur == nil {\n        return\n    }\n    // 子節點數量 = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        let child = cur?.left ?? cur?.right\n        // 刪除節點 cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // 遞迴刪除節點 tmp\n        remove(num: tmp!.val)\n        // 用 tmp 覆蓋 cur\n        cur?.val = tmp!.val\n    }\n}\n</code></pre> binary_search_tree.js<pre><code>/* 刪除節點 */\nremove(num) {\n    // 若樹為空，直接提前返回\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val === num) break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur === null) return;\n    // 子節點數量 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        const child = cur.left !== null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            this.root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // 遞迴刪除節點 tmp\n        this.remove(tmp.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp.val;\n    }\n}\n</code></pre> binary_search_tree.ts<pre><code>/* 刪除節點 */\nremove(num: number): void {\n    // 若樹為空，直接提前返回\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur !== null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur.val === num) break;\n        pre = cur;\n        // 待刪除節點在 cur 的右子樹中\n        if (cur.val &lt; num) cur = cur.right;\n        // 待刪除節點在 cur 的左子樹中\n        else cur = cur.left;\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur === null) return;\n    // 子節點數量 = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // 刪除節點 cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            this.root = child;\n        }\n    }\n    // 子節點數量 = 2\n    else {\n        // 獲取中序走訪中 cur 的下一個節點\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // 遞迴刪除節點 tmp\n        this.remove(tmp!.val);\n        // 用 tmp 覆蓋 cur\n        cur.val = tmp!.val;\n    }\n}\n</code></pre> binary_search_tree.dart<pre><code>/* 刪除節點 */\nvoid remove(int _num) {\n  // 若樹為空，直接提前返回\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // 迴圈查詢，越過葉節點後跳出\n  while (cur != null) {\n    // 找到待刪除節點，跳出迴圈\n    if (cur.val == _num) break;\n    pre = cur;\n    // 待刪除節點在 cur 的右子樹中\n    if (cur.val &lt; _num)\n      cur = cur.right;\n    // 待刪除節點在 cur 的左子樹中\n    else\n      cur = cur.left;\n  }\n  // 若無待刪除節點，直接返回\n  if (cur == null) return;\n  // 子節點數量 = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n    TreeNode? child = cur.left ?? cur.right;\n    // 刪除節點 cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // 若刪除節點為根節點，則重新指定根節點\n      _root = child;\n    }\n  } else {\n    // 子節點數量 = 2\n    // 獲取中序走訪中 cur 的下一個節點\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // 遞迴刪除節點 tmp\n    remove(tmp.val);\n    // 用 tmp 覆蓋 cur\n    cur.val = tmp.val;\n  }\n}\n</code></pre> binary_search_tree.rs<pre><code>/* 刪除節點 */\npub fn remove(&amp;mut self, num: i32) {\n    // 若樹為空，直接提前返回\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // 迴圈查詢，越過葉節點後跳出\n    while let Some(node) = cur.clone() {\n        match num.cmp(&amp;node.borrow().val) {\n            // 找到待刪除節點，跳出迴圈\n            Ordering::Equal =&gt; break,\n            // 待刪除節點在 cur 的右子樹中\n            Ordering::Greater =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // 待刪除節點在 cur 的左子樹中\n            Ordering::Less =&gt; {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // 子節點數量 = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) =&gt; {\n            // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // 刪除節點 cur\n            if !Rc::ptr_eq(&amp;cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() &amp;&amp; Rc::ptr_eq(left.as_ref().unwrap(), &amp;cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // 若刪除節點為根節點，則重新指定根節點\n                self.root = child;\n            }\n        }\n        // 子節點數量 = 2\n        (Some(_), Some(_)) =&gt; {\n            // 獲取中序走訪中 cur 的下一個節點\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmp_val = tmp.unwrap().borrow().val;\n            // 遞迴刪除節點 tmp\n            self.remove(tmp_val);\n            // 用 tmp 覆蓋 cur\n            cur.borrow_mut().val = tmp_val;\n        }\n    }\n}\n</code></pre> binary_search_tree.c<pre><code>/* 刪除節點 */\n// 由於引入了 stdio.h ，此處無法使用 remove 關鍵詞\nvoid removeItem(BinarySearchTree *bst, int num) {\n    // 若樹為空，直接提前返回\n    if (bst-&gt;root == NULL)\n        return;\n    TreeNode *cur = bst-&gt;root, *pre = NULL;\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != NULL) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur-&gt;val == num)\n            break;\n        pre = cur;\n        if (cur-&gt;val &lt; num) {\n            // 待刪除節點在 root 的右子樹中\n            cur = cur-&gt;right;\n        } else {\n            // 待刪除節點在 root 的左子樹中\n            cur = cur-&gt;left;\n        }\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == NULL)\n        return;\n    // 判斷待刪除節點是否存在子節點\n    if (cur-&gt;left == NULL || cur-&gt;right == NULL) {\n        /* 子節點數量 = 0 or 1 */\n        // 當子節點數量 = 0 / 1 時， child = nullptr / 該子節點\n        TreeNode *child = cur-&gt;left != NULL ? cur-&gt;left : cur-&gt;right;\n        // 刪除節點 cur\n        if (pre-&gt;left == cur) {\n            pre-&gt;left = child;\n        } else {\n            pre-&gt;right = child;\n        }\n        // 釋放記憶體\n        free(cur);\n    } else {\n        /* 子節點數量 = 2 */\n        // 獲取中序走訪中 cur 的下一個節點\n        TreeNode *tmp = cur-&gt;right;\n        while (tmp-&gt;left != NULL) {\n            tmp = tmp-&gt;left;\n        }\n        int tmpVal = tmp-&gt;val;\n        // 遞迴刪除節點 tmp\n        removeItem(bst, tmp-&gt;val);\n        // 用 tmp 覆蓋 cur\n        cur-&gt;val = tmpVal;\n    }\n}\n</code></pre> binary_search_tree.kt<pre><code>/* 刪除節點 */\nfun remove(num: Int) {\n    // 若樹為空，直接提前返回\n    if (root == null)\n        return\n    var cur = root\n    var pre: TreeNode? = null\n    // 迴圈查詢，越過葉節點後跳出\n    while (cur != null) {\n        // 找到待刪除節點，跳出迴圈\n        if (cur._val == num)\n            break\n        pre = cur\n        // 待刪除節點在 cur 的右子樹中\n        cur = if (cur._val &lt; num)\n            cur.right\n        // 待刪除節點在 cur 的左子樹中\n        else\n            cur.left\n    }\n    // 若無待刪除節點，則直接返回\n    if (cur == null)\n        return\n    // 子節點數量 = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // 當子節點數量 = 0 / 1 時， child = null / 該子節點\n        val child = if (cur.left != null)\n            cur.left\n        else\n            cur.right\n        // 刪除節點 cur\n        if (cur != root) {\n            if (pre!!.left == cur)\n                pre.left = child\n            else\n                pre.right = child\n        } else {\n            // 若刪除節點為根節點，則重新指定根節點\n            root = child\n        }\n        // 子節點數量 = 2\n    } else {\n        // 獲取中序走訪中 cur 的下一個節點\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // 遞迴刪除節點 tmp\n        remove(tmp._val)\n        // 用 tmp 覆蓋 cur\n        cur._val = tmp._val\n    }\n}\n</code></pre> binary_search_tree.rb<pre><code>### 刪除節點 ###\ndef remove(num)\n  # 若樹為空，直接提前返回\n  return if @root.nil?\n\n  # 迴圈查詢，越過葉節點後跳出\n  cur, pre = @root, nil\n  while !cur.nil?\n    # 找到待刪除節點，跳出迴圈\n    break if cur.val == num\n\n    pre = cur\n    # 待刪除節點在 cur 的右子樹中\n    if cur.val &lt; num\n      cur = cur.right\n    # 待刪除節點在 cur 的左子樹中\n    else\n      cur = cur.left\n    end\n  end\n  # 若無待刪除節點，則直接返回\n  return if cur.nil?\n\n  # 子節點數量 = 0 or 1\n  if cur.left.nil? || cur.right.nil?\n    # 當子節點數量 = 0 / 1 時， child = null / 該子節點\n    child = cur.left || cur.right\n    # 刪除節點 cur\n    if cur != @root\n      if pre.left == cur\n        pre.left = child\n      else\n        pre.right = child\n      end\n    else\n      # 若刪除節點為根節點，則重新指定根節點\n      @root = child\n    end\n  # 子節點數量 = 2\n  else\n    # 獲取中序走訪中 cur 的下一個節點\n    tmp = cur.right\n    while !tmp.left.nil?\n      tmp = tmp.left\n    end\n    # 遞迴刪除節點 tmp\n    remove(tmp.val)\n    # 用 tmp 覆蓋 cur\n    cur.val = tmp.val\n  end\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#4","level":3,"title":"4.   中序走訪有序","text":"<p>如圖 7-22 所示，二元樹的中序走訪遵循“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”的走訪順序，而二元搜尋樹滿足“左子節點 \\(&lt;\\) 根節點 \\(&lt;\\) 右子節點”的大小關係。</p> <p>這意味著在二元搜尋樹中進行中序走訪時，總是會優先走訪下一個最小節點，從而得出一個重要性質：二元搜尋樹的中序走訪序列是升序的。</p> <p>利用中序走訪升序的性質，我們在二元搜尋樹中獲取有序資料僅需 \\(O(n)\\) 時間，無須進行額外的排序操作，非常高效。</p> <p></p> <p> 圖 7-22   二元搜尋樹的中序走訪序列 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#742","level":2,"title":"7.4.2   二元搜尋樹的效率","text":"<p>給定一組資料，我們考慮使用陣列或二元搜尋樹儲存。觀察表 7-2 ，二元搜尋樹的各項操作的時間複雜度都是對數階，具有穩定且高效的效能。只有在高頻新增、低頻查詢刪除資料的場景下，陣列比二元搜尋樹的效率更高。</p> <p> 表 7-2   陣列與搜尋樹的效率對比 </p> 無序陣列 二元搜尋樹 查詢元素 \\(O(n)\\) \\(O(\\log n)\\) 插入元素 \\(O(1)\\) \\(O(\\log n)\\) 刪除元素 \\(O(n)\\) \\(O(\\log n)\\) <p>在理想情況下，二元搜尋樹是“平衡”的，這樣就可以在 \\(\\log n\\) 輪迴圈內查詢任意節點。</p> <p>然而，如果我們在二元搜尋樹中不斷地插入和刪除節點，可能導致二元樹退化為圖 7-23 所示的鏈結串列，這時各種操作的時間複雜度也會退化為 \\(O(n)\\) 。</p> <p></p> <p> 圖 7-23   二元搜尋樹退化 </p>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_search_tree/#743","level":2,"title":"7.4.3   二元搜尋樹常見應用","text":"<ul> <li>用作系統中的多級索引，實現高效的查詢、插入、刪除操作。</li> <li>作為某些搜尋演算法的底層資料結構。</li> <li>用於儲存資料流，以保持其有序狀態。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.4 &nbsp; 二元搜尋樹"],"tags":[]},{"location":"chapter_tree/binary_tree/","level":1,"title":"7.1   二元樹","text":"<p>二元樹（binary tree）是一種非線性資料結構，代表“祖先”與“後代”之間的派生關係，體現了“一分為二”的分治邏輯。與鏈結串列類似，二元樹的基本單元是節點，每個節點包含值、左子節點引用和右子節點引用。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby <pre><code>class TreeNode:\n    \"\"\"二元樹節點類別\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # 節點值\n        self.left: TreeNode | None = None  # 左子節點引用\n        self.right: TreeNode | None = None # 右子節點引用\n</code></pre> <pre><code>/* 二元樹節點結構體 */\nstruct TreeNode {\n    int val;          // 節點值\n    TreeNode *left;   // 左子節點指標\n    TreeNode *right;  // 右子節點指標\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    int val;         // 節點值\n    TreeNode left;   // 左子節點引用\n    TreeNode right;  // 右子節點引用\n    TreeNode(int x) { val = x; }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode(int? x) {\n    public int? val = x;    // 節點值\n    public TreeNode? left;  // 左子節點引用\n    public TreeNode? right; // 右子節點引用\n}\n</code></pre> <pre><code>/* 二元樹節點結構體 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* 建構子 */\nfunc NewTreeNode(v int) *TreeNode {\n    return &amp;TreeNode{\n        Left:  nil, // 左子節點指標\n        Right: nil, // 右子節點指標\n        Val:   v,   // 節點值\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    var val: Int // 節點值\n    var left: TreeNode? // 左子節點引用\n    var right: TreeNode? // 右子節點引用\n\n    init(x: Int) {\n        val = x\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    val; // 節點值\n    left; // 左子節點指標\n    right; // 右子節點指標\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // 節點值\n        this.left = left === undefined ? null : left; // 左子節點引用\n        this.right = right === undefined ? null : right; // 右子節點引用\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode {\n  int val;         // 節點值\n  TreeNode? left;  // 左子節點引用\n  TreeNode? right; // 右子節點引用\n  TreeNode(this.val, [this.left, this.right]);\n}\n</code></pre> <pre><code>use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* 二元樹節點結構體 */\nstruct TreeNode {\n    val: i32,                               // 節點值\n    left: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,    // 左子節點引用\n    right: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;,   // 右子節點引用\n}\n\nimpl TreeNode {\n    /* 建構子 */\n    fn new(val: i32) -&gt; Rc&lt;RefCell&lt;Self&gt;&gt; {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n</code></pre> <pre><code>/* 二元樹節點結構體 */\ntypedef struct TreeNode {\n    int val;                // 節點值\n    int height;             // 節點高度\n    struct TreeNode *left;  // 左子節點指標\n    struct TreeNode *right; // 右子節點指標\n} TreeNode;\n\n/* 建構子 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node-&gt;val = val;\n    node-&gt;height = 0;\n    node-&gt;left = NULL;\n    node-&gt;right = NULL;\n    return node;\n}\n</code></pre> <pre><code>/* 二元樹節點類別 */\nclass TreeNode(val _val: Int) {  // 節點值\n    val left: TreeNode? = null   // 左子節點引用\n    val right: TreeNode? = null  // 右子節點引用\n}\n</code></pre> <pre><code>### 二元樹節點類別 ###\nclass TreeNode\n  attr_accessor :val    # 節點值\n  attr_accessor :left   # 左子節點引用\n  attr_accessor :right  # 右子節點引用\n\n  def initialize(val)\n    @val = val\n  end\nend\n</code></pre> <p>每個節點都有兩個引用（指標），分別指向左子節點（left-child node）和右子節點（right-child node），該節點被稱為這兩個子節點的父節點（parent node）。當給定一個二元樹的節點時，我們將該節點的左子節點及其以下節點形成的樹稱為該節點的左子樹（left subtree），同理可得右子樹（right subtree）。</p> <p>在二元樹中，除葉節點外，其他所有節點都包含子節點和非空子樹。如圖 7-1 所示，如果將“節點 2”視為父節點，則其左子節點和右子節點分別是“節點 4”和“節點 5”，左子樹是“節點 4 及其以下節點形成的樹”，右子樹是“節點 5 及其以下節點形成的樹”。</p> <p></p> <p> 圖 7-1   父節點、子節點、子樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#711","level":2,"title":"7.1.1   二元樹常見術語","text":"<p>二元樹的常用術語如圖 7-2 所示。</p> <ul> <li>根節點（root node）：位於二元樹頂層的節點，沒有父節點。</li> <li>葉節點（leaf node）：沒有子節點的節點，其兩個指標均指向 <code>None</code> 。</li> <li>邊（edge）：連線兩個節點的線段，即節點引用（指標）。</li> <li>節點所在的層（level）：從頂至底遞增，根節點所在層為 1 。</li> <li>節點的度（degree）：節點的子節點的數量。在二元樹中，度的取值範圍是 0、1、2 。</li> <li>二元樹的高度（height）：從根節點到最遠葉節點所經過的邊的數量。</li> <li>節點的深度（depth）：從根節點到該節點所經過的邊的數量。</li> <li>節點的高度（height）：從距離該節點最遠的葉節點到該節點所經過的邊的數量。</li> </ul> <p></p> <p> 圖 7-2   二元樹的常用術語 </p> <p>Tip</p> <p>請注意，我們通常將“高度”和“深度”定義為“經過的邊的數量”，但有些題目或教材可能會將其定義為“經過的節點的數量”。在這種情況下，高度和深度都需要加 1 。</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#712","level":2,"title":"7.1.2   二元樹基本操作","text":"","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#1","level":3,"title":"1.   初始化二元樹","text":"<p>與鏈結串列類似，首先初始化節點，然後構建引用（指標）。</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 初始化二元樹\n# 初始化節點\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.cpp<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.java<pre><code>// 初始化節點\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.cs<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.go<pre><code>/* 初始化二元樹 */\n// 初始化節點\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// 構建節點之間的引用（指標）\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n</code></pre> binary_tree.swift<pre><code>// 初始化節點\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.js<pre><code>/* 初始化二元樹 */\n// 初始化節點\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.ts<pre><code>/* 初始化二元樹 */\n// 初始化節點\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.dart<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// 構建節點之間的引用（指標）\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n</code></pre> binary_tree.rs<pre><code>// 初始化節點\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// 構建節點之間的引用（指標）\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n</code></pre> binary_tree.c<pre><code>/* 初始化二元樹 */\n// 初始化節點\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// 構建節點之間的引用（指標）\nn1-&gt;left = n2;\nn1-&gt;right = n3;\nn2-&gt;left = n4;\nn2-&gt;right = n5;\n</code></pre> binary_tree.kt<pre><code>// 初始化節點\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> binary_tree.rb<pre><code># 初始化二元樹\n# 初始化節點\nn1 = TreeNode.new(1)\nn2 = TreeNode.new(2)\nn3 = TreeNode.new(3)\nn4 = TreeNode.new(4)\nn5 = TreeNode.new(5)\n# 構建節點之間的引用（指標）\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#2","level":3,"title":"2.   插入與刪除節點","text":"<p>與鏈結串列類似，在二元樹中插入與刪除節點可以透過修改指標來實現。圖 7-3 給出了一個示例。</p> <p></p> <p> 圖 7-3   在二元樹中插入與刪除節點 </p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree.py<pre><code># 插入與刪除節點\np = TreeNode(0)\n# 在 n1 -&gt; n2 中間插入節點 P\nn1.left = p\np.left = n2\n# 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.cpp<pre><code>/* 插入與刪除節點 */\nTreeNode* P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1-&gt;left = P;\nP-&gt;left = n2;\n// 刪除節點 P\nn1-&gt;left = n2;\n// 釋放記憶體\ndelete P;\n</code></pre> binary_tree.java<pre><code>TreeNode P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.cs<pre><code>/* 插入與刪除節點 */\nTreeNode P = new(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.go<pre><code>/* 插入與刪除節點 */\n// 在 n1 -&gt; n2 中間插入節點 P\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// 刪除節點 P\nn1.Left = n2\n</code></pre> binary_tree.swift<pre><code>let P = TreeNode(x: 0)\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P\nP.left = n2\n// 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.js<pre><code>/* 插入與刪除節點 */\nlet P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.ts<pre><code>/* 插入與刪除節點 */\nconst P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.dart<pre><code>/* 插入與刪除節點 */\nTreeNode P = new TreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P;\nP.left = n2;\n// 刪除節點 P\nn1.left = n2;\n</code></pre> binary_tree.rs<pre><code>let p = TreeNode::new(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// 刪除節點 p\nn1.borrow_mut().left = Some(n2);\n</code></pre> binary_tree.c<pre><code>/* 插入與刪除節點 */\nTreeNode *P = newTreeNode(0);\n// 在 n1 -&gt; n2 中間插入節點 P\nn1-&gt;left = P;\nP-&gt;left = n2;\n// 刪除節點 P\nn1-&gt;left = n2;\n// 釋放記憶體\nfree(P);\n</code></pre> binary_tree.kt<pre><code>val P = TreeNode(0)\n// 在 n1 -&gt; n2 中間插入節點 P\nn1.left = P\nP.left = n2\n// 刪除節點 P\nn1.left = n2\n</code></pre> binary_tree.rb<pre><code># 插入與刪除節點\n_p = TreeNode.new(0)\n# 在 n1 -&gt; n2 中間插入節點 _p\nn1.left = _p\n_p.left = n2\n# 刪除節點\nn1.left = n2\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>需要注意的是，插入節點可能會改變二元樹的原有邏輯結構，而刪除節點通常意味著刪除該節點及其所有子樹。因此，在二元樹中，插入與刪除通常是由一套操作配合完成的，以實現有實際意義的操作。</p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#713","level":2,"title":"7.1.3   常見二元樹型別","text":"","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#1_1","level":3,"title":"1.   完美二元樹","text":"<p>如圖 7-4 所示，完美二元樹（perfect binary tree）所有層的節點都被完全填滿。在完美二元樹中，葉節點的度為 \\(0\\) ，其餘所有節點的度都為 \\(2\\) ；若樹的高度為 \\(h\\) ，則節點總數為 \\(2^{h+1} - 1\\) ，呈現標準的指數級關係，反映了自然界中常見的細胞分裂現象。</p> <p>Tip</p> <p>請注意，在中文社群中，完美二元樹常被稱為滿二元樹。</p> <p></p> <p> 圖 7-4   完美二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#2_1","level":3,"title":"2.   完全二元樹","text":"<p>如圖 7-5 所示，完全二元樹（complete binary tree）僅允許最底層的節點不完全填滿，且最底層的節點必須從左至右依次連續填充。請注意，完美二元樹也是一棵完全二元樹。</p> <p></p> <p> 圖 7-5   完全二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#3","level":3,"title":"3.   完滿二元樹","text":"<p>如圖 7-6 所示，完滿二元樹（full binary tree）除了葉節點之外，其餘所有節點都有兩個子節點。</p> <p></p> <p> 圖 7-6   完滿二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#4","level":3,"title":"4.   平衡二元樹","text":"<p>如圖 7-7 所示，平衡二元樹（balanced binary tree）中任意節點的左子樹和右子樹的高度之差的絕對值不超過 1 。</p> <p></p> <p> 圖 7-7   平衡二元樹 </p>","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree/#714","level":2,"title":"7.1.4   二元樹的退化","text":"<p>圖 7-8 展示了二元樹的理想結構與退化結構。當二元樹的每層節點都被填滿時，達到“完美二元樹”；而當所有節點都偏向一側時，二元樹退化為“鏈結串列”。</p> <ul> <li>完美二元樹是理想情況，可以充分發揮二元樹“分治”的優勢。</li> <li>鏈結串列則是另一個極端，各項操作都變為線性操作，時間複雜度退化至 \\(O(n)\\) 。</li> </ul> <p></p> <p> 圖 7-8   二元樹的最佳結構與最差結構 </p> <p>如表 7-1 所示，在最佳結構和最差結構下，二元樹的葉節點數量、節點總數、高度等達到極大值或極小值。</p> <p> 表 7-1   二元樹的最佳結構與最差結構 </p> 完美二元樹 鏈結串列 第 \\(i\\) 層的節點數量 \\(2^{i-1}\\) \\(1\\) 高度為 \\(h\\) 的樹的葉節點數量 \\(2^h\\) \\(1\\) 高度為 \\(h\\) 的樹的節點總數 \\(2^{h+1} - 1\\) \\(h + 1\\) 節點總數為 \\(n\\) 的樹的高度 \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)","path":["第 7 章 &nbsp; 樹","7.1 &nbsp; 二元樹"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/","level":1,"title":"7.2   二元樹走訪","text":"<p>從物理結構的角度來看，樹是一種基於鏈結串列的資料結構，因此其走訪方式是透過指標逐個訪問節點。然而，樹是一種非線性資料結構，這使得走訪樹比走訪鏈結串列更加複雜，需要藉助搜尋演算法來實現。</p> <p>二元樹常見的走訪方式包括層序走訪、前序走訪、中序走訪和後序走訪等。</p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#721","level":2,"title":"7.2.1   層序走訪","text":"<p>如圖 7-9 所示，層序走訪（level-order traversal）從頂部到底部逐層走訪二元樹，並在每一層按照從左到右的順序訪問節點。</p> <p>層序走訪本質上屬於廣度優先走訪（breadth-first traversal），也稱廣度優先搜尋（breadth-first search, BFS），它體現了一種“一圈一圈向外擴展”的逐層走訪方式。</p> <p></p> <p> 圖 7-9   二元樹的層序走訪 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1","level":3,"title":"1.   程式碼實現","text":"<p>廣度優先走訪通常藉助“佇列”來實現。佇列遵循“先進先出”的規則，而廣度優先走訪則遵循“逐層推進”的規則，兩者背後的思想是一致的。實現程式碼如下：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_bfs.py<pre><code>def level_order(root: TreeNode | None) -&gt; list[int]:\n    \"\"\"層序走訪\"\"\"\n    # 初始化佇列，加入根節點\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # 初始化一個串列，用於儲存走訪序列\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # 隊列出隊\n        res.append(node.val)  # 儲存節點值\n        if node.left is not None:\n            queue.append(node.left)  # 左子節點入列\n        if node.right is not None:\n            queue.append(node.right)  # 右子節點入列\n    return res\n</code></pre> binary_tree_bfs.cpp<pre><code>/* 層序走訪 */\nvector&lt;int&gt; levelOrder(TreeNode *root) {\n    // 初始化佇列，加入根節點\n    queue&lt;TreeNode *&gt; queue;\n    queue.push(root);\n    // 初始化一個串列，用於儲存走訪序列\n    vector&lt;int&gt; vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // 隊列出隊\n        vec.push_back(node-&gt;val); // 儲存節點值\n        if (node-&gt;left != nullptr)\n            queue.push(node-&gt;left); // 左子節點入列\n        if (node-&gt;right != nullptr)\n            queue.push(node-&gt;right); // 右子節點入列\n    }\n    return vec;\n}\n</code></pre> binary_tree_bfs.java<pre><code>/* 層序走訪 */\nList&lt;Integer&gt; levelOrder(TreeNode root) {\n    // 初始化佇列，加入根節點\n    Queue&lt;TreeNode&gt; queue = new LinkedList&lt;&gt;();\n    queue.add(root);\n    // 初始化一個串列，用於儲存走訪序列\n    List&lt;Integer&gt; list = new ArrayList&lt;&gt;();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // 隊列出隊\n        list.add(node.val);           // 儲存節點值\n        if (node.left != null)\n            queue.offer(node.left);   // 左子節點入列\n        if (node.right != null)\n            queue.offer(node.right);  // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.cs<pre><code>/* 層序走訪 */\nList&lt;int&gt; LevelOrder(TreeNode root) {\n    // 初始化佇列，加入根節點\n    Queue&lt;TreeNode&gt; queue = new();\n    queue.Enqueue(root);\n    // 初始化一個串列，用於儲存走訪序列\n    List&lt;int&gt; list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // 隊列出隊\n        list.Add(node.val!.Value);       // 儲存節點值\n        if (node.left != null)\n            queue.Enqueue(node.left);    // 左子節點入列\n        if (node.right != null)\n            queue.Enqueue(node.right);   // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.go<pre><code>/* 層序走訪 */\nfunc levelOrder(root *TreeNode) []any {\n    // 初始化佇列，加入根節點\n    queue := list.New()\n    queue.PushBack(root)\n    // 初始化一個切片，用於儲存走訪序列\n    nums := make([]any, 0)\n    for queue.Len() &gt; 0 {\n        // 隊列出隊\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // 儲存節點值\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // 左子節點入列\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // 右子節點入列\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\n}\n</code></pre> binary_tree_bfs.swift<pre><code>/* 層序走訪 */\nfunc levelOrder(root: TreeNode) -&gt; [Int] {\n    // 初始化佇列，加入根節點\n    var queue: [TreeNode] = [root]\n    // 初始化一個串列，用於儲存走訪序列\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // 隊列出隊\n        list.append(node.val) // 儲存節點值\n        if let left = node.left {\n            queue.append(left) // 左子節點入列\n        }\n        if let right = node.right {\n            queue.append(right) // 右子節點入列\n        }\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.js<pre><code>/* 層序走訪 */\nfunction levelOrder(root) {\n    // 初始化佇列，加入根節點\n    const queue = [root];\n    // 初始化一個串列，用於儲存走訪序列\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // 隊列出隊\n        list.push(node.val); // 儲存節點值\n        if (node.left) queue.push(node.left); // 左子節點入列\n        if (node.right) queue.push(node.right); // 右子節點入列\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.ts<pre><code>/* 層序走訪 */\nfunction levelOrder(root: TreeNode | null): number[] {\n    // 初始化佇列，加入根節點\n    const queue = [root];\n    // 初始化一個串列，用於儲存走訪序列\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // 隊列出隊\n        list.push(node.val); // 儲存節點值\n        if (node.left) {\n            queue.push(node.left); // 左子節點入列\n        }\n        if (node.right) {\n            queue.push(node.right); // 右子節點入列\n        }\n    }\n    return list;\n}\n</code></pre> binary_tree_bfs.dart<pre><code>/* 層序走訪 */\nList&lt;int&gt; levelOrder(TreeNode? root) {\n  // 初始化佇列，加入根節點\n  Queue&lt;TreeNode?&gt; queue = Queue();\n  queue.add(root);\n  // 初始化一個串列，用於儲存走訪序列\n  List&lt;int&gt; res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // 隊列出隊\n    res.add(node!.val); // 儲存節點值\n    if (node.left != null) queue.add(node.left); // 左子節點入列\n    if (node.right != null) queue.add(node.right); // 右子節點入列\n  }\n  return res;\n}\n</code></pre> binary_tree_bfs.rs<pre><code>/* 層序走訪 */\nfn level_order(root: &amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    // 初始化佇列，加入根節點\n    let mut que = VecDeque::new();\n    que.push_back(root.clone());\n    // 初始化一個串列，用於儲存走訪序列\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // 隊列出隊\n        vec.push(node.borrow().val); // 儲存節點值\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(left.clone()); // 左子節點入列\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(right.clone()); // 右子節點入列\n        };\n    }\n    vec\n}\n</code></pre> binary_tree_bfs.c<pre><code>/* 層序走訪 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* 輔助佇列 */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* 輔助佇列 */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // 佇列指標\n    front = 0, rear = 0;\n    // 加入根節點\n    queue[rear++] = root;\n    // 初始化一個串列，用於儲存走訪序列\n    /* 輔助陣列 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // 陣列指標\n    index = 0;\n    while (front &lt; rear) {\n        // 隊列出隊\n        node = queue[front++];\n        // 儲存節點值\n        arr[index++] = node-&gt;val;\n        if (node-&gt;left != NULL) {\n            // 左子節點入列\n            queue[rear++] = node-&gt;left;\n        }\n        if (node-&gt;right != NULL) {\n            // 右子節點入列\n            queue[rear++] = node-&gt;right;\n        }\n    }\n    // 更新陣列長度的值\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // 釋放輔助陣列空間\n    free(queue);\n    return arr;\n}\n</code></pre> binary_tree_bfs.kt<pre><code>/* 層序走訪 */\nfun levelOrder(root: TreeNode?): MutableList&lt;Int&gt; {\n    // 初始化佇列，加入根節點\n    val queue = LinkedList&lt;TreeNode?&gt;()\n    queue.add(root)\n    // 初始化一個串列，用於儲存走訪序列\n    val list = mutableListOf&lt;Int&gt;()\n    while (queue.isNotEmpty()) {\n        val node = queue.poll()      // 隊列出隊\n        list.add(node?._val!!)       // 儲存節點值\n        if (node.left != null)\n            queue.offer(node.left)   // 左子節點入列\n        if (node.right != null)\n            queue.offer(node.right)  // 右子節點入列\n    }\n    return list\n}\n</code></pre> binary_tree_bfs.rb<pre><code>### 層序走訪 ###\ndef level_order(root)\n  # 初始化佇列，加入根節點\n  queue = [root]\n  # 初始化一個串列，用於儲存走訪序列\n  res = []\n  while !queue.empty?\n    node = queue.shift # 隊列出隊\n    res &lt;&lt; node.val # 儲存節點值\n    queue &lt;&lt; node.left unless node.left.nil? # 左子節點入列\n    queue &lt;&lt; node.right unless node.right.nil? # 右子節點入列\n  end\n  res\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2","level":3,"title":"2.   複雜度分析","text":"<ul> <li>時間複雜度為 \\(O(n)\\) ：所有節點被訪問一次，使用 \\(O(n)\\) 時間，其中 \\(n\\) 為節點數量。</li> <li>空間複雜度為 \\(O(n)\\) ：在最差情況下，即滿二元樹時，走訪到最底層之前，佇列中最多同時存在 \\((n + 1) / 2\\) 個節點，佔用 \\(O(n)\\) 空間。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#722","level":2,"title":"7.2.2   前序、中序、後序走訪","text":"<p>相應地，前序、中序和後序走訪都屬於深度優先走訪（depth-first traversal），也稱深度優先搜尋（depth-first search, DFS），它體現了一種“先走到盡頭，再回溯繼續”的走訪方式。</p> <p>圖 7-10 展示了對二元樹進行深度優先走訪的工作原理。深度優先走訪就像是繞著整棵二元樹的外圍“走”一圈，在每個節點都會遇到三個位置，分別對應前序走訪、中序走訪和後序走訪。</p> <p></p> <p> 圖 7-10   二元搜尋樹的前序、中序、後序走訪 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#1_1","level":3,"title":"1.   程式碼實現","text":"<p>深度優先搜尋通常基於遞迴實現：</p> PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby binary_tree_dfs.py<pre><code>def pre_order(root: TreeNode | None):\n    \"\"\"前序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"中序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"後序走訪\"\"\"\n    if root is None:\n        return\n    # 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n</code></pre> binary_tree_dfs.cpp<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    vec.push_back(root-&gt;val);\n    preOrder(root-&gt;left);\n    preOrder(root-&gt;right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root-&gt;left);\n    vec.push_back(root-&gt;val);\n    inOrder(root-&gt;right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root-&gt;left);\n    postOrder(root-&gt;right);\n    vec.push_back(root-&gt;val);\n}\n</code></pre> binary_tree_dfs.java<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n</code></pre> binary_tree_dfs.cs<pre><code>/* 前序走訪 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* 中序走訪 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* 後序走訪 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n</code></pre> binary_tree_dfs.go<pre><code>/* 前序走訪 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* 中序走訪 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* 後序走訪 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n</code></pre> binary_tree_dfs.swift<pre><code>/* 前序走訪 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* 中序走訪 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* 後序走訪 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n</code></pre> binary_tree_dfs.js<pre><code>/* 前序走訪 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.ts<pre><code>/* 前序走訪 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* 中序走訪 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* 後序走訪 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n</code></pre> binary_tree_dfs.dart<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n</code></pre> binary_tree_dfs.rs<pre><code>/* 前序走訪 */\nfn pre_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n            let node = node.borrow();\n            res.push(node.val);\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 中序走訪 */\nfn in_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            res.push(node.val);\n            dfs(node.right.as_ref(), res);\n        }\n    }\n    dfs(root, &amp;mut result);\n\n    result\n}\n\n/* 後序走訪 */\nfn post_order(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -&gt; Vec&lt;i32&gt; {\n    let mut result = vec![];\n\n    fn dfs(root: Option&lt;&amp;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;, res: &amp;mut Vec&lt;i32&gt;) {\n        if let Some(node) = root {\n            // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n            let node = node.borrow();\n            dfs(node.left.as_ref(), res);\n            dfs(node.right.as_ref(), res);\n            res.push(node.val);\n        }\n    }\n\n    dfs(root, &amp;mut result);\n\n    result\n}\n</code></pre> binary_tree_dfs.c<pre><code>/* 前序走訪 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    arr[(*size)++] = root-&gt;val;\n    preOrder(root-&gt;left, size);\n    preOrder(root-&gt;right, size);\n}\n\n/* 中序走訪 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root-&gt;left, size);\n    arr[(*size)++] = root-&gt;val;\n    inOrder(root-&gt;right, size);\n}\n\n/* 後序走訪 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root-&gt;left, size);\n    postOrder(root-&gt;right, size);\n    arr[(*size)++] = root-&gt;val;\n}\n</code></pre> binary_tree_dfs.kt<pre><code>/* 前序走訪 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n    list.add(root._val)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* 中序走訪 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n    inOrder(root.left)\n    list.add(root._val)\n    inOrder(root.right)\n}\n\n/* 後序走訪 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root._val)\n}\n</code></pre> binary_tree_dfs.rb<pre><code>### 前序走訪 ###\ndef pre_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：根節點 -&gt; 左子樹 -&gt; 右子樹\n  $res &lt;&lt; root.val\n  pre_order(root.left)\n  pre_order(root.right)\nend\n\n### 中序走訪 ###\ndef in_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：左子樹 -&gt; 根節點 -&gt; 右子樹\n  in_order(root.left)\n  $res &lt;&lt; root.val\n  in_order(root.right)\nend\n\n### 後序走訪 ###\ndef post_order(root)\n  return if root.nil?\n\n  # 訪問優先順序：左子樹 -&gt; 右子樹 -&gt; 根節點\n  post_order(root.left)\n  post_order(root.right)\n  $res &lt;&lt; root.val\nend\n</code></pre> 視覺化執行 <p> 全螢幕觀看 &gt;</p> <p>Tip</p> <p>深度優先搜尋也可以基於迭代實現，有興趣的讀者可以自行研究。</p> <p>圖 7-11 展示了前序走訪二元樹的遞迴過程，其可分為“遞”和“迴”兩個逆向的部分。</p> <ol> <li>“遞”表示開啟新方法，程式在此過程中訪問下一個節點。</li> <li>“迴”表示函式返回，代表當前節點已經訪問完畢。</li> </ol> &lt;1&gt;&lt;2&gt;&lt;3&gt;&lt;4&gt;&lt;5&gt;&lt;6&gt;&lt;7&gt;&lt;8&gt;&lt;9&gt;&lt;10&gt;&lt;11&gt; <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p></p> <p> 圖 7-11   前序走訪的遞迴過程 </p>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/binary_tree_traversal/#2_1","level":3,"title":"2.   複雜度分析","text":"<ul> <li>時間複雜度為 \\(O(n)\\) ：所有節點被訪問一次，使用 \\(O(n)\\) 時間。</li> <li>空間複雜度為 \\(O(n)\\) ：在最差情況下，即樹退化為鏈結串列時，遞迴深度達到 \\(n\\) ，系統佔用 \\(O(n)\\) 堆疊幀空間。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.2 &nbsp; 二元樹走訪"],"tags":[]},{"location":"chapter_tree/summary/","level":1,"title":"7.6   小結","text":"","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/summary/#1","level":3,"title":"1.   重點回顧","text":"<ul> <li>二元樹是一種非線性資料結構，體現“一分為二”的分治邏輯。每個二元樹節點包含一個值以及兩個指標，分別指向其左子節點和右子節點。</li> <li>對於二元樹中的某個節點，其左（右）子節點及其以下形成的樹被稱為該節點的左（右）子樹。</li> <li>二元樹的相關術語包括根節點、葉節點、層、度、邊、高度和深度等。</li> <li>二元樹的初始化、節點插入和節點刪除操作與鏈結串列操作方法類似。</li> <li>常見的二元樹型別有完美二元樹、完全二元樹、完滿二元樹和平衡二元樹。完美二元樹是最理想的狀態，而鏈結串列是退化後的最差狀態。</li> <li>二元樹可以用陣列表示，方法是將節點值和空位按層序走訪順序排列，並根據父節點與子節點之間的索引對映關係來實現指標。</li> <li>二元樹的層序走訪是一種廣度優先搜尋方法，它體現了“一圈一圈向外擴展”的逐層走訪方式，通常透過佇列來實現。</li> <li>前序、中序、後序走訪皆屬於深度優先搜尋，它們體現了“先走到盡頭，再回溯繼續”的走訪方式，通常使用遞迴來實現。</li> <li>二元搜尋樹是一種高效的元素查詢資料結構，其查詢、插入和刪除操作的時間複雜度均為 \\(O(\\log n)\\) 。當二元搜尋樹退化為鏈結串列時，各項時間複雜度會劣化至 \\(O(n)\\) 。</li> <li>AVL 樹，也稱平衡二元搜尋樹，它透過旋轉操作確保在不斷插入和刪除節點後樹仍然保持平衡。</li> <li>AVL 樹的旋轉操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或刪除節點後，AVL 樹會從底向頂執行旋轉操作，使樹重新恢復平衡。</li> </ul>","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]},{"location":"chapter_tree/summary/#2-q-a","level":3,"title":"2.   Q &amp; A","text":"<p>Q：對於只有一個節點的二元樹，樹的高度和根節點的深度都是 \\(0\\) 嗎？</p> <p>是的，因為高度和深度通常定義為“經過的邊的數量”。</p> <p>Q：二元樹中的插入與刪除一般由一套操作配合完成，這裡的“一套操作”指什麼呢？可以理解為資源的子節點的資源釋放嗎？</p> <p>拿二元搜尋樹來舉例，刪除節點操作要分三種情況處理，其中每種情況都需要進行多個步驟的節點操作。</p> <p>Q：為什麼 DFS 走訪二元樹有前、中、後三種順序，分別有什麼用呢？</p> <p>與順序和逆序走訪陣列類似，前序、中序、後序走訪是三種二元樹走訪方法，我們可以使用它們得到一個特定順序的走訪結果。例如在二元搜尋樹中，由於節點大小滿足 <code>左子節點值 &lt; 根節點值 &lt; 右子節點值</code> ，因此我們只要按照“左 \\(\\rightarrow\\) 根 \\(\\rightarrow\\) 右”的優先順序走訪樹，就可以獲得有序的節點序列。</p> <p>Q：右旋操作是處理失衡節點 <code>node</code>、<code>child</code>、<code>grand_child</code> 之間的關係，那 <code>node</code> 的父節點和 <code>node</code> 原來的連線不需要維護嗎？右旋操作後豈不是斷掉了？</p> <p>我們需要從遞迴的視角來看這個問題。右旋操作 <code>right_rotate(root)</code> 傳入的是子樹的根節點，最終 <code>return child</code> 返回旋轉之後的子樹的根節點。子樹的根節點和其父節點的連線是在該函式返回後完成的，不屬於右旋操作的維護範圍。</p> <p>Q：在 C++ 中，函式被劃分到 <code>private</code> 和 <code>public</code> 中，這方面有什麼考量嗎？為什麼要將 <code>height()</code> 函式和 <code>updateHeight()</code> 函式分別放在 <code>public</code> 和 <code>private</code> 中呢？</p> <p>主要看方法的使用範圍，如果方法只在類別內部使用，那麼就設計為 <code>private</code> 。例如，使用者單獨呼叫 <code>updateHeight()</code> 是沒有意義的，它只是插入、刪除操作中的一步。而 <code>height()</code> 是訪問節點高度，類似於 <code>vector.size()</code> ，因此設定成 <code>public</code> 以便使用。</p> <p>Q：如何從一組輸入資料構建一棵二元搜尋樹？根節點的選擇是不是很重要？</p> <p>是的，構建樹的方法已在二元搜尋樹程式碼中的 <code>build_tree()</code> 方法中給出。至於根節點的選擇，我們通常會將輸入資料排序，然後將中點元素作為根節點，再遞迴地構建左右子樹。這樣做可以最大程度保證樹的平衡性。</p> <p>Q：在 Java 中，字串對比是否一定要用 <code>equals()</code> 方法？</p> <p>在 Java 中，對於基本資料型別，<code>==</code> 用於對比兩個變數的值是否相等。對於引用型別，兩種符號的工作原理是不同的。</p> <ul> <li><code>==</code> ：用來比較兩個變數是否指向同一個物件，即它們在記憶體中的位置是否相同。</li> <li><code>equals()</code>：用來對比兩個物件的值是否相等。</li> </ul> <p>因此，如果要對比值，我們應該使用 <code>equals()</code> 。然而，透過 <code>String a = \"hi\"; String b = \"hi\";</code> 初始化的字串都儲存在字串常數池中，它們指向同一個物件，因此也可以用 <code>a == b</code> 來比較兩個字串的內容。</p> <p>Q：廣度優先走訪到最底層之前，佇列中的節點數量是 \\(2^h\\) 嗎？</p> <p>是的，例如高度 \\(h = 2\\) 的滿二元樹，其節點總數 \\(n = 7\\) ，則底層節點數量 \\(4 = 2^h = (n + 1) / 2\\) 。</p>","path":["第 7 章 &nbsp; 樹","7.6 &nbsp; 小結"],"tags":[]}]}
\ No newline at end of file
diff --git a/zh-hant/stylesheets/extra.css b/zh-hant/stylesheets/extra.css
index fe7c5f8f1..6947b6f7c 100644
--- a/zh-hant/stylesheets/extra.css
+++ b/zh-hant/stylesheets/extra.css
@@ -1,4 +1,4 @@
-/* Color Settings */
+/* Theme tokens */
 /* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
 /* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
 :root>* {
@@ -14,21 +14,23 @@
   --md-code-fg-color: #1d1d20;
   --md-code-bg-color: #f5f5f5;
 
-  --md-accent-fg-color: #999;
-
   --md-typeset-color: #1d1d20;
   --md-typeset-a-color: #349890;
 
+  --md-accent-fg-color: var(--md-typeset-a-color);
+
   --md-typeset-btn-color: #55aea6;
   --md-typeset-btn-hover-color: #52bbb1;
 
   --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
-  --md-admonition-pythontutor-color: #eee;
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+
+  --hello-algo-sidebar-width: 13rem;
 }
 
 [data-md-color-scheme="slate"] {
-  --theme-dark-base: #1E1E1E;
-  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-base: #1e1e1e;
+  --theme-dark-mantle: #1a1a1a;
   --theme-dark-crust: #171717;
   --hero-starfield-bg-color: var(--theme-dark-base);
 
@@ -37,25 +39,25 @@
 
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: var(--theme-dark-base);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
 
-  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-body-bg-color: var(--md-default-bg-color);
   --md-header-bg-color: rgba(26, 26, 26, 0.8);
 
   --md-code-fg-color: #adbac7;
   --md-code-bg-color: var(--theme-dark-crust);
 
-  --md-accent-fg-color: #aaa;
-
-  --md-footer-fg-color: #adbac7;
-  --md-footer-bg-color: var(--theme-dark-mantle);
-
   --md-typeset-color: #adbac7;
   --md-typeset-a-color: #52bbb1;
+  --md-accent-fg-color: var(--md-typeset-a-color);
 
   --md-typeset-btn-color: #52bbb1;
   --md-typeset-btn-hover-color: #55aea6;
 
-  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
 }
 
 [data-md-color-scheme="slate"][data-md-color-primary="black"],
@@ -63,24 +65,82 @@
   --md-typeset-a-color: #52bbb1;
 }
 
+/* Base layout */
+body {
+  background-color: var(--md-default-bg-color);
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Banner and footer */
+.md-banner {
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
 [data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner {
-  background-color: var(--theme-dark-mantle);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer-meta {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
-[data-md-color-scheme="slate"] .md-footer__link {
-  background-color: var(--theme-dark-crust);
-  color: var(--md-footer-fg-color);
-}
-
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
 [data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--theme-dark-base);
+  color: var(--md-footer-fg-color);
 }
 
 [data-md-color-scheme="slate"] .md-footer__title,
@@ -93,40 +153,31 @@
   color: var(--md-footer-fg-color);
 }
 
-/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
-.md-nav__link[for] {
-  color: var(--md-default-fg-color) !important;
-}
-
-/* Figure class */
+/* Shared content elements */
 .animation-figure {
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Cover image class */
 .cover-image {
   width: 28rem;
   height: auto;
   border-radius: 0.3rem;
   display: block;
   margin: 0 auto;
-  box-shadow: var(--md-shadow-z2);
+  box-shadow: 0 0.03rem 0.16rem rgb(0 0 0 / 0.07);
 }
 
-/* Center Markdown Tables (requires md_in_html extension) */
 .center-table {
   text-align: center;
 }
 
-/* Reset alignment for table cells */
 .md-typeset .center-table :is(td, th):not([align]) {
   text-align: initial;
 }
 
-/* Font size */
 .md-typeset {
   font-size: 0.75rem;
   line-height: 1.5;
@@ -136,7 +187,6 @@
   font-size: 0.95em;
 }
 
-/* Markdown Header */
 /* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
 .md-typeset h1 {
   font-weight: 400;
@@ -155,11 +205,6 @@
   text-transform: none;
 }
 
-.md-typeset a:hover {
-  color: var(--md-typeset-a-color);
-  text-decoration: underline;
-}
-
 .md-typeset code {
   border-radius: 0.2rem;
 }
@@ -168,21 +213,11 @@
   font-weight: normal;
 }
 
-/* font-family setting for Win10 */
-body {
-  --md-text-font-family: -apple-system, BlinkMacSystemFont,
-    var(--md-text-font, _), Helvetica, Arial, sans-serif;
-  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
-    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
-}
-
-/* max height of code block */
 /* https://github.com/squidfunk/mkdocs-material/issues/3444 */
 .md-typeset pre>code {
   max-height: 25rem;
 }
 
-/* Keep code block scrollbar hover neutral instead of accent-colored */
 .md-typeset pre>code:hover {
   scrollbar-color: var(--md-default-fg-color--lighter) transparent;
 }
@@ -191,29 +226,48 @@ body {
   background-color: var(--md-default-fg-color--lighter);
 }
 
-/* Make the picture not glare in dark theme */
 [data-md-color-scheme="slate"] .md-typeset img,
 [data-md-color-scheme="slate"] .md-typeset svg,
 [data-md-color-scheme="slate"] .md-typeset video {
   filter: brightness(0.85) invert(0.05);
 }
 
-/* landing page */
-.header-img-div {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0 auto;
-  width: 100%;
-  /* Default to full width */
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+/* Admonitions and tabs */
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
 }
 
-/* Admonition for python tutor */
 .md-typeset .admonition.pythontutor,
 .md-typeset details.pythontutor {
   border-color: var(--md-default-fg-color--lightest);
   margin-top: 0;
   margin-bottom: 1.5625em;
+  background-color: var(--md-code-bg-color);
 }
 
 .md-typeset .pythontutor>.admonition-title,
@@ -228,26 +282,18 @@ body {
   mask-image: var(--md-admonition-icon--pythontutor);
 }
 
-/* code block tabs */
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
 .md-typeset .tabbed-labels>label {
   font-size: 0.61rem;
 }
 
 .md-typeset .tabbed-labels--linked>label>a {
-  padding: .78125em 1.0em .625em;
-}
-
-/* header banner */
-.md-banner {
-  background-color: var(--md-code-bg-color);
-  color: var(--md-default-fg-color);
-  font-size: 0.75rem;
-}
-
-.md-banner .banner-svg svg {
-  margin-right: 0.3rem;
-  height: 0.63rem;
-  fill: var(--md-default-fg-color);
+  padding: 0.78125em 1em 0.625em;
 }
 
 .pythontutor-iframe {
@@ -260,115 +306,55 @@ body {
   border: none;
 }
 
-/* landing page container */
+/* Landing page layout */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+}
+
 .home-div {
   width: 100%;
   height: auto;
   display: flex;
   justify-content: center;
   align-items: center;
+  padding: 3em 2em;
   background-color: var(--md-default-bg-color);
   color: var(--md-default-fg-color);
   font-size: 0.9rem;
-  padding: 3em 2em;
   text-align: center;
 }
 
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6,
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
 .section-content {
   width: 100%;
   height: auto;
   max-width: 70vw;
 }
 
-/* rounded button */
-.rounded-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: 10em;
-  margin: 0 0.1em;
-  padding: 0.6em 1.3em;
-  border: none;
-  background-color: var(--md-typeset-btn-color);
-  color: var(--md-primary-fg-color) !important;
-  text-align: center;
-  text-decoration: none;
-  cursor: pointer;
-}
-
-.rounded-button:hover {
-  background-color: var(--md-typeset-btn-hover-color);
-}
-
-.rounded-button span {
-  margin: 0;
-  margin-bottom: 0.07em;
-  white-space: nowrap;
-}
-
-.rounded-button svg {
-  fill: var(--md-primary-fg-color);
-  width: auto;
-  height: 1.2em;
-  margin-right: 0.5em;
-}
-
-/* device image */
-.device-on-hover {
-  width: auto;
-  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
-}
-
-a:hover .device-on-hover {
-  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
-  transform: scale(1.01);
-}
-
-/* text button */
-.reading-media {
-  display: flex;
-  justify-content: center;
-  align-items: flex-end;
-  height: 32vw;
-}
-
-.media-block {
-  height: 100%;
-  margin: 0 0.2em;
-}
-
-.text-button {
-  width: auto;
-  color: var(--md-typeset-btn-color);
-  text-decoration: none;
-  text-align: center;
-  margin: 2.7em auto;
-}
-
-.text-button span {
-  white-space: nowrap;
-}
-
-.text-button svg {
-  display: inline-block;
-  fill: var(--md-typeset-btn-color);
-  width: auto;
-  height: 0.9em;
-  background-size: cover;
-  padding-top: 0.17em;
-  margin-left: 0.15em;
-}
-
-a:hover .text-button span {
-  text-decoration: underline;
-}
-
-/* hero image */
 .hero-div {
   height: min(84vh, 75vw);
   width: min(112vh, 100vw);
-  margin: 0 auto;
-  margin-top: -2.4rem;
+  margin: -2.4rem auto 0;
   padding: 0;
   position: relative;
   font-size: min(1.8vh, 2.5vw);
@@ -384,13 +370,12 @@ a:hover .text-button span {
 }
 
 .hero-bg {
-  height: 100%;
   width: 100%;
+  height: 100%;
   object-fit: cover;
   position: absolute;
 }
 
-/* hover on the planets */
 .hero-div>a>img {
   width: auto;
   position: absolute;
@@ -402,7 +387,6 @@ a:hover .text-button span {
   position: absolute;
   transform: translateX(-50%) translateY(-50%);
   white-space: nowrap;
-  /* prevent line breaks */
   color: white;
 }
 
@@ -412,21 +396,105 @@ a:hover .text-button span {
 }
 
 .hero-div>a:hover>span {
-  text-decoration: underline;
   color: var(--md-typeset-btn-color);
+  text-decoration: underline;
 }
 
 .heading-div {
   width: 100%;
   position: absolute;
-  transform: translateX(-50%);
   left: 50%;
   bottom: min(2vh, 3vw);
+  transform: translateX(-50%);
   pointer-events: none;
   color: #fff;
 }
 
-/* code badge */
+/* Landing page CTAs */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  border-radius: 10em;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0 0 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+  fill: var(--md-primary-fg-color);
+}
+
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  margin: 2.7em auto;
+  color: var(--md-typeset-btn-color);
+  text-align: center;
+  text-decoration: none;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  width: auto;
+  height: 0.9em;
+  margin-left: 0.15em;
+  padding-top: 0.17em;
+  fill: var(--md-typeset-btn-color);
+  background-size: cover;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* Landing page content blocks */
 .code-badge {
   width: 100%;
   height: auto;
@@ -434,11 +502,10 @@ a:hover .text-button span {
 }
 
 .code-badge img {
-  height: 1.07em;
   width: auto;
+  height: 1.07em;
 }
 
-/* brief intro */
 .intro-container {
   display: flex;
   align-items: center;
@@ -455,14 +522,13 @@ a:hover .text-button span {
 
 .intro-text {
   flex-grow: 1;
-  /* fill the space */
   display: flex;
   flex-direction: column;
   justify-content: center;
-  text-align: left;
   align-items: flex-start;
   width: fit-content;
   margin: 2em;
+  text-align: left;
 }
 
 .intro-text>div {
@@ -471,6 +537,10 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
+.intro-text svg path {
+  fill: #3b3b3b;
+}
+
 .endor-text {
   width: 50%;
 }
@@ -480,7 +550,10 @@ a:hover .text-button span {
   font-weight: bold;
 }
 
-/* contributors table */
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
 .profile-div {
   display: flex;
   flex-wrap: wrap;
@@ -495,6 +568,11 @@ a:hover .text-button span {
   text-align: center;
 }
 
+.profile-cell a:hover b,
+.profile-cell a:focus-visible b {
+  text-decoration: underline;
+}
+
 .profile-img {
   width: 5em;
   border-radius: 50%;
@@ -517,7 +595,37 @@ a:hover .text-button span {
   margin: 0 auto;
 }
 
-/* Hide navigation */
+/* Embedded media */
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Responsive adjustments */
 @media screen and (max-width: 76.25em) {
   .section-content {
     max-width: 95vw;
@@ -532,7 +640,6 @@ a:hover .text-button span {
   }
 }
 
-/* mobile devices */
 @media screen and (max-width: 60em) {
   .home-div {
     font-size: 0.75rem;
@@ -571,209 +678,4 @@ a:hover .text-button span {
     flex: 1 1 30%;
   }
 }
-
-.video-container {
-  position: relative;
-  padding-bottom: 56.25%;
-  /* 16:9 */
-  height: 0;
-}
-
-.video-container iframe {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-/* starfield */
-.starfield {
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  z-index: 0;
-  background-color: var(--hero-starfield-bg-color, transparent);
-}
-
-.starfield-origin {
-  position: absolute;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-}
-
-/* Zensical-specific adjustments merged into the main stylesheet. */
-:root>* {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --hello-algo-sidebar-width: 13rem;
-}
-
-[data-md-color-scheme="slate"] {
-  --md-accent-fg-color: var(--md-typeset-a-color);
-  --md-admonition-pythontutor-color: var(--md-code-bg-color);
-  --md-body-bg-color: var(--md-default-bg-color);
-  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
-}
-
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
-[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
-  background-color: #f5f5f5;
-  color: #1d1d20;
-}
-
-body {
-  background-color: var(--md-default-bg-color);
-}
-
-html:has(body[data-md-color-scheme="slate"]) {
-  background-color: #1e1e1e;
-}
-
-html:has(body[data-md-color-scheme="default"]) {
-  background-color: #ffffff;
-}
-
-.home-div[data-md-color-scheme="default"],
-.home-div[data-md-color-scheme="default"] h1,
-.home-div[data-md-color-scheme="default"] h2,
-.home-div[data-md-color-scheme="default"] h3,
-.home-div[data-md-color-scheme="default"] h4,
-.home-div[data-md-color-scheme="default"] h5,
-.home-div[data-md-color-scheme="default"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div[data-md-color-scheme="slate"],
-.home-div[data-md-color-scheme="slate"] h1,
-.home-div[data-md-color-scheme="slate"] h2,
-.home-div[data-md-color-scheme="slate"] h3,
-.home-div[data-md-color-scheme="slate"] h4,
-.home-div[data-md-color-scheme="slate"] h5,
-.home-div[data-md-color-scheme="slate"] h6 {
-  color: var(--md-default-fg-color);
-}
-
-.home-div .intro-quote {
-  color: var(--md-default-fg-color--light) !important;
-}
-
-.reading-media+p {
-  margin-top: 1em !important;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before,
-.md-typeset summary:after {
-  top: 50%;
-}
-
-.md-typeset .admonition-title:before,
-.md-typeset summary:before {
-  transform: translateY(-50%);
-}
-
-.md-typeset summary:after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open]>summary:after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-nav__link[for] {
-  color: inherit !important;
-}
-
-.md-nav__link[for].md-nav__link--active {
-  color: var(--md-accent-fg-color) !important;
-}
-
-@media screen and (min-width: 76.25em) {
-  .md-grid {
-    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
-  }
-
-  .md-sidebar--primary,
-  .md-sidebar--secondary {
-    width: var(--hello-algo-sidebar-width);
-  }
-
-  [dir="ltr"] .md-sidebar__inner {
-    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-
-  [dir="rtl"] .md-sidebar__inner {
-    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
-  }
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap {
-  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
-}
-
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
-.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
-  background-color: var(--md-default-fg-color--lighter);
-}
-
-.md-footer,
-.md-footer__inner,
-.md-footer-meta,
-.md-footer__link,
-.md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-footer {
-  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
-}
-
-[data-md-color-scheme="slate"] .md-footer,
-[data-md-color-scheme="slate"] .md-footer__inner,
-[data-md-color-scheme="slate"] .md-footer-meta,
-[data-md-color-scheme="slate"] .md-footer__link,
-[data-md-color-scheme="slate"] .md-footer__link:hover {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-banner {
-  background-color: var(--md-default-bg-color);
-}
-
-.md-typeset .admonition.pythontutor,
-.md-typeset details.pythontutor,
-.md-typeset .pythontutor>.admonition-title,
-.md-typeset .pythontutor>summary {
-  background-color: var(--md-code-bg-color);
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before,
-.md-typeset .pythontutor>summary::after {
-  top: 50%;
-}
-
-.md-typeset .pythontutor>.admonition-title::before,
-.md-typeset .pythontutor>summary::before {
-  transform: translateY(-50%);
-}
-
-.md-typeset .pythontutor>summary::after {
-  transform: translateY(-50%) rotate(0deg);
-}
-
-.md-typeset details[open].pythontutor>summary::after {
-  transform: translateY(-50%) rotate(90deg);
-}
-
-.md-typeset a:not(.md-button) {
-  text-decoration: none;
-}
-
-.md-typeset a:not(.md-button):hover,
-.md-typeset a:not(.md-button):focus-visible {
-  text-decoration: underline;
-}
-/*! update cache: 20260331044502 */
+/*! update cache: 20260331053155 */